@provex/utils 1.0.16 → 1.2.3

package/dist/src/deposit.d.ts

@@ -1 +1,69 @@
-export type StatusMutatingAction = "deposit" | "withdrawal" | "closed" | "exchange";
+/**
+ * @fileoverview Deposit status definitions and types.
+ *
+ * This module defines the possible states for escrow deposits and provides
+ * the canonical type definitions used across the indexer and UI.
+ *
+ * @remarks
+ * **Status Lifecycle:**
+ *
+ * V2 Deposits:
+ * - active: Deposit has funds available for matching
+ * - underfunded: Deposit exists but balance is too low
+ * - withdrawn: All funds removed, deposit empty
+ * - closed: Explicitly closed by depositor (terminal state)
+ *
+ * V3 Deposits:
+ * - active: Deposit has funds and is accepting intents
+ * - underfunded: Deposit exists but balance is too low
+ * - withdrawn: All funds removed, deposit empty
+ * - paused: Deposit has funds but acceptingIntents = false
+ *
+ * @see {@link indexer/depositStatus} for status derivation logic
+ */
+/**
+ * Deposit status mapping - single source of truth for all deposit statuses.
+ * Used across the indexer and UI for consistent status handling.
+ *
+ * V2 statuses: active, underfunded, withdrawn, closed
+ * V3 statuses: active, underfunded, withdrawn, paused (V3 has no 'closed' state)
+ */
+export declare const depositStatuses: {
+    readonly ACTIVE: "active";
+    readonly CLOSED: "closed";
+    readonly PAUSED: "paused";
+    readonly WITHDRAWN: "withdrawn";
+    readonly UNDERFUNDED: "underfunded";
+};
+/**
+ * Union type of all valid deposit status values.
+ */
+export type DepositStatus = (typeof depositStatuses)[keyof typeof depositStatuses];
+/**
+ * Array of deposit status values for use with onchainEnum in ponder.schema.ts.
+ */
+export declare const DEPOSIT_STATUSES: readonly DepositStatus[];
+/**
+ * Actions that can mutate a deposit's status.
+ * - deposit: Adding funds
+ * - withdrawal: Removing funds
+ * - exchange: Intent fulfilled, funds exchanged
+ * - closed: V2 only - explicitly closing the deposit
+ * - paused: V3 only - toggling acceptingIntents
+ */
+export type StatusMutatingAction = 'deposit' | 'withdrawal' | 'closed' | 'exchange' | 'paused';
+/**
+ * Escrow version mapping - single source of truth for escrow contract versions.
+ */
+export declare const escrowVersions: {
+    readonly V2: "v2";
+    readonly V3: "v3";
+};
+/**
+ * Union type of all valid escrow version values.
+ */
+export type EscrowVersion = (typeof escrowVersions)[keyof typeof escrowVersions];
+/**
+ * Array of escrow version values for use with onchainEnum in ponder.schema.ts.
+ */
+export declare const ESCROW_VERSIONS: readonly EscrowVersion[];

package/dist/src/deposit.js

