@dzapio/sdk 2.0.6 → 2.0.7

package/dist/src/utils/decoder/swap/inputDataDecoder.d.ts

@@ -0,0 +1,14 @@
+import { HexString, SwapInfo } from '../../../types';
+export declare class SwapInputDataDecoder {
+    private decodeSingleSwapData;
+    private decodeMultiSwapData;
+    private decodeBatchPermitSwapData;
+    private decodeGaslessExecuteMultiSwapData;
+    private decodeGaslessExecuteMultiSwapWithWitnessData;
+    private decodeGaslessExecuteSwapData;
+    private readonly swapFunctionSignatureWithInputTokenIndex;
+    updateSwapInfo: ({ data, eventSwapInfo, }: {
+        eventSwapInfo?: SwapInfo[] | SwapInfo;
+        data?: HexString;
+    }) => SwapInfo[] | SwapInfo | undefined;
+}

package/dist/src/utils/decoder/swap/inputDataDecoder.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapInputDataDecoder = void 0;
+const utils_1 = require("viem/utils");
+const abis_1 = require("./abis");
+const tokens_1 = require("../../tokens");
+class SwapInputDataDecoder {
+    constructor() {
+        this.decodeSingleSwapData = (data) => {
+            var _a;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.SingleSwap,
+            });
+            return [(_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[4]];
+        };
+        this.decodeMultiSwapData = (data) => {
+            var _a;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.MultiSwapAbi,
+            });
+            return (_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[4];
+        };
+        this.decodeBatchPermitSwapData = (data) => {
+            var _a, _b;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.BatchPermitSwapAbi,
+            });
+            const permitData = (_b = (_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[5]) === null || _b === void 0 ? void 0 : _b.permitted;
+            return permitData;
+        };
+        this.decodeGaslessExecuteMultiSwapData = (data) => {
+            var _a;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.GaslessExecuteMultiSwapAbi,
+            });
+            return (_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[7];
+        };
+        this.decodeGaslessExecuteMultiSwapWithWitnessData = (data) => {
+            var _a;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.GaslessExecuteMultiSwapWithWitnessAbi,
+            });
+            return (_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[7];
+        };
+        this.decodeGaslessExecuteSwapData = (data) => {
+            var _a;
+            const decodedData = (0, utils_1.decodeFunctionData)({
+                data,
+                abi: abis_1.SwapAbisByFunctionName.GaslessExecuteSwapAbi,
+            });
+            return [(_a = decodedData === null || decodedData === void 0 ? void 0 : decodedData.args) === null || _a === void 0 ? void 0 : _a[7]];
+        };
+        this.swapFunctionSignatureWithInputTokenIndex = {
+            '0x50d52584': {
+                name: 'singleSwap',
+                decoder: this.decodeSingleSwapData,
+            },
+            '0x8de34776': {
+                name: 'multiSwap',
+                decoder: this.decodeMultiSwapData,
+            },
+            '0x8d44ea24': {
+                name: 'batchPermitSwap',
+                decoder: this.decodeBatchPermitSwapData,
+            },
+            '0xd367ada5': {
+                name: 'gaslessExecuteMultiSwap',
+                decoder: this.decodeGaslessExecuteMultiSwapData,
+            },
+            '0xdcdc6089': {
+                name: 'gaslessExecuteMultiSwapWithWitness',
+                decoder: this.decodeGaslessExecuteMultiSwapWithWitnessData,
+            },
+            '0x0d2eedd4': {
+                name: 'gaslessExecuteSwap',
+                decoder: this.decodeGaslessExecuteSwapData,
+            },
+        };
+        this.updateSwapInfo = ({ data, eventSwapInfo, }) => {
+            var _a;
+            try {
+                if (!data || !eventSwapInfo || data === '0x') {
+                    return eventSwapInfo;
+                }
+                const functionSignature = data.slice(0, 10);
+                const decoder = (_a = this.swapFunctionSignatureWithInputTokenIndex[functionSignature]) === null || _a === void 0 ? void 0 : _a.decoder;
+                if (!decoder) {
+                    return eventSwapInfo;
+                }
+                const inputTokenData = decoder(data);
+                if (!inputTokenData || inputTokenData.length === 0) {
+                    return eventSwapInfo;
+                }
+                const tokenToAmount = inputTokenData
+                    .filter((item) => item.token && item.amount)
+                    .reduce((acc, cur) => {
+                    acc[(0, tokens_1.formatToken)(cur.token)] = cur.amount;
+                    return acc;
+                }, {});
+                if (Array.isArray(eventSwapInfo)) {
+                    return eventSwapInfo.map((item) => {
+                        const formattedSrcToken = (0, tokens_1.formatToken)(item.fromToken);
+                        const inputAmount = tokenToAmount[formattedSrcToken] || item.fromAmount;
+                        return Object.assign(Object.assign({}, item), { fromAmount: inputAmount });
+                    });
+                }
+                else {
+                    const formattedSrcToken = (0, tokens_1.formatToken)(eventSwapInfo.fromToken);
+                    const inputAmount = tokenToAmount[formattedSrcToken] || eventSwapInfo.fromAmount;
+                    return Object.assign(Object.assign({}, eventSwapInfo), { fromAmount: inputAmount });
+                }
+            }
+            catch (error) {
+                return eventSwapInfo;
+            }
+        };
+    }
+}
+exports.SwapInputDataDecoder = SwapInputDataDecoder;

