@0xtorch/evm 0.0.60 → 0.0.62

package/analyzer/swap/analyze.ts

@@ -1,905 +1,905 @@
-import type {
-  CryptoCurrency,
-  CryptoCurrencyPrice,
-  NormalActionAtomicArbitrage,
-  NormalActionTrade,
-} from '@0xtorch/core'
-import { parseNormalActionToAccountActions } from '@0xtorch/core'
-import { zeroAddress } from 'viem'
-import type { Chain } from '../../chains'
-import type {
-  DecodedLog,
-  Erc20Transfer,
-  InternalTransaction,
-  LowerHex,
-} from '../../types'
-import { toLowerHex } from '../../types'
-import { createEvmAddressId } from '../../utils'
-import { createEvmActionSource } from '../../utils/create'
-import {
-  parseErc20TransferToActionTransferIn,
-  parseErc20TransferToActionTransferOut,
-  parseInternalTransactionToActionTransferIn,
-  parseInternalTransactionToActionTransferOut,
-} from '../parsers/transfer'
-import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
-import type { TraderJoeLBPairSwapLog } from './traderJoeLBPairSwap'
-import { parseToTraderJoeLBPairSwap } from './traderJoeLBPairSwap'
-import type { UniV2PairSwapLog } from './univ2PairSwap'
-import { parseToUniv2SwapLog } from './univ2PairSwap'
-import type { UniV3PoolSwapLog } from './univ3PoolSwap'
-import { parseToUniv3SwapLog } from './univ3PoolSwap'
-import type { WrappedDepositLog } from './wrappedDeposit'
-import { parseToWrappedDepositLog } from './wrappedDeposit'
-import type { WrappedWithdrawalLog } from './wrappedWithdrawal'
-import { parseToWrappedWithdrawalLog } from './wrappedWithdrawal'
-
-export const analyzeSwap = <Price extends CryptoCurrencyPrice | undefined>({
-  chain,
-  transaction,
-  accountAddresses,
-}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
-  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' as const,
-          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: InternalTransaction<Price>[] = [
-    ...(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 is DecodedLog => log !== undefined)
-  const univ2SwapLogs = decodedLogs
-    .map((log) => parseToUniv2SwapLog(log))
-    .filter((log): log is UniV2PairSwapLog => log !== undefined)
-  const univ3SwapLogs = decodedLogs
-    .map((log) => parseToUniv3SwapLog(log))
-    .filter((log): log is UniV3PoolSwapLog => log !== undefined)
-  const traderJoeLBPairSwapLogs = decodedLogs
-    .map((log) => parseToTraderJoeLBPairSwap(log))
-    .filter((log): log is TraderJoeLBPairSwapLog => log !== undefined)
-  const depositLogs = decodedLogs
-    .map((log) => parseToWrappedDepositLog(log))
-    .filter((log): log is WrappedDepositLog => log !== undefined)
-  const withdrawalLogs = decodedLogs
-    .map((log) => parseToWrappedWithdrawalLog(log))
-    .filter((log): log is WrappedWithdrawalLog => 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 is Swap<Price> => swap !== undefined)
-  const univ3Swaps = univ3SwapLogs
-    .map((log) => createSwapFromUniv3SwapLog(log, erc20Transfers))
-    .filter((swap): swap is Swap<Price> => swap !== undefined)
-  const traderJoeLBPairSwaps = traderJoeLBPairSwapLogs
-    .map((log) => createSwapFromTraderJoeLBPairSwapLog(log, erc20Transfers))
-    .filter((swap): swap is Swap<Price> => 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 accountIds = new Set(
-    accountAddresses.map((address) =>
-      createEvmAddressId({ chainId: chain.id, address }),
-    ),
-  )
-  const source = createEvmActionSource({
-    chainId: chain.id,
-    transactionHash: transaction.transactionHash,
-  })
-  const accountActions = parseNormalActionToAccountActions({
-    action: normalAction,
-    accountIds,
-    source,
-    // TODO 値を入れる
-    cexAccountIds: undefined,
-  })
-
-  return Promise.resolve({
-    actions: [normalAction],
-    accountActions,
-  })
-}
-
-const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
-  swap: Swap<Price>,
-  chain: Chain,
-  timestamp: number,
-): NormalActionAtomicArbitrage | NormalActionTrade => {
-  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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  swap: Swap<Price>,
-  chain: Chain,
-  timestamp: number,
-): NormalActionAtomicArbitrage => {
-  const { transferIn, transferOut } = swap
-  if (transferIn.to === undefined || transferOut.to === undefined) {
-    throw new Error('invalid swap')
-  }
-
-  return {
-    type: 'NormalAction',
-    action: 'atomic-arbitrage',
-    evidence: 'contract',
-    timestamp,
-    comment: undefined,
-    app: undefined,
-    transfers: [
-      transferIn.type === 'InternalTransaction'
-        ? parseInternalTransactionToActionTransferOut({
-            chain,
-            internalTransaction: transferIn,
-          })
-        : parseErc20TransferToActionTransferOut({
-            chainId: chain.id,
-            transfer: transferIn,
-          }),
-      transferOut.type === 'InternalTransaction'
-        ? parseInternalTransactionToActionTransferIn({
-            chain,
-            internalTransaction: transferOut,
-          })
-        : parseErc20TransferToActionTransferIn({
-            chainId: chain.id,
-            transfer: transferOut,
-          }),
-    ],
-  }
-}
-
-const generateNormalActionTrade = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  swap: Swap<Price>,
-  chain: Chain,
-  timestamp: number,
-): NormalActionTrade => {
-  const { transferIn, transferOut } = swap
-  if (transferIn.to === undefined || transferOut.to === undefined) {
-    throw new Error('invalid swap')
-  }
-
-  return {
-    type: 'NormalAction',
-    action: 'trade',
-    evidence: 'contract',
-    timestamp,
-    comment: undefined,
-    app: undefined,
-    transfers: [
-      transferIn.type === 'InternalTransaction'
-        ? parseInternalTransactionToActionTransferOut({
-            chain,
-            internalTransaction: transferIn,
-          })
-        : parseErc20TransferToActionTransferOut({
-            chainId: chain.id,
-            transfer: transferIn,
-          }),
-      transferOut.type === 'InternalTransaction'
-        ? parseInternalTransactionToActionTransferIn({
-            chain,
-            internalTransaction: transferOut,
-          })
-        : parseErc20TransferToActionTransferIn({
-            chainId: chain.id,
-            transfer: transferOut,
-          }),
-    ],
-  }
-}
-
-const getIndex = <Price extends CryptoCurrencyPrice | undefined>(
-  data:
-    | Swap<Price>
-    | Erc20Transfer<Price>
-    | WrappedDepositLog
-    | WrappedWithdrawalLog,
-): number => {
-  switch (data.type) {
-    case 'WrappedDepositLog': {
-      return data.logIndex
-    }
-    case 'WrappedWithdrawalLog': {
-      return data.logIndex
-    }
-    case 'Erc20Transfer': {
-      return data.logIndex
-    }
-    case 'Swap': {
-      return data.swapLogIndex
-    }
-  }
-}
-
-type Swap<Price extends CryptoCurrencyPrice | undefined> = {
-  readonly type: 'Swap'
-  readonly contractAddress: LowerHex
-  readonly transferIn: Erc20Transfer<Price> | InternalTransaction<Price>
-  readonly transferOut: Erc20Transfer<Price> | InternalTransaction<Price>
-  readonly swapLogIndex: number
-}
-
-const createSwapFromUniv2SwapLog = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  log: UniV2PairSwapLog,
-  erc20TokenTransfers: readonly Erc20Transfer<Price>[],
-): Swap<Price> | undefined => {
-  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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  log: UniV3PoolSwapLog,
-  erc20TokenTransfers: readonly Erc20Transfer<Price>[],
-): Swap<Price> | undefined => {
-  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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  log: TraderJoeLBPairSwapLog,
-  erc20TokenTransfers: readonly Erc20Transfer<Price>[],
-): Swap<Price> | undefined => {
-  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 = <Price extends CryptoCurrencyPrice | undefined>({
-  contractAddress,
-  transferIn,
-  transferOut,
-  swapLogIndex,
-}: {
-  readonly contractAddress: LowerHex
-  readonly transferIn: Erc20Transfer<Price> | InternalTransaction<Price>
-  readonly transferOut: Erc20Transfer<Price> | InternalTransaction<Price>
-  readonly swapLogIndex: number
-}): Swap<Price> => ({
-  type: 'Swap',
-  contractAddress,
-  transferIn,
-  transferOut,
-  swapLogIndex,
-})
-
-const createSwapUsingIndexes = <Price extends CryptoCurrencyPrice | undefined>({
-  swapLogIndex,
-  transferIn,
-  transferOut,
-}: Swap<Price>): readonly number[] => {
-  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
-}
-
-type Action<Price extends CryptoCurrencyPrice | undefined> =
-  | Erc20Transfer<Price>
-  | WrappedDepositLog
-  | WrappedWithdrawalLog
-  | Swap<Price>
-
-const mergeActions = <Price extends CryptoCurrencyPrice | undefined>(
-  actions: readonly Action<Price>[],
-  nativeTokenCryptocurrency: CryptoCurrency,
-): readonly Action<Price>[] => {
-  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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  actions: readonly Action<Price>[],
-): readonly Action<Price>[] => {
-  const mut_newActions: Action<Price>[] = []
-  let mut_previousAction: Action<Price> | undefined = 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: Swap<Price> | undefined = 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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  actions: readonly Action<Price>[],
-): readonly Action<Price>[] => {
-  const mut_newActions: Action<Price>[] = []
-  let mut_previousAction: Action<Price> | undefined = 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: Swap<Price> | undefined = 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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  actions: readonly Action<Price>[],
-  nativeTokenCryptocurrency: CryptoCurrency,
-): readonly Action<Price>[] => {
-  const mut_newActions: Action<Price>[] = []
-  let mut_previousAction: Action<Price> | undefined = undefined
-  for (const action of actions) {
-    if (mut_previousAction === undefined) {
-      mut_previousAction = action
-      continue
-    }
-
-    // 前後の action を結合するか試す
-    const mergedAction: Swap<Price> | undefined = 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 = <Price extends CryptoCurrencyPrice | undefined>(
-  actions: readonly [Action<Price>, Action<Price>],
-  nativeTokenCryptocurrency: CryptoCurrency,
-): Swap<Price> | undefined => {
-  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 = <Price extends CryptoCurrencyPrice | undefined>(
-  swaps: readonly [Swap<Price>, Swap<Price>],
-): Swap<Price> | undefined =>
-  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 = <Price extends CryptoCurrencyPrice | undefined>(
-  swaps: readonly [Swap<Price>, Swap<Price>],
-): Swap<Price> | undefined =>
-  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 = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  swap: Swap<Price>,
-  internalTransactions: readonly InternalTransaction<Price>[],
-): {
-  readonly swap: Swap<Price>
-  readonly internalTransactions: readonly InternalTransaction<Price>[]
-} => {
-  // 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,
-  }
-}
+// import type {
+//   CryptoCurrency,
+//   CryptoCurrencyPrice,
+//   NormalActionAtomicArbitrage,
+//   NormalActionTrade,
+// } from '@0xtorch/core'
+// import { parseNormalActionToAccountActions } from '@0xtorch/core'
+// import { zeroAddress } from 'viem'
+// import type { Chain } from '../../chain'
+// import type {
+//   DecodedLog,
+//   Erc20Transfer,
+//   InternalTransaction,
+//   LowerHex,
+// } from '../../types'
+// import { toLowerHex } from '../../types'
+// import { createEvmAddressId } from '../../utils'
+// import { createEvmActionSource } from '../../utils/create'
+// import {
+//   parseErc20TransferToActionTransferIn,
+//   parseErc20TransferToActionTransferOut,
+//   parseInternalTransactionToActionTransferIn,
+//   parseInternalTransactionToActionTransferOut,
+// } from '../parsers/transfer'
+// import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
+// import type { TraderJoeLBPairSwapLog } from './traderJoeLBPairSwap'
+// import { parseToTraderJoeLBPairSwap } from './traderJoeLBPairSwap'
+// import type { UniV2PairSwapLog } from './univ2PairSwap'
+// import { parseToUniv2SwapLog } from './univ2PairSwap'
+// import type { UniV3PoolSwapLog } from './univ3PoolSwap'
+// import { parseToUniv3SwapLog } from './univ3PoolSwap'
+// import type { WrappedDepositLog } from './wrappedDeposit'
+// import { parseToWrappedDepositLog } from './wrappedDeposit'
+// import type { WrappedWithdrawalLog } from './wrappedWithdrawal'
+// import { parseToWrappedWithdrawalLog } from './wrappedWithdrawal'
+
+// export const analyzeSwap = <Price extends CryptoCurrencyPrice | undefined>({
+//   chain,
+//   transaction,
+//   accountAddresses,
+// }: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
+//   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' as const,
+//           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: InternalTransaction<Price>[] = [
+//     ...(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 is DecodedLog => log !== undefined)
+//   const univ2SwapLogs = decodedLogs
+//     .map((log) => parseToUniv2SwapLog(log))
+//     .filter((log): log is UniV2PairSwapLog => log !== undefined)
+//   const univ3SwapLogs = decodedLogs
+//     .map((log) => parseToUniv3SwapLog(log))
+//     .filter((log): log is UniV3PoolSwapLog => log !== undefined)
+//   const traderJoeLBPairSwapLogs = decodedLogs
+//     .map((log) => parseToTraderJoeLBPairSwap(log))
+//     .filter((log): log is TraderJoeLBPairSwapLog => log !== undefined)
+//   const depositLogs = decodedLogs
+//     .map((log) => parseToWrappedDepositLog(log))
+//     .filter((log): log is WrappedDepositLog => log !== undefined)
+//   const withdrawalLogs = decodedLogs
+//     .map((log) => parseToWrappedWithdrawalLog(log))
+//     .filter((log): log is WrappedWithdrawalLog => 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 is Swap<Price> => swap !== undefined)
+//   const univ3Swaps = univ3SwapLogs
+//     .map((log) => createSwapFromUniv3SwapLog(log, erc20Transfers))
+//     .filter((swap): swap is Swap<Price> => swap !== undefined)
+//   const traderJoeLBPairSwaps = traderJoeLBPairSwapLogs
+//     .map((log) => createSwapFromTraderJoeLBPairSwapLog(log, erc20Transfers))
+//     .filter((swap): swap is Swap<Price> => 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 accountIds = new Set(
+//     accountAddresses.map((address) =>
+//       createEvmAddressId({ chainId: chain.id, address }),
+//     ),
+//   )
+//   const source = createEvmActionSource({
+//     chainId: chain.id,
+//     transactionHash: transaction.transactionHash,
+//   })
+//   const accountActions = parseNormalActionToAccountActions({
+//     action: normalAction,
+//     accountIds,
+//     source,
+//     // TODO 値を入れる
+//     cexAccountIds: undefined,
+//   })
+
+//   return Promise.resolve({
+//     actions: [normalAction],
+//     accountActions,
+//   })
+// }
+
+// const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
+//   swap: Swap<Price>,
+//   chain: Chain,
+//   timestamp: number,
+// ): NormalActionAtomicArbitrage | NormalActionTrade => {
+//   if (
+//     swap.transferIn.type === 'InternalTransaction' &&
+//     swap.transferOut.type === 'InternalTransaction'
+//   ) {
+//     return generateNormalActionAtomicArbitrage(swap, chain, timestamp)
+//   }
+//   if (
+//     swap.transferIn.type === 'Erc20Transfer' &&
+//     swap.transferOut.type === 'Erc20Transfer' &&
+//     swap.transferIn.token.contractAddress ===
+//       swap.transferOut.token.contractAddress
+//   ) {
+//     return generateNormalActionAtomicArbitrage(swap, chain, timestamp)
+//   }
+//   return generateNormalActionTrade(swap, chain, timestamp)
+// }
+
+// const generateNormalActionAtomicArbitrage = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   swap: Swap<Price>,
+//   chain: Chain,
+//   timestamp: number,
+// ): NormalActionAtomicArbitrage => {
+//   const { transferIn, transferOut } = swap
+//   if (transferIn.to === undefined || transferOut.to === undefined) {
+//     throw new Error('invalid swap')
+//   }
+
+//   return {
+//     type: 'NormalAction',
+//     action: 'atomic-arbitrage',
+//     evidence: 'contract',
+//     timestamp,
+//     comment: undefined,
+//     app: undefined,
+//     transfers: [
+//       transferIn.type === 'InternalTransaction'
+//         ? parseInternalTransactionToActionTransferOut({
+//             chain,
+//             internalTransaction: transferIn,
+//           })
+//         : parseErc20TransferToActionTransferOut({
+//             chainId: chain.id,
+//             transfer: transferIn,
+//           }),
+//       transferOut.type === 'InternalTransaction'
+//         ? parseInternalTransactionToActionTransferIn({
+//             chain,
+//             internalTransaction: transferOut,
+//           })
+//         : parseErc20TransferToActionTransferIn({
+//             chainId: chain.id,
+//             transfer: transferOut,
+//           }),
+//     ],
+//   }
+// }
+
+// const generateNormalActionTrade = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   swap: Swap<Price>,
+//   chain: Chain,
+//   timestamp: number,
+// ): NormalActionTrade => {
+//   const { transferIn, transferOut } = swap
+//   if (transferIn.to === undefined || transferOut.to === undefined) {
+//     throw new Error('invalid swap')
+//   }
+
+//   return {
+//     type: 'NormalAction',
+//     action: 'trade',
+//     evidence: 'contract',
+//     timestamp,
+//     comment: undefined,
+//     app: undefined,
+//     transfers: [
+//       transferIn.type === 'InternalTransaction'
+//         ? parseInternalTransactionToActionTransferOut({
+//             chain,
+//             internalTransaction: transferIn,
+//           })
+//         : parseErc20TransferToActionTransferOut({
+//             chainId: chain.id,
+//             transfer: transferIn,
+//           }),
+//       transferOut.type === 'InternalTransaction'
+//         ? parseInternalTransactionToActionTransferIn({
+//             chain,
+//             internalTransaction: transferOut,
+//           })
+//         : parseErc20TransferToActionTransferIn({
+//             chainId: chain.id,
+//             transfer: transferOut,
+//           }),
+//     ],
+//   }
+// }
+
+// const getIndex = <Price extends CryptoCurrencyPrice | undefined>(
+//   data:
+//     | Swap<Price>
+//     | Erc20Transfer<Price>
+//     | WrappedDepositLog
+//     | WrappedWithdrawalLog,
+// ): number => {
+//   switch (data.type) {
+//     case 'WrappedDepositLog': {
+//       return data.logIndex
+//     }
+//     case 'WrappedWithdrawalLog': {
+//       return data.logIndex
+//     }
+//     case 'Erc20Transfer': {
+//       return data.logIndex
+//     }
+//     case 'Swap': {
+//       return data.swapLogIndex
+//     }
+//   }
+// }
+
+// type Swap<Price extends CryptoCurrencyPrice | undefined> = {
+//   readonly type: 'Swap'
+//   readonly contractAddress: LowerHex
+//   readonly transferIn: Erc20Transfer<Price> | InternalTransaction<Price>
+//   readonly transferOut: Erc20Transfer<Price> | InternalTransaction<Price>
+//   readonly swapLogIndex: number
+// }
+
+// const createSwapFromUniv2SwapLog = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   log: UniV2PairSwapLog,
+//   erc20TokenTransfers: readonly Erc20Transfer<Price>[],
+// ): Swap<Price> | undefined => {
+//   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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   log: UniV3PoolSwapLog,
+//   erc20TokenTransfers: readonly Erc20Transfer<Price>[],
+// ): Swap<Price> | undefined => {
+//   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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   log: TraderJoeLBPairSwapLog,
+//   erc20TokenTransfers: readonly Erc20Transfer<Price>[],
+// ): Swap<Price> | undefined => {
+//   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 = <Price extends CryptoCurrencyPrice | undefined>({
+//   contractAddress,
+//   transferIn,
+//   transferOut,
+//   swapLogIndex,
+// }: {
+//   readonly contractAddress: LowerHex
+//   readonly transferIn: Erc20Transfer<Price> | InternalTransaction<Price>
+//   readonly transferOut: Erc20Transfer<Price> | InternalTransaction<Price>
+//   readonly swapLogIndex: number
+// }): Swap<Price> => ({
+//   type: 'Swap',
+//   contractAddress,
+//   transferIn,
+//   transferOut,
+//   swapLogIndex,
+// })
+
+// const createSwapUsingIndexes = <Price extends CryptoCurrencyPrice | undefined>({
+//   swapLogIndex,
+//   transferIn,
+//   transferOut,
+// }: Swap<Price>): readonly number[] => {
+//   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
+// }
+
+// type Action<Price extends CryptoCurrencyPrice | undefined> =
+//   | Erc20Transfer<Price>
+//   | WrappedDepositLog
+//   | WrappedWithdrawalLog
+//   | Swap<Price>
+
+// const mergeActions = <Price extends CryptoCurrencyPrice | undefined>(
+//   actions: readonly Action<Price>[],
+//   nativeTokenCryptocurrency: CryptoCurrency,
+// ): readonly Action<Price>[] => {
+//   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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   actions: readonly Action<Price>[],
+// ): readonly Action<Price>[] => {
+//   const mut_newActions: Action<Price>[] = []
+//   let mut_previousAction: Action<Price> | undefined = 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: Swap<Price> | undefined = 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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   actions: readonly Action<Price>[],
+// ): readonly Action<Price>[] => {
+//   const mut_newActions: Action<Price>[] = []
+//   let mut_previousAction: Action<Price> | undefined = 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: Swap<Price> | undefined = 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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   actions: readonly Action<Price>[],
+//   nativeTokenCryptocurrency: CryptoCurrency,
+// ): readonly Action<Price>[] => {
+//   const mut_newActions: Action<Price>[] = []
+//   let mut_previousAction: Action<Price> | undefined = undefined
+//   for (const action of actions) {
+//     if (mut_previousAction === undefined) {
+//       mut_previousAction = action
+//       continue
+//     }
+
+//     // 前後の action を結合するか試す
+//     const mergedAction: Swap<Price> | undefined = 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 = <Price extends CryptoCurrencyPrice | undefined>(
+//   actions: readonly [Action<Price>, Action<Price>],
+//   nativeTokenCryptocurrency: CryptoCurrency,
+// ): Swap<Price> | undefined => {
+//   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 = <Price extends CryptoCurrencyPrice | undefined>(
+//   swaps: readonly [Swap<Price>, Swap<Price>],
+// ): Swap<Price> | undefined =>
+//   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 = <Price extends CryptoCurrencyPrice | undefined>(
+//   swaps: readonly [Swap<Price>, Swap<Price>],
+// ): Swap<Price> | undefined =>
+//   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 = <
+//   Price extends CryptoCurrencyPrice | undefined,
+// >(
+//   swap: Swap<Price>,
+//   internalTransactions: readonly InternalTransaction<Price>[],
+// ): {
+//   readonly swap: Swap<Price>
+//   readonly internalTransactions: readonly InternalTransaction<Price>[]
+// } => {
+//   // 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,
+//   }
+// }