@rabby-wallet/rabby-action 0.1.0

package/dist/actions/wrapToken/fetchData.js

@@ -0,0 +1,19 @@
+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 fetchDataWrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    if (!options.actionData.wrapToken) {
+        return {};
+    }
+    return fetchDataSwap(options, options.actionData.wrapToken);
+});

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

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

package/dist/actions/wrapToken/formatSecurityEngine.js

@@ -0,0 +1,34 @@
+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 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 {};
+    }
+    const { slippageTolerance, receiver } = actionData.wrapToken;
+    const data = requireData;
+    return {
+        wrapToken: {
+            slippageTolerance,
+            receiver,
+            from: data.sender,
+            chainId,
+            id: data.id,
+            receiverInWallet: data.receiverInWallet,
+        },
+        contractCall: {
+            id: data.id,
+            chainId,
+        },
+    };
+});

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

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

package/dist/actions/wrapToken/parseAction.js

@@ -0,0 +1,17 @@
+import { calcSlippageTolerance } from '../../utils/calcSlippageTolerance';
+export const parseActionWrapToken = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'wrap_token') {
+        return {};
+    }
+    const { pay_token, receive_token, receiver } = data.data;
+    const slippageTolerance = calcSlippageTolerance(pay_token.raw_amount || '0', receive_token.min_raw_amount || '0');
+    return {
+        wrapToken: {
+            payToken: pay_token,
+            receiveToken: receive_token,
+            slippageTolerance,
+            receiver,
+        },
+    };
+};

package/dist/fetchActionRequiredData.d.ts

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

package/dist/fetchActionRequiredData.js

@@ -0,0 +1,87 @@
+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 { fetchDataDeployContract } from './actions/deployContract/fetchData';
+import { fetchDataSend } from './actions/send/fetchData';
+import { fetchDataSendNFT } from './actions/sendNFT/fetchData';
+import { fetchDataSwap } from './actions/swap/fetchData';
+import { fetchDataCrossToken } from './actions/crossToken/fetchData';
+import { fetchDataCrossSwapToken } from './actions/crossSwapToken/fetchData';
+import { fetchDataApproveToken } from './actions/approveToken/fetchData';
+import { fetchDataApproveNFT } from './actions/approveNFT/fetchData';
+import { fetchDataCancelTx } from './actions/cancelTx/fetchData';
+import { fetchDataContractCall } from './actions/contractCall/fetchData';
+import { fetchDataRevokeNFT } from './actions/revokeNFT/fetchData';
+import { fetchDataRevokePermit2 } from './actions/revokePermit2/fetchData';
+import { fetchDataRevokeToken } from './actions/revokeToken/fetchData';
+import { fetchDataWrapToken } from './actions/wrapToken/fetchData';
+import { fetchDataUnwrapToken } from './actions/unwrapToken/fetchData';
+import { fetchDataApproveNFTCollection } from './actions/approveNFTCollection/fetchData';
+import { fetchDataAssetOrder } from './actions/assetOrder/fetchData';
+import { fetchDataCommon } from './actions/common/fetchData';
+import { fetchDataPushMultiSig } from './actions/pushMultiSig/fetchData';
+import { fetchDataRevokeNFTCollection } from './actions/revokeNFTCollection/fetchData';
+import { fetchDataPermit2BatchRevokeToken } from './actions/permit2BatchRevokeToken/fetchData';
+import { fetchDataBatchPermit2 } from './actions/batchPermit2/fetchData';
+import { fetchDataBatchSellNFT } from './actions/batchSellNFT/fetchData';
+import { fetchDataBuyNFT } from './actions/buyNFT/fetchData';
+import { fetchDataCoboSafeCreate } from './actions/coboSafeCreate/fetchData';
+import { fetchDataCoboSafeModificationDelegatedAddress } from './actions/coboSafeModificationDelegatedAddress/fetchData';
+import { fetchDataCoboSafeModificationRole } from './actions/coboSafeModificationRole/fetchData';
+import { fetchDataCoboSafeModificationTokenApproval } from './actions/coboSafeModificationTokenApproval/fetchData';
+import { fetchDataCreateKey } from './actions/createKey/fetchData';
+import { fetchDataPermit } from './actions/permit/fetchData';
+import { fetchDataPermit2 } from './actions/permit2/fetchData';
+import { fetchDataRevokePermit } from './actions/revokePermit/fetchData';
+import { fetchDataSellNFT } from './actions/sellNFT/fetchData';
+import { fetchDataSignMultiSig } from './actions/signMultiSig/fetchData';
+import { fetchDataSwapTokenOrder } from './actions/swapTokenOrder/fetchData';
+import { fetchDataVerifyAddress } from './actions/verifyAddress/fetchData';
+export const fetchActionRequiredData = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield Promise.all([
+        fetchDataApproveNFT(options),
+        fetchDataApproveNFTCollection(options),
+        fetchDataApproveToken(options),
+        fetchDataAssetOrder(options),
+        fetchDataCancelTx(options),
+        // @deprecated we don't parse common action data anymore, will be removed in the future
+        fetchDataCommon(options),
+        fetchDataContractCall(options),
+        fetchDataCrossSwapToken(options),
+        fetchDataCrossToken(options),
+        fetchDataDeployContract(options),
+        fetchDataPushMultiSig(options),
+        fetchDataRevokeNFT(options),
+        fetchDataRevokeNFTCollection(options),
+        fetchDataRevokePermit2(options),
+        fetchDataRevokeToken(options),
+        fetchDataSend(options),
+        fetchDataSendNFT(options),
+        fetchDataSwap(options),
+        fetchDataUnwrapToken(options),
+        fetchDataWrapToken(options),
+        fetchDataPermit2BatchRevokeToken(options),
+        fetchDataSellNFT(options),
+        fetchDataBatchSellNFT(options),
+        fetchDataSignMultiSig(options),
+        fetchDataBuyNFT(options),
+        fetchDataPermit(options),
+        fetchDataPermit2(options),
+        fetchDataBatchPermit2(options),
+        fetchDataSwapTokenOrder(options),
+        fetchDataCreateKey(options),
+        fetchDataVerifyAddress(options),
+        fetchDataCoboSafeCreate(options),
+        fetchDataCoboSafeModificationDelegatedAddress(options),
+        fetchDataCoboSafeModificationRole(options),
+        fetchDataCoboSafeModificationTokenApproval(options),
+        fetchDataRevokePermit(options),
+    ]);
+    return result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
+});

