viem 3.0.0-next.12 → 3.0.0-next.13

package/src/tempo/Relay.ts

@@ -0,0 +1,430 @@
+import type { Address } from 'abitype'
+import * as RpcResponse from 'ox/RpcResponse'
+import type { Local as LocalAccount } from '../core/Account.js'
+import type { Client as Client_ } from '../core/Client.js'
+import { ChainNotConfiguredError } from '../core/Client.js'
+import type * as Transport from '../core/Transport.js'
+import * as Sponsorship from './internal/relay/feePayer.js'
+import * as FeeToken from './internal/relay/feeToken.js'
+import * as Multisig from './internal/relay/multisig.js'
+import * as Request_ from './internal/relay/request.js'
+import * as Simulate from './internal/relay/simulate.js'
+import * as internal from './internal/relay.js'
+import type * as Store from './Store.js'
+
+type EIP1193RequestOptions = NonNullable<Parameters<Transport.RequestFn>[1]>
+
+/**
+ * Creates a relay with RPC and Fetch handlers backed by a client or chain resolver.
+ *
+ * Pass a chain-configured `client` for a single chain, or `getClient` for multiple
+ * chains. Plugins may resolve the chain before forwarding to the selected client.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Relay } from 'viem/tempo'
+ *
+ * const relay = Relay.create({
+ *   client: Client.create({ chain: tempo, transport: http() }),
+ * })
+ * export default { fetch: relay.fetch }
+ * ```
+ *
+ * @param options - Client selection and relay plugins.
+ * @returns RPC and Fetch handlers sharing the same plugins.
+ */
+export function create<const chainId extends number>(
+  options: handleRequest.Options & {
+    client: Client & { chain: { id: chainId } }
+    getClient?: never
+  },
+): create.ReturnType<chainId>
+export function create<const chainId extends number = number>(
+  options: handleRequest.Options & {
+    client?: never
+    getClient: (options: { chainId: chainId }) => Client
+  },
+): create.ReturnType<chainId>
+export function create<getClient extends (options: never) => Client>(
+  options: handleRequest.Options & { client?: never; getClient: getClient },
+): create.ReturnType<
+  Parameters<getClient>[0] extends { chainId: infer chainId extends number }
+    ? chainId
+    : number
+>
+export function create(
+  options: handleRequest.Options & {
+    client?: Client | undefined
+    getClient?: ((options: never) => Client) | undefined
+  },
+): create.ReturnType {
+  if (Boolean(options.client) === Boolean(options.getClient))
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Expected exactly one of client or getClient.',
+    })
+  const clientChainId = options.client?.chain?.id
+  if (
+    options.client &&
+    (!Number.isSafeInteger(clientChainId) ||
+      !clientChainId ||
+      clientChainId <= 0)
+  )
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Expected a client with a configured chain.',
+    })
+
+  const getClient = (chainId: number) => {
+    try {
+      const client = options.client ?? options.getClient!({ chainId } as never)
+      if (client.chain.id !== chainId)
+        throw new RpcResponse.InvalidParamsError({
+          message: 'Conflicting chain ids.',
+        })
+      return client
+    } catch (error) {
+      if (error instanceof ChainNotConfiguredError)
+        throw new RpcResponse.InvalidParamsError({
+          message: error.shortMessage,
+        })
+      throw error
+    }
+  }
+  const handle = Request_.compose(
+    async (request, requestOptions) => {
+      const { chainId, response: _, ...rest } = requestOptions ?? {}
+      if (chainId === undefined)
+        throw new RpcResponse.InvalidParamsError({
+          message: 'A chain ID is required to resolve the downstream client.',
+        })
+      return getClient(chainId).request(request as never, rest)
+    },
+    options,
+    getClient,
+  )
+
+  const request: handleRequest.Handler = (request, requestOptions) => {
+    const chainId = requestOptions?.chainId ?? clientChainId
+    if (
+      chainId !== undefined &&
+      (!Number.isSafeInteger(chainId) || chainId <= 0)
+    )
+      return Promise.reject(
+        new RpcResponse.InvalidParamsError({
+          message: 'Expected a valid chain ID.',
+        }),
+      )
+    if (clientChainId !== undefined && chainId !== clientChainId)
+      return Promise.reject(
+        new RpcResponse.InvalidParamsError({
+          message: 'Conflicting chain ids.',
+        }),
+      )
+    return handle(request, { ...requestOptions, chainId })
+  }
+  return {
+    request,
+    fetch: (request_, options: create.RequestOptions = {}) =>
+      internal.fetch(request_, request, options),
+  }
+}
+
+export declare namespace create {
+  /** Client selection and middleware for a relay. */
+  export type Options<chainId extends number = number> = handleRequest.Options &
+    (
+      | {
+          /** Chain-configured client used for every forwarded request. */
+          client: Client & { chain: { id: chainId } }
+          getClient?: never
+        }
+      | {
+          client?: never
+          /** Resolves the client after plugins have selected the request's chain. */
+          getClient: (options: {
+            chainId: chainId
+          }) => Client & { chain: { id: number } }
+        }
+    )
+
+  /** Optional chain selection and RPC request options. */
+  export type RequestOptions<chainId extends number = number> = Omit<
+    handleRequest.RequestOptions,
+    'chainId'
+  > & { chainId?: chainId | undefined }
+
+  /** Handlers sharing one composed relay pipeline. */
+  export type ReturnType<chainId extends number = number> = {
+    /** Handles a POST JSON-RPC request, returning JSON or an empty 204 for notifications. */
+    fetch: {
+      (request: Request): Promise<Response>
+      (
+        request: Request,
+        options?: RequestOptions<chainId> | undefined,
+      ): Promise<Response>
+    }
+    /** Handles a parsed RPC call and returns its result. */
+    request: (
+      request: handleRequest.Request,
+      options?: RequestOptions<chainId> | undefined,
+    ) => Promise<unknown>
+  }
+}
+
+/**
+ * Creates an RPC request handler by composing relay plugins around a downstream handler.
+ *
+ * Requests enter plugins in array order, and responses return in reverse order.
+ * Post-fill hooks run concurrently after middleware finishes. Middleware sees
+ * the downstream result before post-fill enrichment and signing.
+ * Without plugins, the downstream handler is returned unchanged. Plugins decide
+ * whether to forward, transform, or handle a request. Errors propagate unchanged
+ * unless a plugin handles them.
+ *
+ * @example
+ * ```ts
+ * import { http } from 'viem'
+ * import { Relay } from 'viem/tempo'
+ *
+ * const rpc = http('https://rpc.tempo.xyz').setup()
+ * const handle = Relay.handleRequest(rpc.request, {
+ *   plugins: [
+ *     {
+ *       async handleRequest(context, next) {
+ *         context.options.retryCount = 0
+ *         await next()
+ *       },
+ *     },
+ *   ],
+ * })
+ * const chainId = await handle({ method: 'eth_chainId' })
+ * // @log: '0x1079'
+ * ```
+ *
+ * @param next - Downstream RPC request handler, typically forwarding to the Tempo (Execution) RPC.
+ * @param options - Relay options.
+ * @returns The composed RPC request handler.
+ */
+export function handleRequest(
+  next: handleRequest.Handler,
+  options: handleRequest.Options = {},
+): handleRequest.Handler {
+  return Request_.compose(next, options)
+}
+
+export declare namespace handleRequest {
+  /** RPC request handler shared by relay plugins and the downstream execution RPC. */
+  export type Handler = (
+    request: Request,
+    options?: RequestOptions | undefined,
+  ) => Promise<unknown>
+
+  /** Options for {@link handleRequest}. */
+  export type Options = {
+    /** Plugins in request execution order. Defaults to an empty list. */
+    plugins?: readonly Plugin[] | undefined
+    /** Fee-token candidates shared by all plugins, memoized per request and chain. */
+    resolveTokens?:
+      | ((chainId: number) => readonly Address[] | Promise<readonly Address[]>)
+      | undefined
+    /** Deadline in milliseconds for a plugin-handled fill, including callbacks. Defaults to 10,000. */
+    timeout?: number | undefined
+  }
+
+  /** RPC request passed to a handler. */
+  export type Request = {
+    /** RPC method name. */
+    method: string
+    /** RPC method parameters. */
+    params?: readonly unknown[] | undefined
+  }
+
+  /** Options for one handled request. */
+  export type RequestOptions = EIP1193RequestOptions & {
+    /** Chain selected by the caller or resolved by a plugin. */
+    chainId?: number | undefined
+    /** Response metadata collected by the Fetch adapter. */
+    response?:
+      | { sponsorship_details?: Sponsorship.SponsorshipDetails | undefined }
+      | undefined
+  }
+}
+
+/** Hooks extending relay request processing and filled transaction responses. */
+export type Plugin = {
+  /** Processes an RPC request. Await next(), then read or replace context.result. */
+  handleRequest?:
+    | ((context: Plugin.Context, next: () => Promise<void>) => Promise<unknown>)
+    | undefined
+  /** Runs concurrently after the final fill. Returns capability fields to merge. */
+  afterFill?:
+    | ((
+        filled: Plugin.FillResult,
+        context: Plugin.Context,
+      ) => Promise<Plugin.Enrichment | undefined>)
+    | undefined
+  /** Signs the final fill concurrently with enrichment. Only one signer may be registered. */
+  signTransaction?:
+    | ((
+        filled: Plugin.FillResult,
+        context: Plugin.Context,
+      ) => Promise<Plugin.Signature | undefined>)
+    | undefined
+}
+
+export declare namespace Plugin {
+  /** State and services isolated to one RPC invocation. */
+  export type Context = {
+    /** Current RPC request. Changes are passed to next(). */
+    request: handleRequest.Request
+    /** Downstream result, populated by next(). */
+    result: unknown
+    /** Transport options and selected chain. */
+    options: handleRequest.RequestOptions
+    /** Downstream client for the selected chain. */
+    readonly client: Client_
+    /** Gets a downstream client for the selected or specified chain. */
+    getClient: (chainId?: number) => Client_
+    /** Gets the shared token candidates for the selected or specified chain. */
+    resolveTokens: (chainId?: number) => Promise<readonly Address[]>
+    /** Scopes a configured store to this invocation. */
+    getStore: (store: Store.Store | undefined) => Store.Store | undefined
+  }
+  /** Immutable RPC fill supplied to post-fill hooks. */
+  export type FillResult = {
+    readonly tx: Readonly<Record<string, unknown>>
+    readonly capabilities?: Readonly<Record<string, unknown>> | undefined
+    readonly sponsor?: unknown
+  }
+  /** Additional response capabilities. Duplicate keys from hooks are rejected. */
+  export type Enrichment = {
+    capabilities?: Record<string, unknown> | undefined
+  }
+  /** Fee-payer signature in RPC format. */
+  export type Signature = {
+    r: `0x${string}`
+    s: `0x${string}`
+    yParity: `0x${string}`
+  }
+}
+
+declare const multisigBrand: unique symbol
+
+/**
+ * Coordinates native multisig approvals using shared atomic storage.
+ *
+ * Memory storage is process-local. Independent clients and multiple server
+ * instances must use the same persistent store to share pending approvals.
+ *
+ * @example
+ * ```ts
+ * import { http } from 'viem'
+ * import { Relay, Store, withRelay } from 'viem/tempo'
+ *
+ * const transport = withRelay(http(), {
+ *   plugins: [Relay.multisig({ store: Store.memory() })],
+ * })
+ * ```
+ *
+ * @param options - Shared atomic storage.
+ * @returns A plugin that coordinates multisig requests and forwards other calls.
+ */
+export function multisig(options: multisig.Options): multisig.ReturnType {
+  return Multisig.create(options)
+}
+
+export declare namespace multisig {
+  /** Multisig coordination options. */
+  export type Options = {
+    /** Store shared by multisig coordinators, with atomic compare-and-set support. */
+    store: Store.Atomic
+  }
+  /** Middleware advertising native multisig coordination. */
+  export type ReturnType = Plugin & { readonly [multisigBrand]: true }
+}
+
+/**
+ * Sponsors transactions with a local account or an external fee-payer relay.
+ *
+ * Place multisig before this plugin and fee-token selection after it.
+ *
+ * @example
+ * ```ts
+ * import { Account } from 'viem'
+ * import { Relay } from 'viem/tempo'
+ * const plugin = Relay.feePayer({ account: Account.fromPrivateKey('0x...') })
+ * ```
+ * @param options - Sponsor account, policy, and display metadata.
+ * @returns A fee-payer relay plugin.
+ */
+export function feePayer(options: feePayer.Options = {}): Plugin {
+  return Sponsorship.create(options)
+}
+
+export declare namespace feePayer {
+  /** Fee sponsorship configuration. */
+  export type Options = {
+    /** Local sponsor. Omit when requests use an external fee-payer URL. */
+    account?: LocalAccount | undefined
+    /** Trusted external fee-payer URLs. Matches the normalized full URL, including path and query. Defaults to none. */
+    allowedFeePayers?: readonly string[] | undefined
+    /** Sponsor's preferred fee token. Overrides the request token on sponsored fills. */
+    feeToken?: Address | undefined
+    /** Allow HTTP and private external relay hosts in trusted development environments. @default false */
+    internal_allowUnsafeUrls?: boolean | undefined
+    /** Display name returned in sponsor capabilities. */
+    name?: string | undefined
+    /** Called after signing and before returning or broadcasting. A thrown error aborts sponsorship. */
+    onSponsored?: Sponsorship.sign.Options['onSponsored'] | undefined
+    /** Sponsor display URL. */
+    url?: string | undefined
+    /** Only `true` authorizes sponsorship. Rejected fills fall back to sender-paid transactions. */
+    validate?: Sponsorship.Validate | undefined
+  }
+  /** Result of a sponsorship policy check. */
+  export type Validation = Sponsorship.Validation
+  /** Facts passed to the sponsorship callback. */
+  export type SponsoredEvent = Sponsorship.SponsoredEvent
+}
+
+/**
+ * Resolves fee tokens from user preferences, balances, and available fee AMM liquidity.
+ *
+ * @example
+ * ```ts
+ * import { Relay } from 'viem/tempo'
+ * const plugin = Relay.feeToken()
+ * ```
+ * @returns A fee-token relay plugin.
+ */
+export function feeToken(): Plugin {
+  return FeeToken.create()
+}
+
+/**
+ * Adds balance changes, estimated fees, and execution errors to fill capabilities.
+ *
+ * Runs after transaction middleware to simulate the final filled result.
+ *
+ * @example
+ * ```ts
+ * import { Relay } from 'viem/tempo'
+ * const plugin = Relay.simulate()
+ * ```
+ * @param options - Optional metadata store.
+ * @returns A simulation relay plugin.
+ */
+export function simulate(options: simulate.Options = {}): Plugin {
+  return Simulate.create(options)
+}
+
+export declare namespace simulate {
+  /** Simulation configuration. */
+  export type Options = {
+    /** Store for cached metadata. Omit to read metadata for each request. */
+    store?: Store.Store | undefined
+  }
+}
+
+type Client = Pick<Client_, 'request'> & { chain: { id: number } }

