@rabby-wallet/rabby-action 0.1.12-beta.0 → 0.1.13-beta.0

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

@@ -0,0 +1,9 @@
+import { FetchActionRequiredData } from '../../types';
+export declare const fetchDataAddLiquidity: FetchActionRequiredData<{
+    receiver: string;
+    exchange_rate: string;
+    min_exchange_rate: string;
+    max_exchange_rate: string;
+    token0: any;
+    token1: any;
+}>;

package/dist/actions/addLiquidity/fetchData.js

@@ -0,0 +1,67 @@
+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 BigNumber from 'bignumber.js';
+export const fetchDataAddLiquidity = (options, likeAction) => __awaiter(void 0, void 0, void 0, function* () {
+    const { actionData, apiProvider, sender, walletProvider, chainId } = options;
+    const action = likeAction || actionData.addLiquidity;
+    if (!action || options.type === 'text') {
+        return {};
+    }
+    const { receiver, exchange_rate, token0, token1 } = action;
+    const fair_exchange_rate = new BigNumber(token0.price).div(token1.price);
+    const diff = +new BigNumber(exchange_rate)
+        .minus(fair_exchange_rate)
+        .abs()
+        .div(fair_exchange_rate)
+        .times(100)
+        .toFixed(4);
+    const receiverInWallet = yield walletProvider.hasAddress(receiver);
+    const id = options.type === 'transaction'
+        ? options.tx.to
+        : options.actionData.contractId;
+    if (!id) {
+        return {};
+    }
+    const result = {
+        id,
+        protocol: null,
+        bornAt: 0,
+        rank: null,
+        sender,
+        receiverInWallet,
+        hasInteraction: false,
+        receiver,
+        poolRate: exchange_rate,
+        token0,
+        token1,
+        marketRate: fair_exchange_rate.toFixed(),
+        diff,
+    };
+    const queue = new PQueue();
+    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/addLiquidity/formatSecurityEngine.d.ts

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

package/dist/actions/addLiquidity/formatSecurityEngine.js

@@ -0,0 +1,23 @@
+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 formatSecurityEngineAddLiquidity = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { actionData, requireData, chainId } = options;
+    if (!actionData.addLiquidity || !chainId) {
+        return {};
+    }
+    const data = requireData;
+    return {
+        addLiquidity: {
+            receiverMatch: ((_a = data.receiver) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === data.sender.toLowerCase(),
+            diff: data.diff,
+        },
+    };
+});

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

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

package/dist/actions/addLiquidity/parseAction.js

@@ -0,0 +1,17 @@
+export const parseActionAddLiquidity = (options) => {
+    const { data } = options;
+    if ((data === null || data === void 0 ? void 0 : data.type) !== 'add_liquidity') {
+        return {};
+    }
+    const { receiver, exchange_rate, min_exchange_rate, max_exchange_rate, token0, token1, } = data.data;
+    return {
+        addLiquidity: {
+            receiver,
+            exchange_rate,
+            min_exchange_rate,
+            max_exchange_rate,
+            token0,
+            token1,
+        },
+    };
+};

package/dist/actions/send/fetchData.js

@@ -73,6 +73,7 @@ export const fetchDataSend = (options, likeSendAction) => __awaiter(void 0, void
             result.cex.logo = options.cex.logo;
             result.cex.name = options.cex.name;
             result.cex.id = options.cex.id;
+            result.cex.isDeposit = true;
         }
         if (desc.contract && Object.keys(desc.contract).length > 0) {
             result.contract = desc.contract;

package/dist/fetchActionRequiredData.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { fetchDataDeployContract } from './actions/deployContract/fetchData';
 import { fetchDataSend } from './actions/send/fetchData';
 import { fetchDataSendNFT } from './actions/sendNFT/fetchData';
+import { fetchDataAddLiquidity } from './actions/addLiquidity/fetchData';
 import { fetchDataSwap } from './actions/swap/fetchData';
 import { fetchDataCrossToken } from './actions/crossToken/fetchData';
 import { fetchDataCrossSwapToken } from './actions/crossSwapToken/fetchData';
@@ -87,6 +88,7 @@ export const fetchActionRequiredData = (options) => __awaiter(void 0, void 0, vo
         fetchDataCoboSafeModificationRole(options),
         fetchDataCoboSafeModificationTokenApproval(options),
         fetchDataRevokePermit(options),
+        fetchDataAddLiquidity(options),
     ]);
     return result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
 });

