viem 3.0.0-next.10 → 3.0.0-next.13

package/src/tempo/Transport.ts

@@ -1,10 +1,16 @@
 import type { Hex } from 'ox'
 import { TxEnvelopeTempo } from 'ox/tempo'
 
+import { RpcResponse } from 'ox'
 import * as Transport from '../core/Transport.js'
+import { http as http_ } from '../core/transports/http.js'
+import * as Plugin from './internal/relay/plugin.js'
+import * as Request from './internal/relay/request.js'
+import type * as Relay_ from './Relay.js'
+import * as Store from './Store.js'
 
 /** A relay {@link Transport.Transport}: routes fee sponsorship traffic to a relay (fee payer service). */
-export type Relay = Transport.Transport<'relay'>
+export type Relay = Transport.Transport<'relay', { multisig: true }>
 
 /**
  * Creates a {@link Transport.Transport} that routes requests between a
@@ -22,7 +28,9 @@ export type Relay = Transport.Transport<'relay'>
  * - `'sign-and-broadcast'`: the submission is forwarded to the relay, which
  *   co-signs and broadcasts it itself.
  *
- * All other requests are forwarded to the default transport.
+ * Multisig approvals and submissions are sent to the relay. Transaction and
+ * receipt lookups fall back to the relay for pending multisig operations.
+ * Other requests are forwarded to the default transport.
  *
  * @example
  * ```ts
@@ -38,17 +46,55 @@ export type Relay = Transport.Transport<'relay'>
  * @param options - Options.
  * @returns A relay transport.
  */