@@ -1 +1,52 @@
-export {};
+/**
+ * @fileoverview Deposit status definitions and types.
+ *
+ * This module defines the possible states for escrow deposits and provides
+ * the canonical type definitions used across the indexer and UI.
+ *
+ * @remarks
+ * **Status Lifecycle:**
+ *
+ * V2 Deposits:
+ * - active: Deposit has funds available for matching
+ * - underfunded: Deposit exists but balance is too low
+ * - withdrawn: All funds removed, deposit empty
+ * - closed: Explicitly closed by depositor (terminal state)
+ *
+ * V3 Deposits:
+ * - active: Deposit has funds and is accepting intents
+ * - underfunded: Deposit exists but balance is too low
+ * - withdrawn: All funds removed, deposit empty
+ * - paused: Deposit has funds but acceptingIntents = false
+ *
+ * @see {@link indexer/depositStatus} for status derivation logic
+ */
+/**
+ * Deposit status mapping - single source of truth for all deposit statuses.
+ * Used across the indexer and UI for consistent status handling.
+ *
+ * V2 statuses: active, underfunded, withdrawn, closed
+ * V3 statuses: active, underfunded, withdrawn, paused (V3 has no 'closed' state)
+ */
+export const depositStatuses = {
+    ACTIVE: 'active',
+    CLOSED: 'closed', // V2 only - terminal state when deposit is explicitly closed
+    PAUSED: 'paused', // V3 only - deposit is paused (acceptingIntents = false)
+    WITHDRAWN: 'withdrawn',
+    UNDERFUNDED: 'underfunded',
+};
+/**
+ * Array of deposit status values for use with onchainEnum in ponder.schema.ts.
+ */
+export const DEPOSIT_STATUSES = Object.values(depositStatuses);
+/**
+ * Escrow version mapping - single source of truth for escrow contract versions.
+ */
+export const escrowVersions = {
+    V2: 'v2',
+    V3: 'v3',
+};
+/**
+ * Array of escrow version values for use with onchainEnum in ponder.schema.ts.
+ */
+export const ESCROW_VERSIONS = Object.values(escrowVersions);

package/dist/src/depositKeys.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @fileoverview Compound key utilities for deposit and related entity identification.
+ *
+ * Deposits are uniquely identified by a compound key of (escrow, localId, chainId).
+ * This module provides types and utilities for creating, serializing, and
+ * converting these compound keys for use in database operations and event handling.
+ *
+ * @remarks
+ * The compound key approach allows deposits to be uniquely identified across:
+ * - Multiple chains (Base, Pulsechain)
+ * - Multiple escrow contract versions (V2, V3)
+ * - Different deposit IDs within each escrow
+ *
+ * @see {@link ids} for ID serialization utilities
+ */
+import { type Hex } from "viem";
+import type { ChainId } from "./chain.js";
+/**
+ * Compound key uniquely identifying a deposit across all chains and escrows.
+ *
+ * @remarks
+ * This is the primary key structure used by the indexer to track deposits.
+ * A deposit can only be uniquely identified by all three fields together.
+ */
+export type DepositKey = {
+    /** Escrow contract address */
+    escrow: Hex;
+    /** Deposit ID within the escrow contract (per-escrow counter) */
+    localId: bigint;
+    /** Chain ID where the deposit exists */
+    chainId: bigint;
+};
+/**
+ * Creates a deposit compound key from blockchain event data.
+ *
+ * @param params - Event data containing escrow address, deposit ID, and chain ID
+ * @returns DepositKey for database operations
+ *
+ * @example
+ * ```ts
+ * const key = makeDepositKey({
+ *   escrow: '0x2f121CDDCA6d652f35e8B3E560f9760898888888',
+ *   depositId: 42n,
+ *   chainId: 8453
+ * })
+ * ```
+ */
+export declare const makeDepositKey: ({ escrow, depositId, chainId }: {
+    escrow: Hex;
+    depositId: bigint;
+    chainId: ChainId;
+}) => DepositKey;
+/**
+ * Serializes a deposit compound key into a single hex string.
+ * Format: [escrow (20 bytes)][localId (8 bytes)][chainId (4 bytes)] = 32 bytes
+ *
+ * @param depositKey - The deposit compound key to serialize
+ * @returns 32-byte hex string representation
+ *
+ * @example
+ * ```ts
+ * const hex = serializeDepositKey({ escrow, localId: 42n, chainId: 8453n })
+ * // '0x2f121CDDCA6d652f35e8B3E560f976089888888800000000000000002a00002105'
+ * ```
+ */
+export declare const serializeDepositKey: ({ escrow, localId, chainId }: DepositKey) => Hex;
+/**
+ * Converts a deposit key to foreign key field names for database relations.
+ * Used when inserting records that reference a deposit.
+ *
+ * @param depositKey - The deposit compound key
+ * @returns Object with depositEscrow, depositLocalId, depositChainId fields
+ */
+export declare const toDepositForeignKey: (depositKey: DepositKey) => {
+    readonly depositEscrow: `0x${string}`;
+    readonly depositLocalId: bigint;
+    readonly depositChainId: bigint;
+};
+/**
+ * Compound key for deposit payment method (verifier) associations.
+ * Extends deposit key with payment method identification.
+ */
+export type DepositVerifierAddedKey = {
+    depositEscrow: Hex;
+    depositLocalId: bigint;
+    depositChainId: bigint;
+    paymentMethodId: Hex;
+};
+/**
+ * Compound key for deposit currency support associations.
+ * Extends verifier key with currency identification.
+ */
+export type DepositCurrencyAddedKey = {
+    depositEscrow: Hex;
+    depositLocalId: bigint;
+    depositChainId: bigint;
+    paymentMethodId: Hex;
+    currency: Hex;
+};
+/**
+ * Compound key for conversion rate update tracking.
+ * Extends currency key with a change counter for historical tracking.
+ */
+export type DepositConversionRateUpdatedKey = {
+    depositEscrow: Hex;
+    depositLocalId: bigint;
+    depositChainId: bigint;
+    paymentMethodId: Hex;
+    currency: Hex;
+    changeId: number;
+};
+/**
+ * Creates a depositVerifierAdded compound key
+ */
+export declare const makeDepositVerifierAddedKey: ({ depositKey, paymentMethodId }: {
+    depositKey: DepositKey;
+    paymentMethodId: Hex;
+}) => DepositVerifierAddedKey;
+/**
+ * Creates a depositCurrencyAdded compound key
+ */
+export declare const makeDepositCurrencyAddedKey: ({ depositKey, paymentMethodId, currency }: {
+    depositKey: DepositKey;
+    paymentMethodId: Hex;
+    currency: Hex;
+}) => DepositCurrencyAddedKey;
+/**
+ * Creates a depositConversionRateUpdated compound key
+ */
+export declare const makeDepositConversionRateUpdatedKey: ({ depositKey, paymentMethodId, currency, changeId }: {
+    depositKey: DepositKey;
+    paymentMethodId: Hex;
+    currency: Hex;
+    changeId: number;
+}) => DepositConversionRateUpdatedKey;
+/**
+ * Compound key for payment method active status changes.
+ * Tracks when a payment method is enabled/disabled on a deposit.
+ */
+export type DepositPaymentMethodActiveUpdatedKey = {
+    depositEscrow: Hex;
+    depositLocalId: bigint;
+    depositChainId: bigint;
+    paymentMethodId: Hex;
+    changeId: number;
+};
+/**
+ * Creates a depositPaymentMethodActiveUpdated compound key
+ */
+export declare const makeDepositPaymentMethodActiveUpdatedKey: ({ depositKey, paymentMethodId, changeId, }: {
+    depositKey: DepositKey;
+    paymentMethodId: Hex;
+    changeId: number;
+}) => DepositPaymentMethodActiveUpdatedKey;

