@rabby-wallet/rabby-action 0.1.0

package/dist/actions/contractCall/fetchData.js

@@ -0,0 +1,115 @@
+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 { getProtocol } from '../../utils/getProtocol';
+import { waitQueueFinished } from '../../utils/waitQueueFinished';
+export const fetchDataContractCall = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    const queue = new PQueue();
+    const { contractCall, walletProvider, actionData, sender, apiProvider, chainId, tx, } = options;
+    if (!(actionData.contractCall || actionData.common) || !contractCall) {
+        return {};
+    }
+    const chain = walletProvider.findChain({
+        serverId: chainId,
+    });
+    const result = {
+        contract: null,
+        rank: null,
+        hasInteraction: false,
+        bornAt: 0,
+        protocol: null,
+        call: contractCall,
+        id: contractCall.contract.id,
+        payNativeTokenAmount: tx.value || '0x0',
+        nativeTokenSymbol: (chain === null || chain === void 0 ? void 0 : chain.nativeTokenSymbol) || 'ETH',
+        unexpectedAddr: null,
+        receiverInWallet: false,
+    };
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const contractInfo = yield apiProvider.getContractInfo(contractCall.contract.id, chainId);
+        if (!contractInfo) {
+            result.rank = null;
+        }
+        else {
+            result.rank = contractInfo.credit.rank_at;
+        }
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { desc } = yield apiProvider.addrDesc(contractCall.contract.id);
+        if (desc.contract) {
+            result.contract = desc.contract;
+            if (desc.contract[chainId]) {
+                result.bornAt = desc.contract[chainId].create_at;
+            }
+        }
+        result.protocol = getProtocol(desc.protocol, chainId);
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const hasInteraction = yield apiProvider.hasInteraction(sender, chainId, contractCall.contract.id);
+        result.hasInteraction = hasInteraction.has_interaction;
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const addr = (_a = actionData.common) === null || _a === void 0 ? void 0 : _a.receiver;
+        if (addr) {
+            result.receiverInWallet = yield walletProvider.hasAddress(addr);
+            const receiverData = {
+                address: addr,
+                chain: chain,
+                eoa: null,
+                cex: null,
+                contract: null,
+                usd_value: 0,
+                hasTransfer: false,
+                isTokenContract: false,
+                name: null,
+                onTransferWhitelist: false,
+            };
+            const { has_transfer } = yield apiProvider.hasTransfer(chainId, sender, addr);
+            receiverData.hasTransfer = has_transfer;
+            const { desc } = yield apiProvider.addrDesc(addr);
+            if ((_b = desc.cex) === null || _b === void 0 ? void 0 : _b.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;
+            if (result.contract) {
+                const { is_token } = yield apiProvider.isTokenContract(chainId, addr);
+                receiverData.isTokenContract = is_token;
+            }
+            receiverData.name = desc.name;
+            if (walletProvider.ALIAS_ADDRESS[addr.toLowerCase()]) {
+                receiverData.name = walletProvider.ALIAS_ADDRESS[addr.toLowerCase()];
+            }
+            const whitelist = yield walletProvider.getWhitelist();
+            receiverData.onTransferWhitelist = whitelist.includes(addr.toLowerCase());
+            result.unexpectedAddr = receiverData;
+        }
+    }));
+    yield waitQueueFinished(queue);
+    return result;
+});

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

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

package/dist/actions/contractCall/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 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 {};
+    }
+    const data = requireData;
+    return {
+        contractCall: {
+            chainId,
+            id: data.id,
+        },
+    };
+});

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

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

package/dist/actions/contractCall/parseAction.js

@@ -0,0 +1,5 @@
+export const parseActionContractCall = () => {
+    return {
+        contractCall: {},
+    };
+};

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

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

package/dist/actions/createKey/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 fetchDataCreateKey = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    return {};
+});

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

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

package/dist/actions/createKey/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 formatSecurityEngineCreateKey = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'text' && options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, origin } = options;
+    if (!actionData.createKey) {
+        return {};
+    }
+    return {
+        createKey: {
+            allowOrigins: actionData.createKey.allow_origins,
+            origin,
+        },
+    };
+});

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

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

package/dist/actions/createKey/parseAction.js

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

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

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

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

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

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

package/dist/actions/crossSwapToken/formatSecurityEngine.js

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

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

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

package/dist/actions/crossSwapToken/parseAction.js

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

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

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

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

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

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

package/dist/actions/crossToken/formatSecurityEngine.js