package/src/tempo/Selectors.ts

@@ -186,6 +186,7 @@ export const tip20Factory = {
 
 /** Function selectors of the TIP-20 token interface. */
 export const tip20 = {
+  BURN_AT_ROLE: '0xc6990381',
   BURN_BLOCKED_ROLE: '0x32ad9be8',
   DOMAIN_SEPARATOR: '0x3644e515',
   ISSUER_ROLE: '0x82aefa24',
@@ -195,6 +196,7 @@ export const tip20 = {
   approve: '0x095ea7b3',
   balanceOf: '0x70a08231',
   burn: '0x42966c68',
+  burnAt: '0x9803f216',
   burnBlocked: '0xec0cf3dc',
   burnWithMemo: '0x38f23b0b',
   changeTransferPolicyId: '0xfd5e9420',
@@ -317,14 +319,8 @@ export const zoneFactory = {
   OverloadedFunctionSelectors<'createZone'>
 
 export const zoneVerifier = {
-  verify: {
-    'verify(uint32,uint64,uint64,bytes32,uint64,(bytes32,bytes32),(bytes32,bytes32,uint64,uint64),bytes32,bytes,bytes)':
-      '0x7106a43e',
-    'verify(uint32,uint64,uint64,bytes32,uint64,uint256,(bytes32,bytes32),(bytes32,bytes32,uint64,uint64),(uint64,uint64),bytes32,bytes,bytes)':
-      '0xebb2ddc9',
-  },
-} as const satisfies FunctionSelectors<typeof Abis.zoneVerifier, 'verify'> &
-  OverloadedFunctionSelectors<'verify'>
+  verify: '0xebb2ddc9',
+} as const satisfies FunctionSelectors<typeof Abis.zoneVerifier>
 
 export const zonePortal = {
   FIXED_DEPOSIT_GAS: '0xf706cfbf',
@@ -332,6 +328,8 @@ export const zonePortal = {
   MAX_GAS_FEE_RATE: '0xf490ca96',
   MAX_TOKENS_ENABLED_PER_TEMPO_BLOCK: '0x3fcf7df4',
   MAX_TOKEN_METADATA_BYTES: '0x996329a2',
+  MAX_UNPROCESSED_DEPOSITS: '0x5e53dcd3',
+  MAX_UNPROCESSED_TOKEN_ENABLEMENTS: '0x3b667e74',
   MAX_WITHDRAWAL_GAS_LIMIT: '0x86f47e55',
   abdicate: '0xbf4c5411',
   abdicationEffectiveAt: '0x04a3b098',
@@ -366,6 +364,7 @@ export const zonePortal = {
   isSequencer: '0x6d46e987',
   isTokenEnabled: '0x748538d9',
   lastProcessedDepositNumber: '0xe84abe69',
+  lastProcessedEnabledTokenCount: '0xccd537ca',
   lastSyncedTempoBlockNumber: '0xbe2a63ee',
   leader: '0x40eedabb',
   leaderActivationTempoBlock: '0xb83c755f',
@@ -399,8 +398,14 @@ export const zonePortal = {
   setSequencerEncryptionKey: '0xef10b187',
   setSequencerSet: '0x86012b45',
   setZoneGasRate: '0x0e86bbdc',
-  submitBatch: '0x78fb159b',
+  submitBatch: {
+    'submitBatch(uint64,uint64,(bytes32,bytes32),(bytes32,bytes32,uint64,uint64),(uint64,uint64),bytes32,bytes,bytes,uint256,bytes[])':
+      '0x4cd6c7c7',
+    'submitBatch(uint64,uint64,(bytes32,bytes32),(bytes32,bytes32,uint64,uint64),bytes32,bytes,bytes,uint256,bytes[])':
+      '0x78fb159b',
+  },
   tokenConfig: '0xfe136c4e',
+  tokenEnablementCursorInitialized: '0x370ddf99',
   tokenEnablementHash: '0xb456c0dd',
   transferAdmin: '0x75829def',
   verifier: '0x2b7ac3f3',
@@ -411,8 +416,17 @@ export const zonePortal = {
   zoneGasRate: '0xecf79a4e',
   zoneHeight: '0x430f8b4f',
   zoneId: '0xd179978a',
-} as const satisfies FunctionSelectors<typeof Abis.zonePortal, 'deposit'> &
-  OverloadedFunctionSelectors<'deposit'>
+} as const satisfies FunctionSelectors<
+  typeof Abis.zonePortal,
+  'deposit' | 'submitBatch'
+> &
+  OverloadedFunctionSelectors<'deposit' | 'submitBatch'>
+
+export const zonePortalPreT13Retired = {
+  MAX_DEPOSITS_PER_TEMPO_BLOCK: '0x1bf00ca8',
+  MAX_TOKENS_ENABLED_PER_TEMPO_BLOCK: '0x3fcf7df4',
+  submitBatch: '0x78fb159b',
+} as const satisfies FunctionSelectors<typeof Abis.zonePortalPreT13Retired>
 
 export const zoneOutbox = {
   AUTHENTICATED_WITHDRAWAL_CIPHERTEXT_LENGTH: '0x43c3cb83',

package/src/tempo/Transport.ts

@@ -4,7 +4,9 @@ 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 Multisig from './Multisig.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). */
@@ -44,17 +46,55 @@ export type Relay = Transport.Transport<'relay', { multisig: true }>
  * @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,
@@ -65,7 +105,7 @@ export function withRelay(
       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
@@ -166,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
@@ -265,40 +332,3 @@ export declare namespace http {
     store?: Store.Store | undefined
   }
 }
-
-/** Wraps a transport with native multisig approval coordination. */
-export function withMultisig<transport extends Transport.Transport>(
-  transport: transport,
-  options: Multisig.handleRequest.Parameters,
-): withMultisig.ReturnValue<transport> {
-  return {
-    ...transport,
-    setup(parameters = {}) {
-      const value = transport.setup(parameters)
-      return {
-        ...value,
-        multisig: true,
-        request: Multisig.handleRequest(
-          (request, options) => value.request(request, options),
-          options,
-        ),
-      }
-    },
-  } as unknown as withMultisig.ReturnValue<transport>
-}
-
-export declare namespace withMultisig {
-  /** Parameters for multisig coordination. */
-  type Options = Multisig.handleRequest.Parameters
-  /** Wrapped transport with multisig coordination metadata. */
-  type ReturnValue<
-    transport extends Transport.Transport = Transport.Transport,
-  > =
-    transport extends Transport.Transport<
-      infer type,
-      infer properties,
-      infer request
-    >
-      ? Transport.Transport<type, properties & { multisig: true }, request>
-      : never
-}