package/dist/src/depositKeys.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Compound key utilities for deposit and related entity identification.
+ *
+ * Deposits are uniquely identified by a compound key of (escrow, localId, chainId).
+ * This module provides types and utilities for creating, serializing, and
+ * converting these compound keys for use in database operations and event handling.
+ *
+ * @remarks
+ * The compound key approach allows deposits to be uniquely identified across:
+ * - Multiple chains (Base, Pulsechain)
+ * - Multiple escrow contract versions (V2, V3)
+ * - Different deposit IDs within each escrow
+ *
+ * @see {@link ids} for ID serialization utilities
+ */
+import { concatHex, numberToHex } from "viem";
+/**
+ * Creates a deposit compound key from blockchain event data.
+ *
+ * @param params - Event data containing escrow address, deposit ID, and chain ID
+ * @returns DepositKey for database operations
+ *
+ * @example
+ * ```ts
+ * const key = makeDepositKey({
+ *   escrow: '0x2f121CDDCA6d652f35e8B3E560f9760898888888',
+ *   depositId: 42n,
+ *   chainId: 8453
+ * })
+ * ```
+ */
+export const makeDepositKey = ({ escrow, depositId, chainId }) => ({
+    escrow,
+    localId: depositId,
+    chainId: BigInt(chainId),
+});
+/**
+ * Serializes a deposit compound key into a single hex string.
+ * Format: [escrow (20 bytes)][localId (8 bytes)][chainId (4 bytes)] = 32 bytes
+ *
+ * @param depositKey - The deposit compound key to serialize
+ * @returns 32-byte hex string representation
+ *
+ * @example
+ * ```ts
+ * const hex = serializeDepositKey({ escrow, localId: 42n, chainId: 8453n })
+ * // '0x2f121CDDCA6d652f35e8B3E560f976089888888800000000000000002a00002105'
+ * ```
+ */
+export const serializeDepositKey = ({ escrow, localId, chainId }) => {
+    return concatHex([escrow, numberToHex(localId, { size: 8 }), numberToHex(chainId, { size: 4 })]);
+};
+/**
+ * Converts a deposit key to foreign key field names for database relations.
+ * Used when inserting records that reference a deposit.
+ *
+ * @param depositKey - The deposit compound key
+ * @returns Object with depositEscrow, depositLocalId, depositChainId fields
+ */
+export const toDepositForeignKey = (depositKey) => ({
+    depositEscrow: depositKey.escrow,
+    depositLocalId: depositKey.localId,
+    depositChainId: depositKey.chainId,
+});
+/**
+ * Creates a depositVerifierAdded compound key
+ */
+export const makeDepositVerifierAddedKey = ({ depositKey, paymentMethodId }) => ({
+    depositEscrow: depositKey.escrow,
+    depositLocalId: depositKey.localId,
+    depositChainId: depositKey.chainId,
+    paymentMethodId,
+});
+/**
+ * Creates a depositCurrencyAdded compound key
+ */
+export const makeDepositCurrencyAddedKey = ({ depositKey, paymentMethodId, currency }) => ({
+    depositEscrow: depositKey.escrow,
+    depositLocalId: depositKey.localId,
+    depositChainId: depositKey.chainId,
+    paymentMethodId,
+    currency,
+});
+/**
+ * Creates a depositConversionRateUpdated compound key
+ */
+export const makeDepositConversionRateUpdatedKey = ({ depositKey, paymentMethodId, currency, changeId }) => ({
+    depositEscrow: depositKey.escrow,
+    depositLocalId: depositKey.localId,
+    depositChainId: depositKey.chainId,
+    paymentMethodId,
+    currency,
+    changeId,
+});
+/**
+ * Creates a depositPaymentMethodActiveUpdated compound key
+ */
+export const makeDepositPaymentMethodActiveUpdatedKey = ({ depositKey, paymentMethodId, changeId, }) => ({
+    depositEscrow: depositKey.escrow,
+    depositLocalId: depositKey.localId,
+    depositChainId: depositKey.chainId,
+    paymentMethodId,
+    changeId,
+});

