@0xtorch/evm 0.0.4 → 0.0.6

package/_esm/analyzer/swap/analyze.js

@@ -0,0 +1,654 @@
+import { createBigDecimal } from '@0xtorch/big-decimal';
+import { zeroAddress } from 'viem';
+import { createEvmAccount } from '../../creates/createEvmAccount';
+import { toLowerHex } from '../../types';
+import { createAccountActionByAction } from '../createAccountActionByAction';
+import { parseToTraderJoeLBPairSwap } from './traderJoeLBPairSwap';
+import { parseToUniv2SwapLog } from './univ2PairSwap';
+import { parseToUniv3SwapLog } from './univ3PoolSwap';
+import { parseToWrappedDepositLog } from './wrappedDeposit';
+import { parseToWrappedWithdrawalLog } from './wrappedWithdrawal';
+export const analyzeSwap = ({ chain, transaction, accountAddresses, }) => {
+    const { transactionHash, from, to, value, erc20Transfers, erc721Transfers, erc1155Transfers, internalTransactions, block, logs, nativeTokenPrice, } = transaction;
+    const timestamp = Number(block.timestamp) * 1000;
+    const nativeTransfer = value > 0 && to !== null
+        ? {
+            type: 'InternalTransaction',
+            transactionHash,
+            from: toLowerHex(from),
+            to: toLowerHex(to),
+            contractAddress: undefined,
+            txType: '',
+            value: value -
+                internalTransactions
+                    .filter((internal) => internal.from === toLowerHex(to) &&
+                    internal.to === toLowerHex(from))
+                    .reduce((accumulator, internal) => accumulator + internal.value, 0n),
+            gas: 0n,
+            gasUsed: 0n,
+            isError: false,
+            input: undefined,
+            currency: chain.nativeToken.currency,
+            price: nativeTokenPrice,
+        }
+        : undefined;
+    const allInternalTransactions = [
+        ...(nativeTransfer === undefined ? [] : [nativeTransfer]),
+        ...internalTransactions.filter((internal) => value === 0n ||
+            to === null ||
+            internal.from !== toLowerHex(to) ||
+            internal.to !== toLowerHex(from)),
+    ];
+    // If the transaction contains ERC721 or ERC1155 transfers, return undefined as a pattern mismatch.
+    if (erc721Transfers.length > 0 || erc1155Transfers.length > 0) {
+        return Promise.resolve(undefined);
+    }
+    // classify logs by type
+    const decodedLogs = logs
+        .map((log) => (log.type === 'decoded' ? log.log : undefined))
+        .filter((log) => log !== undefined);
+    const univ2SwapLogs = decodedLogs
+        .map((log) => parseToUniv2SwapLog(log))
+        .filter((log) => log !== undefined);
+    const univ3SwapLogs = decodedLogs
+        .map((log) => parseToUniv3SwapLog(log))
+        .filter((log) => log !== undefined);
+    const traderJoeLBPairSwapLogs = decodedLogs
+        .map((log) => parseToTraderJoeLBPairSwap(log))
+        .filter((log) => log !== undefined);
+    const depositLogs = decodedLogs
+        .map((log) => parseToWrappedDepositLog(log))
+        .filter((log) => log !== undefined);
+    const withdrawalLogs = decodedLogs
+        .map((log) => parseToWrappedWithdrawalLog(log))
+        .filter((log) => log !== undefined);
+    // If the transaction does not contain any swap logs, return undefined as a pattern mismatch.
+    if (univ2SwapLogs.length === 0 &&
+        univ3SwapLogs.length === 0 &&
+        traderJoeLBPairSwapLogs.length === 0) {
+        return Promise.resolve(undefined);
+    }
+    // swap 生成
+    const univ2Swaps = univ2SwapLogs
+        .map((log) => createSwapFromUniv2SwapLog(log, erc20Transfers))
+        .filter((swap) => swap !== undefined);
+    const univ3Swaps = univ3SwapLogs
+        .map((log) => createSwapFromUniv3SwapLog(log, erc20Transfers))
+        .filter((swap) => swap !== undefined);
+    const traderJoeLBPairSwaps = traderJoeLBPairSwapLogs
+        .map((log) => createSwapFromTraderJoeLBPairSwapLog(log, erc20Transfers))
+        .filter((swap) => swap !== undefined);
+    const swaps = [...univ2Swaps, ...univ3Swaps, ...traderJoeLBPairSwaps];
+    // swap action の前後に残る Transfer log を抽出
+    const swapUsingIndexes = new Set(swaps.flatMap((swap) => createSwapUsingIndexes(swap)));
+    // from,to が同一の transfer は除外
+    // from,to が zero address の transfer は除外
+    const unrelatedTransfers = erc20Transfers.filter((transfer) => !swapUsingIndexes.has(transfer.logIndex) &&
+        transfer.from !== transfer.to &&
+        transfer.from !== zeroAddress &&
+        transfer.to !== zeroAddress);
+    // index で swap, transfer, deposit, withdrawal log をソート
+    const actions = [
+        ...swaps,
+        ...unrelatedTransfers,
+        ...depositLogs,
+        ...withdrawalLogs,
+    ].toSorted((a, b) => getIndex(a) - getIndex(b));
+    // sort した action を結合できる場合は結合していく
+    const mergedActions = mergeActions(actions, chain.nativeToken.currency);
+    // 結合した action が swap 1 つのみで無ければパターン不一致として、 undefined を返す
+    if (mergedActions.length !== 1) {
+        return Promise.resolve(undefined);
+    }
+    const mergedAction = mergedActions[0];
+    if (mergedAction.type !== 'Swap') {
+        return Promise.resolve(undefined);
+    }
+    // 結合できる internal transaction があれば結合する
+    const { swap, internalTransactions: remainInternalTransactions } = mergeSwapAndInternalTransactions(mergedAction, allInternalTransactions);
+    // 結合後の internal transaction に account に関連する value > 0 の transaction があれば、
+    // パターン不一致として、 undefined を返す
+    if (remainInternalTransactions.some((internalTransaction) => (internalTransaction.value > 0n &&
+        accountAddresses.includes(internalTransaction.from)) ||
+        (internalTransaction.to !== undefined &&
+            accountAddresses.includes(internalTransaction.to)))) {
+        return Promise.resolve(undefined);
+    }
+    // 最終的に swap のみ残った場合は Trade / AtomicArbitrage / SwapTransfer のいずれかとして扱う
+    if (swap.transferOut.to === undefined) {
+        return Promise.resolve(undefined);
+    }
+    // normal action を生成
+    const normalAction = generateNormalAction(swap, chain, timestamp);
+    // account action を生成
+    const accountAction = createAccountActionByAction(normalAction, transaction, accountAddresses);
+    return Promise.resolve({
+        actions: [normalAction],
+        accountActions: accountAction === undefined ? [] : [accountAction],
+    });
+};
+const generateNormalAction = (swap, chain, timestamp) => {
+    if (swap.transferIn.type === 'InternalTransaction' &&
+        swap.transferOut.type === 'InternalTransaction') {
+        return generateNormalActionAtomicArbitrage(swap, chain, timestamp);
+    }
+    else if (swap.transferIn.type === 'Erc20Transfer' &&
+        swap.transferOut.type === 'Erc20Transfer' &&
+        swap.transferIn.token.contractAddress ===
+            swap.transferOut.token.contractAddress) {
+        return generateNormalActionAtomicArbitrage(swap, chain, timestamp);
+    }
+    else {
+        return generateNormalActionTrade(swap, chain, timestamp);
+    }
+};
+const generateNormalActionAtomicArbitrage = (swap, chain, timestamp) => {
+    const { transferIn, transferOut } = swap;
+    const transferInAsset = transferIn.type === 'Erc20Transfer'
+        ? transferIn.token.currency
+        : chain.nativeToken.currency;
+    const transferOutAsset = transferOut.type === 'Erc20Transfer'
+        ? transferOut.token.currency
+        : chain.nativeToken.currency;
+    if (transferIn.to === undefined ||
+        transferOut.to === undefined ||
+        transferInAsset === undefined ||
+        transferOutAsset === undefined) {
+        throw new Error('invalid swap');
+    }
+    const transferInDecimals = transferIn.type === 'Erc20Transfer'
+        ? transferIn.token.decimals
+        : chain.nativeToken.decimals;
+    const transferOutDecimals = transferOut.type === 'Erc20Transfer'
+        ? transferOut.token.decimals
+        : chain.nativeToken.decimals;
+    return {
+        type: 'NormalAction',
+        action: 'atomic-arbitrage',
+        evidence: 'contract',
+        timestamp,
+        comment: undefined,
+        app: undefined,
+        transfers: [
+            {
+                target: transferIn.from,
+                direction: 'out',
+                from: createEvmAccount({ address: transferIn.from, chainId: chain.id }),
+                to: createEvmAccount({ address: transferIn.to, chainId: chain.id }),
+                asset: transferInAsset,
+                amount: createBigDecimal(transferIn.value, transferInDecimals),
+                price: transferIn.price,
+            },
+            {
+                target: transferOut.to,
+                direction: 'in',
+                from: createEvmAccount({
+                    address: transferOut.from,
+                    chainId: chain.id,
+                }),
+                to: createEvmAccount({ address: transferOut.to, chainId: chain.id }),
+                asset: transferOutAsset,
+                amount: createBigDecimal(transferOut.value, transferOutDecimals),
+                price: transferOut.price,
+            },
+        ],
+    };
+};
+const generateNormalActionTrade = (swap, chain, timestamp) => {
+    const { transferIn, transferOut } = swap;
+    const transferInAsset = transferIn.type === 'Erc20Transfer'
+        ? transferIn.token.currency
+        : chain.nativeToken.currency;
+    const transferOutAsset = transferOut.type === 'Erc20Transfer'
+        ? transferOut.token.currency
+        : chain.nativeToken.currency;
+    if (transferIn.to === undefined ||
+        transferOut.to === undefined ||
+        transferInAsset === undefined ||
+        transferOutAsset === undefined) {
+        throw new Error('invalid swap');
+    }
+    const transferInDecimals = transferIn.type === 'Erc20Transfer'
+        ? transferIn.token.decimals
+        : chain.nativeToken.decimals;
+    const transferOutDecimals = transferOut.type === 'Erc20Transfer'
+        ? transferOut.token.decimals
+        : chain.nativeToken.decimals;
+    return {
+        type: 'NormalAction',
+        action: 'trade',
+        evidence: 'contract',
+        timestamp,
+        comment: undefined,
+        app: undefined,
+        transfers: [
+            {
+                target: transferIn.from,
+                direction: 'out',
+                from: createEvmAccount({ address: transferIn.from, chainId: chain.id }),
+                to: createEvmAccount({ address: transferIn.to, chainId: chain.id }),
+                asset: transferInAsset,
+                amount: createBigDecimal(transferIn.value, transferInDecimals),
+                price: transferIn.price,
+            },
+            {
+                target: transferOut.to,
+                direction: 'in',
+                from: createEvmAccount({
+                    address: transferOut.from,
+                    chainId: chain.id,
+                }),
+                to: createEvmAccount({ address: transferOut.to, chainId: chain.id }),
+                asset: transferOutAsset,
+                amount: createBigDecimal(transferOut.value, transferOutDecimals),
+                price: transferOut.price,
+            },
+        ],
+    };
+};
+const getIndex = (data) => {
+    switch (data.type) {
+        case 'WrappedDepositLog': {
+            return data.logIndex;
+        }
+        case 'WrappedWithdrawalLog': {
+            return data.logIndex;
+        }
+        case 'Erc20Transfer': {
+            return data.logIndex;
+        }
+        case 'Swap': {
+            return data.swapLogIndex;
+        }
+    }
+};
+const createSwapFromUniv2SwapLog = (log, erc20TokenTransfers) => {
+    const { args, logIndex: swapLogIndex, address: contractAddress } = log;
+    const { value: amount0In } = args[1];
+    const { value: amount1In } = args[2];
+    const { value: amount0Out } = args[3];
+    const { value: amount1Out } = args[4];
+    // swap log より前の transfer log を抽出
+    const beforeSwapTransfers = erc20TokenTransfers.filter((transfer) => transfer.logIndex < swapLogIndex);
+    // swap log から amountIn / amountOut を取得
+    const amountIn = amount0In + amount1In;
+    const amountOut = amount0Out + amount1Out;
+    // amountIn / amountOut が一致する transfer log を探す
+    const transferIn = beforeSwapTransfers.findLast((transfer) => transfer.value === amountIn);
+    const transferOut = beforeSwapTransfers.findLast((transfer) => transfer.value === amountOut);
+    // なければ undefined を返す
+    if (transferIn == undefined || transferOut === undefined) {
+        return undefined;
+    }
+    // あれば swap を生成して返す
+    return createSwap({
+        contractAddress,
+        transferIn,
+        transferOut,
+        swapLogIndex,
+    });
+};
+const createSwapFromUniv3SwapLog = (log, erc20TokenTransfers) => {
+    const { args, logIndex: swapLogIndex, address: contractAddress } = log;
+    const { value: amount0 } = args[2];
+    const { value: amount1 } = args[3];
+    // swap log より前の transfer log を抽出
+    const beforeSwapTransfers = erc20TokenTransfers.filter((transfer) => transfer.logIndex < swapLogIndex);
+    // amountIn / amountOut の片方がプラス、もう片方がマイナスの場合でなければ undefined を返す
+    if (amount0 === 0n ||
+        amount1 === 0n ||
+        (amount0 > 0n && amount1 > 0n) ||
+        (amount0 < 0n && amount1 < 0n)) {
+        return undefined;
+    }
+    // swap log から amountIn / amountOut を取得
+    const amountIn = amount0 > 0n ? amount0 : amount1;
+    const amountOut = -1n * (amount0 > 0n ? amount1 : amount0);
+    // amountIn / amountOut が一致する transfer log を探す
+    const transferIn = beforeSwapTransfers.findLast((transfer) => transfer.value === amountIn);
+    const transferOut = beforeSwapTransfers.findLast((transfer) => transfer.value === amountOut);
+    // なければ undefined を返す
+    if (transferIn == undefined || transferOut === undefined) {
+        return undefined;
+    }
+    // あれば swap を生成して返す
+    return createSwap({
+        contractAddress: contractAddress,
+        transferIn,
+        transferOut,
+        swapLogIndex,
+    });
+};
+const createSwapFromTraderJoeLBPairSwapLog = (log, erc20TokenTransfers) => {
+    const { args, logIndex: swapLogIndex, address: contractAddress } = log;
+    // swap log から amountIn / amountOut を取得
+    const { value: amountIn } = args[4];
+    const { value: amountOut } = args[5];
+    const { value: fees } = args[7];
+    const amountInWithFees = amountIn + fees;
+    // amountIn / amountOut が一致する transfer log を探す
+    const transferIn = erc20TokenTransfers.findLast((transfer) => transfer.value === amountInWithFees);
+    const transferOut = erc20TokenTransfers.findLast((transfer) => transfer.value === amountOut);
+    // なければ undefined を返す
+    if (transferIn == undefined || transferOut === undefined) {
+        return undefined;
+    }
+    // あれば swap を生成して返す
+    return createSwap({
+        contractAddress,
+        transferIn,
+        transferOut,
+        swapLogIndex,
+    });
+};
+const createSwap = ({ contractAddress, transferIn, transferOut, swapLogIndex, }) => ({
+    type: 'Swap',
+    contractAddress,
+    transferIn,
+    transferOut,
+    swapLogIndex,
+});
+const createSwapUsingIndexes = ({ swapLogIndex, transferIn, transferOut, }) => {
+    const transferInLogIndex = transferIn.type === 'Erc20Transfer' ? transferIn.logIndex : swapLogIndex;
+    const transferOutLogIndex = transferOut.type === 'Erc20Transfer' ? transferOut.logIndex : swapLogIndex;
+    const minIndex = Math.min(swapLogIndex, transferInLogIndex, transferOutLogIndex);
+    const maxIndex = Math.max(swapLogIndex, transferInLogIndex, transferOutLogIndex);
+    const mut_indexes = [];
+    for (let index = minIndex; index <= maxIndex; index++) {
+        mut_indexes.push(index);
+    }
+    return mut_indexes;
+};
+const mergeActions = (actions, nativeTokenCryptocurrency) => {
+    const sequenceMergedActions = mergeActionsBySequenceSwap(actions);
+    const similarMergedActions = mergeActionsBySimilarSwap(sequenceMergedActions);
+    const mergedActions = mergeActionsBySwapAndOtherAction(similarMergedActions, nativeTokenCryptocurrency);
+    // TODO deposit - transfer と並んでいて、 deposit value と transfer value が一致 & wrapped token である場合、結合して良さそう
+    // [deposit, swap, withdraw] と残った場合のみ、 deposit - withdrawal の値が swap in と一致する場合は 3つ合わせて結合する
+    if (mergedActions.length === 3) {
+        const [deposit, swap, withdrawal] = mergedActions;
+        if (deposit.type === 'WrappedDepositLog' &&
+            swap.type === 'Swap' &&
+            withdrawal.type === 'WrappedWithdrawalLog' &&
+            deposit.args[1].value - withdrawal.args[1].value === swap.transferIn.value) {
+            return [
+                createSwap({
+                    ...swap,
+                    transferIn: {
+                        type: 'InternalTransaction',
+                        transactionHash: '0x',
+                        from: swap.transferIn.from,
+                        to: swap.transferIn.to,
+                        contractAddress: undefined,
+                        txType: '',
+                        value: swap.transferIn.value,
+                        gas: 0n,
+                        gasUsed: 0n,
+                        isError: false,
+                        input: undefined,
+                        currency: nativeTokenCryptocurrency,
+                        price: swap.transferIn.price,
+                    },
+                }),
+            ];
+        }
+    }
+    return mergedActions;
+};
+const mergeActionsBySequenceSwap = (actions) => {
+    const mut_newActions = [];
+    let mut_previousAction = undefined;
+    for (const action of actions) {
+        if (mut_previousAction === undefined) {
+            mut_previousAction = action;
+            continue;
+        }
+        if (mut_previousAction.type === 'Swap' && action.type === 'Swap') {
+            // 前後の swap を結合するか試す
+            const mergedSwap = mergeSequenceSwaps([
+                mut_previousAction,
+                action,
+            ]);
+            if (mergedSwap === undefined) {
+                // 結合できていなければ、previous action を newActions に追加して、action を previous action に設定
+                mut_newActions.push(mut_previousAction);
+                mut_previousAction = action;
+            }
+            else {
+                // 結合できていれば、結合結果を previous action に設定
+                mut_previousAction = mergedSwap;
+            }
+        }
+        else {
+            // previous action を newActions に追加して、action を previous action に設定
+            mut_newActions.push(mut_previousAction);
+            mut_previousAction = action;
+        }
+    }
+    // previous action が残っていれば newActions に追加
+    if (mut_previousAction !== undefined) {
+        mut_newActions.push(mut_previousAction);
+    }
+    return mut_newActions;
+};
+const mergeActionsBySimilarSwap = (actions) => {
+    const mut_newActions = [];
+    let mut_previousAction = undefined;
+    for (const action of actions) {
+        if (mut_previousAction === undefined) {
+            mut_previousAction = action;
+            continue;
+        }
+        if (mut_previousAction.type === 'Swap' && action.type === 'Swap') {
+            // 前後の swap を結合するか試す
+            const mergedSwap = mergeSimilarSwaps([
+                mut_previousAction,
+                action,
+            ]);
+            if (mergedSwap === undefined) {
+                // 結合できていなければ、currentSwap を newActions に追加して、action を currentSwap に設定
+                mut_newActions.push(mut_previousAction);
+                mut_previousAction = action;
+            }
+            else {
+                // 結合できていれば、結合結果を currentSwap に設定
+                mut_previousAction = mergedSwap;
+            }
+        }
+        else {
+            // prevAction を newActions に追加して、action を prevAction に設定
+            mut_newActions.push(mut_previousAction);
+            mut_previousAction = action;
+        }
+    }
+    // currentSwap が残っていれば newActions に追加
+    if (mut_previousAction !== undefined) {
+        mut_newActions.push(mut_previousAction);
+    }
+    return mut_newActions;
+};
+const mergeActionsBySwapAndOtherAction = (actions, nativeTokenCryptocurrency) => {
+    const mut_newActions = [];
+    let mut_previousAction = undefined;
+    for (const action of actions) {
+        if (mut_previousAction === undefined) {
+            mut_previousAction = action;
+            continue;
+        }
+        // 前後の action を結合するか試す
+        const mergedAction = mergeSwapAndOtherAction([mut_previousAction, action], nativeTokenCryptocurrency);
+        if (mergedAction === undefined) {
+            // 結合できていなければ、previous action を newActions に追加して、action を previous action に設定
+            mut_newActions.push(mut_previousAction);
+            mut_previousAction = action;
+        }
+        else {
+            // 結合できていれば、結合結果を previous action に設定
+            mut_previousAction = mergedAction;
+        }
+    }
+    // previous action が残っていれば newActions に追加
+    if (mut_previousAction !== undefined) {
+        mut_newActions.push(mut_previousAction);
+    }
+    return mut_newActions;
+};
+const mergeSwapAndOtherAction = (actions, nativeTokenCryptocurrency) => {
+    const [action0, action1] = actions;
+    if (action0.type === 'Swap') {
+        // action1=Transfer | action0.out の token/amount/address が一致する場合は結合
+        if (action1.type === 'Erc20Transfer' &&
+            action0.transferOut.type === 'Erc20Transfer' &&
+            action0.transferOut.token.contractAddress ===
+                action1.token.contractAddress &&
+            action0.transferOut.to === action1.from &&
+            action0.transferOut.value === action1.value) {
+            return createSwap({
+                ...action0,
+                transferOut: action1,
+            });
+        }
+        // action1=Withdrawal で action0.out の token/amount/address が一致する場合は結合
+        if (action1.type === 'WrappedWithdrawalLog' &&
+            action0.transferOut.type === 'Erc20Transfer' &&
+            action0.transferOut.token.contractAddress === action1.address &&
+            action0.transferOut.to === action1.args[0].value &&
+            action0.transferOut.value === action1.args[1].value) {
+            return createSwap({
+                ...action0,
+                transferOut: {
+                    type: 'InternalTransaction',
+                    transactionHash: '0x',
+                    from: action0.transferOut.from,
+                    to: action0.transferOut.to,
+                    contractAddress: undefined,
+                    txType: '',
+                    value: action0.transferOut.value,
+                    gas: 0n,
+                    gasUsed: 0n,
+                    isError: false,
+                    input: undefined,
+                    currency: nativeTokenCryptocurrency,
+                    price: action0.transferOut.price,
+                },
+            });
+        }
+    }
+    else if (action1.type === 'Swap') {
+        // action0=Transfer で action1.in の token/amount/address が一致する場合は結合
+        if (action0.type === 'Erc20Transfer' &&
+            action1.transferIn.type === 'Erc20Transfer' &&
+            action1.transferIn.token.contractAddress ===
+                action0.token.contractAddress &&
+            action1.transferIn.from === action0.to &&
+            action1.transferIn.value === action0.value) {
+            return createSwap({
+                ...action1,
+                transferIn: action0,
+            });
+        }
+        // action0=Deposit で action1.in の token/amount/address が一致する場合は結合
+        if (action0.type === 'WrappedDepositLog' &&
+            action1.transferIn.type === 'Erc20Transfer' &&
+            action1.transferIn.token.contractAddress === action0.address &&
+            action1.transferIn.from === action0.args[0].value &&
+            action1.transferIn.value === action0.args[1].value) {
+            return createSwap({
+                ...action1,
+                transferIn: {
+                    type: 'InternalTransaction',
+                    transactionHash: '0x',
+                    from: action1.transferIn.from,
+                    to: action1.transferIn.to,
+                    contractAddress: undefined,
+                    txType: '',
+                    value: action1.transferIn.value,
+                    gas: 0n,
+                    gasUsed: 0n,
+                    isError: false,
+                    input: undefined,
+                    currency: nativeTokenCryptocurrency,
+                    price: action1.transferIn.price,
+                },
+            });
+        }
+    }
+    return undefined;
+};
+/** swap0 -> swap1 が連続取引の場合に結合して返す */
+const mergeSequenceSwaps = (swaps) => swaps[0].transferOut.type === 'Erc20Transfer' &&
+    swaps[1].transferIn.type === 'Erc20Transfer' &&
+    swaps[0].transferOut.value === swaps[1].transferIn.value &&
+    swaps[0].transferOut.token.contractAddress ===
+        swaps[1].transferIn.token.contractAddress
+    ? createSwap({
+        ...swaps[0],
+        transferOut: swaps[1].transferOut,
+        swapLogIndex: swaps[1].swapLogIndex,
+    })
+    : undefined;
+/** swap0 , swap1 の address,token が全て同じ場合に結合して返す */
+const mergeSimilarSwaps = (swaps) => swaps[0].transferIn.type === 'Erc20Transfer' &&
+    swaps[0].transferOut.type === 'Erc20Transfer' &&
+    swaps[1].transferIn.type === 'Erc20Transfer' &&
+    swaps[1].transferOut.type === 'Erc20Transfer' &&
+    swaps[0].transferIn.from === swaps[1].transferIn.from &&
+    swaps[0].transferOut.to === swaps[1].transferOut.to &&
+    swaps[0].transferIn.token.contractAddress ===
+        swaps[1].transferIn.token.contractAddress &&
+    swaps[0].transferOut.token.contractAddress ===
+        swaps[1].transferOut.token.contractAddress
+    ? createSwap({
+        ...swaps[0],
+        transferIn: {
+            ...swaps[0].transferIn,
+            value: swaps[0].transferIn.value + swaps[1].transferIn.value,
+        },
+        transferOut: {
+            ...swaps[1].transferOut,
+            value: swaps[0].transferOut.value + swaps[1].transferOut.value,
+        },
+        swapLogIndex: swaps[1].swapLogIndex,
+    })
+    : undefined;
+const mergeSwapAndInternalTransactions = (swap, internalTransactions) => {
+    // swap.transferIn = internalTx で、swap.transferIn.from への internal transaction があれば結合
+    if (swap.transferIn.type === 'InternalTransaction') {
+        const index = internalTransactions.findIndex((transaction) => transaction.to !== undefined &&
+            transaction.to === swap.transferIn.from &&
+            transaction.value === swap.transferIn.value);
+        const internalTransaction = internalTransactions[index];
+        if (internalTransaction !== undefined &&
+            internalTransaction.to !== undefined) {
+            return {
+                swap: createSwap({
+                    ...swap,
+                    transferIn: internalTransaction,
+                }),
+                internalTransactions: internalTransactions.filter((_, index_) => index_ !== index),
+            };
+        }
+    }
+    // swap.out = native で、swap.addressOut への internal transaction があれば結合
+    if (swap.transferOut.type === 'InternalTransaction') {
+        const index = internalTransactions.findIndex((transaction) => transaction.from !== undefined &&
+            transaction.from === swap.transferOut.to &&
+            transaction.value === swap.transferOut.value);
+        const internalTransaction = internalTransactions[index];
+        if (internalTransaction !== undefined &&
+            internalTransaction.to !== undefined) {
+            return {
+                swap: createSwap({
+                    ...swap,
+                    transferOut: internalTransaction,
+                }),
+                internalTransactions: internalTransactions.filter((_, index_) => index_ !== index),
+            };
+        }
+    }
+    return {
+        swap,
+        internalTransactions,
+    };
+};
+//# sourceMappingURL=analyze.js.map