@rabby-wallet/rabby-action 0.1.0

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

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

package/dist/actions/send/formatSecurityEngine.js

@@ -0,0 +1,47 @@
+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 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 {};
+    }
+    const data = requireData;
+    const { to } = actionData.send;
+    return {
+        send: {
+            to,
+            contract: data.contract
+                ? {
+                    chains: Object.keys(data.contract),
+                }
+                : null,
+            cex: data.cex
+                ? {
+                    id: data.cex.id,
+                    isDeposit: data.cex.isDeposit,
+                    supportToken: data.cex.supportToken,
+                }
+                : null,
+            hasTransfer: data.hasTransfer,
+            chainId,
+            usedChainList: data.usedChains.map((item) => item.id),
+            isTokenContract: data.isTokenContract,
+            onTransferWhitelist: data.whitelistEnable
+                ? data.onTransferWhitelist
+                : false,
+            receiverIsSpoofing: data.receiverIsSpoofing,
+            hasReceiverMnemonicInWallet: data.hasReceiverMnemonicInWallet,
+            hasReceiverPrivateKeyInWallet: data.hasReceiverPrivateKeyInWallet,
+        },
+    };
+});

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

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

package/dist/actions/send/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionSend = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'send_token') {
+        return {};
+    }
+    return {
+        send: data.data,
+    };
+};

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

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

package/dist/actions/sendNFT/fetchData.js

@@ -0,0 +1,26 @@
+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 { 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 {};
+    }
+    return yield fetchDataSend(options, {
+        to: sendNFT.to,
+        token: {
+            id: sendNFT.nft.contract_id,
+            chain: options.chainId,
+        },
+    });
+});

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

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

package/dist/actions/sendNFT/formatSecurityEngine.js

@@ -0,0 +1,46 @@
+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 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 {};
+    }
+    const data = requireData;
+    const { to } = actionData.sendNFT;
+    return {
+        sendNFT: {
+            to,
+            contract: data.contract
+                ? {
+                    chains: Object.keys(data.contract),
+                }
+                : null,
+            cex: data.cex
+                ? {
+                    id: data.cex.id,
+                    isDeposit: data.cex.isDeposit,
+                    supportToken: data.cex.supportToken,
+                }
+                : null,
+            hasTransfer: data.hasTransfer,
+            chainId,
+            usedChainList: data.usedChains.map((item) => item.id),
+            onTransferWhitelist: data.whitelistEnable
+                ? data.onTransferWhitelist
+                : false,
+            receiverIsSpoofing: data.receiverIsSpoofing,
+            hasReceiverMnemonicInWallet: data.hasReceiverMnemonicInWallet,
+            hasReceiverPrivateKeyInWallet: data.hasReceiverPrivateKeyInWallet,
+        },
+    };
+});

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

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

package/dist/actions/sendNFT/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionSendNFT = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'send_nft') {
+        return {};
+    }
+    return {
+        sendNFT: data.data,
+    };
+};

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

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

package/dist/actions/signMultiSig/fetchData.js

@@ -0,0 +1,27 @@
+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 fetchDataSignMultiSig = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, apiProvider } = options;
+    if (!actionData.signMultiSig) {
+        return {};
+    }
+    const result = {
+        contract: null,
+        id: actionData.signMultiSig.multisig_id,
+    };
+    const { desc } = yield apiProvider.addrDesc(actionData.signMultiSig.multisig_id);
+    if (desc.contract) {
+        result.contract = desc.contract;
+    }
+    return result;
+});

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

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

package/dist/actions/signMultiSig/formatSecurityEngine.js

@@ -0,0 +1,12 @@
+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 formatSecurityEngineSignMultiSig = () => __awaiter(void 0, void 0, void 0, function* () {
+    return {};
+});

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

@@ -0,0 +1,2 @@
+import { PartialParseAction } from '../../types';
+export declare const parseActionSignMultiSig: PartialParseAction<'typed_data'>;

package/dist/actions/signMultiSig/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionSignMultiSig = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'sign_multisig') {
+        return {};
+    }
+    return {
+        signMultiSig: data.data,
+    };
+};

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