package/dist/formatSecurityEngineContext.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { formatSecurityEngineApproveNFT } from './actions/approveNFT/formatSecurityEngine';
 import { formatSecurityEngineApproveNFTCollection } from './actions/approveNFTCollection/formatSecurityEngine';
+import { formatSecurityEngineAddLiquidity } from './actions/addLiquidity/formatSecurityEngine';
 import { formatSecurityEngineApproveToken } from './actions/approveToken/formatSecurityEngine';
 import { formatSecurityEngineAssetOrder } from './actions/assetOrder/formatSecurityEngine';
 import { formatSecurityEngineCancelTx } from './actions/cancelTx/formatSecurityEngine';
@@ -90,6 +91,7 @@ export const formatSecurityEngineContext = (options) => __awaiter(void 0, void 0
         formatSecurityEngineCoboSafeModificationRole(options),
         formatSecurityEngineCoboSafeModificationTokenApproval(options),
         formatSecurityEngineRevokePermit(options),
+        formatSecurityEngineAddLiquidity(options),
     ]);
     return result.reduce((acc, val) => (Object.assign(Object.assign({}, acc), val)), {});
 });

package/dist/parseAction.js

@@ -1,6 +1,7 @@
 import { parseActionSwapLimitPay } from './actions/swapLimitPay/parseAction';
 import { parseActionMultiSwap } from './actions/multiSwap/parseAction';
 import { parseActionTransferOwner } from './actions/transferOwner/parseAction';
+import { parseActionAddLiquidity } from './actions/addLiquidity/parseAction';
 import { parseActionSend } from './actions/send/parseAction';
 import { parseActionApproveNFT } from './actions/approveNFT/parseAction';
 import { parseActionApproveNFTCollection } from './actions/approveNFTCollection/parseAction';
