@rabby-wallet/rabby-action 0.1.0 → 0.1.1-beta.1

package/dist/actions/approveNFT/fetchData.js

@@ -10,9 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import PQueue from 'p-queue';
 import { waitQueueFinished } from '../../utils/waitQueueFinished';
 export const fetchDataApproveNFT = (options, likeAction) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const queue = new PQueue();
     const { sender, apiProvider, chainId, actionData } = options;
     const action = likeAction || actionData.approveNFT;

package/dist/actions/approveNFT/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineApproveNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction' && options.type !== 'typed_data') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.approveNFT || !chainId) {
         return {};

package/dist/actions/approveNFTCollection/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataApproveNFT } from '../approveNFT/fetchData';
 export const fetchDataApproveNFTCollection = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.approveNFTCollection) {
         return {};
     }

package/dist/actions/approveNFTCollection/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineApproveNFTCollection = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.approveNFTCollection || !chainId) {
         return {};

package/dist/actions/approveNFTCollection/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionApproveNFTCollection: ParseAction<'transaction'>;
+export declare const parseActionApproveNFTCollection: ParseAction;

package/dist/actions/approveToken/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineApproveToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.approveToken || !chainId) {
         return {};

package/dist/actions/approveToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionApproveToken: ParseAction<'transaction'>;
+export declare const parseActionApproveToken: ParseAction;

package/dist/actions/assetOrder/fetchData.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { fetchDataCommon } from '../common/fetchData';
+// TODO: text action not supported
 export const fetchDataAssetOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
     let action;
     if (options.type === 'transaction' && options.actionData.assetOrder) {

package/dist/actions/assetOrder/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineAssetOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction' && options.type !== 'typed_data') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.assetOrder) {
         return {};

package/dist/actions/assetOrder/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionAssetOrder: ParseAction<'transaction' | 'typed_data'>;
+export declare const parseActionAssetOrder: ParseAction;

package/dist/actions/cancelTx/fetchData.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const fetchDataCancelTx = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { walletProvider, actionData, chainId, sender } = options;
     if (!actionData.cancelTx) {
         return {};
@@ -18,7 +15,7 @@ export const fetchDataCancelTx = (options) => __awaiter(void 0, void 0, void 0,
     const chain = walletProvider.findChain({
         serverId: chainId,
     });
-    if (chain) {
+    if (chain && actionData.cancelTx.nonce !== undefined) {
         const pendingTxs = yield walletProvider.getPendingTxsByNonce(sender, chain.id, Number(actionData.cancelTx.nonce));
         return {
             pendingTxs,

package/dist/actions/cancelTx/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionCancelTx: ParseAction<'transaction'>;
+export declare const parseActionCancelTx: ParseAction;

package/dist/actions/cancelTx/parseAction.js

@@ -1,11 +1,11 @@
 export const parseActionCancelTx = (options) => {
-    const { tx, data } = options;
+    const { data } = options;
     if ((data === null || data === void 0 ? void 0 : data.type) !== 'cancel_tx') {
         return {};
     }
     return {
         cancelTx: {
-            nonce: tx.nonce,
+            nonce: options.type === 'transaction' ? options.tx.nonce : undefined,
         },
     };
 };

package/dist/actions/common/formatSecurityEngine.js

@@ -8,14 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineCommon = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type === 'text') {
-        return {};
-    }
+    var _a;
     if (!options.actionData.common) {
         return {};
     }
     return {
-        common: Object.assign(Object.assign({}, options.actionData.common), { receiverInWallet: options.requireData
-                .receiverInWallet }),
+        common: Object.assign(Object.assign({}, options.actionData.common), { receiverInWallet: (_a = options.requireData) === null || _a === void 0 ? void 0 : _a.receiverInWallet }),
     };
 });

package/dist/actions/common/parseAction.js

@@ -4,7 +4,7 @@ export const parseActionCommon = (options) => {
         return {};
     }
     const from = options.type === 'transaction'
-        ? options.tx.from
+        ? options.sender
         : options.type === 'text'
             ? undefined
             : options.sender;

package/dist/actions/contractCall/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineContractCall = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction' && options.type !== 'typed_data') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.contractCall || !chainId) {
         return {};

package/dist/actions/crossSwapToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataSwap } from '../swap/fetchData';
 export const fetchDataCrossSwapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.crossSwapToken) {
         return {};
     }

package/dist/actions/crossSwapToken/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineCrossSwapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.crossSwapToken) {
         return {};

package/dist/actions/crossSwapToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionCrossSwapToken: ParseAction<'transaction'>;
+export declare const parseActionCrossSwapToken: ParseAction;

package/dist/actions/crossToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataSwap } from '../swap/fetchData';
 export const fetchDataCrossToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.crossToken) {
         return {};
     }

package/dist/actions/crossToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionCrossToken: ParseAction<'transaction'>;
+export declare const parseActionCrossToken: ParseAction;

package/dist/actions/deployContract/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionDeployContract: ParseAction<'transaction'>;
+export declare const parseActionDeployContract: ParseAction;

package/dist/actions/multiSwap/fetchData.d.ts

