tapimo 0.4.4 → 0.5.1

package/src/internal/Log.ts

@@ -12,6 +12,8 @@ export type Variables = {
   errorCode?: string | undefined
   /** Redacted provider failure details recorded by an upstream adapter. */
   providerFailure?: Entry['provider'] | undefined
+  /** Redacted provider failures when multiple upstream adapters fail. */
+  providerFailures?: Entry['providerFailures'] | undefined
 }
 
 /** Hono environment shape used by the request logger. */
@@ -28,6 +30,20 @@ export type Environment = {
 /** Log level, derived from the response status. */
 export type Level = 'error' | 'info' | 'warn'
 
+/** Redacted upstream provider failure details. */
+export type ProviderFailure = {
+  /** Stable provider error code, when one is safe to retain. */
+  code?: string | undefined
+  /** Failure boundary that rejected the provider request. */
+  failure: 'http' | 'network' | 'payload' | 'timeout' | 'unknown'
+  /** Provider identifier. */
+  id: string
+  /** Provider operation identifier. */
+  operation: string
+  /** Upstream HTTP status, when a response was received. */
+  status?: number | undefined
+}
+
 /** One canonical request log entry. */
 export type Entry = {
   /** `'hit'` when the edge response cache served the request without reaching the origin handlers. */
@@ -64,20 +80,9 @@ export type Entry = {
       }
     | undefined
   /** Redacted upstream provider failure details, when an adapter request fails. */
-  provider?:
-    | {
-        /** Stable provider error code, when one is safe to retain. */
-        code?: string | undefined
-        /** Failure boundary that rejected the provider request. */
-        failure: 'http' | 'network' | 'payload' | 'unknown'
-        /** Provider identifier. */
-        id: string
-        /** Provider operation identifier. */
-        operation: string
-        /** Upstream HTTP status, when a response was received. */
-        status?: number | undefined
-      }
-    | undefined
+  provider?: ProviderFailure | undefined
+  /** Redacted failures for every provider when multiple adapters fail. */
+  providerFailures?: readonly ProviderFailure[] | undefined
   /** Raw query string (no leading `?`) with API-key tokens redacted, when present. */
   query?: string | undefined
   /** Rate limit state from the `RateLimit-*` response headers, when enforced. */
@@ -136,6 +141,7 @@ export function middleware<environment extends Environment = Environment>(
     const principal = c.get('principal' as never) as Auth.Principal | undefined
     const errorCode = c.get('errorCode' as never) as string | undefined
     const provider = c.get('providerFailure' as never) as Entry['provider']
+    const providerFailures = c.get('providerFailures' as never) as Entry['providerFailures']
 
     // The `request` total metric duplicates `duration` (measured here, one
     // layer further out), so only operation timings are kept.
@@ -186,6 +192,7 @@ export function middleware<environment extends Environment = Environment>(
             },
           }),
       ...(provider === undefined ? {} : { provider }),
+      ...(providerFailures === undefined ? {} : { providerFailures }),
       ...(query ? { query } : {}),
       ...(rateLimit === undefined ? {} : { rateLimit }),
       requestId: c.get('requestId' as never) as string,

package/src/internal/Tidx.test.ts

@@ -203,6 +203,21 @@ describe('resolve', () => {
     `)
   })
 
+  test('resolves Bearer auth', () => {
+    expect(
+      Tidx.resolve(
+        { baseUrl: 'https://internal.indexer', bearerAuth: 'zone-secret' },
+        { chainId: 4217, principal: apiKeyPrincipal },
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "baseUrl": "https://internal.indexer",
+        "basicAuth": undefined,
+        "bearerAuth": "zone-secret",
+      }
+    `)
+  })
+
   test('the resolver form routes anonymous callers to a separate upstream', () => {
     const tidx = ({ principal }: Viem.resolve.Context) =>
       principal?.type === 'public'
@@ -243,6 +258,28 @@ describe('resolve', () => {
   })
 })
 
