@dzapio/sdk 2.0.6 → 2.0.7

package/dist/src/utils/permit2/values.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermitBatchTransferFromValues = exports.getPermitTransferFromValues = exports.getPermitSingleValues = void 0;
+exports.getPermit2Values = getPermit2Values;
+const erc20_1 = require("../../constants/erc20");
+const permit_1 = require("../../constants/permit");
+const Permit2_1 = require("../../artifacts/Permit2");
+const index_1 = require("../index");
+const nonce_1 = require("./nonce");
+const getPermitSingleValues = async ({ spender, deadline, chainId, rpcUrls, account, expiration, token, permit2Address, }) => {
+    const publicClient = (0, index_1.getPublicClient)({ chainId, rpcUrls });
+    const nonceResult = await publicClient.readContract({
+        address: permit2Address,
+        abi: Permit2_1.abi,
+        functionName: erc20_1.erc20PermitFunctions.allowance,
+        args: [account, token.address, spender],
+    });
+    return {
+        permit2Values: {
+            details: {
+                token: token.address,
+                amount: BigInt(token.amount),
+                expiration,
+                nonce: nonceResult[2],
+            },
+            spender,
+            sigDeadline: deadline,
+        },
+        nonce: BigInt(nonceResult[2]),
+    };
+};
+exports.getPermitSingleValues = getPermitSingleValues;
+const getPermitTransferFromValues = async ({ spender, deadline, chainId, rpcUrls, account, token, permit2Address, firstTokenNonce, }) => {
+    let nonce;
+    if (token.index === 0) {
+        nonce = await (0, nonce_1.getNextPermit2Nonce)(permit2Address, account, chainId, rpcUrls);
+    }
+    else if (firstTokenNonce === null) {
+        throw new Error(`Unable to find nonce for token:${token.address} for PermitTransferFrom`);
+    }
+    else {
+        nonce = BigInt(firstTokenNonce) + BigInt(token.index);
+    }
+    return {
+        permit2Values: {
+            permitted: {
+                token: token.address,
+                amount: BigInt(token.amount),
+            },
+            spender,
+            nonce,
+            deadline,
+        },
+        nonce,
+    };
+};
+exports.getPermitTransferFromValues = getPermitTransferFromValues;
+const getPermitBatchTransferFromValues = async ({ spender, deadline, chainId, rpcUrls, account, permit2Address, tokens, }) => {
+    const nonce = await (0, nonce_1.getNextPermit2Nonce)(permit2Address, account, chainId, rpcUrls);
+    return {
+        permit2Values: {
+            permitted: tokens.map((token) => ({
+                token: token.address,
+                amount: BigInt(token.amount),
+            })),
+            spender,
+            nonce,
+            deadline,
+        },
+        nonce,
+    };
+};
+exports.getPermitBatchTransferFromValues = getPermitBatchTransferFromValues;
+async function getPermit2Values(params) {
+    switch (params.primaryType) {
+        case permit_1.permit2PrimaryType.PermitSingle:
+            if (params.expiration === undefined || params.expiration === null) {
+                throw new Error('Expiration is required for PermitSingle');
+            }
+            return (0, exports.getPermitSingleValues)(Object.assign(Object.assign({}, params), { token: params.tokens[0], expiration: params.expiration }));
+        case permit_1.permit2PrimaryType.PermitWitnessTransferFrom:
+            return (0, exports.getPermitTransferFromValues)(Object.assign(Object.assign({}, params), { token: params.tokens[0] }));
+        case permit_1.permit2PrimaryType.PermitBatchWitnessTransferFrom:
+            return (0, exports.getPermitBatchTransferFromValues)(params);
+        default:
+            throw new Error(`Invalid permit type: ${params.primaryType}`);
+    }
+}

package/dist/src/utils/permit2/witnessData.d.ts

@@ -0,0 +1,4 @@
+import { Permit2Params, WitnessData } from '../../types/permit';
+export declare const getPermit2WitnessData: (params: Permit2Params) => {
+    witnessData: WitnessData;
+};