package/dist/src/depositKeys.test.d.ts

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

package/dist/src/depositKeys.test.js

@@ -0,0 +1,231 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeDepositKey, serializeDepositKey, toDepositForeignKey, makeDepositVerifierAddedKey, makeDepositCurrencyAddedKey, makeDepositConversionRateUpdatedKey, makeDepositPaymentMethodActiveUpdatedKey, } from './depositKeys.js';
+describe('depositKeys', () => {
+    const TEST_ESCROW = '0x1234567890123456789012345678901234567890';
+    const TEST_PAYMENT_METHOD = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd';
+    const TEST_CURRENCY = '0x5553440000000000000000000000000000000000000000000000000000000000';
+    const TEST_CHAIN_ID = 8453;
+    describe('makeDepositKey', () => {
+        it('creates a deposit key from event data', () => {
+            const key = makeDepositKey({
+                escrow: TEST_ESCROW,
+                depositId: 123n,
+                chainId: TEST_CHAIN_ID,
+            });
+            assert.equal(key.escrow, TEST_ESCROW);
+            assert.equal(key.localId, 123n);
+            assert.equal(key.chainId, BigInt(TEST_CHAIN_ID));
+        });
+        it('converts numeric chainId to bigint', () => {
+            const key = makeDepositKey({
+                escrow: TEST_ESCROW,
+                depositId: 1n,
+                chainId: 369,
+            });
+            assert.equal(key.chainId, 369n);
+        });
+    });
+    describe('serializeDepositKey', () => {
+        it('serializes deposit key to hex string', () => {
+            const key = {
+                escrow: TEST_ESCROW,
+                localId: 1n,
+                chainId: 8453n,
+            };
+            const serialized = serializeDepositKey(key);
+            assert.ok(serialized.startsWith('0x'));
+            // escrow (20 bytes) + localId (8 bytes) + chainId (4 bytes) = 32 bytes = 64 hex chars + 0x
+            assert.equal(serialized.length, 66);
+        });
+        it('produces consistent results', () => {
+            const key = {
+                escrow: TEST_ESCROW,
+                localId: 42n,
+                chainId: 8453n,
+            };
+            const s1 = serializeDepositKey(key);
+            const s2 = serializeDepositKey(key);
+            assert.equal(s1, s2);
+        });
+    });
+    describe('toDepositForeignKey', () => {
+        it('converts deposit key to foreign key fields', () => {
+            const key = {
+                escrow: TEST_ESCROW,
+                localId: 5n,
+                chainId: 8453n,
+            };
+            const fk = toDepositForeignKey(key);
+            assert.equal(fk.depositEscrow, TEST_ESCROW);
+            assert.equal(fk.depositLocalId, 5n);
+            assert.equal(fk.depositChainId, 8453n);
+        });
+    });
+    describe('makeDepositVerifierAddedKey', () => {
+        it('creates compound key with deposit and payment method', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 10n,
+                chainId: 8453n,
+            };
+            const key = makeDepositVerifierAddedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+            });
+            assert.equal(key.depositEscrow, TEST_ESCROW);
+            assert.equal(key.depositLocalId, 10n);
+            assert.equal(key.depositChainId, 8453n);
+            assert.equal(key.paymentMethodId, TEST_PAYMENT_METHOD);
+        });
+    });
+    describe('makeDepositCurrencyAddedKey', () => {
+        it('creates compound key with deposit, payment method, and currency', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 20n,
+                chainId: 8453n,
+            };
+            const key = makeDepositCurrencyAddedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                currency: TEST_CURRENCY,
+            });
+            assert.equal(key.depositEscrow, TEST_ESCROW);
+            assert.equal(key.depositLocalId, 20n);
+            assert.equal(key.depositChainId, 8453n);
+            assert.equal(key.paymentMethodId, TEST_PAYMENT_METHOD);
+            assert.equal(key.currency, TEST_CURRENCY);
+        });
+    });
+    describe('makeDepositConversionRateUpdatedKey', () => {
+        it('creates compound key with changeId', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 30n,
+                chainId: 8453n,
+            };
+            const key = makeDepositConversionRateUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                currency: TEST_CURRENCY,
+                changeId: 0,
+            });
+            assert.equal(key.depositEscrow, TEST_ESCROW);
+            assert.equal(key.depositLocalId, 30n);
+            assert.equal(key.depositChainId, 8453n);
+            assert.equal(key.paymentMethodId, TEST_PAYMENT_METHOD);
+            assert.equal(key.currency, TEST_CURRENCY);
+            assert.equal(key.changeId, 0);
+        });
+        it('handles sequential changeIds', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 30n,
+                chainId: 8453n,
+            };
+            const key0 = makeDepositConversionRateUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                currency: TEST_CURRENCY,
+                changeId: 0,
+            });
+            const key1 = makeDepositConversionRateUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                currency: TEST_CURRENCY,
+                changeId: 1,
+            });
+            assert.equal(key0.changeId, 0);
+            assert.equal(key1.changeId, 1);
+            assert.notDeepEqual(key0, key1);
+        });
+    });
+    describe('makeDepositPaymentMethodActiveUpdatedKey', () => {
+        it('creates compound key with all fields', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 40n,
+                chainId: 8453n,
+            };
+            const key = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 0,
+            });
+            assert.equal(key.depositEscrow, TEST_ESCROW);
+            assert.equal(key.depositLocalId, 40n);
+            assert.equal(key.depositChainId, 8453n);
+            assert.equal(key.paymentMethodId, TEST_PAYMENT_METHOD);
+            assert.equal(key.changeId, 0);
+        });
+        it('increments changeId correctly', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 40n,
+                chainId: 8453n,
+            };
+            const key0 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 0,
+            });
+            const key1 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 1,
+            });
+            const key2 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 2,
+            });
+            assert.equal(key0.changeId, 0);
+            assert.equal(key1.changeId, key0.changeId + 1);
+            assert.equal(key2.changeId, key1.changeId + 1);
+        });
+        it('creates different keys for different payment methods', () => {
+            const depositKey = {
+                escrow: TEST_ESCROW,
+                localId: 40n,
+                chainId: 8453n,
+            };
+            const pm1 = '0x1111111111111111111111111111111111111111111111111111111111111111';
+            const pm2 = '0x2222222222222222222222222222222222222222222222222222222222222222';
+            const key1 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: pm1,
+                changeId: 0,
+            });
+            const key2 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey,
+                paymentMethodId: pm2,
+                changeId: 0,
+            });
+            assert.notEqual(key1.paymentMethodId, key2.paymentMethodId);
+        });
+        it('creates different keys for different deposits', () => {
+            const depositKey1 = {
+                escrow: TEST_ESCROW,
+                localId: 1n,
+                chainId: 8453n,
+            };
+            const depositKey2 = {
+                escrow: TEST_ESCROW,
+                localId: 2n,
+                chainId: 8453n,
+            };
+            const key1 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey: depositKey1,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 0,
+            });
+            const key2 = makeDepositPaymentMethodActiveUpdatedKey({
+                depositKey: depositKey2,
+                paymentMethodId: TEST_PAYMENT_METHOD,
+                changeId: 0,
+            });
+            assert.notEqual(key1.depositLocalId, key2.depositLocalId);
+        });
+    });
+});