@@ -0,0 +1,2 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataMultiSwap: FetchActionRequiredData;

package/dist/actions/multiSwap/fetchData.js

@@ -0,0 +1,16 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { fetchDataSwap } from '../swap/fetchData';
+export const fetchDataMultiSwap = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!options.actionData.multiSwap) {
+        return {};
+    }
+    return fetchDataSwap(options, options.actionData.multiSwap);
+});

package/dist/actions/multiSwap/formatSecurityEngine.d.ts

@@ -0,0 +1,2 @@
+import { FormatSecurityEngineContext } from '../../types';
+export declare const formatSecurityEngineMultiSwap: FormatSecurityEngineContext;

package/dist/actions/multiSwap/formatSecurityEngine.js

@@ -0,0 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const formatSecurityEngineMultiSwap = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { actionData, requireData, chainId } = options;
+    if (!actionData.multiSwap) {
+        return {};
+    }
+    const { receiver } = actionData.multiSwap;
+    const data = requireData;
+    return {
+        multiSwap: {
+            from: data.sender,
+            receiver: receiver || '',
+            chainId,
+            id: data.id,
+        },
+    };
+});

package/dist/actions/multiSwap/parseAction.d.ts

@@ -0,0 +1,2 @@
+import { ParseAction } from '../../types';
+export declare const parseActionMultiSwap: ParseAction;

package/dist/actions/multiSwap/parseAction.js

@@ -0,0 +1,14 @@
+export const parseActionMultiSwap = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'multi_swap_token') {
+        return {};
+    }
+    const { pay_token_list: payTokenList, receive_token_list: receiveTokenList, receiver, } = data.data;
+    return {
+        multiSwap: {
+            payTokenList,
+            receiveTokenList,
+            receiver,
+        },
+    };
+};

package/dist/actions/permit2BatchRevokeToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataApproveToken } from '../approveToken/fetchData';
 export const fetchDataPermit2BatchRevokeToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData } = options;
     const action = actionData.permit2BatchRevokeToken;
     if (!action) {

package/dist/actions/permit2BatchRevokeToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionPermit2BatchRevokeToken: ParseAction<'transaction'>;
+export declare const parseActionPermit2BatchRevokeToken: ParseAction;

package/dist/actions/pushMultiSig/fetchData.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const fetchDataPushMultiSig = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { apiProvider, actionData } = options;
     if (!actionData.pushMultiSig) {
         return {};

package/dist/actions/pushMultiSig/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionPushMultiSig: ParseAction<'transaction'>;
+export declare const parseActionPushMultiSig: ParseAction;

package/dist/actions/revokeNFT/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataApproveNFT } from '../approveNFT/fetchData';
 export const fetchDataRevokeNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.revokeNFT) {
         return {};
     }

package/dist/actions/revokeNFT/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionRevokeNFT: ParseAction<'transaction'>;
+export declare const parseActionRevokeNFT: ParseAction;

package/dist/actions/revokeNFTCollection/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionRevokeNFTCollection: ParseAction<'transaction'>;
+export declare const parseActionRevokeNFTCollection: ParseAction;

package/dist/actions/revokePermit2/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataApproveToken } from '../approveToken/fetchData';
 export const fetchDataRevokePermit2 = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.revokePermit2) {
         return {};
     }

package/dist/actions/revokePermit2/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionRevokePermit2: ParseAction<'transaction'>;
+export declare const parseActionRevokePermit2: ParseAction;

package/dist/actions/revokeToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataApproveToken } from '../approveToken/fetchData';
 export const fetchDataRevokeToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.revokeToken) {
         return {};
     }

