@rabby-wallet/rabby-action 0.1.0

package/dist/actions/permit2BatchRevokeToken/fetchData.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());
+    });
+};
+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) {
+        return {};
+    }
+    const spenders = action.revoke_list.map((item) => item.spender);
+    // filter out the same spender
+    const uniqueSpenders = Array.from(new Set(spenders));
+    const result = {};
+    yield Promise.all(uniqueSpenders.map((spender) => __awaiter(void 0, void 0, void 0, function* () {
+        result[spender] = (yield fetchDataApproveToken(options, {
+            spender,
+        }));
+    })));
+    return result;
+});

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

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

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

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

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

package/dist/actions/permit2BatchRevokeToken/parseAction.js

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

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

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

package/dist/actions/pushMultiSig/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 fetchDataPushMultiSig = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    const { apiProvider, actionData } = options;
+    if (!actionData.pushMultiSig) {
+        return {};
+    }
+    const result = {
+        contract: null,
+        id: actionData.pushMultiSig.multisig_id,
+    };
+    const { desc } = yield apiProvider.addrDesc(actionData.pushMultiSig.multisig_id);
+    if (desc.contract) {
+        result.contract = desc.contract;
+    }
+    return result;
+});

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

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

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

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

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

package/dist/actions/pushMultiSig/parseAction.js

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

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

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

package/dist/actions/revokeNFT/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 { 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 {};
+    }
+    return fetchDataApproveNFT(options, options.actionData.revokeNFT);
+});

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

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

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

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

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

package/dist/actions/revokeNFT/parseAction.js

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

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

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

package/dist/actions/revokeNFTCollection/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 { fetchDataApproveNFT } from '../approveNFT/fetchData';
+export const fetchDataRevokeNFTCollection = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    if (!options.actionData.revokeNFTCollection) {
+        return {};
+    }
+    return fetchDataApproveNFT(options, options.actionData.revokeNFTCollection);
+});

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

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

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

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

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

package/dist/actions/revokeNFTCollection/parseAction.js

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

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

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

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

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

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

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

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

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

package/dist/actions/revokePermit/parseAction.js

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

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

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

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

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

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

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

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

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

package/dist/actions/revokePermit2/parseAction.js

@@ -0,0 +1,13 @@
+export const parseActionRevokePermit2 = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'permit2_revoke_token') {
+        return {};
+    }
+    const { spender, token } = data.data;
+    return {
+        revokePermit2: {
+            spender,
+            token,
+        },
+    };
+};

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

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

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

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

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

package/dist/actions/revokeToken/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 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 {};
+    }
+    const { gasUsed } = actionData.revokeToken;
+    return {
+        revokeApprove: {
+            gasUsed,
+            chainId,
+        },
+    };
+});

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

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

package/dist/actions/revokeToken/parseAction.js

@@ -0,0 +1,14 @@
+export const parseActionRevokeToken = (options) => {
+    const { data, gasUsed } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'revoke_token') {
+        return {};
+    }
+    const { spender, token } = data.data;
+    return {
+        revokeToken: {
+            spender,
+            token,
+            gasUsed,
+        },
+    };
+};

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

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

package/dist/actions/sellNFT/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 fetchDataSellNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    if (!options.actionData.contractId || !options.actionData.sellNFT) {
+        return {};
+    }
+    return fetchDataCommon(options, {
+        receiver: options.actionData.contractId,
+    });
+});

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

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

package/dist/actions/sellNFT/formatSecurityEngine.js

@@ -0,0 +1,33 @@
+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 formatSecurityEngineSellNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.sellNFT) {
+        return {};
+    }
+    const receiveTokenIsFake = actionData.sellNFT.receive_token.is_verified === false;
+    const receiveTokenIsScam = receiveTokenIsFake
+        ? false
+        : !!actionData.sellNFT.receive_token.is_suspicious;
+    return {
+        sellNFT: {
+            specificBuyer: actionData.sellNFT.takers[0],
+            from: actionData.sender,
+            receiver: actionData.sellNFT.receiver,
+            receiveTokenIsFake,
+            receiveTokenIsScam,
+            chainId: chainId,
+            id: actionData.contractId,
+        },
+    };
+});

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

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

