@rabby-wallet/rabby-action 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# rabby-action
+
+## Install
+
+```bash
+npm install @rabby-wallet/rabby-action @rabby-wallet/rabby-api @debank/common @rabby-wallet/rabby-security-engine bignumber.js
+```

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

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

package/dist/actions/approveNFT/fetchData.js

@@ -0,0 +1,60 @@
+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 fetchDataApproveNFT = (options, likeAction) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction') {
+        return {};
+    }
+    const queue = new PQueue();
+    const { sender, apiProvider, chainId, actionData } = options;
+    const action = likeAction || actionData.approveNFT;
+    if (!action) {
+        return {};
+    }
+    const result = {
+        isEOA: false,
+        contract: null,
+        riskExposure: 0,
+        rank: null,
+        hasInteraction: false,
+        bornAt: 0,
+        protocol: null,
+        isDanger: false,
+        tokenBalance: '0',
+    };
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const contractInfo = yield apiProvider.getContractInfo(action.spender, chainId);
+        if (!contractInfo) {
+            result.isEOA = true;
+            result.rank = null;
+        }
+        else {
+            result.rank = contractInfo.credit.rank_at;
+            result.riskExposure = contractInfo.top_nft_spend_usd_value;
+            result.bornAt = contractInfo.create_at;
+            result.isDanger =
+                contractInfo.is_danger.auto || contractInfo.is_danger.edit;
+            result.protocol = contractInfo.protocol;
+        }
+        if (result.isEOA) {
+            queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+                const { desc } = yield apiProvider.addrDesc(action.spender);
+                result.bornAt = desc.born_at;
+            }));
+        }
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const hasInteraction = yield apiProvider.hasInteraction(sender, chainId, action.spender);
+        result.hasInteraction = hasInteraction.has_interaction;
+    }));
+    yield waitQueueFinished(queue);
+    return result;
+});

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

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

package/dist/actions/approveNFT/formatSecurityEngine.js

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

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

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

package/dist/actions/approveNFT/parseAction.js

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

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

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

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

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

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

package/dist/actions/approveNFTCollection/formatSecurityEngine.js

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

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

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

package/dist/actions/approveNFTCollection/parseAction.js

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

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

@@ -0,0 +1,6 @@
+import { FetchActionRequiredData } from '../../types';
+import { ApproveAction } from '@rabby-wallet/rabby-api/dist/types';
+export declare const fetchDataApproveToken: FetchActionRequiredData<{
+    spender: ApproveAction['spender'];
+    token?: ApproveAction['token'];
+}>;

package/dist/actions/approveToken/fetchData.js

@@ -0,0 +1,64 @@
+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 fetchDataApproveToken = (options, likeAction) => __awaiter(void 0, void 0, void 0, function* () {
+    const queue = new PQueue();
+    const { sender, apiProvider, chainId, actionData } = options;
+    const action = likeAction || actionData.approveToken;
+    if (!action || !chainId) {
+        return {};
+    }
+    const { spender, token } = action;
+    const result = {
+        isEOA: false,
+        contract: null,
+        riskExposure: 0,
+        rank: null,
+        hasInteraction: false,
+        bornAt: 0,
+        protocol: null,
+        isDanger: false,
+        token: Object.assign(Object.assign({}, token), { amount: 0, raw_amount_hex_str: '0x0' }),
+    };
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const contractInfo = yield apiProvider.getContractInfo(spender, chainId);
+        if (!contractInfo) {
+            result.isEOA = true;
+            result.rank = null;
+        }
+        else {
+            result.rank = contractInfo.credit.rank_at;
+            result.riskExposure = contractInfo.spend_usd_value;
+            result.bornAt = contractInfo.create_at;
+            result.isDanger =
+                contractInfo.is_danger.auto || contractInfo.is_danger.edit;
+            result.protocol = contractInfo.protocol;
+        }
+        if (result.isEOA) {
+            queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+                const { desc } = yield apiProvider.addrDesc(spender);
+                result.bornAt = desc.born_at;
+            }));
+        }
+    }));
+    if (token) {
+        queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+            const t = yield apiProvider.getToken(sender, chainId, token.id);
+            result.token = t;
+        }));
+    }
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const hasInteraction = yield apiProvider.hasInteraction(sender, chainId, spender);
+        result.hasInteraction = hasInteraction.has_interaction;
+    }));
+    yield waitQueueFinished(queue);
+    return result;
+});

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

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

package/dist/actions/approveToken/formatSecurityEngine.js

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

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

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

package/dist/actions/approveToken/parseAction.js

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

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

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

package/dist/actions/assetOrder/fetchData.js

