@0xtorch/evm 0.0.13 → 0.0.15

package/_esm/analyzer/json/generator.js

@@ -1,4 +1,4 @@
-import { isTransferCryptoCurrencyIn, isTransferCryptoCurrencyOut, isTransferFiatCurrencyIn, isTransferFiatCurrencyOut, isTransferNftIn, isTransferNftOut, } from '@0xtorch/core';
+import { parseBaseNormalActionToNormalAction } from '@0xtorch/core';
 import { createCommentByCommentComponent } from './components/comment';
 import { isMatchErc1155Component } from './components/erc1155';
 import { isMatchErc20Component } from './components/erc20';
@@ -149,7 +149,6 @@ export const generateActionsByGenerator = ({ generator, chain, transaction, }) =
 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,
@@ -195,648 +194,9 @@ const generateActionByGeneratorWithTargets = ({ generator, chain, transaction, t
                 targetsLog,
             }))
                 .join(''),
+        // TODO target を生成できるようにする
+        target: undefined,
     };
-    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': {
-            // 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: 'CrossNormalAction',
-                action: 'cross-replace',
-                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: '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');
-            }
-            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-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,
-            };
-        }
-    }
+    return parseBaseNormalActionToNormalAction(action);
 };
 //# sourceMappingURL=generator.js.map