@0xtorch/evm 0.0.11 → 0.0.13

package/analyzer/json/generator.ts

@@ -0,0 +1,1184 @@
+import type {
+  CryptoCurrencyPrice,
+  NormalAction,
+  NormalActionAddLiquidity,
+  NormalActionApprove,
+  NormalActionAtomicArbitrage,
+  NormalActionBorrow,
+  NormalActionBorrowWithDebt,
+  NormalActionBridgeFrom,
+  NormalActionBridgeTo,
+  NormalActionBuyCrypto,
+  NormalActionBuyNft,
+  NormalActionCrossReplace,
+  NormalActionCrossTrade,
+  NormalActionDeposit,
+  NormalActionDepositWithBond,
+  NormalActionFailTx,
+  NormalActionFee,
+  NormalActionFreeMintNft,
+  NormalActionIncome,
+  NormalActionMintNft,
+  NormalActionReceiveFromCex,
+  NormalActionRemoveLiquidity,
+  NormalActionRepayment,
+  NormalActionRepaymentWithDebt,
+  NormalActionReplace,
+  NormalActionRevoke,
+  NormalActionSellCrypto,
+  NormalActionSellNft,
+  NormalActionSendToCex,
+  NormalActionSpam,
+  NormalActionStake,
+  NormalActionSwapNft,
+  NormalActionTrade,
+  NormalActionTransactionFee,
+  NormalActionTransfer,
+  NormalActionUnstake,
+  NormalActionUnwrap,
+  NormalActionWithdraw,
+  NormalActionWithdrawWithBond,
+  NormalActionWrap,
+  Transfer,
+  TransferCryptoCurrencyIn,
+  TransferCryptoCurrencyOut,
+  TransferFiatCurrencyIn,
+  TransferFiatCurrencyOut,
+  TransferNftIn,
+  TransferNftOut,
+} from '@0xtorch/core'
+import {
+  isTransferCryptoCurrencyIn,
+  isTransferCryptoCurrencyOut,
+  isTransferFiatCurrencyIn,
+  isTransferFiatCurrencyOut,
+  isTransferNftIn,
+  isTransferNftOut,
+} from '@0xtorch/core'
+import type { Chain } from '../../chains'
+import type {
+  Erc1155Transfer,
+  Erc20Transfer,
+  Erc721Transfer,
+  InternalTransaction,
+  LogData,
+  TransactionDecoded,
+} from '../../types'
+import { createCommentByCommentComponent } from './components/comment'
+import { isMatchErc1155Component } from './components/erc1155'
+import { isMatchErc20Component } from './components/erc20'
+import { isMatchErc721Component } from './components/erc721'
+import { createIdByIdComponent } from './components/id'
+import { isMatchInternalComponent } from './components/internal'
+import { isMatchLogArgumentComponent } from './components/logArgument'
+import { createTransfersByTransferComponent } from './components/transfer'
+import type { ActionGenerator } from './types'
+
+type GenerateActionsByGeneratorParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly generator: ActionGenerator
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded<Price>
+}
+
+type Target<Price extends CryptoCurrencyPrice | undefined> = {
+  readonly targetsErc20?: readonly Erc20Transfer<Price>[]
+  readonly targetsErc721?: readonly Erc721Transfer[]
+  readonly targetsErc1155?: readonly Erc1155Transfer[]
+  readonly targetsInternal?: readonly InternalTransaction<Price>[]
+  readonly targetsLog?: readonly LogData[]
+}
+
+export const generateActionsByGenerator = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  generator,
+  chain,
+  transaction,
+}: GenerateActionsByGeneratorParameters<Price>): NormalAction[] => {
+  const { target } = generator
+  // target=undefined の場合は単一 action 生成
+  if (target === undefined) {
+    return [
+      generateActionByGeneratorWithTargets({
+        generator,
+        chain,
+        transaction,
+      }),
+    ]
+  }
+
+  // target が undefined でない場合は target 毎に action 生成
+  const mut_erc20Transfers = [...transaction.erc20Transfers]
+  const mut_erc721Transfers = [...transaction.erc721Transfers]
+  const mut_erc1155Transfers = [...transaction.erc1155Transfers]
+  const mut_internalTransactions = [...transaction.internalTransactions]
+  const mut_logs = [...transaction.logs]
+  const mut_targets: Target<Price>[] = []
+  let repeat = true
+  while (repeat) {
+    const mut_targetsErc20: Erc20Transfer<Price>[] = []
+    const mut_targetsErc721: Erc721Transfer[] = []
+    const mut_targetsErc1155: Erc1155Transfer[] = []
+    const mut_targetsInternal: InternalTransaction<Price>[] = []
+    const mut_targetsLog: LogData[] = []
+    for (const component of target) {
+      switch (component.type) {
+        case 'erc20': {
+          const erc20Index = mut_erc20Transfers.findIndex((transfer) =>
+            isMatchErc20Component({
+              component: {
+                ...component,
+                index: 0,
+              },
+              transfer,
+              transaction,
+            }),
+          )
+          if (erc20Index === -1) {
+            repeat = false
+            break
+          }
+          mut_targetsErc20.push(mut_erc20Transfers[erc20Index])
+          mut_erc20Transfers.splice(erc20Index, 1)
+          break
+        }
+        case 'erc721': {
+          const erc721Index = mut_erc721Transfers.findIndex((transfer) =>
+            isMatchErc721Component({
+              component: {
+                ...component,
+                index: 0,
+              },
+              transfer,
+              transaction,
+            }),
+          )
+          if (erc721Index === -1) {
+            repeat = false
+            break
+          }
+          mut_targetsErc721.push(mut_erc721Transfers[erc721Index])
+          mut_erc721Transfers.splice(erc721Index, 1)
+          break
+        }
+        case 'erc1155': {
+          const erc1155Index = mut_erc1155Transfers.findIndex((transfer) =>
+            isMatchErc1155Component({
+              component: {
+                ...component,
+                index: 0,
+              },
+              transfer,
+              transaction,
+            }),
+          )
+          if (erc1155Index === -1) {
+            repeat = false
+            break
+          }
+          mut_targetsErc1155.push(mut_erc1155Transfers[erc1155Index])
+          mut_erc1155Transfers.splice(erc1155Index, 1)
+          break
+        }
+        case 'internal': {
+          const internalIndex = mut_internalTransactions.findIndex((internal) =>
+            isMatchInternalComponent({
+              component: {
+                ...component,
+                index: 0,
+              },
+              internal,
+              transaction,
+            }),
+          )
+          if (internalIndex === -1) {
+            repeat = false
+            break
+          }
+          mut_targetsInternal.push(mut_internalTransactions[internalIndex])
+          mut_internalTransactions.splice(internalIndex, 1)
+          break
+        }
+        case 'log': {
+          const logIndex = mut_logs.findIndex((log) =>
+            isMatchLogArgumentComponent({
+              component: {
+                ...component,
+                index: 0,
+                argIndex: 0,
+                valueType: 'other',
+              },
+              log,
+              transaction,
+            }),
+          )
+          if (logIndex === -1) {
+            repeat = false
+            break
+          }
+          mut_targetsLog.push(mut_logs[logIndex])
+          mut_logs.splice(logIndex, 1)
+          break
+        }
+      }
+      if (!repeat) {
+        break
+      }
+    }
+    if (!repeat) {
+      break
+    }
+    mut_targets.push({
+      targetsErc20: mut_targetsErc20,
+      targetsErc721: mut_targetsErc721,
+      targetsErc1155: mut_targetsErc1155,
+      targetsInternal: mut_targetsInternal,
+      targetsLog: mut_targetsLog,
+    })
+  }
+
+  const actions = mut_targets.map((target) =>
+    generateActionByGeneratorWithTargets({
+      generator,
+      chain,
+      transaction,
+      ...target,
+    }),
+  )
+  return actions
+}
+
+type GenerateActionsByGeneratorWithTargetsParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = GenerateActionsByGeneratorParameters<Price> & Target<Price>
+
+type BaseAction = Omit<NormalAction, 'transfers' | 'crossId' | 'loanId'> & {
+  readonly transfers: readonly Transfer[]
+  readonly crossId: string | undefined
+  readonly crossType: 'start' | 'middle' | 'end' | undefined
+  readonly loanId: string | undefined
+}
+
+const generateActionByGeneratorWithTargets = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  generator,
+  chain,
+  transaction,
+  targetsErc20,
+  targetsErc721,
+  targetsErc1155,
+  targetsInternal,
+  targetsLog,
+}: GenerateActionsByGeneratorWithTargetsParameters<Price>): NormalAction => {
+  // generator に基づいて action 生成
+  const action: BaseAction = {
+    type: 'NormalAction',
+    action: generator.action,
+    evidence: 'contract',
+    timestamp: Number(transaction.block.timestamp) * 1000,
+    comment:
+      generator.comment === undefined
+        ? undefined
+        : generator.comment
+            .map((component) =>
+              createCommentByCommentComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+              }),
+            )
+            .join(''),
+    app: transaction.app,
+    transfers: generator.transfers.flatMap((component) =>
+      createTransfersByTransferComponent({
+        component,
+        transaction,
+        chain,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      }),
+    ),
+    crossId:
+      generator.crossId === undefined
+        ? undefined
+        : generator.crossId
+            .map((component) =>
+              createIdByIdComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+              }),
+            )
+            .join(''),
+    crossType: generator.crossType,
+    loanId:
+      generator.loanId === undefined
+        ? undefined
+        : generator.loanId
+            .map((component) =>
+              createIdByIdComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+              }),
+            )
+            .join(''),
+  }
+
+  switch (action.action) {
+    case 'add-liquidity': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for add-liquidity')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for add-liquidity')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'add-liquidity',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionAddLiquidity
+    }
+    case 'approve': {
+      if (action.transfers.length > 0) {
+        throw new Error('Invalid action.transfers for approve')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'approve',
+        transfers: [],
+      } satisfies NormalActionApprove
+    }
+    case 'atomic-arbitrage': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyIn | TransferCryptoCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for atomic-arbitrage')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'atomic-arbitrage',
+        transfers,
+      } satisfies NormalActionAtomicArbitrage
+    }
+    case 'borrow': {
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for borrow')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for borrow')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'borrow',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionBorrow
+    }
+    case 'borrow-with-debt': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for borrow-with-debt')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for borrow-with-debt')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'borrow-with-debt',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionBorrowWithDebt
+    }
+    case 'bridge-from': {
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for bridge-from')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for bridge-from')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for bridge-from')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'bridge-from',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionBridgeFrom
+    }
+    case 'bridge-to': {
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for bridge-to')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for bridge-to')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for bridge-to')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'bridge-to',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionBridgeTo
+    }
+    case 'buy-crypto': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyIn | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for buy-crypto')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'buy-crypto',
+        transfers,
+      } satisfies NormalActionBuyCrypto
+    }
+    case 'buy-nft': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferNftIn
+          | TransferFiatCurrencyOut
+          | TransferCryptoCurrencyOut =>
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyOut(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for buy-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'buy-nft',
+        transfers,
+      } satisfies NormalActionBuyNft
+    }
+    case 'cross-replace': {
+      // transferInSchema, transferOutSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferFiatCurrencyIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut
+          | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for cross-replace')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for cross-replace')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for cross-replace')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'cross-replace',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionCrossReplace
+    }
+    case 'deposit': {
+      // transferCryptoCurrencyOutSchema, transferNftOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for deposit')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for deposit')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'deposit',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionDeposit
+    }
+    case 'cross-trade': {
+      // transferInSchema, transferOutSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferFiatCurrencyIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut
+          | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for cross-trade')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for cross-trade')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for cross-trade')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'cross-trade',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionCrossTrade
+    }
+    case 'deposit-with-bond': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for deposit-with-bond')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for deposit-with-bond')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'deposit-with-bond',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionDepositWithBond
+    }
+    case 'fail-tx': {
+      if (action.transfers.length > 0) {
+        throw new Error('Invalid action.transfers for fail-tx')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'fail-tx',
+        transfers: [],
+      } satisfies NormalActionFailTx
+    }
+    case 'fee': {
+      // transferCryptoCurrencyOutSchema, transferFiatCurrencyOutSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyOut | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for fee')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'fee',
+        transfers,
+      } satisfies NormalActionFee
+    }
+    case 'free-mint-nft': {
+      // transferNftInSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferNftIn => isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for free-mint-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'free-mint-nft',
+        transfers,
+      } satisfies NormalActionFreeMintNft
+    }
+    case 'income': {
+      // transferInSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferFiatCurrencyIn =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for income')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'income',
+        transfers,
+      } satisfies NormalActionIncome
+    }
+    case 'mint-nft': {
+      // transferNftInSchema,
+      // transferFiatCurrencyOutSchema,
+      // transferCryptoCurrencyOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferNftIn
+          | TransferFiatCurrencyOut
+          | TransferCryptoCurrencyOut =>
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyOut(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for mint-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'mint-nft',
+        transfers,
+      } satisfies NormalActionMintNft
+    }
+    case 'receive-from-cex': {
+      // transferCryptoCurrencyInSchema, transferNftInSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for receive-from-cex')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'receive-from-cex',
+        transfers,
+      } satisfies NormalActionReceiveFromCex
+    }
+    case 'remove-liquidity': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for remove-liquidity')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for remove-liquidity')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'remove-liquidity',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionRemoveLiquidity
+    }
+    case 'repayment': {
+      // transferCryptoCurrencyOutSchema, transferNftOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for repayment')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for repayment')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'repayment',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionRepayment
+    }
+    case 'repayment-with-debt': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for repayment-with-debt')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for repayment-with-debt')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'repayment-with-debt',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionRepaymentWithDebt
+    }
+    case 'replace': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for replace')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'replace',
+        transfers,
+      } satisfies NormalActionReplace
+    }
+    case 'revoke': {
+      if (action.transfers.length > 0) {
+        throw new Error('Invalid action.transfers for revoke')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'revoke',
+        transfers: [],
+      } satisfies NormalActionRevoke
+    }
+    case 'sell-crypto': {
+      // transferFiatCurrencyInSchema, transferCryptoCurrencyOutSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferFiatCurrencyIn | TransferCryptoCurrencyOut =>
+          isTransferFiatCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for sell-crypto')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'sell-crypto',
+        transfers,
+      } satisfies NormalActionSellCrypto
+    }
+    case 'sell-nft': {
+      // transferFiatCurrencyInSchema,
+      // transferCryptoCurrencyInSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferFiatCurrencyIn
+          | TransferCryptoCurrencyIn
+          | TransferNftOut =>
+          isTransferFiatCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for sell-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'sell-nft',
+        transfers,
+      } satisfies NormalActionSellNft
+    }
+    case 'send-to-cex': {
+      // transferCryptoCurrencyOutSchema, transferNftOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for send-to-cex')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'send-to-cex',
+        transfers,
+      } satisfies NormalActionSendToCex
+    }
+    case 'spam': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for spam')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'spam',
+        transfers,
+      } satisfies NormalActionSpam
+    }
+    case 'stake': {
+      // transferCryptoCurrencyOutSchema, transferNftOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for stake')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for stake')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'stake',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionStake
+    }
+    case 'swap-nft': {
+      // transferNftInSchema, transferNftOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferNftIn | TransferNftOut =>
+          isTransferNftIn(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for swap-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'swap-nft',
+        transfers,
+      } satisfies NormalActionSwapNft
+    }
+    case 'trade': {
+      // transferInSchema, transferOutSchema
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferFiatCurrencyIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut
+          | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for trade')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'trade',
+        transfers,
+      } satisfies NormalActionTrade
+    }
+    case 'transaction-fee': {
+      // transferCryptoCurrencyOutSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut =>
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for transaction-fee')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'transaction-fee',
+        transfers,
+      } satisfies NormalActionTransactionFee
+    }
+    case 'transfer': {
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'transfer',
+        transfers: [...action.transfers],
+      } satisfies NormalActionTransfer
+    }
+    case 'unstake': {
+      // transferCryptoCurrencyInSchema, transferNftInSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for unstake')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for unstake')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'unstake',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionUnstake
+    }
+    case 'unwrap': {
+      // transferCryptoCurrencyInSchema,
+      // transferCryptoCurrencyOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyIn | TransferCryptoCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for unwrap')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'unwrap',
+        transfers,
+      } satisfies NormalActionUnwrap
+    }
+    case 'wrap': {
+      // transferCryptoCurrencyInSchema,
+      // transferCryptoCurrencyOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyIn | TransferCryptoCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for wrap')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'wrap',
+        transfers,
+      } satisfies NormalActionWrap
+    }
+    case 'valuedown': {
+      // TODO asset の指定を可能にする
+      throw new Error('Not implemented for valuedown')
+    }
+    case 'valueup': {
+      // TODO
+      throw new Error('Not implemented for valueup')
+    }
+    case 'withdraw': {
+      // transferCryptoCurrencyInSchema, transferNftInSchema
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for withdraw')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for withdraw')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'withdraw',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionWithdraw
+    }
+    case 'withdraw-with-bond': {
+      // transferCryptoCurrencyInSchema,
+      // transferNftInSchema,
+      // transferCryptoCurrencyOutSchema,
+      // transferNftOutSchema,
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for withdraw-with-bond')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for withdraw-with-bond')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'withdraw-with-bond',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionWithdrawWithBond
+    }
+  }
+}