@dzapio/sdk 2.0.6 → 2.0.7

package/dist/src/service/price/provider/coingecko/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoingeckoPriceProvider = void 0;
+const httpMethods_1 = require("../../../../constants/httpMethods");
+const axios_1 = require("../../../../utils/axios");
+const tokens_1 = require("../../../../utils/tokens");
+const IPriceProvider_1 = require("../../types/IPriceProvider");
+const config_1 = require("./config");
+class CoingeckoPriceProvider {
+    constructor() {
+        this.id = IPriceProvider_1.priceProviders.coingecko;
+        this.requiresChainConfig = true;
+        this.fetchNativePrice = async (chainId, chainConfig) => {
+            var _a;
+            if (!chainConfig || !chainConfig[chainId].isEnabled)
+                return 0;
+            const { coingecko } = chainConfig[chainId];
+            if (!coingecko)
+                return 0;
+            const response = await (0, axios_1.invoke)({
+                endpoint: config_1.coingeckoConfig.urls.nativeTokenPrice(coingecko === null || coingecko === void 0 ? void 0 : coingecko.nativeTokenKey),
+                method: httpMethods_1.GET,
+            });
+            return ((_a = response[coingecko === null || coingecko === void 0 ? void 0 : coingecko.nativeTokenKey]) === null || _a === void 0 ? void 0 : _a.usd) || null;
+        };
+        this.fetchERC20Prices = async (chainId, addresses, chainConfig) => {
+            if (!addresses.length || !chainConfig || !chainConfig[chainId].isEnabled)
+                return {};
+            const { coingecko } = chainConfig[chainId];
+            if (!coingecko)
+                return {};
+            const requests = addresses.map((address) => (0, axios_1.invoke)({ endpoint: config_1.coingeckoConfig.urls.ecr20TokenPrice(address, coingecko.chainKey), method: httpMethods_1.GET }));
+            const responses = await Promise.allSettled(requests);
+            return responses.reduce((acc, result, index) => {
+                var _a;
+                const address = addresses[index];
+                if (result.status === 'fulfilled') {
+                    const tokenPrice = (_a = result.value[address.toLowerCase()]) === null || _a === void 0 ? void 0 : _a.usd;
+                    acc[address] = tokenPrice === undefined ? null : tokenPrice.toString();
+                }
+                else {
+                    acc[address] = null;
+                    console.error(`Error fetching data for address ${address}:`, result.reason);
+                }
+                return acc;
+            }, {});
+        };
+        this.fetchPrices = async (chainId, tokenAddresses, chainConfig) => {
+            try {
+                const addressesWithoutNativeToken = tokenAddresses.filter((address) => !(0, tokens_1.isNativeCurrency)(address, chainConfig));
+                const [erc20Prices, nativePrice] = await Promise.all([
+                    this.fetchERC20Prices(chainId, addressesWithoutNativeToken, chainConfig),
+                    addressesWithoutNativeToken.length !== tokenAddresses.length ? this.fetchNativePrice(chainId, chainConfig) : undefined,
+                ]);
+                if (chainConfig[chainId].isEnabled && nativePrice) {
+                    erc20Prices[chainConfig[chainId].nativeToken.contract] = nativePrice.toString();
+                }
+                return erc20Prices;
+            }
+            catch (e) {
+                return {};
+            }
+        };
+    }
+}
+exports.CoingeckoPriceProvider = CoingeckoPriceProvider;

package/dist/src/service/price/provider/defiLlama/config.d.ts

@@ -0,0 +1,3 @@
+export declare const defiLlamaConfig: {
+    url: (tokens: string[]) => string;
+};

package/dist/src/service/price/provider/defiLlama/config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defiLlamaConfig = void 0;
+exports.defiLlamaConfig = {
+    url: (tokens) => `https://coins.llama.fi/prices/current/${tokens.join(',')}`,
+};

package/dist/src/service/price/provider/defiLlama/index.d.ts

