@dzapio/sdk 1.0.3 → 2.0.2

package/dist/transactionHandlers/permit.d.ts

@@ -1,60 +1,61 @@
-import { Signer } from 'ethers';
-import { WalletClient } from 'viem';
+import { PermitTypes } from '../constants/permit';
 import { ContractVersion, StatusCodes, TxnStatus } from '../enums';
-import { AvailableDZapServices, HexString, PermitMode } from '../types';
+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 generatePermitDataForToken: ({ token, isFirstToken, oneToMany, totalSrcAmount, chainId, rpcUrls, sender, spender, permitType, signer, service, permitEIP2612DisabledTokens, contractVersion, }: {
-        token: {
-            address: HexString;
-            amount: string;
-        };
-        isFirstToken: boolean;
-        oneToMany: boolean;
-        totalSrcAmount: bigint;
-        chainId: number;
-        rpcUrls?: string[];
-        sender: HexString;
-        spender: HexString;
-        permitType: PermitMode;
-        signer: WalletClient | Signer;
-        service: AvailableDZapServices;
-        permitEIP2612DisabledTokens?: string[];
-        contractVersion: ContractVersion;
-    }) => Promise<{
+    static generateBatchPermitDataForTokens: (params: BatchPermitParams) => Promise<BatchPermitResponse>;
+    static generatePermitDataForToken: (params: PermitDataParams) => Promise<PermitResponse>;
+    static signGaslessUserIntent: (signPermitReq: GaslessSignatureParams) => Promise<{
         status: TxnStatus;
         code: StatusCodes;
-        permitData: HexString;
-        permitType: PermitMode;
+        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 signPermit: ({ chainId, tokens, rpcUrls, sender, signer, service, signatureCallback, spender, permitType, permitEIP2612DisabledTokens, contractVersion, }: {
-        chainId: number;
-        sender: HexString;
-        tokens: {
-            address: HexString;
-            permitData?: HexString;
-            amount: string;
-        }[];
+    static v1PermitSupport: ({ contractVersion, service }: {
+        contractVersion: ContractVersion;
         service: AvailableDZapServices;
-        rpcUrls?: string[];
-        signer: WalletClient | Signer;
-        signatureCallback?: ({ permitData, srcToken, amount, permitType, }: {
-            permitData: HexString;
-            srcToken: HexString;
-            amount: string;
-            permitType: PermitMode;
-        }) => Promise<void>;
-        spender: HexString;
+    }) => boolean;
+    static shouldUseBatchPermit: ({ permitType, isBatchPermitAllowed, tokens, oneToMany, contractVersion, service, }: {
         permitType: PermitMode;
-        permitEIP2612DisabledTokens?: string[];
-        contractVersion: ContractVersion;
-    }) => Promise<{
-        status: TxnStatus;
+        isBatchPermitAllowed?: boolean;
         tokens: {
             address: HexString;
-            permitData?: HexString;
+            permitData?: HexString | undefined;
             amount: string;
         }[];
-        code: StatusCodes;
-    }>;
+        oneToMany: boolean;
+        contractVersion: ContractVersion;
+        service: AvailableDZapServices;
+    }) => boolean;
+    static signPermit: (signPermitReq: GasSignatureParams) => Promise<SignPermitResponse>;
 }
 export default PermitTxnHandler;

package/dist/transactionHandlers/trade.d.ts

@@ -1,9 +1,10 @@
 import { Signer } from 'ethers';
 import { WalletClient } from 'viem';
-import { DZapTransactionResponse, HexString, TradeBuildTxnRequest, TradeBuildTxnResponse } from '../types';
+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;
@@ -12,5 +13,12 @@ declare class TradeTxnHandler {
         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;

package/dist/types/eip-2612.d.ts

@@ -1,6 +1,24 @@
-export declare const EIP2612Types: {
+export declare const EIP2612DefaultTypes: {
     Permit: {
         name: string;
         type: string;
     }[];
 };
+export declare const DzapUserIntentSwapTypes: {
+    SignedGasLessSwapData: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const DzapUserIntentBridgeTypes: {
+    SignedGasLessBridgeData: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const DzapUserIntentSwapBridgeTypes: {
+    SignedGasLessSwapBridgeData: {
+        name: string;
+        type: string;
+    }[];
+};

package/dist/types/index.d.ts

@@ -1,8 +1,11 @@
-import { DZapAbis, OtherAbis, QuoteFilters, Services, STATUS_RESPONSE } from '../constants';
-import { ApprovalModes } from '../constants/approval';
-import { PermitTypes } from '../constants/permit';
-import { AppEnv, ContractVersion, StatusCodes, TxnStatus } from '../enums';
+import { Signer } from 'ethers';
+import { Prettify, TypedDataDomain, WalletClient } from 'viem';
+import { DZapAbis, GaslessTxType, OtherAbis, QuoteFilters, Services, STATUS, STATUS_RESPONSE } from './../constants';
+import { ApprovalModes } from './../constants/approval';
+import { PermitTypes } from './../constants/permit';
+import { AppEnv, ContractVersion, StatusCodes, TxnStatus } from './../enums';
 import { PsbtInput, PsbtOutput } from './btc';
+import { GaslessBridgeParams, GaslessSwapParams } from './permit';
 export type HexString = `0x${string}`;
 export type ChainData = {
     [key in number]: Chain;
@@ -14,6 +17,7 @@ export type NativeTokenInfo = {
     name: string;
     balance: string;
     price?: string;
+    logo: string;
 };
 export declare const contractErrorActions: {
     readonly TRY_ANOTHER_ROUTE: "TRY_ANOTHER_ROUTE";
@@ -86,7 +90,6 @@ export type Chain = {
     mainnet: boolean;
     tags?: Tag[];
     version?: ContractVersion;
-    permitDisabledTokens?: DisabledPermitTokens;
 };
 export type ApiRpcResponse = {
     url: string;
@@ -116,11 +119,18 @@ export type Fee = {
 export type QuoteFilter = keyof typeof QuoteFilters;
 export type TradeQuotesRequest = {
     fromChain: number;
+    gasless?: boolean;
     data: TradeQuotesRequestData[];
     disableEstimation?: boolean;
     account?: string;
     allowedProtocols?: string[];
     filter?: QuoteFilter;
+    timingStrategy?: Partial<{
+        minWaitTimeMs: number;
+        maxWaitTimeMs: number;
+        subsequentDelayMs: number;
+        preferredResultCount: number;
+    }>;
 };
 export type TradeQuotesRequestData = {
     amount: string;
@@ -169,6 +179,7 @@ export type TradeQuote = {
     fee: Fee;
     priceImpactPercent: string;
     duration: string;
+    gasless: boolean;
     steps: TradeStep[];
     path: TradePath[];
     tags?: Tag[];
@@ -200,7 +211,18 @@ export type Token = {
     symbol: string;
     price?: string;
 };
-export type TokenInfo = NativeTokenInfo & {
+export type TokenPermitData = {
+    eip2612: {
+        supported: boolean;
+        data?: {
+            domain?: TypedDataDomain;
+        };
+    };
+    permit2: {
+        supported: boolean;
+    };
+};
+export type TokenInfo = Prettify<NativeTokenInfo & {
     chainId: number;
     balanceInUsd?: number | null;
     isDisabledOnSwapBridge?: {
@@ -211,7 +233,8 @@ export type TokenInfo = NativeTokenInfo & {
         source: boolean;
         destination: boolean;
     };
-};
+    permit?: TokenPermitData;
+}>;
 export type TokenResponse = {
     [key: string]: TokenInfo;
 };
@@ -219,8 +242,10 @@ export type TradeBuildTxnRequest = {
     sender: HexString;
     refundee: HexString;
     fromChain: number;
+    gasless: boolean;
     disableEstimation?: boolean;
     data: TradeBuildTxnRequestData[];
+    hasPermit2ApprovalForAllTokens?: boolean;
     publicKey?: string;
 };
 export type TradeBuildTxnRequestData = {
@@ -235,28 +260,85 @@ export type TradeBuildTxnRequestData = {
     slippage: number;
     additionalInfo?: AdditionalInfo;
     permitData?: string;
+    permit?: TokenPermitData;
 };
-export type ExecuteTxnData = {
+export type ParamQuotes = {
+    additionalInfo?: Record<string, unknown>;
+    destAmount: string;
+    provider: string;
+    minDestAmount: string;
+};
+export type EvmTxData = {
+    from: HexString;
     data: HexString;
     to: HexString;
-    from: HexString;
-    chainId: number;
     value: string;
     gasLimit: string;
 };
-export type TradeBuildTxnResponse = ExecuteTxnData & {
-    additionalInfo?: AdditionalInfo;
+export type SvmTxData = {
+    from: string;
+    data: string;
+    blockhash?: string;
+    lastValidBlockHeight?: number;
+};
+export type BtcTxData = {
+    from: string;
+    data: string;
+    inputs: PsbtInput[];
+    outputs: PsbtOutput[];
+    feeRate: number;
+};
+export type TxData = EvmTxData | SvmTxData | BtcTxData;
+export type TxRequestData<T> = {
+    status: typeof STATUS.success;
+    txId: string;
+    chainId: number;
+    transaction: T;
+};
+export type TradeGasBuildTxnResponse<T = TxData> = TxRequestData<T> & {
+    quotes: Record<string, ParamQuotes>;
+    gasless: false;
+};
+export type TradeBuildTxnResponse = TradeGasBuildTxnResponse & {
+    data: string;
+    from: string;
+    to?: string;
+    value?: string;
+    gasLimit?: string;
+    svmTxData?: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    };
     btcTxData?: {
         inputs: PsbtInput[];
         outputs: PsbtOutput[];
         feeRate: number;
     };
-    svmTxData?: {
-        blockhash: string;
-        lastValidBlockHeight: number;
-    };
+    additionalInfo: Record<string, Record<string, unknown>>;
     updatedQuotes: Record<string, string>;
 };
+export type GaslessTxTypes = keyof typeof GaslessTxType;
+type BridgeGaslessTxData = {
+    executorFeesHash: HexString;
+    swapDataHash?: HexString;
+    adapterDataHash: HexString;
+    txType: typeof GaslessTxType.bridge;
+    value: string;
+};
+type SwapGaslessTxData = {
+    executorFeesHash: HexString;
+    swapDataHash: HexString;
+    txType: typeof GaslessTxType.swap;
+    value: string;
+};
+export type GaslessTradeBuildTxnResponse = {
+    status: 'success';
+    txId: HexString;
+    transaction: BridgeGaslessTxData | SwapGaslessTxData;
+    quotes: Record<string, ParamQuotes>;
+    gasless: true;
+    onlySwapData: false;
+};
 export type AvailableDZapServices = (typeof Services)[keyof typeof Services];
 export type DZapAvailableAbis = (typeof DZapAbis)[keyof typeof DZapAbis];
 export type OtherAvailableAbis = (typeof OtherAbis)[keyof typeof OtherAbis];
@@ -312,5 +394,89 @@ export type TradeStatusResponseData = PartialStatusData & RefundStatusData & {
 export type TradeStatusResponse = {
     [pair: string]: TradeStatusResponseData;
 };
+export type EIP2612GaslessExecuteTxParams = {
+    permitData: {
+        token: HexString;
+        amount: string;
+        permit: HexString;
+    }[];
+    gaslessIntentSignature: HexString;
+    gaslessIntentDeadline: string;
+    gaslessIntentNonce: string;
+};
+export type BatchGaslessExecuteTxParams = {
+    batchPermitData: HexString;
+};
+export type GaslessExecuteTxParams = {
+    chainId: number;
+    txId: HexString;
+    permit: EIP2612GaslessExecuteTxParams | BatchGaslessExecuteTxParams;
+};
 export type PermitMode = keyof typeof PermitTypes;
 export type ApprovalMode = Exclude<keyof typeof ApprovalModes, 'EIP2612Permit'>;
+export type SinglePermitCallbackParams = {
+    permitData: HexString;
+    srcToken: HexString;
+    amount: string;
+    permitType: Exclude<PermitMode, keyof typeof PermitTypes.PermitBatchWitnessTransferFrom>;
+};
+export type BatchPermitCallbackParams = {
+    batchPermitData: HexString;
+    tokens: {
+        address: HexString;
+        amount: string;
+    }[];
+    permitType: typeof PermitTypes.PermitBatchWitnessTransferFrom;
+};
+export type SignatureCallbackParams = SinglePermitCallbackParams | BatchPermitCallbackParams;
+export type SignatureParamsBase = {
+    chainId: number;
+    sender: HexString;
+    signer: WalletClient | Signer;
+    tokens: {
+        address: HexString;
+        permitData?: HexString;
+        amount: string;
+        permit?: TokenPermitData;
+    }[];
+    spender: HexString;
+    rpcUrls: string[];
+    permitType: PermitMode;
+    isBatchPermitAllowed?: boolean;
+    signatureCallback?: (params: SignatureCallbackParams) => Promise<void>;
+    service: AvailableDZapServices;
+    contractVersion: ContractVersion;
+};
+export type GasSignatureParams = SignatureParamsBase & {
+    gasless: false;
+};
+export type GaslessSignatureParams = ((SignatureParamsBase & GaslessBridgeParams) | (SignatureParamsBase & GaslessSwapParams)) & {
+    gasless: true;
+};
+export type SignatureParams = GasSignatureParams | GaslessSignatureParams;
+export type SignPermitResponse = {
+    status: TxnStatus.success;
+    code: StatusCodes;
+    tokens: {
+        address: HexString;
+        permitData?: HexString;
+        amount: string;
+    }[];
+    permitType: PermitMode;
+} | {
+    status: TxnStatus.success;
+    code: StatusCodes;
+    batchPermitData: HexString;
+    permitType: typeof PermitTypes.PermitBatchWitnessTransferFrom;
+} | {
+    status: Exclude<TxnStatus, typeof TxnStatus.success>;
+    code: StatusCodes;
+    permitType: PermitMode;
+};
+export type BroadcastTxData = string;
+export type BroadcastTxParams = {
+    txId: string;
+    chainId: number;
+    txData: BroadcastTxData;
+};
+export {};

package/dist/types/permit.d.ts

@@ -0,0 +1,191 @@
+import { Signer, TypedDataField } from 'ethers';
+import { HexString, PermitMode, StatusCodes, TxnStatus } from '..';
+import { GaslessTxType } from '../constants';
+import { permit2PrimaryType } from '../constants/permit';
+import { ContractVersion } from '../enums';
+import { Address, TypedDataDomain, WalletClient } from 'viem';
+import { AvailableDZapServices, TokenPermitData } from '.';
+export declare const defaultWitnessType: {
+    typeName: string;
+    type: {
+        DZapTransferWitness: {
+            name: string;
+            type: string;
+        }[];
+    };
+};
+export declare const swapGaslessWitnessType: {
+    typeName: string;
+    type: {
+        DZapSwapWitness: {
+            name: string;
+            type: string;
+        }[];
+    };
+};
+export declare const bridgeGaslessWitnessType: {
+    typeName: string;
+    type: {
+        DZapBridgeWitness: {
+            name: string;
+            type: string;
+        }[];
+    };
+};
+export declare const BatchPermitAbiParams: readonly [{
+    readonly name: "permit";
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "permitted";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "permitSignature";
+    readonly type: "bytes";
+}];
+type BaseToken = {
+    address: HexString;
+    amount: string;
+};
+export type TokenWithIndex = {
+    index: number;
+} & BaseToken;
+type TokenPermissions = {
+    token: Address;
+    amount: bigint;
+};
+export type TokenWithPermitData = {
+    index: number;
+    address: HexString;
+    amount: string;
+    permit?: TokenPermitData;
+};
+export type Permit2PrimaryType = (typeof permit2PrimaryType)[keyof typeof permit2PrimaryType];
+type GaslessBaseParams = {
+    gasless: true;
+    txId: HexString;
+    executorFeesHash: HexString;
+};
+export type GaslessSwapParams = {
+    txType: typeof GaslessTxType.swap;
+    swapDataHash: HexString;
+} & GaslessBaseParams;
+export type GaslessBridgeParams = {
+    txType: typeof GaslessTxType.bridge;
+    adapterDataHash: HexString;
+    swapDataHash?: HexString;
+} & GaslessBaseParams;
+export type BasePermitParams = {
+    chainId: number;
+    account: HexString;
+    spender: HexString;
+    rpcUrls?: string[];
+    deadline?: bigint;
+    signer: WalletClient | Signer;
+    contractVersion: ContractVersion;
+    service: AvailableDZapServices;
+};
+type Permit2612BaseParams = {
+    token: TokenWithPermitData;
+    version: string;
+    sigDeadline?: bigint;
+    name: string;
+    nonce: bigint;
+} & BasePermitParams;
+export type DefaultPermit2612Params = {
+    gasless: false;
+} & Permit2612BaseParams;
+type GaslessSwapPermit2612Params = BasePermitParams & GaslessSwapParams;
+type GaslessBridgePermit2612Params = BasePermitParams & GaslessBridgeParams;
+export type Gasless2612PermitParams = GaslessSwapPermit2612Params | GaslessBridgePermit2612Params;
+export type CustomTypedDataParams = {
+    account: HexString;
+    signer: WalletClient | Signer;
+    domain: TypedDataDomain;
+    types: Record<string, Array<TypedDataField>>;
+    message: Record<string, any>;
+    primaryType: string;
+};
+export type Permit2612Params = DefaultPermit2612Params | Gasless2612PermitParams;
+export type BasePermit2Params = {
+    tokens: TokenWithPermitData[];
+    expiration?: bigint;
+    permitType: Permit2PrimaryType;
+    firstTokenNonce?: bigint;
+} & BasePermitParams;
+type DefaultPermit2Params = {
+    gasless: false;
+} & BasePermit2Params;
+type GaslessSwapPermit2Params = BasePermit2Params & GaslessSwapParams;
+type GaslessBridgePermit2Params = BasePermit2Params & GaslessBridgeParams;
+export type Permit2Params = DefaultPermit2Params | GaslessSwapPermit2Params | GaslessBridgePermit2Params;
+export type PermitParams = Permit2612Params | Permit2Params;
+export type BasePermitResponse = {
+    status: TxnStatus;
+    code: StatusCodes;
+    permitData?: HexString;
+    nonce?: bigint;
+};
+export type PermitResponse = {
+    permitType: PermitMode;
+} & BasePermitResponse;
+export type BatchPermitResponse = {
+    permitType: typeof permit2PrimaryType.PermitBatchWitnessTransferFrom;
+} & BasePermitResponse;
+type BaseWitnessStructure<T, N extends string, TType> = {
+    witness: T;
+    witnessTypeName: N;
+    witnessType: TType;
+};
+type GaslessWitnessData = {
+    txId: HexString;
+    user: HexString;
+    executorFeesHash: HexString;
+    swapDataHash: HexString;
+};
+type BridgeWitnessData = {
+    adapterDataHash: HexString;
+} & GaslessWitnessData;
+export type DefaultWitnessData = BaseWitnessStructure<{
+    owner: HexString;
+    recipient: HexString;
+}, typeof defaultWitnessType.typeName, typeof defaultWitnessType.type>;
+export type SwapGaslessWitnessData = BaseWitnessStructure<GaslessWitnessData, typeof swapGaslessWitnessType.typeName, typeof swapGaslessWitnessType.type>;
+export type BridgeGaslessWitnessData = BaseWitnessStructure<BridgeWitnessData, typeof bridgeGaslessWitnessType.typeName, typeof bridgeGaslessWitnessType.type>;
+export type WitnessData = DefaultWitnessData | SwapGaslessWitnessData | BridgeGaslessWitnessData;
+export type PermitSingleValues = {
+    details: {
+        token: Address;
+        amount: bigint;
+        expiration: bigint;
+        nonce: number;
+    };
+    spender: Address;
+    sigDeadline: bigint;
+};
+export type PermitTransferFromValues = {
+    permitted: TokenPermissions;
+    spender: Address;
+    nonce: bigint;
+    deadline: bigint;
+};
+export type PermitBatchTransferFromValues = {
+    permitted: TokenPermissions[];
+    spender: Address;
+    nonce: bigint;
+    deadline: bigint;
+};
+export {};

package/dist/types/zap/build.d.ts

@@ -20,15 +20,15 @@ export type ZapBuildTxnResponse = {
     path: ZapPath[];
 };
 export type ZapBuildTxnRequest = {
-    srcToken: HexString;
+    srcToken: string;
     srcChainId: number;
-    destToken: HexString;
+    destToken: string;
     destChainId: number;
-    recipient: HexString;
-    refundee: HexString;
+    recipient: string;
+    refundee: string;
     slippage: number;
-    account: HexString;
-    permitData?: HexString;
+    account: string;
+    permitData?: string;
     amount?: string;
     estimateGas?: boolean;
     positionDetails?: ZapRouteRequestPositionDetails;

package/dist/types/zap/quote.d.ts

@@ -1,3 +1,7 @@
 import { ZapBuildTxnResponse, ZapBuildTxnRequest } from './build';
 export type ZapQuoteResponse = Omit<ZapBuildTxnResponse, 'steps'>;
-export type ZapQuoteRequest = ZapBuildTxnRequest;
+export type ZapQuoteRequest = Omit<ZapBuildTxnRequest, 'refundee' | 'recipient' | 'account'> & Partial<{
+    refundee: string;
+    recipient: string;
+    account: string;
+}>;

package/dist/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;
+}>;