@0xtorch/core 0.0.30 → 0.0.31

package/actions/{utils.ts → utils/parseBaseAccountActionToAccountAction.ts}

@@ -44,925 +44,22 @@ import type {
   AccountActionWithdraw,
   AccountActionWithdrawWithBond,
   AccountActionWrap,
-  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,
-  Transfer,
   TransferCryptoCurrencyIn,
-  TransferCryptoCurrencyNone,
   TransferCryptoCurrencyOut,
   TransferFiatCurrencyIn,
-  TransferFiatCurrencyNone,
   TransferFiatCurrencyOut,
   TransferNftIn,
-  TransferNftNone,
   TransferNftOut,
-} from './types'
-import type {
-  AccountAction,
-  BaseAccountAction,
-  BaseNormalAction,
-  NormalAction,
-} from './types/action'
-
-export const isTransferCryptoCurrencyIn = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferCryptoCurrencyOut = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferCryptoCurrencyNone = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyNone =>
-  transfer.direction === 'none' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferNftIn = (
-  transfer: Transfer,
-): transfer is TransferNftIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'Nft'
-
-export const isTransferNftOut = (
-  transfer: Transfer,
-): transfer is TransferNftOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'Nft'
-
-export const isTransferNftNone = (
-  transfer: Transfer,
-): transfer is TransferNftNone =>
-  transfer.direction === 'none' && transfer.asset.type === 'Nft'
-
-export const isTransferFiatCurrencyIn = (
-  transfer: Transfer,
-): transfer is TransferFiatCurrencyIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'FiatCurrency'
-
-export const isTransferFiatCurrencyOut = (
-  transfer: Transfer,
-): transfer is TransferFiatCurrencyOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'FiatCurrency'
-
-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 '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
-    }
-  }
-}
+} from '../types'
+import type { AccountAction, BaseAccountAction } from '../types/action'
+import {
+  isTransferCryptoCurrencyIn,
+  isTransferCryptoCurrencyOut,
+  isTransferFiatCurrencyIn,
+  isTransferFiatCurrencyOut,
+  isTransferNftIn,
+  isTransferNftOut,
+} from './transfer'
 
 export const parseBaseAccountActionToAccountAction = (
   action: BaseAccountAction,