tapimo 0.1.0 → 0.3.0

package/src/handlers/internal/multisig.ts

@@ -66,7 +66,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   const config = await resolveValidatedConfig({
     account: input.account,
     chainId: input.chainId,
-    genesisConfigId: input.genesisConfigId,
     init: input.init,
     pending,
     resolveConfig,
@@ -78,7 +77,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     })
   const initConfig = resolveInitConfig({
     config,
-    genesisConfigId: input.genesisConfigId,
     init: input.init,
     nonce: input.nonce,
     pending,
@@ -91,7 +89,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     claimExpiresAt: pending?.claimExpiresAt,
     config,
     createdAt: pending?.createdAt ?? now,
-    genesisConfigId: input.genesisConfigId,
     id: input.id,
     init: pending?.init || !!initConfig,
     initConfig,
@@ -106,7 +103,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   let approvals = getApprovals({
     account: input.account,
     config,
-    genesisConfigId: input.genesisConfigId,
     payload: input.payload,
     signatures: operation.signatures,
   })
@@ -121,7 +117,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     approvals = getApprovals({
       account: operation.account,
       config,
-      genesisConfigId: operation.genesisConfigId,
       payload: operation.payload,
       signatures: operation.signatures,
     })
@@ -136,14 +131,12 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   approvals = getApprovals({
     account: operation.account,
     config,
-    genesisConfigId: operation.genesisConfigId,
     payload: operation.payload,
     signatures: operation.signatures,
   })
   const client = getClient(operation.chainId)
   const final = await serializeFinal({
     account: operation.account,
-    genesisConfigId: operation.genesisConfigId,
     init: operation.initConfig ?? initConfig,
     signatures: approvals.signatures,
     transaction: input.transaction,
@@ -199,6 +192,7 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
           : undefined,
         getClient,
         method: broadcastMethod,
+        onSponsored: sponsor.onSponsored,
         request: { params: [final] },
         sender: operation.account,
         validate: sponsor.validate,
@@ -295,7 +289,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
   const config = await resolveValidatedConfig({
     account: operation.account,
     chainId: operation.chainId,
-    genesisConfigId: operation.genesisConfigId,
     pending: operation,
     resolveConfig: options.resolveConfig,
   })
@@ -303,7 +296,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
     return {
       account: operation.account,
       chainId: operation.chainId,
-      genesisConfigId: operation.genesisConfigId,
       id: operation.id,
       signatures: operation.signatures.length,
       status: operation.status,
@@ -312,7 +304,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
   const approvals = getApprovals({
     account: operation.account,
     config,
-    genesisConfigId: operation.genesisConfigId,
     payload: operation.payload,
     signatures: operation.signatures,
   })
@@ -339,7 +330,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
       const config = await resolveValidatedConfig({
         account: operation.account,
         chainId: operation.chainId,
-        genesisConfigId: operation.genesisConfigId,
         pending: operation,
         resolveConfig: options.resolveConfig,
       })
@@ -347,7 +337,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
         return {
           account: operation.account,
           chainId: operation.chainId,
-          genesisConfigId: operation.genesisConfigId,
           id: operation.id,
           signatures: operation.signatures.length,
           status: operation.status,
@@ -356,7 +345,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
       const approvals = getApprovals({
         account: operation.account,
         config,
-        genesisConfigId: operation.genesisConfigId,
         payload: operation.payload,
         signatures: operation.signatures,
       })
@@ -497,8 +485,6 @@ export type ResolveConfig = (request: {
   account: Address
   /** Transaction chain id. */
   chainId: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Bootstrap config carried by the transaction, when present. */
   init?: MultisigConfig.Config | undefined
 }) => MultisigConfig.Config | Promise<MultisigConfig.Config | undefined> | undefined
@@ -509,6 +495,8 @@ export type Sponsor = {
   account: LocalAccount
   /** Fee token to set before fee payer signing. */
   feeToken?: Address | undefined
+  /** Called once the fee payer has signed, before any broadcast. */
+  onSponsored?: Sponsorship.handleRawTransaction.Options['onSponsored']
   /** Resolves the default fee token for raw sponsorship. */
   resolveFeeToken?:
     | ((chainId: number) => Address | Promise<Address | undefined> | undefined)
@@ -570,8 +558,6 @@ export type Operation = {
   config?: MultisigConfig.Config | undefined
   /** Creation timestamp in milliseconds. */
   createdAt: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Deterministic operation id. */
   id: Hex.Hex
   /** Whether the finalized transaction must carry the genesis init config. */
@@ -598,8 +584,6 @@ export type Status = {
   account: Address
   /** Transaction chain id. */
   chainId: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Deterministic operation id. */
   id: Hex.Hex
   /** Number of collected owner approvals. */
@@ -627,7 +611,6 @@ function parse(serialized: Hex.Hex) {
   const chainId = Number(transaction['chainId'])
   const id = MultisigConfig.getSignPayload({
     account: signature.account,
-    genesisConfigId: signature.genesisConfigId,
     payload,
   })
   const init = signature.init ? MultisigConfig.from(signature.init) : undefined
@@ -636,7 +619,6 @@ function parse(serialized: Hex.Hex) {
   return {
     account: signature.account,
     chainId,
-    genesisConfigId: signature.genesisConfigId,
     id,
     init,
     nonce,
@@ -652,7 +634,6 @@ function isMultisigSignature(value: unknown): value is SignatureEnvelope.Multisi
     value !== null &&
     (value as { type?: unknown }).type === 'multisig' &&
     typeof (value as { account?: unknown }).account === 'string' &&
-    typeof (value as { genesisConfigId?: unknown }).genesisConfigId === 'string' &&
     Array.isArray((value as { signatures?: unknown }).signatures)
   )
 }
@@ -660,50 +641,39 @@ function isMultisigSignature(value: unknown): value is SignatureEnvelope.Multisi
 async function resolveValidatedConfig(options: {
   account: Address
   chainId: number
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   pending?: Operation | undefined
   resolveConfig?: ResolveConfig | undefined
 }) {
-  const { account, chainId, genesisConfigId, init, pending, resolveConfig } = options
-  const config =
-    (await resolveConfig?.({ account, chainId, genesisConfigId, init })) ?? pending?.config ?? init
+  const { account, chainId, init, pending, resolveConfig } = options
+  const config = (await resolveConfig?.({ account, chainId, init })) ?? pending?.config ?? init
   if (!config) return undefined
 
-  if (init && !isGenesisConfig(init, genesisConfigId))
-    throw new RpcResponse.InvalidParamsError({
-      message: 'Bootstrap multisig init config does not match genesis config id.',
-    })
-
   const normalized = MultisigConfig.from(config)
-  const account_expected = MultisigConfig.getAddress({ genesisConfigId })
-  if (account_expected.toLowerCase() !== account.toLowerCase())
+  if (
+    init &&
+    MultisigConfig.getAddress(MultisigConfig.from(init)).toLowerCase() !== account.toLowerCase()
+  )
     throw new RpcResponse.InvalidParamsError({
-      message: 'Resolved multisig config does not match account or genesis config id.',
+      message: 'Bootstrap multisig init config does not match the multisig account.',
     })
   return normalized
 }
 
 function resolveInitConfig(options: {
   config: MultisigConfig.Config
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   nonce?: number | undefined
   pending?: Operation | undefined
 }) {
-  const { config, genesisConfigId, init, nonce, pending } = options
+  const { config, init, nonce, pending } = options
   if (pending?.initConfig) return pending.initConfig
-  if (pending?.init && pending.config && isGenesisConfig(pending.config, genesisConfigId))
-    return pending.config
+  if (pending?.init && pending.config) return pending.config
   if (init) return init
-  if (nonce === 0 && isGenesisConfig(config, genesisConfigId)) return config
+  if (nonce === 0) return config
   return undefined
 }
 
-function isGenesisConfig(config: MultisigConfig.Config, genesisConfigId: Hex.Hex) {
-  return MultisigConfig.toId(config).toLowerCase() === genesisConfigId.toLowerCase()
-}
-
 function mergeSignatures(signatures: readonly Hex.Hex[]) {
   const seen = new Set<string>()
   const out: Hex.Hex[] = []
@@ -719,12 +689,11 @@ function mergeSignatures(signatures: readonly Hex.Hex[]) {
 function getApprovals(options: {
   account: Address
   config: MultisigConfig.Config
-  genesisConfigId: Hex.Hex
   payload: Hex.Hex
   signatures: readonly Hex.Hex[]
 }) {
-  const { account, config, genesisConfigId, payload } = options
-  const digest = MultisigConfig.getSignPayload({ account, genesisConfigId, payload })
+  const { account, config, payload } = options
+  const digest = MultisigConfig.getSignPayload({ account, payload })
   const owners = new Map(
     config.owners.map((owner) => [
       owner.owner.toLowerCase(),
@@ -764,7 +733,6 @@ function getApprovals(options: {
 
 async function serializeFinal(options: {
   account: Address
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   signatures: readonly Hex.Hex[]
   transaction: Record<string, unknown>
@@ -804,13 +772,11 @@ async function serializeFinal(options: {
   const signatures = options.signatures.map((approval) => SignatureEnvelope.from(approval))
   const sorted = SignatureEnvelope.sortMultisigApprovals({
     account: options.account,
-    genesisConfigId: options.genesisConfigId,
     payload,
     signatures,
   })
   const signature = SignatureEnvelope.from({
     account: options.account,
-    genesisConfigId: options.genesisConfigId,
     signatures: sorted,
     ...(options.init ? { init: options.init } : {}),
   })
@@ -847,7 +813,6 @@ function toStatus(options: {
   return {
     account: operation.account,
     chainId: operation.chainId,
-    genesisConfigId: operation.genesisConfigId,
     id: operation.id,
     signatures: approvals.signatures.length,
     status: operation.status,

package/src/handlers/internal/sponsorship.ts

@@ -1,4 +1,4 @@
-import { RpcResponse, Signature } from 'ox'
+import { Hash, type Hex, RpcResponse, Signature } from 'ox'
 import { TxEnvelopeTempo } from 'ox/tempo'
 import type { Address, Client } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
@@ -6,6 +6,34 @@ import { Transaction } from 'viem/tempo'
 
 import * as Utils from './utils.js'
 
+/**
+ * Sponsorship approval callback. The candidate always carries its `chainId`:
+ * raw submissions deserialize it, and fills validate only prepared/filled
+ * transactions. Anything but `true` refuses; raw submissions surface a named
+ * reason to the caller while fills fall back to an unsponsored fill.
+ */
+export type Validate = (
+  request: Transaction.TransactionRequest & { chainId?: number | Hex.Hex | undefined },
+) => Validation | Promise<Validation>
+
+/** A sponsorship verdict: `true` sponsors; `false` or a named reason refuses. */
+export type Validation =
+  | boolean
+  | 'billing_past_due'
+  | 'billing_required'
+  | 'fee_token_unsupported'
+  | 'spend_limit_exceeded'
+  | 'tx_fee_limit_exceeded'
+
+/** Refusal messages keyed by named validation reason. */
+const refusalMessages = {
+  billing_past_due: 'Billing past due.',
+  billing_required: 'Billing required.',
+  fee_token_unsupported: 'Fee token unsupported.',
+  spend_limit_exceeded: 'Spend limit exceeded.',
+  tx_fee_limit_exceeded: 'Transaction fee limit exceeded.',
+} as const satisfies Record<Exclude<Validation, boolean>, string>
+
 /** Returns sponsor metadata for `eth_fillTransaction` responses. */
 export function getSponsor(options: getSponsor.Options): getSponsor.ReturnType {
   const { account, name, url } = options
@@ -40,10 +68,13 @@ export declare namespace getSponsor {
 export async function shouldSponsor(options: shouldSponsor.Options) {
   const { sender, transaction, validate } = options
   if (!validate) return true
-  return await validate({
+  // Named refusal reasons collapse to false: fills fall back to an
+  // unsponsored fill instead of surfacing the reason.
+  const verdict = await validate({
     ...transaction,
     from: sender,
   } as Transaction.TransactionRequest)
+  return verdict === true
 }
 
 export declare namespace shouldSponsor {
@@ -53,7 +84,7 @@ export declare namespace shouldSponsor {
     /** Filled transaction to validate. */
     transaction: Record<string, unknown>
     /** Optional sponsorship approval callback. */
-    validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
+    validate?: Validate | undefined
   }
 }
 
@@ -88,13 +119,28 @@ export async function sign(options: sign.Options) {
     })
   if (!account.sign) throw new Error('Fee payer account cannot sign transactions.')
 
-  const feePayerSignature = Signature.from(
-    await account.sign({
-      hash: TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(prepared as never), {
-        sender: prepared.from,
-      }),
-    }),
-  )
+  const chainId = Utils.resolveChainId(transaction['chainId'])
+  if (chainId === undefined)
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Transaction chainId must be provided before fee payer signing.',
+    })
+
+  const envelope = TxEnvelopeTempo.from(prepared as never)
+  const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender: prepared.from })
+  const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }))
+
+  // Awaited before the signature leaves the relay: a fill-signed envelope can
+  // broadcast anywhere (even directly to a node), so the commitment records as
+  // an intent — no transaction hash until the sender signs.
+  const feeToken = transaction['feeToken'] as Address | null | undefined
+  await options.onSponsored?.({
+    chainId,
+    ...(feeToken ? { feeToken } : {}),
+    method: 'eth_fillTransaction',
+    sender: prepared.from,
+    signPayload,
+    transaction: TxEnvelopeTempo.serialize(envelope, { feePayerSignature }),
+  })
 
   return { ...prepared, feePayerSignature }
 }
@@ -103,6 +149,8 @@ export declare namespace sign {
   type Options = {
     /** Account used as the fee payer. */
     account: LocalAccount
+    /** Called once the fee payer has signed the fill. Awaited: a throw aborts the fill. */
+    onSponsored?: ((event: SponsoredEvent) => Promise<void> | void) | undefined
     /** Filled transaction to sign. */
     transaction: Record<string, unknown>
     /** Sender address from the original request. */
@@ -140,22 +188,36 @@ export async function handleRawTransaction(options: handleRawTransaction.Options
     feeToken_chain
   const transaction_sponsored = feeToken ? { ...transaction, feeToken } : transaction
 
-  if (validate && !(await validate(transaction_sponsored as Transaction.TransactionRequest)))
-    throw new RpcResponse.InvalidParamsError({
-      message: 'Sponsorship rejected.',
-    })
+  if (validate) {
+    const verdict = await validate(transaction_sponsored as Transaction.TransactionRequest)
+    if (verdict !== true)
+      throw new RpcResponse.InvalidParamsError(
+        verdict === false
+          ? { message: 'Sponsorship rejected.' }
+          : { data: { code: verdict }, message: refusalMessages[verdict] },
+      )
+  }
 
   const envelope = TxEnvelopeTempo.from(transaction_sponsored as never)
-  const feePayerSignature = Signature.from(
-    await account.sign({
-      hash: TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender }),
-    }),
-  )
+  const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender })
+  const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }))
   const serializedTransaction = TxEnvelopeTempo.serialize(envelope, {
     feePayerSignature,
     signature: transaction.signature,
   })
 
+  // Awaited before any broadcast so a recording failure refuses sponsorship —
+  // no sponsored transaction ever reaches the chain unrecorded.
+  await options.onSponsored?.({
+    chainId: transaction.chainId,
+    ...(feeToken ? { feeToken } : {}),
+    method,
+    sender,
+    signPayload,
+    transaction: serializedTransaction,
+    transactionHash: Hash.keccak256(serializedTransaction),
+  })
+
   // Raw-sign requests stop after fee-payer signature is added; send methods broadcast it.
   if (method === 'eth_signRawTransaction') return serializedTransaction
   return await client.request({
@@ -176,11 +238,35 @@ export declare namespace handleRawTransaction {
     getClient: (chainId?: number) => Client
     /** Raw transaction method to handle. */
     method: 'eth_signRawTransaction' | 'eth_sendRawTransaction' | 'eth_sendRawTransactionSync'
+    /** Called once the fee payer has signed, before any broadcast. Awaited: a throw aborts the request. */
+    onSponsored?: ((event: SponsoredEvent) => Promise<void> | void) | undefined
     /** Incoming JSON-RPC request. */
     request: { params?: readonly unknown[] | undefined }
     /** Sender address to use if it cannot be recovered from the raw envelope. */
     sender?: Address | undefined
     /** Optional sponsorship approval callback. */
-    validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
+    validate?: Validate | undefined
   }
 }
+
+/** Facts of one sponsorship commitment, emitted at fee-payer signing time. */
+export type SponsoredEvent = {
+  /** Chain the sponsored transaction targets. */
+  chainId: number
+  /** Fee token the sponsorship resolved, when known. */
+  feeToken?: Address | undefined
+  /** Method that triggered sponsorship: a fill (intent) or a raw submission. */
+  method:
+    | 'eth_fillTransaction'
+    | 'eth_signRawTransaction'
+    | 'eth_sendRawTransaction'
+    | 'eth_sendRawTransactionSync'
+  /** Transaction sender. */
+  sender: Address
+  /** Fee-payer sign payload — a stable identity for the sponsored envelope. */
+  signPayload: Hex.Hex
+  /** Serialized sponsored transaction (sender-unsigned for fill intents). */
+  transaction: Hex.Hex
+  /** Transaction hash (keccak256 of the signed envelope); absent for fill intents, whose senders have not signed yet. */
+  transactionHash?: Hex.Hex | undefined
+}

package/src/handlers/internal/utils.ts

@@ -80,18 +80,30 @@ export function normalizeTempoTransaction(value: Record<string, unknown> | undef
 
 /** Returns a raw JSON-RPC error response object (not wrapped in a `Response`). */
 export function rpcErrorJson(request: RpcRequest.RpcRequest, error: unknown) {
-  if (error instanceof RpcResponse.InvalidParamsError)
-    return RpcResponse.from({ error }, { request })
-
-  if (error instanceof RpcResponse.MethodNotSupportedError)
-    return RpcResponse.from({ error }, { request })
+  // Serialize error instances to plain objects: `Error.message` is
+  // non-enumerable, so instances stringify onto the wire without it.
+  if (
+    error instanceof RpcResponse.InvalidParamsError ||
+    error instanceof RpcResponse.MethodNotSupportedError
+  )
+    return RpcResponse.from(
+      {
+        error: {
+          code: error.code,
+          message: error.message,
+          ...(error.data !== undefined ? { data: error.data } : {}),
+        },
+      },
+      { request },
+    )
 
   if ((error as { name?: string | undefined }).name === 'ZodError')
     return RpcResponse.from(
       {
-        error: new RpcResponse.InvalidParamsError({
+        error: {
+          code: RpcResponse.InvalidParamsError.code,
           message: (error as Error).message,
-        }),
+        },
       },
       { request },
     )

package/src/handlers/{internal/relay.localnet.test.ts → relay.test.ts}

@@ -5,8 +5,8 @@ import { fillTransaction, sendTransactionSync } from 'viem/actions'
 import { Actions, Addresses, Capabilities, Tick, Transaction, VirtualAddress } from 'viem/tempo'
 import { tempo, tempoModerato } from 'viem/tempo/chains'
 
-import * as Relay from '../../../test/Relay.js'
-import * as Runtime from '../../../test/runtime.js'
+import * as Relay from '../../test/Relay.js'
+import * as Runtime from '../../test/runtime.js'
 
 type Server = Relay.Server
 

package/src/handlers/relay.ts

@@ -15,7 +15,7 @@ import {
 } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
 import { simulateCalls } from 'viem/actions'
-import { Abis, Actions, Addresses, Capabilities, Transaction, VirtualAddress } from 'viem/tempo'
+import { Abis, Actions, Addresses, Capabilities, VirtualAddress } from 'viem/tempo'
 
 import * as ExecutionError from './internal/executionError.js'
 import type * as RpcSchema from '../internal/RpcSchema.js'
@@ -150,6 +150,13 @@ export function relay(options: relay.Options): Handler {
 
           const { feePayer: _feePayer, ...normalized } =
             Utils.normalizeFillTransactionRequest(parameters)
+          const hasMultisigHints =
+            (typeof normalized['multisig'] === 'object' && normalized['multisig'] !== null) ||
+            (typeof normalized['multisigInit'] === 'object' &&
+              normalized['multisigInit'] !== null) ||
+            typeof normalized['multisigSignatureCount'] !== 'undefined'
+          const shouldDeferFeePayerSignature =
+            feePayerOptions && multisigOptions && hasMultisigHints
 
           // When sponsoring, the sponsor's preferred fee token (if set)
           // overrides whatever the consumer asked for — the sponsor is
@@ -362,9 +369,16 @@ export function relay(options: relay.Options): Handler {
             })(),
             // Sign as fee payer (if sponsored and not already signed).
             (async () => {
-              if (!(sponsored && feePayerOptions && !alreadySigned)) return transaction_filled
+              // Multisig finalization changes the sender signature. Sign after quorum.
+              if (shouldDeferFeePayerSignature) return transaction_filled
+              // Never sign with the managed fee payer for an app-provided
+              // external fee payer URL: that relay is the sponsorship authority,
+              // and signing here would bypass this fee payer's `validate` gate.
+              if (!(sponsored && feePayerOptions && !externalFeePayerUrl && !alreadySigned))
+                return transaction_filled
               return Sponsorship.sign({
                 account: feePayerOptions.account,
+                onSponsored: feePayerOptions.onSponsored,
                 sender: from,
                 transaction: transaction_filled,
               })
@@ -519,6 +533,7 @@ export function relay(options: relay.Options): Handler {
                 ? {
                     account: feePayerOptions.account,
                     feeToken: feePayerOptions.feeToken,
+                    onSponsored: feePayerOptions.onSponsored,
                     resolveFeeToken: async (chainId) => (await getTokens(chainId))[0],
                     validate: feePayerOptions.validate,
                   }
@@ -563,6 +578,7 @@ export function relay(options: relay.Options): Handler {
             getFeeToken: async (chainId) => (await getTokens(chainId))[0],
             getClient,
             method: request.method as Sponsorship.handleRawTransaction.Options['method'],
+            onSponsored: feePayerOptions.onSponsored,
             request: { params: 'params' in request ? request.params : undefined },
             validate: feePayerOptions.validate,
           })
@@ -660,13 +676,15 @@ export namespace relay {
           account: LocalAccount
           /** Preferred fee token the sponsor wants to pay fees in. */
           feeToken?: Address | undefined
+          /**
+           * Called once the fee payer has signed a raw transaction.
+           */
+          onSponsored?: Sponsorship.handleRawTransaction.Options['onSponsored']
           /**
            * Validates whether to sponsor the transaction. When omitted, all
            * transactions are sponsored. Return `false` to reject sponsorship.
            */
-          validate?:
-            | ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>)
-            | undefined
+          validate?: Sponsorship.Validate | undefined
           /** Sponsor display name returned from `eth_fillTransaction`. */
           name?: string | undefined
           /** Sponsor URL returned from `eth_fillTransaction`. */

package/src/index.ts

@@ -1,3 +1,4 @@
+export * as Analytics from './analytics/Analytics.js'
 export * as ApiKey from './ApiKey.js'
 export * as ApiKeys from './ApiKeys.js'
 export * as App from './App.js'