package/dist/formatSecurityEngineContext.d.ts

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

package/dist/formatSecurityEngineContext.js

@@ -0,0 +1,89 @@
+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 { formatSecurityEngineApproveNFT } from './actions/approveNFT/formatSecurityEngine';
+import { formatSecurityEngineApproveNFTCollection } from './actions/approveNFTCollection/formatSecurityEngine';
+import { formatSecurityEngineApproveToken } from './actions/approveToken/formatSecurityEngine';
+import { formatSecurityEngineAssetOrder } from './actions/assetOrder/formatSecurityEngine';
+import { formatSecurityEngineCancelTx } from './actions/cancelTx/formatSecurityEngine';
+import { formatSecurityEngineCommon } from './actions/common/formatSecurityEngine';
+import { formatSecurityEngineContractCall } from './actions/contractCall/formatSecurityEngine';
+import { formatSecurityEngineCrossSwapToken } from './actions/crossSwapToken/formatSecurityEngine';
+import { formatSecurityEngineCrossToken } from './actions/crossToken/formatSecurityEngine';
+import { formatSecurityEngineDeployContract } from './actions/deployContract/formatSecurityEngine';
+import { formatSecurityEnginePushMultiSig } from './actions/pushMultiSig/formatSecurityEngine';
+import { formatSecurityEngineRevokeNFT } from './actions/revokeNFT/formatSecurityEngine';
+import { formatSecurityEngineRevokeNFTCollection } from './actions/revokeNFTCollection/formatSecurityEngine';
+import { formatSecurityEngineRevokePermit2 } from './actions/revokePermit2/formatSecurityEngine';
+import { formatSecurityEngineRevokeToken } from './actions/revokeToken/formatSecurityEngine';
+import { formatSecurityEngineSend } from './actions/send/formatSecurityEngine';
+import { formatSecurityEngineSendNFT } from './actions/sendNFT/formatSecurityEngine';
+import { formatSecurityEngineSwap } from './actions/swap/formatSecurityEngine';
+import { formatSecurityEngineUnwrapToken } from './actions/unwrapToken/formatSecurityEngine';
+import { formatSecurityEngineWrapToken } from './actions/wrapToken/formatSecurityEngine';
+import { formatSecurityEnginePermit2BatchRevokeToken } from './actions/permit2BatchRevokeToken/formatSecurityEngine';
+import { formatSecurityEngineBatchPermit2 } from './actions/batchPermit2/formatSecurityEngine';
+import { formatSecurityEngineBatchSellNFT } from './actions/batchSellNFT/formatSecurityEngine';
+import { formatSecurityEngineBuyNFT } from './actions/buyNFT/formatSecurityEngine';
+import { formatSecurityEngineCoboSafeCreate } from './actions/coboSafeCreate/formatSecurityEngine';
+import { formatSecurityEngineCoboSafeModificationDelegatedAddress } from './actions/coboSafeModificationDelegatedAddress/formatSecurityEngine';
+import { formatSecurityEngineCoboSafeModificationRole } from './actions/coboSafeModificationRole/formatSecurityEngine';
+import { formatSecurityEngineCoboSafeModificationTokenApproval } from './actions/coboSafeModificationTokenApproval/formatSecurityEngine';
+import { formatSecurityEngineCreateKey } from './actions/createKey/formatSecurityEngine';
+import { formatSecurityEnginePermit } from './actions/permit/formatSecurityEngine';
+import { formatSecurityEnginePermit2 } from './actions/permit2/formatSecurityEngine';
+import { formatSecurityEngineRevokePermit } from './actions/revokePermit/formatSecurityEngine';
+import { formatSecurityEngineSellNFT } from './actions/sellNFT/formatSecurityEngine';
+import { formatSecurityEngineSignMultiSig } from './actions/signMultiSig/formatSecurityEngine';
+import { formatSecurityEngineSwapTokenOrder } from './actions/swapTokenOrder/formatSecurityEngine';
+import { formatSecurityEngineVerifyAddress } from './actions/verifyAddress/formatSecurityEngine';
+export const formatSecurityEngineContext = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'text' && options.isTestnet) {
+        return {};
+    }
+    const result = yield Promise.all([
+        formatSecurityEngineApproveNFT(options),
+        formatSecurityEngineApproveNFTCollection(options),
+        formatSecurityEngineApproveToken(options),
+        formatSecurityEngineAssetOrder(options),
+        formatSecurityEngineCancelTx(options),
+        formatSecurityEngineCommon(options),
+        formatSecurityEngineContractCall(options),
+        formatSecurityEngineCrossSwapToken(options),
+        formatSecurityEngineCrossToken(options),
+        formatSecurityEngineDeployContract(options),
+        formatSecurityEnginePushMultiSig(options),
+        formatSecurityEngineRevokeNFT(options),
+        formatSecurityEngineRevokeNFTCollection(options),
+        formatSecurityEngineRevokePermit2(options),
+        formatSecurityEngineRevokeToken(options),
+        formatSecurityEngineSend(options),
+        formatSecurityEngineSendNFT(options),
+        formatSecurityEngineSwap(options),
+        formatSecurityEngineUnwrapToken(options),
+        formatSecurityEngineWrapToken(options),
+        formatSecurityEnginePermit2BatchRevokeToken(options),
+        formatSecurityEngineSellNFT(options),
+        formatSecurityEngineBatchSellNFT(options),
+        formatSecurityEngineSignMultiSig(options),
+        formatSecurityEngineBuyNFT(options),
+        formatSecurityEnginePermit(options),
+        formatSecurityEnginePermit2(options),
+        formatSecurityEngineBatchPermit2(options),
+        formatSecurityEngineSwapTokenOrder(options),
+        formatSecurityEngineCreateKey(options),
+        formatSecurityEngineVerifyAddress(options),
+        formatSecurityEngineCoboSafeCreate(options),
+        formatSecurityEngineCoboSafeModificationDelegatedAddress(options),
+        formatSecurityEngineCoboSafeModificationRole(options),
+        formatSecurityEngineCoboSafeModificationTokenApproval(options),
+        formatSecurityEngineRevokePermit(options),
+    ]);
+    return result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './parseAction';
+export * from './fetchActionRequiredData';
+export * from './formatSecurityEngineContext';
+export * from './types';
+export * from './utils/getProtocol';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './parseAction';
+export * from './fetchActionRequiredData';
+export * from './formatSecurityEngineContext';
+export * from './types';
+export * from './utils/getProtocol';

