tapimo 0.19.0 → 0.20.0

package/src/handlers/internal/sponsorship.ts

@@ -1,8 +1,8 @@
 import { Address as core_Address, Hash, Hex, Rlp, RpcResponse, Signature } from 'ox'
 import {
+  AccountConfig,
+  AccountOperation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
   SignatureEnvelope,
   TxEnvelopeTempo,
 } from 'ox/tempo'
@@ -291,7 +291,7 @@ export async function handleRawTransaction(options: handleRawTransaction.Options
 function isCanonical(serialized: Hex.Hex) {
   try {
     const envelope = TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized)
-    // Fee-payer handoffs encode a sender address or, for multisig senders, the `0x00` marker; parsing recovers `from` either way.
+    // Fee-payer handoffs encode a sender address or, for configurable account senders, the `0x00` marker; parsing recovers `from` either way.
     const slot = (Rlp.toHex(Hex.slice(serialized, 1)) as readonly Hex.Hex[])[11]
     const serialized_parsed = serialized.startsWith(TxEnvelopeTempo.feePayerMagic)
       ? TxEnvelopeTempo.serialize(envelope, {
@@ -387,7 +387,7 @@ async function recoverSender(client: Client, serialized: `0x76${string}` | `0x78
   const payload = TxEnvelopeTempo.getSignPayload(envelope)
 
   const sender = await (async () => {
-    if (signature.type === 'multisig') return verifyMultisig(client, { payload, signature })
+    if (signature.type === 'configurable') return verifyConfigurable(client, { payload, signature })
     if (signature.type !== 'keychain') return recoverSigner(payload, signature)
     // Tempo rejects V1 access-key signatures, which do not bind the key to its account.
     if (signature.version !== 'v2')
@@ -418,8 +418,8 @@ async function recoverSender(client: Client, serialized: `0x76${string}` | `0x78
       const { signature: signature_authorization } = keyAuthorization
       const payload_authorization = KeyAuthorization.getSignPayload(keyAuthorization)
       const authorizer =
-        signature_authorization.type === 'multisig'
-          ? await verifyMultisig(client, {
+        signature_authorization.type === 'configurable'
+          ? await verifyConfigurable(client, {
               payload: payload_authorization,
               signature: signature_authorization,
             })
@@ -472,63 +472,63 @@ async function recoverSender(client: Client, serialized: `0x76${string}` | `0x78
 }
 
 /**
- * Returns a multisig signature's account once its config matches the on-chain commitment and its
+ * Returns a configurable signature's account once its config matches the on-chain commitment and
  * owner approvals of `payload` reach quorum. Raw signing returns before any node checks them.
  */
-async function verifyMultisig(client: Client, options: verifyMultisig.Options) {
+async function verifyConfigurable(client: Client, options: verifyConfigurable.Options) {
   const { payload, signature } = options
   const { account } = signature
-  const config = MultisigConfig.from(signature.config)
+  const config = AccountConfig.from(signature.config)
   // Caller-token Zone endpoints scope reads to the authorized account.
   const commitment = await readContract(client, {
-    ...Actions.multisig.getConfigCommitment.call({ account }),
+    ...Actions.accounts.getConfigCommitment.call({ account }),
     account,
   })
   // A version-zero config derives its account; a registered account must match its stored commitment.
   if (
     config.version === 0n &&
     !core_Address.isEqual(
-      MultisigConfig.getAddress(config, { factory: Addresses.nativeMultisigFactory }),
+      AccountConfig.getAddress(config, { factory: Addresses.configurableAccountRecoveryFactory }),
       account,
     )
   )
     throw new RpcResponse.InvalidParamsError({
-      message: 'Initial account config does not match the multisig account.',
+      message: 'Initial account config does not match the configurable account.',
     })
   if (
     !(config.version === 0n && Hex.toBigInt(commitment) === 0n) &&
-    commitment.toLowerCase() !== MultisigConfig.getCommitment(config).toLowerCase()
+    commitment.toLowerCase() !== AccountConfig.getCommitment(config).toLowerCase()
   )
     throw new RpcResponse.InvalidParamsError({
       message: `Account config does not match account ${account}.`,
     })
   const { threshold, weight } = await (async () => {
     try {
-      return await MultisigOperation.selectApprovals({
+      return await AccountOperation.selectApprovals({
         account,
         approvals: signature.signatures.map((approval) => SignatureEnvelope.serialize(approval)),
         config,
-        hash: MultisigConfig.getSignPayload({ account, config, payload }),
+        hash: AccountConfig.getSignPayload({ account, config, payload }),
       })
     } catch (error) {
-      if (error instanceof MultisigOperation.InvalidApprovalError)
+      if (error instanceof AccountOperation.InvalidApprovalError)
         throw new RpcResponse.InvalidParamsError({ message: error.shortMessage })
       throw error
     }
   })()
   if (weight < threshold)
     throw new RpcResponse.InvalidParamsError({
-      message: 'Multisig account approvals do not reach quorum.',
+      message: 'Configurable account approvals do not reach quorum.',
     })
   return account
 }
 
-declare namespace verifyMultisig {
+declare namespace verifyConfigurable {
   type Options = {
     /** Sign payload the account's owners approve. */
     payload: Hex.Hex
-    /** Multisig signature carrying the account config and owner approvals. */
-    signature: Extract<SignatureEnvelope.SignatureEnvelope, { type: 'multisig' }>
+    /** Configurable signature carrying the account config and owner approvals. */
+    signature: Extract<SignatureEnvelope.SignatureEnvelope, { type: 'configurable' }>
   }
 }
 

package/src/handlers/relay.test.ts

@@ -801,7 +801,7 @@ describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: raw sponsorship se
   })
 })
 
-describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-83f3ccd')(
+describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-04e67d3')(
   'multisig',
   () => {
     let client: ReturnType<typeof Relay.getClient>
@@ -812,7 +812,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       server = await Relay.createServer(
         (
           await Relay.relay({
-            multisig: { store },
+            accounts: { store },
             tokens: localnetTokens,
           })
         ).listener,
@@ -831,7 +831,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
     test('example: initial configuration', async () => {
       const owner_1 = Relay.accounts[1]!
       const owner_2 = Relay.accounts[2]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [owner_1.address, owner_2.address],
         salt: toHex(0x109700, { size: 32 }),
@@ -857,10 +857,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         token: Relay.addresses.alphaUsd,
       })
       expect({
-        signatureCount: pending.multisig?.signatureCount,
+        signatureCount: pending.operation?.signatureCount,
         status: pending.status,
-        threshold: pending.multisig?.threshold,
-        weight: pending.multisig?.weight,
+        threshold: pending.operation?.threshold,
+        weight: pending.operation?.weight,
       }).toMatchInlineSnapshot(`
       {
         "signatureCount": 1,
@@ -879,10 +879,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         token: Relay.addresses.alphaUsd,
       } as never)
       expect({
-        signatureCount: receipt.multisig?.signatureCount,
+        signatureCount: receipt.operation?.signatureCount,
         status: receipt.status,
-        threshold: receipt.multisig?.threshold,
-        weight: receipt.multisig?.weight,
+        threshold: receipt.operation?.threshold,
+        weight: receipt.operation?.weight,
       }).toMatchInlineSnapshot(`
       {
         "signatureCount": 2,
@@ -903,8 +903,8 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       const transaction = await getTransaction(client, {
         hash: receipt.transactionHash,
       })
-      if (transaction.signature?.type !== 'multisig')
-        throw new Error('Expected a multisig signature.')
+      if (transaction.signature?.type !== 'configurable')
+        throw new Error('Expected a configurable signature.')
       expect({
         account: transaction.signature.account,
         signatureCount: transaction.signature.signatures.length,
@@ -914,15 +914,15 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       {
         "account": "${account.address.toLowerCase()}",
         "signatureCount": 2,
-        "type": "multisig",
+        "type": "configurable",
         "version": 0n,
       }
     `)
     })
 
-    test('rejects multisig accounts as owners', () => {
-      const child = Account.fromMultisig({ owners: [Relay.accounts[3]!] })
-      expect(() => Account.fromMultisig({ owners: [child as never] })).toThrow()
+    test('rejects configurable accounts as owners', () => {
+      const child = Account.fromConfig({ owners: [Relay.accounts[3]!] })
+      expect(() => Account.fromConfig({ owners: [child as never] })).toThrow()
     })
 
     test('example: weighted quorum', async () => {
@@ -932,7 +932,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       const heavy = owners[0]!
       const light_1 = owners[1]!
       const light_2 = owners[2]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [
           { owner: heavy.address, weight: 2 },
@@ -959,7 +959,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       })
       expect({
         status: alicePending.status,
-        weight: alicePending.multisig?.weight,
+        weight: alicePending.operation?.weight,
       }).toMatchInlineSnapshot(`
       {
         "status": "pending",
@@ -1010,7 +1010,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       } as never)
       expect({
         status: bobCarolPending.status,
-        weight: bobCarolPending.multisig?.weight,
+        weight: bobCarolPending.operation?.weight,
       }).toMatchInlineSnapshot(`
       {
         "status": "pending",
@@ -1031,12 +1031,12 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       const transaction = await getTransaction(client, {
         hash: receipt.transactionHash,
       })
-      if (transaction.signature?.type !== 'multisig')
-        throw new Error('Expected a multisig signature.')
+      if (transaction.signature?.type !== 'configurable')
+        throw new Error('Expected a configurable signature.')
       expect({
         signatureCount: transaction.signature.signatures.length,
         status: receipt.status,
-        weight: receipt.multisig?.weight,
+        weight: receipt.operation?.weight,
       }).toMatchInlineSnapshot(`
       {
         "signatureCount": 2,
@@ -1055,7 +1055,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
               account: feePayerAccount,
               onSponsored: () => ({ subsidized: true }),
             },
-            multisig: { store: sponsorStore },
+            accounts: { store: sponsorStore },
             tokens: localnetTokens,
           })
         ).listener,
@@ -1089,7 +1089,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
           sponsorship_details: { subsidized: true },
         })
 
-        const ownerFirst = Account.fromMultisig({
+        const ownerFirst = Account.fromConfig({
           address: 'infer',
           owners: [owner_1.address, owner_2.address],
           salt: toHex(0x109704, { size: 32 }),
@@ -1110,9 +1110,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
           to: recipient.address,
           token: Relay.addresses.alphaUsd,
         })
-        if (!ownerFirstPending.multisig) throw new Error('Expected a multisig operation.')
+        if (!ownerFirstPending.operation)
+          throw new Error('Expected a configurable account operation.')
         const ownerFirstTransaction = Transaction.deserialize(
-          ownerFirstPending.multisig.transaction,
+          ownerFirstPending.operation.transaction,
         )
         expect({
           feePayerSigned:
@@ -1144,7 +1145,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         }
       `)
 
-        const feePayerFirst = Account.fromMultisig({
+        const feePayerFirst = Account.fromConfig({
           address: 'infer',
           owners: [owner_1.address, owner_2.address],
           salt: toHex(0x109705, { size: 32 }),
@@ -1165,9 +1166,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
           to: recipient.address,
           token: Relay.addresses.alphaUsd,
         })
-        if (!feePayerFirstPending.multisig) throw new Error('Expected a multisig operation.')
+        if (!feePayerFirstPending.operation)
+          throw new Error('Expected a configurable account operation.')
         const feePayerFirstTransaction = Transaction.deserialize(
-          feePayerFirstPending.multisig.transaction,
+          feePayerFirstPending.operation.transaction,
         )
         expect({
           feePayerSigned:
@@ -1206,7 +1208,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
     test('example: initial config and immediate access key use', async () => {
       const owner_1 = Relay.accounts[3]!
       const owner_2 = Relay.accounts[4]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [owner_1, owner_2],
         salt: toHex(0x109706, { size: 32 }),
@@ -1228,10 +1230,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         owner: owner_1,
       })
       expect({
-        signatureCount: pending.multisig.signatureCount,
+        signatureCount: pending.operation.signatureCount,
         status: pending.status,
-        threshold: pending.multisig.threshold,
-        weight: pending.multisig.weight,
+        threshold: pending.operation.threshold,
+        weight: pending.operation.weight,
       }).toMatchInlineSnapshot(`
       {
         "signatureCount": 1,
@@ -1261,13 +1263,13 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         status: receipt.status,
         transactionSignature: transaction.signature?.type,
         version:
-          transaction.keyAuthorization?.signature.type === 'multisig'
+          transaction.keyAuthorization?.signature.type === 'configurable'
             ? transaction.keyAuthorization.signature.config.version
             : undefined,
       }).toMatchInlineSnapshot(`
       {
         "from": "${account.address.toLowerCase()}",
-        "keyAuthorizationSignature": "multisig",
+        "keyAuthorizationSignature": "configurable",
         "status": "success",
         "transactionSignature": "keychain",
         "version": 0n,
@@ -1278,7 +1280,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
     test('example: initial config and subsequent access key use', async () => {
       const owner_1 = Relay.accounts[6]!
       const owner_2 = Relay.accounts[8]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [owner_1, owner_2],
         salt: toHex(0x109707, { size: 32 }),
@@ -1330,9 +1332,9 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         transactionSignature: initialTransaction.signature?.type,
       }).toMatchInlineSnapshot(`
       {
-        "keyAuthorizationSignature": "multisig",
+        "keyAuthorizationSignature": "configurable",
         "status": "success",
-        "transactionSignature": "multisig",
+        "transactionSignature": "configurable",
       }
     `)
 
@@ -1357,7 +1359,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       const owner_1 = Relay.accounts[1]!
       const owner_2 = Relay.accounts[2]!
       const owner_3 = Relay.accounts[3]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [owner_1, owner_2],
         salt: toHex(0x109708, { size: 32 }),
@@ -1374,14 +1376,14 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         to: account.address,
         token: Relay.addresses.alphaUsd,
       })
-      const { receipt: pending } = await Actions.multisig.updateConfigSync(client, {
+      const { receipt: pending } = await Actions.accounts.updateConfigSync(client, {
         account,
         nextConfig,
         owner: owner_1,
       })
       expect({
         status: pending.status,
-        version: pending.multisig?.config.version,
+        version: pending.operation?.config.version,
       }).toMatchInlineSnapshot(`
       {
         "status": "pending",
@@ -1389,7 +1391,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       }
     `)
 
-      const { receipt: updateReceipt, ...rotation } = await Actions.multisig.updateConfigSync(
+      const { receipt: updateReceipt, ...rotation } = await Actions.accounts.updateConfigSync(
         client,
         {
           account,
@@ -1412,7 +1414,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
       }
     `)
 
-      const currentAccount = Account.fromMultisig(account.address)
+      const currentAccount = Account.fromConfig(account.address)
       const { receipt } = await Actions.token.transferSync(client, {
         account: currentAccount,
         amount: 11n,
@@ -1427,7 +1429,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
         account: transaction.from,
         status: receipt.status,
         version:
-          transaction.signature?.type === 'multisig'
+          transaction.signature?.type === 'configurable'
             ? transaction.signature.config.version
             : undefined,
       }).toMatchInlineSnapshot(`
@@ -1442,7 +1444,7 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
     test('behavior: routes pathless approvals to their operation chain', async () => {
       const owner_1 = Relay.accounts[1]!
       const owner_2 = Relay.accounts[2]!
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         address: 'infer',
         owners: [owner_1, owner_2],
         salt: toHex(0x109709, { size: 32 }),
@@ -1470,10 +1472,10 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
           await Relay.relay({
             getClient(chainId) {
               if (chainId !== Relay.chain.id)
-                throw new Error('Expected the multisig operation chain.')
+                throw new Error('Expected the configurable account operation chain.')
               return getClient(chainId)
             },
-            multisig: { store },
+            accounts: { store },
             tokens: localnetTokens,
           })
         ).listener,

package/src/handlers/relay.ts

@@ -1,7 +1,7 @@
 import { AbiEvent, Hash, Hex, RpcRequest, RpcResponse } from 'ox'
 import {
+  type AccountOperation,
   KeyAuthorization,
-  type MultisigOperation,
   Transaction as core_Transaction,
   TxEnvelopeTempo,
 } from 'ox/tempo'
@@ -30,7 +30,7 @@ import { type Handler, from } from '../Handler.js'
 import * as Store from '../internal/Store.js'
 import * as PublicUrl from '../internal/PublicUrl.js'
 import * as Tip20 from '../internal/Tip20.js'
-import * as Multisig from './internal/multisig.js'
+import * as Accounts from './internal/accounts.js'
 import * as Sponsorship from './internal/sponsorship.js'
 import * as Utils from './internal/utils.js'
 
@@ -87,7 +87,7 @@ export function relay(options: relay.Options = {}): Handler {
   const getClient = getClient_ ?? defaultGetClient({ apiKey })
   const resolveTokens = resolveTokens_ ?? defaultResolveTokens({ apiKey })
   const feePayerOptions = options.feePayer
-  const multisigStore = options.multisig ? Multisig.fromStore(options.multisig.store) : undefined
+  const accountsStore = options.accounts ? Accounts.fromStore(options.accounts.store) : undefined
 
   const getTokens = async (chainId: number | undefined): Promise<readonly Address[]> => {
     if (chainId === undefined) return []
@@ -170,9 +170,9 @@ export function relay(options: relay.Options = {}): Handler {
       )
     const chainId_request = chainId_path ?? chainId_body
 
-    if (multisigStore && Multisig.methods.has(request.method)) {
+    if (accountsStore && Accounts.methods.has(request.method)) {
       let sponsorshipDetails: Sponsorship.SponsorshipDetails | undefined
-      const handleMultisigRequest = Relay.handleRequest(
+      const handleAccountsRequest = Relay.handleRequest(
         async (inner, requestOptions) => {
           // Inner calls serve the caller's operation, so they resolve under its method.
           const client = await getClient(requestOptions?.chainId, { method: request.method })
@@ -186,13 +186,13 @@ export function relay(options: relay.Options = {}): Handler {
           }
           return await client.request(inner as never, requestOptions)
         },
-        { plugins: [Relay.multisig({ store: multisigStore })] },
+        { plugins: [Relay.accounts({ store: accountsStore })] },
       )
       try {
         const hash = (() => {
-          if (request.method === 'multisig_approveKeyAuthorization') return first?.['hash']
+          if (request.method === 'account_approveKeyAuthorization') return first?.['hash']
           if (
-            request.method === 'multisig_getOperation' ||
+            request.method === 'account_getOperation' ||
             request.method === 'eth_getTransactionByHash' ||
             request.method === 'eth_getTransactionReceipt'
           )
@@ -201,10 +201,10 @@ export function relay(options: relay.Options = {}): Handler {
         })()
         const operation =
           typeof hash === 'string' && Hash.validate(hash)
-            ? ((await handleMultisigRequest({
-                method: 'multisig_getOperation',
+            ? ((await handleAccountsRequest({
+                method: 'account_getOperation',
                 params: [hash],
-              })) as MultisigOperation.Rpc | null)
+              })) as AccountOperation.Rpc | null)
             : undefined
         // Stored hashes commit to their payload's chain. Authorize it before coordination can return state or update approvals without upstream access.
         if (operation) {
@@ -219,9 +219,9 @@ export function relay(options: relay.Options = {}): Handler {
           await getClient(chainId, { method: request.method })
         }
         const result =
-          request.method === 'multisig_getOperation' && operation !== undefined
+          request.method === 'account_getOperation' && operation !== undefined
             ? operation
-            : await handleMultisigRequest(
+            : await handleAccountsRequest(
                 {
                   method: request.method,
                   params,
@@ -296,11 +296,11 @@ export function relay(options: relay.Options = {}): Handler {
 
           const { feePayer: _feePayer, ...normalized } =
             Utils.normalizeFillTransactionRequest(parameters)
-          const hasMultisigSimulation =
-            typeof normalized['multisigSimulation'] === 'object' &&
-            normalized['multisigSimulation'] !== null
+          const hasAccountSimulation =
+            typeof normalized['configurableAccountSimulation'] === 'object' &&
+            normalized['configurableAccountSimulation'] !== null
           const shouldDeferFeePayerSignature =
-            feePayerOptions && multisigStore && hasMultisigSimulation
+            feePayerOptions && accountsStore && hasAccountSimulation
 
           // When sponsoring, the sponsor's preferred fee token (if set)
           // overrides whatever the consumer asked for — the sponsor is
@@ -526,7 +526,7 @@ 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.
+              // Configurable account finalization changes the sender signature. Sign after quorum.
               if (shouldDeferFeePayerSignature)
                 return { sponsorshipDetails: undefined, transaction: transaction_filled }
               // Never sign with the managed fee payer for an app-provided
@@ -865,6 +865,13 @@ export namespace relay {
   }
 
   export type Options = from.Options & {
+    /** Configurable account coordination. */
+    accounts?:
+      | {
+          /** Authoritative state shared by every relay instance. */
+          store: Store.State
+        }
+      | undefined
     /**
      * Tempo API key used by the default RPC clients and token resolver. When
      * omitted, RPC clients use each chain's default transport.
@@ -881,7 +888,7 @@ export namespace relay {
         }
       | undefined
     /**
-     * Resolves a viem client from the request or stored multisig operation, synchronously or asynchronously.
+     * Resolves a viem client from the request or stored configurable account operation, synchronously or asynchronously.
      * Receives the JSON-RPC method the client will serve. Defaults to Tempo mainnet and testnet clients.
      */
     getClient?:
@@ -916,13 +923,6 @@ export namespace relay {
           url?: string | undefined
         }
       | undefined
-    /** Native multisig coordination. */
-    multisig?:
-      | {
-          /** Authoritative state shared by every relay instance. */
-          store: Store.State
-        }
-      | undefined
     /**
      * Relay features.
      *

package/src/internal/Auth.test.ts

@@ -468,8 +468,12 @@ describe('require', () => {
       `)
     })
 
-    test('records per-Zone scopes as delegation tags on the principal', async () => {
-      const zoned = { ...key, scopes: ['data:read', 'zone:421700001:read', 'zone:421700002:write'] }
+    test("carries the key record's Zone tags on the principal", async () => {
+      const zoned = {
+        ...key,
+        scopes: ['data:read', 'zone:read', 'zone:421700002:write'],
+        zoneTags: [421700001, 421700002],
+      }
       const app = createApp({
         auth: {
           apiKey: { resolve: TestApp.resolver({ keys: [{ ...zoned, token }] }) },

package/src/internal/Auth.ts

@@ -984,7 +984,7 @@ namespace schema {
   /** Email OTP send body accepted before Better Auth runs; 254 characters is the SMTP path limit. */
   export const EmailOtpSend = z
     .object({
-      email: z.email().check(z.maxLength(254), z.describe('Recipient email address.')),
+      email: Schema.Email.check(z.maxLength(254), z.describe('Recipient email address.')),
       type: z.literal('sign-in').check(z.describe('OTP purpose; only sign-in is supported.')),
     })
     .check(z.describe('Email OTP send request.'))
@@ -2385,10 +2385,10 @@ export function require<environment extends Environment = Environment>(
 
       // CLI session tokens are prefixed, so they skip the API-key lookup.
       const cliToken = CliAuth.isToken(credential.token)
-      const apiKey_resolved = cliToken
+      const apiKey = cliToken
         ? null
         : await Timing.sum(c as never, 'auth_key', () => auth.apiKey?.resolve(c, credential.token))
-      if (!apiKey_resolved) {
+      if (!apiKey) {
         if (unsupportedChain)
           return Response.unsupportedChainId(
             c,
@@ -2427,10 +2427,6 @@ export function require<environment extends Environment = Environment>(
         })
       }
 
-      const scopes = Scope.expandAliases(apiKey_resolved.scopes)
-      const apiKey =
-        scopes === apiKey_resolved.scopes ? apiKey_resolved : { ...apiKey_resolved, scopes }
-
       // Sandbox keys are testnet-only. A sandbox key that explicitly targets
       // mainnet (`?chainId`) is rejected with a clear message rather than
       // steered or downgraded to anonymous, so the caller learns their key does
@@ -2968,8 +2964,6 @@ function payer(c: hono_Context) {
 }
 
 function principalFromApiKey(apiKey: ApiKey.ApiKey): Principal {
-  // Explicit record tags win; per-Zone scopes double as tags for keys without them.
-  const zoneTags = apiKey.zoneTags ?? Scope.zoneTags(apiKey.scopes)
   return {
     apiKey,
     environment: apiKey.environment,
@@ -2977,7 +2971,7 @@ function principalFromApiKey(apiKey: ApiKey.ApiKey): Principal {
     orgId: apiKey.orgId,
     ...(apiKey.projectId === undefined ? {} : { projectId: apiKey.projectId }),
     type: 'api_key',
-    ...(zoneTags === undefined ? {} : { zoneTags }),
+    ...(apiKey.zoneTags === undefined ? {} : { zoneTags: apiKey.zoneTags }),
   }
 }
 

package/src/internal/EarnRates.ts

@@ -71,12 +71,10 @@ export namespace schema {
   /** Annualized share-price growth over one measurement window. */
   export const Apy = z
     .strictObject({
-      asOf: z.iso
-        .datetime()
-        .check(
-          z.describe('UTC instant the rate was measured to, rounded to a 15-minute bucket.'),
-          z.meta({ examples: ['2026-07-21T09:00:00.000Z'] }),
-        ),
+      asOf: Schema.dateTime().check(
+        z.describe('UTC instant the rate was measured to, rounded to a 15-minute bucket.'),
+        z.meta({ examples: ['2026-07-21T09:00:00.000Z'] }),
+      ),
       methodology: z
         .literal(methodology)
         .check(