package/dist/src/utils/eip-2612/eip2612Permit.d.ts

@@ -0,0 +1,23 @@
+import { StatusCodes, TxnStatus } from '../../enums';
+import { HexString, TokenPermitData } from '../../types';
+import { DefaultPermit2612Params } from '../../types/permit';
+export declare const eip2612DisabledChains: number[];
+export declare const checkEIP2612PermitSupport: ({ address, chainId, rpcUrls, owner, permit, }: {
+    chainId: number;
+    address: HexString;
+    rpcUrls?: string[];
+    owner: HexString;
+    permit?: TokenPermitData;
+}) => Promise<{
+    supportsPermit: boolean;
+    data?: {
+        version: string;
+        name: string;
+        nonce: bigint;
+    };
+}>;
+export declare const getEIP2612PermitSignature: (params: DefaultPermit2612Params) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    permitData?: HexString;
+}>;

package/dist/src/utils/eip-2612/eip2612Permit.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEIP2612PermitSignature = exports.checkEIP2612PermitSupport = exports.eip2612DisabledChains = void 0;
+const ethers_1 = require("ethers");
+const viem_1 = require("viem");
+const ERC20Permit_1 = require("../../artifacts/ERC20Permit");
+const config_1 = require("../../config");
+const constants_1 = require("../../constants");
+const erc20_1 = require("../../constants/erc20");
+const permit2_1 = require("../../constants/permit2");
+const enums_1 = require("../../enums");
+const eip_2612_1 = require("../../types/eip-2612");
+const date_1 = require("../date");
+const multicall_1 = require("../multicall");
+const signTypedData_1 = require("../signTypedData");
+exports.eip2612DisabledChains = config_1.config.getEip2612DisabledChains();
+const checkEIP2612PermitSupport = async ({ address, chainId, rpcUrls, owner, permit, }) => {
+    var _a;
+    if (((_a = permit === null || permit === void 0 ? void 0 : permit.eip2612) === null || _a === void 0 ? void 0 : _a.supported) === false || exports.eip2612DisabledChains.includes(chainId)) {
+        return { supportsPermit: false };
+    }
+    const contracts = [
+        {
+            address: address,
+            abi: ERC20Permit_1.erc20PermitAbi,
+            functionName: erc20_1.erc20Functions.domainSeparator,
+        },
+        {
+            address: address,
+            abi: ERC20Permit_1.erc20PermitAbi,
+            functionName: erc20_1.erc20Functions.nonces,
+            args: [owner],
+        },
+        {
+            address: address,
+            abi: ERC20Permit_1.erc20PermitAbi,
+            functionName: erc20_1.erc20Functions.version,
+        },
+        {
+            address: address,
+            abi: ERC20Permit_1.erc20PermitAbi,
+            functionName: erc20_1.erc20Functions.name,
+        },
+    ];
+    const multicallResult = await (0, multicall_1.multicall)({
+        chainId,
+        contracts,
+        rpcUrls,
+        allowFailure: true,
+    });
+    if (multicallResult.status !== enums_1.TxnStatus.success) {
+        return { supportsPermit: false };
+    }
+    const results = multicallResult.data;
+    const [domainSeparatorResult, nonceResult, versionResult, nameResult] = results;
+    if (domainSeparatorResult.status !== enums_1.TxnStatus.success || nonceResult.status !== enums_1.TxnStatus.success || nameResult.status !== enums_1.TxnStatus.success) {
+        return { supportsPermit: false };
+    }
+    const name = nameResult.result;
+    const nonce = nonceResult.result;
+    const version = versionResult.status === enums_1.TxnStatus.success ? versionResult.result : permit2_1.DEFAULT_PERMIT_VERSION;
+    return {
+        supportsPermit: true,
+        data: {
+            version,
+            name,
+            nonce,
+        },
+    };
+};
+exports.checkEIP2612PermitSupport = checkEIP2612PermitSupport;
+const getEIP2612PermitSignature = async (params) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    try {
+        const { chainId, spender, account, token, signer, contractVersion, service, name, nonce, version, deadline = (0, date_1.generateDeadline)(permit2_1.SignatureExpiryInSecs), } = params;
+        const { address } = token;
+        const amount = token.amount ? BigInt(token.amount) : viem_1.maxUint256;
+        const domain = ((_c = (_b = (_a = token === null || token === void 0 ? void 0 : token.permit) === null || _a === void 0 ? void 0 : _a.eip2612) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.domain)
+            ? (_f = (_e = (_d = token === null || token === void 0 ? void 0 : token.permit) === null || _d === void 0 ? void 0 : _d.eip2612) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.domain
+            : {
+                name,
+                version,
+                chainId,
+                verifyingContract: address,
+            };
+        const message = {
+            owner: account,
+            spender,
+            value: amount,
+            nonce,
+            deadline,
+        };
+        const types = eip_2612_1.EIP2612DefaultTypes;
+        const signature = await (0, signTypedData_1.signTypedData)({
+            signer,
+            domain,
+            message,
+            types,
+            account,
+            primaryType: 'Permit',
+        });
+        const sig = ethers_1.ethers.utils.splitSignature(signature);
+        const dZapPermitData = contractVersion === enums_1.ContractVersion.v1 && service !== constants_1.Services.zap
+            ? ethers_1.ethers.utils.defaultAbiCoder.encode(['address', 'address', 'uint256', 'uint256', 'uint8', 'bytes32', 'bytes32'], [account, spender, amount, deadline, sig.v, sig.r, sig.s])
+            : ethers_1.ethers.utils.defaultAbiCoder.encode(['uint256', 'uint8', 'bytes32', 'bytes32'], [deadline, sig.v, sig.r, sig.s]);
+        const permitData = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('uint8, bytes'), [enums_1.DZapPermitMode.PERMIT, dZapPermitData]);
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            permitData,
+        };
+    }
+    catch (error) {
+        console.log('Error generating permit signature:', error);
+        if (((_g = error === null || error === void 0 ? void 0 : error.cause) === null || _g === void 0 ? void 0 : _g.code) === enums_1.StatusCodes.UserRejectedRequest || (error === null || error === void 0 ? void 0 : error.code) === enums_1.StatusCodes.UserRejectedRequest) {
+            return { status: enums_1.TxnStatus.rejected, code: enums_1.StatusCodes.UserRejectedRequest };
+        }
+        return { status: enums_1.TxnStatus.error, code: enums_1.StatusCodes.Error };
+    }
+};
+exports.getEIP2612PermitSignature = getEIP2612PermitSignature;