package/dist/parseAction.d.ts

@@ -0,0 +1,4 @@
+import { ParsedActionData, ParseTextActionParameters, ParseTransactionActionParameters, ParseTypedDataActionParameters } from './types';
+export declare function parseAction(options: ParseTypedDataActionParameters): ParsedActionData<'typed_data'>;
+export declare function parseAction(options: ParseTransactionActionParameters): ParsedActionData<'transaction'>;
+export declare function parseAction(options: ParseTextActionParameters): ParsedActionData<'text'>;

package/dist/parseAction.js

@@ -0,0 +1,66 @@
+import { parseActionSend } from './actions/send/parseAction';
+import { parseActionApproveNFT } from './actions/approveNFT/parseAction';
+import { parseActionApproveNFTCollection } from './actions/approveNFTCollection/parseAction';
+import { parseActionApproveToken } from './actions/approveToken/parseAction';
+import { parseActionAssetOrder } from './actions/assetOrder/parseAction';
+import { parseActionCancelTx } from './actions/cancelTx/parseAction';
+import { parseActionCommon } from './actions/common/parseAction';
+import { parseActionContractCall } from './actions/contractCall/parseAction';
+import { parseActionCrossSwapToken } from './actions/crossSwapToken/parseAction';
+import { parseActionCrossToken } from './actions/crossToken/parseAction';
+import { parseActionDeployContract } from './actions/deployContract/parseAction';
+import { parseActionPushMultiSig } from './actions/pushMultiSig/parseAction';
+import { parseActionRevokeNFT } from './actions/revokeNFT/parseAction';
+import { parseActionRevokeNFTCollection } from './actions/revokeNFTCollection/parseAction';
+import { parseActionRevokePermit2 } from './actions/revokePermit2/parseAction';
+import { parseActionRevokeToken } from './actions/revokeToken/parseAction';
+import { parseActionSendNFT } from './actions/sendNFT/parseAction';
+import { parseActionSwap } from './actions/swap/parseAction';
+import { parseActionUnwrapToken } from './actions/unwrapToken/parseAction';
+import { parseActionWrapToken } from './actions/wrapToken/parseAction';
+import { parseActionPermit2BatchRevokeToken } from './actions/permit2BatchRevokeToken/parseAction';
+import { parseActionBatchPermit2 } from './actions/batchPermit2/parseAction';
+import { parseActionBatchSellNFT } from './actions/batchSellNFT/parseAction';
+import { parseActionBuyNFT } from './actions/buyNFT/parseAction';
+import { parseActionCoboSafeCreate } from './actions/coboSafeCreate/parseAction';
+import { parseActionCoboSafeModificationDelegatedAddress } from './actions/coboSafeModificationDelegatedAddress/parseAction';
+import { parseActionCoboSafeModificationRole } from './actions/coboSafeModificationRole/parseAction';
+import { parseActionCoboSafeModificationTokenApproval } from './actions/coboSafeModificationTokenApproval/parseAction';
+import { parseActionCreateKey } from './actions/createKey/parseAction';
+import { parseActionPermit } from './actions/permit/parseAction';
+import { parseActionPermit2 } from './actions/permit2/parseAction';
+import { parseActionRevokePermit } from './actions/revokePermit/parseAction';
+import { parseActionSellNFT } from './actions/sellNFT/parseAction';
+import { parseActionSignMultiSig } from './actions/signMultiSig/parseAction';
+import { parseActionSwapTokenOrder } from './actions/swapTokenOrder/parseAction';
+import { parseActionVerifyAddress } from './actions/verifyAddress/parseAction';
+import { parseTypedDataAction } from './utils/parseTypedDataAction';
+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));
+    }
+    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));
+    }
+    if (options.type === 'text') {
+        result.push(parseTextAction(parseActionCommon)(options), parseTextAction(parseActionCreateKey)(options), parseTextAction(parseActionVerifyAddress)(options));
+    }
+    const action = result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
+    // filter out typedData or text keys
+    const actionKeys = Object.keys(action).filter((key) => !['sender', 'actionType', 'brand', 'contractId', 'chainId'].includes(key));
+    if (actionKeys.length > 1) {
+        console.error('parseAction: more than one action found', Object.keys(action));
+    }
+    if (actionKeys.length === 0) {
+        if (options.type === 'typed_data') {
+            return parseTypedDataAction(parseActionContractCall)(options);
+        }
+        else if (options.type === 'transaction') {
+            return parseActionContractCall(options);
+        }
+        return {};
+    }
+    return action;
+}