@@ -0,0 +1,9 @@
+import { ChainData } from '../../../../types';
+import { IPriceProvider } from '../../types/IPriceProvider';
+export declare class DefiLlamaPriceProvider implements IPriceProvider {
+    id: "defiLlama";
+    requiresChainConfig: boolean;
+    private preProcess;
+    private postProcess;
+    fetchPrices: (chainId: number, tokenAddresses: string[], chainConfig: ChainData) => Promise<Record<string, string | null>>;
+}

package/dist/src/service/price/provider/defiLlama/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefiLlamaPriceProvider = void 0;
+const httpMethods_1 = require("../../../../constants/httpMethods");
+const axios_1 = require("../../../../utils/axios");
+const tokens_1 = require("../../../../utils/tokens");
+const IPriceProvider_1 = require("../../types/IPriceProvider");
+const config_1 = require("./config");
+class DefiLlamaPriceProvider {
+    constructor() {
+        this.id = IPriceProvider_1.priceProviders.defiLlama;
+        this.requiresChainConfig = true;
+        this.postProcess = (chainId, tokenAddresses, chainConfig, respose) => {
+            const { name } = chainConfig[chainId];
+            if (!name)
+                return {};
+            return tokenAddresses.reduce((acc, address) => {
+                const token = respose.coins[`${name}:${address}`];
+                if (!token) {
+                    acc[address] = null;
+                    return acc;
+                }
+                acc[address] = token.price.toString();
+                return acc;
+            }, {});
+        };
+        this.fetchPrices = async (chainId, tokenAddresses, chainConfig) => {
+            try {
+                const requestTokens = this.preProcess(chainId, tokenAddresses, chainConfig);
+                if (!requestTokens.length)
+                    return {};
+                const response = await (0, axios_1.invoke)({
+                    endpoint: config_1.defiLlamaConfig.url(requestTokens),
+                    method: httpMethods_1.GET,
+                });
+                return this.postProcess(chainId, tokenAddresses, chainConfig, response);
+            }
+            catch (e) {
+                return {};
+            }
+        };
+    }
+    preProcess(chainId, tokenAddresses, chainConfig) {
+        const chainInfo = chainConfig[chainId];
+        if (!chainInfo.isEnabled || !(chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.name)) {
+            return [];
+        }
+        const { name, defiLlama } = chainInfo;
+        return tokenAddresses.map((address) => {
+            if (defiLlama === null || defiLlama === void 0 ? void 0 : defiLlama.chainKey) {
+                if ((0, tokens_1.isNativeCurrency)(address, chainConfig)) {
+                    return `${defiLlama.chainKey}:${defiLlama.nativeTokenKey}`;
+                }
+                return `${defiLlama.chainKey}:${address}`;
+            }
+            return `${name}:${address}`;
+        });
+    }
+}
+exports.DefiLlamaPriceProvider = DefiLlamaPriceProvider;

package/dist/src/service/price/provider/defiLlama/types.d.ts

@@ -0,0 +1,11 @@
+export type DefiLlamaCoin = {
+    price: number;
+    symbol: string;
+    timestamp: number;
+    confidence: number;
+};
+export type DefiLlamaResponse = {
+    coins: {
+        [key: string]: DefiLlamaCoin;
+    };
+};

package/dist/src/service/price/provider/defiLlama/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/service/price/provider/dzap/index.d.ts

@@ -0,0 +1,6 @@
+import { IPriceProvider } from '../../types/IPriceProvider';
+export declare class DZapPriceProvider implements IPriceProvider {
+    id: "dZap";
+    requiresChainConfig: boolean;
+    fetchPrices: (chainId: number, tokenAddresses: string[]) => Promise<Record<string, string | null>>;
+}

package/dist/src/service/price/provider/dzap/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DZapPriceProvider = void 0;
+const api_1 = require("../../../../api");
+const IPriceProvider_1 = require("../../types/IPriceProvider");
+class DZapPriceProvider {
+    constructor() {
+        this.id = IPriceProvider_1.priceProviders.dZap;
+        this.requiresChainConfig = false;
+        this.fetchPrices = async (chainId, tokenAddresses) => {
+            try {
+                const tokenPrices = await (0, api_1.fetchTokenPrice)(tokenAddresses, chainId);
+                return tokenPrices;
+            }
+            catch (e) {
+                console.error('Failed to fetch token price', e);
+                return {};
+            }
+        };
+    }
+}
+exports.DZapPriceProvider = DZapPriceProvider;