@@ -0,0 +1,29 @@
+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 fetchDataAssetOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    let action;
+    if (options.type === 'transaction' && options.actionData.assetOrder) {
+        action = {
+            receiver: options.tx.to,
+        };
+    }
+    if (options.type === 'typed_data' &&
+        options.actionData.assetOrder &&
+        options.actionData.contractId) {
+        action = {
+            receiver: options.actionData.contractId,
+        };
+    }
+    if (!action || !options.chainId) {
+        return {};
+    }
+    return fetchDataCommon(options, action);
+});

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

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

package/dist/actions/assetOrder/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 formatSecurityEngineAssetOrder = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'transaction' && options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.assetOrder) {
+        return {};
+    }
+    const { takers, receiver, receiveNFTList, receiveTokenList } = actionData.assetOrder;
+    const data = requireData;
+    return {
+        assetOrder: {
+            specificBuyer: takers[0],
+            from: data.sender,
+            receiver: receiver || '',
+            chainId,
+            id: data.id,
+            hasReceiveAssets: receiveNFTList.length + receiveTokenList.length > 0,
+        },
+    };
+});

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

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

package/dist/actions/assetOrder/parseAction.js

@@ -0,0 +1,18 @@
+export const parseActionAssetOrder = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'swap_order') {
+        return {};
+    }
+    const { pay_token_list, pay_nft_list, receive_nft_list, receive_token_list, receiver, takers, expire_at, } = data.data;
+    return {
+        assetOrder: {
+            payTokenList: pay_token_list,
+            payNFTList: pay_nft_list,
+            receiveNFTList: receive_nft_list,
+            receiveTokenList: receive_token_list,
+            receiver,
+            takers,
+            expireAt: expire_at,
+        },
+    };
+};

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

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

package/dist/actions/batchPermit2/fetchData.js

@@ -0,0 +1,65 @@
+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 fetchDataBatchPermit2 = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, apiProvider, sender, chainId } = options;
+    if (!actionData.batchPermit2 || !chainId) {
+        return {};
+    }
+    const queue = new PQueue();
+    const tokens = actionData.batchPermit2.token_list;
+    const spender = actionData.batchPermit2.spender;
+    const result = {
+        isEOA: false,
+        contract: null,
+        riskExposure: 0,
+        rank: null,
+        hasInteraction: false,
+        bornAt: 0,
+        protocol: null,
+        isDanger: false,
+        tokens: tokens.map((token) => (Object.assign(Object.assign({}, token), { amount: 0, raw_amount_hex_str: '0x0' }))),
+    };
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const contractInfo = yield apiProvider.getContractInfo(spender, chainId);
+        if (!contractInfo) {
+            result.isEOA = true;
+            result.rank = null;
+        }
+        else {
+            result.rank = contractInfo.credit.rank_at;
+            result.riskExposure = contractInfo.spend_usd_value;
+            result.bornAt = contractInfo.create_at;
+            result.isDanger =
+                contractInfo.is_danger.auto || contractInfo.is_danger.edit;
+            result.protocol = contractInfo.protocol;
+        }
+        if (result.isEOA) {
+            queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+                const { desc } = yield apiProvider.addrDesc(spender);
+                result.bornAt = desc.born_at;
+            }));
+        }
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const list = yield Promise.all(tokens.map((token) => apiProvider.getToken(sender, chainId, token.id)));
+        result.tokens = list;
+    }));
+    queue.add(() => __awaiter(void 0, void 0, void 0, function* () {
+        const hasInteraction = yield apiProvider.hasInteraction(sender, chainId, spender);
+        result.hasInteraction = hasInteraction.has_interaction;
+    }));
+    yield waitQueueFinished(queue);
+    return result;
+});

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

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

package/dist/actions/batchPermit2/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 formatSecurityEngineBatchPermit2 = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.batchPermit2) {
+        return {};
+    }
+    const data = requireData;
+    return {
+        batchPermit2: {
+            spender: actionData.batchPermit2.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/batchPermit2/parseAction.d.ts

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

package/dist/actions/batchPermit2/parseAction.js

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

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

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

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

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

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

package/dist/actions/batchSellNFT/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 formatSecurityEngineBatchSellNFT = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.type !== 'typed_data') {
+        return {};
+    }
+    const { actionData, requireData, chainId, provider } = options;
+    if (!actionData.batchSellNFT) {
+        return {};
+    }
+    const receiveTokenIsFake = actionData.batchSellNFT.receive_token.is_verified === false;
+    const receiveTokenIsScam = receiveTokenIsFake
+        ? false
+        : !!actionData.batchSellNFT.receive_token.is_suspicious;
+    return {
+        batchSellNFT: {
+            specificBuyer: actionData.batchSellNFT.takers[0],
+            from: actionData.sender,
+            receiver: actionData.batchSellNFT.receiver,
+            receiveTokenHasFake: receiveTokenIsFake,
+            receiveTokenHasScam: receiveTokenIsScam,
+            chainId,
+            id: actionData.contractId,
+        },
+    };
+});

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

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

package/dist/actions/batchSellNFT/parseAction.js

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

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

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