@0xtorch/core 0.0.15 → 0.0.17

package/_cjs/actions/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTransferFiatCurrencyNone = exports.isTransferFiatCurrencyOut = exports.isTransferFiatCurrencyIn = exports.isTransferNftNone = exports.isTransferNftOut = exports.isTransferNftIn = exports.isTransferCryptoCurrencyNone = exports.isTransferCryptoCurrencyOut = exports.isTransferCryptoCurrencyIn = void 0;
+exports.parseBaseAccountActionToAccountAction = exports.parseBaseNormalActionToNormalAction = exports.isTransferFiatCurrencyNone = exports.isTransferFiatCurrencyOut = exports.isTransferFiatCurrencyIn = exports.isTransferNftNone = exports.isTransferNftOut = exports.isTransferNftIn = exports.isTransferCryptoCurrencyNone = exports.isTransferCryptoCurrencyOut = exports.isTransferCryptoCurrencyIn = void 0;
 const isTransferCryptoCurrencyIn = (transfer) => transfer.direction === 'in' && transfer.asset.type === 'CryptoCurrency';
 exports.isTransferCryptoCurrencyIn = isTransferCryptoCurrencyIn;
 const isTransferCryptoCurrencyOut = (transfer) => transfer.direction === 'out' && transfer.asset.type === 'CryptoCurrency';
@@ -19,4 +19,1321 @@ const isTransferFiatCurrencyOut = (transfer) => transfer.direction === 'out' &&
 exports.isTransferFiatCurrencyOut = isTransferFiatCurrencyOut;
 const isTransferFiatCurrencyNone = (transfer) => transfer.direction === 'none' && transfer.asset.type === 'FiatCurrency';
 exports.isTransferFiatCurrencyNone = isTransferFiatCurrencyNone;
+const parseBaseNormalActionToNormalAction = (action) => {
+    switch (action.action) {
+        case 'add-liquidity': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'approve': {
+            if (action.transfers.length > 0) {
+                throw new Error('Invalid action.transfers for approve');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'approve',
+                transfers: [],
+            };
+        }
+        case 'atomic-arbitrage': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'borrow': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'borrow-with-debt': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'bridge-from': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'bridge-to': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'buy-crypto': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'buy-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'cross-replace': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'cross-trade': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'deposit': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'deposit-with-bond': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        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: [],
+            };
+        }
+        case 'fee': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for fee');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'fee',
+                transfers,
+            };
+        }
+        case 'free-mint-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.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,
+            };
+        }
+        case 'income': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for income');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'income',
+                transfers,
+            };
+        }
+        case 'mint-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'receive-from-cex': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'remove-liquidity': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'repayment': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'repayment-with-debt': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'replace': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for replace');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'replace',
+                transfers,
+            };
+        }
+        case 'revoke': {
+            if (action.transfers.length > 0) {
+                throw new Error('Invalid action.transfers for revoke');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'revoke',
+                transfers: [],
+            };
+        }
+        case 'sell-crypto': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'sell-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'send-to-cex': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'spam': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for spam');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'spam',
+                transfers,
+            };
+        }
+        case 'stake': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'swap-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'transaction-fee': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.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,
+            };
+        }
+        case 'trade': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for trade');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'trade',
+                transfers,
+            };
+        }
+        case 'transfer': {
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'transfer',
+                transfers: [...action.transfers],
+            };
+        }
+        case 'unstake': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'unwrap': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for unwrap');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'unwrap',
+                transfers,
+            };
+        }
+        case 'valuedown': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'valueup': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'withdraw': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'withdraw-with-bond': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'wrap': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for wrap');
+            }
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'wrap',
+                transfers,
+            };
+        }
+    }
+};
+exports.parseBaseNormalActionToNormalAction = parseBaseNormalActionToNormalAction;
+const parseBaseAccountActionToAccountAction = (action) => {
+    switch (action.action) {
+        case 'add-liquidity': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'approve': {
+            if (action.transfers.length > 0) {
+                throw new Error('Invalid action.transfers for approve');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'approve',
+                transfers: [],
+            };
+        }
+        case 'atomic-arbitrage': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'borrow': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'borrow-with-debt': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'bridge-from': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'bridge-to': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'buy-crypto': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'buy-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'cross-replace': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'cross-trade': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'deposit': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'deposit-with-bond': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        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: [],
+            };
+        }
+        case 'fee': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for fee');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'fee',
+                transfers,
+            };
+        }
+        case 'free-mint-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.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,
+            };
+        }
+        case 'ignore': {
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'ignore',
+                transfers: [...action.transfers],
+            };
+        }
+        case 'income': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for income');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'income',
+                transfers,
+            };
+        }
+        case 'mint-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'move': {
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'move',
+                transfers: [...action.transfers],
+            };
+        }
+        case 'nft-royalty': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'receive-from-cex': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'reduce': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.isTransferNftOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for reduce');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'reduce',
+                transfers,
+            };
+        }
+        case 'remove-liquidity': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'repayment': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'repayment-with-debt': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'replace': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for replace');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'replace',
+                transfers,
+            };
+        }
+        case 'revoke': {
+            if (action.transfers.length > 0) {
+                throw new Error('Invalid action.transfers for revoke');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'revoke',
+                transfers: [],
+            };
+        }
+        case 'sell-crypto': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'sell-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'send-to-cex': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'spam': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for spam');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'spam',
+                transfers,
+            };
+        }
+        case 'stake': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'swap-income': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'swap-nft': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferNftIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'swap-transfer': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) || (0, exports.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,
+            };
+        }
+        case 'trade': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferFiatCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for trade');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'trade',
+                transfers,
+            };
+        }
+        case 'transaction-fee': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.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,
+            };
+        }
+        case 'transfer': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.isTransferFiatCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for transfer');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'transfer',
+                transfers,
+            };
+        }
+        case 'unstake': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'unwrap': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for unwrap');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'unwrap',
+                transfers,
+            };
+        }
+        case 'valuedown': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'valueup': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.isTransferNftOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'withdraw': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) || (0, exports.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,
+            };
+        }
+        case 'withdraw-with-bond': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferNftIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer) ||
+                (0, exports.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,
+            };
+        }
+        case 'wrap': {
+            const transfers = action.transfers.filter((transfer) => (0, exports.isTransferCryptoCurrencyIn)(transfer) ||
+                (0, exports.isTransferCryptoCurrencyOut)(transfer));
+            if (transfers.length !== action.transfers.length) {
+                throw new Error('Invalid action.transfers for wrap');
+            }
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'wrap',
+                transfers,
+            };
+        }
+    }
+};
+exports.parseBaseAccountActionToAccountAction = parseBaseAccountActionToAccountAction;
 //# sourceMappingURL=utils.js.map