package/dist/types/actionRequireData.d.ts

@@ -0,0 +1,158 @@
+import { ContractDesc, UsedChain, CollectionWithFloorPrice, TokenItem, ParseTxResponse, Chain } from '@rabby-wallet/rabby-api/dist/types';
+import { TransactionGroup } from './walletProvider';
+export interface SwapRequireData {
+    id: string;
+    protocol: {
+        name: string;
+        logo_url: string;
+    } | null;
+    bornAt: number;
+    hasInteraction: boolean;
+    rank: number | null;
+    sender: string;
+    receiverInWallet: boolean;
+}
+export interface SendRequireData {
+    eoa: {
+        id: string;
+        bornAt: number;
+    } | null;
+    cex: {
+        id: string;
+        name: string;
+        logo: string;
+        bornAt: number;
+        isDeposit: boolean;
+        supportToken?: boolean;
+    } | null;
+    contract: Record<string, ContractDesc> | null;
+    usd_value: number;
+    protocol: {
+        id: string;
+        logo_url: string;
+        name: string;
+    } | null;
+    hasTransfer: boolean;
+    isTokenContract: boolean;
+    usedChains: UsedChain[];
+    name: string | null;
+    onTransferWhitelist: boolean;
+    whitelistEnable: boolean;
+    receiverIsSpoofing: boolean;
+    hasReceiverPrivateKeyInWallet: boolean;
+    hasReceiverMnemonicInWallet: boolean;
+}
+export interface SendNFTRequireData extends SendRequireData {
+    collection?: CollectionWithFloorPrice | null;
+}
+export interface ApproveTokenRequireData {
+    isEOA: boolean;
+    contract: Record<string, ContractDesc> | null;
+    riskExposure: number;
+    rank: number | null;
+    hasInteraction: boolean;
+    bornAt: number;
+    protocol: {
+        id: string;
+        name: string;
+        logo_url: string;
+    } | null;
+    isDanger: boolean | null;
+    token: TokenItem;
+}
+export type RevokeTokenApproveRequireData = ApproveTokenRequireData;
+export interface WrapTokenRequireData {
+    id: string;
+    protocol: {
+        name: string;
+        logo_url: string;
+    } | null;
+    bornAt: number;
+    hasInteraction: boolean;
+    rank: number | null;
+    sender: string;
+    receiverInWallet: boolean;
+}
+export interface ContractCallRequireData {
+    id: string;
+    contract: Record<string, ContractDesc> | null;
+    rank: number | null;
+    hasInteraction: boolean;
+    bornAt: number;
+    protocol: {
+        name: string;
+        logo_url: string;
+    } | null;
+    call: NonNullable<ParseTxResponse['contract_call']>;
+    payNativeTokenAmount: string;
+    nativeTokenSymbol: string;
+    unexpectedAddr: ReceiverData | null;
+    receiverInWallet: boolean;
+}
+export type ApproveNFTRequireData = Omit<ApproveTokenRequireData, 'token'> & {
+    tokenBalance: string;
+};
+export type RevokeNFTRequireData = ApproveNFTRequireData;
+export interface CancelTxRequireData {
+    pendingTxs: TransactionGroup[];
+}
+export interface PushMultiSigRequireData {
+    contract: Record<string, ContractDesc> | null;
+    id: string;
+}
+export type BatchRevokePermit2RequireData = Record<string, Omit<ApproveTokenRequireData, 'token'>>;
+export interface ReceiverData {
+    title?: string;
+    address: string;
+    chain: Chain;
+    eoa: {
+        id: string;
+        bornAt: number;
+    } | null;
+    cex: {
+        id: string;
+        name: string;
+        logo: string;
+        bornAt: number;
+        isDeposit: boolean;
+        supportToken?: boolean;
+    } | null;
+    contract: Record<string, ContractDesc> | null;
+    usd_value: number;
+    hasTransfer: boolean;
+    isTokenContract: boolean;
+    name: string | null;
+    onTransferWhitelist: boolean;
+    token?: TokenItem;
+    isLabelAddress?: boolean;
+    labelAddressLogo?: string;
+    hasReceiverMnemonicInWallet?: boolean;
+    hasReceiverPrivateKeyInWallet?: boolean;
+    rank?: number;
+}
+export interface ContractRequireData {
+    id: string;
+    protocol: {
+        name: string;
+        logo_url: string;
+    } | null;
+    bornAt: number;
+    hasInteraction: boolean;
+    rank: number | null;
+    unexpectedAddr: ReceiverData | null;
+    receiverInWallet: boolean;
+}
+export interface AssetOrderRequireData extends ContractRequireData {
+    sender: string;
+}
+export interface MultiSigRequireData {
+    id: string;
+    contract: Record<string, ContractDesc> | null;
+}
+export interface SwapTokenOrderRequireData extends ContractRequireData {
+    sender: string;
+}
+export type BatchApproveTokenRequireData = Omit<ApproveTokenRequireData, 'token'> & {
+    tokens: TokenItem[];
+};
+export type ActionRequireData = SwapRequireData | ApproveTokenRequireData | SendRequireData | ApproveNFTRequireData | RevokeNFTRequireData | ContractCallRequireData | Record<string, any> | ContractCallRequireData | CancelTxRequireData | WrapTokenRequireData | PushMultiSigRequireData | AssetOrderRequireData | BatchRevokePermit2RequireData | SwapTokenOrderRequireData | ContractRequireData | MultiSigRequireData | BatchApproveTokenRequireData | null;