package/dist/src/utils/permit2/witnessData.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermit2WitnessData = void 0;
+const constants_1 = require("../../constants");
+const permit_1 = require("../../types/permit");
+const getPermit2WitnessData = (params) => {
+    const { gasless, account, spender } = params;
+    let witnessData;
+    if (gasless && params.swapDataHash) {
+        if (params.txType === constants_1.GaslessTxType.swap) {
+            witnessData = {
+                witness: {
+                    txId: params.txId,
+                    user: account,
+                    executorFeesHash: params.executorFeesHash,
+                    swapDataHash: params.swapDataHash,
+                },
+                witnessTypeName: permit_1.swapGaslessWitnessType.typeName,
+                witnessType: permit_1.swapGaslessWitnessType.type,
+            };
+        }
+        else {
+            witnessData = {
+                witness: {
+                    txId: params.txId,
+                    user: account,
+                    executorFeesHash: params.executorFeesHash,
+                    swapDataHash: params.swapDataHash,
+                    adapterDataHash: params.adapterDataHash,
+                },
+                witnessTypeName: permit_1.bridgeGaslessWitnessType.typeName,
+                witnessType: permit_1.bridgeGaslessWitnessType.type,
+            };
+        }
+    }
+    else {
+        witnessData = {
+            witness: {
+                owner: account,
+                recipient: spender,
+            },
+            witnessTypeName: permit_1.defaultWitnessType.typeName,
+            witnessType: permit_1.defaultWitnessType.type,
+        };
+    }
+    return { witnessData };
+};
+exports.getPermit2WitnessData = getPermit2WitnessData;

package/dist/src/utils/signIntent/custom.d.ts

@@ -0,0 +1,11 @@
+import { StatusCodes, TxnStatus } from '../../enums';
+import { HexString } from '../../types';
+import { CustomTypedDataParams } from '../../types/permit';
+export declare const signCustomTypedData: (params: CustomTypedDataParams) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    data?: {
+        signature: HexString;
+        message: Record<string, any>;
+    };
+}>;

package/dist/src/utils/signIntent/custom.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signCustomTypedData = void 0;
+const enums_1 = require("../../enums");
+const errors_1 = require("../errors");
+const signTypedData_1 = require("../signTypedData");
+const signCustomTypedData = async (params) => {
+    try {
+        const { account, signer, message, domain, primaryType, types } = params;
+        const signature = await (0, signTypedData_1.signTypedData)({
+            signer,
+            account,
+            domain,
+            message,
+            primaryType,
+            types,
+        });
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            data: {
+                signature,
+                message,
+            },
+        };
+    }
+    catch (error) {
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+exports.signCustomTypedData = signCustomTypedData;

package/dist/src/utils/signIntent/gasless.d.ts

@@ -0,0 +1,12 @@
+import { StatusCodes, TxnStatus } from '../../enums';
+import { HexString } from '../../types';
+import { Gasless2612PermitParams } from '../../types/permit';
+export declare const signGaslessDzapUserIntent: (params: Gasless2612PermitParams) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    data?: {
+        signature: HexString;
+        nonce: bigint;
+        deadline: bigint;
+    };
+}>;

