@0xtorch/core 0.0.14 → 0.0.16

package/actions/utils.ts

@@ -1,4 +1,90 @@
 import type {
+  AccountActionAddLiquidity,
+  AccountActionApprove,
+  AccountActionAtomicArbitrage,
+  AccountActionBorrow,
+  AccountActionBorrowWithDebt,
+  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,
+  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,
+  NormalActionValuedown,
+  NormalActionValueup,
+  NormalActionWithdraw,
+  NormalActionWithdrawWithBond,
+  NormalActionWrap,
   Transfer,
   TransferCryptoCurrencyIn,
   TransferCryptoCurrencyNone,
@@ -10,6 +96,12 @@ import type {
   TransferNftNone,
   TransferNftOut,
 } from './types'
+import type {
+  AccountAction,
+  BaseAccountAction,
+  BaseNormalAction,
+  NormalAction,
+} from './types/action'
 
 export const isTransferCryptoCurrencyIn = (
   transfer: Transfer,
@@ -55,3 +147,1862 @@ export const isTransferFiatCurrencyNone = (
   transfer: Transfer,
 ): transfer is TransferFiatCurrencyNone =>
   transfer.direction === 'none' && transfer.asset.type === 'FiatCurrency'
+
+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 'borrow-with-debt': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferCryptoCurrencyIn
+          | TransferNftIn
+          | TransferCryptoCurrencyOut
+          | TransferNftOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferNftIn(transfer) ||
+          isTransferCryptoCurrencyOut(transfer) ||
+          isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for borrow-with-debt')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for borrow-with-debt')
+      }
+      return {
+        ...action,
+        type: 'LoanNormalAction',
+        action: 'borrow-with-debt',
+        loanId: action.loanId,
+        transfers,
+      } satisfies NormalActionBorrowWithDebt
+    }
+    case 'bridge-from': {
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
+          isTransferCryptoCurrencyOut(transfer) || isTransferNftOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for bridge-from')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for bridge-from')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for bridge-from')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'bridge-from',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionBridgeFrom
+    }
+    case 'bridge-to': {
+      const transfers = action.transfers.filter(
+        (transfer): transfer is TransferCryptoCurrencyIn | TransferNftIn =>
+          isTransferCryptoCurrencyIn(transfer) || isTransferNftIn(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for bridge-to')
+      }
+      if (action.crossId === undefined) {
+        throw new Error('action.crossId is required for bridge-to')
+      }
+      if (action.crossType === undefined) {
+        throw new Error('action.crossType is required for bridge-to')
+      }
+      return {
+        ...action,
+        type: 'CrossNormalAction',
+        action: 'bridge-to',
+        crossId: action.crossId,
+        crossType: action.crossType,
+        transfers,
+      } satisfies NormalActionBridgeTo
+    }
+    case 'buy-crypto': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is TransferCryptoCurrencyIn | TransferFiatCurrencyOut =>
+          isTransferCryptoCurrencyIn(transfer) ||
+          isTransferFiatCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for buy-crypto')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'buy-crypto',
+        transfers,
+      } satisfies NormalActionBuyCrypto
+    }
+    case 'buy-nft': {
+      const transfers = action.transfers.filter(
+        (
+          transfer,
+        ): transfer is
+          | TransferNftIn
+          | TransferFiatCurrencyOut
+          | TransferCryptoCurrencyOut =>
+          isTransferNftIn(transfer) ||
+          isTransferFiatCurrencyOut(transfer) ||
+          isTransferCryptoCurrencyOut(transfer),
+      )
+      if (transfers.length !== action.transfers.length) {
+        throw new Error('Invalid action.transfers for buy-nft')
+      }
+      return {
+        ...action,
+        type: 'NormalAction',
+        action: 'buy-nft',
+        transfers,
+      } satisfies NormalActionBuyNft
+    }
+    case 'cross-replace': {
+      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
+    }
+  }
+}
+
+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 'borrow-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 borrow-with-debt')
+      }
+      if (action.loanId === undefined) {
+        throw new Error('action.loandId is required for borrow-with-debt')
+      }
+      return {
+        ...action,
+        type: 'LoanAccountAction',
+        action: 'borrow-with-debt',
+        loanId: action.loanId,
+        transfers,
+      } satisfies AccountActionBorrowWithDebt
+    }
+    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
+    }
+  }
+}