package/dist/actions/revokeToken/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineRevokeToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.revokeToken) {
         return {};
@@ -18,7 +15,7 @@ export const formatSecurityEngineRevokeToken = (options) => __awaiter(void 0, vo
     const { gasUsed } = actionData.revokeToken;
     return {
         revokeApprove: {
-            gasUsed,
+            gasUsed: gasUsed || 0,
             chainId,
         },
     };

package/dist/actions/revokeToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionRevokeToken: ParseAction<'transaction'>;
+export declare const parseActionRevokeToken: ParseAction;

package/dist/actions/send/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineSend = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction' && options.type !== 'typed_data') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.send || !chainId) {
         return {};

package/dist/actions/sendNFT/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataSend } from '../send/fetchData';
 export const fetchDataSendNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const sendNFT = options.actionData.sendNFT;
     if (!sendNFT) {
         return {};

package/dist/actions/sendNFT/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineSendNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.sendNFT || !chainId) {
         return {};

package/dist/actions/sendNFT/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionSendNFT: ParseAction<'transaction'>;
+export declare const parseActionSendNFT: ParseAction;

package/dist/actions/swap/fetchData.js

@@ -9,19 +9,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import PQueue from 'p-queue';
 import { waitQueueFinished } from '../../utils/waitQueueFinished';
+// TODO: text
 export const fetchDataSwap = (options, likeSwapAction) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
+    if (options.type === 'text') {
         return {};
     }
     const queue = new PQueue();
-    const { actionData, walletProvider, tx, sender, apiProvider, chainId } = options;
+    const { actionData, walletProvider, sender, apiProvider, chainId } = options;
     const swapAction = likeSwapAction || actionData.swap;
     if (!swapAction) {
         return {};
     }
     const { receiver } = swapAction;
     const receiverInWallet = yield walletProvider.hasAddress(receiver);
-    const id = tx.to;
+    const id = options.type === 'transaction'
+        ? options.tx.to
+        : options.actionData.contractId;
+    if (!id) {
+        return {};
+    }
     const result = {
         id,
         protocol: null,

package/dist/actions/swap/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineSwap = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.swap || !chainId) {
         return {};

package/dist/actions/swap/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionSwap: ParseAction<'transaction'>;
+export declare const parseActionSwap: ParseAction;

package/dist/actions/swap/parseAction.js

@@ -3,21 +3,21 @@ import { calcSlippageTolerance } from '../../utils/calcSlippageTolerance';
 import { calcUSDValueChange } from '../../utils/calcUSDValueChange';
 import { isSameAddress } from '../../utils/isSameAddress';
 export const parseActionSwap = (options) => {
-    const { data, balanceChange, preExecVersion, tx } = options;
+    const { data, balanceChange, preExecVersion, sender } = options;
     if ((data === null || data === void 0 ? void 0 : data.type) !== 'swap_token') {
         return {};
     }
     const { pay_token: payToken, receive_token: receiveToken, receiver, } = data.data;
-    const balanceChangeSuccess = balanceChange.success;
+    const balanceChangeSuccess = balanceChange === null || balanceChange === void 0 ? void 0 : balanceChange.success;
     const supportBalanceChange = preExecVersion !== 'v0';
-    const actualReceiveToken = balanceChange.receive_token_list.find((token) => isSameAddress(token.id, receiveToken.id));
+    const actualReceiveToken = balanceChange === null || balanceChange === void 0 ? void 0 : balanceChange.receive_token_list.find((token) => isSameAddress(token.id, receiveToken.id));
     const receiveTokenAmount = actualReceiveToken ? actualReceiveToken.amount : 0;
     const slippageTolerance = balanceChangeSuccess && supportBalanceChange
         ? calcSlippageTolerance(actualReceiveToken ? actualReceiveToken.raw_amount || '0' : '0', receiveToken.min_raw_amount || '0')
         : null;
     const receiveTokenUsdValue = new BigNumber(receiveTokenAmount).times(receiveToken.price);
     const payTokenUsdValue = new BigNumber(payToken.amount).times(payToken.price);
-    const hasReceiver = !isSameAddress(receiver, tx.from);
+    const hasReceiver = !isSameAddress(receiver, sender);
     const usdValueDiff = hasReceiver || !balanceChangeSuccess || !supportBalanceChange
         ? null
         : receiveTokenUsdValue.minus(payTokenUsdValue).toFixed();
@@ -35,8 +35,8 @@ export const parseActionSwap = (options) => {
             usdValueDiff,
             usdValuePercentage,
             balanceChange: {
-                success: balanceChangeSuccess,
-                support: supportBalanceChange,
+                success: !!balanceChangeSuccess,
+                support: !!supportBalanceChange,
             },
         },
     };

package/dist/actions/swapLimitPay/fetchData.d.ts

@@ -0,0 +1,2 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataSwapLimitPay: FetchActionRequiredData;

package/dist/actions/swapLimitPay/fetchData.js

@@ -0,0 +1,16 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { fetchDataSwap } from '../swap/fetchData';
+export const fetchDataSwapLimitPay = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!options.actionData.swapLimitPay) {
+        return {};
+    }
+    return fetchDataSwap(options, options.actionData.swapLimitPay);
+});

package/dist/actions/swapLimitPay/formatSecurityEngine.d.ts

@@ -0,0 +1,2 @@
+import { FormatSecurityEngineContext } from '../../types';
+export declare const formatSecurityEngineSwapLimitPay: FormatSecurityEngineContext;

package/dist/actions/swapLimitPay/formatSecurityEngine.js

@@ -0,0 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const formatSecurityEngineSwapLimitPay = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { actionData, requireData, chainId } = options;
+    if (!actionData.swapLimitPay) {
+        return {};
+    }
+    const { receiver } = actionData.swapLimitPay;
+    const data = requireData;
+    return {
+        multiSwap: {
+            from: data.sender,
+            receiver: receiver || '',
+            chainId,
+            id: data.id,
+        },
+    };
+});

package/dist/actions/swapLimitPay/parseAction.d.ts

@@ -0,0 +1,2 @@
+import { ParseAction } from '../../types';
+export declare const parseActionSwapLimitPay: ParseAction;

package/dist/actions/swapLimitPay/parseAction.js

@@ -0,0 +1,14 @@
+export const parseActionSwapLimitPay = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'swap_token_limit_pay') {
+        return {};
+    }
+    const { pay_token: payToken, receive_token: receiveToken, receiver, } = data.data;
+    return {
+        swapLimitPay: {
+            payToken,
+            receiveToken,
+            receiver,
+        },
+    };
+};

package/dist/actions/transferOwner/fetchData.d.ts

