mev-inspect/lib/classifier/items/balancerV1.js

A JS port of 'mev-inspect-py' optimised for ease of use.

import { Contract } from 'ethcall';
import factoryAbi from '../../abi/balancerV1Factory.js';
import poolAbi from '../../abi/balancerV1Pool.js';
const FACTORY_ADDRESS = '0x9424b1412450d0f8fc2255faf6046b98213b76bd';
function isValidSwap(event) {
    return event.name === 'LOG_SWAP';
}
function isValidDeposit(event) {
    return event.name === 'LOG_JOIN';
}
function isValidWithdrawal(event) {
    return event.name === 'LOG_EXIT';
}
function getPoolCalls(address) {
    const factoryContract = new Contract(FACTORY_ADDRESS, factoryAbi);
    const isPoolCall = factoryContract.isBPool(address);
    const poolContract = new Contract(address, poolAbi);
    const assetsCall = poolContract.getCurrentTokens();
    return [isPoolCall, assetsCall];
}
function processPoolCalls(result) {
    const [isPool, tokens] = result;
    if (!isPool || !tokens) {
        return null;
    }
    const assets = tokens.map((token) => token.toLowerCase());
    return {
        factoryAddress: FACTORY_ADDRESS,
        assets,
    };
}
function parseSwap(pool, event) {
    const { values, transactionFrom, transactionHash: hash, transactionIndex, gasUsed, logIndex, address, blockHash, blockNumber, } = event;
    const sender = values.caller.toLowerCase();
    const assetIn = values.tokenIn.toLowerCase();
    const assetOut = values.tokenOut.toLowerCase();
    const amountIn = values.tokenAmountIn;
    const amountOut = values.tokenAmountOut;
    return {
        contract: {
            address: pool.address,
            protocol: {
                abi: 'BalancerV1',
                factory: pool.factory,
            },
        },
        block: {
            hash: blockHash,
            number: blockNumber,
        },
        transaction: {
            from: transactionFrom.toLowerCase(),
            hash,
            index: transactionIndex,
            gasUsed,
        },
        event: {
            logIndex,
            address: address.toLowerCase(),
        },
        from: sender,
        to: sender,
        assetIn: {
            type: 'erc20',
            address: assetIn,
        },
        amountIn,
        assetOut: {
            type: 'erc20',
            address: assetOut,
        },
        amountOut,
        metadata: {},
    };
}
function parseDeposit(pool, event) {
    const { values, transactionFrom, transactionHash: hash, transactionIndex, gasUsed, logIndex, address, blockHash, blockNumber, } = event;
    const depositor = values.caller.toLowerCase();
    const asset = values.tokenIn.toLowerCase();
    const amount = values.tokenAmountIn;
    return {
        contract: {
            address: pool.address,
            protocol: {
                abi: 'BalancerV1',
                factory: pool.factory,
            },
        },
        block: {
            hash: blockHash,
            number: blockNumber,
        },
        transaction: {
            from: transactionFrom.toLowerCase(),
            hash,
            index: transactionIndex,
            gasUsed,
        },
        event: {
            address: address.toLowerCase(),
            logIndex,
        },
        depositor,
        assets: [
            {
                type: 'erc20',
                address: asset,
            },
        ],
        amounts: [amount],
        metadata: {},
    };
}
function parseWithdrawal(pool, event) {
    const { values, transactionFrom, transactionHash: hash, transactionIndex, gasUsed, logIndex, address, blockHash, blockNumber, } = event;
    const withdrawer = values.caller.toLowerCase();
    const asset = values.tokenOut.toLowerCase();
    const amount = values.tokenAmountOut;
    return {
        contract: {
            address: pool.address,
            protocol: {
                abi: 'BalancerV1',
                factory: pool.factory,
            },
        },
        block: {
            hash: blockHash,
            number: blockNumber,
        },
        transaction: {
            from: transactionFrom.toLowerCase(),
            hash,
            index: transactionIndex,
            gasUsed,
        },
        event: {
            address: address.toLowerCase(),
            logIndex,
        },
        withdrawer,
        assets: [
            {
                type: 'erc20',
                address: asset,
            },
        ],
        amounts: [amount],
        metadata: {},
    };
}
const CLASSIFIER = {
    swap: {
        type: 'swap',
        protocol: 'BalancerV1',
        abi: poolAbi,
        isValid: isValidSwap,
        parse: parseSwap,
        pool: {
            getCalls: getPoolCalls,
            processCalls: processPoolCalls,
        },
    },
    liquidityDeposit: {
        type: 'liquidity_deposit',
        protocol: 'BalancerV1',
        abi: poolAbi,
        isValid: isValidDeposit,
        parse: parseDeposit,
        pool: {
            getCalls: getPoolCalls,
            processCalls: processPoolCalls,
        },
    },
    liquidityWithdrawal: {
        type: 'liquidity_withdrawal',
        protocol: 'BalancerV1',
        abi: poolAbi,
        isValid: isValidWithdrawal,
        parse: parseWithdrawal,
        pool: {
            getCalls: getPoolCalls,
            processCalls: processPoolCalls,
        },
    },
};
export default CLASSIFIER;
//# sourceMappingURL=balancerV1.js.map