ox 0.14.55 → 0.14.57

package/tempo/KeyAuthorization.ts

@@ -29,7 +29,7 @@ import * as TempoAddress from './TempoAddress.js'
  * - `chainId`: Chain ID for replay protection (0 = valid on any chain)
  * - `expiry`: Unix timestamp when the key expires (undefined = never expires)
  * - `limits`: Per-TIP-20 token spending limits (only applies to `transfer()` and `approve()` calls)
- * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `multisig`)
+ * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `configurable`)
  *
  * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
  */
@@ -77,39 +77,39 @@ export type KeyAuthorization<
   witness?: Hex.Hex | undefined
 } & (
   | {
-      /** Optional account address binding. */
+      /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
       account?: addressType | undefined
       /** Primitive key type. */
       type: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a multisig grant. */
-      account: addressType
-      /** Multisig key type. */
-      type: 'multisig'
+      /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
+      account?: addressType | undefined
+      /** Configurable account key type. */
+      type: 'configurable'
     }
 ) &
   (signed extends true
     ? {
         signature:
           | SignatureEnvelope.Primitive<bigintType, numberType>
-          | SignatureEnvelope.Multisig<bigintType, numberType>
+          | SignatureEnvelope.Configurable<bigintType, numberType>
       }
     : {
         signature?:
           | SignatureEnvelope.Primitive<bigintType, numberType>
-          | SignatureEnvelope.Multisig<bigintType, numberType>
+          | SignatureEnvelope.Configurable<bigintType, numberType>
           | undefined
       })
 
 /** Signature that can authorize an access key. */
 export type Signature<bigintType = bigint, numberType = number> =
   | SignatureEnvelope.Primitive<bigintType, numberType>
-  | SignatureEnvelope.Multisig<bigintType, numberType>
+  | SignatureEnvelope.Configurable<bigintType, numberType>
 
 /** RPC-formatted signature that can authorize an access key. */
 export type SignatureRpc =
-  | SignatureEnvelope.MultisigRpc
+  | SignatureEnvelope.ConfigurableRpc
   | SignatureEnvelope.PrimitiveRpc
 
 /** Input type for a Key Authorization. */
@@ -146,10 +146,10 @@ export type Rpc = {
       keyType: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a multisig grant. */
-      account: Address.Address
-      /** Multisig key type. */
-      keyType: 'multisig'
+      /** Optional account address binding (TIP-1049). */
+      account?: Address.Address | null | undefined
+      /** Configurable account key type, named `configurableAccount` by the node. */
+      keyType: 'configurableAccount'
     }
 )
 
@@ -180,9 +180,9 @@ export type Signed<
 > = KeyAuthorization<true, bigintType, numberType, addressType>
 
 type SignatureValue =
-  | SignatureEnvelope.from.MultisigFromConfig
+  | SignatureEnvelope.from.ConfigurableFromConfig
   | UnionPartialBy<SignatureEnvelope.Primitive, 'prehash' | 'type'>
-  | PartialBy<SignatureEnvelope.Multisig, 'type'>
+  | PartialBy<SignatureEnvelope.Configurable, 'type'>
   | SignatureEnvelope.Secp256k1Flat
   | SignatureEnvelope.Serialized
 