+export function withRelay<
+  transport extends Transport.Transport,
+  const plugins extends readonly Relay_.Plugin[] = readonly [],
+>(
+  defaultTransport: transport,
+  options: withRelay.LocalOptions<plugins>,
+): withRelay.LocalReturnValue<transport, plugins>
 export function withRelay(
   defaultTransport: Transport.Transport,
   relayTransport: Transport.Transport,
+  options?: withRelay.Options,
+): Relay
+export function withRelay(
+  defaultTransport: Transport.Transport,
+  relayTransport: Transport.Transport | withRelay.LocalOptions,
   options: withRelay.Options = {},
-): Relay {
+): Transport.Transport {
+  if (!('setup' in relayTransport))
+    return {
+      ...defaultTransport,
+      setup(config = {}) {
+        const transport = defaultTransport.setup(config)
+        const request = Request.compose(
+          (request, options) => transport.request(request, options),
+          relayTransport,
+          config.chain ? () => ({ chain: config.chain! }) : undefined,
+        )
+        return {
+          ...transport,
+          request: ((request_, options) =>
+            request(request_ as Relay_.handleRequest.Request, {
+              chainId: config.chain?.id,
+              ...options,
+            })) as typeof transport.request,
+          ...(relayTransport.plugins?.some((plugin) =>
+            Plugin.isMultisig(plugin),
+          )
+            ? { multisig: true }
+            : {}),
+        }
+      },
+    }
+
   const { policy = 'sign-only' } = options
   return Transport.from({
     key: options.key ?? 'relay',
     name: options.name ?? 'Relay Proxy',
     type: 'relay',
-    setup({ chain, retryCount, timeout }) {
+    setup({ chain, timeout }) {
       const transport = defaultTransport.setup({
         chain,
         retryCount: 0,
@@ -57,8 +103,9 @@ export function withRelay(
       const relay = relayTransport.setup({ chain, retryCount: 0, timeout })
 
       return {
+        multisig: true as const,
         methods: options.methods,
-        retryCount: options.retryCount ?? retryCount,
+        retryCount: 0,
         retryDelay: options.retryDelay,
         async request(args, opts) {
           const { method, params } = args
@@ -66,12 +113,77 @@ export function withRelay(
           // The relay decides whether to sponsor from the fill request's `feePayer`.
           if (method === 'eth_fillTransaction') return relay.request(args, opts)
 
+          if (
+            method === 'eth_getTransactionByHash' ||
+            method === 'eth_getTransactionReceipt'
+          ) {
+            const result = await transport.request(
+              { method, params: params as [Hex.Hex] },
+              opts,
+            )
+            if (result !== null && typeof result !== 'undefined') return result
+
+            const operation = await (async () => {
+              try {
+                return await relay.request(
+                  { method: 'multisig_getOperation', params },
+                  opts,
+                )
+              } catch (error) {
+                if (
+                  error instanceof RpcResponse.MethodNotFoundError ||
+                  error instanceof RpcResponse.MethodNotSupportedError
+                ) {
+                  // Relays created before multisig coordination do not expose this method.
+                  return null
+                }
+                throw error
+              }
+            })()
+            if (
+              !operation ||
+              typeof operation !== 'object' ||
+              !('type' in operation) ||
+              operation.type !== 'transaction'
+            )
+              return result
+            return relay.request({ method, params: params as [Hex.Hex] }, opts)
+          }
+
+          if (
+            method === 'multisig_approveKeyAuthorization' ||
+            method === 'multisig_approveRawTransaction' ||
+            method === 'multisig_approveRawTransactionSync' ||
+            method === 'multisig_getConfig' ||
+            method === 'multisig_getOperation'
+          )
+            return relay.request({ method, params: params as [Hex.Hex] }, opts)
+
           if (
             method === 'eth_sendRawTransaction' ||
             method === 'eth_sendRawTransactionSync'
           ) {
             const serialized = (params as readonly unknown[])?.[0]
             // A pending fee payer signature marks the envelope as awaiting relay co-signature.
+            if (
+              typeof serialized === 'string' &&
+              serialized.startsWith(TxEnvelopeTempo.serializedType)
+            ) {
+              const envelope = (() => {
+                try {
+                  return TxEnvelopeTempo.deserialize(
+                    serialized as TxEnvelopeTempo.Serialized,
+                  )
+                } catch {
+                  return undefined
+                }
+              })()
+              if (envelope?.signature?.type === 'multisig')
+                return relay.request(
+                  { method, params: [serialized as Hex.Hex] },
+                  opts,
+                )
+            }
             const sponsored = toFeePayerFormat(serialized)
             if (sponsored) {
               if (policy === 'sign-and-broadcast')
@@ -94,6 +206,33 @@ export function withRelay(
 }
 
 export declare namespace withRelay {
+  /** Plugins applied directly to the default transport. */
+  type LocalOptions<
+    plugins extends readonly Relay_.Plugin[] = readonly Relay_.Plugin[],
+  > = Pick<Relay_.handleRequest.Options, 'resolveTokens'> & {
+    /** Ordered relay plugins. Defaults to an empty list. */
+    plugins?: plugins | undefined
+  }
+  /** Wrapped transport preserving its attributes and RPC schema. */
+  type LocalReturnValue<
+    transport extends Transport.Transport,
+    plugins extends readonly Relay_.Plugin[] = readonly [],
+  > =
+    transport extends Transport.Transport<
+      infer type,
+      infer properties,
+      infer request
+    >
+      ? Transport.Transport<
+          type,
+          properties &
+            (Extract<plugins[number], Relay_.multisig.ReturnType> extends never
+              ? {}
+              : { multisig: true }),
+          request
+        >
+      : never
+
   type Options = {
     /** Transport key. @default 'relay' */
     key?: string | undefined
@@ -135,3 +274,61 @@ function toFeePayerFormat(serialized: unknown): Hex.Hex | undefined {
     return undefined
   }
 }
+
+/**
+ * Creates an HTTP JSON-RPC transport with support for Zone authorization
+ * tokens.
+ *
+ * Reads the authorization token for the client's chain from {@link Store}
+ * and injects the `X-Authorization-Token` header on every request. Batching
+ * is not supported because zone tokens are account-scoped.
+ *
+ * @example
+ * ```ts
+ * import { Client, http, Zone } from 'viem/tempo'
+ *
+ * const client = Client.create({
+ *   chain: Zone.a,
+ *   transport: http(),
+ * })
+ * ```
+ *
+ * @param url - RPC URL. Defaults to the chain's default RPC URL.
+ * @param options - Options.
+ * @returns An HTTP transport.
+ */
+export function http(
+  url?: string | undefined,
+  options: http.Options = {},
+): Transport.Http {
+  const { onFetchRequest, store = Store.defaultStore(), ...rest } = options
+  return {
+    key: rest.key ?? 'http',
+    name: rest.name ?? 'HTTP JSON-RPC',
+    type: 'http',
+    setup(setupOptions = {}) {
+      const chainId = setupOptions.chain?.id
+      return http_(url, {
+        ...rest,
+        async onFetchRequest(request, init) {
+          const next = (await onFetchRequest?.(request, init)) ?? init
+          const headers = new Headers(next.headers)
+
+          if (chainId) {
+            const token = await store.getItem(`auth:token:${chainId}`)
+            if (token) headers.set('X-Authorization-Token', token)
+          }
+
+          return { ...next, headers }
+        },
+      }).setup(setupOptions)
+    },
+  }
+}
+
+export declare namespace http {
+  type Options = Omit<http_.Options, 'batch' | 'raw'> & {
+    /** Store for reading zone authorization tokens. Defaults to session storage (web) or memory (server). */
+    store?: Store.Store | undefined
+  }
+}

package/src/tempo/Zone.ts

@@ -0,0 +1,72 @@
+import * as Chain from '../core/Chain.js'
+import type { Assign } from '../core/internal/types.js'
+import { type ChainConfig, chainConfig } from './chainConfig.js'
+
+type Defaults = {
+  contracts: undefined
+  nativeCurrency: {
+    decimals: number
+    name: string
+    symbol: string
+  }
+  rpcUrls: { http: string[] }
+  supportsTransactionReplacementDetection: boolean
+}
+
+/** Defines a Tempo Zone chain. */
+export function from<const config extends from.Parameters>(
+  config: config,
+): from.ReturnValue<config>
+export function from(config: from.Parameters) {
+  const chain = {
+    ...chainConfig,
+    contracts: undefined,
+    nativeCurrency: {
+      name: 'USD',
+      symbol: 'USD',
+      decimals: 6,
+    },
+    rpcUrls: { http: [] as string[] },
+    supportsTransactionReplacementDetection: false,
+    ...config,
+  }
+  return Chain.from(chain)
+}
+
+export declare namespace from {
+  type Parameters = Pick<Chain.Chain, 'id' | 'name'> &
+    Partial<Omit<Chain.Chain, 'id' | 'name' | 'sourceId'>> & {
+      sourceId: number
+    }
+
+  type ReturnValue<config extends Parameters = Parameters> = Assign<
+    Assign<Chain.from.ReturnType<ChainConfig>, Defaults>,
+    config
+  >
+}
+
+export const a = /*#__PURE__*/ from({
+  id: 4_217_000_006,
+  name: 'Zone A',
+  rpcUrls: { http: ['https://rpc-zone-a.testnet.tempo.xyz'] },
+  sourceId: 42_431,
+})
+
+export const b = /*#__PURE__*/ from({
+  id: 4_217_000_007,
+  name: 'Zone B',
+  rpcUrls: { http: ['https://rpc-zone-b.testnet.tempo.xyz'] },
+  sourceId: 42_431,
+})
+
+export const internal = /*#__PURE__*/ from({
+  id: 421_700_001,
+  name: 'Internal Zone',
+  sourceId: 4_217, // tempo mainnet
+})
+
+export const internalTestnet = /*#__PURE__*/ from({
+  id: 1_424_310_003,
+  name: 'Internal Testnet Zone',
+  sourceId: 42_431, // tempo testnet
+})

package/src/tempo/actions/accessKey/authorizeSync.ts

@@ -1,4 +1,5 @@
 import type { Address, Errors } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -47,6 +48,9 @@ export async function authorizeSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as authorizeSync.ReturnType
+
   const { args } = authorize.extractEvent(receipt.logs)
   return { ...args, receipt }
 }

package/src/tempo/actions/accessKey/burnWitnessSync.ts

@@ -1,4 +1,5 @@
 import type { Address, Errors, Hex } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -43,6 +44,9 @@ export async function burnWitnessSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as burnWitnessSync.ReturnType
+
   const { args } = burnWitness.extractEvent(receipt.logs)
   return { ...args, receipt }
 }

package/src/tempo/actions/accessKey/index.ts

@@ -16,3 +16,5 @@ export { verifyHash } from './verifyHash.js'
 export { watchAdminAuthorized } from './watchAdminAuthorized.js'
 export { watchWitness } from './watchWitness.js'
 export { watchWitnessBurned } from './watchWitnessBurned.js'
+
+export { prepareAuthorization } from './prepareAuthorization.js'

package/src/tempo/actions/accessKey/prepareAuthorization.ts

@@ -0,0 +1,132 @@
+import { Address, type Hex } from 'ox'
+import { KeyAuthorization, MultisigConfig } from 'ox/tempo'
+import * as CoreAccount from '../../../core/Account.js'
+import type * as Chain from '../../../core/Chain.js'
+import type * as Client from '../../../core/Client.js'
+import type { Compute } from '../../../core/internal/types.js'
+import {
+  getKeyAuthorizationSignPayload,
+  resolveAccessKey,
+  signKeyAuthorization,
+  type MultisigAccount,
+} from '../../Account.js'
+
+/**
+ * Prepares a key authorization for signing.
+ *
+ * @example
+ * ```ts
+ * const authorization = await Actions.accessKey.prepareAuthorization(client, {
+ *   account,
+ *   accessKey,
+ * })
+ * const keyAuthorization = await Actions.accessKey.signAuthorization(
+ *   client,
+ *   authorization,
+ * )
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Prepared key authorization parameters.
+ */
+export async function prepareAuthorization<
+  chain extends Chain.Chain | undefined,
+  account extends CoreAccount.Account | undefined,
+>(
+  client: Client.Client<chain, account>,
+  parameters: prepareAuthorization.Options<account>,
+): Promise<prepareAuthorization.ReturnType> {
+  const { chainId = client.chain?.id } = parameters
+  const account_ = parameters.account ?? client.account
+  if (!account_) throw new Error('account is required.')
+  if (!chainId) throw new Error('chainId is required.')
+  const parsed = CoreAccount.from(account_)
+  const multisigState = await (async () => {
+    if ('multisig' in parameters) return parameters.multisig
+    if (!('source' in parsed) || parsed.source !== 'multisig') return undefined
+    const account = parsed as MultisigAccount
+    if (!account.config)
+      throw new Error(
+        'A multisig config is required to prepare a key authorization.',
+      )
+    return { config: account.config }
+  })()
+  const authorizationSignPayload = getKeyAuthorizationSignPayload(
+    parsed as CoreAccount.Local,
+    {
+      ...parameters,
+      chainId: BigInt(chainId),
+      key: parameters.accessKey,
+    },
+  )
+  const signPayload =
+    'source' in parsed && parsed.source === 'multisig' && multisigState
+      ? MultisigConfig.getSignPayload({
+          account: parsed.address,
+          config: multisigState.config,
+          payload: authorizationSignPayload,
+        })
+      : authorizationSignPayload
+  return {
+    ...parameters,
+    account: parsed,
+    chainId,
+    multisig: multisigState,
+    signPayload,
+  } as prepareAuthorization.ReturnType
+}
+
+export namespace prepareAuthorization {
+  export type Options<
+    account extends CoreAccount.Account | undefined =
+      | CoreAccount.Account
+      | undefined,
+  > = {
+    account?: account | CoreAccount.Account | Address.Address | undefined
+  } & {
+    /** The access key to authorize. */
+    accessKey: resolveAccessKey.Parameters
+    /**
+     * Whether to authorize the key as an admin key. Admin keys are unrestricted
+     * and can manage the account's other access keys; `expiry`, `limits`, and
+     * `scopes` are ignored. Requires the T6 hardfork.
+     *
+     * [TIP-1049](https://tips.sh/1049)
+     */
+    admin?: boolean | undefined
+    /** The chain ID. */
+    chainId?: number | undefined
+    /** Unix timestamp when the key expires. */
+    expiry?: number | undefined
+    /** Spending limits per token. */
+    limits?:
+      | { token: Address.Address; limit: bigint; period?: number | undefined }[]
+      | undefined
+    /** @internal Prepared multisig state. */
+    multisig?: signKeyAuthorization.Parameters['multisig']
+    /** Call scopes restricting which contracts/selectors this key can call. */
+    scopes?: KeyAuthorization.Scope[] | undefined
+    /**
+     * Optional 32-byte witness bound into the authorization's signing hash.
+     *
+     * Applications use this to bind a single signature to an arbitrary offchain
+     * context (e.g. a server-issued challenge), or as a revocation handle that
+     * can be burned onchain (see {@link burnWitness}) to invalidate the
+     * authorization before it is submitted.
+     *
+     * [TIP-1053](https://tips.sh/1053)
+     */
+    witness?: Hex.Hex | undefined
+  }
+
+  export type ReturnType = Compute<
+    Omit<Options<CoreAccount.Account | undefined>, 'account' | 'chainId'> & {
+      account: CoreAccount.Account
+      chainId: number
+      multisig: signKeyAuthorization.Parameters['multisig']
+      /** Payload that the authorizing account or multisig owners sign. */
+      signPayload: Hex.Hex
+    }
+  >
+}

package/src/tempo/actions/accessKey/revokeSync.ts

@@ -1,4 +1,5 @@
 import type { Address, Errors } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -41,6 +42,9 @@ export async function revokeSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as revokeSync.ReturnType
+
   const { args } = revoke.extractEvent(receipt.logs)
   return { ...args, receipt }
 }