tapimo 0.0.0 → 0.0.2

package/src/internal/Viem.test.ts

@@ -0,0 +1,115 @@
+import type * as Auth from './Auth.js'
+import * as Viem from './Viem.js'
+
+/** Anonymous (public) request principal. */
+const publicPrincipal: Auth.Principal = { id: 'pub', type: 'public' }
+/** Authenticated API-key request principal. */
+const apiKeyPrincipal: Auth.Principal = {
+  apiKey: {} as never,
+  environment: 'production',
+  id: 'key_test',
+  orgId: 'org_test',
+  type: 'api_key',
+}
+
+describe('isMainnet', () => {
+  test('is true only for the mainnet chain id', () => {
+    expect(Viem.isMainnet(Viem.chainId.mainnet)).toBe(true)
+    expect(Viem.isMainnet(Viem.chainId.testnet)).toBe(false)
+    expect(Viem.isMainnet(31337)).toBe(false)
+  })
+
+  test('mainnet is the default chain', () => {
+    expect(Viem.defaultChainId).toBe(Viem.chainId.mainnet)
+  })
+})
+
+describe('resolve', () => {
+  test('defaults to the per-chain RPC URL', () => {
+    expect(Viem.resolve(undefined, { chainId: 4217, principal: null })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": undefined,
+        "url": "https://rpc.tempo.xyz",
+      }
+    `)
+    expect(Viem.resolve(undefined, { chainId: 42431, principal: null })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": undefined,
+        "url": "https://rpc.testnet.tempo.xyz",
+      }
+    `)
+  })
+
+  test('uses a static config override', () => {
+    expect(
+      Viem.resolve(
+        { basicAuth: 'user:pass', url: (chainId) => `https://${chainId}.rpc.test` },
+        { chainId: 4217, principal: null },
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "basicAuth": "user:pass",
+        "url": "https://4217.rpc.test",
+      }
+    `)
+  })
+
+  test('the static form ignores the principal', () => {
+    const rpc = { basicAuth: 'user:pass', url: () => 'https://internal.rpc' }
+    expect(Viem.resolve(rpc, { chainId: 4217, principal: publicPrincipal })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": "user:pass",
+        "url": "https://internal.rpc",
+      }
+    `)
+    expect(Viem.resolve(rpc, { chainId: 4217, principal: apiKeyPrincipal })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": "user:pass",
+        "url": "https://internal.rpc",
+      }
+    `)
+  })
+
+  test('the resolver form routes anonymous callers to a separate upstream', () => {
+    const rpc = ({ principal }: Viem.resolve.Context) =>
+      principal?.type === 'public'
+        ? { url: 'https://rpc.tempo.xyz' }
+        : { basicAuth: 'user:pass', url: 'https://internal.rpc' }
+    expect(Viem.resolve(rpc, { chainId: 4217, principal: publicPrincipal })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": undefined,
+        "url": "https://rpc.tempo.xyz",
+      }
+    `)
+    expect(Viem.resolve(rpc, { chainId: 4217, principal: apiKeyPrincipal })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": "user:pass",
+        "url": "https://internal.rpc",
+      }
+    `)
+  })
+
+  test('a null principal (trusted poller) takes the non-public branch', () => {
+    const rpc = ({ principal }: Viem.resolve.Context) =>
+      principal?.type === 'public'
+        ? { url: 'https://rpc.tempo.xyz' }
+        : { basicAuth: 'user:pass', url: 'https://internal.rpc' }
+    expect(Viem.resolve(rpc, { chainId: 4217, principal: null })).toMatchInlineSnapshot(`
+      {
+        "basicAuth": "user:pass",
+        "url": "https://internal.rpc",
+      }
+    `)
+  })
+
+  test('a resolver that omits url falls back to the built-in public host', () => {
+    const rpc = () => ({})
+    expect(Viem.resolve(rpc, { chainId: 42431, principal: publicPrincipal }))
+      .toMatchInlineSnapshot(`
+      {
+        "basicAuth": undefined,
+        "url": "https://rpc.testnet.tempo.xyz",
+      }
+    `)
+  })
+})

package/src/internal/Viem.ts

@@ -0,0 +1,165 @@
+import { createClient, http, publicActions } from 'viem'
+import type { Client as core_Client, HttpTransport, PublicActions } from 'viem'
+import { tempoActions } from 'viem/tempo'
+import type { TempoActions } from 'viem/tempo'
+import { tempoMainnet, tempoTestnet } from 'viem/tempo/chains'
+import type * as z from 'zod/mini'
+
+import type * as Auth from './Auth.js'
+import type * as Schema from './Schema.js'
+
+/** Known Tempo chains keyed by id, for metadata lookups. */
+export const chains = [tempoMainnet, tempoTestnet]
+
+/** Tempo chain ids keyed by network. */
+export const chainId = {
+  mainnet: tempoMainnet.id,
+  testnet: tempoTestnet.id,
+} as const
+
+/** Default Tempo chain id. */
+export const defaultChainId = chainId.mainnet
+
+/** Whether a chain id is Tempo mainnet. */
+export function isMainnet(id: number): boolean {
+  return id === chainId.mainnet
+}
+
+/** Default Tempo RPC URLs keyed by chain id. */
+export const url: Record<number, string> = {
+  [chainId.mainnet]: 'https://rpc.tempo.xyz',
+  [chainId.testnet]: 'https://rpc.testnet.tempo.xyz',
+}
+
+/** Tempo chain id. */
+export type ChainId = z.output<typeof Schema.ChainId>
+
+/** Tempo chain metadata with a configurable chain id. */
+export type Chain = Omit<typeof tempoMainnet, 'id'> & { id: ChainId }
+
+/** Gets a Tempo viem client for a chain id. */
+export type GetClient = (chainId?: ChainId) => getClient.ReturnType
+
+/**
+ * Resolves an RPC URL for a Tempo chain id. May return `undefined` to fall back
+ * to the built-in {@link url} map (e.g. for a chain the resolver doesn't serve).
+ */
+export type UrlResolver = (chainId: ChainId) => string | undefined
+
+/**
+ * Resolves the effective RPC config for a single request.
+ *
+ * Accepts either a static config object or a per-request resolver function. The
+ * resolver receives a {@link 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 upstream. A
+ * `null` principal denotes a trusted, non-request caller (the scheduled
+ * 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
+ * {@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
+ * {@link getClient} (or let `getClient` resolve for you) to build a client.
+ */
+export function resolve(
+  rpc: getClient.Rpc | undefined,
+  context: resolve.Context,
+): resolve.Resolved {
+  const config = typeof rpc === 'function' ? rpc(context) : rpc
+  return {
+    basicAuth: config?.basicAuth,
+    url:
+      (typeof config?.url === 'function' ? config.url(context.chainId) : config?.url) ??
+      url[context.chainId],
+  }
+}
+
+export declare namespace resolve {
+  /** RPC resolution context. */
+  type Context = {
+    /** Tempo chain id. */
+    chainId: ChainId
+    /**
+     * Request principal, or `null` for a trusted non-request caller (the
+     * scheduled webhook poller). Anonymous and MPP-paid public requests carry a
+     * `type: 'public'` principal; authenticated requests a `type: 'api_key'` one.
+     */
+    principal: Auth.Principal | null
+  }
+
+  /** Resolved RPC config for a single request. */
+  type Resolved = {
+    /** Basic auth credentials, or undefined to send no Basic auth. */
+    basicAuth?: string | undefined
+    /**
+     * Resolved RPC URL, or `undefined` when neither a configured `rpc` nor the
+     * built-in {@link url} map covers the chain (e.g. an unconfigured localnet).
+     * A `undefined` URL falls through to viem's chain default transport.
+     */
+    url: string | undefined
+  }
+}
+
+export function getClient(options: getClient.Options): getClient.ReturnType {
+  const { chainId = defaultChainId, principal = null, rpc } = options
+  const { basicAuth, url: rpcUrl } = resolve(rpc, { chainId, principal })
+
+  return createClient({
+    // Auto-batch `eth_call`s within the same macrotask into a single
+    // deployless multicall. Lets call sites issue `Promise.all` of N reads
+    // (e.g. `balanceOf` across many tokens) and pay one RPC round-trip.
+    // Deployless mode bytecode-injects multicall3 so Tempo, which doesn't
+    // 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)}` } } } : {},
+    ),
+  })
+    .extend(publicActions)
+    .extend(tempoActions())
+}
+
+export declare namespace getClient {
+  /** Tempo viem client with public and Tempo action helpers. */
+  type ReturnType = core_Client<
+    HttpTransport,
+    Chain,
+    undefined,
+    undefined,
+    // Omit core's ERC-20 `token` namespace; `tempoActions` shadows it at runtime.
+    Omit<PublicActions<HttpTransport, Chain, undefined>, 'token'> & TempoActions<Chain, undefined>
+  >
+
+  /** Options for getting a Tempo viem client. */
+  type Options = {
+    /** Tempo chain id. */
+    chainId?: ChainId | undefined
+    /** Request principal, or `null`/omitted for a trusted non-request caller. */
+    principal?: Auth.Principal | null | undefined
+    /** Tempo RPC options. */
+    rpc?: Rpc | undefined
+  }
+
+  /**
+   * Tempo RPC options: either a static config, or a per-request resolver
+   * function that receives a {@link resolve.Context} and returns the config to
+   * use (e.g. routing anonymous callers to a public, no-auth RPC).
+   */
+  type Rpc =
+    | {
+        /** Basic auth credentials for RPC requests. */
+        basicAuth?: string | undefined
+        /** Resolves the RPC URL for a Tempo chain id. */
+        url?: UrlResolver | undefined
+      }
+    | ((context: resolve.Context) => {
+        /** Basic auth credentials for RPC requests, or undefined for none. */
+        basicAuth?: string | undefined
+        /** RPC URL to use; falls back to the built-in public host when omitted. */
+        url?: string | undefined
+      })
+}