package/dist/src/endpoints.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Service endpoint URLs for the Provex platform.
+ *
+ * Each URL resolves at module load time using this priority:
+ * 1. Vite env (`import.meta.env.VITE_<NAME>`)
+ * 2. Node env (`process.env.<NAME>` or `process.env.VITE_<NAME>`)
+ * 3. Hardcoded production default
+ *
+ * Override any URL by setting the corresponding environment variable
+ * before the module is imported.
+ *
+ * @example
+ * // In .env or shell
+ * VITE_SPONSOR_SERVER_URL=http://localhost:3001
+ */
+/**
+ * Base URL for the gas-sponsorship relay server.
+ *
+ * The sponsor server wraps user operations in a sponsored transaction
+ * so end-users never need native gas tokens.
+ *
+ * @defaultValue `https://sponsor.provex.xyz`
+ */
+export declare const SPONSOR_SERVER_URL: string;
+/**
+ * WebSocket URL for the Reclaim Protocol attestor node.
+ *
+ * Used during the ZK proof generation flow to obtain a TLS attestation
+ * of payment-provider API responses.
+ *
+ * @defaultValue `wss://attestor.reclaimprotocol.org/ws`
+ */
+export declare const ATTESTOR_WS_URL: string;
+/**
+ * GraphQL endpoint for the Provex indexer.
+ *
+ * Serves deposit listings, intent history, and on-chain event data
+ * consumed by the UI and analytics dashboard.
+ *
+ * @defaultValue `https://indexer.provex.xyz/graphql`
+ */
+export declare const INDEXER_GRAPHQL_URL: string;
+/**
+ * Base URL for the attestation verification service.
+ *
+ * Validates TLS attestations produced by the attestor before they
+ * are submitted on-chain as proof of payment.
+ *
+ * @defaultValue `https://attestation.provex.xyz`
+ */
+export declare const ATTESTATION_SERVICE_URL: string;