tapimo 0.10.0 → 0.10.2

package/src/internal/Webhooks.ts

@@ -3,6 +3,7 @@ import { Hash, Hex } from 'ox'
 import type * as app_Webhooks from '../apps/data/routes/webhooks.js'
 import type * as Db from '../db/Db.js'
 import * as WebhookDeliveries from '../db/tables/webhookDeliveries.js'
+import * as WebhookQueueEvents from '../db/tables/webhookQueueEvents.js'
 import * as WebhookSubscriptions from '../db/tables/webhookSubscriptions.js'
 import type * as Metrics from '../Metrics.js'
 import * as Cursor from './Cursor.js'
@@ -372,13 +373,20 @@ export async function maxCursorBlock(db: Db.Db, chainId: number): Promise<number
   )
   let max: number | null = null
   for (const cursor of cursors) {
-    const decoded = Cursor.decode(cursor, ['int', 'int']) ?? Cursor.decode(cursor, ['int'])
-    const block = decoded?.[0]
-    if (typeof block === 'number' && (max === null || block > max)) max = block
+    const block = cursorBlock(cursor)
+    if (block !== undefined && (max === null || block > max)) max = block
   }
   return max
 }
 
+/** Decodes the block component of a subscription cursor, if any. */
+export function cursorBlock(cursor: string | null): number | undefined {
+  if (cursor === null) return undefined
+  const decoded = Cursor.decode(cursor, ['int', 'int']) ?? Cursor.decode(cursor, ['int'])
+  const block = decoded?.[0]
+  return typeof block === 'number' ? block : undefined
+}
+
 /** Reads a subscription's keyset cursor. Returns null when unset. */
 export async function getCursor(db: Db.Db, subscriptionId: string): Promise<string | null> {
   return WebhookSubscriptions.getCursor(db, subscriptionId)
@@ -423,6 +431,7 @@ export async function setCursor(db: Db.Db, subscriptionId: string, cursor: strin
 export async function pruneExpired(db: Db.Db, options: pruneExpired.Options = {}): Promise<void> {
   const iso = (options.now ?? (() => new Date()))().toISOString()
   await WebhookDeliveries.pruneExpired(db, iso)
+  await WebhookQueueEvents.pruneExpired(db, iso)
   await WebhookSubscriptions.pruneExpired(db, iso)
 }
 
@@ -440,6 +449,263 @@ export declare namespace pruneExpired {
  */
 export const deliveryRetentionMs = 7 * 24 * 60 * 60 * 1_000
 
+/** A compact Cloudflare Queue message referencing a durable staged envelope. */
+export type QueueReference = {
+  /** Idempotent event id of the staged envelope. */
+  eventId: string
+  /** Subscription that owns the staged envelope. */
+  subscriptionId: string
+}
+
+/** A full envelope staged outside Cloudflare Queues. */
+export type QueueEvent = QueueReference & {
+  /** ISO timestamp when the envelope was staged. */
+  createdAt: string
+  /** Full envelope loaded by the Queue consumer. */
+  envelope: Envelope
+  /** ISO timestamp after which an unconsumed envelope may be pruned. */
+  expiresAt: string
+}
+
+/** A claim newer than this counts as an in-flight attempt; above the 10s destination timeout default. */
+export const deliveryAttemptStaleMs = 60_000
+
+/**
+ * Retry backoff by attempt count: 5s, 25s, ~2m, ~10m, ~52m, then hourly.
+ * Endpoint outages retry on this schedule until delivery or auto-disable.
+ */
+export function retryDelayMs(attemptCount: number): number {
+  return Math.min(5_000 * 5 ** Math.max(0, attemptCount - 1), 3_600_000)
+}
+
+/**
+ * Stages full envelopes as delivery obligations and returns compact
+ * references safe for Queue admission. Existing rows are left untouched, so
+ * the first staged envelope wins and terminal outcomes never resurrect.
+ */
+export async function ensureQueueEvents(
+  db: Db.Db,
+  dispatchables: readonly ensureQueueEvents.Dispatchable[],
+  options: ensureQueueEvents.Options = {},
+): Promise<ensureQueueEvents.Result> {
+  const now = (options.now ?? (() => new Date()))()
+  const expiresAt = new Date(now.getTime() + (options.ttl ?? deliveryRetentionMs)).toISOString()
+  const events = dispatchables.map(({ envelope, subscription }) => ({
+    createdAt: now.toISOString(),
+    envelope,
+    eventId: envelope.id,
+    // Inert while pending; the meaningful dedupe deadline is stamped at
+    // terminal transitions.
+    expiresAt,
+    // Due immediately; the value orders the sweep so it is never null here.
+    nextAttemptAt: now.toISOString(),
+    subscriptionId: subscription.id,
+  }))
+  return {
+    created: await WebhookQueueEvents.ensure(db, events),
+    references: events.map(({ eventId, subscriptionId }) => ({ eventId, subscriptionId })),
+  }
+}
+
+export declare namespace ensureQueueEvents {
+  /** One full envelope and the subscription that produced it. */
+  type Dispatchable = {
+    /** Webhook envelope. */
+    envelope: Envelope
+    /** Subscription that owns the envelope. */
+    subscription: Subscription
+  }
+
+  /** Staged-envelope retention options. */
+  type Options = {
+    /** Clock used for staging timestamps. */
+    now?: (() => Date) | undefined
+    /** Staged-envelope TTL in ms; defaults to {@link deliveryRetentionMs}. */
+    ttl?: number | undefined
+  }
+
+  /** Created-row count plus references for every requested obligation. */
+  type Result = {
+    /** Newly staged obligations. */
+    created: number
+    /** Compact references for all inputs, including pre-existing rows. */
+    references: QueueReference[]
+  }
+}
+
+/** Claims one due pending obligation; misses classify why the claim is unavailable. */
+export function claimQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+): Promise<WebhookQueueEvents.claim.Result> {
+  const now = new Date()
+  return WebhookQueueEvents.claim(db, reference, {
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/**
+ * Marks a claimed obligation terminal and restarts its retention window, so
+ * the dedupe row outlives replays. Fenced by the claim marker: a stale
+ * claimant's completion returns false instead of clobbering a newer claim.
+ */
+export function completeQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+  options: completeQueueEvent.Options,
+): Promise<boolean> {
+  return WebhookQueueEvents.complete(db, reference, {
+    ...options,
+    expiresAt: new Date(Date.now() + deliveryRetentionMs).toISOString(),
+  })
+}
+
+export declare namespace completeQueueEvent {
+  /** Fenced terminal transition. */
+  type Options = {
+    /** Claim marker from the claimed record's `attemptingAt`. */
+    claimedAt: string
+    /** Terminal obligation outcome. */
+    status: WebhookQueueEvents.TerminalStatus
+  }
+}
+
+/**
+ * Releases a claim and schedules the next attempt on the retry backoff.
+ * Fenced by the claim marker like {@link completeQueueEvent}.
+ */
+export function scheduleQueueEventRetry(
+  db: Db.Db,
+  reference: QueueReference,
+  options: scheduleQueueEventRetry.Options,
+): Promise<boolean> {
+  return WebhookQueueEvents.schedule(db, reference, {
+    claimedAt: options.claimedAt,
+    nextAttemptAt: new Date(Date.now() + retryDelayMs(options.attemptCount)).toISOString(),
+  })
+}
+
+export declare namespace scheduleQueueEventRetry {
+  /** Fenced retry scheduling. */
+  type Options = {
+    /** Attempts claimed so far; drives the backoff position. */
+    attemptCount: number
+    /** Claim marker from the claimed record's `attemptingAt`. */
+    claimedAt: string
+  }
+}
+
+/** Lists due pending references for the sweeper, oldest first. */
+export function dueQueueEvents(db: Db.Db, limit: number): Promise<QueueReference[]> {
+  const now = new Date()
+  return WebhookQueueEvents.due(db, {
+    limit,
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/** Returns the authoritative pending-obligation snapshot. */
+export function pendingQueueEvents(db: Db.Db): Promise<WebhookQueueEvents.pending.Result> {
+  const now = new Date()
+  return WebhookQueueEvents.pending(db, {
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/** Reads a full staged envelope for a compact Queue reference. */
+export async function getQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+): Promise<QueueEvent | null> {
+  return WebhookQueueEvents.get(db, reference)
+}
+
+/** Loads a staged envelope and delivers it with the subscription's current configuration. */
+export async function deliverQueueEventAndRecord(
+  db: Db.Db,
+  reference: QueueReference,
+  options: deliverAndRecord.Options = {},
+): Promise<deliverQueueEventAndRecord.Result> {
+  const dequeuedAt = Date.now()
+  const event = await getQueueEvent(db, reference)
+  if (!event) return { status: 'missing' }
+  return deliverClaimedAndRecord(db, event, { ...options, dequeuedAt })
+}
+
+/**
+ * Delivers an already-loaded obligation envelope with the subscription's
+ * current configuration, skipping the staged-row read a claim already paid.
+ */
+export async function deliverClaimedAndRecord(
+  db: Db.Db,
+  claimed: deliverClaimedAndRecord.Claimed,
+  options: deliverClaimedAndRecord.Options = {},
+): Promise<deliverClaimedAndRecord.Result> {
+  const dequeuedAt = options.dequeuedAt ?? Date.now()
+  const subscriptionReadStartedAt = Date.now()
+  const subscription = await WebhookSubscriptions.getById(
+    db,
+    claimed.subscriptionId,
+    new Date().toISOString(),
+  )
+  if (!subscription || subscription.status !== 'active') return { status: 'skipped' }
+  return {
+    result: await deliverAndRecord(db, subscription, claimed.envelope, {
+      ...options,
+      dequeuedAt,
+      subscriptionReadMs: Date.now() - subscriptionReadStartedAt,
+    }),
+    status: 'delivered',
+  }
+}
+
+export declare namespace deliverClaimedAndRecord {
+  /** Envelope and owning subscription id from a claimed obligation. */
+  type Claimed = {
+    /** Immutable event envelope to deliver. */
+    envelope: Envelope
+    /** Subscription re-resolved for current status and secret. */
+    subscriptionId: string
+  }
+
+  /** Delivery options plus the dequeue timestamp of the claiming path. */
+  type Options = deliverAndRecord.Options & {
+    /** Epoch ms the claiming message was dequeued; defaults to now. */
+    dequeuedAt?: number | undefined
+  }
+
+  /** A delivered event or an inactive subscription. */
+  type Result =
+    | {
+        /** Transport result from the current subscription state. */
+        result: WebhookDestination.Result
+        /** The envelope was delivered. */
+        status: 'delivered'
+      }
+    | {
+        /** The current subscription is inactive or deleted. */
+        status: 'skipped'
+      }
+}
+
+export declare namespace deliverQueueEventAndRecord {
+  /** A delivered event, inactive subscription, or stale duplicate reference. */
+  type Result =
+    | {
+        /** Transport result from the current subscription state. */
+        result: WebhookDestination.Result
+        /** The staged event was delivered. */
+        status: 'delivered'
+      }
+    | {
+        /** The staged event or current subscription was not deliverable. */
+        status: 'missing' | 'skipped'
+      }
+}
+
 /** Records one delivery-log row (stateful, owner-agnostic; scoped per subscription). */
 export async function recordDelivery(
   db: Db.Db,
@@ -587,13 +853,21 @@ export async function deliverAndRecord(
 ): Promise<WebhookDestination.Result> {
   const startedAt = Date.now()
   // Snapshot the attempt before recordSuccess/recordFailure mutate the counter.
-  const attempt = subscription.failureCount + 1
-  const result = await WebhookDestination.from(subscription.destination).deliver({
-    envelope,
-    secret: subscription.secret,
-    ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
-    ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-  })
+  const attempt = options.attempt ?? subscription.failureCount + 1
+  const result = await (async () => {
+    try {
+      return await WebhookDestination.from(subscription.destination).deliver({
+        envelope,
+        secret: subscription.secret,
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+      })
+    } catch {
+      // A formatting failure is a failed attempt, not an exception that bypasses
+      // subscription failure state and delivery metrics on every queue retry.
+      return { error: 'delivery failed before request', ok: false }
+    }
+  })()
   const stateWriteStartedAt = Date.now()
   if (result.ok) await recordSuccess(db, subscription, options)
   else await recordFailure(db, subscription, options)
@@ -625,6 +899,7 @@ export async function deliverAndRecord(
       queueAttempt: options.queueAttempt,
       result,
       subscription,
+      attempt,
       timings: {
         deliveryLogMs: completedAt - deliveryLogStartedAt,
         envelopeToQueueMs:
@@ -667,6 +942,12 @@ function eventTimestamp(envelope: Envelope): number | undefined {
 export declare namespace deliverAndRecord {
   /** Options for {@link deliverAndRecord}. */
   type Options = {
+    /**
+     * Delivery-log attempt number; the ledger claim count on the queue path.
+     * Defaults to the subscription failure counter, which concurrent
+     * deliveries can read stale.
+     */
+    attempt?: number | undefined
     /** Delivery-log row TTL in ms; defaults to {@link deliveryRetentionMs}. */
     deliveryRetentionMs?: number | undefined
     /** Queue dequeue time as epoch milliseconds, captured before subscription lookup. */

package/src/internal/funding/Provider.test.ts

@@ -13,7 +13,7 @@ const providers = [
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
+  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',

package/src/internal/funding/providers/index.test.ts

@@ -7,13 +7,15 @@ import * as Squid from './squid.js'
 import * as Symbiosis from './symbiosis.js'
 
 const now = () => new Date('2026-01-01T00:00:00.000Z')
+const evmUserAddress = TestFunding.relayQuoteUsers['eip155:4217']
+const solanaUserAddress = '7ZwiMrYFNCzZ4TcPkeMx7BTZSZ9jDgGR8H8Nkazhr6L1'
 const providers = [
   Across.across({
     apiKey: 'across-api-key',
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
+  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',
@@ -141,7 +143,7 @@ describe('funding providers', () => {
       apiKey: 'relay-api-key',
       fetch,
       now,
-      userAddress: '0x1111111111111111111111111111111111111111',
+      userAddresses: TestFunding.relayQuoteUsers,
     })
 
     const result = await provider.getQuote(getQuoteInput(candidate), new AbortController().signal)
@@ -192,6 +194,74 @@ describe('funding providers', () => {
     `)
   })
 
+  test('requires a Relay quote wallet for the source chain', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('relay', {
+      destinationToken: 'pathUSD',
+      sourceChain: 'solana',
+    })
+    const provider = Relay.relay({
+      fetch: recordingFetch(requests, async () => jsonResponse({})),
+      now,
+      userAddresses: { 'eip155:4217': evmUserAddress },
+    })
+
+    const result = await provider.getQuote(getQuoteInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(0)
+    expect(result).toMatchObject({
+      quality: {
+        sourceDetail: 'relay:quote-v2:QUOTE_USER_NOT_CONFIGURED',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  test('uses chain-specific Relay quote wallets', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('relay', {
+      destinationToken: 'pathUSD',
+      sourceChain: 'solana',
+    })
+    const fetch = recordingFetch(requests, async () =>
+      jsonResponse({
+        details: {
+          currencyOut: { amount: '990000', minimumAmount: '980000' },
+          timeEstimate: 15,
+        },
+      }),
+    )
+    const provider = Relay.relay({
+      fetch,
+      now,
+      userAddresses: {
+        'eip155:4217': evmUserAddress,
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': solanaUserAddress,
+      },
+    })
+
+    const result = await provider.getQuote(getQuoteInput(candidate), new AbortController().signal)
+
+    expect(jsonRequestBody(requests[0])).toMatchObject({
+      destinationChainId: 4217,
+      originChainId: 792703809,
+      recipient: evmUserAddress,
+      user: solanaUserAddress,
+    })
+    expect(result).toMatchObject({ status: 'available' })
+  })
+
+  test('rejects invalid chain-specific Relay quote wallets', () => {
+    expect(() =>
+      Relay.relay({
+        userAddresses: {
+          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': '0x1111111111111111111111111111111111111111',
+        },
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingProvider.ProviderConfigurationError]`)
+  })
+
   test('maps successful Squid quotes to available quote results', async () => {
     const requests: RecordedRequest[] = []
     const candidate = quoteCandidate('squid')
@@ -646,7 +716,7 @@ describe('funding providers', () => {
     try {
       const provider = Relay.relay({
         now,
-        userAddress: '0x1111111111111111111111111111111111111111',
+        userAddresses: TestFunding.relayQuoteUsers,
       })
       const result = await provider.getQuote(getQuoteInput(candidate), new AbortController().signal)
 

package/src/internal/funding/providers/relay.test.ts

@@ -123,7 +123,6 @@ describe.skipIf(!apiKey)('relay.prepareTransfer (live)', () => {
         requestBody = JSON.parse(init.body) as Record<string, unknown>
         return globalThis.fetch(input, init)
       },
-      userAddress: sender,
     })
     result = await provider.prepareTransfer!(prepareInput(provider), new AbortController().signal)
   })
@@ -172,7 +171,6 @@ describe.skipIf(!apiKey)('relay.createDepositAddress (live)', () => {
         return globalThis.fetch(input, init)
       },
       subsidies: { maxAmount: '100' },
-      userAddress: sender,
     })
     result = await provider.createDepositAddress!(
       { ...depositAddressInput(provider), subsidize: true },
@@ -410,9 +408,7 @@ describe('relay.createDepositAddress', () => {
 
 describe('relay.prepareTransfer', () => {
   test('refuses methods and modes it cannot prepare', async () => {
-    const provider = Relay.relay({
-      userAddress: sender,
-    })
+    const provider = Relay.relay()
     await expect(
       provider.prepareTransfer!(
         { ...prepareInput(provider), method: 'depositAddress' },

package/src/internal/funding/providers/relay.ts

@@ -1,4 +1,4 @@
-import { AbiEvent, AbiFunction, Address, Hash, Hex, RpcTransport } from 'ox'
+import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex, RpcTransport } from 'ox'
 import { createClient, custom, fallback } from 'viem'
 import { getBlockNumber, getLogs, getTransaction, getTransactionReceipt } from 'viem/actions'
 import * as z from 'zod/mini'
@@ -253,11 +253,9 @@ export function parseDepositAddressRequests(value: unknown) {
 
 /** Creates a Relay funding provider backed by `/quote/v2`. */
 export function relay(options: relay.Options = {}): FundingProvider.Provider<'relay'> {
+  const userAddresses = parseUserAddresses(options.userAddresses)
   if (
-    (options.userAddress !== undefined &&
-      !Address.validate(options.userAddress, { strict: false })) ||
-    (options.recipientAddress !== undefined &&
-      !Address.validate(options.recipientAddress, { strict: false }))
+    Object.entries(userAddresses).some(([chainId, address]) => invalidUserAddress(chainId, address))
   )
     throw new FundingProvider.ProviderConfigurationError()
 
@@ -411,13 +409,22 @@ export function relay(options: relay.Options = {}): FundingProvider.Provider<'re
       }
     },
     async getQuote({ candidate, route }, signal) {
-      if (options.userAddress === undefined)
+      const userAddress = userAddresses[route.source.chain.id]
+      if (userAddress === undefined)
         return FundingProvider.unavailableResult({
           detail: 'relay:quote-v2',
           message: 'QUOTE_USER_NOT_CONFIGURED',
           now: now(),
           source: 'providerQuote',
         })
+      const recipientAddress = userAddresses[route.destination.chain.id]
+      if (recipientAddress === undefined)
+        return FundingProvider.unavailableResult({
+          detail: 'relay:quote-v2',
+          message: 'QUOTE_RECIPIENT_NOT_CONFIGURED',
+          now: now(),
+          source: 'providerQuote',
+        })
       const destinationChainId = relayChainId(route.destination.chain)
       const sourceChainId = relayChainId(route.source.chain)
       try {
@@ -428,9 +435,9 @@ export function relay(options: relay.Options = {}): FundingProvider.Provider<'re
             destinationCurrency: candidate.destinationToken.address,
             originChainId: sourceChainId,
             originCurrency: candidate.sourceToken.address,
-            recipient: options.recipientAddress ?? options.userAddress,
+            recipient: recipientAddress,
             tradeType: 'EXACT_INPUT',
-            user: options.userAddress,
+            user: userAddress,
           },
           fetch,
           headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
@@ -621,12 +628,10 @@ export declare namespace relay {
     now?: (() => Date) | undefined
     /** EVM chain evidence used to accelerate authenticated provider delivery. */
     observation?: Observation | undefined
-    /** Optional recipient override; defaults to `userAddress`. */
-    recipientAddress?: string | undefined
     /** Deposit subsidy policy enabled for this integration. */
     subsidies?: Subsidy.Policy | undefined
-    /** Optional wallet address for indicative quotes. */
-    userAddress?: string | undefined
+    /** Optional source and destination quote wallets keyed by CAIP-2 chain id. */
+    userAddresses?: Readonly<Partial<Record<FundingChain.Id, string>>> | string | undefined
     /** Tempo infrastructure used to receive authenticated Relay webhooks. */
     webhook?: Webhook | undefined
   }
@@ -662,6 +667,45 @@ export declare namespace relay {
     | 'unknown_address'
 }
 
+function parseUserAddresses(value: relay.Options['userAddresses']) {
+  if (!value) return {}
+  const addresses =
+    typeof value === 'string'
+      ? (() => {
+          try {
+            return JSON.parse(value) as unknown
+          } catch {
+            throw new FundingProvider.ProviderConfigurationError()
+          }
+        })()
+      : value
+  if (!addresses || typeof addresses !== 'object' || Array.isArray(addresses))
+    throw new FundingProvider.ProviderConfigurationError()
+  return addresses as Readonly<Partial<Record<FundingChain.Id, string>>>
+}
+
+function invalidUserAddress(chainId: string, address: unknown) {
+  if (typeof address !== 'string') return true
+  if (/^eip155:\d+$/.test(chainId)) return !Address.validate(address, { strict: false })
+  if (/^solana:[1-9A-HJ-NP-Za-km-z]+$/.test(chainId)) {
+    try {
+      return Base58.toBytes(address).length !== 32
+    } catch {
+      return true
+    }
+  }
+  if (!/^tron:0x[0-9a-fA-F]+$/.test(chainId)) return true
+  try {
+    const bytes = Base58.toBytes(address)
+    if (bytes.length !== 25 || bytes[0] !== 0x41) return true
+    const payload = bytes.slice(0, 21)
+    const checksum = Hash.sha256(Hash.sha256(payload), { as: 'Bytes' }).slice(0, 4)
+    return !Bytes.isEqual(bytes.slice(21), checksum)
+  } catch {
+    return true
+  }
+}
+
 type DepositAddressObserverOptions = relay.Observation & {
   apiKey?: string | undefined
   baseUrl?: string | undefined

package/src/internal/index.test.ts

@@ -5,6 +5,7 @@ test('exports internal modules', () => {
     [
       "Auth",
       "Cache",
+      "Credential",
       "Cursor",
       "EdgeCache",
       "EarnVaults",

package/src/internal/index.ts

@@ -1,5 +1,6 @@
 export * as Auth from './Auth.js'
 export * as Cache from './Cache.js'
+export * as Credential from './Credential.js'
 export * as Cursor from './Cursor.js'
 export * as EdgeCache from './EdgeCache.js'
 export * as EarnVaults from './EarnVaults.js'