@provex/utils 1.0.16 → 1.2.4

package/dist/deposit.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @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/deposit.js

@@ -0,0 +1,52 @@
+/**
+ * @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/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/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/depositKeys.test.d.ts

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

package/dist/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/events.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Event type definitions for the Provex indexer.
+ *
+ * This module defines all blockchain event types in their display order.
+ * The order determines how events are sorted in the UI when viewing
+ * deposit history - deposit creation events come first, followed by
+ * intent events, then close/withdrawal events.
+ *
+ * @remarks
+ * The eventOrderId map assigns each event a numeric ID used in orderId
+ * serialization for consistent cross-chain ordering.
+ *
+ * @see {@link ids} for orderId serialization
+ * @see {@link indexer} for event handlers
+ */
+/**
+ * Ordered list of all event types supported by the indexer.
+ * The order determines the display sort priority in the UI.
+ *
+ * Event categories:
+ * 1. Deposit open events (creation, configuration)
+ * 2. Intent lifecycle events (signal, lock, verify, fulfill)
+ * 3. Deposit close events (withdrawal, close)
+ * 4. Protocol configuration events (dust, fees, registries)
+ */
+export declare const eventOrder: readonly ["deposit_received", "deposit_payment_method_added", "deposit_payment_method_active_updated", "deposit_currency_added", "deposit_delegate_set", "deposit_delegate_removed", "deposit_conversion_rate_updated", "deposit_accepting_intents_updated", "deposit_intent_amount_range_updated", "deposit_funds_added", "intent_signaled", "funds_locked", "payment_verified", "funds_unlocked_and_transferred", "intent_fulfilled", "intent_pruned", "funds_unlocked", "intent_expiry_extended", "funds_removed", "deposit_withdrawn", "deposit_closed", "dust_collected", "dust_recipient_updated", "dust_threshold_updated", "deposit_retain_on_empty_updated", "payment_method_currency_added", "payment_method_currency_removed", "payment_method_added", "payment_method_removed", "allow_multiple_intents_updated", "escrow_registry_updated", "post_intent_hook_registry_updated", "protocol_fee_recipient_updated", "protocol_fee_updated", "relayer_registry_updated", "unpaused", "paused", "intent_expiration_period_updated", "max_intents_per_deposit_updated", "min_deposit_amount_set", "orchestrator_updated", "ownership_transferred", "payment_verifier_registry_updated", "provider_hash_added", "provider_hash_removed"];
+/**
+ * Union type of all valid event type names.
+ * Use this when filtering or handling specific event types.
+ */
+export type EventType = (typeof eventOrder)[number];
+/**
+ * Map from event type name to its numeric order ID.
+ * Used in orderId serialization to maintain consistent ordering.
+ *
+ * @example
+ * ```ts
+ * const id = eventOrderId.get('intent_signaled') // 9
+ * ```
+ */
+export declare const eventOrderId: Map<"paused" | "deposit_received" | "deposit_payment_method_added" | "deposit_payment_method_active_updated" | "deposit_currency_added" | "deposit_delegate_set" | "deposit_delegate_removed" | "deposit_conversion_rate_updated" | "deposit_accepting_intents_updated" | "deposit_intent_amount_range_updated" | "deposit_funds_added" | "intent_signaled" | "funds_locked" | "payment_verified" | "funds_unlocked_and_transferred" | "intent_fulfilled" | "intent_pruned" | "funds_unlocked" | "intent_expiry_extended" | "funds_removed" | "deposit_withdrawn" | "deposit_closed" | "dust_collected" | "dust_recipient_updated" | "dust_threshold_updated" | "deposit_retain_on_empty_updated" | "payment_method_currency_added" | "payment_method_currency_removed" | "payment_method_added" | "payment_method_removed" | "allow_multiple_intents_updated" | "escrow_registry_updated" | "post_intent_hook_registry_updated" | "protocol_fee_recipient_updated" | "protocol_fee_updated" | "relayer_registry_updated" | "unpaused" | "intent_expiration_period_updated" | "max_intents_per_deposit_updated" | "min_deposit_amount_set" | "orchestrator_updated" | "ownership_transferred" | "payment_verifier_registry_updated" | "provider_hash_added" | "provider_hash_removed", number>;