@@ -0,0 +1,4 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataSwap: FetchActionRequiredData<{
+    receiver: string;
+}>;

package/dist/actions/swap/fetchData.js

@@ -0,0 +1,51 @@
+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 fetchDataSwap = (options, likeSwapAction) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    const queue = new PQueue();
+    const { actionData, walletProvider, tx, 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 result = {
+        id,
+        protocol: null,
+        bornAt: 0,
+        hasInteraction: false,
+        rank: null,
+        sender,
+        receiverInWallet,
+    };
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const contractInfo = yield apiProvider.getContractInfo(id, chainId);
+        if (!contractInfo) {
+            result.rank = null;
+        }
+        else {
+            result.rank = contractInfo.credit.rank_at;
+            result.bornAt = contractInfo.create_at;
+            result.protocol = contractInfo.protocol;
+        }
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const hasInteraction = yield apiProvider.hasInteraction(sender, chainId, id);
+        result.hasInteraction = hasInteraction.has_interaction;
+    }));
+    yield waitQueueFinished(queue);
+    return result;
+});

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

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

package/dist/actions/swap/formatSecurityEngine.js

@@ -0,0 +1,39 @@
+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 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 {};
+    }
+    const data = requireData;
+    const { receiver, receiveToken, slippageTolerance, usdValuePercentage } = actionData.swap;
+    const { sender, id } = data;
+    const receiveTokenIsFake = receiveToken.is_verified === false;
+    const receiveTokenIsScam = receiveTokenIsFake
+        ? false
+        : !!receiveToken.is_suspicious;
+    return {
+        swap: {
+            receiveTokenIsScam,
+            receiveTokenIsFake,
+            receiver,
+            from: sender,
+            chainId,
+            id: data.id,
+            contractAddress: id,
+            slippageTolerance,
+            usdValuePercentage,
+            receiverInWallet: data.receiverInWallet,
+        },
+    };
+});

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

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

package/dist/actions/swap/parseAction.js

@@ -0,0 +1,43 @@
+import BigNumber from 'bignumber.js';
+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;
+    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 supportBalanceChange = preExecVersion !== 'v0';
+    const actualReceiveToken = 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 usdValueDiff = hasReceiver || !balanceChangeSuccess || !supportBalanceChange
+        ? null
+        : receiveTokenUsdValue.minus(payTokenUsdValue).toFixed();
+    const usdValuePercentage = hasReceiver || !balanceChangeSuccess || !supportBalanceChange
+        ? null
+        : calcUSDValueChange(payTokenUsdValue.toFixed(), receiveTokenUsdValue.toFixed());
+    const minReceive = Object.assign(Object.assign({}, receiveToken), { amount: receiveToken.min_amount || 0 });
+    return {
+        swap: {
+            payToken,
+            receiveToken: Object.assign(Object.assign({}, receiveToken), { amount: receiveTokenAmount }),
+            minReceive,
+            slippageTolerance,
+            receiver,
+            usdValueDiff,
+            usdValuePercentage,
+            balanceChange: {
+                success: balanceChangeSuccess,
+                support: supportBalanceChange,
+            },
+        },
+    };
+};

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

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

package/dist/actions/swapTokenOrder/fetchData.js

@@ -0,0 +1,21 @@
+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 { fetchDataCommon } from '../common/fetchData';
+export const fetchDataSwapTokenOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    if (!options.actionData.contractId || !options.actionData.swapTokenOrder) {
+        return {};
+    }
+    return fetchDataCommon(options, {
+        receiver: options.actionData.contractId,
+    });
+});

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

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

package/dist/actions/swapTokenOrder/formatSecurityEngine.js