@@ -449,7 +449,6 @@ export function from<
   options: from.Options<signature> = {},
 ): from.ReturnType<authorization, signature> {
   if ('keyId' in authorization) return fromRpc(authorization as Rpc) as never
-  assertAccountBinding(authorization.type, authorization.account)
   const auth = authorization as KeyAuthorization & {
     limits?: readonly { token: TempoAddress.Address; limit: bigint }[]
     scopes?: readonly {
@@ -508,11 +507,11 @@ export declare namespace from {
   type Options<
     signature extends SignatureValue | undefined = SignatureValue | undefined,
   > = {
-    /** The primitive or multisig signature to attach to the Key Authorization. */
+    /** The primitive or configurable account signature to attach to the Key Authorization. */
     signature?:
       | signature
       | SignatureEnvelope.Primitive
-      | SignatureEnvelope.Multisig
+      | SignatureEnvelope.Configurable
       | undefined
   }
 
@@ -535,10 +534,7 @@ export declare namespace from {
         >
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -572,7 +568,7 @@ export function fromRpc(authorization: Rpc): Signed {
   const witness = authorization.witness ?? undefined
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
-  assertAccountBinding(keyType, account)
+  const type = keyType === 'configurableAccount' ? 'configurable' : keyType
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
   assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
@@ -607,9 +603,7 @@ export function fromRpc(authorization: Rpc): Signed {
     })),
     ...(scopes ? { scopes } : {}),
     signature,
-    ...(keyType === 'multisig'
-      ? { account: account!, type: keyType }
-      : { type: keyType }),
+    ...(type === 'configurable' ? { account: account!, type } : { type }),
     ...(witness !== undefined ? { witness } : {}),
     ...(account !== undefined ? { account } : {}),
     ...(isAdmin ? { isAdmin: true as const } : {}),
@@ -617,10 +611,7 @@ export function fromRpc(authorization: Rpc): Signed {
 }
 
 export declare namespace fromRpc {
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -683,7 +674,7 @@ export function fromTuple<const tuple extends Tuple>(
       case '0x02':
         return 'webAuthn'
       case '0x03':
-        return 'multisig'
+        return 'configurable'
       default:
         throw new Error(`Invalid key type: ${keyType_hex}`)
     }
@@ -740,11 +731,10 @@ export function fromTuple<const tuple extends Tuple>(
   const account = isAbsent(rawAccount)
     ? undefined
     : (rawAccount as Address.Address)
-  assertAccountBinding(keyType, account)
   const args: KeyAuthorization = {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
-    ...(keyType === 'multisig'
+    ...(keyType === 'configurable'
       ? { account: account!, type: keyType }
       : { type: keyType }),
     ...(expiry !== undefined ? { expiry } : {}),
@@ -767,10 +757,7 @@ export declare namespace fromTuple {
     KeyAuthorization<authorization extends Tuple<true> ? true : false>
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -962,7 +949,6 @@ export declare namespace serialize {
  * @returns An RPC-formatted Key Authorization.
  */
 export function toRpc(authorization: Signed): Rpc {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     scopes,
@@ -1006,7 +992,9 @@ export function toRpc(authorization: Signed): Rpc {
     chainId: chainId === 0n ? '0x' : Hex.fromNumber(chainId),
     expiry: typeof expiry === 'number' ? Hex.fromNumber(expiry) : null,
     keyId: TempoAddress.resolve(address),
-    ...(type === 'multisig' ? { account, keyType: type } : { keyType: type }),
+    ...(type === 'configurable'
+      ? { account, keyType: 'configurableAccount' as const }
+      : { keyType: type }),
     limits: limits?.map(({ token, limit, period }) => ({
       token,
       limit: Hex.fromNumber(limit),
@@ -1014,7 +1002,7 @@ export function toRpc(authorization: Signed): Rpc {
     })),
     signature: SignatureEnvelope.toRpc(signature) as
       | SignatureEnvelope.PrimitiveRpc
-      | SignatureEnvelope.MultisigRpc,
+      | SignatureEnvelope.ConfigurableRpc,
     ...(allowedCalls ? { allowedCalls } : {}),
     ...(witness !== undefined ? { witness } : {}),
     ...(isAdmin ? { isAdmin: true } : {}),
@@ -1023,10 +1011,7 @@ export function toRpc(authorization: Signed): Rpc {
 }
 
 export declare namespace toRpc {
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -1063,7 +1048,6 @@ export declare namespace toRpc {
 export function toTuple<const authorization extends KeyAuthorization>(
   authorization: authorization,
 ): toTuple.ReturnType<authorization> {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     chainId,
@@ -1089,7 +1073,7 @@ export function toTuple<const authorization extends KeyAuthorization>(
         return '0x01'
       case 'webAuthn':
         return '0x02'
-      case 'multisig':
+      case 'configurable':
         return '0x03'
       default:
         throw new Error(`Invalid key type: ${keyType}`)
@@ -1172,10 +1156,7 @@ export declare namespace toTuple {
   type ReturnType<authorization extends KeyAuthorization = KeyAuthorization> =
     Compute<Tuple<authorization extends KeyAuthorization<true> ? true : false>>
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 function bigintToHex(value: bigint): Hex.Hex {
@@ -1209,13 +1190,6 @@ function resolveSelector(
   return AbiItem.getSelector(selector)
 }
 
-function assertAccountBinding(
-  type: KeyAuthorization['type'],
-  account: TempoAddress.Address | null | undefined,
-): void {
-  if (type === 'multisig' && account == null) throw new MissingAccountError()
-}
-
 function assertWitness(witness: Hex.Hex): void {
   if (Hex.size(witness) !== 32) throw new InvalidWitnessSizeError(witness)
 }
@@ -1256,15 +1230,20 @@ export class InvalidSignatureTypeError extends Error {
   override readonly name = 'KeyAuthorization.InvalidSignatureTypeError'
   constructor(type: SignatureEnvelope.SignatureEnvelope['type']) {
     super(
-      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.`,
+      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.`,
     )
   }
 }
 
-/** Thrown when a multisig key grant omits its parent account binding. */
+/**
+ * Thrown when a configurable account key grant omits its parent account binding.
+ *
+ * @deprecated No longer thrown. The Tempo node only requires `account` on grants
+ * signed by an admin access key, which it checks against the transaction sender.
+ */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'
   constructor() {
-    super('Multisig key grants require a parent account binding.')
+    super('Configurable account key grants require a parent account binding.')
   }
 }

package/tempo/RpcSchemaTempo.test-d.ts

@@ -1,76 +1,76 @@
 import type { Provider } from 'ox'
 import type {
+  AccountConfig,
+  AccountOperation,
+  AccountSimulation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
-  MultisigSimulation,
   RpcSchemaTempo,
 } from 'ox/tempo'
 import { expectTypeOf, test } from 'vitest'
 import type * as Address from '../core/Address.js'
 import type * as Hex from '../core/Hex.js'
 
-declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Multisig }>
+declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Account }>
 declare const tempoProvider: Provider.Provider<{
   schema: RpcSchemaTempo.Tempo
 }>
 declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigSimulation: MultisigSimulation.Rpc
+declare const configurableAccountSimulation: AccountSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
-test('multisig provider methods', () => {
+test('account provider methods', () => {
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransaction',
+      method: 'account_approveRawTransaction',
       params: [serializedTransaction],
     }),
   ).resolves.toEqualTypeOf<Hex.Hex>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransactionSync',
+      method: 'account_approveRawTransactionSync',
       params: [serializedTransaction],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.TransactionRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.TransactionRpc>()
 
   provider.request({
-    method: 'multisig_approveRawTransactionSync',
+    method: 'account_approveRawTransactionSync',
     params: [serializedTransaction, 30_000],
   })
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ keyAuthorization }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ hash, signature }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getConfig',
+      method: 'account_getConfig',
       params: [{ address }],
     }),
-  ).resolves.toEqualTypeOf<MultisigConfig.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountConfig.Rpc | null>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getOperation',
+      method: 'account_getOperation',
       params: [hash],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountOperation.Rpc | null>()
 })
 
-test('tempo simulation accepts multisig specs', () => {
+test('tempo simulation accepts account simulation specs', () => {
   tempoProvider.request({
     method: 'tempo_simulateV1',
     params: [
@@ -79,7 +79,7 @@ test('tempo simulation accepts multisig specs', () => {
           {
             calls: [
               {
-                multisigSimulation,
+                configurableAccountSimulation,
               },
             ],
           },

package/tempo/RpcSchemaTempo.ts

@@ -5,9 +5,9 @@ import type * as Hex from '../core/Hex.js'
 import type * as Log from '../core/Log.js'
 import type * as RpcSchema from '../core/RpcSchema.js'
 import type * as StateOverrides from '../core/StateOverrides.js'
+import type * as AccountConfig from './AccountConfig.js'
+import type * as AccountOperation from './AccountOperation.js'
 import type * as KeyAuthorization from './KeyAuthorization.js'
-import type * as MultisigConfig from './MultisigConfig.js'
-import type * as MultisigOperation from './MultisigOperation.js'
 import type * as TransactionRequest from './TransactionRequest.js'
 
 /**
@@ -58,44 +58,44 @@ export type Tempo = RpcSchema.From<{
   }
 }>
 
-/** Union of all JSON-RPC methods for the `multisig_` namespace. */
-export type Multisig = RpcSchema.From<
+/** Union of all JSON-RPC methods for the `account_` namespace. */
+export type Account = RpcSchema.From<
   | {
       Request: {
-        method: 'multisig_approveRawTransaction'
+        method: 'account_approveRawTransaction'
         params: [serializedTransaction: Hex.Hex]
       }
       ReturnType: Hex.Hex
     }
   | {
       Request: {
-        method: 'multisig_approveRawTransactionSync'
+        method: 'account_approveRawTransactionSync'
         params: [serializedTransaction: Hex.Hex, timeout?: number]
       }
-      ReturnType: MultisigOperation.TransactionRpc
+      ReturnType: AccountOperation.TransactionRpc
     }
   | {
       Request: {
-        method: 'multisig_approveKeyAuthorization'
+        method: 'account_approveKeyAuthorization'
         params: [
           | { keyAuthorization: KeyAuthorization.Rpc }
           | { hash: Hex.Hex; signature: Hex.Hex },
         ]
       }
-      ReturnType: MultisigOperation.KeyAuthorizationRpc
+      ReturnType: AccountOperation.KeyAuthorizationRpc
     }
   | {
       Request: {
-        method: 'multisig_getConfig'
+        method: 'account_getConfig'
         params: [{ address: Address.Address }]
       }
-      ReturnType: MultisigConfig.Rpc | null
+      ReturnType: AccountConfig.Rpc | null
     }
   | {
       Request: {
-        method: 'multisig_getOperation'
+        method: 'account_getOperation'
         params: [hash: Hex.Hex]
       }
-      ReturnType: MultisigOperation.Rpc | null
+      ReturnType: AccountOperation.Rpc | null
     }
 >

package/tempo/SignatureEnvelope.test-d.ts

@@ -15,24 +15,24 @@ const envelope = SignatureEnvelope.from({
   signatures: [primitive],
 })
 
-test('preserves primitive and multisig RPC types', () => {
+test('preserves primitive and configurable RPC types', () => {
   expectTypeOf(
     SignatureEnvelope.toRpc(primitive),
   ).toEqualTypeOf<SignatureEnvelope.Secp256k1Rpc>()
   expectTypeOf(SignatureEnvelope.toRpc(envelope)).toEqualTypeOf<Hex.Hex>()
   expectTypeOf<
     SignatureEnvelope.GetType<typeof envelope>
-  >().toEqualTypeOf<'multisig'>()
-  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Multisig>()
+  >().toEqualTypeOf<'configurable'>()
+  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Configurable>()
 })
 
 test('requires config and primitive approvals', () => {
-  // @ts-expect-error Every multisig signature carries its current config.
+  // @ts-expect-error Every configurable signature carries its current config.
   SignatureEnvelope.from({ account: envelope.account, signatures: [primitive] })
-  // @ts-expect-error Multisig owners cannot recursively approve with multisigs.
+  // @ts-expect-error Configurable owners cannot recursively approve with configurable signatures.
   SignatureEnvelope.from({ ...envelope, signatures: [envelope] })
-  // @ts-expect-error Multisig RPC signatures are hex-encoded RLP.
-  const rpc: SignatureEnvelope.MultisigRpc = {
+  // @ts-expect-error Configurable RPC signatures are hex-encoded RLP.
+  const rpc: SignatureEnvelope.ConfigurableRpc = {
     account: envelope.account,
     signatures: [],
   }