@@ -0,0 +1,38 @@
+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 formatSecurityEngineCrossToken = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.crossToken) {
+        return {};
+    }
+    const data = requireData;
+    const { receiver, receiveToken, usdValuePercentage, usdValueDiff } = actionData.crossToken;
+    const { sender } = data;
+    const receiveTokenIsFake = receiveToken.is_verified === false;
+    const receiveTokenIsScam = receiveTokenIsFake
+        ? false
+        : !!receiveToken.is_suspicious;
+    return {
+        crossToken: {
+            receiveTokenIsScam,
+            receiveTokenIsFake,
+            receiver,
+            from: sender,
+            id: data.id,
+            chainId,
+            usdValuePercentage,
+            usdValueChange: Number(usdValueDiff),
+            receiverInWallet: data.receiverInWallet,
+        },
+    };
+});

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

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

package/dist/actions/crossToken/parseAction.js

@@ -0,0 +1,22 @@
+import BigNumber from 'bignumber.js';
+import { calcUSDValueChange } from '../../utils/calcUSDValueChange';
+export const parseActionCrossToken = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'cross_token') {
+        return {};
+    }
+    const { pay_token: payToken, receive_token: receiveToken, receiver, } = data.data;
+    const receiveTokenUsdValue = new BigNumber(receiveToken.min_amount).times(receiveToken.price);
+    const payTokenUsdValue = new BigNumber(payToken.amount).times(payToken.price);
+    const usdValueDiff = receiveTokenUsdValue.minus(payTokenUsdValue).toFixed();
+    const usdValuePercentage = calcUSDValueChange(payTokenUsdValue.toFixed(), receiveTokenUsdValue.toFixed());
+    return {
+        crossToken: {
+            payToken,
+            receiveToken,
+            receiver,
+            usdValueDiff,
+            usdValuePercentage,
+        },
+    };
+};

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

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

package/dist/actions/deployContract/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 fetchDataDeployContract = () => __awaiter(void 0, void 0, void 0, function* () {
+    return {};
+});

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

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

package/dist/actions/deployContract/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 formatSecurityEngineDeployContract = () => __awaiter(void 0, void 0, void 0, function* () {
+    return {};
+});

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

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

package/dist/actions/deployContract/parseAction.js

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

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

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

package/dist/actions/permit/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 { fetchDataApproveToken } from '../approveToken/fetchData';
+export const fetchDataPermit = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    if (!options.actionData.permit) {
+        return {};
+    }
+    return fetchDataApproveToken(options, options.actionData.permit);
+});

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

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

package/dist/actions/permit/formatSecurityEngine.js

@@ -0,0 +1,30 @@
+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 formatSecurityEnginePermit = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.permit) {
+        return {};
+    }
+    const data = requireData;
+    return {
+        permit: {
+            spender: actionData.permit.spender,
+            isEOA: data.isEOA,
+            riskExposure: data.riskExposure,
+            deployDays: provider.getTimeSpan(Math.floor(Date.now() / 1000) - data.bornAt).d,
+            hasInteracted: data.hasInteraction,
+            isDanger: !!data.isDanger,
+            chainId,
+        },
+    };
+});

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

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

package/dist/actions/permit/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionPermit = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'permit1_approve_token') {
+        return {};
+    }
+    return {
+        permit: Object.assign(Object.assign({}, data.data), { expire_at: data.expire_at }),
+    };
+};

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

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

package/dist/actions/permit2/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 { fetchDataApproveToken } from '../approveToken/fetchData';
+export const fetchDataPermit2 = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    if (!options.actionData.permit2) {
+        return {};
+    }
+    return fetchDataApproveToken(options, options.actionData.permit2);
+});

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

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

package/dist/actions/permit2/formatSecurityEngine.js

@@ -0,0 +1,30 @@
+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 formatSecurityEnginePermit2 = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.permit2) {
+        return {};
+    }
+    const data = requireData;
+    return {
+        permit2: {
+            spender: actionData.permit2.spender,
+            isEOA: data.isEOA,
+            riskExposure: data.riskExposure,
+            deployDays: provider.getTimeSpan(Math.floor(Date.now() / 1000) - data.bornAt).d,
+            hasInteracted: data.hasInteraction,
+            isDanger: !!data.isDanger,
+            chainId,
+        },
+    };
+});

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

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

package/dist/actions/permit2/parseAction.js

@@ -0,0 +1,9 @@
+export const parseActionPermit2 = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'permit2_approve_token') {
+        return {};
+    }
+    return {
+        permit2: Object.assign(Object.assign({}, data.data), { sig_expire_at: data.expire_at }),
+    };
+};

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

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