@0xtorch/core 0.0.14 → 0.0.16

package/_esm/actions/utils.js

@@ -7,4 +7,1393 @@ export const isTransferNftNone = (transfer) => transfer.direction === 'none' &&
 export const isTransferFiatCurrencyIn = (transfer) => transfer.direction === 'in' && transfer.asset.type === 'FiatCurrency';
 export const isTransferFiatCurrencyOut = (transfer) => transfer.direction === 'out' && transfer.asset.type === 'FiatCurrency';
 export const isTransferFiatCurrencyNone = (transfer) => transfer.direction === 'none' && transfer.asset.type === 'FiatCurrency';
+export const parseBaseNormalActionToNormalAction = (action) => {
+    switch (action.action) {
+        case 'add-liquidity': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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) => 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,
+            };
+        }
+        case 'borrow': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'borrow-with-debt': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'bridge-from': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'bridge-to': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'buy-crypto': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'buy-nft': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'cross-replace': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'cross-trade': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'deposit': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'deposit-with-bond': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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) => 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,
+            };
+        }
+        case 'free-mint-nft': {
+            const transfers = action.transfers.filter((transfer) => 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) => 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,
+            };
+        }
+        case 'mint-nft': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'receive-from-cex': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'remove-liquidity': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'repayment': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'repayment-with-debt': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'replace': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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) => 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,
+            };
+        }
+        case 'sell-nft': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'send-to-cex': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'spam': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'stake': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'swap-nft': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'transaction-fee': {
+            const transfers = action.transfers.filter((transfer) => 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) => 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,
+            };
+        }
+        case 'transfer': {
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'transfer',
+                transfers: [...action.transfers],
+            };
+        }
+        case 'unstake': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'unwrap': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'valuedown': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'valueup': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'withdraw': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'withdraw-with-bond': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'wrap': {
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+    }
+};
+export const parseBaseAccountActionToAccountAction = (action) => {
+    switch (action.action) {
+        case 'add-liquidity': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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': {
+            // transferCryptoCurrencyInSchema,
+            // transferCryptoCurrencyOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'borrow': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'borrow-with-debt': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'bridge-from': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'bridge-to': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'buy-crypto': {
+            // transferCryptoCurrencyInSchema, transferFiatCurrencyOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'buy-nft': {
+            // transferNftInSchema,
+            // transferFiatCurrencyOutSchema,
+            // transferCryptoCurrencyOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'cross-replace': {
+            // transferInSchema, transferOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'cross-trade': {
+            // transferInSchema, transferOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'deposit': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'deposit-with-bond': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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': {
+            // transferCryptoCurrencyOutSchema, transferFiatCurrencyOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'free-mint-nft': {
+            // transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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': {
+            // transferInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'mint-nft': {
+            // transferNftInSchema,
+            // transferFiatCurrencyOutSchema,
+            // transferCryptoCurrencyOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'move': {
+            return {
+                ...action,
+                type: 'NormalAccountAction',
+                action: 'move',
+                transfers: [...action.transfers],
+            };
+        }
+        case 'nft-royalty': {
+            // transferCryptoCurrencyInSchema, transferFiatCurrencyInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'receive-from-cex': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'reduce': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'remove-liquidity': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'repayment': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'repayment-with-debt': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'replace': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        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': {
+            // transferFiatCurrencyInSchema, transferCryptoCurrencyOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'sell-nft': {
+            // transferFiatCurrencyInSchema,
+            // transferCryptoCurrencyInSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'send-to-cex': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'spam': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'stake': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'swap-income': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'swap-nft': {
+            // transferNftInSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'swap-transfer': {
+            // transferCryptoCurrencyOutSchema, transferNftOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'trade': {
+            // transferInSchema, transferOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'transaction-fee': {
+            // transferCryptoCurrencyOutSchema
+            const transfers = action.transfers.filter((transfer) => 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': {
+            // transferOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'unstake': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'unwrap': {
+            // transferCryptoCurrencyInSchema,
+            // transferCryptoCurrencyOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'valuedown': {
+            // transferInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'valueup': {
+            // transferOutSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'withdraw': {
+            // transferCryptoCurrencyInSchema, transferNftInSchema
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'withdraw-with-bond': {
+            // transferCryptoCurrencyInSchema,
+            // transferNftInSchema,
+            // transferCryptoCurrencyOutSchema,
+            // transferNftOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+        case 'wrap': {
+            // transferCryptoCurrencyInSchema,
+            // transferCryptoCurrencyOutSchema,
+            const transfers = action.transfers.filter((transfer) => 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,
+            };
+        }
+    }
+};
 //# sourceMappingURL=utils.js.map