package/dist/src/service/price/types/IPriceProvider.d.ts

@@ -0,0 +1,14 @@
+import { ChainData } from '../../../types';
+export declare const priceProviders: {
+    readonly dZap: "dZap";
+    readonly defiLlama: "defiLlama";
+    readonly coingecko: "coingecko";
+};
+export type PriceProvider = (typeof priceProviders)[keyof typeof priceProviders];
+export type IPriceProvider = {
+    id: PriceProvider;
+    requiresChainConfig: boolean;
+    fetchPrices(chainId: number, tokenAddresses: string[], chainConfig: ChainData | null): Promise<Record<string, string | null>>;
+    allowedSources?: PriceProvider[];
+    notAllowedSources?: PriceProvider[];
+};

package/dist/src/service/price/types/IPriceProvider.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priceProviders = void 0;
+exports.priceProviders = {
+    dZap: 'dZap',
+    defiLlama: 'defiLlama',
+    coingecko: 'coingecko',
+};

package/dist/src/transactionHandlers/generic.d.ts

@@ -0,0 +1,24 @@
+import { Signer } from 'ethers';
+import { WalletClient } from 'viem';
+import { StatusCodes, TxnStatus } from '../enums';
+import { HexString } from '../types';
+declare class GenericTxnHandler {
+    static sendTransaction: ({ chainId, signer, from, to, data, value, }: {
+        chainId: number;
+        signer: Signer | WalletClient;
+        from: HexString;
+        to: HexString;
+        data: HexString;
+        value: string;
+    }) => Promise<{
+        status: TxnStatus;
+        error: any;
+        errorMsg: any;
+        code: StatusCodes;
+    } | {
+        status: TxnStatus;
+        code: StatusCodes;
+        txnHash: HexString;
+    }>;
+}
+export default GenericTxnHandler;

package/dist/src/transactionHandlers/generic.js