package/dist/src/utils/eip-5792/batchApproveTokens.d.ts

@@ -0,0 +1,21 @@
+import { type WalletClient } from 'viem';
+import { HexString } from '../../types';
+import { BatchCallParams } from './sendBatchCalls';
+export declare function generateApprovalBatchCalls({ tokens, chainId, sender, spender, multicallAddress, rpcUrls, }: {
+    tokens: Array<{
+        address: HexString;
+        amount: string;
+    }>;
+    chainId: number;
+    sender: HexString;
+    spender: HexString;
+    multicallAddress?: HexString;
+    rpcUrls?: string[];
+}): Promise<BatchCallParams[]>;
+export declare function batchApproveTokens(walletClient: WalletClient, tokens: Array<{
+    address: HexString;
+    amount: string;
+}>, chainId: number, spender: HexString, sender: HexString, multicallAddress?: HexString, rpcUrls?: string[]): Promise<{
+    success: boolean;
+    batchId?: string;
+}>;

package/dist/src/utils/eip-5792/batchApproveTokens.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApprovalBatchCalls = generateApprovalBatchCalls;
+exports.batchApproveTokens = batchApproveTokens;
+const encodeApproveCall_1 = require("../encodeApproveCall");
+const erc20_1 = require("../erc20");
+const index_1 = require("../index");
+const sendBatchCalls_1 = require("./sendBatchCalls");
+async function generateApprovalBatchCalls({ tokens, chainId, sender, spender, multicallAddress, rpcUrls, }) {
+    const tokensToCheck = tokens.filter((token) => !(0, index_1.isDZapNativeToken)(token.address));
+    if (tokensToCheck.length === 0) {
+        return [];
+    }
+    const { data: allowanceData } = await (0, erc20_1.getAllowance)({
+        chainId,
+        sender,
+        tokens: tokensToCheck,
+        spender,
+        multicallAddress,
+        rpcUrls,
+    });
+    const tokensNeedingApproval = tokensToCheck.filter((token) => { var _a; return (_a = allowanceData[token.address]) === null || _a === void 0 ? void 0 : _a.approvalNeeded; });
+    return tokensNeedingApproval.map((token) => ({
+        to: token.address,
+        data: (0, encodeApproveCall_1.encodeApproveCallData)({
+            spender,
+            amount: BigInt(token.amount),
+        }),
+        value: BigInt(0),
+    }));
+}
+async function batchApproveTokens(walletClient, tokens, chainId, spender, sender, multicallAddress, rpcUrls) {
+    const approveCalls = await generateApprovalBatchCalls({
+        tokens,
+        chainId,
+        sender,
+        multicallAddress,
+        spender,
+        rpcUrls,
+    });
+    if (approveCalls.length === 0) {
+        return { success: true };
+    }
+    const batchResult = await (0, sendBatchCalls_1.sendBatchCalls)(walletClient, approveCalls);
+    return {
+        success: Boolean(batchResult),
+        batchId: batchResult === null || batchResult === void 0 ? void 0 : batchResult.id,
+    };
+}

