@0xtorch/core 0.0.29 → 0.0.31

package/actions/utils/parseBaseNormalActionToNormalAction.ts

@@ -0,0 +1,874 @@
+import type {
+  NormalActionAddLiquidity,
+  NormalActionApprove,
+  NormalActionAtomicArbitrage,
+  NormalActionBorrow,
+  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,
+  NormalActionValuedown,
+  NormalActionValueup,
+  NormalActionWithdraw,
+  NormalActionWithdrawWithBond,
+  NormalActionWrap,
+  TransferCryptoCurrencyIn,
+  TransferCryptoCurrencyOut,
+  TransferFiatCurrencyIn,
+  TransferFiatCurrencyOut,
+  TransferNftIn,
+  TransferNftOut,
+} from '../types'
+import type { BaseNormalAction, NormalAction } from '../types/action'
+import {
+  isTransferCryptoCurrencyIn,
+  isTransferCryptoCurrencyOut,
+  isTransferFiatCurrencyIn,
+  isTransferFiatCurrencyOut,
+  isTransferNftIn,
+  isTransferNftOut,
+} from './transfer'
+
+export const parseBaseNormalActionToNormalAction = (
+  action: BaseNormalAction,
+): NormalAction => {
+  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 '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': {
+      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 'cross-trade': {
+      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': {
+      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 'deposit-with-bond': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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': {
+      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 'transaction-fee': {
+      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 'trade': {
+      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 'transfer': {
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'transfer',
+        transfers: [...action.transfers],
+      } satisfies NormalActionTransfer
+    }
+    case 'unstake': {
+      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': {
+      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 'valuedown': {
+      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: 'NormalAction',
+        action: 'valuedown',
+        target: action.target,
+        transfers,
+      } satisfies NormalActionValuedown
+    }
+    case 'valueup': {
+      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: 'NormalAction',
+        action: 'valueup',
+        target: action.target,
+        transfers,
+      } satisfies NormalActionValueup
+    }
+    case 'withdraw': {
+      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': {
+      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
+    }
+    case 'wrap': {
+      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
+    }
+  }
+}