@dzapio/sdk 2.0.15 → 2.0.16

package/dist/{dZapClient/index.d.ts → index.d.mts}

@@ -1,9 +1,868 @@
+import * as viem from 'viem';
+import { WalletCallReceipt as WalletCallReceipt$1, TypedDataDomain, Prettify, WalletClient, TransactionReceipt } from 'viem';
 import { Signer } from 'ethers';
-import { Prettify, TransactionReceipt, WalletClient } from 'viem';
-import { ContractVersion, StatusCodes, TxnStatus } from '../enums';
-import { ApprovalMode, AvailableDZapServices, BroadcastTxParams, BroadcastTxResponse, CalculatePointsRequest, ChainData, EvmTxData, GasSignatureParams, GaslessTradeBuildTxnResponse, HexString, OtherAvailableAbis, PermitMode, SignPermitResponse, TokenInfo, TokenResponse, TradeBuildTxnRequest, TradeBuildTxnResponse, TradeQuotesRequest, TradeQuotesResponse, TradeStatusResponse } from '../types';
-import { ZapBuildTxnRequest, ZapBuildTxnResponse, ZapChains, ZapPoolDetails, ZapPoolDetailsRequest, ZapPoolsRequest, ZapPoolsResponse, ZapPositionsRequest, ZapPositionsResponse, ZapProviders, ZapQuoteRequest, ZapQuoteResponse, ZapStatusRequest, ZapStatusResponse, ZapTransactionStep } from '../types/zap';
-import { BatchCallParams } from '../utils/eip-5792';
+
+declare const STATUS: {
+    pending: string;
+    inProgress: string;
+    success: string;
+    rejected: string;
+    error: string;
+};
+declare const OtherAbis: {
+    readonly permit2: "permit2";
+    readonly erc20: "erc20";
+};
+declare const Services: {
+    readonly trade: "trade";
+    readonly dca: "dca";
+    readonly zap: "zap";
+};
+declare const GaslessTxType: {
+    readonly swap: "swap";
+    readonly bridge: "bridge";
+};
+declare const QuoteFilters: {
+    readonly fastest: "fastest";
+    readonly best: "best";
+    readonly all: "all";
+};
+declare const STATUS_RESPONSE: {
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly PARTIAL: "PARTIAL";
+    readonly REFUNDED: "REFUNDED";
+};
+
+declare const ApprovalModes: {
+    readonly Default: "Default";
+    readonly PermitSingle: "PermitSingle";
+    readonly PermitWitnessTransferFrom: "PermitWitnessTransferFrom";
+    readonly PermitBatchWitnessTransferFrom: "PermitBatchWitnessTransferFrom";
+    readonly AutoPermit: "AutoPermit";
+};
+
+declare const erc20Functions: {
+    readonly name: "name";
+    readonly allowance: "allowance";
+    readonly approve: "approve";
+    readonly transfer: "transfer";
+    readonly transferFrom: "transferFrom";
+    readonly balanceOf: "balanceOf";
+    readonly decimals: "decimals";
+    readonly symbol: "symbol";
+    readonly version: "version";
+    readonly nonces: "nonces";
+    readonly domainSeparator: "DOMAIN_SEPARATOR";
+};
+
+declare enum DZapPermitMode {
+    PERMIT = 0,
+    PERMIT2_APPROVE = 1,
+    PERMIT2_WITNESS_TRANSFER = 2,
+    BATCH_PERMIT2_WITNESS_TRANSFER = 3
+}
+declare enum ContractVersion {
+    v1 = "v1",
+    v2 = "v2"
+}
+declare enum TxnStatus {
+    mining = "mining",
+    success = "success",
+    rejected = "rejected",
+    error = "error",
+    reverted = "reverted",
+    pendingWalletConfirmation = "pendingWalletConfirmation",
+    partialSuccess = "partialSuccess",
+    waitingForExecution = "waitingForExecution"
+}
+declare enum StatusCodes {
+    UserRejectedRequest = 4001,
+    Success = 200,
+    FunctionNotFound = 32771,
+    Error = 500,
+    WalletRPCFailure = 429,
+    SimulationFailure = 417,
+    ContractExecutionError = -500
+}
+
+declare const PermitTypes: {
+    readonly PermitSingle: "PermitSingle";
+    readonly PermitWitnessTransferFrom: "PermitWitnessTransferFrom";
+    readonly PermitBatchWitnessTransferFrom: "PermitBatchWitnessTransferFrom";
+    readonly EIP2612Permit: "EIP2612Permit";
+    readonly AutoPermit: "AutoPermit";
+};
+
+declare const SignatureExpiryInSecs = 1800;
+
+type WalletCallReceipt = WalletCallReceipt$1<bigint, 'success' | 'reverted'>;
+
+type Witness = {
+    value: number;
+    script: string;
+};
+type PsbtInputP2PKH = {
+    scriptType: 'p2pkh';
+    nonWitnessUtxo: Buffer;
+    redeemScript?: never;
+};
+type PsbtInputP2SH = {
+    scriptType: 'p2sh';
+    witnessUtxo: Witness;
+    redeemScript: Buffer;
+    redeemScriptArgumentByteLengths?: number[];
+};
+type PsbtInputP2WPKH = {
+    scriptType: 'p2wpkh';
+    witnessUtxo: Witness;
+    redeemScript?: never;
+};
+type PsbtInputP2WSH = {
+    scriptType: 'p2wsh';
+    witnessUtxo: Witness;
+    witnessScript: Buffer;
+};
+type PsbtInputP2TR = {
+    scriptType: 'p2tr';
+    witnessUtxo: Witness;
+    tapInternalKey: Buffer;
+};
+type PsbtInput = {
+    hash: string;
+    index: number;
+    sequence: number;
+    value: number;
+} & (PsbtInputP2PKH | PsbtInputP2SH | PsbtInputP2WPKH | PsbtInputP2TR | PsbtInputP2WSH);
+type PsbtOutput = {
+    address: string;
+    script?: Buffer;
+    value: number;
+} | {
+    script: string;
+    value: number;
+};
+
+type HexString = `0x${string}`;
+type StatusResponse = keyof typeof STATUS_RESPONSE;
+type ChainData = {
+    [key in number]: Chain;
+};
+type NativeTokenInfo = {
+    contract: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    balance: string;
+    price?: string;
+    logo: string;
+};
+declare const contractErrorActions: {
+    readonly TRY_ANOTHER_ROUTE: "TRY_ANOTHER_ROUTE";
+    readonly INCREASE_SLIPPAGE: "INCREASE_SLIPPAGE";
+    readonly INCREASE_ALLOWANCE: "INCREASE_ALLOWANCE";
+};
+type ContractErrorResponse = {
+    status: string;
+    txId: string;
+    code: number;
+    message: string;
+    error: unknown;
+    action: keyof typeof contractErrorActions;
+    details?: unknown;
+};
+type CalculatePointsRequest = {
+    srcTokens: {
+        amount: string;
+        address: string;
+        decimals: number;
+    }[];
+    destTokens: {
+        amount: string;
+        address: string;
+        decimals: number;
+    }[];
+    providers: string[];
+    chainId: number;
+    account: string;
+    txType: 'swap' | 'bridge';
+};
+type Chain = {
+    coinKey: string;
+    chainId: number;
+    chainType: string;
+    name: string;
+    coin: string;
+    dcaContract: string;
+    swapBridgeContract: string;
+    logo: string;
+    tokenlistUrl?: string;
+    multicallAddress?: HexString;
+    blockExplorerUrl: string;
+    nativeToken: NativeTokenInfo;
+    rpcProviders: ApiRpcResponse[];
+    pricingAvailable: boolean;
+    balanceAvailable: boolean;
+    supportedAs: {
+        source: boolean;
+        destination: boolean;
+    };
+    contracts?: Partial<{
+        router: string;
+        dca: string;
+        zap: string;
+    }>;
+    coingecko?: {
+        chainKey: string;
+        nativeTokenKey: string;
+    };
+    defiLlama?: {
+        chainKey: string;
+        nativeTokenKey: string;
+    };
+    disableMultiTxn: boolean;
+    isEnabled: boolean;
+    mainnet: boolean;
+    tags?: Tag[];
+    version?: ContractVersion;
+};
+type ApiRpcResponse = {
+    url: string;
+    keyRequired: boolean;
+    keyType?: 'ALCHEMY_KEY' | 'BLASTAPI_KEY';
+};
+type ProviderDetails = {
+    id: string;
+    name: string;
+    icon: string;
+};
+type FeeDetails = {
+    address: string;
+    decimals: number;
+    chainId: number;
+    symbol: string;
+    logo?: string;
+    amount: string;
+    amountUSD: string;
+    included: boolean;
+};
+type Fee = {
+    gasFee: FeeDetails[];
+    protocolFee: FeeDetails[];
+    providerFee: FeeDetails[];
+};
+type QuoteFilter = keyof typeof QuoteFilters;
+type ProtocolFilter = {
+    allow?: string[];
+    deny?: string[];
+};
+type TradeQuotesRequest = {
+    fromChain: number;
+    gasless?: boolean;
+    data: TradeQuotesRequestData[];
+    disableEstimation?: boolean;
+    account?: string;
+    bridges?: ProtocolFilter;
+    dexes?: ProtocolFilter;
+    filter?: QuoteFilter;
+    timingStrategy?: Partial<{
+        minWaitTimeMs: number;
+        maxWaitTimeMs: number;
+        subsequentDelayMs: number;
+        preferredResultCount: number;
+        relaxMinSuccessOnDelay: boolean;
+    }>;
+};
+type TradeQuotesRequestData = {
+    amount: string;
+    srcToken: string;
+    srcDecimals?: number;
+    destToken: string;
+    destDecimals?: number;
+    toChain: number;
+    slippage: number;
+    selectedSource?: string;
+};
+type TradeStep = {
+    type: string;
+    exchange: {
+        logo: string;
+        name: string;
+    };
+};
+type TradePath = {
+    type: string;
+    exchange: ProviderDetails;
+    srcToken: Token;
+    srcAmount: string;
+    srcAmountUSD: string;
+    destToken: Token;
+    destAmount: string;
+    destAmountUSD: string;
+    fee: Fee;
+};
+type Tag = {
+    title: string;
+    link?: string;
+    message?: string;
+};
+type TradeQuote = {
+    bridgeDetails?: ProviderDetails;
+    providerDetails: ProviderDetails;
+    srcAmount: string;
+    srcAmountUSD: string;
+    destAmount: string;
+    destAmountUSD: string;
+    minDestAmount: string;
+    swapPerUnit: string;
+    srcToken: Token;
+    destToken: Token;
+    fee: Fee;
+    priceImpactPercent: string;
+    duration: string;
+    gasless: boolean;
+    steps: TradeStep[];
+    path: TradePath[];
+    tags?: Tag[];
+    additionalInfo?: AdditionalInfo;
+};
+type TradeQuotesByProviderId = {
+    [providerAndBridge: string]: TradeQuote;
+};
+type TradeQuotesResponse = {
+    [pair: string]: {
+        status?: string;
+        message?: string;
+        recommendedSource: string;
+        fastestSource?: string;
+        bestReturnSource: string;
+        questSource?: string;
+        quoteRates?: TradeQuotesByProviderId;
+        tokensWithoutPrice: Record<number, string[]>;
+    };
+};
+type AdditionalInfo = {
+    [key: string]: unknown;
+};
+type Token = {
+    address: HexString;
+    decimals: number;
+    chainId: number;
+    logo: string;
+    symbol: string;
+    price?: string;
+};
+type TokenPermitData = {
+    eip2612: {
+        supported: boolean;
+        data?: {
+            domain?: TypedDataDomain;
+        };
+    };
+    permit2: {
+        supported: boolean;
+    };
+};
+type TokenInfo = Prettify<NativeTokenInfo & {
+    chainId: number;
+    balanceInUsd?: number | null;
+    isDisabledOnSwapBridge?: {
+        source: boolean;
+        destination: boolean;
+    };
+    isDisabledOnZap?: {
+        source: boolean;
+        destination: boolean;
+    };
+    permit?: TokenPermitData;
+}>;
+type TokenResponse = {
+    [key: string]: TokenInfo;
+};
+type TradeBuildTxnRequest = {
+    sender: HexString;
+    refundee: HexString;
+    fromChain: number;
+    gasless: boolean;
+    disableEstimation?: boolean;
+    data: TradeBuildTxnRequestData[];
+    hasPermit2ApprovalForAllTokens?: boolean;
+    publicKey?: string;
+};
+type TradeBuildTxnRequestData = {
+    amount: string;
+    srcToken: string;
+    srcDecimals?: number;
+    destToken: string;
+    destDecimals?: number;
+    toChain: number;
+    protocol: string;
+    recipient: string;
+    slippage: number;
+    additionalInfo?: AdditionalInfo;
+    permitData?: string;
+    permit?: TokenPermitData;
+};
+type ParamQuotes = {
+    additionalInfo?: Record<string, unknown>;
+    destAmount: string;
+    provider: string;
+    minDestAmount: string;
+};
+type EvmTxData = {
+    from: HexString;
+    data: HexString;
+    to: HexString;
+    value: string;
+    gasLimit: string;
+};
+type SvmTxData = {
+    from: string;
+    data: string;
+    blockhash?: string;
+    lastValidBlockHeight?: number;
+};
+type BtcTxData = {
+    from: string;
+    data: string;
+    inputs: PsbtInput[];
+    outputs: PsbtOutput[];
+    feeRate: number;
+};
+type TxData = EvmTxData | SvmTxData | BtcTxData;
+type TxRequestData<T> = {
+    status: typeof STATUS.success;
+    txId: string;
+    chainId: number;
+    transaction: T;
+};
+type TradeGasBuildTxnResponse<T = TxData> = TxRequestData<T> & {
+    quotes: Record<string, ParamQuotes>;
+    gasless: false;
+};
+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;
+    };
+    additionalInfo: Record<string, Record<string, unknown>>;
+    updatedQuotes: Record<string, string>;
+};
+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;
+};
+type GaslessTradeBuildTxnResponse = {
+    status: 'success';
+    txId: HexString;
+    transaction: BridgeGaslessTxData | SwapGaslessTxData;
+    quotes: Record<string, ParamQuotes>;
+    gasless: true;
+    onlySwapData: false;
+};
+type AvailableDZapServices = (typeof Services)[keyof typeof Services];
+type OtherAvailableAbis = (typeof OtherAbis)[keyof typeof OtherAbis];
+type DZapTransactionResponse = {
+    status: TxnStatus;
+    errorMsg?: string;
+    code: StatusCodes | number;
+    action?: keyof typeof contractErrorActions;
+    txnHash?: HexString;
+    error?: unknown;
+    additionalInfo?: Record<string, unknown>;
+    updatedQuotes?: Record<string, string>;
+};
+type SwapInfo = {
+    dex: string;
+    fromToken: string;
+    fromAmount: bigint;
+    toToken: string;
+    returnToAmount: bigint;
+};
+type StatusAsset = {
+    contract: string;
+    chainId: number;
+    name?: string;
+    symbol?: string;
+    decimals?: number;
+    logo?: string | undefined;
+};
+type TransactionInfo = {
+    asset: StatusAsset;
+    amount: string;
+    amountUSD: number;
+    txHash: string;
+    account: string;
+};
+type TxStatusForPair = {
+    source: TransactionInfo;
+    destination: TransactionInfo & {
+        timestamp?: number;
+    };
+    expected?: Omit<TransactionInfo, 'txHash' | 'status'>;
+    status: StatusResponse;
+    provider: ProviderDetails;
+    allowUserTxOnDestChain: boolean;
+    message?: string;
+    protocolExplorerLink?: string;
+};
+type TradeStatusResponse = {
+    status: StatusResponse;
+    gasless: boolean;
+    txHash: string;
+    chainId: number;
+    timestamp: number;
+    transactions: TxStatusForPair[];
+};
+type PermitMode = keyof typeof PermitTypes;
+type ApprovalMode = Exclude<keyof typeof ApprovalModes, 'EIP2612Permit'>;
+type SinglePermitCallbackParams = {
+    permitData: HexString;
+    srcToken: HexString;
+    amount: string;
+    permitType: Exclude<PermitMode, keyof typeof PermitTypes.PermitBatchWitnessTransferFrom>;
+};
+type BatchPermitCallbackParams = {
+    batchPermitData: HexString;
+    tokens: {
+        address: HexString;
+        amount: string;
+    }[];
+    permitType: typeof PermitTypes.PermitBatchWitnessTransferFrom;
+};
+type SignatureCallbackParams = SinglePermitCallbackParams | BatchPermitCallbackParams;
+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;
+};
+type GasSignatureParams = SignatureParamsBase & {
+    gasless: false;
+};
+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;
+};
+type BroadcastTxData = string;
+type BroadcastTxParams = {
+    txId: string;
+    chainId: number;
+    txData: BroadcastTxData;
+};
+type BroadcastTxResponse = {
+    status: TxnStatus.success;
+    txnHash: string;
+} | {
+    status: Exclude<TxnStatus, typeof TxnStatus.success>;
+    message: string;
+};
+
+declare const zapPathAction: {
+    readonly swap: "swap";
+    readonly bridge: "bridge";
+    readonly deposit: "deposit";
+    readonly withdraw: "withdraw";
+    readonly stake: "stake";
+    readonly unstake: "unstake";
+};
+
+type ZapPathAction = keyof typeof zapPathAction;
+type ZapPathAsset = {
+    chainId: number;
+    address: HexString;
+    symbol: string;
+    logo: string;
+    decimals: number;
+    price: string;
+    type: string;
+    name: string;
+    provider?: ProviderDetails;
+    underlyingTokens?: ZapUnderlyingToken[];
+};
+type ZapPath = {
+    action: ZapPathAction;
+    protocol: ProviderDetails;
+    fee: ZapFee[];
+    estimatedDuration: number;
+    input: {
+        asset: ZapPathAsset;
+        amount: string;
+        amountUSD: string;
+    }[];
+    output: {
+        asset: ZapPathAsset;
+        amount: string;
+        amountUSD: string;
+        dust?: boolean;
+    }[];
+};
+
+declare const chainTypes: {
+    readonly evm: "evm";
+    readonly bvm: "bvm";
+    readonly svm: "svm";
+    readonly aptosvm: "aptosvm";
+    readonly cosmos: "cosmos";
+    readonly nearvm: "nearvm";
+    readonly starknetvm: "starknetvm";
+    readonly stellarvm: "stellarvm";
+    readonly suivm: "suivm";
+    readonly tonvm: "tonvm";
+    readonly tronvm: "tronvm";
+};
+
+declare const zapStepAction: {
+    readonly execute: "execute";
+};
+
+type StepAction = keyof typeof zapStepAction;
+type ZapEvmTxnDetails = {
+    type: typeof chainTypes.evm;
+    txnId: HexString;
+    callData: HexString;
+    callTo: HexString;
+    value: string;
+    estimatedGas: string;
+};
+type ZapBvmTxnDetails = {
+    type: typeof chainTypes.bvm;
+    txnId: HexString;
+    data: string;
+};
+type SVMTxnDetails = {
+    type: typeof chainTypes.svm;
+    txnId: HexString;
+    data: string[];
+    estimatedGas: string;
+    isJitoTx?: boolean;
+};
+type ZapTxnDetails = ZapEvmTxnDetails | ZapBvmTxnDetails | SVMTxnDetails;
+type ZapTransactionStep<T extends ZapTxnDetails = ZapTxnDetails> = {
+    action: StepAction;
+    data: T;
+};
+type ZapStep = ZapTransactionStep;
+
+type ZapRouteRequestPositionDetails = {
+    nftId: string;
+};
+type ZapRouteRequestPoolDetails = {
+    lowerTick: number;
+    upperTick: number;
+    metadata?: unknown;
+};
+type ZapIntegratorConfig = {
+    id: string;
+    feeBps: number;
+    wallet: string;
+};
+type ZapBuildTxnResponse = {
+    amountOut: string;
+    approvalData: {
+        callTo: HexString;
+        approveTo: HexString;
+        amount: string;
+    } | null;
+    steps: ZapStep[];
+    path: ZapPath[];
+};
+type ZapBuildTxnRequest = {
+    srcToken: string;
+    srcChainId: number;
+    destToken: string;
+    destChainId: number;
+    recipient: string;
+    refundee: string;
+    slippage: number;
+    account: string;
+    integrator?: ZapIntegratorConfig;
+    permitData?: string;
+    amount?: string;
+    estimateGas?: boolean;
+    positionDetails?: ZapRouteRequestPositionDetails;
+    poolDetails?: ZapRouteRequestPoolDetails;
+    allowedBridges?: string[];
+    allowedDexes?: string[];
+};
+
+type ZapPoolDetailsRequest = {
+    address: HexString;
+    chainId: number;
+    provider: string;
+};
+type ZapPoolsRequest = {
+    chainId: number;
+    provider: string;
+    limit?: number;
+    offset?: number;
+};
+type ZapPoolsResponse = {
+    pools: ZapPool[];
+    pages: number;
+    limit: number;
+    offset: number;
+};
+type ZapPool = {
+    address: string;
+    chainId: number;
+    name: string;
+    provider: string;
+    underlyingAssets: ZapUnderlyingToken[];
+    tvl: string;
+    apr: number;
+    metadata?: unknown;
+    symbol: string;
+    decimals: number;
+};
+type ZapPoolDetails = {
+    address: string;
+    slot0: {
+        sqrtPriceX96: string;
+        tick: number;
+        tickSpacing: number;
+    };
+};
+
+type ZapPositionsRequest = {
+    account: HexString;
+    chainId: number;
+    provider: string;
+};
+type ZapPosition = {
+    underlyingAssets: ZapUnderlyingTokenWithAmount[];
+    address: string;
+    apr: number;
+    name: string;
+    chainId: number;
+    provider: string;
+    amount: string;
+    amountUSD: string;
+    nftDetails?: {
+        id: string;
+        manager: HexString;
+    };
+    metadata?: unknown;
+    decimals: number;
+};
+type ZapPositionsResponse = {
+    positions: ZapPosition[];
+    count: number;
+};
+
+type ZapQuoteResponse = Omit<ZapBuildTxnResponse, 'steps'>;
+type ZapQuoteRequest = Omit<ZapBuildTxnRequest, 'refundee' | 'recipient' | 'account'> & Partial<{
+    refundee: string;
+    recipient: string;
+    account: string;
+}>;
+
+type ZapStatus = 'PENDING' | 'COMPLETED' | 'FAILED' | 'REFUNDED';
+type ZapStatusAsset = {
+    asset: ZapPathAsset;
+    amount: string;
+    amountUSD: string;
+};
+type ZapStatusStep = {
+    chainId: number;
+    hash?: string;
+    status: ZapStatus;
+    action: string;
+    protocol: ProviderDetails;
+    input: ZapStatusAsset[];
+    output: ZapStatusAsset[];
+};
+type ZapStatusResponse = {
+    status: ZapStatus;
+    steps: ZapStatusStep[];
+    recipient: string;
+    timestamp: number;
+    completedAt: number;
+};
+type ZapStatusRequest = {
+    chainId: number;
+    txnHash: string;
+};
+
+type ZapProviders = Record<string, ProviderDetails>;
+type ZapChains = {
+    [key: string]: {
+        name: string;
+        supportedProviders: string[];
+    };
+};
+type ZapFee = {
+    amount: string;
+    amountUSD: string;
+    asset: ZapPathAsset;
+    included: boolean;
+};
+type ZapUnderlyingToken = {
+    chainId: number;
+    address: HexString;
+    name?: string;
+    symbol: string;
+    decimals: number;
+    logo?: string | null;
+};
+type ZapUnderlyingTokenWithAmount = ZapUnderlyingToken & {
+    amount: string;
+    amountUSD: string;
+};
+
+type BatchCallParams = {
+    to: HexString;
+    data: HexString;
+    value?: bigint;
+};
+
 declare class DZapClient {
     private static instance;
     private cancelTokenSource;
@@ -12,7 +871,7 @@ declare class DZapClient {
     private constructor();
     static getInstance(apiKey?: string, rpcUrlsByChainId?: Record<number, string[]>): DZapClient;
     static getChainConfig(): Promise<ChainData>;
-    static getDZapAbi(service: AvailableDZapServices, version: ContractVersion): import("viem").Abi;
+    static getDZapAbi(service: AvailableDZapServices, version: ContractVersion): viem.Abi;
     static getOtherAbi: (name: OtherAvailableAbis) => readonly [{
         readonly inputs: readonly [{
             readonly internalType: "uint256";
@@ -898,13 +1757,13 @@ declare class DZapClient {
         txnData?: TradeBuildTxnResponse;
         batchTransaction?: boolean;
         rpcUrls?: string[];
-    }): Promise<import("../types").DZapTransactionResponse>;
+    }): Promise<DZapTransactionResponse>;
     tradeGasless({ request, signer, txnData, txnStatusCallback, }: {
         request: TradeBuildTxnRequest;
         signer: Signer | WalletClient;
         txnData?: GaslessTradeBuildTxnResponse;
         txnStatusCallback?: (status: TxnStatus) => void;
-    }): Promise<import("../types").DZapTransactionResponse>;
+    }): Promise<DZapTransactionResponse>;
     sendTransaction({ chainId, signer, txnData }: {
         chainId: number;
         signer: Signer | WalletClient;
@@ -922,14 +1781,14 @@ declare class DZapClient {
     waitForBatchTransactionReceipt({ walletClient, batchHash }: {
         walletClient: WalletClient;
         batchHash: HexString;
-    }): Promise<import("../types/wallet").WalletCallReceipt>;
+    }): Promise<WalletCallReceipt>;
     decodeTxnData({ data, service, chainId }: {
         data: TransactionReceipt;
         service: AvailableDZapServices;
         chainId: number;
     }): Promise<{
         swapFailPairs: string[];
-        swapInfo: import("../types").SwapInfo | import("../types").SwapInfo[];
+        swapInfo: SwapInfo | SwapInfo[];
     }>;
     calculatePoints(request: CalculatePointsRequest): Promise<{
         points: number;
@@ -993,7 +1852,7 @@ declare class DZapClient {
         request: ZapBuildTxnRequest;
         signer: WalletClient | Signer;
         steps?: ZapTransactionStep[];
-    }): Promise<import("../types").DZapTransactionResponse | {
+    }): Promise<DZapTransactionResponse | {
         status: TxnStatus.success;
         code: StatusCodes | number;
         txnHash: HexString;
@@ -1016,4 +1875,45 @@ declare class DZapClient {
     broadcastTradeTx(request: BroadcastTxParams): Promise<BroadcastTxResponse>;
     broadcastZapTx(request: BroadcastTxParams): Promise<BroadcastTxResponse>;
 }
-export default DZapClient;
+
+declare function getTokensPairKey({ srcToken, destToken, srcChainId, destChainId, srcChainNativeAddress, destChainNativeAddress, }: {
+    srcToken: string;
+    destToken: string;
+    srcChainId: number;
+    destChainId: number;
+    srcChainNativeAddress?: string;
+    destChainNativeAddress?: string;
+}): string;
+
+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;
+}
+
+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;
+    };
+}>;
+
+declare const formatToken: <T extends HexString | string = string>(token: T, nativeTokenAddress?: T) => T;
+
+export { type ApiRpcResponse, type ApprovalMode, ApprovalModes, type BatchPermitCallbackParams, type BtcTxData, type Chain, type ChainData, type ContractErrorResponse, DZapClient, DZapPermitMode, type DZapTransactionResponse, type EvmTxData, type Fee, type FeeDetails, type GaslessTradeBuildTxnResponse, type HexString, OtherAbis, type ParamQuotes, type PermitMode, PermitTypes, type ProviderDetails, type PsbtInput, type PsbtOutput, type QuoteFilter, QuoteFilters, STATUS, type SVMTxnDetails, Services, type SignPermitResponse, type SignatureCallbackParams, SignatureExpiryInSecs, type SinglePermitCallbackParams, StatusCodes, type StepAction, type SvmTxData, type SwapInfo, SwapInputDataDecoder, type Token, type TokenInfo, type TokenPermitData, type TokenResponse, type TradeBuildTxnRequest, type TradeBuildTxnRequestData, type TradeBuildTxnResponse, type TradeGasBuildTxnResponse, type TradePath, type TradeQuotesRequest, type TradeQuotesRequestData, type TradeQuotesResponse, type TradeStatusResponse, type TradeStep, TxnStatus, type ZapBuildTxnRequest, type ZapBuildTxnResponse, type ZapBvmTxnDetails, type ZapChains, type ZapEvmTxnDetails, type ZapFee, type ZapIntegratorConfig, type ZapPath, type ZapPathAction, type ZapPathAsset, type ZapPool, type ZapPoolDetails, type ZapPoolDetailsRequest, type ZapPoolsRequest, type ZapPoolsResponse, type ZapPosition, type ZapPositionsRequest, type ZapPositionsResponse, type ZapProviders, type ZapQuoteRequest, type ZapQuoteResponse, type ZapRouteRequestPoolDetails, type ZapRouteRequestPositionDetails, type ZapStatus, type ZapStatusAsset, type ZapStatusRequest, type ZapStatusResponse, type ZapStatusStep, type ZapStep, type ZapTransactionStep, type ZapTxnDetails, type ZapUnderlyingToken, type ZapUnderlyingTokenWithAmount, checkEIP2612PermitSupport, contractErrorActions, erc20Functions, formatToken, getTokensPairKey, zapPathAction, zapStepAction };