@0xtorch/evm 0.0.10 → 0.0.12

package/_esm/analyzer/json/generator.js

@@ -0,0 +1,825 @@
+import { isTransferCryptoCurrencyIn, isTransferCryptoCurrencyOut, isTransferFiatCurrencyIn, isTransferFiatCurrencyOut, isTransferNftIn, isTransferNftOut, } from '@0xtorch/core';
+import { createCommentByCommentComponent } from './components/comment';
+import { isMatchErc1155Component } from './components/erc1155';
+import { isMatchErc20Component } from './components/erc20';
+import { isMatchErc721Component } from './components/erc721';
+import { createIdByIdComponent } from './components/id';
+import { isMatchInternalComponent } from './components/internal';
+import { isMatchLogArgumentComponent } from './components/logArgument';
+import { createTransfersByTransferComponent } from './components/transfer';
+export const generateActionsByGenerator = ({ generator, chain, transaction, }) => {
+    const { target } = generator;
+    // target=undefined の場合は単一 action 生成
+    if (target === undefined) {
+        return [
+            generateActionByGeneratorWithTargets({
+                generator,
+                chain,
+                transaction,
+            }),
+        ];
+    }
+    // target が undefined でない場合は target 毎に action 生成
+    const mut_erc20Transfers = [...transaction.erc20Transfers];
+    const mut_erc721Transfers = [...transaction.erc721Transfers];
+    const mut_erc1155Transfers = [...transaction.erc1155Transfers];
+    const mut_internalTransactions = [...transaction.internalTransactions];
+    const mut_logs = [...transaction.logs];
+    const mut_targets = [];
+    let repeat = true;
+    while (repeat) {
+        const mut_targetsErc20 = [];
+        const mut_targetsErc721 = [];
+        const mut_targetsErc1155 = [];
+        const mut_targetsInternal = [];
+        const mut_targetsLog = [];
+        for (const component of target) {
+            switch (component.type) {
+                case 'erc20': {
+                    const erc20Index = mut_erc20Transfers.findIndex((transfer) => isMatchErc20Component({
+                        component: {
+                            ...component,
+                            index: 0,
+                        },
+                        transfer,
+                        transaction,
+                    }));
+                    if (erc20Index === -1) {
+                        repeat = false;
+                        break;
+                    }
+                    mut_targetsErc20.push(mut_erc20Transfers[erc20Index]);
+                    mut_erc20Transfers.splice(erc20Index, 1);
+                    break;
+                }
+                case 'erc721': {
+                    const erc721Index = mut_erc721Transfers.findIndex((transfer) => isMatchErc721Component({
+                        component: {
+                            ...component,
+                            index: 0,
+                        },
+                        transfer,
+                        transaction,
+                    }));
+                    if (erc721Index === -1) {
+                        repeat = false;
+                        break;
+                    }
+                    mut_targetsErc721.push(mut_erc721Transfers[erc721Index]);
+                    mut_erc721Transfers.splice(erc721Index, 1);
+                    break;
+                }
+                case 'erc1155': {
+                    const erc1155Index = mut_erc1155Transfers.findIndex((transfer) => isMatchErc1155Component({
+                        component: {
+                            ...component,
+                            index: 0,
+                        },
+                        transfer,
+                        transaction,
+                    }));
+                    if (erc1155Index === -1) {
+                        repeat = false;
+                        break;
+                    }
+                    mut_targetsErc1155.push(mut_erc1155Transfers[erc1155Index]);
+                    mut_erc1155Transfers.splice(erc1155Index, 1);
+                    break;
+                }
+                case 'internal': {
+                    const internalIndex = mut_internalTransactions.findIndex((internal) => isMatchInternalComponent({
+                        component: {
+                            ...component,
+                            index: 0,
+                        },
+                        internal,
+                        transaction,
+                    }));
+                    if (internalIndex === -1) {
+                        repeat = false;
+                        break;
+                    }
+                    mut_targetsInternal.push(mut_internalTransactions[internalIndex]);
+                    mut_internalTransactions.splice(internalIndex, 1);
+                    break;
+                }
+                case 'log': {
+                    const logIndex = mut_logs.findIndex((log) => isMatchLogArgumentComponent({
+                        component: {
+                            ...component,
+                            index: 0,
+                            argIndex: 0,
+                            valueType: 'other',
+                        },
+                        log,
+                        transaction,
+                    }));
+                    if (logIndex === -1) {
+                        repeat = false;
+                        break;
+                    }
+                    mut_targetsLog.push(mut_logs[logIndex]);
+                    mut_logs.splice(logIndex, 1);
+                    break;
+                }
+            }
+            if (!repeat) {
+                break;
+            }
+        }
+        if (!repeat) {
+            break;
+        }
+        mut_targets.push({
+            targetsErc20: mut_targetsErc20,
+            targetsErc721: mut_targetsErc721,
+            targetsErc1155: mut_targetsErc1155,
+            targetsInternal: mut_targetsInternal,
+            targetsLog: mut_targetsLog,
+        });
+    }
+    const actions = mut_targets.map((target) => generateActionByGeneratorWithTargets({
+        generator,
+        chain,
+        transaction,
+        ...target,
+    }));
+    return actions;
+};
+const generateActionByGeneratorWithTargets = ({ generator, chain, transaction, targetsErc20, targetsErc721, targetsErc1155, targetsInternal, targetsLog, }) => {
+    // generator に基づいて action 生成
+    const action = {
+        type: 'NormalAction',
+        action: generator.action,
+        evidence: 'contract',
+        timestamp: Number(transaction.block.timestamp) * 1000,
+        comment: generator.comment === undefined
+            ? undefined
+            : generator.comment
+                .map((component) => createCommentByCommentComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+            }))
+                .join(''),
+        app: transaction.app,
+        transfers: generator.transfers.flatMap((component) => createTransfersByTransferComponent({
+            component,
+            transaction,
+            chain,
+            targetsErc20,
+            targetsErc721,
+            targetsErc1155,
+            targetsInternal,
+            targetsLog,
+        })),
+        crossId: generator.crossId === undefined
+            ? undefined
+            : generator.crossId
+                .map((component) => createIdByIdComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+            }))
+                .join(''),
+        loanId: generator.loanId === undefined
+            ? undefined
+            : generator.loanId
+                .map((component) => createIdByIdComponent({
+                component,
+                transaction,
+                chain,
+                targetsLog,
+            }))
+                .join(''),
+    };
+    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');
+            }
+            return {
+                ...action,
+                type: 'CrossNormalAction',
+                action: 'bridge-from',
+                crossId: action.crossId,
+                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');
+            }
+            return {
+                ...action,
+                type: 'CrossNormalAction',
+                action: 'bridge-to',
+                crossId: action.crossId,
+                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': {
+            // 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');
+            }
+            return {
+                ...action,
+                type: 'CrossNormalAction',
+                action: 'cross-replace',
+                crossId: action.crossId,
+                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: 'LoanNormalAction',
+                action: 'deposit',
+                loanId: action.loanId,
+                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');
+            }
+            return {
+                ...action,
+                type: 'CrossNormalAction',
+                action: 'cross-trade',
+                crossId: action.crossId,
+                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: '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': {
+            // 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: 'NormalAction',
+                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: 'NormalAction',
+                action: 'free-mint-nft',
+                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: 'NormalAction',
+                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: 'NormalAction',
+                action: 'mint-nft',
+                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: 'NormalAction',
+                action: 'receive-from-cex',
+                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: 'LoanNormalAction',
+                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: 'LoanNormalAction',
+                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: 'LoanNormalAction',
+                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: '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': {
+            // 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: 'NormalAction',
+                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: 'NormalAction',
+                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: 'NormalAction',
+                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: 'NormalAction',
+                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: 'LoanNormalAction',
+                action: 'stake',
+                loanId: action.loanId,
+                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: 'NormalAction',
+                action: 'swap-nft',
+                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: 'NormalAction',
+                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: 'NormalAction',
+                action: 'transaction-fee',
+                transfers,
+            };
+        }
+        case 'transfer': {
+            return {
+                ...action,
+                type: 'NormalAction',
+                action: 'transfer',
+                transfers: [...action.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: 'LoanNormalAction',
+                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: 'NormalAction',
+                action: 'unwrap',
+                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: 'NormalAction',
+                action: 'wrap',
+                transfers,
+            };
+        }
+        case 'valuedown': {
+            // TODO asset の指定を可能にする
+            throw new Error('Not implemented for valuedown');
+        }
+        case 'valueup': {
+            // TODO
+            throw new Error('Not implemented for valueup');
+        }
+        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: 'LoanNormalAction',
+                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: 'LoanNormalAction',
+                action: 'withdraw-with-bond',
+                loanId: action.loanId,
+                transfers,
+            };
+        }
+    }
+};
+//# sourceMappingURL=generator.js.map