@0xtorch/evm 0.0.12 → 0.0.14

package/analyzer/json/generator.ts

@@ -1,60 +1,9 @@
 import type {
+  BaseNormalAction,
   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 { parseBaseNormalActionToNormalAction } from '@0xtorch/core'
 import type { Chain } from '../../chains'
 import type {
   Erc1155Transfer,
@@ -254,12 +203,6 @@ 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 loanId: string | undefined
-}
-
 const generateActionByGeneratorWithTargets = <
   Price extends CryptoCurrencyPrice | undefined,
 >({
@@ -273,8 +216,7 @@ const generateActionByGeneratorWithTargets = <
   targetsLog,
 }: GenerateActionsByGeneratorWithTargetsParameters<Price>): NormalAction => {
   // generator に基づいて action 生成
-  const action: BaseAction = {
-    type: 'NormalAction',
+  const action: BaseNormalAction = {
     action: generator.action,
     evidence: 'contract',
     timestamp: Number(transaction.block.timestamp) * 1000,
@@ -317,6 +259,7 @@ const generateActionByGeneratorWithTargets = <
               }),
             )
             .join(''),
+    crossType: generator.crossType,
     loanId:
       generator.loanId === undefined
         ? undefined
@@ -330,837 +273,9 @@ const generateActionByGeneratorWithTargets = <
               }),
             )
             .join(''),
+    // TODO target を生成できるようにする
+    target: undefined,
   }
 
-  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')
-      }
-      return {
-        ...action,
-        type: 'CrossNormalAction',
-        action: 'bridge-from',
-        crossId: action.crossId,
-        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')
-      }
-      return {
-        ...action,
-        type: 'CrossNormalAction',
-        action: 'bridge-to',
-        crossId: action.crossId,
-        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')
-      }
-      return {
-        ...action,
-        type: 'CrossNormalAction',
-        action: 'cross-replace',
-        crossId: action.crossId,
-        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')
-      }
-      return {
-        ...action,
-        type: 'CrossNormalAction',
-        action: 'cross-trade',
-        crossId: action.crossId,
-        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
-    }
-  }
+  return parseBaseNormalActionToNormalAction(action)
 }