+describe('getClient', () => {
+  test('sends Bearer auth', async () => {
+    const fetch = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({ columns: [], ok: true, row_count: 0, rows: [] }), {
+        headers: { 'content-type': 'application/json' },
+      }),
+    )
+    try {
+      const client = Tidx.getClient({
+        chainId: 4217,
+        tidx: { baseUrl: 'https://internal.indexer', bearerAuth: 'zone-secret' },
+      })
+      await client.fetch({ query: 'select 1' })
+
+      const upstream = fetch.mock.calls[0]![0] as Request
+      expect(upstream.headers.get('authorization')).toBe('Bearer zone-secret')
+    } finally {
+      fetch.mockRestore()
+    }
+  })
+})
+
 describe('createGetClient', () => {
   test('memoizes one client per resolved upstream', () => {
     const getTidx = Tidx.createGetClient({
@@ -267,6 +304,17 @@ describe('createGetClient', () => {
     expect(getTidx(4217, null)).toBe(getTidx(4217, publicPrincipal))
   })
 
+  test('does not share clients across Bearer credentials', () => {
+    const getTidx = Tidx.createGetClient({
+      tidx: ({ principal }) => ({
+        baseUrl: 'https://internal.indexer',
+        bearerAuth: principal?.type === 'public' ? 'public-secret' : 'private-secret',
+      }),
+    })
+
+    expect(getTidx(4217, publicPrincipal)).not.toBe(getTidx(4217, apiKeyPrincipal))
+  })
+
   test('consults the resolver on every call but builds one client per upstream', () => {
     const seen: (string | undefined)[] = []
     const getTidx = Tidx.createGetClient({

package/src/internal/Tidx.ts

@@ -29,8 +29,8 @@ export type UrlResolver = (chainId: Viem.ChainId) => string | undefined
  * receives a {@link Viem.resolve.Context} (`chainId` plus the request
  * `principal`), so callers can route traffic per caller — e.g. send anonymous
  * (`principal.type === 'public'`) traffic to a separate, no-auth indexer. A
- * missing `baseUrl` falls back to the built-in public host map ({@link url}); a
- * missing `basicAuth` means no Basic auth is sent.
+ * missing `baseUrl` falls back to the built-in public host map ({@link url});
+ * missing auth fields send no Authorization header.
  */
 export function resolve(
   tidx: getClient.Tidx | undefined,
@@ -42,6 +42,7 @@ export function resolve(
       (typeof config?.baseUrl === 'function' ? config.baseUrl(context.chainId) : config?.baseUrl) ??
       url[context.chainId],
     basicAuth: config?.basicAuth,
+    ...(config?.bearerAuth ? { bearerAuth: config.bearerAuth } : {}),
   }
 }
 
@@ -56,13 +57,22 @@ export declare namespace resolve {
     baseUrl: string | undefined
     /** Basic auth credentials, or undefined to send no Basic auth. */
     basicAuth?: string | undefined
+    /** Bearer auth credential, or undefined to send no Bearer auth. */
+    bearerAuth?: string | undefined
   }
 }
 
 export function getClient(options: getClient.Options): Client {
   const { chainId = Viem.defaultChainId, principal = null, tidx } = options
-  const { baseUrl, basicAuth } = resolve(tidx, { chainId, principal })
-  return withTransientRetry(Tidx.create({ baseUrl, basicAuth, chainId }))
+  const { baseUrl, basicAuth, bearerAuth } = resolve(tidx, { chainId, principal })
+  return withTransientRetry(
+    Tidx.create({
+      baseUrl,
+      basicAuth,
+      bearerAuth,
+      chainId,
+    }),
+  )
 }
 
 /**
@@ -72,7 +82,7 @@ export function getClient(options: getClient.Options): Client {
  * output (`baseUrl` + `basicAuth` + `chainId`), not the principal, so a resolver
  * `tidx` may branch on any principal field while client cardinality stays
  * bounded by the number of distinct upstreams — callers that resolve to the same
- * upstream share a client. Shared by `App.create` (per-request reads) and
+ * upstream share a client. Shared by `data()` (per-request reads) and
  * `Webhooks.createPoller` (the scheduled poller) so the resolver logic lives in
  * one place.
  */
@@ -83,8 +93,8 @@ export function createGetClient(options: createGetClient.Options = {}): GetClien
   return (chainId = defaultChainId, principal = null) => {
     // Resolve to derive the cache key; `getClient` re-resolves to build the
     // client on a miss. `resolve` is pure and cheap, so the extra call is free.
-    const { baseUrl, basicAuth } = resolve(tidx, { chainId, principal })
-    const cacheKey = `${baseUrl}|${basicAuth ?? ''}|${chainId}`
+    const { baseUrl, basicAuth, bearerAuth } = resolve(tidx, { chainId, principal })
+    const cacheKey = `${baseUrl}|${basicAuth ?? ''}|${bearerAuth ?? ''}|${chainId}`
     const existing = clients.get(cacheKey)
     if (existing) return existing
 
@@ -218,12 +228,16 @@ export declare namespace getClient {
         baseUrl?: UrlResolver | string | undefined
         /** Basic auth credentials for TIDX requests. */
         basicAuth?: string | undefined
+        /** Bearer auth credential for TIDX requests. */
+        bearerAuth?: string | undefined
       }
     | ((context: Viem.resolve.Context) => {
         /** TIDX base URL to use; falls back to the built-in public host when omitted. */
         baseUrl?: string | undefined
         /** Basic auth credentials for TIDX requests, or undefined for none. */
         basicAuth?: string | undefined
+        /** Bearer auth credential for TIDX requests, or undefined for none. */
+        bearerAuth?: string | undefined
       })
 }
 

package/src/internal/Viem.test.ts

@@ -113,3 +113,49 @@ describe('resolve', () => {
     `)
   })
 })
+
+describe('createGetClient', () => {
+  test('memoizes one client per resolved upstream', () => {
+    const getClient = Viem.createGetClient({
+      rpc: ({ principal }) =>
+        principal?.type === 'public'
+          ? { url: 'https://rpc.tempo.xyz' }
+          : { basicAuth: 'user:pass', url: 'https://internal.rpc' },
+    })
+
+    expect(getClient(4217, apiKeyPrincipal)).toBe(getClient(4217, apiKeyPrincipal))
+    expect(getClient(4217, publicPrincipal)).toBe(getClient(4217, publicPrincipal))
+    expect(getClient(4217, publicPrincipal)).not.toBe(getClient(4217, apiKeyPrincipal))
+    expect(getClient(4217, apiKeyPrincipal)).not.toBe(getClient(42431, apiKeyPrincipal))
+  })
+
+  test('shares a client across principals when they resolve identically', () => {
+    const getClient = Viem.createGetClient()
+
+    expect(getClient(4217, publicPrincipal)).toBe(getClient(4217, apiKeyPrincipal))
+    expect(getClient(4217, null)).toBe(getClient(4217, publicPrincipal))
+  })
+
+  test('consults the resolver on cache hits', () => {
+    const seen: (string | undefined)[] = []
+    const getClient = Viem.createGetClient({
+      rpc: ({ principal }) => {
+        seen.push(principal?.type)
+        return { url: 'https://internal.rpc' }
+      },
+    })
+
+    const first = getClient(4217, apiKeyPrincipal)
+    const second = getClient(4217, apiKeyPrincipal)
+    getClient(4217, publicPrincipal)
+
+    expect(seen).toMatchInlineSnapshot(`
+      [
+        "api_key",
+        "api_key",
+        "public",
+      ]
+    `)
+    expect(first).toBe(second)
+  })
+})

package/src/internal/Viem.ts

@@ -1,3 +1,4 @@
+import { ZoneRpcAuthentication } from 'ox/tempo'
 import { createClient, http, publicActions } from 'viem'
 import type { Client as core_Client, HttpTransport, PublicActions } from 'viem'
 import { tempoActions } from 'viem/tempo'
@@ -57,7 +58,7 @@ export type UrlResolver = (chainId: ChainId) => string | undefined
  * webhook poller). A missing `url` falls back to the built-in public host map
  * ({@link url}); a missing `basicAuth` means no Basic auth is sent.
  *
- * Memoization is keyed on the resolved output (see `App.create` and
+ * Memoization is keyed on the resolved output (see {@link createGetClient} and
  * {@link Tidx.createGetClient}), not the context, so a resolver may branch on
  * any principal field without unbounded client cardinality: callers that
  * resolve to the same upstream share a client. Pass the result to
@@ -103,8 +104,17 @@ export declare namespace resolve {
 }
 
 export function getClient(options: getClient.Options): getClient.ReturnType {
-  const { chainId = defaultChainId, principal = null, rpc } = options
+  const { chainId = defaultChainId, principal = null, rpc, zoneToken } = options
   const { basicAuth, url: rpcUrl } = resolve(rpc, { chainId, principal })
+  const fetchOptions =
+    basicAuth || zoneToken
+      ? {
+          headers: {
+            ...(basicAuth ? { Authorization: `Basic ${btoa(basicAuth)}` } : {}),
+            ...(zoneToken ? { [ZoneRpcAuthentication.headerName]: zoneToken } : {}),
+          },
+        }
+      : undefined
 
   return createClient({
     // Auto-batch `eth_call`s within the same macrotask into a single
@@ -114,15 +124,45 @@ export function getClient(options: getClient.Options): getClient.ReturnType {
     // configure a deployed multicall3, can still serve the aggregated call.
     batch: { multicall: { deployless: true } },
     chain: { ...tempoMainnet, id: chainId },
-    transport: http(
-      rpcUrl,
-      basicAuth ? { fetchOptions: { headers: { Authorization: `Basic ${btoa(basicAuth)}` } } } : {},
-    ),
+    transport: http(rpcUrl, fetchOptions ? { fetchOptions } : {}),
   })
     .extend(publicActions)
     .extend(tempoActions())
 }
 
+/** Builds a memoized Tempo client resolver. */
+export function createGetClient(options: createGetClient.Options = {}): createGetClient.ReturnType {
+  const { defaultChainId: defaultChainId_option = defaultChainId, rpc } = options
+  const clients = new Map<string, getClient.ReturnType>()
+
+  return (chainId = defaultChainId_option, principal = null) => {
+    const { basicAuth, url } = resolve(rpc, { chainId, principal })
+    const cacheKey = JSON.stringify([url, basicAuth, chainId])
+    const existing = clients.get(cacheKey)
+    if (existing) return existing
+
+    const client = getClient({
+      chainId,
+      rpc: { basicAuth, url: () => url },
+    })
+    clients.set(cacheKey, client)
+    return client
+  }
+}
+
+export declare namespace createGetClient {
+  /** Options for building a memoized Tempo client resolver. */
+  type Options = {
+    /** Tempo chain id used when a caller omits one. */
+    defaultChainId?: ChainId | undefined
+    /** Tempo RPC options applied to every constructed client. */
+    rpc?: getClient.Rpc | undefined
+  }
+
+  /** Memoized Tempo client resolver. */
+  type ReturnType = (chainId?: ChainId, principal?: Auth.Principal | null) => getClient.ReturnType
+}
+
 export declare namespace getClient {
   /** Tempo viem client with public and Tempo action helpers. */
   type ReturnType = core_Client<
@@ -142,6 +182,8 @@ export declare namespace getClient {
     principal?: Auth.Principal | null | undefined
     /** Tempo RPC options. */
     rpc?: Rpc | undefined
+    /** Zone authorization token forwarded to the RPC node. */
+    zoneToken?: string | undefined
   }
 
   /**

package/src/internal/index.test.ts

@@ -9,7 +9,7 @@ test('exports internal modules', () => {
       "EdgeCache",
       "Errors",
       "Fees",
-      "FundingRoutes",
+      "FundingQuotes",
       "Id",
       "Log",
       "MetricSink",

package/src/internal/index.ts

@@ -4,7 +4,7 @@ export * as Cursor from './Cursor.js'
 export * as EdgeCache from './EdgeCache.js'
 export * as Errors from './Errors.js'
 export * as Fees from './Fees.js'
-export * as FundingRoutes from './FundingRoutes.js'
+export * as FundingQuotes from './FundingQuotes.js'
 export * as Id from './Id.js'
 export * as Log from './Log.js'
 export * as MetricSink from './MetricSink.js'

package/dist/apps/data/FundingRouteProviders.d.ts

@@ -1,36 +0,0 @@
-import * as FundingRoutes from '../../internal/FundingRoutes.js';
-type Fetch = typeof globalThis.fetch;
-/** Creates the live funding route adapters configured for this deployment. */
-export declare function createAdapters(options?: createAdapters.Options): {
-    relay: FundingRoutes.ProviderAdapter;
-} | {
-    relay?: never;
-};
-export declare namespace createAdapters {
-    /** Provider adapter factory options. Omit a provider to keep its routes static. */
-    type Options = {
-        /** Relay quote adapter options. */
-        relay?: relay.Options | false | undefined;
-    };
-}
-/** Creates a Relay quote adapter backed by `/chains/liquidity` and `/quote/v2`. */
-export declare function relay(options: relay.Options): FundingRoutes.ProviderAdapter;
-export declare namespace relay {
-    /** Relay quote adapter options. */
-    type Options = {
-        /** Probe wallet address required by Relay's quote API. */
-        userAddress: string;
-        /** Optional recipient override; defaults to `userAddress`. */
-        recipientAddress?: string | undefined;
-        /** Optional Relay API key for higher rate limits. */
-        apiKey?: string | undefined;
-        /** Override for tests or Relay testnet environments. */
-        baseUrl?: string | undefined;
-        /** Fetch implementation override for tests. */
-        fetch?: Fetch | undefined;
-        /** Clock override for deterministic tests. */
-        now?: (() => Date) | undefined;
-    };
-}
-export {};
-//# sourceMappingURL=FundingRouteProviders.d.ts.map

package/dist/apps/data/FundingRouteProviders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FundingRouteProviders.d.ts","sourceRoot":"","sources":["../../../src/apps/data/FundingRouteProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,iCAAiC,CAAA;AAEhE,KAAK,KAAK,GAAG,OAAO,UAAU,CAAC,KAAK,CAAA;AAMpC,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,OAAO,GAAE,cAAc,CAAC,OAAY;;;;EAIlE;AAED,MAAM,CAAC,OAAO,WAAW,cAAc,CAAC;IACtC,mFAAmF;IACnF,KAAK,OAAO,GAAG;QACb,mCAAmC;QACnC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,KAAK,GAAG,SAAS,CAAA;KAC1C,CAAA;CACF;AAED,mFAAmF;AACnF,wBAAgB,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,aAAa,CAAC,eAAe,CAkD3E;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,mCAAmC;IACnC,KAAK,OAAO,GAAG;QACb,0DAA0D;QAC1D,WAAW,EAAE,MAAM,CAAA;QACnB,8DAA8D;QAC9D,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACrC,qDAAqD;QACrD,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC3B,wDAAwD;QACxD,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC5B,+CAA+C;QAC/C,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;QACzB,8CAA8C;QAC9C,GAAG,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAA;KAC/B,CAAA;CACF"}

package/dist/apps/data/FundingRouteProviders.js

@@ -1,245 +0,0 @@
-import * as FundingRoutes from '../../internal/FundingRoutes.js';
-const defaultFetch = (input, init) => globalThis.fetch(input, init);
-const defaultRelayBaseUrl = 'https://api.relay.link';
-/** Creates the live funding route adapters configured for this deployment. */
-export function createAdapters(options = {}) {
-    return (options.relay ? { relay: relay(options.relay) } : {});
-}
-/** Creates a Relay quote adapter backed by `/chains/liquidity` and `/quote/v2`. */
-export function relay(options) {
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRelayBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    return {
-        async probeQuote({ route }, signal) {
-            const originChainId = providerChainId(route.sourceChain, 'relay');
-            const destinationChainId = eip155ChainId(route.destinationChain);
-            const headers = relayHeaders(options.apiKey);
-            try {
-                const quote = await requestJson(new URL(`${baseUrl}/quote/v2`), {
-                    body: {
-                        amount: route.sourceAmount.amount,
-                        destinationChainId: Number(destinationChainId),
-                        destinationCurrency: route.destinationToken.address,
-                        originChainId: Number(originChainId),
-                        originCurrency: route.sourceToken.address,
-                        recipient: options.recipientAddress ?? options.userAddress,
-                        tradeType: 'EXACT_INPUT',
-                        user: options.userAddress,
-                    },
-                    fetcher,
-                    headers,
-                    method: 'POST',
-                    signal,
-                });
-                const liquidityUrl = new URL(`${baseUrl}/chains/liquidity`);
-                liquidityUrl.searchParams.set('chainId', destinationChainId);
-                const liquidity = await requestJson(liquidityUrl, { fetcher, headers, signal }).catch(() => undefined);
-                return formatRelayResult(route, quote, liquidity, now());
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, [
-                    'NO_QUOTES',
-                    'NO_ROUTE',
-                    'UNSUPPORTED_ROUTE',
-                ]);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'relay:quote-v2',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-function formatRelayResult(route, quote, liquidity, now) {
-    const details = record(record(quote)['details']);
-    const currencyOut = record(details['currencyOut']);
-    const outputAmount = decimalString(currencyOut['amount']);
-    const liquidityRow = relayLiquidity(liquidity, route);
-    const destinationLiquidity = decimalString(liquidityRow?.['balance']);
-    const availableVolumeUsd = decimalString(liquidityRow?.['amountUsd']) ?? null;
-    const liquidityStatus = relayLiquidityStatus({ destinationLiquidity, outputAmount });
-    return {
-        limits: null,
-        minimumOutputAmount: decimalString(currencyOut['minimumAmount']),
-        outputAmount,
-        outputAmountFormatted: outputAmount
-            ? decimalFromBaseUnits(outputAmount, route.destinationToken.decimals)
-            : null,
-        quality: {
-            availableVolumeUsd: availableVolumeUsd,
-            estimatedSeconds: nonnegativeInteger(details['timeEstimate']),
-            feeBps: null,
-            historicalVolumeUsd24h: null,
-            instantVolumeUsd: availableVolumeUsd,
-            liquiditySource: 'providerQuote',
-            score: scoreFor(liquidityStatus.tier),
-            sourceDetail: 'relay:quote-v2',
-            tier: liquidityStatus.tier,
-        },
-        sampledAt: now.toISOString(),
-        status: liquidityStatus.status,
-    };
-}
-function relayLiquidityStatus(options) {
-    if (!options.outputAmount)
-        return { status: 'unknown', tier: 'unknown' };
-    if (!options.destinationLiquidity)
-        return { status: 'unknown', tier: 'unknown' };
-    if (compareIntegerStrings(options.destinationLiquidity, options.outputAmount) < 0)
-        return { status: 'thin', tier: 'thin' };
-    return { status: 'available', tier: 'liquid' };
-}
-function unavailableResult(options) {
-    return {
-        quality: {
-            availableVolumeUsd: null,
-            estimatedSeconds: null,
-            feeBps: null,
-            historicalVolumeUsd24h: null,
-            instantVolumeUsd: null,
-            liquiditySource: options.source,
-            score: 0,
-            sourceDetail: `${options.detail}:${options.message}`,
-            tier: 'unavailable',
-        },
-        sampledAt: options.now.toISOString(),
-        status: 'unavailable',
-    };
-}
-function relayLiquidity(input, route) {
-    const response = record(input);
-    const rows = Array.isArray(response['liquidity']) ? response['liquidity'] : [];
-    const destinationChainId = eip155ChainId(route.destinationChain);
-    return rows.map(record).find((row) => {
-        const rowChainId = integerString(row['chainId']);
-        const rowAddress = typeof row['address'] === 'string' ? row['address'].toLowerCase() : undefined;
-        return (rowChainId === destinationChainId &&
-            rowAddress === route.destinationToken.address.toLowerCase());
-    });
-}
-async function requestJson(url, options) {
-    const headers = { accept: 'application/json', ...options.headers };
-    const init = {
-        headers: options.body === undefined ? headers : { ...headers, 'content-type': 'application/json' },
-        method: options.method ?? 'GET',
-        signal: options.signal,
-    };
-    if (options.body !== undefined)
-        init.body = JSON.stringify(options.body);
-    const response = await options.fetcher(url, init);
-    const text = await response.text();
-    const body = parseJson(text);
-    if (!response.ok)
-        throw new ProviderResponseError(response.status, body);
-    return body;
-}
-function relayHeaders(apiKey) {
-    return apiKey ? { 'x-api-key': apiKey } : undefined;
-}
-function providerUnavailable(cause, codes) {
-    if (!(cause instanceof ProviderResponseError) || cause.status < 400 || cause.status >= 500)
-        return undefined;
-    const code = providerErrorCode(cause.body);
-    if (code && codes.includes(code))
-        return code;
-    return undefined;
-}
-function providerErrorCode(input) {
-    const body = record(input);
-    const code = stringValue(body['code']) ?? stringValue(body['errorCode']);
-    return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined;
-}
-class ProviderResponseError extends Error {
-    status;
-    body;
-    name = 'FundingRouteProviders.ProviderResponseError';
-    constructor(status, body) {
-        super(`Provider request failed with status ${status}`);
-        this.status = status;
-        this.body = body;
-    }
-}
-function providerChainId(routeChain, provider) {
-    const providerIds = routeChain.providerIds;
-    const id = providerIds?.[provider];
-    if (id && /^\d+$/.test(id))
-        return id;
-    return eip155ChainId(routeChain);
-}
-function eip155ChainId(chain) {
-    if (chain.kind !== 'evm')
-        throw new UnsupportedProviderRouteError();
-    const match = /^eip155:(\d+)$/.exec(chain.id);
-    if (!match?.[1])
-        throw new UnsupportedProviderRouteError();
-    return match[1];
-}
-class UnsupportedProviderRouteError extends Error {
-    name = 'FundingRouteProviders.UnsupportedProviderRouteError';
-}
-function normalizeBaseUrl(input) {
-    return input.replace(/\/+$/, '');
-}
-function parseJson(input) {
-    if (!input)
-        return null;
-    try {
-        return JSON.parse(input);
-    }
-    catch {
-        return input;
-    }
-}
-function record(input) {
-    return input && typeof input === 'object' && !Array.isArray(input)
-        ? input
-        : {};
-}
-function stringValue(input) {
-    return typeof input === 'string' && input.length > 0 ? input : undefined;
-}
-function decimalString(input) {
-    if (typeof input === 'string' && /^\d+(\.\d+)?$/.test(input))
-        return input;
-    if (typeof input === 'number' && Number.isFinite(input) && input >= 0)
-        return String(input);
-    return undefined;
-}
-function integerString(input) {
-    if (typeof input === 'string' && /^\d+$/.test(input))
-        return input;
-    if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0)
-        return String(input);
-    return undefined;
-}
-function nonnegativeInteger(input) {
-    if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0)
-        return input;
-    if (typeof input === 'string' && /^\d+$/.test(input))
-        return Number(input);
-    return null;
-}
-function decimalFromBaseUnits(baseUnits, decimals) {
-    const padded = baseUnits.padStart(decimals + 1, '0');
-    const whole = decimals === 0 ? padded : padded.slice(0, -decimals);
-    const fraction = decimals === 0 ? '' : padded.slice(-decimals).replace(/0+$/, '');
-    return fraction ? `${whole}.${fraction}` : whole;
-}
-function compareIntegerStrings(left, right) {
-    return BigInt(left) === BigInt(right) ? 0 : BigInt(left) > BigInt(right) ? 1 : -1;
-}
-function scoreFor(tier) {
-    if (tier === 'liquid')
-        return 90;
-    if (tier === 'thin')
-        return 65;
-    if (tier === 'unavailable')
-        return 0;
-    return null;
-}
-//# sourceMappingURL=FundingRouteProviders.js.map