@0xtorch/core 0.0.35 → 0.0.37

package/actions/utils/parseBaseAccountActionToAccountAction.ts

@@ -1,1043 +0,0 @@
-import type {
-  AccountActionAddLiquidity,
-  AccountActionApprove,
-  AccountActionAtomicArbitrage,
-  AccountActionBorrow,
-  AccountActionBridgeFrom,
-  AccountActionBridgeTo,
-  AccountActionBuyCrypto,
-  AccountActionBuyNft,
-  AccountActionCrossReplace,
-  AccountActionCrossTrade,
-  AccountActionDeposit,
-  AccountActionDepositWithBond,
-  AccountActionFailTx,
-  AccountActionFee,
-  AccountActionFreeMintNft,
-  AccountActionIgnore,
-  AccountActionIncome,
-  AccountActionMintNft,
-  AccountActionMove,
-  AccountActionNftRoyalty,
-  AccountActionReceiveFromCex,
-  AccountActionReduce,
-  AccountActionRemoveLiquidity,
-  AccountActionRepayment,
-  AccountActionRepaymentWithDebt,
-  AccountActionReplace,
-  AccountActionRevoke,
-  AccountActionSellCrypto,
-  AccountActionSellNft,
-  AccountActionSendToCex,
-  AccountActionSpam,
-  AccountActionStake,
-  AccountActionSwapIncome,
-  AccountActionSwapNft,
-  AccountActionSwapTransfer,
-  AccountActionTrade,
-  AccountActionTransactionFee,
-  AccountActionTransfer,
-  AccountActionUnstake,
-  AccountActionUnwrap,
-  AccountActionValuedown,
-  AccountActionValueup,
-  AccountActionWithdraw,
-  AccountActionWithdrawWithBond,
-  AccountActionWrap,
-  TransferCryptoCurrencyIn,
-  TransferCryptoCurrencyOut,
-  TransferFiatCurrencyIn,
-  TransferFiatCurrencyOut,
-  TransferNftIn,
-  TransferNftOut,
-} from '../types'
-import type { AccountAction, BaseAccountAction } from '../types/action'
-import {
-  isTransferCryptoCurrencyIn,
-  isTransferCryptoCurrencyOut,
-  isTransferFiatCurrencyIn,
-  isTransferFiatCurrencyOut,
-  isTransferNftIn,
-  isTransferNftOut,
-} from './transfer'
-
-export const parseBaseAccountActionToAccountAction = (
-  action: BaseAccountAction,
-): AccountAction => {
-  switch (action.action) {
-    case 'add-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 add-liquidity')
-      }
-      if (action.loanId === undefined) {
-        throw new Error('action.loandId is required for add-liquidity')
-      }
-      return {
-        ...action,
-        type: 'LoanAccountAction',
-        action: 'add-liquidity',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionAddLiquidity
-    }
-    case 'approve': {
-      if (action.transfers.length > 0) {
-        throw new Error('Invalid action.transfers for approve')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'approve',
-        transfers: [],
-      } satisfies AccountActionApprove
-    }
-    case 'atomic-arbitrage': {
-      // 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 atomic-arbitrage')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'atomic-arbitrage',
-        transfers,
-      } satisfies AccountActionAtomicArbitrage
-    }
-    case 'borrow': {
-      // 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 borrow')
-      }
-      if (action.loanId === undefined) {
-        throw new Error('action.loandId is required for borrow')
-      }
-      return {
-        ...action,
-        type: 'LoanAccountAction',
-        action: 'borrow',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionBorrow
-    }
-    case 'bridge-from': {
-      // 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 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: 'CrossAccountAction',
-        action: 'bridge-from',
-        crossId: action.crossId,
-        crossType: action.crossType,
-        transfers,
-      } satisfies AccountActionBridgeFrom
-    }
-    case 'bridge-to': {
-      // 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 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: 'CrossAccountAction',
-        action: 'bridge-to',
-        crossId: action.crossId,
-        crossType: action.crossType,
-        transfers,
-      } satisfies AccountActionBridgeTo
-    }
-    case 'buy-crypto': {
-      // transferCryptoCurrencyInSchema, transferFiatCurrencyOutSchema
-      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: 'NormalAccountAction',
-        action: 'buy-crypto',
-        transfers,
-      } satisfies AccountActionBuyCrypto
-    }
-    case 'buy-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 buy-nft')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'buy-nft',
-        transfers,
-      } satisfies AccountActionBuyNft
-    }
-    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: 'CrossAccountAction',
-        action: 'cross-replace',
-        crossId: action.crossId,
-        crossType: action.crossType,
-        transfers,
-      } satisfies AccountActionCrossReplace
-    }
-    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: 'CrossAccountAction',
-        action: 'cross-trade',
-        crossId: action.crossId,
-        crossType: action.crossType,
-        transfers,
-      } satisfies AccountActionCrossTrade
-    }
-    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: 'LoanAccountAction',
-        action: 'deposit',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionDeposit
-    }
-    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: 'LoanAccountAction',
-        action: 'deposit-with-bond',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionDepositWithBond
-    }
-    case 'fail-tx': {
-      if (action.transfers.length > 0) {
-        throw new Error('Invalid action.transfers for fail-tx')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'fail-tx',
-        transfers: [],
-      } satisfies AccountActionFailTx
-    }
-    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: 'NormalAccountAction',
-        action: 'fee',
-        transfers,
-      } satisfies AccountActionFee
-    }
-    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: 'NormalAccountAction',
-        action: 'free-mint-nft',
-        transfers,
-      } satisfies AccountActionFreeMintNft
-    }
-    case 'ignore': {
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'ignore',
-        transfers: [...action.transfers],
-      } satisfies AccountActionIgnore
-    }
-    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: 'NormalAccountAction',
-        action: 'income',
-        transfers,
-      } satisfies AccountActionIncome
-    }
-    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: 'NormalAccountAction',
-        action: 'mint-nft',
-        transfers,
-      } satisfies AccountActionMintNft
-    }
-    case 'move': {
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'move',
-        transfers: [...action.transfers],
-      } satisfies AccountActionMove
-    }
-    case 'nft-royalty': {
-      // transferCryptoCurrencyInSchema, transferFiatCurrencyInSchema
-      const transfers = action.transfers.filter(
-        (
-          transfer,
-        ): transfer is TransferCryptoCurrencyIn | TransferFiatCurrencyIn =>
-          isTransferCryptoCurrencyIn(transfer) ||
-          isTransferFiatCurrencyIn(transfer),
-      )
-      if (transfers.length !== action.transfers.length) {
-        throw new Error('Invalid action.transfers for nft-royalty')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'nft-royalty',
-        transfers,
-      } satisfies AccountActionNftRoyalty
-    }
-    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: 'NormalAccountAction',
-        action: 'receive-from-cex',
-        transfers,
-      } satisfies AccountActionReceiveFromCex
-    }
-    case 'reduce': {
-      // 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 reduce')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'reduce',
-        transfers,
-      } satisfies AccountActionReduce
-    }
-    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: 'LoanAccountAction',
-        action: 'remove-liquidity',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionRemoveLiquidity
-    }
-    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: 'LoanAccountAction',
-        action: 'repayment',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionRepayment
-    }
-    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: 'LoanAccountAction',
-        action: 'repayment-with-debt',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionRepaymentWithDebt
-    }
-    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: 'NormalAccountAction',
-        action: 'replace',
-        transfers,
-      } satisfies AccountActionReplace
-    }
-    case 'revoke': {
-      if (action.transfers.length > 0) {
-        throw new Error('Invalid action.transfers for revoke')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'revoke',
-        transfers: [],
-      } satisfies AccountActionRevoke
-    }
-    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: 'NormalAccountAction',
-        action: 'sell-crypto',
-        transfers,
-      } satisfies AccountActionSellCrypto
-    }
-    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: 'NormalAccountAction',
-        action: 'sell-nft',
-        transfers,
-      } satisfies AccountActionSellNft
-    }
-    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: 'NormalAccountAction',
-        action: 'send-to-cex',
-        transfers,
-      } satisfies AccountActionSendToCex
-    }
-    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: 'NormalAccountAction',
-        action: 'spam',
-        transfers,
-      } satisfies AccountActionSpam
-    }
-    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: 'LoanAccountAction',
-        action: 'stake',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionStake
-    }
-    case 'swap-income': {
-      // 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 swap-income')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'swap-income',
-        transfers,
-      } satisfies AccountActionSwapIncome
-    }
-    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: 'NormalAccountAction',
-        action: 'swap-nft',
-        transfers,
-      } satisfies AccountActionSwapNft
-    }
-    case 'swap-transfer': {
-      // 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 swap-transfer')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'swap-transfer',
-        transfers,
-      } satisfies AccountActionSwapTransfer
-    }
-    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: 'NormalAccountAction',
-        action: 'trade',
-        transfers,
-      } satisfies AccountActionTrade
-    }
-    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: 'NormalAccountAction',
-        action: 'transaction-fee',
-        transfers,
-      } satisfies AccountActionTransactionFee
-    }
-    case 'transfer': {
-      // transferOutSchema
-      const transfers = action.transfers.filter(
-        (
-          transfer,
-        ): transfer is
-          | TransferCryptoCurrencyOut
-          | TransferNftOut
-          | TransferFiatCurrencyOut =>
-          isTransferCryptoCurrencyOut(transfer) ||
-          isTransferNftOut(transfer) ||
-          isTransferFiatCurrencyOut(transfer),
-      )
-      if (transfers.length !== action.transfers.length) {
-        throw new Error('Invalid action.transfers for transfer')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'transfer',
-        transfers,
-      } satisfies AccountActionTransfer
-    }
-    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: 'LoanAccountAction',
-        action: 'unstake',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionUnstake
-    }
-    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: 'NormalAccountAction',
-        action: 'unwrap',
-        transfers,
-      } satisfies AccountActionUnwrap
-    }
-    case 'valuedown': {
-      // 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 valuedown')
-      }
-      if (action.target === undefined) {
-        throw new Error('action.target is required for valuedown')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'valuedown',
-        target: action.target,
-        transfers,
-      } satisfies AccountActionValuedown
-    }
-    case 'valueup': {
-      // transferOutSchema
-      const transfers = action.transfers.filter(
-        (
-          transfer,
-        ): transfer is
-          | TransferCryptoCurrencyOut
-          | TransferNftOut
-          | TransferFiatCurrencyOut =>
-          isTransferCryptoCurrencyOut(transfer) ||
-          isTransferNftOut(transfer) ||
-          isTransferFiatCurrencyOut(transfer),
-      )
-      if (transfers.length !== action.transfers.length) {
-        throw new Error('Invalid action.transfers for valueup')
-      }
-      if (action.target === undefined) {
-        throw new Error('action.target is required for valueup')
-      }
-      return {
-        ...action,
-        type: 'NormalAccountAction',
-        action: 'valueup',
-        target: action.target,
-        transfers,
-      } satisfies AccountActionValueup
-    }
-    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: 'LoanAccountAction',
-        action: 'withdraw',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionWithdraw
-    }
-    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: 'LoanAccountAction',
-        action: 'withdraw-with-bond',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionWithdrawWithBond
-    }
-    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: 'NormalAccountAction',
-        action: 'wrap',
-        transfers,
-      } satisfies AccountActionWrap
-    }
-  }
-}