package/dist/types/actionRequireData.js

@@ -0,0 +1 @@
+export {};

package/dist/types/fetchActionRequiredData.d.ts

@@ -0,0 +1,24 @@
+import { ParseTxResponse, Tx } from '@rabby-wallet/rabby-api/dist/types';
+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> = {
+    actionData: ParsedActionData<T>;
+    sender: string;
+    walletProvider: WalletProvider;
+    apiProvider: OpenApiService;
+};
+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 FetchActionRequiredData<T = undefined> = (options: FetchActionRequiredDataParameters, likeAction?: T) => Promise<ActionRequireData>;
+export {};

package/dist/types/fetchActionRequiredData.js

@@ -0,0 +1 @@
+export {};

package/dist/types/formatSecurityEngineContext.d.ts

@@ -0,0 +1,40 @@
+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;
+    isTestnet: boolean;
+    chainId?: string;
+    provider: {
+        getTimeSpan: (time: number) => {
+            d: number;
+            h: number;
+            m: number;
+            s: number;
+        };
+        hasAddress: (address: string) => Promise<boolean>;
+    };
+} | {
+    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>;
+    };
+} | {
+    type: 'text';
+    actionData: ParsedActionData<'text'>;
+    origin: string;
+};
+export type FormatSecurityEngineContext = (options: FormatSecurityEngineContextParameters) => Promise<ContextActionData>;