package/dist/actions/sellNFT/parseAction.js

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

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

@@ -0,0 +1,8 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataSend: FetchActionRequiredData<{
+    to: string;
+    token: {
+        id: string;
+        chain: string;
+    };
+}>;

package/dist/actions/send/fetchData.js

@@ -0,0 +1,103 @@
+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';
+import { KEYRING_TYPE } from '../../utils/keyring';
+// send, sendNFT, typedData.send
+export const fetchDataSend = (options, likeSendAction) => __awaiter(void 0, void 0, void 0, function* () {
+    const queue = new PQueue();
+    const { actionData, walletProvider, apiProvider, chainId, sender } = options;
+    const sendAction = likeSendAction || actionData.send;
+    if (!sendAction || !chainId) {
+        return {};
+    }
+    const result = {
+        eoa: null,
+        cex: null,
+        contract: null,
+        usd_value: 0,
+        protocol: null,
+        hasTransfer: false,
+        usedChains: [],
+        isTokenContract: false,
+        name: null,
+        onTransferWhitelist: false,
+        whitelistEnable: false,
+        receiverIsSpoofing: false,
+        hasReceiverPrivateKeyInWallet: false,
+        hasReceiverMnemonicInWallet: false,
+    };
+    const hasPrivateKeyInWallet = yield walletProvider.hasPrivateKeyInWallet(sendAction.to);
+    if (hasPrivateKeyInWallet) {
+        result.hasReceiverPrivateKeyInWallet =
+            hasPrivateKeyInWallet === KEYRING_TYPE.SimpleKeyring;
+        result.hasReceiverMnemonicInWallet =
+            hasPrivateKeyInWallet === KEYRING_TYPE.HdKeyring;
+    }
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { has_transfer } = yield apiProvider.hasTransfer(chainId, sender, sendAction.to);
+        result.hasTransfer = has_transfer;
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { desc } = yield apiProvider.addrDesc(sendAction.to);
+        if ((_a = desc.cex) === null || _a === void 0 ? void 0 : _a.id) {
+            result.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) {
+            result.contract = desc.contract;
+        }
+        if (!result.cex && !result.contract) {
+            result.eoa = {
+                id: sendAction.to,
+                bornAt: desc.born_at,
+            };
+        }
+        result.usd_value = desc.usd_value;
+        if (result.cex) {
+            const { support } = yield apiProvider.depositCexSupport(sendAction.token.id, sendAction.token.chain, result.cex.id);
+            result.cex.supportToken = support;
+        }
+        if (result.contract) {
+            const { is_token } = yield apiProvider.isTokenContract(chainId, sendAction.to);
+            result.isTokenContract = is_token;
+        }
+        result.name = desc.name;
+        if (walletProvider.ALIAS_ADDRESS[sendAction.to.toLowerCase()]) {
+            result.name = walletProvider.ALIAS_ADDRESS[sendAction.to.toLowerCase()];
+        }
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const usedChainList = yield apiProvider.addrUsedChainList(sendAction.to);
+        result.usedChains = usedChainList;
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { is_spoofing } = yield apiProvider.checkSpoofing({
+            from: sender,
+            to: sendAction.to,
+        });
+        result.receiverIsSpoofing = is_spoofing;
+    }));
+    const whitelist = yield walletProvider.getWhitelist();
+    // FIXME: I don't know why `isWhitelistEnabled` is blocking running tests, so skip it in test
+    if (process.env.NODE_ENV !== 'test') {
+        const whitelistEnable = yield walletProvider.isWhitelistEnabled();
+        result.whitelistEnable = whitelistEnable;
+    }
+    result.onTransferWhitelist = whitelist.includes(sendAction.to.toLowerCase());
+    yield waitQueueFinished(queue);
+    return result;
+});