@@ -0,0 +1,35 @@
+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 formatSecurityEngineSwapTokenOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.swapTokenOrder) {
+        return {};
+    }
+    const receiverInWallet = yield provider.hasAddress(actionData.swapTokenOrder.receiver);
+    const receiveTokenIsFake = actionData.swapTokenOrder.receiveToken.is_verified === false;
+    const receiveTokenIsScam = receiveTokenIsFake
+        ? false
+        : !!actionData.swapTokenOrder.receiveToken.is_suspicious;
+    return {
+        swapTokenOrder: {
+            receiveTokenIsFake,
+            receiveTokenIsScam,
+            receiver: actionData.swapTokenOrder.receiver,
+            from: actionData.sender,
+            usdValuePercentage: actionData.swapTokenOrder.usdValuePercentage,
+            chainId,
+            id: actionData.contractId,
+            receiverInWallet,
+        },
+    };
+});

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

@@ -0,0 +1,2 @@
+import { PartialParseAction } from '../../types';
+export declare const parseActionSwapTokenOrder: PartialParseAction<'typed_data'>;

package/dist/actions/swapTokenOrder/parseAction.js

@@ -0,0 +1,27 @@
+import BigNumber from 'bignumber.js';
+import { calcUSDValueChange } from '../../utils/calcUSDValueChange';
+export const parseActionSwapTokenOrder = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'swap_token_order') {
+        return {};
+    }
+    const actionData = data.data;
+    const receiveTokenUsdValue = new BigNumber(actionData.receive_token.raw_amount || '0')
+        .div(10 ** actionData.receive_token.decimals)
+        .times(actionData.receive_token.price);
+    const payTokenUsdValue = new BigNumber(actionData.pay_token.raw_amount || '0')
+        .div(10 ** actionData.pay_token.decimals)
+        .times(actionData.pay_token.price);
+    const usdValueDiff = receiveTokenUsdValue.minus(payTokenUsdValue).toFixed();
+    const usdValuePercentage = calcUSDValueChange(payTokenUsdValue.toFixed(), receiveTokenUsdValue.toFixed());
+    return {
+        swapTokenOrder: {
+            payToken: actionData.pay_token,
+            receiveToken: actionData.receive_token,
+            receiver: actionData.receiver,
+            usdValueDiff,
+            usdValuePercentage,
+            expireAt: actionData.expire_at,
+        },
+    };
+};

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

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

package/dist/actions/unwrapToken/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 fetchDataUnwrapToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    if (!options.actionData.unWrapToken) {
+        return {};
+    }
+    return fetchDataSwap(options, options.actionData.unWrapToken);
+});

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

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

package/dist/actions/unwrapToken/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 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 {};
+    }
+    const { slippageTolerance, receiver } = actionData.unWrapToken;
+    const data = requireData;
+    return {
+        unwrapToken: {
+            slippageTolerance,
+            receiver,
+            from: data.sender,
+            chainId,
+            id: data.id,
+            receiverInWallet: data.receiverInWallet,
+        },
+        contractCall: {
+            id: data.id,
+            chainId,
+        },
+    };
+});

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

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

package/dist/actions/unwrapToken/parseAction.js

@@ -0,0 +1,17 @@
+import { calcSlippageTolerance } from '../../utils/calcSlippageTolerance';
+export const parseActionUnwrapToken = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'unwrap_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 {
+        unWrapToken: {
+            payToken: pay_token,
+            receiveToken: receive_token,
+            slippageTolerance,
+            receiver,
+        },
+    };
+};

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

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

package/dist/actions/verifyAddress/fetchData.js

@@ -0,0 +1,12 @@
+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 fetchDataVerifyAddress = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    return {};
+});

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

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

package/dist/actions/verifyAddress/formatSecurityEngine.js

@@ -0,0 +1,24 @@
+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 formatSecurityEngineVerifyAddress = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'text' && options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, origin } = options;
+    if (!actionData.verifyAddress) {
+        return {};
+    }
+    return {
+        verifyAddress: {
+            allowOrigins: actionData.verifyAddress.allow_origins,
+            origin,
+        },
+    };
+});

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

@@ -0,0 +1,2 @@
+import { PartialParseAction } from '../../types';
+export declare const parseActionVerifyAddress: PartialParseAction<'typed_data' | 'text'>;

package/dist/actions/verifyAddress/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionVerifyAddress = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'verify_address') {
+        return {};
+    }
+    return {
+        verifyAddress: data.data,
+    };
+};

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

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