@@ -0,0 +1,2 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataTransferOwner: FetchActionRequiredData;

package/dist/actions/transferOwner/fetchData.js

@@ -0,0 +1,82 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import PQueue from 'p-queue';
+import { waitQueueFinished } from '../../utils/waitQueueFinished';
+export const fetchDataTransferOwner = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!options.actionData.transferOwner) {
+        return {};
+    }
+    const queue = new PQueue();
+    const { actionData, walletProvider, apiProvider, chainId, sender } = options;
+    const addr = (_a = actionData.transferOwner) === null || _a === void 0 ? void 0 : _a.to;
+    const result = {
+        receiver: null,
+    };
+    if (addr) {
+        const chain = walletProvider.findChain({
+            serverId: chainId,
+        });
+        const receiverData = {
+            address: addr,
+            chain: chain,
+            eoa: null,
+            cex: null,
+            contract: null,
+            usd_value: 0,
+            hasTransfer: false,
+            isTokenContract: false,
+            name: null,
+            onTransferWhitelist: false,
+        };
+        queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+            const { has_transfer } = yield apiProvider.hasTransfer(chainId, sender, addr);
+            receiverData.hasTransfer = has_transfer;
+        }));
+        queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const { desc } = yield apiProvider.addrDesc(addr);
+            if ((_a = desc.cex) === null || _a === void 0 ? void 0 : _a.id) {
+                receiverData.cex = {
+                    id: desc.cex.id,
+                    logo: desc.cex.logo_url,
+                    name: desc.cex.name,
+                    bornAt: desc.born_at,
+                    isDeposit: desc.cex.is_deposit,
+                };
+            }
+            if (desc.contract && Object.keys(desc.contract).length > 0) {
+                receiverData.contract = desc.contract;
+            }
+            if (!receiverData.cex && !receiverData.contract) {
+                receiverData.eoa = {
+                    id: addr,
+                    bornAt: desc.born_at,
+                };
+            }
+            receiverData.usd_value = desc.usd_value;
+            receiverData.name = desc.name;
+        }));
+        queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+            if (addr) {
+                const { is_token } = yield apiProvider.isTokenContract(chainId, addr);
+                receiverData.isTokenContract = is_token;
+            }
+            if (walletProvider.ALIAS_ADDRESS[addr.toLowerCase()]) {
+                receiverData.name = walletProvider.ALIAS_ADDRESS[addr.toLowerCase()];
+            }
+            const whitelist = yield walletProvider.getWhitelist();
+            receiverData.onTransferWhitelist = whitelist.includes(addr.toLowerCase());
+        }));
+        yield waitQueueFinished(queue);
+        result.receiver = receiverData;
+    }
+    return result;
+});

package/dist/actions/transferOwner/formatSecurityEngine.d.ts

@@ -0,0 +1,2 @@
+import { FormatSecurityEngineContext } from '../../types';
+export declare const formatSecurityEngineTransferOwner: FormatSecurityEngineContext;

package/dist/actions/transferOwner/formatSecurityEngine.js

@@ -0,0 +1,22 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const formatSecurityEngineTransferOwner = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.transferOwner || !chainId) {
+        return {};
+    }
+    const data = requireData;
+    return {
+        transferOwner: {
+            receiverInWhitelist: !!((_a = data.receiver) === null || _a === void 0 ? void 0 : _a.onTransferWhitelist),
+        },
+    };
+});

package/dist/actions/transferOwner/parseAction.d.ts

@@ -0,0 +1,2 @@
+import { ParseAction } from '../../types';
+export declare const parseActionTransferOwner: ParseAction;

package/dist/actions/transferOwner/parseAction.js

@@ -0,0 +1,14 @@
+export const parseActionTransferOwner = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'transfer_ownership') {
+        return {};
+    }
+    const { description, from_addr, to_addr } = data.data;
+    return {
+        transferOwner: {
+            description,
+            from: from_addr,
+            to: to_addr,
+        },
+    };
+};

package/dist/actions/unwrapToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataSwap } from '../swap/fetchData';
 export const fetchDataUnwrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.unWrapToken) {
         return {};
     }