package/dist/src/utils/signIntent/gasless.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signGaslessDzapUserIntent = void 0;
+const viem_1 = require("viem");
+const constants_1 = require("../../constants");
+const permit_1 = require("../../constants/permit");
+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 errors_1 = require("../errors");
+const index_1 = require("../index");
+const signTypedData_1 = require("../signTypedData");
+const getSignTypedData = (params) => {
+    const { account, deadline, nonce, swapDataHash } = params;
+    if (params.txType === constants_1.GaslessTxType.swap) {
+        return {
+            message: {
+                txId: params.txId,
+                user: account,
+                executorFeesHash: params.executorFeesHash,
+                swapDataHash: params.swapDataHash,
+                nonce,
+                deadline,
+            },
+            types: eip_2612_1.DzapUserIntentSwapTypes,
+            primaryType: permit_1.dZapIntentPrimaryType.SignedGasLessSwapData,
+        };
+    }
+    else if (swapDataHash) {
+        return {
+            message: {
+                txId: params.txId,
+                user: account,
+                nonce,
+                deadline,
+                executorFeesHash: params.executorFeesHash,
+                swapDataHash: params.swapDataHash,
+                adapterDataHash: params.adapterDataHash,
+            },
+            types: eip_2612_1.DzapUserIntentSwapBridgeTypes,
+            primaryType: permit_1.dZapIntentPrimaryType.SignedGasLessSwapBridgeData,
+        };
+    }
+    else {
+        return {
+            message: {
+                txId: params.txId,
+                user: account,
+                nonce,
+                deadline,
+                executorFeesHash: params.executorFeesHash,
+                adapterDataHash: params.adapterDataHash,
+            },
+            types: eip_2612_1.DzapUserIntentBridgeTypes,
+            primaryType: permit_1.dZapIntentPrimaryType.SignedGasLessBridgeData,
+        };
+    }
+};
+const signGaslessDzapUserIntent = async (params) => {
+    try {
+        const { chainId, spender, account, signer, rpcUrls } = params;
+        const deadline = params.deadline || (0, date_1.generateDeadline)(permit2_1.SignatureExpiryInSecs);
+        const contract = (0, viem_1.getContract)({
+            abi: (0, index_1.getDZapAbi)('trade', params.contractVersion),
+            address: spender,
+            client: (0, index_1.getPublicClient)({ chainId, rpcUrls }),
+        });
+        const nonce = (await contract.read.getNonce([account]));
+        const domain = {
+            name: permit_1.eip2612GaslessDomain.name,
+            version: permit_1.eip2612GaslessDomain.version,
+            chainId,
+            verifyingContract: spender,
+            salt: permit_1.eip2612GaslessDomain.salt,
+        };
+        const { message, types, primaryType } = getSignTypedData(Object.assign(Object.assign({}, params), { deadline,
+            nonce }));
+        const signature = await (0, signTypedData_1.signTypedData)({
+            signer,
+            domain,
+            message,
+            types,
+            account,
+            primaryType,
+        });
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            data: {
+                signature,
+                nonce,
+                deadline,
+            },
+        };
+    }
+    catch (error) {
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+exports.signGaslessDzapUserIntent = signGaslessDzapUserIntent;

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

@@ -0,0 +1,11 @@
+import { Signer, TypedDataField } from 'ethers';
+import { TypedDataDomain, WalletClient } from 'viem';
+import { HexString } from '../types';
+export declare const signTypedData: ({ signer, domain, message, types, account, primaryType, }: {
+    signer: WalletClient | Signer;
+    domain: TypedDataDomain;
+    types: Record<string, Array<TypedDataField>>;
+    message: Record<string, any>;
+    account: string;
+    primaryType: string;
+}) => Promise<HexString>;

package/dist/src/utils/signTypedData.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTypedData = void 0;
+const index_1 = require("./index");
+const signTypedData = async ({ signer, domain, message, types, account, primaryType, }) => {
+    let signature;
+    if ((0, index_1.isTypeSigner)(signer)) {
+        signature = (await signer._signTypedData(domain, types, message));
+    }
+    else {
+        signature = await signer.signTypedData({
+            account: account,
+            domain,
+            message,
+            primaryType,
+            types,
+        });
+    }
+    return signature;
+};
+exports.signTypedData = signTypedData;

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

@@ -0,0 +1,8 @@
+import { PriceService } from '../service/price';
+import { ChainData, HexString, TokenInfo, TokenResponse } from '../types';
+export declare const isNativeCurrency: (address: string, chainConfig: ChainData) => boolean;
+export declare const sortByBalanceInUsd: (tokenEntries: [string, TokenInfo][]) => TokenResponse;
+export declare const updateTokenListPrices: (tokens: TokenResponse, chainId: number, chainConfig: ChainData, priceService: PriceService) => Promise<TokenResponse>;
+export declare function isNonEVMChain(chainId: number, chainConfig: ChainData): boolean;
+export declare const getChecksumAddress: (address: string) => HexString;
+export declare const formatToken: <T extends HexString | string = string>(token: T, nativeTokenAddress?: T) => T;

package/dist/src/utils/tokens.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToken = exports.getChecksumAddress = exports.updateTokenListPrices = exports.sortByBalanceInUsd = exports.isNativeCurrency = void 0;
+exports.isNonEVMChain = isNonEVMChain;
+const viem_1 = require("viem");
+const address_1 = require("../constants/address");
+const IPriceProvider_1 = require("../service/price/types/IPriceProvider");
+const isNativeCurrency = (address, chainConfig) => {
+    if (!chainConfig)
+        return false;
+    return Object.values(chainConfig).some((chain) => chain.isEnabled && chain.nativeToken.contract === address);
+};
+exports.isNativeCurrency = isNativeCurrency;
+const sortByBalanceInUsd = (tokenEntries) => {
+    const { withBalanceInUsd, withoutBalanceInUsd } = tokenEntries.reduce((acc, [key, token]) => {
+        if (token.balanceInUsd !== null) {
+            acc.withBalanceInUsd.push([key, token]);
+        }
+        else {
+            acc.withoutBalanceInUsd.push([key, token]);
+        }
+        return acc;
+    }, { withBalanceInUsd: [], withoutBalanceInUsd: [] });
+    withBalanceInUsd.sort((a, b) => b[1].balanceInUsd - a[1].balanceInUsd);
+    return Object.fromEntries([...withBalanceInUsd, ...withoutBalanceInUsd]);
+};
+exports.sortByBalanceInUsd = sortByBalanceInUsd;
+const updateTokenListPrices = async (tokens, chainId, chainConfig, priceService) => {
+    try {
+        const tokensWithoutPrice = Object.values(tokens)
+            .filter(({ price, balance }) => (!price || price === '0') && balance !== '0')
+            .map(({ contract }) => contract);
+        if (tokensWithoutPrice.length === 0)
+            return tokens;
+        const fetchedPrices = await priceService.getPrices({
+            chainId,
+            tokenAddresses: tokensWithoutPrice,
+            chainConfig,
+            notAllowSources: [IPriceProvider_1.priceProviders.dZap],
+        });
+        tokensWithoutPrice.forEach((token) => {
+            tokens[token].price = fetchedPrices[token] || tokens[token].price;
+            tokens[token].balanceInUsd = fetchedPrices[token]
+                ? parseFloat(fetchedPrices[token]) * parseFloat((0, viem_1.formatUnits)(BigInt(tokens[token].balance), tokens[token].decimals))
+                : null;
+        });
+        return (0, exports.sortByBalanceInUsd)(Object.entries(tokens));
+    }
+    catch (error) {
+        console.error('Error fetching token prices:', error);
+        return tokens;
+    }
+};
+exports.updateTokenListPrices = updateTokenListPrices;
+function isNonEVMChain(chainId, chainConfig) {
+    var _a;
+    return ((_a = chainConfig[chainId]) === null || _a === void 0 ? void 0 : _a.chainType) !== 'evm';
+}
+const isNativeAddress = (contract) => address_1.nativeTokens.includes(contract);
+const getChecksumAddress = (address) => (0, viem_1.getAddress)(address);
+exports.getChecksumAddress = getChecksumAddress;
+const formatToken = (token, nativeTokenAddress = viem_1.zeroAddress) => {
+    if (!(0, viem_1.isAddress)(token)) {
+        return token;
+    }
+    else if (isNativeAddress(token)) {
+        return nativeTokenAddress;
+    }
+    else {
+        return (0, exports.getChecksumAddress)(token);
+    }
+};
+exports.formatToken = formatToken;

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

@@ -0,0 +1,3 @@
+import { PriceService } from '../service/price';
+import { ChainData, TradeQuotesRequest, TradeQuotesResponse } from '../types';
+export declare const updateQuotes: (quotes: TradeQuotesResponse, request: TradeQuotesRequest, priceService: PriceService, chainConfig: ChainData) => Promise<TradeQuotesResponse>;

package/dist/src/utils/updateQuotes.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateQuotes = void 0;
+const decimal_js_1 = require("decimal.js");
+const IPriceProvider_1 = require("../service/price/types/IPriceProvider");
+const amount_1 = require("./amount");
+const updateQuotes = async (quotes, request, priceService, chainConfig) => {
+    var _a, _b;
+    const tokensWithoutPrice = {};
+    Object.values(quotes).forEach((quote) => {
+        if (quote.tokensWithoutPrice) {
+            Object.entries(quote.tokensWithoutPrice).forEach(([chainIdStr, tokens]) => {
+                const chainId = Number(chainIdStr);
+                if (!tokensWithoutPrice[chainId]) {
+                    tokensWithoutPrice[chainId] = new Set();
+                }
+                tokens.forEach((token) => tokensWithoutPrice[chainId].add(token));
+            });
+        }
+    });
+    if (Object.keys(tokensWithoutPrice).length === 0) {
+        return quotes;
+    }
+    const tokensPrice = Object.fromEntries(await Promise.all(Object.entries(tokensWithoutPrice).map(async ([chainIdStr, tokens]) => {
+        const chainId = Number(chainIdStr);
+        const tokenAddresses = Array.from(tokens);
+        const prices = await priceService.getPrices({ chainId, tokenAddresses, chainConfig, notAllowSources: [IPriceProvider_1.priceProviders.dZap] });
+        return [chainId, prices];
+    })));
+    for (const quote of Object.values(quotes)) {
+        if (!quote.quoteRates || !Object.keys(quote.quoteRates).length) {
+            continue;
+        }
+        let isSorted = true;
+        for (const data of Object.values(quote.quoteRates)) {
+            const srcDecimals = data.srcToken.decimals;
+            const destDecimals = data.destToken.decimals;
+            const toChain = data.destToken.chainId;
+            if (!Number(data.srcAmountUSD)) {
+                isSorted = false;
+                const srcTokenPricePerUnit = ((_a = tokensPrice[request.fromChain]) === null || _a === void 0 ? void 0 : _a[data.srcToken.address]) || '0';
+                data.srcAmountUSD = (0, amount_1.calculateAmountUSD)(data.srcAmount, srcDecimals, srcTokenPricePerUnit);
+            }
+            if (!Number(data.destAmountUSD)) {
+                isSorted = false;
+                const destTokenPricePerUnit = ((_b = tokensPrice[toChain]) === null || _b === void 0 ? void 0 : _b[data.destToken.address]) || '0';
+                data.destAmountUSD = (0, amount_1.calculateAmountUSD)(data.destAmount, destDecimals, destTokenPricePerUnit);
+            }
+            if (Number(data.srcAmountUSD) && Number(data.destAmountUSD)) {
+                const priceImpact = new decimal_js_1.default(data.destAmountUSD).minus(data.srcAmountUSD).div(data.srcAmountUSD).mul(100);
+                data.priceImpactPercent = priceImpact.toFixed(2);
+            }
+            const { isUpdated, fee } = (0, amount_1.updateFee)(data.fee, tokensPrice);
+            isSorted = isSorted && !isUpdated;
+            data.fee = fee;
+            data.path = (0, amount_1.updatePath)(data, tokensPrice);
+        }
+        if (Object.keys(quote.tokensWithoutPrice).length !== 0 && isSorted === false) {
+            quote.quoteRates = Object.fromEntries(Object.entries(quote.quoteRates).sort(([, a], [, b]) => {
+                const aNetAmount = (0, amount_1.calculateNetAmountUsd)(a);
+                const bNetAmount = (0, amount_1.calculateNetAmountUsd)(b);
+                return Number(bNetAmount) - Number(aNetAmount);
+            }));
+            quote.recommendedSource = Object.keys(quote.quoteRates)[0];
+        }
+    }
+    return quotes;
+};
+exports.updateQuotes = updateQuotes;

package/dist/src/zap/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './path';
+export * from './step';

package/dist/src/zap/constants/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./path"), exports);
+__exportStar(require("./step"), exports);

package/dist/src/zap/constants/path.d.ts

@@ -0,0 +1,8 @@
+export declare const zapPathAction: {
+    readonly swap: "swap";
+    readonly bridge: "bridge";
+    readonly deposit: "deposit";
+    readonly withdraw: "withdraw";
+    readonly stake: "stake";
+    readonly unstake: "unstake";
+};

package/dist/src/zap/constants/path.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zapPathAction = void 0;
+exports.zapPathAction = {
+    swap: 'swap',
+    bridge: 'bridge',
+    deposit: 'deposit',
+    withdraw: 'withdraw',
+    stake: 'stake',
+    unstake: 'unstake',
+};

package/dist/src/zap/constants/step.d.ts

@@ -0,0 +1,3 @@
+export declare const zapStepAction: {
+    readonly execute: "execute";
+};

package/dist/src/zap/constants/step.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zapStepAction = void 0;
+exports.zapStepAction = {
+    execute: 'execute',
+};

package/dist/src/zap/constants/urls.d.ts

@@ -0,0 +1,13 @@
+export declare const ZAP_ENDPOINTS: {
+    status: string;
+    config: {
+        chains: string;
+        providers: string;
+    };
+    pools: string;
+    poolDetails: string;
+    positions: string;
+    buildTx: string;
+    quote: string;
+    broadcast: string;
+};

package/dist/src/zap/constants/urls.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZAP_ENDPOINTS = void 0;
+exports.ZAP_ENDPOINTS = {
+    status: '/status',
+    config: {
+        chains: '/config/chains',
+        providers: '/config/providers',
+    },
+    pools: '/pools',
+    poolDetails: '/pool/details',
+    positions: '/user/positions',
+    buildTx: '/buildTx',
+    quote: '/quote',
+    broadcast: '/broadcast',
+};

package/dist/test/build.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/build.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dZapClient_1 = require("../src/dZapClient");
+describe('DZapClient - buildTxn', () => {
+    let client;
+    beforeAll(() => {
+        client = dZapClient_1.default.getInstance();
+    });
+    it('should build a cross-chain transaction', async () => {
+        const request = {
+            fromChain: 42161,
+            data: [
+                {
+                    amount: '374980',
+                    srcToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                    destDecimals: 18,
+                    srcDecimals: 6,
+                    protocol: 'relayLink',
+                    destToken: '0x4200000000000000000000000000000000000006',
+                    slippage: 1,
+                    recipient: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+                    toChain: 8453,
+                },
+            ],
+            gasless: false,
+            refundee: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+            sender: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+            publicKey: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+        };
+        const result = await client.buildTradeTxn(request);
+        expect(result).toBeDefined();
+        expect(result.data).toBeDefined();
+        expect(result.to).toBeDefined();
+        expect(result.from).toBeDefined();
+        expect(result.chainId).toBeDefined();
+    });
+    it('should build a same-chain transaction', async () => {
+        const request = {
+            fromChain: 42161,
+            data: [
+                {
+                    amount: '374980',
+                    srcToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                    destDecimals: 18,
+                    srcDecimals: 6,
+                    protocol: 'sushiswap',
+                    destToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+                    slippage: 1,
+                    recipient: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+                    toChain: 42161,
+                },
+            ],
+            gasless: false,
+            refundee: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+            sender: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+            publicKey: '0x99BCEBf44433E901597D9fCb16E799a4847519f6',
+        };
+        const result = await client.buildTradeTxn(request);
+        expect(result).toBeDefined();
+        expect(result.data).toBeDefined();
+        expect(result.to).toBeDefined();
+        expect(result.from).toBeDefined();
+        expect(result.chainId).toBeDefined();
+    });
+});

package/dist/test/permit/permit2Nonce.test.d.ts

@@ -0,0 +1,2 @@
+import { HexString } from '../../src/types';
+export declare const getNextPermit2NonceFromProxy: (permitAddress: HexString, account: HexString, chainId: number, rpcUrls?: string[]) => Promise<bigint>;