@0xtorch/evm 0.0.1

package/src/analyzer/swap/analyze.ts

@@ -0,0 +1,939 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  CryptoCurrency,
+  CryptoCurrencyPrice,
+  NormalActionAtomicArbitrage,
+  NormalActionTrade,
+} from '@0xtorch/core'
+import { zeroAddress } from 'viem'
+import type { Chain } from '../../chains'
+import { createEvmAccount } from '../../creates/createEvmAccount'
+import type {
+  DecodedLog,
+  Erc20Transfer,
+  EvmAccount,
+  InternalTransaction,
+  LowerHex,
+} from '../../types'
+import { toLowerHex } from '../../types'
+import { createAccountActionByAction } from '../createAccountActionByAction'
+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<Price> | 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 accountAction = createAccountActionByAction(
+    normalAction,
+    transaction,
+    accountAddresses,
+  )
+
+  return Promise.resolve({
+    actions: [normalAction],
+    accountActions: accountAction === undefined ? [] : [accountAction],
+  })
+}
+
+const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
+  swap: Swap<Price>,
+  chain: Chain,
+  timestamp: number,
+):
+  | NormalActionAtomicArbitrage<EvmAccount, Price>
+  | NormalActionTrade<EvmAccount, Price, CryptoCurrency> => {
+  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<EvmAccount, Price> => {
+  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 = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  swap: Swap<Price>,
+  chain: Chain,
+  timestamp: number,
+): NormalActionTrade<EvmAccount, Price, CryptoCurrency> => {
+  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 = <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,
+  }
+}