package/dist/actions/unwrapToken/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineUnwrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.unWrapToken || !chainId) {
         return {};

package/dist/actions/unwrapToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionUnwrapToken: ParseAction<'transaction'>;
+export declare const parseActionUnwrapToken: ParseAction;

package/dist/actions/wrapToken/fetchData.js

@@ -9,9 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { fetchDataSwap } from '../swap/fetchData';
 export const fetchDataWrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     if (!options.actionData.wrapToken) {
         return {};
     }

package/dist/actions/wrapToken/formatSecurityEngine.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export const formatSecurityEngineWrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'transaction') {
-        return {};
-    }
     const { actionData, requireData, chainId, provider } = options;
     if (!actionData.wrapToken || !chainId) {
         return {};

package/dist/actions/wrapToken/parseAction.d.ts

@@ -1,2 +1,2 @@
 import { ParseAction } from '../../types';
-export declare const parseActionWrapToken: ParseAction<'transaction'>;
+export declare const parseActionWrapToken: ParseAction;

package/dist/fetchActionRequiredData.js

@@ -43,8 +43,14 @@ import { fetchDataSellNFT } from './actions/sellNFT/fetchData';
 import { fetchDataSignMultiSig } from './actions/signMultiSig/fetchData';
 import { fetchDataSwapTokenOrder } from './actions/swapTokenOrder/fetchData';
 import { fetchDataVerifyAddress } from './actions/verifyAddress/fetchData';
+import { fetchDataTransferOwner } from './actions/transferOwner/fetchData';
+import { fetchDataMultiSwap } from './actions/multiSwap/fetchData';
+import { fetchDataSwapLimitPay } from './actions/swapLimitPay/fetchData';
 export const fetchActionRequiredData = (options) => __awaiter(void 0, void 0, void 0, function* () {
     const result = yield Promise.all([
+        fetchDataTransferOwner(options),
+        fetchDataMultiSwap(options),
+        fetchDataSwapLimitPay(options),
         fetchDataApproveNFT(options),
         fetchDataApproveNFTCollection(options),
         fetchDataApproveToken(options),
@@ -83,5 +89,9 @@ export const fetchActionRequiredData = (options) => __awaiter(void 0, void 0, vo
         fetchDataCoboSafeModificationTokenApproval(options),
         fetchDataRevokePermit(options),
     ]);
-    return result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
+    const requireData = result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
+    if (requireData && Object.keys(requireData).length === 0) {
+        return null;
+    }
+    return requireData;
 });

package/dist/formatSecurityEngineContext.js

@@ -43,11 +43,17 @@ import { formatSecurityEngineSellNFT } from './actions/sellNFT/formatSecurityEng
 import { formatSecurityEngineSignMultiSig } from './actions/signMultiSig/formatSecurityEngine';
 import { formatSecurityEngineSwapTokenOrder } from './actions/swapTokenOrder/formatSecurityEngine';
 import { formatSecurityEngineVerifyAddress } from './actions/verifyAddress/formatSecurityEngine';
+import { formatSecurityEngineTransferOwner } from './actions/transferOwner/formatSecurityEngine';
+import { formatSecurityEngineMultiSwap } from './actions/multiSwap/formatSecurityEngine';
+import { formatSecurityEngineSwapLimitPay } from './actions/swapLimitPay/formatSecurityEngine';
 export const formatSecurityEngineContext = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.type !== 'text' && options.isTestnet) {
+    if (options.isTestnet) {
         return {};
     }
     const result = yield Promise.all([
+        formatSecurityEngineTransferOwner(options),
+        formatSecurityEngineMultiSwap(options),
+        formatSecurityEngineSwapLimitPay(options),
         formatSecurityEngineApproveNFT(options),
         formatSecurityEngineApproveNFTCollection(options),
         formatSecurityEngineApproveToken(options),

package/dist/parseAction.js

@@ -1,3 +1,6 @@
+import { parseActionSwapLimitPay } from './actions/swapLimitPay/parseAction';
+import { parseActionMultiSwap } from './actions/multiSwap/parseAction';
+import { parseActionTransferOwner } from './actions/transferOwner/parseAction';
 import { parseActionSend } from './actions/send/parseAction';
 import { parseActionApproveNFT } from './actions/approveNFT/parseAction';
 import { parseActionApproveNFTCollection } from './actions/approveNFTCollection/parseAction';
@@ -39,13 +42,21 @@ import { parseTextAction } from './utils/parseTextAction';
 export function parseAction(options) {
     const result = [];
     if (options.type === 'transaction') {
-        result.push(parseActionApproveNFT(options), parseActionApproveNFTCollection(options), parseActionApproveToken(options), parseActionAssetOrder(options), parseActionCancelTx(options), parseActionCommon(options), parseActionCrossSwapToken(options), parseActionCrossToken(options), parseActionDeployContract(options), parseActionPushMultiSig(options), parseActionRevokeNFT(options), parseActionRevokeNFTCollection(options), parseActionRevokePermit2(options), parseActionRevokeToken(options), parseActionSend(options), parseActionSendNFT(options), parseActionSwap(options), parseActionUnwrapToken(options), parseActionWrapToken(options), parseActionPermit2BatchRevokeToken(options));
+        result.push(parseActionApproveNFT(options), parseActionApproveNFTCollection(options), parseActionApproveToken(options), parseActionAssetOrder(options), parseActionCancelTx(options), parseActionCommon(options), parseActionCrossSwapToken(options), parseActionCrossToken(options), parseActionDeployContract(options), parseActionPushMultiSig(options), parseActionRevokeNFT(options), parseActionRevokeNFTCollection(options), parseActionRevokePermit2(options), parseActionRevokeToken(options), parseActionSend(options), parseActionSendNFT(options), parseActionSwap(options), parseActionUnwrapToken(options), parseActionWrapToken(options), parseActionPermit2BatchRevokeToken(options), parseActionTransferOwner(options), parseActionSwapLimitPay(options), parseActionMultiSwap(options));
     }
     if (options.type === 'typed_data') {
-        result.push(parseTypedDataAction(parseActionCommon)(options), parseTypedDataAction(parseActionAssetOrder)(options), parseTypedDataAction(parseActionSend)(options), parseTypedDataAction(parseActionApproveNFT)(options), parseTypedDataAction(parseActionCreateKey)(options), parseTypedDataAction(parseActionVerifyAddress)(options), parseTypedDataAction(parseActionSellNFT)(options), parseTypedDataAction(parseActionBatchSellNFT)(options), parseTypedDataAction(parseActionSignMultiSig)(options), parseTypedDataAction(parseActionBuyNFT)(options), parseTypedDataAction(parseActionPermit)(options), parseTypedDataAction(parseActionPermit2)(options), parseTypedDataAction(parseActionBatchPermit2)(options), parseTypedDataAction(parseActionSwapTokenOrder)(options), parseTypedDataAction(parseActionCoboSafeCreate)(options), parseTypedDataAction(parseActionCoboSafeModificationDelegatedAddress)(options), parseTypedDataAction(parseActionCoboSafeModificationRole)(options), parseTypedDataAction(parseActionCoboSafeModificationTokenApproval)(options), parseTypedDataAction(parseActionRevokePermit)(options));
+        result.push(
+        // tx actions
+        parseTypedDataAction(parseActionCommon)(options), parseTypedDataAction(parseActionAssetOrder)(options), parseTypedDataAction(parseActionSend)(options), parseTypedDataAction(parseActionApproveNFT)(options), parseTypedDataAction(parseActionApproveNFTCollection)(options), parseTypedDataAction(parseActionApproveToken)(options), parseTypedDataAction(parseActionCancelTx)(options), parseTypedDataAction(parseActionCrossSwapToken)(options), parseTypedDataAction(parseActionCrossToken)(options), parseTypedDataAction(parseActionDeployContract)(options), parseTypedDataAction(parseActionPushMultiSig)(options), parseTypedDataAction(parseActionRevokeNFT)(options), parseTypedDataAction(parseActionRevokeNFTCollection)(options), parseTypedDataAction(parseActionRevokePermit2)(options), parseTypedDataAction(parseActionRevokeToken)(options), parseTypedDataAction(parseActionSendNFT)(options), parseTypedDataAction(parseActionSwap)(options), parseTypedDataAction(parseActionUnwrapToken)(options), parseTypedDataAction(parseActionWrapToken)(options), parseTypedDataAction(parseActionPermit2BatchRevokeToken)(options), parseTypedDataAction(parseActionTransferOwner)(options), parseTypedDataAction(parseActionSwapLimitPay)(options), parseTypedDataAction(parseActionMultiSwap)(options), 
+        // typed data actions
+        parseTypedDataAction(parseActionCreateKey)(options), parseTypedDataAction(parseActionVerifyAddress)(options), parseTypedDataAction(parseActionSellNFT)(options), parseTypedDataAction(parseActionBatchSellNFT)(options), parseTypedDataAction(parseActionSignMultiSig)(options), parseTypedDataAction(parseActionBuyNFT)(options), parseTypedDataAction(parseActionPermit)(options), parseTypedDataAction(parseActionPermit2)(options), parseTypedDataAction(parseActionBatchPermit2)(options), parseTypedDataAction(parseActionSwapTokenOrder)(options), parseTypedDataAction(parseActionCoboSafeCreate)(options), parseTypedDataAction(parseActionCoboSafeModificationDelegatedAddress)(options), parseTypedDataAction(parseActionCoboSafeModificationRole)(options), parseTypedDataAction(parseActionCoboSafeModificationTokenApproval)(options), parseTypedDataAction(parseActionRevokePermit)(options));
     }
     if (options.type === 'text') {
-        result.push(parseTextAction(parseActionCommon)(options), parseTextAction(parseActionCreateKey)(options), parseTextAction(parseActionVerifyAddress)(options));
+        result.push(
+        // tx actions
+        parseTextAction(parseActionCommon)(options), parseTextAction(parseActionAssetOrder)(options), parseTextAction(parseActionSend)(options), parseTextAction(parseActionApproveNFT)(options), parseTextAction(parseActionApproveNFTCollection)(options), parseTextAction(parseActionApproveToken)(options), parseTextAction(parseActionCancelTx)(options), parseTextAction(parseActionCrossSwapToken)(options), parseTextAction(parseActionCrossToken)(options), parseTextAction(parseActionDeployContract)(options), parseTextAction(parseActionPushMultiSig)(options), parseTextAction(parseActionRevokeNFT)(options), parseTextAction(parseActionRevokeNFTCollection)(options), parseTextAction(parseActionRevokePermit2)(options), parseTextAction(parseActionRevokeToken)(options), parseTextAction(parseActionSendNFT)(options), parseTextAction(parseActionSwap)(options), parseTextAction(parseActionUnwrapToken)(options), parseTextAction(parseActionWrapToken)(options), parseTextAction(parseActionPermit2BatchRevokeToken)(options), 
+        // text actions
+        parseTextAction(parseActionCreateKey)(options), parseTextAction(parseActionVerifyAddress)(options));
     }
     const action = result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
     // filter out typedData or text keys
@@ -60,6 +71,9 @@ export function parseAction(options) {
         else if (options.type === 'transaction') {
             return parseActionContractCall(options);
         }
+        else if (options.type === 'text') {
+            return parseTextAction(parseActionContractCall)(options);
+        }
         return {};
     }
     return action;

package/dist/types/actionRequireData.d.ts

@@ -130,6 +130,9 @@ export interface ReceiverData {
     hasReceiverPrivateKeyInWallet?: boolean;
     rank?: number;
 }
+export interface TransferOwnerRequireData {
+    receiver: ReceiverData | null;
+}
 export interface ContractRequireData {
     id: string;
     protocol: {

package/dist/types/fetchActionRequiredData.d.ts

@@ -3,22 +3,24 @@ import { ParsedActionData } from './parsedActionData';
 import { OpenApiService } from '@rabby-wallet/rabby-api';
 import { WalletProvider } from './walletProvider';
 import { ActionRequireData } from './actionRequireData';
-type BaseFetchActionRequiredDataParameters<T extends 'typed_data' | 'transaction' | undefined> = {
+type BaseFetchActionRequiredDataParameters<T extends 'typed_data' | 'transaction' | 'text' | undefined> = {
     actionData: ParsedActionData<T>;
     sender: string;
     walletProvider: WalletProvider;
     apiProvider: OpenApiService;
+    chainId: string;
 };
 export type FetchTransactionRequiredDataParameters = BaseFetchActionRequiredDataParameters<'transaction'> & {
     type: 'transaction';
     contractCall?: ParseTxResponse['contract_call'] | null;
-    chainId: string;
     tx: Tx;
 };
 export type FetchTypedDataRequiredDataParameters = BaseFetchActionRequiredDataParameters<'typed_data'> & {
     type: 'typed_data';
-    chainId?: string;
 };
-export type FetchActionRequiredDataParameters = FetchTransactionRequiredDataParameters | FetchTypedDataRequiredDataParameters;
+export type FetchTextRequiredDataParameters = BaseFetchActionRequiredDataParameters<'text'> & {
+    type: 'text';
+};
+export type FetchActionRequiredDataParameters = FetchTransactionRequiredDataParameters | FetchTypedDataRequiredDataParameters | FetchTextRequiredDataParameters;
 export type FetchActionRequiredData<T = undefined> = (options: FetchActionRequiredDataParameters, likeAction?: T) => Promise<ActionRequireData>;
 export {};

package/dist/types/formatSecurityEngineContext.d.ts

@@ -1,12 +1,10 @@
 import { ContextActionData } from '@rabby-wallet/rabby-security-engine/dist/rules';
 import { ActionRequireData } from './actionRequireData';
 import { ParsedActionData } from './parsedActionData';
-export type FormatSecurityEngineContextParameters = {
-    type: 'transaction';
-    actionData: ParsedActionData<'transaction'>;
-    requireData: ActionRequireData;
+type BaseFormatSecurityEngineContextParameters = {
     isTestnet: boolean;
-    chainId?: string;
+    chainId: string;
+    requireData: ActionRequireData;
     provider: {
         getTimeSpan: (time: number) => {
             d: number;
@@ -16,25 +14,21 @@ export type FormatSecurityEngineContextParameters = {
         };
         hasAddress: (address: string) => Promise<boolean>;
     };
-} | {
+};
+export type FormatTransactionSecurityEngineContextParameters = BaseFormatSecurityEngineContextParameters & {
+    type: 'transaction';
+    actionData: ParsedActionData<'transaction'>;
+};
+export type FormatTypedDataSecurityEngineContextParameters = BaseFormatSecurityEngineContextParameters & {
     type: 'typed_data';
     actionData: ParsedActionData<'typed_data'>;
-    requireData?: ActionRequireData;
-    isTestnet: boolean;
-    chainId?: string;
     origin: string;
-    provider: {
-        getTimeSpan: (time: number) => {
-            d: number;
-            h: number;
-            m: number;
-            s: number;
-        };
-        hasAddress: (address: string) => Promise<boolean>;
-    };
-} | {
+};
+export type FormatTextSecurityEngineContextParameters = BaseFormatSecurityEngineContextParameters & {
     type: 'text';
     actionData: ParsedActionData<'text'>;
     origin: string;
 };
+export type FormatSecurityEngineContextParameters = FormatTransactionSecurityEngineContextParameters | FormatTypedDataSecurityEngineContextParameters | FormatTextSecurityEngineContextParameters;
 export type FormatSecurityEngineContext = (options: FormatSecurityEngineContextParameters) => Promise<ContextActionData>;
+export {};

package/dist/types/parseAction.d.ts

@@ -1,10 +1,11 @@
-import { ParseTxResponse, ExplainTxResponse, Tx, ParseTypedDataResponse, ParseTextResponse } from '@rabby-wallet/rabby-api/dist/types';
+import { ParseTxResponse, ExplainTxResponse, ParseTypedDataResponse, ParseTextResponse, Tx } from '@rabby-wallet/rabby-api/dist/types';
 import { ParsedActionData } from './parsedActionData';
 export type ParseTransactionActionParameters = {
     type: 'transaction';
     data: ParseTxResponse['action'];
-    balanceChange: ExplainTxResponse['balance_change'];
+    sender: string;
     tx: Tx;
+    balanceChange: ExplainTxResponse['balance_change'];
     preExecVersion: 'v0' | 'v1' | 'v2';
     gasUsed: number;
 };
@@ -13,12 +14,18 @@ export type ParseTypedDataActionParameters = {
     data: ParseTypedDataResponse['action'];
     typedData: null | Record<string, any>;
     sender: string;
+    balanceChange?: ExplainTxResponse['balance_change'];
+    preExecVersion?: 'v0' | 'v1' | 'v2';
+    gasUsed?: number;
 };
 export type ParseTextActionParameters = {
     type: 'text';
     data: ParseTextResponse['action'];
     text: string;
     sender: string;
+    balanceChange?: ExplainTxResponse['balance_change'];
+    preExecVersion?: 'v0' | 'v1' | 'v2';
+    gasUsed?: number;
 };
 export type ParseActionParameters = ParseTransactionActionParameters | ParseTypedDataActionParameters | ParseTextActionParameters;
 export type ActionType = ParseActionParameters['type'];

package/dist/types/parsedActionData.d.ts

@@ -1,4 +1,4 @@
-import { TokenItem, NFTItem, RevokeTokenApproveAction, PushMultiSigAction, ApproveNFTAction, BatchSellNFTOrderAction, BuyNFTOrderAction, CreateCoboSafeAction, CreateKeyAction, SellNFTOrderAction, SendAction, SignMultiSigActions, SubmitDelegatedAddressModificationAction, SubmitSafeRoleModificationAction, SubmitTokenApprovalModificationAction, VerifyAddressAction, BatchPermit2Action, Permit2Action, PermitAction, RevokeNFTAction, SendNFTAction, ApproveAction, ApproveNFTCollectionAction, RevokeNFTCollectionAction, RevokePermit2Action } from '@rabby-wallet/rabby-api/dist/types';
+import { TokenItem, NFTItem, RevokeTokenApproveAction, PushMultiSigAction, ApproveNFTAction, BatchSellNFTOrderAction, BuyNFTOrderAction, CreateCoboSafeAction, CreateKeyAction, SellNFTOrderAction, SendAction, SignMultiSigActions, SubmitDelegatedAddressModificationAction, SubmitSafeRoleModificationAction, SubmitTokenApprovalModificationAction, VerifyAddressAction, BatchPermit2Action, Permit2Action, PermitAction, RevokeNFTAction, SendNFTAction, ApproveAction, ApproveNFTCollectionAction, RevokeNFTCollectionAction, RevokePermit2Action, MaxPayTokenItem } from '@rabby-wallet/rabby-api/dist/types';
 import { ActionType } from './parseAction';
 export interface ReceiveTokenItem extends TokenItem {
     min_amount: number;
@@ -14,6 +14,21 @@ interface BatchPermit2ActionData extends BatchPermit2Action {
     sig_expire_at: number | undefined;
 }
 export type ParsedTransactionActionData = {
+    swapLimitPay?: {
+        payToken: MaxPayTokenItem;
+        receiveToken: TokenItem;
+        receiver: string;
+    };
+    multiSwap?: {
+        payTokenList: TokenItem[];
+        receiveTokenList: ReceiveTokenItem[];
+        receiver: string;
+    };
+    transferOwner?: {
+        description: string;
+        from: string;
+        to: string;
+    };
     swap?: {
         payToken: TokenItem;
         receiveToken: ReceiveTokenItem;
@@ -49,7 +64,7 @@ export type ParsedTransactionActionData = {
     revokeToken?: {
         spender: string;
         token: TokenItem;
-        gasUsed: number;
+        gasUsed?: number;
     };
     revokePermit2?: RevokePermit2Action;
     wrapToken?: {
@@ -66,7 +81,7 @@ export type ParsedTransactionActionData = {
     };
     deployContract?: Record<string, never>;
     cancelTx?: {
-        nonce: string;
+        nonce?: string;
     };
     pushMultiSig?: PushMultiSigAction;
     permit2BatchRevokeToken?: {
@@ -94,7 +109,7 @@ export type ParsedTransactionActionData = {
         from: string;
     };
 };
-export type ParsedTypedDataActionData = {
+export type ParsedTypedDataActionData = ParsedTransactionActionData & {
     chainId?: string;
     brand?: {
         logo_url: string;
@@ -146,7 +161,7 @@ export type ParsedTypedDataActionData = {
         from: string;
     };
 };
-export type ParsedTextActionData = {
+export type ParsedTextActionData = ParsedTransactionActionData & {
     sender: string;
     createKey?: CreateKeyAction;
     verifyAddress?: VerifyAddressAction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/rabby-action",
-  "version": "0.1.0",
+  "version": "0.1.1-beta.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -15,8 +15,8 @@
   "devDependencies": {
     "@babel/preset-env": "^7.19.1",
     "@debank/common": "^0.3.60",
-    "@rabby-wallet/rabby-api": "^0.7.26",
-    "@rabby-wallet/rabby-security-engine": "^2.0.5",
+    "@rabby-wallet/rabby-api": "0.7.28",
+    "@rabby-wallet/rabby-security-engine": "2.0.7-beta",
     "@types/jest": "^29.0.3",
     "@types/lodash": "^4.14.185",
     "@types/node": "^18.7.18",