package/dist/types/formatSecurityEngineContext.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './actionRequireData';
+export * from './fetchActionRequiredData';
+export * from './formatSecurityEngineContext';
+export * from './parseAction';
+export * from './parsedActionData';

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from './actionRequireData';
+export * from './fetchActionRequiredData';
+export * from './formatSecurityEngineContext';
+export * from './parseAction';
+export * from './parsedActionData';

package/dist/types/parseAction.d.ts

@@ -0,0 +1,26 @@
+import { ParseTxResponse, ExplainTxResponse, Tx, ParseTypedDataResponse, ParseTextResponse } from '@rabby-wallet/rabby-api/dist/types';
+import { ParsedActionData } from './parsedActionData';
+export type ParseTransactionActionParameters = {
+    type: 'transaction';
+    data: ParseTxResponse['action'];
+    balanceChange: ExplainTxResponse['balance_change'];
+    tx: Tx;
+    preExecVersion: 'v0' | 'v1' | 'v2';
+    gasUsed: number;
+};
+export type ParseTypedDataActionParameters = {
+    type: 'typed_data';
+    data: ParseTypedDataResponse['action'];
+    typedData: null | Record<string, any>;
+    sender: string;
+};
+export type ParseTextActionParameters = {
+    type: 'text';
+    data: ParseTextResponse['action'];
+    text: string;
+    sender: string;
+};
+export type ParseActionParameters = ParseTransactionActionParameters | ParseTypedDataActionParameters | ParseTextActionParameters;
+export type ActionType = ParseActionParameters['type'];
+export type ParseAction<T extends ActionType | undefined = undefined> = (options: T extends 'transaction' ? ParseTransactionActionParameters : T extends 'typed_data' ? ParseTypedDataActionParameters : T extends 'text' ? ParseTextActionParameters : ParseActionParameters) => ParsedActionData<T>;
+export type PartialParseAction<T extends ActionType | undefined = undefined> = (options: T extends 'transaction' ? ParseTransactionActionParameters : T extends 'typed_data' ? ParseTypedDataActionParameters : T extends 'text' ? ParseTextActionParameters : ParseActionParameters) => Partial<ParsedActionData<T>>;

package/dist/types/parseAction.js

@@ -0,0 +1 @@
+export {};