package/dist/src/utils/eip-5792/index.d.ts

@@ -0,0 +1,3 @@
+export { batchApproveTokens } from './batchApproveTokens';
+export { sendBatchCalls, type BatchCallParams } from './sendBatchCalls';
+export { waitForBatchTransactionReceipt } from './waitForBatchTransactionReceipt';

package/dist/src/utils/eip-5792/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForBatchTransactionReceipt = exports.sendBatchCalls = exports.batchApproveTokens = void 0;
+var batchApproveTokens_1 = require("./batchApproveTokens");
+Object.defineProperty(exports, "batchApproveTokens", { enumerable: true, get: function () { return batchApproveTokens_1.batchApproveTokens; } });
+var sendBatchCalls_1 = require("./sendBatchCalls");
+Object.defineProperty(exports, "sendBatchCalls", { enumerable: true, get: function () { return sendBatchCalls_1.sendBatchCalls; } });
+var waitForBatchTransactionReceipt_1 = require("./waitForBatchTransactionReceipt");
+Object.defineProperty(exports, "waitForBatchTransactionReceipt", { enumerable: true, get: function () { return waitForBatchTransactionReceipt_1.waitForBatchTransactionReceipt; } });

package/dist/src/utils/eip-5792/isBatchTxnSupportedByWallet.d.ts