@@ -42,19 +43,19 @@ import { parseTextAction } from './utils/parseTextAction';
 export function parseAction(options) {
     const result = [];
     if (options.type === 'transaction') {
-        result.push(parseActionApproveNFT(options), parseActionApproveNFTCollection(options), parseActionApproveToken(options), parseActionAssetOrder(options), parseActionCancelTx(options), parseActionCommon(options), parseActionCrossSwapToken(options), parseActionCrossToken(options), parseActionDeployContract(options), parseActionPushMultiSig(options), parseActionRevokeNFT(options), parseActionRevokeNFTCollection(options), parseActionRevokePermit2(options), parseActionRevokeToken(options), parseActionSend(options), parseActionSendNFT(options), parseActionSwap(options), parseActionUnwrapToken(options), parseActionWrapToken(options), parseActionPermit2BatchRevokeToken(options), parseActionTransferOwner(options), parseActionSwapLimitPay(options), parseActionMultiSwap(options));
+        result.push(parseActionApproveNFT(options), parseActionApproveNFTCollection(options), parseActionApproveToken(options), parseActionAssetOrder(options), parseActionCancelTx(options), parseActionCommon(options), parseActionCrossSwapToken(options), parseActionCrossToken(options), parseActionDeployContract(options), parseActionPushMultiSig(options), parseActionRevokeNFT(options), parseActionRevokeNFTCollection(options), parseActionRevokePermit2(options), parseActionRevokeToken(options), parseActionSend(options), parseActionSendNFT(options), parseActionSwap(options), parseActionUnwrapToken(options), parseActionWrapToken(options), parseActionPermit2BatchRevokeToken(options), parseActionTransferOwner(options), parseActionSwapLimitPay(options), parseActionMultiSwap(options), parseActionAddLiquidity(options));
     }
     if (options.type === 'typed_data') {
         result.push(
         // tx actions
-        parseTypedDataAction(parseActionCommon)(options), parseTypedDataAction(parseActionAssetOrder)(options), parseTypedDataAction(parseActionSend)(options), parseTypedDataAction(parseActionApproveNFT)(options), parseTypedDataAction(parseActionApproveNFTCollection)(options), parseTypedDataAction(parseActionApproveToken)(options), parseTypedDataAction(parseActionCancelTx)(options), parseTypedDataAction(parseActionCrossSwapToken)(options), parseTypedDataAction(parseActionCrossToken)(options), parseTypedDataAction(parseActionDeployContract)(options), parseTypedDataAction(parseActionPushMultiSig)(options), parseTypedDataAction(parseActionRevokeNFT)(options), parseTypedDataAction(parseActionRevokeNFTCollection)(options), parseTypedDataAction(parseActionRevokePermit2)(options), parseTypedDataAction(parseActionRevokeToken)(options), parseTypedDataAction(parseActionSendNFT)(options), parseTypedDataAction(parseActionSwap)(options), parseTypedDataAction(parseActionUnwrapToken)(options), parseTypedDataAction(parseActionWrapToken)(options), parseTypedDataAction(parseActionPermit2BatchRevokeToken)(options), parseTypedDataAction(parseActionTransferOwner)(options), parseTypedDataAction(parseActionSwapLimitPay)(options), parseTypedDataAction(parseActionMultiSwap)(options), 
+        parseTypedDataAction(parseActionCommon)(options), parseTypedDataAction(parseActionAssetOrder)(options), parseTypedDataAction(parseActionSend)(options), parseTypedDataAction(parseActionApproveNFT)(options), parseTypedDataAction(parseActionApproveNFTCollection)(options), parseTypedDataAction(parseActionApproveToken)(options), parseTypedDataAction(parseActionCancelTx)(options), parseTypedDataAction(parseActionCrossSwapToken)(options), parseTypedDataAction(parseActionCrossToken)(options), parseTypedDataAction(parseActionDeployContract)(options), parseTypedDataAction(parseActionPushMultiSig)(options), parseTypedDataAction(parseActionRevokeNFT)(options), parseTypedDataAction(parseActionRevokeNFTCollection)(options), parseTypedDataAction(parseActionRevokePermit2)(options), parseTypedDataAction(parseActionRevokeToken)(options), parseTypedDataAction(parseActionSendNFT)(options), parseTypedDataAction(parseActionSwap)(options), parseTypedDataAction(parseActionUnwrapToken)(options), parseTypedDataAction(parseActionWrapToken)(options), parseTypedDataAction(parseActionPermit2BatchRevokeToken)(options), parseTypedDataAction(parseActionTransferOwner)(options), parseTypedDataAction(parseActionSwapLimitPay)(options), parseTypedDataAction(parseActionMultiSwap)(options), parseTypedDataAction(parseActionAddLiquidity)(options), 
         // typed data actions
         parseTypedDataAction(parseActionCreateKey)(options), parseTypedDataAction(parseActionVerifyAddress)(options), parseTypedDataAction(parseActionSellNFT)(options), parseTypedDataAction(parseActionBatchSellNFT)(options), parseTypedDataAction(parseActionSignMultiSig)(options), parseTypedDataAction(parseActionBuyNFT)(options), parseTypedDataAction(parseActionPermit)(options), parseTypedDataAction(parseActionPermit2)(options), parseTypedDataAction(parseActionBatchPermit2)(options), parseTypedDataAction(parseActionSwapTokenOrder)(options), parseTypedDataAction(parseActionCoboSafeCreate)(options), parseTypedDataAction(parseActionCoboSafeModificationDelegatedAddress)(options), parseTypedDataAction(parseActionCoboSafeModificationRole)(options), parseTypedDataAction(parseActionCoboSafeModificationTokenApproval)(options), parseTypedDataAction(parseActionRevokePermit)(options));
     }
     if (options.type === 'text') {
         result.push(
         // tx actions
-        parseTextAction(parseActionCommon)(options), parseTextAction(parseActionAssetOrder)(options), parseTextAction(parseActionSend)(options), parseTextAction(parseActionApproveNFT)(options), parseTextAction(parseActionApproveNFTCollection)(options), parseTextAction(parseActionApproveToken)(options), parseTextAction(parseActionCancelTx)(options), parseTextAction(parseActionCrossSwapToken)(options), parseTextAction(parseActionCrossToken)(options), parseTextAction(parseActionDeployContract)(options), parseTextAction(parseActionPushMultiSig)(options), parseTextAction(parseActionRevokeNFT)(options), parseTextAction(parseActionRevokeNFTCollection)(options), parseTextAction(parseActionRevokePermit2)(options), parseTextAction(parseActionRevokeToken)(options), parseTextAction(parseActionSendNFT)(options), parseTextAction(parseActionSwap)(options), parseTextAction(parseActionUnwrapToken)(options), parseTextAction(parseActionWrapToken)(options), parseTextAction(parseActionPermit2BatchRevokeToken)(options), 
+        parseTextAction(parseActionCommon)(options), parseTextAction(parseActionAssetOrder)(options), parseTextAction(parseActionSend)(options), parseTextAction(parseActionApproveNFT)(options), parseTextAction(parseActionApproveNFTCollection)(options), parseTextAction(parseActionApproveToken)(options), parseTextAction(parseActionCancelTx)(options), parseTextAction(parseActionCrossSwapToken)(options), parseTextAction(parseActionCrossToken)(options), parseTextAction(parseActionDeployContract)(options), parseTextAction(parseActionPushMultiSig)(options), parseTextAction(parseActionRevokeNFT)(options), parseTextAction(parseActionRevokeNFTCollection)(options), parseTextAction(parseActionRevokePermit2)(options), parseTextAction(parseActionRevokeToken)(options), parseTextAction(parseActionSendNFT)(options), parseTextAction(parseActionSwap)(options), parseTextAction(parseActionUnwrapToken)(options), parseTextAction(parseActionWrapToken)(options), parseTextAction(parseActionPermit2BatchRevokeToken)(options), parseTextAction(parseActionAddLiquidity)(options), 
         // text actions
         parseTextAction(parseActionCreateKey)(options), parseTextAction(parseActionVerifyAddress)(options));
     }

package/dist/types/actionRequireData.d.ts

@@ -159,4 +159,22 @@ export interface SwapTokenOrderRequireData extends ContractRequireData {
 export type BatchApproveTokenRequireData = Omit<ApproveTokenRequireData, 'token'> & {
     tokens: TokenItem[];
 };
-export type ActionRequireData = SwapRequireData | ApproveTokenRequireData | SendRequireData | ApproveNFTRequireData | RevokeNFTRequireData | ContractCallRequireData | Record<string, any> | ContractCallRequireData | CancelTxRequireData | WrapTokenRequireData | PushMultiSigRequireData | AssetOrderRequireData | BatchRevokePermit2RequireData | SwapTokenOrderRequireData | ContractRequireData | MultiSigRequireData | BatchApproveTokenRequireData | null;
+export interface AddLiquidityRequireData {
+    id: string;
+    protocol: {
+        name: string;
+        logo_url: string;
+    } | null;
+    bornAt: number;
+    rank: number | null;
+    receiverInWallet: boolean;
+    hasInteraction: boolean;
+    sender: string;
+    receiver: string;
+    poolRate: string;
+    token0: TokenItem;
+    token1: TokenItem;
+    marketRate: string;
+    diff: number;
+}
+export type ActionRequireData = SwapRequireData | ApproveTokenRequireData | SendRequireData | ApproveNFTRequireData | RevokeNFTRequireData | ContractCallRequireData | Record<string, any> | ContractCallRequireData | CancelTxRequireData | WrapTokenRequireData | PushMultiSigRequireData | AssetOrderRequireData | BatchRevokePermit2RequireData | SwapTokenOrderRequireData | ContractRequireData | MultiSigRequireData | BatchApproveTokenRequireData | AddLiquidityRequireData | null;

package/dist/types/parsedActionData.d.ts

@@ -108,6 +108,14 @@ export type ParsedTransactionActionData = {
         receiver?: string;
         from: string;
     };
+    addLiquidity?: {
+        receiver: string;
+        exchange_rate: string;
+        min_exchange_rate: string;
+        max_exchange_rate: string;
+        token0: TokenItem;
+        token1: TokenItem;
+    };
 };
 export type ParsedTypedDataActionData = ParsedTransactionActionData & {
     chainId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/rabby-action",
-  "version": "0.1.12-beta.0",
+  "version": "0.1.13-beta.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [