@0xtorch/evm 0.0.1

package/src/analyzer/seaport/analyze.ts

@@ -0,0 +1,917 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  AccountActionBuyNft,
+  AccountActionNftRoyalty,
+  AccountActionSellNft,
+  AccountActionSwapNft,
+  AccountActionTrade,
+  CryptoCurrencyPrice,
+  NormalActionTrade,
+} from '@0xtorch/core'
+import type { Chain } from '../../chains'
+import { createEvmAccount } from '../../creates/createEvmAccount'
+import type {
+  DecodedLog,
+  Erc1155Transfer,
+  Erc20Transfer,
+  Erc721Transfer,
+  EvmAccount,
+  InternalTransaction,
+  LowerHex,
+  TransactionDecoded,
+  TransactionSource,
+} from '../../types'
+import { toLowerHex } from '../../types'
+import { analyzeAsSpam } from '../spam'
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
+import type { OrderFulfilledLog } from './orderFulfilled'
+import { parseToOrderFulfilledLog } from './orderFulfilled'
+
+export const analyzeSeaport = async <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  chain,
+  transaction,
+  accountAddresses,
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+  const {
+    transactionHash,
+    value,
+    from,
+    to,
+    contractAddress,
+    logs,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    internalTransactions,
+    nativeTokenPrice,
+  } = transaction
+
+  // internal transaction に native token trnasfer を追加する
+  const allInternalTransactions = [
+    ...(value > 0n
+      ? [
+          {
+            type: 'InternalTransaction' as const,
+            transactionHash,
+            from: toLowerHex(from),
+            to: to === null ? undefined : toLowerHex(to),
+            contractAddress:
+              contractAddress === null
+                ? undefined
+                : toLowerHex(contractAddress),
+            txType: '',
+            value,
+            gas: 0n,
+            gasUsed: 0n,
+            isError: false,
+            input: undefined,
+            currency: chain.nativeToken.currency,
+            price: nativeTokenPrice,
+          },
+        ]
+      : []),
+    ...internalTransactions,
+  ]
+
+  // OrderFulfilled event が 1 つでない場合は処理しない
+  // offerer と recipient が同一の OrderFulfilled event は除外する
+  const decodedLogs = logs
+    .map((log) => (log.type === 'decoded' ? log.log : undefined))
+    .filter((log): log is DecodedLog => log !== undefined)
+  const orderFulfilledLogs = decodedLogs
+    .map((log) => parseToOrderFulfilledLog(log))
+    .filter((log): log is OrderFulfilledLog => log !== undefined)
+    .filter((log) => log.args[1].value !== log.args[3].value)
+  if (orderFulfilledLogs.length !== 1) {
+    return undefined
+  }
+  const orderFulfilledLog = orderFulfilledLogs[0]
+  const orderOfferer = orderFulfilledLog.args[1].value
+  const orderRecipient = orderFulfilledLog.args[3].value
+
+  // orderFulfilled.offer の item 毎に item の token が order の ofeerer から order の recipient へ transfer される
+  // offer に含まれる ERC20,721,1155 token が指定された recipient に transfer されない動きをしている場合、 transaction を spam として処理
+  const mut_offerTransfers: (
+    | Erc20Transfer<Price>
+    | Erc721Transfer
+    | Erc1155Transfer
+    | InternalTransaction<Price>
+  )[] = []
+  let mut_isSpam = false
+  let mut_includeNativeToken = false
+  for (const offerItem of orderFulfilledLog.args[4].value) {
+    switch (offerItem.itemType) {
+      case 0: {
+        // native token
+        // internal transaction の場合は from に制約を付けない
+        // offer に native token があって、 recipient にもある場合、相殺する
+        const considerationAmount = orderFulfilledLog.args[5].value
+          .filter((item) => item.itemType === 0)
+          .reduce((accumulator, item) => accumulator + item.amount, 0n)
+        const amount = offerItem.amount - considerationAmount
+        const internalTransfers = allInternalTransactions.filter(
+          (internal) =>
+            internal.value === amount && internal.to === orderRecipient,
+        )
+        if (internalTransfers.length <= 1) {
+          // 合致する internal transfer が 1 つ以下の場合は includeNativeToken を true にする
+          mut_includeNativeToken = true
+          break
+        } else {
+          // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        }
+      }
+      case 1: {
+        // ERC20
+        // offer に ERC20 があって、同一 token が recipient にもある場合、相殺する
+        const considerationAmount = orderFulfilledLog.args[5].value
+          .filter(
+            (item) => item.itemType === 1 && item.token === offerItem.token,
+          )
+          .reduce((accumulator, item) => accumulator + item.amount, 0n)
+        const amount = offerItem.amount - considerationAmount
+        const erc20OfferTransfers = erc20Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === offerItem.token &&
+            transfer.value === amount &&
+            transfer.from === orderOfferer &&
+            transfer.to === orderRecipient,
+        )
+        if (erc20OfferTransfers.length === 1) {
+          // 合致する ERC20 transfer が 1 つの場合は mut_offerTransfers に追加
+          mut_offerTransfers.push(erc20OfferTransfers[0])
+          break
+        } else if (erc20OfferTransfers.length > 1) {
+          // 合致する ERC20 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc20Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === offerItem.token &&
+                transfer.value === amount,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+      case 2: {
+        // ERC721
+        const erc721OfferTransfers = erc721Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === offerItem.token &&
+            transfer.tokenId === offerItem.identifier &&
+            transfer.from === orderOfferer &&
+            transfer.to === orderRecipient,
+        )
+        if (erc721OfferTransfers.length === 1) {
+          // 合致する ERC721 transfer が 1 つの場合は mut_offerTransfers に追加
+          mut_offerTransfers.push(erc721OfferTransfers[0])
+          break
+        } else if (erc721OfferTransfers.length > 1) {
+          // 合致する ERC721 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc721Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === offerItem.token &&
+                transfer.tokenId === offerItem.identifier,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+      case 3: {
+        // ERC1155
+        const erc1155OfferTransfers = erc1155Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === offerItem.token &&
+            transfer.id === offerItem.identifier &&
+            transfer.value === offerItem.amount &&
+            transfer.from === orderOfferer &&
+            transfer.to === orderRecipient,
+        )
+        if (erc1155OfferTransfers.length === 1) {
+          // 合致する ERC1155 transfer が 1 つの場合は mut_offerTransfers に追加
+          mut_offerTransfers.push(erc1155OfferTransfers[0])
+          break
+        } else if (erc1155OfferTransfers.length > 1) {
+          // 合致する ERC1155 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc1155Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === offerItem.token &&
+                transfer.id === offerItem.identifier,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+    }
+  }
+
+  // orderFulfilled.consideration の item 毎に item の token が order の recipient から item の recipient へ transfer されている
+  // consideration , offer に含まれる ERC20,721,1155 token が指定された recipient に transfer されない動きをしている場合、 transaction を spam として処理
+  const mut_considerationTransfers: (
+    | Erc20Transfer<Price>
+    | Erc721Transfer
+    | Erc1155Transfer
+    | InternalTransaction<Price>
+  )[] = []
+  for (const considerationItem of orderFulfilledLog.args[5].value) {
+    if (orderRecipient === considerationItem.recipient) {
+      continue
+    }
+    switch (considerationItem.itemType) {
+      case 0: {
+        // native token
+        // internal transaction の場合は from に制約を付けない
+        const internalTransfers = allInternalTransactions.filter(
+          (internal) =>
+            internal.value === considerationItem.amount &&
+            internal.to === considerationItem.recipient,
+        )
+        if (internalTransfers.length <= 1) {
+          // 合致する internal transfer が 1 つ以下の場合は includeNativeToken を true にする
+          mut_includeNativeToken = true
+          break
+        } else {
+          // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        }
+      }
+      case 1: {
+        // ERC20
+        // offer に ERC20 があって、同一 token が recipient にもある場合、from を offerer にする
+        const from = orderFulfilledLog.args[4].value.some(
+          (item) =>
+            item.itemType === 1 && item.token === considerationItem.token,
+        )
+          ? orderOfferer
+          : orderRecipient
+        const erc20ConsiderationTransfers = erc20Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === considerationItem.token &&
+            transfer.value === considerationItem.amount &&
+            transfer.from === from &&
+            transfer.to === considerationItem.recipient,
+        )
+        if (erc20ConsiderationTransfers.length === 1) {
+          // 合致する ERC20 transfer が 1 つの場合は mut_considerationTransfers に追加
+          mut_considerationTransfers.push(erc20ConsiderationTransfers[0])
+          break
+        } else if (erc20ConsiderationTransfers.length > 1) {
+          // 合致する ERC20 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc20Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === considerationItem.token &&
+                transfer.value === considerationItem.amount,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+      case 2: {
+        // ERC721
+        const erc721ConsiderationTransfers = erc721Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === considerationItem.token &&
+            transfer.tokenId === considerationItem.identifier &&
+            transfer.from === orderRecipient &&
+            transfer.to === considerationItem.recipient,
+        )
+        if (erc721ConsiderationTransfers.length === 1) {
+          // 合致する ERC721 transfer が 1 つの場合は mut_considerationTransfers に追加
+          mut_considerationTransfers.push(erc721ConsiderationTransfers[0])
+          break
+        } else if (erc721ConsiderationTransfers.length > 1) {
+          // 合致する ERC721 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc721Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === considerationItem.token &&
+                transfer.tokenId === considerationItem.identifier,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+      case 3: {
+        // ERC1155
+        const erc1155ConsiderationTransfers = erc1155Transfers.filter(
+          (transfer) =>
+            transfer.token.contractAddress === considerationItem.token &&
+            transfer.id === considerationItem.identifier &&
+            transfer.value === considerationItem.amount &&
+            transfer.from === orderRecipient &&
+            transfer.to === considerationItem.recipient,
+        )
+        if (erc1155ConsiderationTransfers.length === 1) {
+          // 合致する ERC1155 transfer が 1 つの場合は mut_considerationTransfers に追加
+          mut_considerationTransfers.push(erc1155ConsiderationTransfers[0])
+          break
+        } else if (erc1155ConsiderationTransfers.length > 1) {
+          // 合致する ERC1155 transfer が複数の場合は pattern 不一致として undefined を返す
+          return undefined
+        } else {
+          // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+          if (
+            erc1155Transfers.some(
+              (transfer) =>
+                transfer.token.contractAddress === considerationItem.token &&
+                transfer.id === considerationItem.identifier,
+            )
+          ) {
+            mut_isSpam = true
+          } else {
+            return undefined
+          }
+          break
+        }
+      }
+    }
+  }
+
+  // spam としての処理
+  if (mut_isSpam) {
+    return await analyzeAsSpam({ chain, transaction, accountAddresses })
+  }
+
+  // それ以外の transfer が含まれる場合は処理しない
+  if (
+    erc20Transfers.some(
+      (transfer) =>
+        mut_offerTransfers.every(
+          (offerTransfer) =>
+            offerTransfer.type !== 'Erc20Transfer' ||
+            transfer.logIndex !== offerTransfer.logIndex,
+        ) &&
+        mut_considerationTransfers.every(
+          (considerationTransfer) =>
+            considerationTransfer.type !== 'Erc20Transfer' ||
+            transfer.logIndex !== considerationTransfer.logIndex,
+        ),
+    ) ||
+    erc721Transfers.some(
+      (transfer) =>
+        mut_offerTransfers.every(
+          (offerTransfer) =>
+            offerTransfer.type !== 'Erc721Transfer' ||
+            transfer.logIndex !== offerTransfer.logIndex,
+        ) &&
+        mut_considerationTransfers.every(
+          (considerationTransfer) =>
+            considerationTransfer.type !== 'Erc721Transfer' ||
+            transfer.logIndex !== considerationTransfer.logIndex,
+        ),
+    ) ||
+    erc1155Transfers.some(
+      (transfer) =>
+        mut_offerTransfers.every(
+          (offerTransfer) =>
+            offerTransfer.type !== 'Erc1155Transfer' ||
+            transfer.logIndex !== offerTransfer.logIndex,
+        ) &&
+        mut_considerationTransfers.every(
+          (considerationTransfer) =>
+            considerationTransfer.type !== 'Erc1155Transfer' ||
+            transfer.logIndex !== considerationTransfer.logIndex,
+        ),
+    )
+  ) {
+    return undefined
+  }
+
+  // normal action は recipient を基準に作成
+  const normalAction = generateNormalAction(
+    chain,
+    transaction,
+    orderFulfilledLog,
+    mut_offerTransfers,
+    mut_considerationTransfers,
+    mut_includeNativeToken ? allInternalTransactions : [],
+    accountAddresses,
+  )
+  if (normalAction === undefined) {
+    return undefined
+  }
+
+  // account action 作成
+  const accountActions = generateAccountActions(
+    chain,
+    transaction,
+    accountAddresses,
+    normalAction,
+  )
+  if (accountActions === undefined) {
+    return undefined
+  }
+
+  return {
+    actions: [normalAction],
+    accountActions:
+      accountActions as AnalyzeReturnType<Price>['accountActions'],
+  }
+}
+
+const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
+  chain: Chain,
+  { app, block, nativeTokenPrice }: TransactionDecoded<Price>,
+  orderFulfilledLog: OrderFulfilledLog,
+  offerTransfers: (
+    | Erc20Transfer<Price>
+    | Erc721Transfer
+    | Erc1155Transfer
+    | InternalTransaction<Price>
+  )[],
+  considerationTransfers: (
+    | Erc20Transfer<Price>
+    | Erc721Transfer
+    | Erc1155Transfer
+    | InternalTransaction<Price>
+  )[],
+  internalTransactions: InternalTransaction<Price>[],
+  accountAddresses: readonly LowerHex[],
+): NormalActionTrade<EvmAccount, Price> | undefined => {
+  const offerer = orderFulfilledLog.args[1].value
+  const recipient = orderFulfilledLog.args[3].value
+  // offer transfer , consideration transfer を recipient を基準にまとめて trade action 作成
+  // recipient が含まれない transfer がある場合、 offerer を基準にまとめて trade action 作成
+  // offerer 基準でも offerer が含まれない transfer がある場合、 undefined を返す (pattern 不一致)
+  //  undefined を返す (pattern 不一致)
+  let mut_existNoRecipientTransfer =
+    !accountAddresses.includes(recipient) && accountAddresses.includes(offerer)
+  const mut_recipientTransfers: NormalActionTrade<
+    EvmAccount,
+    Price
+  >['transfers'][number][] = []
+  for (const transfer of [
+    ...offerTransfers,
+    ...considerationTransfers,
+    ...internalTransactions,
+  ]) {
+    if (mut_existNoRecipientTransfer) {
+      break
+    }
+    if (transfer.from === recipient && transfer.to === recipient) {
+      continue
+    } else if (transfer.from === recipient || transfer.to === recipient) {
+      const direction = transfer.from === recipient ? 'out' : 'in'
+      switch (transfer.type) {
+        case 'InternalTransaction': {
+          if (transfer.to === undefined) {
+            return undefined
+          }
+          mut_recipientTransfers.push({
+            target: recipient,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: chain.nativeToken.currency,
+            amount: createBigDecimal(
+              transfer.value,
+              chain.nativeToken.decimals,
+            ),
+            price: nativeTokenPrice,
+          })
+          break
+        }
+        case 'Erc20Transfer': {
+          mut_recipientTransfers.push({
+            target: recipient,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.token.currency,
+            amount: createBigDecimal(transfer.value, transfer.token.decimals),
+            price: transfer.price,
+          })
+          break
+        }
+        case 'Erc721Transfer': {
+          mut_recipientTransfers.push({
+            target: recipient,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.nft,
+            amount: createBigDecimal(1n),
+            price: undefined as Price,
+          })
+          break
+        }
+        case 'Erc1155Transfer': {
+          mut_recipientTransfers.push({
+            target: recipient,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.nft,
+            amount: createBigDecimal(transfer.value),
+            price: undefined as Price,
+          })
+          break
+        }
+      }
+    } else if (transfer.type === 'InternalTransaction') {
+      continue
+    } else {
+      mut_existNoRecipientTransfer = true
+      break
+    }
+  }
+
+  if (!mut_existNoRecipientTransfer) {
+    return {
+      type: 'NormalAction',
+      action: 'trade',
+      evidence: 'contract',
+      timestamp: Number(block.timestamp) * 1000,
+      comment: undefined,
+      app,
+      transfers: mut_recipientTransfers,
+    }
+  }
+
+  const mut_offererTransfers: NormalActionTrade<
+    EvmAccount,
+    Price
+  >['transfers'][number][] = []
+  for (const transfer of [
+    ...offerTransfers,
+    ...considerationTransfers,
+    ...internalTransactions,
+  ]) {
+    if (transfer.from === offerer && transfer.to === offerer) {
+      continue
+    } else if (transfer.from === offerer || transfer.to === offerer) {
+      const direction = transfer.from === offerer ? 'out' : 'in'
+      switch (transfer.type) {
+        case 'InternalTransaction': {
+          if (transfer.to === undefined) {
+            return undefined
+          }
+          mut_offererTransfers.push({
+            target: offerer,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: chain.nativeToken.currency,
+            amount: createBigDecimal(
+              transfer.value,
+              chain.nativeToken.decimals,
+            ),
+            price: nativeTokenPrice,
+          })
+          break
+        }
+        case 'Erc20Transfer': {
+          mut_offererTransfers.push({
+            target: offerer,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.token.currency,
+            amount: createBigDecimal(transfer.value, transfer.token.decimals),
+            price: transfer.price,
+          })
+          break
+        }
+        case 'Erc721Transfer': {
+          mut_offererTransfers.push({
+            target: offerer,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.nft,
+            amount: createBigDecimal(1n),
+            price: undefined as Price,
+          })
+          break
+        }
+        case 'Erc1155Transfer': {
+          mut_offererTransfers.push({
+            target: offerer,
+            direction,
+            from: createEvmAccount({
+              address: transfer.from,
+              chainId: chain.id,
+            }),
+            to: createEvmAccount({
+              address: transfer.to,
+              chainId: chain.id,
+            }),
+            asset: transfer.nft,
+            amount: createBigDecimal(transfer.value),
+            price: undefined as Price,
+          })
+          break
+        }
+      }
+    } else if (transfer.type === 'InternalTransaction') {
+      continue
+    } else {
+      return undefined
+    }
+  }
+
+  return {
+    type: 'NormalAction',
+    action: 'trade',
+    evidence: 'contract',
+    timestamp: Number(block.timestamp) * 1000,
+    comment: undefined,
+    app,
+    transfers: mut_offererTransfers,
+  }
+}
+
+const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
+  chain: Chain,
+  { transactionHash }: TransactionDecoded<Price>,
+  accountAddresses: readonly LowerHex[],
+  action: NormalActionTrade<EvmAccount, Price>,
+):
+  | readonly (
+      | AccountActionTrade<EvmAccount, TransactionSource, Price>
+      | AccountActionBuyNft<EvmAccount, TransactionSource, Price>
+      | AccountActionSellNft<EvmAccount, TransactionSource, Price>
+      | AccountActionSwapNft<EvmAccount, TransactionSource, undefined>
+      | AccountActionNftRoyalty<EvmAccount, TransactionSource, Price>
+    )[]
+  | undefined => {
+  const source = `evm_${chain.id}_${toLowerHex(transactionHash)}` as const
+
+  // account address に関係のある transfer を抽出
+  const transfers = action.transfers.filter(
+    (transfer) =>
+      accountAddresses.includes(transfer.from.address) ||
+      accountAddresses.includes(transfer.to.address),
+  )
+
+  if (
+    transfers.some(
+      (transfer) =>
+        accountAddresses.includes(transfer.from.address) &&
+        accountAddresses.includes(transfer.to.address),
+    )
+  ) {
+    // direction: none が含まれる場合は undefined を返す
+    return undefined
+  } else if (
+    transfers.every(
+      (transfer) =>
+        accountAddresses.includes(transfer.to.address) &&
+        transfer.asset.type === 'CryptoCurrency',
+    )
+  ) {
+    // in 側 全て CryptoCurrency / out 側なしの場合は nft-royalty action 作成
+    return transfers.map((transfer) => {
+      if (transfer.asset.type !== 'CryptoCurrency') {
+        throw new Error('invalid transfer')
+      }
+      return {
+        type: 'AccountAction',
+        action: 'nft-royalty',
+        source,
+        evidence: 'contract',
+        timestamp: action.timestamp,
+        order: 0,
+        comment: action.comment,
+        app: action.app,
+        transfers: [
+          {
+            ...transfer,
+            target: transfer.to.address,
+            direction: 'in',
+            asset: transfer.asset,
+          },
+        ],
+      }
+    })
+  } else if (
+    transfers.every((transfer) =>
+      accountAddresses.includes(transfer.from.address),
+    ) ||
+    transfers.every((transfer) =>
+      accountAddresses.includes(transfer.to.address),
+    )
+  ) {
+    // それ以外で in , out のどちらかがからの場合は  undefined を返す
+    return undefined
+  }
+
+  const inTransfers = transfers.filter((transfer) =>
+    accountAddresses.includes(transfer.to.address),
+  )
+  const outTransfers = transfers.filter((transfer) =>
+    accountAddresses.includes(transfer.from.address),
+  )
+
+  // in / out 全て NFT の場合は swap-nft action 作成
+  if (
+    inTransfers.every((transfer) => transfer.asset.type === 'Nft') &&
+    outTransfers.every((transfer) => transfer.asset.type === 'Nft')
+  ) {
+    return [
+      {
+        type: 'AccountAction',
+        action: 'swap-nft',
+        source,
+        evidence: 'contract',
+        timestamp: action.timestamp,
+        order: 0,
+        comment: action.comment,
+        app: action.app,
+        transfers: [
+          ...inTransfers.map((transfer) => {
+            if (transfer.asset.type !== 'Nft') {
+              throw new Error('invalid transfer')
+            }
+            return {
+              ...transfer,
+              target: transfer.to.address,
+              direction: 'in' as const,
+              asset: transfer.asset,
+              price: undefined,
+            }
+          }),
+          ...outTransfers.map((transfer) => {
+            if (transfer.asset.type !== 'Nft') {
+              throw new Error('invalid transfer')
+            }
+            return {
+              ...transfer,
+              target: transfer.from.address,
+              direction: 'out' as const,
+              asset: transfer.asset,
+              price: undefined,
+            }
+          }),
+        ],
+      },
+    ]
+  } else if (
+    inTransfers.every((transfer) => transfer.asset.type === 'Nft') &&
+    outTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency')
+  ) {
+    // in 側全て NFT , out 側全て CryptoCurrency の場合は buy-nft action 作成
+    return [
+      {
+        type: 'AccountAction',
+        action: 'buy-nft',
+        source,
+        evidence: 'contract',
+        timestamp: action.timestamp,
+        order: 0,
+        comment: action.comment,
+        app: action.app,
+        transfers: [
+          ...inTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.to.address,
+            direction: 'in' as const,
+          })),
+          ...outTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.from.address,
+            direction: 'out' as const,
+          })),
+        ],
+      },
+    ]
+  } else if (
+    inTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency') &&
+    outTransfers.every((transfer) => transfer.asset.type === 'Nft')
+  ) {
+    // in 側全て CryptoCurrency , out 側全て NFT の場合は sell-nft action 作成
+    return [
+      {
+        type: 'AccountAction',
+        action: 'sell-nft',
+        source,
+        evidence: 'contract',
+        timestamp: action.timestamp,
+        order: 0,
+        comment: action.comment,
+        app: action.app,
+        transfers: [
+          ...inTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.to.address,
+            direction: 'in' as const,
+          })),
+          ...outTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.from.address,
+            direction: 'out' as const,
+          })),
+        ],
+      },
+    ]
+  } else {
+    // それ以外の場合は trade action 作成
+    return [
+      {
+        type: 'AccountAction',
+        action: 'trade',
+        source,
+        evidence: 'contract',
+        timestamp: action.timestamp,
+        order: 0,
+        comment: action.comment,
+        app: action.app,
+        transfers: [
+          ...inTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.to.address,
+            direction: 'in' as const,
+          })),
+          ...outTransfers.map((transfer) => ({
+            ...transfer,
+            target: transfer.from.address,
+            direction: 'out' as const,
+          })),
+        ],
+      },
+    ]
+  }
+}