@@ -0,0 +1,48 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const chains_1 = require("../chains");
+const errors_1 = require("../utils/errors");
+class GenericTxnHandler {
+}
+_a = GenericTxnHandler;
+GenericTxnHandler.sendTransaction = async ({ chainId, signer, from, to, data, value, }) => {
+    try {
+        if ((0, utils_1.isTypeSigner)(signer)) {
+            console.log('Using ethers signer.');
+            const txnRes = await signer.sendTransaction({
+                from,
+                to,
+                data,
+                value,
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash: txnRes.hash,
+            };
+        }
+        else {
+            console.log('Using viem walletClient.');
+            const txnHash = await signer.sendTransaction({
+                chain: chains_1.viemChainsById[chainId],
+                account: from,
+                to: to,
+                data: data,
+                value: BigInt(value),
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash,
+            };
+        }
+    }
+    catch (error) {
+        console.log({ error });
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+exports.default = GenericTxnHandler;

package/dist/src/transactionHandlers/permit.d.ts

@@ -0,0 +1,61 @@
+import { PermitTypes } from '../constants/permit';
+import { ContractVersion, StatusCodes, TxnStatus } from '../enums';
+import { AvailableDZapServices, GaslessSignatureParams, GasSignatureParams, HexString, PermitMode, SignPermitResponse } from '../types';
+import { BatchPermitResponse, GaslessBridgeParams, GaslessSwapParams, PermitParams, PermitResponse, TokenWithPermitData } from '../types/permit';
+type BasePermitDataParams = {
+    oneToMany: boolean;
+    token: TokenWithPermitData;
+    totalSrcAmount: bigint;
+    permitType: PermitMode;
+    firstTokenNonce?: bigint;
+} & Omit<PermitParams, 'permitType'>;
+type PermitDataParams = BasePermitDataParams & ({
+    gasless: false;
+} | GaslessSwapParams | GaslessBridgeParams);
+type BaseBatchPermitParams = {
+    tokens: TokenWithPermitData[];
+    permitType: typeof PermitTypes.PermitBatchWitnessTransferFrom;
+} & Omit<PermitParams, 'permitType'>;
+type BatchPermitParams = BaseBatchPermitParams & ({
+    gasless: false;
+} | GaslessSwapParams | GaslessBridgeParams);
+declare class PermitTxnHandler {
+    static generateBatchPermitDataForTokens: (params: BatchPermitParams) => Promise<BatchPermitResponse>;
+    static generatePermitDataForToken: (params: PermitDataParams) => Promise<PermitResponse>;
+    static signGaslessUserIntent: (signPermitReq: GaslessSignatureParams) => Promise<{
+        status: TxnStatus;
+        code: StatusCodes;
+        data: {
+            type: "EIP2612Permit";
+            signature: HexString;
+            nonce: bigint;
+            deadline: bigint;
+            batchPermitData?: undefined;
+        } | undefined;
+    } | {
+        status: TxnStatus;
+        code: StatusCodes;
+        data: {
+            type: "PermitSingle" | "PermitWitnessTransferFrom" | "PermitBatchWitnessTransferFrom";
+            batchPermitData: `0x${string}`;
+        } | undefined;
+    }>;
+    static v1PermitSupport: ({ contractVersion, service }: {
+        contractVersion: ContractVersion;
+        service: AvailableDZapServices;
+    }) => boolean;
+    static shouldUseBatchPermit: ({ permitType, isBatchPermitAllowed, tokens, oneToMany, contractVersion, service, }: {
+        permitType: PermitMode;
+        isBatchPermitAllowed?: boolean;
+        tokens: {
+            address: HexString;
+            permitData?: HexString | undefined;
+            amount: string;
+        }[];
+        oneToMany: boolean;
+        contractVersion: ContractVersion;
+        service: AvailableDZapServices;
+    }) => boolean;
+    static signPermit: (signPermitReq: GasSignatureParams) => Promise<SignPermitResponse>;
+}
+export default PermitTxnHandler;

package/dist/src/transactionHandlers/permit.js

@@ -0,0 +1,177 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const permit_1 = require("../constants/permit");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const gasless_1 = require("../utils/signIntent/gasless");
+const eip2612Permit_1 = require("../utils/eip-2612/eip2612Permit");
+const permit2_1 = require("../utils/permit2");
+class PermitTxnHandler {
+}
+_a = PermitTxnHandler;
+PermitTxnHandler.generateBatchPermitDataForTokens = async (params) => {
+    const resp = await (0, permit2_1.getPermit2Signature)(params);
+    return Object.assign(Object.assign({}, resp), { permitType: permit_1.PermitTypes.PermitBatchWitnessTransferFrom });
+};
+PermitTxnHandler.generatePermitDataForToken = async (params) => {
+    const { token, oneToMany, totalSrcAmount, chainId, rpcUrls, permitType, account } = params;
+    const isFirstToken = token.index === 0;
+    if ((0, utils_1.isDZapNativeToken)(token.address)) {
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            permitData: constants_1.DEFAULT_PERMIT_DATA,
+            nonce: BigInt(0),
+            permitType: permit_1.PermitTypes.EIP2612Permit,
+        };
+    }
+    const amount = oneToMany && isFirstToken ? totalSrcAmount : BigInt(token.amount);
+    const eip2612PermitData = await (0, eip2612Permit_1.checkEIP2612PermitSupport)({
+        address: token.address,
+        chainId,
+        rpcUrls,
+        owner: account,
+        permit: token.permit,
+    });
+    if (permitType === permit_1.PermitTypes.EIP2612Permit || (permitType === permit_1.PermitTypes.AutoPermit && eip2612PermitData.supportsPermit)) {
+        if (!eip2612PermitData.supportsPermit || !eip2612PermitData.data) {
+            throw new Error('Token does not support EIP-2612 permits');
+        }
+        if (oneToMany && !isFirstToken) {
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                permitData: constants_1.DEFAULT_PERMIT_DATA,
+                nonce: BigInt(0),
+                permitType: permit_1.PermitTypes.EIP2612Permit,
+            };
+        }
+        const { permitData, status, code } = await (0, eip2612Permit_1.getEIP2612PermitSignature)(Object.assign(Object.assign({}, params), { token: {
+                address: token.address,
+                amount: amount.toString(),
+                index: 0,
+                permit: token.permit,
+            }, gasless: false, version: eip2612PermitData.data.version, name: eip2612PermitData.data.name, nonce: eip2612PermitData.data.nonce }));
+        return {
+            status,
+            code,
+            permitData: permitData,
+            nonce: BigInt(0),
+            permitType: permit_1.PermitTypes.EIP2612Permit,
+        };
+    }
+    else {
+        const normalizedPermitType = permitType === permit_1.PermitTypes.AutoPermit ? permit_1.PermitTypes.PermitWitnessTransferFrom : permitType;
+        if (oneToMany && !isFirstToken) {
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                permitData: constants_1.DEFAULT_PERMIT2_DATA,
+                nonce: BigInt(0),
+                permitType: normalizedPermitType,
+            };
+        }
+        else {
+            const resp = await (0, permit2_1.getPermit2Signature)(Object.assign(Object.assign({}, params), { tokens: [token], permitType: normalizedPermitType }));
+            return Object.assign(Object.assign({}, resp), { permitType: normalizedPermitType });
+        }
+    }
+};
+PermitTxnHandler.signGaslessUserIntent = async (signPermitReq) => {
+    const { tokens, sender, permitType } = signPermitReq;
+    const type = permitType === permit_1.PermitTypes.AutoPermit ? permit_1.PermitTypes.PermitBatchWitnessTransferFrom : permitType;
+    if (type === permit_1.PermitTypes.EIP2612Permit) {
+        const resp = await (0, gasless_1.signGaslessDzapUserIntent)(Object.assign(Object.assign({}, signPermitReq), { account: sender }));
+        return {
+            status: resp.status,
+            code: resp.code,
+            data: (resp === null || resp === void 0 ? void 0 : resp.data) && Object.assign(Object.assign({}, resp.data), { type }),
+        };
+    }
+    const resp = await (0, permit2_1.getPermit2Signature)(Object.assign(Object.assign({}, signPermitReq), { tokens: tokens.map((token, index) => (Object.assign(Object.assign({}, token), { index }))), account: sender, permitType: type }));
+    return {
+        status: resp.status,
+        code: resp.code,
+        data: resp.permitData && {
+            type: type,
+            batchPermitData: resp.permitData,
+        },
+    };
+};
+PermitTxnHandler.v1PermitSupport = ({ contractVersion, service }) => {
+    return contractVersion === enums_1.ContractVersion.v1 && service !== constants_1.Services.zap;
+};
+PermitTxnHandler.shouldUseBatchPermit = ({ permitType, isBatchPermitAllowed = true, tokens, oneToMany, contractVersion, service, }) => {
+    const isBatchPermitRequested = permitType === permit_1.PermitTypes.PermitBatchWitnessTransferFrom;
+    const shouldAutoBatch = permitType === permit_1.PermitTypes.AutoPermit && (tokens === null || tokens === void 0 ? void 0 : tokens.length) > 1 && !oneToMany;
+    const isContractSupport = !_a.v1PermitSupport({ contractVersion, service });
+    return isBatchPermitAllowed && (isBatchPermitRequested || shouldAutoBatch) && isContractSupport;
+};
+PermitTxnHandler.signPermit = async (signPermitReq) => {
+    var _b;
+    const { tokens } = signPermitReq;
+    if (tokens.length === 0) {
+        return { status: enums_1.TxnStatus.success, code: enums_1.StatusCodes.Success, tokens, permitType: signPermitReq.permitType };
+    }
+    const oneToMany = tokens.length > 1 && (0, utils_1.isOneToMany)(tokens[0].address, tokens[1].address);
+    const shouldUseBatchPermit = _a.shouldUseBatchPermit({
+        permitType: signPermitReq.permitType,
+        isBatchPermitAllowed: signPermitReq.isBatchPermitAllowed,
+        tokens,
+        oneToMany,
+        contractVersion: signPermitReq.contractVersion,
+        service: signPermitReq.service,
+    });
+    if (shouldUseBatchPermit) {
+        const resp = await _a.generateBatchPermitDataForTokens(Object.assign(Object.assign({}, signPermitReq), { tokens: tokens.map((token, index) => (Object.assign(Object.assign({}, token), { index }))), account: signPermitReq.sender, permitType: permit_1.PermitTypes.PermitBatchWitnessTransferFrom }));
+        if (resp.status !== enums_1.TxnStatus.success) {
+            return { status: resp.status, code: resp.code, permitType: permit_1.PermitTypes.PermitBatchWitnessTransferFrom };
+        }
+        if (signPermitReq.signatureCallback) {
+            await signPermitReq.signatureCallback({
+                batchPermitData: resp.permitData,
+                tokens,
+                permitType: resp.permitType,
+            });
+        }
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            batchPermitData: resp.permitData,
+            permitType: resp.permitType,
+        };
+    }
+    else {
+        const totalSrcAmount = (0, utils_1.calcTotalSrcTokenAmount)(tokens);
+        let firstTokenNonce = null;
+        let permitType = _a.v1PermitSupport({ contractVersion: signPermitReq.contractVersion, service: signPermitReq.service })
+            ? permit_1.PermitTypes.PermitSingle
+            : signPermitReq.permitType;
+        for (let dataIdx = 0; dataIdx < tokens.length; dataIdx++) {
+            const isFirstToken = dataIdx === 0;
+            const res = await _a.generatePermitDataForToken(Object.assign(Object.assign({}, signPermitReq), { token: Object.assign(Object.assign({}, tokens[dataIdx]), { index: dataIdx }), firstTokenNonce: firstTokenNonce !== null && firstTokenNonce !== void 0 ? firstTokenNonce : undefined, oneToMany,
+                totalSrcAmount, account: signPermitReq.sender, permitType }));
+            permitType = res.permitType;
+            if (res.status !== enums_1.TxnStatus.success) {
+                return { status: res.status, code: res.code, permitType: res.permitType };
+            }
+            tokens[dataIdx].permitData = res.permitData;
+            if (isFirstToken && !(0, utils_1.isDZapNativeToken)(tokens[dataIdx].address)) {
+                firstTokenNonce = (_b = res.nonce) !== null && _b !== void 0 ? _b : null;
+            }
+            if (signPermitReq.signatureCallback && !(0, utils_1.isDZapNativeToken)(tokens[dataIdx].address)) {
+                const amount = oneToMany && isFirstToken ? totalSrcAmount : BigInt(tokens[dataIdx].amount);
+                await signPermitReq.signatureCallback({
+                    permitData: res.permitData,
+                    srcToken: tokens[dataIdx].address,
+                    amount: amount.toString(),
+                    permitType: res.permitType,
+                });
+            }
+        }
+        return { status: enums_1.TxnStatus.success, tokens, code: enums_1.StatusCodes.Success, permitType };
+    }
+};
+exports.default = PermitTxnHandler;

