tapimo 0.14.0 → 0.15.1

package/src/handlers/relay.ts

@@ -15,7 +15,14 @@ import {
 } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
 import { simulateCalls } from 'viem/actions'
-import { Abis, Actions, Addresses, Capabilities, VirtualAddress } from 'viem/tempo'
+import {
+  Abis,
+  Actions,
+  Addresses,
+  Capabilities,
+  Multisig as ViemMultisig,
+  VirtualAddress,
+} from 'viem/tempo'
 import { tempoMainnet, tempoTestnet } from 'viem/tempo/chains'
 
 import * as ExecutionError from './internal/executionError.js'
@@ -28,6 +35,17 @@ import * as Sponsorship from './internal/sponsorship.js'
 import * as Utils from './internal/utils.js'
 
 const defaultChains = [tempoMainnet, tempoTestnet] as const
+const multisigMethods = new Set([
+  'eth_getTransactionByHash',
+  'eth_getTransactionReceipt',
+  'eth_sendRawTransaction',
+  'eth_sendRawTransactionSync',
+  'multisig_approveKeyAuthorization',
+  'multisig_approveRawTransaction',
+  'multisig_approveRawTransactionSync',
+  'multisig_getConfig',
+  'multisig_getOperation',
+])
 
 /**
  * Instantiates a relay handler that proxies `eth_fillTransaction`
@@ -36,7 +54,7 @@ const defaultChains = [tempoMainnet, tempoTestnet] as const
  *
  * @example
  * ```ts
- * import { Handler } from 'tapimo'
+ * import { Handler } from 'tapimo/server'
  *
  * const handler = Handler.relay({ apiKey: process.env.TEMPO_API_KEY })
  *
@@ -55,7 +73,7 @@ const defaultChains = [tempoMainnet, tempoTestnet] as const
  *
  * ```ts
  * import { privateKeyToAccount } from 'viem/accounts'
- * import { Handler } from 'tapimo'
+ * import { Handler } from 'tapimo/server'
  *
  * const handler = Handler.relay({
  *   feePayer: {
@@ -80,16 +98,47 @@ export function relay(options: relay.Options = {}): Handler {
   const getClient = getClient_ ?? defaultGetClient({ apiKey })
   const resolveTokens = resolveTokens_ ?? defaultResolveTokens({ apiKey })
   const feePayerOptions = options.feePayer
-  // Adapt the state store into the multisig operation store once, up front.
-  const multisigOptions = options.multisig
-    ? { ...options.multisig, store: Multisig.fromStore(options.multisig.store) }
-    : undefined
+  const multisigStore = options.multisig ? Multisig.fromStore(options.multisig.store) : undefined
 
   const getTokens = async (chainId: number | undefined): Promise<readonly Address[]> => {
     if (chainId === undefined) return []
     return await resolveTokens(chainId)
   }
 
+  async function handleRawTransaction(
+    method: Sponsorship.handleRawTransaction.Options['method'],
+    params: readonly unknown[] | undefined,
+    client: Client,
+  ) {
+    const serialized = params?.[0]
+    if (!feePayerOptions) {
+      if (method === 'eth_signRawTransaction')
+        throw new RpcResponse.MethodNotFoundError({
+          message:
+            'eth_signRawTransaction requires a fee payer to be configured on the relay. ' +
+            'Set the `feePayer` option in `Handler.relay()` to enable transaction sponsorship.',
+        })
+      return { result: await client.request({ method, params } as never) }
+    }
+
+    if (
+      typeof serialized !== 'string' ||
+      !Sponsorship.requestsRawSponsorship(serialized as `0x${string}`)
+    )
+      return { result: await client.request({ method, params } as never) }
+
+    return await Sponsorship.handleRawTransaction({
+      account: feePayerOptions.account,
+      feeToken: feePayerOptions.feeToken,
+      getFeeToken: async (chainId) => (await getTokens(chainId))[0],
+      getClient,
+      method,
+      onSponsored: feePayerOptions.onSponsored,
+      request: { params },
+      validate: feePayerOptions.validate,
+    })
+  }
+
   // Memoize cache for TIP-20 metadata and user fee-token preferences. Kept
   // opt-in: an always-on cache would pin a raced null preference (set, then
   // fill before the set mines) for the whole TTL.
@@ -128,11 +177,49 @@ export function relay(options: relay.Options = {}): Handler {
         request,
         new RpcResponse.InvalidParamsError({ message: 'Conflicting chain ids.' }),
       )
+    const chainId_request = chainId_path ?? chainId_body
+
+    if (multisigStore && multisigMethods.has(request.method)) {
+      let sponsorshipDetails: Sponsorship.SponsorshipDetails | undefined
+      const handleMultisigRequest = ViemMultisig.handleRequest(
+        async (request, requestOptions) => {
+          const client = getClient(requestOptions?.chainId)
+          if (
+            request.method === 'eth_sendRawTransaction' ||
+            request.method === 'eth_sendRawTransactionSync'
+          ) {
+            const response = await handleRawTransaction(request.method, request.params, client)
+            sponsorshipDetails = response.sponsorshipDetails
+            return response.result
+          }
+          return await client.request(request as never, requestOptions)
+        },
+        { store: multisigStore },
+      )
+      try {
+        const result = await handleMultisigRequest(
+          {
+            method: request.method,
+            params,
+          },
+          chainId_request === undefined ? undefined : { chainId: chainId_request },
+        )
+        return RpcResponse.from(
+          {
+            result,
+            ...(sponsorshipDetails ? { sponsorship_details: sponsorshipDetails } : {}),
+          } as never,
+          { request } as never,
+        )
+      } catch (error) {
+        return Utils.rpcErrorJson(request, error)
+      }
+    }
 
     let chainId: number | undefined
     let client: Client
     try {
-      chainId = chainId_path ?? chainId_body ?? getClient().chain?.id
+      chainId = chainId_request ?? getClient().chain?.id
       client = getClient(chainId)
     } catch (error) {
       return Utils.rpcErrorJson(request, error)
@@ -165,13 +252,11 @@ 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 hasMultisigSimulation =
+            typeof normalized['multisigSimulation'] === 'object' &&
+            normalized['multisigSimulation'] !== null
           const shouldDeferFeePayerSignature =
-            feePayerOptions && multisigOptions && hasMultisigHints
+            feePayerOptions && multisigStore && hasMultisigSimulation
 
           // When sponsoring, the sponsor's preferred fee token (if set)
           // overrides whatever the consumer asked for — the sponsor is
@@ -224,7 +309,7 @@ export function relay(options: relay.Options = {}): Handler {
             ? createClient({
                 chain: client.chain,
                 batch: { multicall: { deployless: true } },
-                transport: http(externalFeePayerUrl),
+                transport: http(externalFeePayerUrl, { fetchOptions: { redirect: 'error' } }),
               })
             : client
 
@@ -358,7 +443,7 @@ export function relay(options: relay.Options = {}): Handler {
             transaction_filled.feePayerSignature != null
 
           const calls = extractCalls(transaction_filled)
-          const [simulation, transaction_final, autoSwap_, virtualAddresses] = await Promise.all([
+          const [simulation, signed, autoSwap_, virtualAddresses] = await Promise.all([
             // Simulate and compute balance diffs + fee.
             // When `capabilities.balanceDiffs` is `false`, skip simulate
             // and compute fee directly from cached metadata.
@@ -385,12 +470,13 @@ export function relay(options: relay.Options = {}): Handler {
             // Sign as fee payer (if sponsored and not already signed).
             (async () => {
               // Multisig finalization changes the sender signature. Sign after quorum.
-              if (shouldDeferFeePayerSignature) return transaction_filled
+              if (shouldDeferFeePayerSignature)
+                return { sponsorshipDetails: undefined, transaction: 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 { sponsorshipDetails: undefined, transaction: transaction_filled }
               return Sponsorship.sign({
                 account: feePayerOptions.account,
                 onSponsored: feePayerOptions.onSponsored,
@@ -405,6 +491,7 @@ export function relay(options: relay.Options = {}): Handler {
             resolveVirtualAddresses(client, { calls }),
           ])
           const { balanceDiffs, fee } = simulation
+          const { sponsorshipDetails, transaction: transaction_final } = signed
 
           const sponsor = (() => {
             if (!sponsored) return undefined
@@ -428,6 +515,7 @@ export function relay(options: relay.Options = {}): Handler {
                   ...(virtualAddresses ? { virtualAddresses } : {}),
                 },
               },
+              ...(sponsorshipDetails ? { sponsorship_details: sponsorshipDetails } : {}),
             },
             { request },
           )
@@ -529,75 +617,18 @@ export function relay(options: relay.Options = {}): Handler {
       case 'eth_sendRawTransaction':
       case 'eth_sendRawTransactionSync': {
         try {
-          const serialized = params[0]
-          if (
-            multisigOptions &&
-            (request.method === 'eth_sendRawTransaction' ||
-              request.method === 'eth_sendRawTransactionSync') &&
-            typeof serialized === 'string' &&
-            Multisig.isMultisigTransaction(serialized as Hex.Hex)
-          ) {
-            const result = await Multisig.handleRawTransaction({
-              claimTtl: multisigOptions.claimTtl,
-              finalize: multisigOptions.finalize,
-              getClient,
-              method: request.method,
-              request: { params: 'params' in request ? request.params : undefined },
-              resolveConfig: multisigOptions.resolveConfig,
-              sponsor: feePayerOptions
-                ? {
-                    account: feePayerOptions.account,
-                    feeToken: feePayerOptions.feeToken,
-                    onSponsored: feePayerOptions.onSponsored,
-                    resolveFeeToken: async (chainId) => (await getTokens(chainId))[0],
-                    validate: feePayerOptions.validate,
-                  }
-                : undefined,
-              store: multisigOptions.store,
-            })
-            return RpcResponse.from({ result } as never, { request } as never)
-          }
-
-          if (!feePayerOptions) {
-            // eth_signRawTransaction is a signing method that only the
-            // relay can fulfill — forwarding it to the RPC node returns
-            // an opaque "Method not found". Return an actionable error.
-            if ((request as { method: string }).method === 'eth_signRawTransaction') {
-              return RpcResponse.from(
-                {
-                  error: {
-                    code: -32601,
-                    message:
-                      'eth_signRawTransaction requires a fee payer to be configured on the relay. ' +
-                      'Set the `feePayer` option in `Handler.relay()` to enable transaction sponsorship.',
-                  },
-                } as never,
-                { request } as never,
-              )
-            }
-            const result = await client.request(request as never)
-            return RpcResponse.from({ result }, { request })
-          }
-
-          if (
-            typeof serialized !== 'string' ||
-            !Sponsorship.requestsRawSponsorship(serialized as `0x${string}`)
-          ) {
-            const result = await client.request(request as never)
-            return RpcResponse.from({ result }, { request })
-          }
-
-          const result = await Sponsorship.handleRawTransaction({
-            account: feePayerOptions.account,
-            feeToken: feePayerOptions.feeToken,
-            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,
-          })
-          return RpcResponse.from({ result } as never, { request } as never)
+          const { result, sponsorshipDetails } = await handleRawTransaction(
+            request.method,
+            params,
+            client,
+          )
+          return RpcResponse.from(
+            {
+              result,
+              ...(sponsorshipDetails ? { sponsorship_details: sponsorshipDetails } : {}),
+            } as never,
+            { request } as never,
+          )
         } catch (error) {
           return Utils.rpcErrorJson(request, error)
         }
@@ -606,17 +637,6 @@ export function relay(options: relay.Options = {}): Handler {
       case 'eth_getTransactionByHash':
       case 'eth_getTransactionReceipt': {
         try {
-          if (multisigOptions) {
-            const aliased = await Multisig.handleGetTransaction({
-              getClient,
-              method: request.method,
-              request: { params: 'params' in request ? request.params : undefined },
-              store: multisigOptions.store,
-            })
-            if (aliased)
-              return RpcResponse.from({ result: aliased.result } as never, { request } as never)
-          }
-
           const result = await client.request(request as never)
           return RpcResponse.from({ result }, { request })
         } catch (error) {
@@ -749,9 +769,8 @@ export namespace relay {
         }
       | undefined
     /**
-     * Resolves a viem client for a chain id. The handler resolves the client
-     * from the `chainId` in the incoming transaction (falling back to the
-     * client's default chain). Defaults to Tempo mainnet and testnet clients.
+     * Resolves a viem client from the request or stored multisig operation,
+     * falling back to the default chain. Defaults to Tempo mainnet and testnet clients.
      */
     getClient?: ((chainId?: number) => Client) | undefined
     /**
@@ -779,12 +798,13 @@ export namespace relay {
           url?: string | undefined
         }
       | undefined
-    /**
-     * Native multisig configuration. When provided, the relay collects owner
-     * approvals from multisig raw transaction submissions and broadcasts once
-     * collected owner weight meets the configured threshold.
-     */
-    multisig?: Multisig.Options | undefined
+    /** Native multisig coordination. */
+    multisig?:
+      | {
+          /** Authoritative state shared by every relay instance. */
+          store: Store.State
+        }
+      | undefined
     /**
      * Relay features.
      *

package/src/index.test-d.ts

@@ -0,0 +1,7 @@
+import * as Tapimo from 'tapimo'
+import * as Client from 'tapimo/client'
+
+test('exports only the client from the package root', () => {
+  expectTypeOf<keyof typeof Tapimo>().toEqualTypeOf<'Client'>()
+  expectTypeOf<typeof Tapimo.Client>().toEqualTypeOf<typeof Client>()
+})

package/src/index.ts

@@ -1,18 +1 @@
-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'
-export * as Assets from './Assets.js'
-export * as Auth from './Auth.js'
-export * as Cli from './cli/Cli.js'
 export * as Client from './Client.js'
-export * as Db from './db/Db.js'
-export * as Handler from './Handler.js'
-export * as Log from './internal/Log.js'
-export * as Metrics from './Metrics.js'
-export * as RateLimit from './internal/RateLimit.js'
-export * as Response from './internal/Response.js'
-export * as Schema from './internal/Schema.js'
-export * as Scope from './Scope.js'
-export * as Store from './internal/Store.js'
-export * as Webhooks from './Webhooks.js'

package/src/internal/AssetResponse.ts

@@ -0,0 +1,26 @@
+import type * as Assets from '../Assets.js'
+
+const svgContentSecurityPolicy =
+  "base-uri 'none'; default-src 'none'; form-action 'none'; frame-ancestors 'none'; img-src data:; sandbox; style-src 'unsafe-inline'"
+
+/** Version that invalidates unsafe response caches and validators. */
+export const version = 'svg-sandbox-v1'
+
+/** Builds response headers that prevent stored SVG assets from executing as documents. */
+export function headers(asset: Assets.Asset) {
+  const contentType = asset.contentType.split(';')[0]?.trim().toLowerCase()
+  return {
+    ...(contentType === 'image/svg+xml'
+      ? { 'Content-Security-Policy': svgContentSecurityPolicy }
+      : {}),
+    'Content-Type': asset.contentType,
+    'X-Content-Type-Options': 'nosniff',
+  }
+}
+
+/** Adds the response version to a client-visible or internal cache URL. */
+export function versionUrl(url: string) {
+  const value = new URL(url, 'http://localhost')
+  value.searchParams.set('__response', version)
+  return url.startsWith('/') ? `${value.pathname}${value.search}` : value.toString()
+}