@@ -0,0 +1,6 @@
+import { Client } from 'viem';
+export declare function isBatchTxnSupportedByWallet({ client, chainId, skipReady, }: {
+    client: Client;
+    chainId: number;
+    skipReady?: boolean;
+}): Promise<boolean>;

package/dist/src/utils/eip-5792/isBatchTxnSupportedByWallet.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBatchTxnSupportedByWallet = isBatchTxnSupportedByWallet;
+const viem_1 = require("viem");
+const actions_1 = require("viem/actions");
+const utils_1 = require("viem/utils");
+async function isBatchTxnSupportedByWallet({ client, chainId, skipReady = false, }) {
+    var _a, _b, _c;
+    try {
+        const capabilities = await (0, viem_1.withTimeout)(async () => await (0, utils_1.getAction)(client, actions_1.getCapabilities, 'getCapabilities')({ chainId }), {
+            timeout: 2000,
+            errorInstance: new Error('Timeout'),
+        });
+        return (((_a = capabilities === null || capabilities === void 0 ? void 0 : capabilities.atomicBatch) === null || _a === void 0 ? void 0 : _a.supported) ||
+            ((_b = capabilities === null || capabilities === void 0 ? void 0 : capabilities.atomic) === null || _b === void 0 ? void 0 : _b.status) === 'supported' ||
+            (!skipReady && ((_c = capabilities === null || capabilities === void 0 ? void 0 : capabilities.atomic) === null || _c === void 0 ? void 0 : _c.status) === 'ready') ||
+            false);
+    }
+    catch (_d) {
+        return false;
+    }
+}

package/dist/src/utils/eip-5792/sendBatchCalls.d.ts

@@ -0,0 +1,10 @@
+import { WalletClient } from 'viem';
+import { HexString } from '../../types';
+export type BatchCallParams = {
+    to: HexString;
+    data: HexString;
+    value?: bigint;
+};
+export declare function sendBatchCalls(walletClient: WalletClient, calls: BatchCallParams[]): Promise<{
+    id: string;
+} | null>;

package/dist/src/utils/eip-5792/sendBatchCalls.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendBatchCalls = sendBatchCalls;
+const actions_1 = require("viem/actions");
+const utils_1 = require("viem/utils");
+async function sendBatchCalls(walletClient, calls) {
+    try {
+        const result = await (0, utils_1.getAction)(walletClient, actions_1.sendCalls, 'sendCalls')({
+            account: walletClient.account,
+            calls: calls.map((call) => {
+                var _a;
+                return ({
+                    to: call.to,
+                    data: call.data,
+                    value: (_a = call.value) !== null && _a !== void 0 ? _a : BigInt(0),
+                });
+            }),
+        });
+        return result;
+    }
+    catch (error) {
+        console.warn('EIP-5792 batch calls not supported:', error);
+        return null;
+    }
+}

package/dist/src/utils/eip-5792/waitForBatchTransactionReceipt.d.ts

@@ -0,0 +1,4 @@
+import { type Client } from 'viem';
+import { HexString } from '../../types';
+import { WalletCallReceipt } from '../../types/wallet';
+export declare const waitForBatchTransactionReceipt: (client: Client, batchHash: HexString) => Promise<WalletCallReceipt>;