package/dist/src/transactionHandlers/trade.d.ts

@@ -0,0 +1,24 @@
+import { Signer } from 'ethers';
+import { WalletClient } from 'viem';
+import { DZapTransactionResponse, GaslessTradeBuildTxnResponse, HexString, TradeBuildTxnRequest, TradeBuildTxnResponse } from '../types';
+declare class TradeTxnHandler {
+    private static sendTransaction;
+    private static sendTxnWithBatch;
+    private static sendHyperLiquidTransaction;
+    static buildAndSendTransaction: ({ request, signer, txnData, multicallAddress, batchTransaction, rpcUrls, }: {
+        request: TradeBuildTxnRequest;
+        signer: Signer | WalletClient;
+        txnData?: TradeBuildTxnResponse;
+        batchTransaction: boolean;
+        multicallAddress?: HexString;
+        rpcUrls?: string[];
+    }) => Promise<DZapTransactionResponse>;
+    static buildGaslessTxAndSignPermit: ({ request, signer, rpcUrls, spender, txnData, }: {
+        request: TradeBuildTxnRequest;
+        signer: Signer | WalletClient;
+        rpcUrls: string[];
+        spender: HexString;
+        txnData?: GaslessTradeBuildTxnResponse;
+    }) => Promise<DZapTransactionResponse>;
+}
+export default TradeTxnHandler;