@zkp2p/sdk 0.0.1

package/dist/Zkp2pClient-CODjD_Kf.d.mts

@@ -0,0 +1,1962 @@
+import { AccessList, AuthorizationList, WalletClient, Hash, Address, PublicClient } from 'viem';
+import { Abi } from 'abitype';
+
+/**
+ * Supported fiat currency codes.
+ *
+ * Use these constants when specifying currencies in conversion rates:
+ *
+ * @example
+ * ```typescript
+ * import { Currency } from '@zkp2p/client-sdk';
+ *
+ * const rates = [
+ *   { currency: Currency.USD, conversionRate: '1020000000000000000' },
+ *   { currency: Currency.EUR, conversionRate: '1100000000000000000' },
+ * ];
+ * ```
+ */
+declare const Currency: {
+    readonly AED: "AED";
+    readonly ARS: "ARS";
+    readonly AUD: "AUD";
+    readonly CAD: "CAD";
+    readonly CHF: "CHF";
+    readonly CNY: "CNY";
+    readonly CZK: "CZK";
+    readonly DKK: "DKK";
+    readonly EUR: "EUR";
+    readonly GBP: "GBP";
+    readonly HKD: "HKD";
+    readonly HUF: "HUF";
+    readonly IDR: "IDR";
+    readonly ILS: "ILS";
+    readonly INR: "INR";
+    readonly JPY: "JPY";
+    readonly KES: "KES";
+    readonly MXN: "MXN";
+    readonly MYR: "MYR";
+    readonly NOK: "NOK";
+    readonly NZD: "NZD";
+    readonly PHP: "PHP";
+    readonly PLN: "PLN";
+    readonly RON: "RON";
+    readonly SAR: "SAR";
+    readonly SEK: "SEK";
+    readonly SGD: "SGD";
+    readonly THB: "THB";
+    readonly TRY: "TRY";
+    readonly UGX: "UGX";
+    readonly USD: "USD";
+    readonly VND: "VND";
+    readonly ZAR: "ZAR";
+};
+/**
+ * Union type of all supported currency codes.
+ */
+type CurrencyType = (typeof Currency)[keyof typeof Currency];
+/**
+ * Complete currency information including name, symbol, and hash.
+ */
+type CurrencyData = {
+    currency: CurrencyType;
+    currencyCode: string;
+    currencyName: string;
+    currencySymbol: string;
+    currencyCodeHash: string;
+    countryCode: string;
+};
+/**
+ * Lookup table containing metadata for all supported currencies.
+ *
+ * Includes currency name, symbol, keccak256 hash (for on-chain use),
+ * and ISO country code for flag display.
+ *
+ * @example
+ * ```typescript
+ * import { currencyInfo, Currency } from '@zkp2p/client-sdk';
+ *
+ * const usd = currencyInfo[Currency.USD];
+ * console.log(usd.currencyName);   // "United States Dollar"
+ * console.log(usd.currencySymbol); // "$"
+ * console.log(usd.currencyCodeHash); // "0x..."
+ * ```
+ */
+declare const currencyInfo: Record<CurrencyType, CurrencyData>;
+/**
+ * UI-friendly currency rate structure used in SDK methods.
+ */
+type UICurrencyRate = {
+    currency: CurrencyType;
+    conversionRate: string;
+};
+/**
+ * On-chain currency structure with minimum conversion rate (V3 escrow format).
+ */
+type OnchainCurrencyMinRate = {
+    code: `0x${string}`;
+    minConversionRate: bigint;
+};
+/**
+ * Maps UI currency rates to on-chain V3 escrow format with minConversionRate.
+ *
+ * @param groups - Nested array of currency rates per payment method
+ * @param expectedGroups - Expected number of groups (for validation)
+ * @returns On-chain formatted currency arrays for V3 escrow
+ * @throws Error if groups structure is invalid or lengths don't match
+ */
+declare function mapConversionRatesToOnchainMinRate(groups: UICurrencyRate[][], expectedGroups?: number): OnchainCurrencyMinRate[][];
+/**
+ * Looks up currency info by its keccak256 hash.
+ *
+ * @param hash - The currency code hash (0x-prefixed)
+ * @returns Currency data if found, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const info = getCurrencyInfoFromHash('0x...');
+ * if (info) {
+ *   console.log(info.currencyCode); // "USD"
+ * }
+ * ```
+ */
+declare function getCurrencyInfoFromHash(hash: string): CurrencyData | undefined;
+/**
+ * Looks up currency info by ISO country code.
+ *
+ * @param code - The ISO country code (e.g., 'US', 'GB')
+ * @returns Currency data if found, undefined otherwise
+ */
+declare function getCurrencyInfoFromCountryCode(code: string): CurrencyData | undefined;
+/**
+ * Converts a currency hash to its ISO currency code.
+ *
+ * @param hash - The currency code hash (0x-prefixed)
+ * @returns Currency code string (e.g., 'USD') or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const code = getCurrencyCodeFromHash('0x...');
+ * console.log(code); // "USD"
+ * ```
+ */
+declare function getCurrencyCodeFromHash(hash: string): string | undefined;
+/**
+ * Checks if a currency hash is recognized by the SDK.
+ *
+ * @param hash - The currency code hash to check
+ * @returns true if the hash corresponds to a supported currency
+ */
+declare function isSupportedCurrencyHash(hash: string): boolean;
+
+/**
+ * Contract resolution utilities for the SDK.
+ *
+ * Provides access to deployed contract addresses and ABIs for different
+ * networks (Base, Base Sepolia) and environments (production, staging).
+ *
+ * @module contracts
+ */
+
+/**
+ * Contract addresses for a specific deployment.
+ */
+type V2ContractAddresses = {
+    /** Escrow contract (holds deposits and manages intents) */
+    escrow: `0x${string}`;
+    /** Orchestrator contract (handles intent signaling and fulfillment) */
+    orchestrator?: `0x${string}`;
+    /** UnifiedPaymentVerifier contract (verifies payment proofs) */
+    unifiedPaymentVerifier?: `0x${string}`;
+    /** ProtocolViewer contract (batch read operations) */
+    protocolViewer?: `0x${string}`;
+    /** USDC token address */
+    usdc?: `0x${string}`;
+};
+/**
+ * Contract ABIs for a specific deployment.
+ */
+type V2ContractAbis = {
+    escrow: Abi;
+    orchestrator?: Abi;
+    unifiedPaymentVerifier?: Abi;
+    protocolViewer?: Abi;
+};
+/**
+ * Runtime environment: 'production' for mainnet, 'staging' for testnet/dev.
+ */
+type RuntimeEnv = 'production' | 'staging';
+/**
+ * Retrieves deployed contract addresses and ABIs for a given chain and environment.
+ *
+ * @param chainId - The chain ID (8453 for Base, 84532 for Base Sepolia)
+ * @param env - Runtime environment ('production' or 'staging')
+ * @returns Object containing addresses and ABIs
+ *
+ * @example
+ * ```typescript
+ * import { getContracts } from '@zkp2p/client-sdk';
+ *
+ * const { addresses, abis } = getContracts(8453, 'production');
+ * console.log(addresses.escrow);  // "0x..."
+ * console.log(addresses.usdc);    // "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"
+ * ```
+ */
+declare function getContracts(chainId: number, env?: RuntimeEnv): {
+    addresses: V2ContractAddresses;
+    abis: V2ContractAbis;
+};
+/**
+ * Catalog of payment methods with their hashes and supported currencies.
+ */
+type PaymentMethodCatalog = Record<string, {
+    paymentMethodHash: `0x${string}`;
+    currencies?: `0x${string}`[];
+}>;
+/**
+ * Retrieves the payment methods catalog for a given chain and environment.
+ *
+ * The catalog maps payment platform names (e.g., 'wise', 'revolut') to their
+ * on-chain hashes and supported currency hashes.
+ *
+ * @param chainId - The chain ID
+ * @param env - Runtime environment
+ * @returns Payment method catalog keyed by platform name
+ *
+ * @example
+ * ```typescript
+ * import { getPaymentMethodsCatalog } from '@zkp2p/client-sdk';
+ *
+ * const catalog = getPaymentMethodsCatalog(8453, 'production');
+ * console.log(Object.keys(catalog)); // ['wise', 'venmo', 'revolut', ...]
+ * console.log(catalog.wise.paymentMethodHash); // "0x..."
+ * console.log(catalog.wise.currencies); // ["0x...", "0x..."] (currency hashes)
+ * ```
+ */
+declare function getPaymentMethodsCatalog(chainId: number, env?: RuntimeEnv): PaymentMethodCatalog;
+/**
+ * Returns the gating service address for a given chain and environment.
+ *
+ * The gating service signs intent parameters before they can be submitted
+ * on-chain, providing an additional validation layer.
+ *
+ * @param chainId - The chain ID
+ * @param env - Runtime environment
+ * @returns Gating service signer address
+ */
+declare function getGatingServiceAddress(chainId: number, env?: RuntimeEnv): `0x${string}`;
+
+type PV_Deposit = {
+    depositor: string;
+    delegate: string;
+    token: string;
+    amount: bigint;
+    intentAmountRange: {
+        min: bigint;
+        max: bigint;
+    };
+    acceptingIntents: boolean;
+    remainingDeposits: bigint;
+    outstandingIntentAmount: bigint;
+    makerProtocolFee: bigint;
+    reservedMakerFees: bigint;
+    accruedMakerFees: bigint;
+    accruedReferrerFees: bigint;
+    intentGuardian: string;
+    referrer: string;
+    referrerFee: bigint;
+};
+type PV_Currency = {
+    code: string;
+    minConversionRate: bigint;
+};
+type PV_PaymentMethodData = {
+    paymentMethod: string;
+    verificationData: {
+        intentGatingService: string;
+        payeeDetails: string;
+        data: string;
+    };
+    currencies: PV_Currency[];
+};
+type PV_DepositView = {
+    depositId: bigint;
+    deposit: PV_Deposit;
+    availableLiquidity: bigint;
+    paymentMethods: PV_PaymentMethodData[];
+    intentHashes: string[];
+};
+type PV_Intent = {
+    owner: string;
+    to: string;
+    escrow: string;
+    depositId: bigint;
+    amount: bigint;
+    timestamp: bigint;
+    paymentMethod: string;
+    fiatCurrency: string;
+    conversionRate: bigint;
+    referrer: string;
+    referrerFee: bigint;
+    postIntentHook: string;
+    data: string;
+};
+type PV_IntentView = {
+    intentHash: string;
+    intent: PV_Intent;
+    deposit: Omit<PV_DepositView, 'intentHashes'>;
+};
+declare function parseDepositView(raw: any): PV_DepositView;
+declare function parseIntentView(raw: any): PV_IntentView;
+
+declare function enrichPvDepositView(view: PV_DepositView, chainId: number, env?: RuntimeEnv): {
+    paymentMethods: {
+        processorName: string | undefined;
+        currencies: {
+            currencyInfo: CurrencyData | undefined;
+            code: string;
+            minConversionRate: bigint;
+        }[];
+        paymentMethod: string;
+        verificationData: {
+            intentGatingService: string;
+            payeeDetails: string;
+            data: string;
+        };
+    }[];
+    depositId: bigint;
+    deposit: PV_Deposit;
+    availableLiquidity: bigint;
+    intentHashes: string[];
+};
+declare function enrichPvIntentView(view: PV_IntentView, chainId: number, env?: RuntimeEnv): any;
+
+/**
+ * Minimal fetch-based GraphQL client for the ZKP2P indexer.
+ * No external GraphQL dependencies; works in Node and browser.
+ */
+type GraphQLRequest = {
+    query: string;
+    variables?: Record<string, unknown>;
+};
+declare class IndexerClient {
+    private endpoint;
+    constructor(endpoint: string);
+    private _post;
+    query<T = any>(request: GraphQLRequest, init?: RequestInit & {
+        retries?: number;
+    }): Promise<T>;
+}
+type DeploymentEnv = 'PRODUCTION' | 'PREPRODUCTION' | 'STAGING' | 'DEV' | 'LOCAL' | 'STAGING_TESTNET';
+declare function defaultIndexerEndpoint(env?: DeploymentEnv): string;
+
+/**
+ * Indexer entity types (GraphQL schema-aligned)
+ */
+type DepositStatus$1 = 'ACTIVE' | 'CLOSED';
+interface DepositEntity {
+    id: string;
+    chainId: number;
+    escrowAddress: string;
+    depositId: string;
+    depositor: string;
+    token: string;
+    remainingDeposits: string;
+    intentAmountMin: string;
+    intentAmountMax: string;
+    acceptingIntents: boolean;
+    status: DepositStatus$1;
+    outstandingIntentAmount: string;
+    totalAmountTaken: string;
+    totalWithdrawn: string;
+    successRateBps?: number;
+    totalIntents: number;
+    signaledIntents: number;
+    fulfilledIntents: number;
+    prunedIntents: number;
+    blockNumber: string;
+    timestamp: string;
+    txHash: string;
+    updatedAt: string;
+}
+interface DepositPaymentMethodEntity {
+    id: string;
+    chainId: number;
+    depositIdOnContract: string;
+    depositId: string;
+    paymentMethodHash: string;
+    verifierAddress: string;
+    intentGatingService: string;
+    payeeDetailsHash: string;
+    active: boolean;
+}
+interface MethodCurrencyEntity {
+    id: string;
+    chainId: number;
+    depositIdOnContract: string;
+    depositId: string;
+    paymentMethodHash: string;
+    currencyCode: string;
+    minConversionRate: string;
+}
+type IntentStatus = 'SIGNALED' | 'FULFILLED' | 'PRUNED' | 'MANUALLY_RELEASED';
+interface IntentEntity {
+    id: string;
+    intentHash: string;
+    depositId: string;
+    orchestratorAddress: string;
+    verifier: string;
+    owner: string;
+    toAddress: string;
+    amount: string;
+    fiatCurrency: string;
+    conversionRate: string;
+    status: IntentStatus;
+    isExpired: boolean;
+    signalTimestamp: string;
+    expiryTime?: string;
+    fulfillTimestamp?: string | null;
+    pruneTimestamp?: string | null;
+    updatedAt?: string | null;
+    signalTxHash: string;
+    fulfillTxHash?: string | null;
+    pruneTxHash?: string | null;
+    paymentMethodHash?: string | null;
+    paymentAmount?: string | null;
+    paymentCurrency?: string | null;
+    paymentTimestamp?: string | null;
+    paymentId?: string | null;
+    releasedAmount?: string | null;
+    takerAmountNetFees?: string | null;
+}
+interface DepositWithRelations extends DepositEntity {
+    paymentMethods?: DepositPaymentMethodEntity[];
+    currencies?: MethodCurrencyEntity[];
+    intents?: IntentEntity[];
+}
+interface IntentFulfilledEntity {
+    intentHash: string;
+    isManualRelease: boolean;
+    fundsTransferredTo?: string | null;
+}
+
+type DepositOrderField = 'remainingDeposits' | 'outstandingIntentAmount' | 'totalAmountTaken' | 'totalWithdrawn' | 'updatedAt' | 'timestamp';
+type OrderDirection = 'asc' | 'desc';
+type DepositFilter = Partial<{
+    status: 'ACTIVE' | 'CLOSED';
+    depositor: string;
+    chainId: number;
+    escrowAddress: string;
+    escrowAddresses: string[];
+    minLiquidity: string;
+    acceptingIntents: boolean;
+}>;
+type PaginationOptions = Partial<{
+    limit: number;
+    offset: number;
+    orderBy: DepositOrderField;
+    orderDirection: OrderDirection;
+}>;
+declare class IndexerDepositService {
+    private client;
+    constructor(client: IndexerClient);
+    private buildDepositWhere;
+    private buildOrderBy;
+    private fetchRelations;
+    private fetchIntents;
+    private attachRelations;
+    fetchDeposits(filter?: DepositFilter, pagination?: PaginationOptions): Promise<DepositEntity[]>;
+    fetchDepositsWithRelations(filter?: DepositFilter, pagination?: PaginationOptions, options?: {
+        includeIntents?: boolean;
+        intentStatuses?: IntentStatus[];
+    }): Promise<DepositWithRelations[]>;
+    fetchDepositsByIds(ids: string[]): Promise<DepositEntity[]>;
+    fetchDepositsByIdsWithRelations(ids: string[], options?: {
+        includeIntents?: boolean;
+        intentStatuses?: IntentStatus[];
+    }): Promise<DepositWithRelations[]>;
+    fetchIntentsForDeposits(depositIds: string[], statuses?: IntentStatus[]): Promise<IntentEntity[]>;
+    fetchIntentsByOwner(owner: string, statuses?: IntentStatus[]): Promise<IntentEntity[]>;
+    fetchDepositWithRelations(id: string, options?: {
+        includeIntents?: boolean;
+        intentStatuses?: IntentStatus[];
+    }): Promise<DepositWithRelations | null>;
+    fetchExpiredIntents(params: {
+        now: bigint | string;
+        depositIds: string[];
+        limit?: number;
+    }): Promise<IntentEntity[]>;
+    fetchFulfilledIntentEvents(intentHashes: string[]): Promise<IntentFulfilledEntity[]>;
+    resolvePayeeHash(params: {
+        escrowAddress?: string | null;
+        depositId?: string | number | bigint | null;
+        paymentMethodHash?: string | null;
+    }): Promise<string | null>;
+    fetchDepositsByPayeeHash(payeeHash: string, options?: {
+        paymentMethodHash?: string;
+        limit?: number;
+        includeIntents?: boolean;
+        intentStatuses?: IntentStatus[];
+    }): Promise<DepositWithRelations[]>;
+}
+
+type FulfillmentRecord = {
+    id: string;
+    intentHash: string;
+    amount: string;
+    isManualRelease: boolean;
+    fundsTransferredTo: string | null;
+};
+type PaymentVerifiedRecord = {
+    id: string;
+    intentHash: string;
+    method: string;
+    currency: string;
+    amount: string;
+    timestamp: string;
+    paymentId: string | null;
+    payeeId: string | null;
+};
+type FulfillmentAndPaymentResponse = {
+    Orchestrator_V21_IntentFulfilled: FulfillmentRecord[];
+    UnifiedVerifier_V21_PaymentVerified: PaymentVerifiedRecord[];
+};
+declare function fetchFulfillmentAndPayment(client: IndexerClient, intentHash: string): Promise<FulfillmentAndPaymentResponse>;
+
+/**
+ * Timeout configuration for different operation types
+ */
+type TimeoutConfig = {
+    /** API call timeout in milliseconds (default: 30000) */
+    api?: number;
+    /** Transaction timeout in milliseconds (default: 60000) */
+    transaction?: number;
+};
+type Zkp2pClientOptions = {
+    walletClient: WalletClient;
+    apiKey: string;
+    chainId: number;
+    environment?: 'production' | 'staging';
+    baseApiUrl?: string;
+    witnessUrl?: string;
+    rpcUrl?: string;
+    /** Optional bearer token for hybrid auth */
+    authorizationToken?: string;
+    /** Optional timeout configuration */
+    timeouts?: TimeoutConfig;
+};
+/**
+ * Callback function for transaction actions
+ * @param params - Transaction callback parameters
+ * @param params.hash - Transaction hash
+ * @param params.data - Optional additional data from the transaction
+ */
+type ActionCallback = (params: {
+    hash: Hash;
+    data?: unknown;
+}) => void;
+/**
+ * Safe transaction overrides including ERC-8021 referrers.
+ * Referrer codes are prepended before the Base builder code (bc_nbn6qkni).
+ */
+type TxOverrides = {
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+    accessList?: AccessList;
+    authorizationList?: AuthorizationList;
+    /**
+     * ERC-8021 referrer code(s) to prepend before the Base builder code.
+     * Accepts a single code or multiple (e.g., ['zkp2p-bot', 'merchant-id']).
+     */
+    referrer?: string | string[];
+};
+/**
+ * Parameters for fulfilling an intent with payment attestation
+ */
+type FulfillIntentParams = {
+    /** Hash of the intent to fulfill */
+    intentHash: Hash;
+    /** Attestation proof - object or stringified JSON from attestation service */
+    proof: Record<string, unknown> | string;
+    /** Optional attestation timestamp buffer override in milliseconds */
+    timestampBufferMs?: number | string;
+    /** Override the attestation service base URL */
+    attestationServiceUrl?: string;
+    /** Override the verifying contract (defaults to UnifiedPaymentVerifier) */
+    verifyingContract?: Address;
+    /** Optional hook payload passed to orchestrator */
+    postIntentHookData?: `0x${string}`;
+    /** Optional viem transaction overrides */
+    txOverrides?: TxOverrides;
+    /** Optional lifecycle callbacks */
+    callbacks?: {
+        onAttestationStart?: () => void;
+        onTxSent?: (hash: Hash) => void;
+        onTxMined?: (hash: Hash) => void;
+    };
+};
+/**
+ * Parameters for releasing funds back to the payer
+ */
+type ReleaseFundsToPayerParams = {
+    /** Hash of the intent to release funds for */
+    intentHash: Hash;
+    /** Callback when transaction is successfully sent */
+    onSuccess?: ActionCallback;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback when transaction is mined */
+    onMined?: ActionCallback;
+};
+/**
+ * Parameters for signaling an intent to use a deposit
+ */
+type SignalIntentParams = {
+    /** Payment processor name (e.g., 'wise', 'revolut') */
+    processorName: string;
+    /** ID of the deposit to use */
+    depositId: string;
+    /** Amount of tokens to transfer */
+    tokenAmount: string;
+    /** Payee details for the payment */
+    payeeDetails: string;
+    /** Recipient blockchain address */
+    toAddress: string;
+    /** Currency type for the payment */
+    currency: CurrencyType;
+    /** Callback when transaction is successfully sent */
+    onSuccess?: ActionCallback;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback when transaction is mined */
+    onMined?: ActionCallback;
+};
+/**
+ * Request structure for posting deposit details
+ */
+type PostDepositDetailsRequest = {
+    /** Deposit data key-value pairs */
+    depositData: {
+        [key: string]: string;
+    };
+    /** Payment processor name */
+    processorName: string;
+};
+/**
+ * Response from posting deposit details
+ */
+type PostDepositDetailsResponse = {
+    /** Whether the request was successful */
+    success: boolean;
+    message: string;
+    responseObject: {
+        id: number;
+        processorName: string;
+        depositData: {
+            [key: string]: string;
+        };
+        hashedOnchainId: string;
+        createdAt: string;
+    };
+    statusCode: number;
+};
+/**
+ * Alias types for clarity when registering payee details (makers/create)
+ */
+type RegisterPayeeDetailsRequest = PostDepositDetailsRequest;
+type RegisterPayeeDetailsResponse = PostDepositDetailsResponse;
+type QuoteRequest = {
+    paymentPlatforms: string[];
+    fiatCurrency: string;
+    user: string;
+    recipient: string;
+    destinationChainId: number;
+    destinationToken: string;
+    referrer?: string;
+    useMultihop?: boolean;
+    quotesToReturn?: number;
+    amount: string;
+    isExactFiat?: boolean;
+    /** Optional filter: limit quotes to these escrow contracts */
+    escrowAddresses?: string[];
+    /** Enable nearby quote discovery when exact match unavailable */
+    includeNearbyQuotes?: boolean;
+    /** Max % deviation to search for nearby quotes (e.g., 10 = ±10%) */
+    nearbySearchRange?: number;
+    /** Max suggestions per direction (1-10, default: 3) */
+    nearbyQuotesCount?: number;
+};
+type FiatResponse = {
+    currencyCode: string;
+    currencyName: string;
+    currencySymbol: string;
+    countryCode: string;
+};
+type TokenResponse = {
+    token: string;
+    decimals: number;
+    name: string;
+    symbol: string;
+    chainId: number;
+};
+/**
+ * Intent details within a quote response
+ */
+type QuoteIntentResponse = {
+    /** Deposit ID */
+    depositId: string;
+    /** Payment processor name */
+    processorName: string;
+    /** Amount to transfer */
+    amount: string;
+    /** Recipient address */
+    toAddress: string;
+    /** Payee details */
+    payeeDetails: string;
+    /** Processor-specific intent data */
+    processorIntentData: Record<string, unknown>;
+    /** Fiat currency code */
+    fiatCurrencyCode: string;
+    /** Chain ID */
+    chainId: string;
+};
+type QuoteSingleResponse = {
+    fiatAmount: string;
+    fiatAmountFormatted: string;
+    tokenAmount: string;
+    tokenAmountFormatted: string;
+    paymentMethod: string;
+    payeeAddress: string;
+    conversionRate: string;
+    intent: QuoteIntentResponse;
+    payeeData?: Record<string, string>;
+};
+type QuoteFeesResponse = {
+    zkp2pFee: string;
+    zkp2pFeeFormatted: string;
+    swapFee: string;
+    swapFeeFormatted: string;
+};
+/**
+ * A nearby quote suggestion returned when no exact match is available.
+ * Fields vary based on whether request was exact-token or exact-fiat mode.
+ */
+type NearbyQuote = {
+    /** For exact-token mode: suggested token amount */
+    suggestedTokenAmount?: string;
+    /** For exact-token mode: formatted suggested token amount */
+    suggestedTokenAmountFormatted?: string;
+    /** For exact-token mode: percentage difference from requested (e.g., "-5.0%" or "+10.0%") */
+    tokenPercentDifference?: string;
+    /** For exact-fiat mode: suggested fiat amount */
+    suggestedFiatAmount?: string;
+    /** For exact-fiat mode: formatted suggested fiat amount */
+    suggestedFiatAmountFormatted?: string;
+    /** For exact-fiat mode: percentage difference from requested */
+    fiatPercentDifference?: string;
+    /** The full quote at this suggested amount */
+    quote: QuoteSingleResponse;
+};
+/**
+ * Nearby quote suggestions when no exact match is available.
+ * Only present in response when includeNearbyQuotes=true and no exact quotes found.
+ */
+type NearbySuggestions = {
+    /** Quotes at amounts below the requested amount (sorted by closest first) */
+    below: NearbyQuote[];
+    /** Quotes at amounts above the requested amount (sorted by closest first) */
+    above: NearbyQuote[];
+};
+type QuoteResponseObject = {
+    fiat: FiatResponse;
+    token: TokenResponse;
+    quotes: QuoteSingleResponse[];
+    fees: QuoteFeesResponse;
+    /** Nearby suggestions when no exact quotes available (only present with includeNearbyQuotes=true) */
+    nearbySuggestions?: NearbySuggestions;
+};
+type QuoteResponse = {
+    message: string;
+    success: boolean;
+    responseObject: QuoteResponseObject;
+    statusCode: number;
+};
+/**
+ * Request to fetch payee details
+ * Prefer `processorName`; `platform` kept for backward compatibility.
+ */
+type GetPayeeDetailsRequest = {
+    hashedOnchainId: string;
+    processorName: string;
+};
+type GetPayeeDetailsResponse = {
+    success: boolean;
+    message: string;
+    responseObject: {
+        id: number;
+        processorName: string;
+        depositData: {
+            [key: string]: string;
+        };
+        hashedOnchainId: string;
+        createdAt: string;
+    };
+    statusCode: number;
+};
+type ValidatePayeeDetailsRequest = {
+    processorName: string;
+    depositData: {
+        [key: string]: string;
+    };
+};
+type ValidatePayeeDetailsResponse = {
+    success: boolean;
+    message: string;
+    responseObject: {
+        isValid: boolean;
+        errors?: string[];
+    };
+    statusCode: number;
+};
+type OnchainCurrency = {
+    code: `0x${string}`;
+    conversionRate: bigint;
+};
+type DepositVerifierData = {
+    intentGatingService: `0x${string}`;
+    payeeDetails: string;
+    data: `0x${string}`;
+};
+type Range = {
+    min: bigint;
+    max: bigint;
+};
+type CreateDepositConversionRate = {
+    currency: CurrencyType;
+    conversionRate: string;
+};
+type CreateDepositParams = {
+    token: Address;
+    amount: bigint;
+    intentAmountRange: Range;
+    conversionRates: CreateDepositConversionRate[][];
+    processorNames: string[];
+    depositData: {
+        [key: string]: string;
+    }[];
+    onSuccess?: ActionCallback;
+    onError?: (error: Error) => void;
+    onMined?: ActionCallback;
+};
+type WithdrawDepositParams = {
+    depositId: string | number | bigint;
+    onSuccess?: ActionCallback;
+    onError?: (error: Error) => void;
+    onMined?: ActionCallback;
+};
+type CancelIntentParams = {
+    intentHash: Hash;
+    onSuccess?: ActionCallback;
+    onError?: (error: Error) => void;
+    onMined?: ActionCallback;
+};
+type DepositStatus = 'ACTIVE' | 'WITHDRAWN' | 'CLOSED';
+type ApiIntentStatus = 'SIGNALED' | 'FULFILLED' | 'PRUNED' | 'MANUALLY_RELEASED';
+type Intent = {
+    id: number;
+    intentHash: string;
+    depositId: string;
+    verifier: string;
+    owner: string;
+    toAddress: string;
+    amount: string;
+    fiatCurrency: string;
+    conversionRate: string;
+    sustainabilityFee: string | null;
+    verifierFee: string | null;
+    status: ApiIntentStatus;
+    signalTxHash: string;
+    signalTimestamp: Date;
+    fulfillTxHash: string | null;
+    fulfillTimestamp: Date | null;
+    pruneTxHash: string | null;
+    prunedTimestamp: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
+type GetOwnerIntentsRequest = {
+    ownerAddress: string;
+    status?: ApiIntentStatus | ApiIntentStatus[];
+};
+type GetOwnerIntentsResponse = {
+    success: boolean;
+    message: string;
+    responseObject: Intent[];
+    statusCode: number;
+};
+type GetIntentsByDepositRequest = {
+    depositId: string;
+    status?: ApiIntentStatus | ApiIntentStatus[];
+};
+type GetIntentsByDepositResponse = {
+    success: boolean;
+    message: string;
+    responseObject: Intent[];
+    statusCode: number;
+};
+type GetIntentByHashRequest = {
+    intentHash: string;
+};
+type GetIntentByHashResponse = {
+    success: boolean;
+    message: string;
+    responseObject: Intent;
+    statusCode: number;
+};
+type DepositVerifierCurrency = {
+    id?: number;
+    depositVerifierId?: number;
+    currencyCode: string;
+    conversionRate: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+};
+type DepositVerifier = {
+    id?: number;
+    depositId: number;
+    verifier: string;
+    intentGatingService: string;
+    payeeDetailsHash: string;
+    data: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    currencies: DepositVerifierCurrency[];
+};
+type ApiDeposit = {
+    id: number;
+    depositor: string;
+    token: string;
+    amount: string;
+    remainingDeposits: string;
+    intentAmountMin: string;
+    intentAmountMax: string;
+    acceptingIntents: boolean;
+    outstandingIntentAmount: string;
+    availableLiquidity: string;
+    status: 'ACTIVE' | 'WITHDRAWN' | 'CLOSED';
+    totalIntents: number;
+    signaledIntents: number;
+    fulfilledIntents: number;
+    prunedIntents: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    verifiers: DepositVerifier[];
+};
+type GetOwnerDepositsRequest = {
+    ownerAddress: string;
+    /** Optional status filter: 'ACTIVE' | 'WITHDRAWN' | 'CLOSED' */
+    status?: DepositStatus;
+};
+type GetOwnerDepositsResponse = {
+    success: boolean;
+    message: string;
+    responseObject: ApiDeposit[];
+    statusCode: number;
+};
+type GetDepositByIdRequest = {
+    depositId: string;
+};
+type GetDepositByIdResponse = {
+    success: boolean;
+    message: string;
+    responseObject: ApiDeposit;
+    statusCode: number;
+};
+type OrderStats = {
+    id: number;
+    totalIntents: number;
+    signaledIntents: number;
+    fulfilledIntents: number;
+    prunedIntents: number;
+};
+type DepositIntentStatistics = OrderStats;
+type TakerTierStats = {
+    lifetimeSignaledCount: number;
+    lifetimeFulfilledCount: number;
+    lifetimeManualReleaseCount: number;
+    lifetimePruneCount: number;
+    totalCancelledVolume: string;
+    totalFulfilledVolume: string;
+    lockScore: string;
+    lockScoreDiluted: string;
+    firstSeenAt: string;
+    lastIntentAt: string;
+    updatedAt: string;
+};
+type TakerTierLevel = 'PEASANT' | 'PEER' | 'PLUS' | 'PRO' | 'PLATINUM' | 'PEER_PRESIDENT';
+type PlatformRiskLevel = 'LOW' | 'MEDIUM_HIGH' | 'HIGH' | 'HIGHEST';
+type PlatformLimit = {
+    paymentMethodHash: string;
+    platformName: string;
+    riskLevel: PlatformRiskLevel;
+    capMultiplier: number;
+    effectiveCap: string;
+    effectiveCapDisplay: string;
+    hasCooldown: boolean;
+    cooldownHours: number;
+    isLocked: boolean;
+    minTierRequired: TakerTierLevel | null;
+};
+type TakerTier = {
+    owner: string;
+    chainId: number;
+    tier: TakerTierLevel;
+    perIntentCapBaseUnits: string;
+    perIntentCapDisplay: string;
+    lastUpdated: string;
+    source: 'computed' | 'fallback';
+    stats: TakerTierStats | null;
+    cooldownHours: number;
+    cooldownSeconds: number;
+    cooldownActive: boolean;
+    cooldownRemainingSeconds: number;
+    nextIntentAvailableAt: string | null;
+    platformLimits?: PlatformLimit[];
+};
+type GetTakerTierRequest = {
+    owner: string;
+    chainId: number;
+};
+type GetTakerTierResponse = {
+    success: boolean;
+    message: string;
+    responseObject: TakerTier;
+    statusCode?: number;
+};
+
+declare const PAYMENT_PLATFORMS: readonly ["wise", "venmo", "revolut", "cashapp", "mercadopago", "zelle", "paypal", "monzo"];
+type PaymentPlatformType = typeof PAYMENT_PLATFORMS[number];
+
+/**
+ * Configuration options for creating a Zkp2pClient instance.
+ *
+ * @example
+ * ```typescript
+ * const options: Zkp2pNextOptions = {
+ *   walletClient,
+ *   chainId: 8453, // Base mainnet
+ *   runtimeEnv: 'production',
+ *   apiKey: 'your-api-key',
+ * };
+ * ```
+ */
+type Zkp2pNextOptions = {
+    /** viem WalletClient instance with an account for signing transactions */
+    walletClient: WalletClient;
+    /** Chain ID (8453 for Base mainnet, 84532 for Base Sepolia) */
+    chainId: number;
+    /** Optional RPC URL override (defaults to wallet's chain RPC, then https://mainnet.base.org for Base or https://sepolia.base.org for Base Sepolia) */
+    rpcUrl?: string;
+    /** Runtime environment: 'production' or 'staging' (defaults to 'production') */
+    runtimeEnv?: RuntimeEnv;
+    /** Optional indexer URL override */
+    indexerUrl?: string;
+    /** Base API URL for ZKP2P services (defaults to https://api.zkp2p.xyz) */
+    baseApiUrl?: string;
+    /** API key for authenticated endpoints (required for createDeposit, signalIntent) */
+    apiKey?: string;
+    /** Optional bearer token for hybrid authentication */
+    authorizationToken?: string;
+    /** Timeout configuration */
+    timeouts?: {
+        /** API call timeout in milliseconds (default: 15000) */
+        api?: number;
+    };
+};
+/**
+ * SDK client for ZKP2P liquidity providers (offramp peers).
+ *
+ * This SDK is designed for **liquidity providers** who want to:
+ * - Create and manage USDC deposits that accept fiat payments
+ * - Configure payment methods, currencies, and conversion rates
+ * - Monitor deposit utilization and manage liquidity
+ *
+ * ## Core Functionality (Deposit Management)
+ *
+ * The primary use case is managing deposits as a liquidity provider:
+ *
+ * | Method | Description |
+ * |--------|-------------|
+ * | `createDeposit()` | Create a new USDC deposit |
+ * | `addFunds()` / `removeFunds()` | Adjust deposit balance |
+ * | `withdrawDeposit()` | Fully withdraw a deposit |
+ * | `setAcceptingIntents()` | Enable/disable new intents |
+ * | `setIntentRange()` | Set min/max intent amounts |
+ * | `setCurrencyMinRate()` | Update conversion rates |
+ * | `addPaymentMethods()` | Add payment platforms |
+ * | `getDeposits()` | Query your deposits |
+ *
+ * ## Supporting Functionality
+ *
+ * These methods support the broader ZKP2P ecosystem but are not the
+ * primary focus of this SDK:
+ *
+ * - **Intent Operations**: `signalIntent()`, `fulfillIntent()`, `cancelIntent()`
+ *   (typically used by takers/buyers, not liquidity providers)
+ * - **Quote API**: `getQuote()` (used by frontends to find available liquidity)
+ *
+ * @example Creating a Deposit (Primary Use Case)
+ * ```typescript
+ * import { createWalletClient, http } from 'viem';
+ * import { base } from 'viem/chains';
+ * import { privateKeyToAccount } from 'viem/accounts';
+ * import { Zkp2pClient } from '@zkp2p/client-sdk';
+ *
+ * const walletClient = createWalletClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: base,
+ *   transport: http(),
+ * });
+ *
+ * const client = new OfframpClient({
+ *   walletClient,
+ *   chainId: base.id,
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Create a 1000 USDC deposit accepting Wise payments
+ * const { hash } = await client.createDeposit({
+ *   token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // USDC
+ *   amount: 1000_000000n,
+ *   intentAmountRange: { min: 10_000000n, max: 500_000000n },
+ *   processorNames: ['wise'],
+ *   depositData: [{ email: 'you@example.com' }],
+ *   conversionRates: [[
+ *     { currency: 'USD', conversionRate: '1020000000000000000' },
+ *     { currency: 'EUR', conversionRate: '1100000000000000000' },
+ *   ]],
+ * });
+ *
+ * // Monitor your deposits
+ * const deposits = await client.getDeposits({ owner: walletClient.account.address });
+ * ```
+ */
+declare class Zkp2pClient {
+    /** The viem WalletClient used for signing transactions */
+    readonly walletClient: WalletClient;
+    /** The viem PublicClient used for reading contract state */
+    readonly publicClient: PublicClient;
+    /** The chain ID this client is configured for */
+    readonly chainId: number;
+    /** Runtime environment ('production' or 'staging') */
+    readonly runtimeEnv: RuntimeEnv;
+    /** Escrow contract address */
+    readonly escrowAddress: Address;
+    /** Escrow contract ABI */
+    readonly escrowAbi: Abi;
+    /** Orchestrator contract address (handles intent signaling/fulfillment) */
+    readonly orchestratorAddress?: Address;
+    /** Orchestrator contract ABI */
+    readonly orchestratorAbi?: Abi;
+    /** UnifiedPaymentVerifier contract address */
+    readonly unifiedPaymentVerifier?: Address;
+    /** ProtocolViewer contract address (for batch reads) */
+    readonly protocolViewerAddress?: Address;
+    /** ProtocolViewer contract ABI */
+    readonly protocolViewerAbi?: Abi;
+    /** Base API URL for ZKP2P services */
+    readonly baseApiUrl?: string;
+    /** API key for authenticated endpoints */
+    readonly apiKey?: string;
+    /** Bearer token for hybrid authentication */
+    readonly authorizationToken?: string;
+    /** API timeout in milliseconds */
+    readonly apiTimeoutMs: number;
+    private _usdcAddress?;
+    private readonly _indexerClient;
+    private readonly _indexerService;
+    /**
+     * Creates a new Zkp2pClient instance.
+     *
+     * @param opts - Configuration options
+     * @throws Error if walletClient is missing an account
+     */
+    constructor(opts: Zkp2pNextOptions);
+    private isValidHexAddress;
+    /**
+     * Simulate a contract call (validation only) and send with ERC-8021 attribution.
+     * Referrer codes are stripped from overrides for simulation and appended to calldata.
+     */
+    private simulateAndSendWithAttribution;
+    /**
+     * Fetches all deposits owned by the connected wallet from on-chain.
+     *
+     * This is the primary method for liquidity providers to query their deposits.
+     * Uses ProtocolViewer for instant on-chain reads (no indexer lag).
+     *
+     * @returns Array of deposit views with payment methods and currencies
+     *
+     * @example
+     * ```typescript
+     * const deposits = await client.getDeposits();
+     * for (const d of deposits) {
+     *   console.log(`Deposit ${d.depositId}: ${d.availableLiquidity} available`);
+     * }
+     * ```
+     */
+    getDeposits(): Promise<PV_DepositView[]>;
+    /**
+     * Fetches all deposits owned by a specific address from on-chain.
+     *
+     * Uses ProtocolViewer for instant on-chain reads.
+     *
+     * @param owner - The owner's Ethereum address
+     * @returns Array of deposit views with payment methods and currencies
+     *
+     * @example
+     * ```typescript
+     * const deposits = await client.getAccountDeposits('0x...');
+     * ```
+     */
+    getAccountDeposits(owner: Address): Promise<PV_DepositView[]>;
+    /**
+     * Fetches a single deposit by its numeric ID from on-chain.
+     *
+     * Uses ProtocolViewer for instant on-chain reads.
+     *
+     * @param depositId - The deposit ID (numeric)
+     * @returns Deposit view with payment methods, currencies, and intent hashes
+     *
+     * @example
+     * ```typescript
+     * const deposit = await client.getDeposit(42n);
+     * console.log(`Available: ${deposit.availableLiquidity}`);
+     * console.log(`Payment methods: ${deposit.paymentMethods.length}`);
+     * ```
+     */
+    getDeposit(depositId: bigint | number | string): Promise<PV_DepositView>;
+    /**
+     * Fetches multiple deposits by their IDs from on-chain in a batch.
+     *
+     * @param depositIds - Array of deposit IDs
+     * @returns Array of deposit views
+     */
+    getDepositsById(depositIds: Array<bigint | number | string>): Promise<PV_DepositView[]>;
+    /**
+     * Fetches all intents created by the connected wallet from on-chain.
+     *
+     * Uses ProtocolViewer for instant on-chain reads.
+     *
+     * @returns Array of intent views with deposit context
+     *
+     * @example
+     * ```typescript
+     * const intents = await client.getIntents();
+     * for (const i of intents) {
+     *   console.log(`Intent ${i.intentHash}: ${i.intent.amount} tokens`);
+     * }
+     * ```
+     */
+    getIntents(): Promise<PV_IntentView[]>;
+    /**
+     * Fetches all intents created by a specific address from on-chain.
+     *
+     * @param owner - The owner's Ethereum address
+     * @returns Array of intent views with deposit context
+     */
+    getAccountIntents(owner: Address): Promise<PV_IntentView[]>;
+    /**
+     * Fetches a single intent by its hash from on-chain.
+     *
+     * @param intentHash - The intent hash (0x-prefixed, 32 bytes)
+     * @returns Intent view with deposit context
+     */
+    getIntent(intentHash: `0x${string}`): Promise<PV_IntentView>;
+    /**
+     * Resolves the payee details hash for a deposit's payment method from on-chain.
+     *
+     * @param depositId - The deposit ID
+     * @param paymentMethodHash - The payment method hash
+     * @returns The payee details hash, or null if not found
+     */
+    resolvePayeeHash(depositId: bigint | number | string, paymentMethodHash: string): Promise<string | null>;
+    /**
+     * Access to the indexer for advanced queries.
+     *
+     * Use this for:
+     * - Historical data (totalAmountTaken, totalWithdrawn)
+     * - Filtered queries across all deposits (not just by owner)
+     * - Pagination with ordering
+     * - Fulfillment/verification records
+     *
+     * @example
+     * ```typescript
+     * // Query deposits with filters and pagination
+     * const deposits = await client.indexer.getDeposits(
+     *   { status: 'ACTIVE', minLiquidity: '1000000' },
+     *   { limit: 50, orderBy: 'remainingDeposits', orderDirection: 'desc' }
+     * );
+     *
+     * // Get historical fulfillment data
+     * const fulfillments = await client.indexer.getFulfilledIntentEvents(['0x...']);
+     * ```
+     */
+    get indexer(): {
+        /** Raw GraphQL client for custom queries */
+        client: IndexerClient;
+        /**
+         * Fetches deposits from the indexer with optional filtering and pagination.
+         * Use for advanced queries across all deposits, not just by owner.
+         */
+        getDeposits: (filter?: DepositFilter, pagination?: PaginationOptions) => Promise<DepositEntity[]>;
+        /**
+         * Fetches deposits with their related payment methods and optionally intents.
+         */
+        getDepositsWithRelations: (filter?: DepositFilter, pagination?: PaginationOptions, options?: {
+            includeIntents?: boolean;
+            intentStatuses?: IntentStatus[];
+        }) => Promise<DepositWithRelations[]>;
+        /**
+         * Fetches a single deposit by its composite ID with all related data.
+         * @param id - Composite ID format: "chainId_escrowAddress_depositId"
+         */
+        getDepositById: (id: string, options?: {
+            includeIntents?: boolean;
+            intentStatuses?: IntentStatus[];
+        }) => Promise<DepositWithRelations | null>;
+        /**
+         * Fetches intents for multiple deposits.
+         */
+        getIntentsForDeposits: (depositIds: string[], statuses?: IntentStatus[]) => Promise<IntentEntity[]>;
+        /**
+         * Fetches all intents created by a specific owner address.
+         */
+        getOwnerIntents: (owner: string, statuses?: IntentStatus[]) => Promise<IntentEntity[]>;
+        /**
+         * Fetches intents that have expired.
+         */
+        getExpiredIntents: (params: {
+            now: bigint | string;
+            depositIds: string[];
+            limit?: number;
+        }) => Promise<IntentEntity[]>;
+        /**
+         * Fetches fulfillment events for completed intents.
+         */
+        getFulfilledIntentEvents: (intentHashes: string[]) => Promise<IntentFulfilledEntity[]>;
+        /**
+         * Fetches both the fulfillment record and payment verification for an intent.
+         */
+        getFulfillmentAndPayment: (intentHash: string) => Promise<FulfillmentAndPaymentResponse>;
+        /**
+         * Fetches deposits that match a specific payee details hash.
+         */
+        getDepositsByPayeeHash: (payeeHash: string, options?: {
+            paymentMethodHash?: string;
+            limit?: number;
+            includeIntents?: boolean;
+            intentStatuses?: IntentStatus[];
+        }) => Promise<DepositWithRelations[]>;
+    };
+    /**
+     * Ensures ERC20 token allowance is sufficient for the Escrow contract.
+     *
+     * If the current allowance is less than the requested amount, this method
+     * will submit an approval transaction. Use `maxApprove: true` for unlimited
+     * approval to avoid repeated approval transactions.
+     *
+     * @param params.token - ERC20 token address to approve
+     * @param params.amount - Minimum required allowance amount
+     * @param params.spender - Spender address (defaults to Escrow contract)
+     * @param params.maxApprove - If true, approves MaxUint256 instead of exact amount
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Object with `hadAllowance` (true if no approval needed) and optional `hash`
+     *
+     * @example
+     * ```typescript
+     * // Ensure allowance for 1000 USDC
+     * const { hadAllowance, hash } = await client.ensureAllowance({
+     *   token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+     *   amount: 1000_000000n,
+     *   maxApprove: true,
+     * });
+     *
+     * if (!hadAllowance) {
+     *   console.log('Approval tx:', hash);
+     * }
+     * ```
+     */
+    ensureAllowance(params: {
+        token: Address;
+        amount: bigint;
+        spender?: Address;
+        maxApprove?: boolean;
+        txOverrides?: TxOverrides;
+    }): Promise<{
+        hadAllowance: boolean;
+        hash?: Hash;
+    }>;
+    /**
+     * Creates a new USDC deposit in the Escrow contract.
+     *
+     * This is the primary method for liquidity providers to add funds to the protocol.
+     * The deposit can accept intents from multiple payment platforms with different
+     * conversion rates per currency.
+     *
+     * **Important**: Requires `apiKey` or `authorizationToken` to be set.
+     * Call `ensureAllowance()` first to approve USDC spending.
+     *
+     * @param params.token - Token address (USDC)
+     * @param params.amount - Total deposit amount in token units (6 decimals for USDC)
+     * @param params.intentAmountRange - Min/max amount per intent
+     * @param params.processorNames - Payment platforms to accept (e.g., ['wise', 'revolut'])
+     * @param params.depositData - Payee details per processor (e.g., [{ email: '...' }])
+     * @param params.conversionRates - Conversion rates per processor, grouped by currency
+     * @param params.delegate - Optional delegate address that can manage the deposit
+     * @param params.intentGuardian - Optional guardian for intent approval
+     * @param params.retainOnEmpty - Keep deposit active when balance reaches zero
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns The deposit details posted to API and the transaction hash
+     *
+     * @throws Error if apiKey/authorizationToken is missing
+     * @throws Error if processorNames, depositData, and conversionRates lengths don't match
+     * @throws Error if a currency is not supported by the specified processor
+     *
+     * @example
+     * ```typescript
+     * // Create a 1000 USDC deposit accepting Wise payments in USD and EUR
+     * const { hash } = await client.createDeposit({
+     *   token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+     *   amount: 1000_000000n,
+     *   intentAmountRange: { min: 10_000000n, max: 500_000000n },
+     *   processorNames: ['wise'],
+     *   depositData: [{ email: 'you@example.com' }],
+     *   conversionRates: [[
+     *     { currency: 'USD', conversionRate: '1020000000000000000' }, // 1.02
+     *     { currency: 'EUR', conversionRate: '1100000000000000000' }, // 1.10
+     *   ]],
+     * });
+     * ```
+     */
+    createDeposit(params: {
+        token: Address;
+        amount: bigint;
+        intentAmountRange: {
+            min: bigint;
+            max: bigint;
+        };
+        processorNames: string[];
+        depositData: {
+            [key: string]: string;
+        }[];
+        conversionRates: {
+            currency: string;
+            conversionRate: string;
+        }[][];
+        delegate?: Address;
+        intentGuardian?: Address;
+        retainOnEmpty?: boolean;
+        txOverrides?: TxOverrides;
+    }): Promise<{
+        depositDetails: PostDepositDetailsRequest[];
+        hash: Hash;
+    }>;
+    /**
+     * Enables or disables a deposit from accepting new intents.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.accepting - Whether to accept new intents
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setAcceptingIntents(params: {
+        depositId: bigint;
+        accepting: boolean;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Updates the min/max intent amount range for a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.min - Minimum intent amount
+     * @param params.max - Maximum intent amount
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setIntentRange(params: {
+        depositId: bigint;
+        min: bigint;
+        max: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Updates the minimum conversion rate for a specific currency on a payment method.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash (bytes32)
+     * @param params.fiatCurrency - Fiat currency hash (bytes32)
+     * @param params.minConversionRate - New minimum conversion rate (18 decimals)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setCurrencyMinRate(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        fiatCurrency: `0x${string}`;
+        minConversionRate: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Adds additional funds to an existing deposit.
+     * Requires prior approval of the token amount.
+     *
+     * @param params.depositId - The deposit ID to add funds to
+     * @param params.amount - Amount to add (in token units)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    addFunds(params: {
+        depositId: bigint;
+        amount: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Removes funds from a deposit (partial withdrawal).
+     * Can only withdraw available (non-locked) funds.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.amount - Amount to remove (in token units)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    removeFunds(params: {
+        depositId: bigint;
+        amount: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Fully withdraws a deposit, returning all available funds to the owner.
+     * The deposit must have no active intents.
+     *
+     * @param params.depositId - The deposit ID to withdraw
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    withdrawDeposit(params: {
+        depositId: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Sets whether a deposit should remain active when its balance reaches zero.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.retain - If true, deposit stays active when empty
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setRetainOnEmpty(params: {
+        depositId: bigint;
+        retain: boolean;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Assigns a delegate address that can manage the deposit on behalf of the owner.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.delegate - Address to delegate management to
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setDelegate(params: {
+        depositId: bigint;
+        delegate: Address;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Removes the delegate from a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    removeDelegate(params: {
+        depositId: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Adds new payment methods to an existing deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethods - Array of payment method hashes to add
+     * @param params.paymentMethodData - Corresponding payment method configuration
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    addPaymentMethods(params: {
+        depositId: bigint;
+        paymentMethods: `0x${string}`[];
+        paymentMethodData: {
+            intentGatingService: Address;
+            payeeDetails: string;
+            data: `0x${string}`;
+        }[];
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Activates or deactivates a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to modify
+     * @param params.isActive - Whether the payment method should accept intents
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    setPaymentMethodActive(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        isActive: boolean;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Deactivates a payment method on a deposit (convenience alias for setPaymentMethodActive).
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to deactivate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    removePaymentMethod(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Adds new currencies to a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to add currencies to
+     * @param params.currencies - Array of currency configurations with code and min rate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    addCurrencies(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        currencies: {
+            code: `0x${string}`;
+            minConversionRate: bigint;
+        }[];
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Deactivates a currency for a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash
+     * @param params.currencyCode - Currency code hash to deactivate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    deactivateCurrency(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        currencyCode: `0x${string}`;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Removes (deactivates) a currency from a payment method.
+     * Alias for deactivateCurrency.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash
+     * @param params.currencyCode - Currency code hash to remove
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    removeCurrency(params: {
+        depositId: bigint;
+        paymentMethod: `0x${string}`;
+        currencyCode: `0x${string}`;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * Removes expired intents from a deposit, freeing up locked funds.
+     * Can be called by anyone (permissionless cleanup).
+     *
+     * @param params.depositId - The deposit ID to prune
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    pruneExpiredIntents(params: {
+        depositId: bigint;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * **Supporting Method** - Signals intent to use a deposit.
+     *
+     * > **Note**: This method is typically used by takers/buyers who want to
+     * > purchase crypto by paying fiat. Liquidity providers generally don't
+     * > need to call this method directly.
+     *
+     * This reserves funds from a deposit and creates an intent that must be
+     * fulfilled (via `fulfillIntent`) or will expire. The taker commits to
+     * sending fiat payment to the deposit's payee.
+     *
+     * If `gatingServiceSignature` is not provided, the SDK will automatically
+     * fetch one from the API (requires `apiKey` or `authorizationToken`).
+     *
+     * @param params.depositId - The deposit to use
+     * @param params.amount - Amount of tokens to claim (in token units)
+     * @param params.toAddress - Address to receive the tokens when fulfilled
+     * @param params.processorName - Payment platform (e.g., 'wise', 'revolut')
+     * @param params.payeeDetails - Hashed payee details (from deposit)
+     * @param params.fiatCurrencyCode - Fiat currency code (e.g., 'USD', 'EUR')
+     * @param params.conversionRate - Agreed conversion rate (18 decimals)
+     * @param params.referrer - Optional referrer address for fee sharing
+     * @param params.referrerFee - Optional referrer fee amount
+     * @param params.postIntentHook - Optional hook contract to call after signaling
+     * @param params.data - Optional data to pass to the hook
+     * @param params.gatingServiceSignature - Pre-obtained signature (if not auto-fetching)
+     * @param params.signatureExpiration - Signature expiration timestamp
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * const hash = await client.signalIntent({
+     *   depositId: 42n,
+     *   amount: 100_000000n, // 100 USDC
+     *   toAddress: '0x...',
+     *   processorName: 'wise',
+     *   payeeDetails: '0x...',
+     *   fiatCurrencyCode: 'USD',
+     *   conversionRate: 1_020000000000000000n, // 1.02
+     * });
+     * ```
+     */
+    signalIntent(params: {
+        depositId: bigint | string;
+        amount: bigint | string;
+        toAddress: Address;
+        processorName: string;
+        payeeDetails: string;
+        fiatCurrencyCode: string;
+        conversionRate: bigint | string;
+        referrer?: Address;
+        referrerFee?: bigint | string;
+        postIntentHook?: Address;
+        data?: `0x${string}`;
+        gatingServiceSignature?: `0x${string}`;
+        signatureExpiration?: bigint | string;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * **Supporting Method** - Cancels a signaled intent before fulfillment.
+     *
+     * Only the intent owner can cancel. Releases reserved funds back to the deposit.
+     *
+     * @param params.intentHash - The intent hash to cancel (0x-prefixed, 32 bytes)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    cancelIntent(params: {
+        intentHash: `0x${string}`;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * **Supporting Method** - Releases funds back to the deposit owner.
+     *
+     * Called by the deposit owner when they want to reject an intent
+     * (e.g., payment verification failed or intent expired).
+     *
+     * @param params.intentHash - The intent hash (0x-prefixed, 32 bytes)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    releaseFundsToPayer(params: {
+        intentHash: `0x${string}`;
+        txOverrides?: TxOverrides;
+    }): Promise<Hash>;
+    /**
+     * **Supporting Method** - Fulfills an intent by submitting a payment proof.
+     *
+     * > **Note**: This method is typically used by takers/buyers after they've
+     * > sent fiat payment. Liquidity providers generally don't call this directly.
+     *
+     * This is the final step in the off-ramp flow. After the taker has sent
+     * fiat payment, they generate a proof (via the browser extension) and
+     * submit it here. The SDK handles attestation service calls automatically.
+     *
+     * **Flow:**
+     * 1. Intent parameters are derived from the indexer/ProtocolViewer
+     * 2. Proof is sent to the attestation service for verification
+     * 3. Attestation response is encoded and submitted on-chain
+     * 4. Funds are released to the intent's `toAddress`
+     *
+     * @param params.intentHash - The intent hash to fulfill (0x-prefixed, 32 bytes)
+     * @param params.proof - Payment proof from Reclaim (object or JSON string)
+     * @param params.timestampBufferMs - Allowed timestamp variance (default: 300000ms)
+     * @param params.attestationServiceUrl - Override attestation service URL
+     * @param params.verifyingContract - Override verifier contract address
+     * @param params.postIntentHookData - Data to pass to post-intent hook
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @param params.callbacks - Lifecycle callbacks for UI updates
+     * @returns Transaction hash
+     */
+    fulfillIntent(params: {
+        intentHash: `0x${string}`;
+        proof: Record<string, unknown> | string;
+        timestampBufferMs?: string;
+        attestationServiceUrl?: string;
+        verifyingContract?: Address;
+        postIntentHookData?: `0x${string}`;
+        txOverrides?: TxOverrides;
+        callbacks?: {
+            onAttestationStart?: () => void;
+            onTxSent?: (hash: Hash) => void;
+            onTxMined?: (hash: Hash) => void;
+        };
+    }): Promise<Hash>;
+    private defaultAttestationService;
+    /**
+     * **Supporting Method** - Fetches quotes for available liquidity.
+     *
+     * > **Note**: This method is typically used by frontend applications to
+     * > display available off-ramp options to users. Liquidity providers can
+     * > use it to see how their deposits appear to takers.
+     *
+     * Returns available quotes from liquidity providers matching the request
+     * criteria. When authenticated, the API returns payee details in each quote.
+     *
+     * @param req - Quote request parameters
+     * @param req.paymentPlatforms - Payment platforms to search (e.g., ['wise', 'revolut'])
+     * @param req.fiatCurrency - Target fiat currency code (e.g., 'USD')
+     * @param req.user - User's address
+     * @param req.recipient - Token recipient address
+     * @param req.destinationChainId - Chain ID for token delivery
+     * @param req.destinationToken - Token address to receive
+     * @param req.amount - Amount (in fiat if isExactFiat, else in tokens)
+     * @param req.isExactFiat - If true, amount is in fiat; quotes return token amounts
+     * @param req.escrowAddresses - Optional filter for specific escrow contracts
+     * @param opts - Optional overrides for API URL and timeout
+     * @returns Quote response with available options
+     *
+     * @example
+     * ```typescript
+     * const quote = await client.getQuote({
+     *   paymentPlatforms: ['wise'],
+     *   fiatCurrency: 'EUR',
+     *   user: '0x...',
+     *   recipient: '0x...',
+     *   destinationChainId: 8453,
+     *   destinationToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+     *   amount: '100',
+     *   isExactFiat: true,
+     * });
+     *
+     * for (const q of quote.responseObject.quotes) {
+     *   console.log(`${q.tokenAmountFormatted} USDC for ${q.fiatAmountFormatted}`);
+     * }
+     * ```
+     */
+    getQuote(req: QuoteRequest, opts?: {
+        baseApiUrl?: string;
+        timeoutMs?: number;
+    }): Promise<QuoteResponse>;
+    /**
+     * **Supporting Method** - Fetches taker tier information for an address.
+     *
+     * > **Note**: Requires `apiKey` or `authorizationToken` to be set.
+     *
+     * @param req - Taker tier request parameters
+     * @param req.owner - Taker address
+     * @param req.chainId - Chain ID
+     * @param opts - Optional overrides for API URL and timeout
+     * @returns Taker tier response
+     */
+    getTakerTier(req: GetTakerTierRequest, opts?: {
+        baseApiUrl?: string;
+        timeoutMs?: number;
+    }): Promise<GetTakerTierResponse>;
+    private requireProtocolViewer;
+    /**
+     * Fetches a deposit directly from on-chain ProtocolViewer contract.
+     * Falls back to Escrow.getDeposit if ProtocolViewer is unavailable.
+     *
+     * @param depositId - The deposit ID (string or bigint)
+     * @returns Parsed deposit view with all payment methods and currencies
+     */
+    getPvDepositById(depositId: string | bigint): Promise<PV_DepositView>;
+    /**
+     * Fetches multiple deposits by ID from on-chain in a batch call.
+     *
+     * @param ids - Array of deposit IDs
+     * @returns Array of parsed deposit views
+     */
+    getPvDepositsFromIds(ids: Array<string | bigint>): Promise<any[]>;
+    /**
+     * Fetches all deposits owned by an address from on-chain.
+     *
+     * @param owner - The owner address
+     * @returns Array of parsed deposit views
+     */
+    getPvAccountDeposits(owner: Address): Promise<PV_DepositView[]>;
+    /**
+     * Fetches all intents created by an address from on-chain.
+     * Requires ProtocolViewer to be available.
+     *
+     * @param owner - The owner address
+     * @returns Array of parsed intent views
+     */
+    getPvAccountIntents(owner: Address): Promise<PV_IntentView[]>;
+    /**
+     * Fetches a single intent by hash from on-chain.
+     *
+     * @param intentHash - The intent hash (0x-prefixed, 32 bytes)
+     * @returns Parsed intent view with deposit context
+     */
+    getPvIntent(intentHash: `0x${string}`): Promise<PV_IntentView>;
+    /**
+     * Returns the USDC token address for the current network (if known).
+     *
+     * @returns USDC address or undefined if not configured
+     */
+    getUsdcAddress(): Address | undefined;
+    /**
+     * Returns all deployed contract addresses for the current network/environment.
+     *
+     * @returns Object with escrow, orchestrator, protocolViewer, verifier, and USDC addresses
+     */
+    getDeployedAddresses(): {
+        escrow: Address;
+        orchestrator?: Address;
+        protocolViewer?: Address;
+        unifiedPaymentVerifier?: Address;
+        usdc?: Address;
+    };
+    /**
+     * Resolves all parameters needed to fulfill an intent.
+     *
+     * Attempts to fetch from ProtocolViewer first (on-chain source of truth),
+     * then falls back to the indexer. This is called internally by `fulfillIntent`
+     * but exposed for advanced use cases.
+     *
+     * @param intentHash - The intent hash to resolve
+     * @returns Intent parameters needed for fulfillment
+     * @throws Error if intent not found or payee details cannot be resolved
+     */
+    getFulfillIntentInputs(intentHash: `0x${string}`): Promise<{
+        amount: string;
+        fiatCurrency: `0x${string}`;
+        conversionRate: string;
+        payeeDetails: `0x${string}`;
+        intentTimestampMs: string;
+        paymentMethodHash: `0x${string}`;
+    }>;
+}
+
+export { type DepositVerifierData as $, type ActionCallback as A, type GetDepositByIdResponse as B, type CreateDepositParams as C, type DepositWithRelations as D, type Intent as E, type FulfillIntentParams as F, type GetPayeeDetailsRequest as G, type ApiIntentStatus as H, type IntentEntity as I, type GetOwnerIntentsRequest as J, type GetOwnerIntentsResponse as K, type GetIntentsByDepositRequest as L, type GetIntentsByDepositResponse as M, type NearbyQuote as N, type GetIntentByHashRequest as O, type PostDepositDetailsRequest as P, type QuoteRequest as Q, type Range as R, type SignalIntentParams as S, type TxOverrides as T, type GetIntentByHashResponse as U, type ValidatePayeeDetailsRequest as V, type WithdrawDepositParams as W, type RegisterPayeeDetailsRequest as X, type RegisterPayeeDetailsResponse as Y, Zkp2pClient as Z, type OnchainCurrency as _, type ValidatePayeeDetailsResponse as a, type OrderStats as a0, type DepositIntentStatistics as a1, type TakerTier as a2, type TakerTierStats as a3, type TakerTierLevel as a4, type PlatformLimit as a5, type PlatformRiskLevel as a6, IndexerClient as a7, defaultIndexerEndpoint as a8, IndexerDepositService as a9, getPaymentMethodsCatalog as aA, getGatingServiceAddress as aB, type RuntimeEnv as aC, parseDepositView as aD, parseIntentView as aE, enrichPvDepositView as aF, enrichPvIntentView as aG, type PV_DepositView as aH, type PV_Deposit as aI, type PV_PaymentMethodData as aJ, type PV_Currency as aK, type PV_IntentView as aL, type PV_Intent as aM, fetchFulfillmentAndPayment as aa, type DepositEntity as ab, type IntentFulfilledEntity as ac, type DepositPaymentMethodEntity as ad, type MethodCurrencyEntity as ae, type IntentStatus as af, type DepositFilter as ag, type PaginationOptions as ah, type DepositOrderField as ai, type OrderDirection as aj, type DeploymentEnv as ak, type FulfillmentRecord as al, type PaymentVerifiedRecord as am, type FulfillmentAndPaymentResponse as an, PAYMENT_PLATFORMS as ao, type PaymentPlatformType as ap, Currency as aq, currencyInfo as ar, getCurrencyInfoFromHash as as, getCurrencyInfoFromCountryCode as at, getCurrencyCodeFromHash as au, isSupportedCurrencyHash as av, mapConversionRatesToOnchainMinRate as aw, type CurrencyType as ax, type CurrencyData as ay, getContracts as az, type PostDepositDetailsResponse as b, type GetPayeeDetailsResponse as c, type GetTakerTierRequest as d, type GetTakerTierResponse as e, type PaymentMethodCatalog as f, type Zkp2pClientOptions as g, type TimeoutConfig as h, type CreateDepositConversionRate as i, type ReleaseFundsToPayerParams as j, type CancelIntentParams as k, type QuoteResponse as l, type QuoteResponseObject as m, type QuoteSingleResponse as n, type QuoteIntentResponse as o, type QuoteFeesResponse as p, type FiatResponse as q, type TokenResponse as r, type NearbySuggestions as s, type ApiDeposit as t, type DepositVerifier as u, type DepositVerifierCurrency as v, type DepositStatus as w, type GetOwnerDepositsRequest as x, type GetOwnerDepositsResponse as y, type GetDepositByIdRequest as z };