package/dist/src/utils/eip-5792/waitForBatchTransactionReceipt.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForBatchTransactionReceipt = void 0;
+const actions_1 = require("viem/actions");
+const utils_1 = require("viem/utils");
+const enums_1 = require("../../enums");
+const waitForBatchTransactionReceipt = async (client, batchHash) => {
+    const { receipts, status, statusCode } = await (0, utils_1.getAction)(client, actions_1.waitForCallsStatus, 'waitForCallsStatus')({
+        id: batchHash,
+        timeout: 3600000 * 24,
+    });
+    if (status === enums_1.TxnStatus.success) {
+        if (!(receipts === null || receipts === void 0 ? void 0 : receipts.length) ||
+            !receipts.every((receipt) => receipt.transactionHash) ||
+            receipts.some((receipt) => receipt.status === enums_1.TxnStatus.reverted)) {
+            throw new Error('Transaction was reverted.');
+        }
+        const transactionReceipt = receipts[receipts.length - 1];
+        return transactionReceipt;
+    }
+    if (statusCode >= 400 && statusCode < 500) {
+        throw new Error('Transaction was canceled.');
+    }
+    throw new Error('Transaction failed.');
+};
+exports.waitForBatchTransactionReceipt = waitForBatchTransactionReceipt;

package/dist/src/utils/encodeApproveCall.d.ts

@@ -0,0 +1,6 @@
+import { Address } from 'viem';
+import { HexString } from '../types';
+export declare function encodeApproveCallData({ spender, amount }: {
+    spender: Address;
+    amount: bigint;
+}): HexString;

package/dist/src/utils/encodeApproveCall.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeApproveCallData = encodeApproveCallData;
+const viem_1 = require("viem");
+const erc20_1 = require("../constants/erc20");
+const artifacts_1 = require("../artifacts");
+function encodeApproveCallData({ spender, amount }) {
+    return (0, viem_1.encodeFunctionData)({
+        abi: artifacts_1.erc20Abi,
+        functionName: erc20_1.erc20Functions.approve,
+        args: [spender, amount],
+    });
+}

package/dist/src/utils/erc20.d.ts

@@ -0,0 +1,65 @@
+import { Signer } from 'ethers';
+import { WalletClient } from 'viem';
+import { StatusCodes, TxnStatus } from '../enums';
+import { ApprovalMode, HexString, TokenPermitData } from '../types';
+type AllowanceParams = {
+    chainId: number;
+    sender: HexString;
+    tokens: {
+        address: HexString;
+        amount: string;
+        permit?: TokenPermitData;
+    }[];
+    spender: HexString;
+    rpcUrls?: string[];
+    mode?: ApprovalMode;
+    multicallAddress?: HexString;
+};
+export declare const approveToken: ({ chainId, signer, rpcUrls, mode, tokens, approvalTxnCallback, spender, }: {
+    chainId: number;
+    signer: WalletClient | Signer;
+    mode: ApprovalMode;
+    tokens: {
+        address: HexString;
+        amount: string;
+    }[];
+    rpcUrls?: string[];
+    approvalTxnCallback?: ({ txnDetails, address, }: {
+        txnDetails: {
+            txnHash: string;
+            code: StatusCodes;
+            status: TxnStatus;
+        };
+        address: HexString;
+    }) => Promise<TxnStatus | null>;
+    spender: HexString;
+}) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+}>;
+export declare const batchGetAllowances: ({ chainId, data, owner, multicallAddress, rpcUrls, }: {
+    chainId: number;
+    data: {
+        token: HexString;
+        spender: HexString;
+    }[];
+    owner: HexString;
+    multicallAddress?: HexString;
+    rpcUrls?: string[];
+}) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    data: Record<string, bigint>;
+}>;
+export declare const getAllowance: ({ chainId, sender, tokens, rpcUrls, multicallAddress, mode, spender }: AllowanceParams) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    data: {
+        [key: string]: {
+            allowance: bigint;
+            approvalNeeded: boolean;
+            signatureNeeded: boolean;
+        };
+    };
+}>;
+export {};