ox 0.14.41 → 0.14.43

package/tempo/SignatureEnvelope.ts

@@ -53,8 +53,6 @@ type SignatureEnvelopeKey =
   | 'version'
 
 type SignatureEnvelopeRpcKey =
-  | 'account'
-  | 'config'
   | 'keyId'
   | 'metadata'
   | 'preHash'
@@ -63,7 +61,6 @@ type SignatureEnvelopeRpcKey =
   | 'r'
   | 's'
   | 'signature'
-  | 'signatures'
   | 'type'
   | 'userAddress'
   | 'v'
@@ -161,7 +158,7 @@ export type SignatureEnvelopeRpc =
       Secp256k1Rpc | P256Rpc | WebAuthnRpc | KeychainRpc,
       SignatureEnvelopeRpcKey
     >
-  | MultisigRpcOneOf
+  | MultisigRpc
 
 /** Primitive signature envelope accepted by protocol sidecars. */
 export type Primitive<bigintType = bigint, numberType = number> = OneOf<
@@ -215,7 +212,7 @@ export type KeychainRpc = {
 export interface Multisig<bigintType = bigint, numberType = number> {
   /** Native multisig account address. */
   account: Address.Address
-  /** Complete applicable multisig configuration witness. */
+  /** Complete applicable multisig configuration. */
   config: MultisigConfig.Config<bigintType, numberType>
   /**
    * Owner approvals over the multisig owner approval digest. Each approval is
@@ -240,33 +237,8 @@ type MultisigOneOf<bigintType = bigint, numberType = number> = Multisig<
   version?: undefined
 }
 
-/** RPC-formatted native multisig signature. */
-export type MultisigRpc = {
-  /** Native multisig account address. */
-  account: Address.Address
-  /** Complete applicable multisig configuration witness. */
-  config: MultisigConfig.Config<number>
-  /** Structured owner approvals. */
-  signatures: readonly SignatureEnvelopeRpc[]
-  /** Multisig RPC signatures are untagged. */
-  type?: undefined
-}
-
-type MultisigRpcOneOf = MultisigRpc & {
-  keyId?: undefined
-  metadata?: undefined
-  preHash?: undefined
-  pubKeyX?: undefined
-  pubKeyY?: undefined
-  r?: undefined
-  s?: undefined
-  signature?: undefined
-  userAddress?: undefined
-  v?: undefined
-  version?: undefined
-  webauthnData?: undefined
-  yParity?: undefined
-}
+/** Canonical RLP-encoded native multisig signature without the `0x05` type byte. */
+export type MultisigRpc = Hex.Hex
 
 export type P256<bigintType = bigint, numberType = number> = {
   prehash: boolean
@@ -1081,7 +1053,7 @@ export declare namespace from {
     | {
         /** Initial native multisig account, derived from config when omitted. */
         account?: Address.Address | undefined
-        /** Initial version-0 multisig configuration witness. */
+        /** Initial version-0 multisig configuration. */
         config: MultisigConfig.Input<0 | 0n>
         /** Primitive or nested owner approvals. */
         signatures: readonly SignatureEnvelope[]
@@ -1090,7 +1062,7 @@ export declare namespace from {
     | {
         /** Native multisig account. */
         account: Address.Address
-        /** Complete applicable multisig configuration witness. */
+        /** Complete applicable multisig configuration. */
         config: MultisigConfig.Input
         /** Primitive or nested owner approvals. */
         signatures: readonly SignatureEnvelope[]
@@ -1140,6 +1112,20 @@ export declare namespace from {
  * @returns The signature envelope with bigint values.
  */
 export function fromRpc(envelope: SignatureEnvelopeRpc): SignatureEnvelope {
+  if (typeof envelope === 'string') {
+    const serialized = Hex.concat(serializedMultisigType, envelope)
+    const result = deserialize(serialized)
+    if (
+      result.type !== 'multisig' ||
+      !Hex.isEqual(serialize(result), serialized)
+    )
+      throw new InvalidSerializedError({
+        reason: 'invalid multisig RPC signature',
+        serialized: envelope,
+      })
+    return result
+  }
+
   if (envelope.type === 'secp256k1')
     return {
       signature: Signature.fromRpc(envelope),
@@ -1222,21 +1208,6 @@ export function fromRpc(envelope: SignatureEnvelopeRpc): SignatureEnvelope {
     }
   }
 
-  if (
-    (envelope as { type?: string | undefined }).type === 'multisig' ||
-    ('config' in envelope && 'signatures' in envelope)
-  ) {
-    const multisig = envelope as MultisigRpc
-    const result = {
-      account: multisig.account,
-      config: MultisigConfig.from(multisig.config),
-      signatures: multisig.signatures.map((signature) => fromRpc(signature)),
-      type: 'multisig',
-    } satisfies Multisig
-    assert(result)
-    return result
-  }
-
   throw new CoercionError({ envelope })
 }
 
@@ -1244,8 +1215,10 @@ export declare namespace fromRpc {
   type ErrorType =
     | assert.ErrorType
     | CoercionError
+    | Hex.concat.ErrorType
+    | Hex.isEqual.ErrorType
     | InvalidSerializedError
-    | MultisigConfig.assert.ErrorType
+    | serialize.ErrorType
     | Signature.fromRpc.ErrorType
     | Errors.GlobalErrorType
 }
@@ -1526,7 +1499,7 @@ export declare namespace sortMultisigApprovals {
   type Value = {
     /** The native multisig account address. */
     account: Address.Address
-    /** Complete applicable multisig configuration witness. */
+    /** Complete applicable multisig configuration. */
     config: MultisigConfig.Input
     /** The inner transaction sign payload (`tx.signature_hash()`). */
     payload: Hex.Hex | Bytes.Bytes
@@ -1611,15 +1584,7 @@ export function toRpc<const envelope extends toRpc.Input>(
 
   if (type === 'multisig') {
     const multisig = envelope as Multisig
-    assert(multisig)
-    return {
-      account: multisig.account,
-      config: {
-        ...multisig.config,
-        version: Hex.toNumber(Hex.fromNumber(multisig.config.version)),
-      },
-      signatures: multisig.signatures.map((signature) => toRpc(signature)),
-    } as never
+    return Hex.slice(serialize(multisig), 1) as never
   }
 
   throw new CoercionError({ envelope })
@@ -1647,7 +1612,8 @@ export declare namespace toRpc {
     | assert.ErrorType
     | CoercionError
     | Hex.fromNumber.ErrorType
-    | Hex.toNumber.ErrorType
+    | Hex.slice.ErrorType
+    | serialize.ErrorType
     | Signature.toRpc.ErrorType
     | Errors.GlobalErrorType
 }

package/tempo/Transaction.test.ts

@@ -1,6 +1,9 @@
 import { Transaction } from 'ox/tempo'
 import { describe, expect, test } from 'vitest'
 
+const multisigRpcSignature =
+  '0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b' as const
+
 describe('fromRpc', () => {
   test('default', () => {
     const transaction = Transaction.fromRpc({
@@ -527,3 +530,61 @@ describe('toRpc', () => {
     `)
   })
 })
+
+describe('roundtrip', () => {
+  test('behavior: multisig RPC signature', () => {
+    const rpc = {
+      accessList: [],
+      blockHash:
+        '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+      blockNumber: '0x12f296f',
+      calls: [],
+      chainId: '0x1',
+      feeToken: '0x20c0000000000000000000000000000000000000',
+      from: '0x9dba7f426b711d4893c11611eacf7cc334e7146b',
+      gas: '0x43f5d',
+      hash: '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+      maxFeePerGas: '0x2',
+      maxPriorityFeePerGas: '0x1',
+      nonce: '0x357',
+      signature: multisigRpcSignature,
+      transactionIndex: '0x2',
+      type: '0x76',
+    } as const satisfies Transaction.TempoRpc
+    const transaction = Transaction.fromRpc(rpc)
+
+    expect({
+      rpc: Transaction.toRpc(transaction).signature,
+      signature: transaction.signature,
+    }).toMatchInlineSnapshot(`
+      {
+        "rpc": "0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b",
+        "signature": {
+          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+          "config": {
+            "owners": [
+              {
+                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "threshold": 1,
+            "version": 0n,
+          },
+          "signatures": [
+            {
+              "signature": {
+                "r": 60871800714128149016591846789173983752390955456021923556141688418770269698437n,
+                "s": 24367763726302312398084372528434045669788111037623467391175388828437596076276n,
+                "yParity": 0,
+              },
+              "type": "secp256k1",
+            },
+          ],
+          "type": "multisig",
+        },
+      }
+    `)
+  })
+})

package/tempo/TransactionRequest.test-d.ts

@@ -1,24 +1,24 @@
 import { expectTypeOf, test } from 'vitest'
-import type * as MultisigWitness from './MultisigWitness.js'
+import type * as MultisigSimulation from './MultisigSimulation.js'
 import type * as TransactionRequest from './TransactionRequest.js'
 
 declare const request: TransactionRequest.TransactionRequest
 declare const rpc: TransactionRequest.Rpc
 
-test('transaction requests use domain multisig witnesses', () => {
-  expectTypeOf(request.multisigWitness?.config.version).toEqualTypeOf<
+test('transaction requests use domain multisig simulation specs', () => {
+  expectTypeOf(request.multisigSimulation?.config.version).toEqualTypeOf<
     bigint | undefined
   >()
 
-  const approval = request.multisigWitness?.approvals[0]
+  const approval = request.multisigSimulation?.approvals[0]
   if (approval?.type === 'multisig')
-    expectTypeOf(approval.witness.approvals[0]?.keyType).toEqualTypeOf<
-      MultisigWitness.NestedPrimitiveApproval['keyType']
+    expectTypeOf(approval.spec.approvals[0]?.keyType).toEqualTypeOf<
+      MultisigSimulation.NestedPrimitiveApproval['keyType']
     >()
 })
 
-test('RPC requests use numeric multisig config versions', () => {
-  expectTypeOf(rpc.multisigWitness?.config.version).toEqualTypeOf<
-    number | undefined
+test('RPC requests use encoded multisig configurations', () => {
+  expectTypeOf(rpc.multisigSimulation?.config).toEqualTypeOf<
+    `0x${string}` | undefined
   >()
 })

package/tempo/TransactionRequest.test.ts

@@ -1,7 +1,11 @@
-import { type MultisigWitness, TransactionRequest } from 'ox/tempo'
+import {
+  MultisigConfig,
+  type MultisigSimulation,
+  TransactionRequest,
+} from 'ox/tempo'
 import { describe, expect, test } from 'vitest'
 
-const multisigWitnessRpc = {
+const multisigSimulationRpc = {
   account: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
   approvals: [
     {
@@ -10,8 +14,7 @@ const multisigWitnessRpc = {
       type: 'primitive',
     },
     {
-      type: 'multisig',
-      witness: {
+      spec: {
         account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
         approvals: [
           {
@@ -20,7 +23,25 @@ const multisigWitnessRpc = {
             owner: '0x2222222222222222222222222222222222222222',
           },
         ],
-        config: {
+        config:
+          '0xf83ba022222222222222222222222222222222222222222222222222222222222222220101d7d694222222222222222222222222222222222222222201',
+      },
+      type: 'multisig',
+    },
+  ],
+  config:
+    '0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
+} as const satisfies MultisigSimulation.Rpc
+
+const multisigSimulation = {
+  account: multisigSimulationRpc.account,
+  approvals: [
+    multisigSimulationRpc.approvals[0],
+    {
+      spec: {
+        account: multisigSimulationRpc.approvals[1].spec.account,
+        approvals: multisigSimulationRpc.approvals[1].spec.approvals,
+        config: MultisigConfig.from({
           owners: [
             {
               owner: '0x2222222222222222222222222222222222222222',
@@ -29,12 +50,13 @@ const multisigWitnessRpc = {
           ],
           salt: `0x${'22'.repeat(32)}`,
           threshold: 1,
-          version: 1,
-        },
+          version: 1n,
+        }),
       },
+      type: 'multisig',
     },
   ],
-  config: {
+  config: MultisigConfig.from({
     owners: [
       {
         owner: '0x1111111111111111111111111111111111111111',
@@ -47,27 +69,8 @@ const multisigWitnessRpc = {
     ],
     salt: `0x${'11'.repeat(32)}`,
     threshold: 2,
-    version: 0,
-  },
-} as const satisfies MultisigWitness.Rpc
-
-const multisigWitness = {
-  ...multisigWitnessRpc,
-  approvals: [
-    multisigWitnessRpc.approvals[0],
-    {
-      ...multisigWitnessRpc.approvals[1],
-      witness: {
-        ...multisigWitnessRpc.approvals[1].witness,
-        config: {
-          ...multisigWitnessRpc.approvals[1].witness.config,
-          version: 1n,
-        },
-      },
-    },
-  ],
-  config: { ...multisigWitnessRpc.config, version: 0n },
-} as const satisfies MultisigWitness.MultisigWitness
+  }),
+} as const satisfies MultisigSimulation.Spec
 
 describe('fromRpc', () => {
   test('default', () => {
@@ -137,19 +140,64 @@ describe('fromRpc', () => {
     expect(request.nonceKey).toBe(255n)
   })
 
-  test('behavior: multisig witness', () => {
+  test('behavior: multisig simulation', () => {
     const request = TransactionRequest.fromRpc({
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigWitness: multisigWitnessRpc,
+      multisigSimulation: multisigSimulationRpc,
       type: '0x76',
     })
 
-    expect(request.multisigWitness?.config.version).toBe(0n)
-    const nested = request.multisigWitness?.approvals[1]
-    expect(nested?.type).toBe('multisig')
-    if (nested?.type !== 'multisig') throw new Error('expected multisig')
-    expect(nested.witness.config.version).toBe(1n)
-    expect(nested.witness.approvals[0]?.keyType).toBe('webAuthn')
+    expect(request.multisigSimulation).toMatchInlineSnapshot(`
+      {
+        "account": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "approvals": [
+          {
+            "keyType": "secp256k1",
+            "owner": "0x1111111111111111111111111111111111111111",
+            "type": "primitive",
+          },
+          {
+            "spec": {
+              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "approvals": [
+                {
+                  "keyData": "0x0578",
+                  "keyType": "webAuthn",
+                  "owner": "0x2222222222222222222222222222222222222222",
+                },
+              ],
+              "config": {
+                "owners": [
+                  {
+                    "owner": "0x2222222222222222222222222222222222222222",
+                    "weight": 1,
+                  },
+                ],
+                "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
+                "threshold": 1,
+                "version": 1n,
+              },
+            },
+            "type": "multisig",
+          },
+        ],
+        "config": {
+          "owners": [
+            {
+              "owner": "0x1111111111111111111111111111111111111111",
+              "weight": 1,
+            },
+            {
+              "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "weight": 1,
+            },
+          ],
+          "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
+          "threshold": 2,
+          "version": 0n,
+        },
+      }
+    `)
   })
 
   test('behavior: empty', () => {
@@ -206,18 +254,43 @@ describe('toRpc', () => {
     `)
   })
 
-  test('behavior: multisig witness', () => {
+  test('behavior: multisig simulation', () => {
     const request = TransactionRequest.toRpc({
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigWitness,
+      multisigSimulation,
     })
 
-    expect(request.multisigWitness?.config.version).toBe(0)
-    const nested = request.multisigWitness?.approvals[1]
-    expect(nested?.type).toBe('multisig')
-    if (nested?.type !== 'multisig') throw new Error('expected multisig')
-    expect(nested.witness.config.version).toBe(1)
-    expect(request.type).toBe('0x76')
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "from": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "multisigSimulation": {
+          "account": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "approvals": [
+            {
+              "keyType": "secp256k1",
+              "owner": "0x1111111111111111111111111111111111111111",
+              "type": "primitive",
+            },
+            {
+              "spec": {
+                "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "approvals": [
+                  {
+                    "keyData": "0x0578",
+                    "keyType": "webAuthn",
+                    "owner": "0x2222222222222222222222222222222222222222",
+                  },
+                ],
+                "config": "0xf83ba022222222222222222222222222222222222222222222222222222222222222220101d7d694222222222222222222222222222222222222222201",
+              },
+              "type": "multisig",
+            },
+          ],
+          "config": "0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01",
+        },
+        "type": "0x76",
+      }
+      `)
   })
 })
 
@@ -241,7 +314,7 @@ describe('roundtrip', () => {
       nonceKey: 255n,
       gas: 100000n,
       maxFeePerGas: 1000000000n,
-      multisigWitness,
+      multisigSimulation,
     }
 
     const rpc = TransactionRequest.toRpc(original)
@@ -262,7 +335,7 @@ describe('roundtrip', () => {
     expect(converted.nonceKey).toBe(original.nonceKey)
     expect(converted.gas).toBe(original.gas)
     expect(converted.maxFeePerGas).toBe(original.maxFeePerGas)
-    expect(converted.multisigWitness).toEqual(original.multisigWitness)
+    expect(converted.multisigSimulation).toEqual(original.multisigSimulation)
     expect(converted.type).toBe('tempo')
   })
 
@@ -280,7 +353,7 @@ describe('roundtrip', () => {
       validAfter: '0x32',
       nonceKey: '0xff',
       gas: '0x186a0',
-      multisigWitness: multisigWitnessRpc,
+      multisigSimulation: multisigSimulationRpc,
       type: '0x76',
     }
 
@@ -293,7 +366,7 @@ describe('roundtrip', () => {
     expect(rpc.validAfter).toBe(original.validAfter)
     expect(rpc.nonceKey).toBe(original.nonceKey)
     expect(rpc.gas).toBe(original.gas)
-    expect(rpc.multisigWitness).toEqual(original.multisigWitness)
+    expect(rpc.multisigSimulation).toEqual(original.multisigSimulation)
     expect(rpc.type).toBe('0x76')
   })
 })

package/tempo/TransactionRequest.ts

@@ -4,7 +4,7 @@ import type { Compute } from '../core/internal/types.js'
 import * as ox_TransactionRequest from '../core/TransactionRequest.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigWitness from './MultisigWitness.js'
+import * as MultisigSimulation from './MultisigSimulation.js'
 import * as TempoAddress from './TempoAddress.js'
 import * as TokenId from './TokenId.js'
 import * as Transaction from './Transaction.js'
@@ -34,27 +34,27 @@ export type TransactionRequest<
       | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
     calls?: readonly Call<bigintType, addressType>[] | undefined
+    feePayer?: boolean | undefined
+    feeToken?: TokenId.TokenIdOrAddress<addressType> | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
     keyType?: KeyType | undefined
-    feePayer?: boolean | undefined
-    feeToken?: TokenId.TokenIdOrAddress<addressType> | undefined
-    multisigWitness?: MultisigWitness.MultisigWitness<bigintType> | undefined
+    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: 'random' | bigintType | undefined
-    validBefore?: numberType | undefined
     validAfter?: numberType | undefined
+    validBefore?: numberType | undefined
   }
 >
 
 /** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
 export type Rpc = Omit<
   TransactionRequest<Hex.Hex, Hex.Hex, string, Hex.Hex>,
-  'authorizationList' | 'feeToken' | 'keyAuthorization' | 'multisigWitness'
+  'authorizationList' | 'feeToken' | 'keyAuthorization' | 'multisigSimulation'
 > & {
   authorizationList?: AuthorizationTempo.ListRpc | undefined
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
-  multisigWitness?: MultisigWitness.Rpc | undefined
+  multisigSimulation?: MultisigSimulation.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
 }
 
@@ -79,7 +79,7 @@ export type Rpc = Omit<
  * @returns A transaction request.
  */
 export function fromRpc(request: Rpc): TransactionRequest {
-  const { authorizationList: _, multisigWitness: __, ...rest } = request
+  const { authorizationList: _, multisigSimulation: __, ...rest } = request
   const request_ = ox_TransactionRequest.fromRpc(
     rest as any,
   ) as TransactionRequest
@@ -110,8 +110,10 @@ export function fromRpc(request: Rpc): TransactionRequest {
     request_.keyAuthorization = KeyAuthorization.fromRpc(
       request.keyAuthorization,
     )
-  if (request.multisigWitness)
-    request_.multisigWitness = MultisigWitness.fromRpc(request.multisigWitness)
+  if (request.multisigSimulation)
+    request_.multisigSimulation = MultisigSimulation.fromRpc(
+      request.multisigSimulation,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = Hex.toNumber(request.validBefore as Hex.Hex)
   if (typeof request.validAfter !== 'undefined')
@@ -125,9 +127,9 @@ export function fromRpc(request: Rpc): TransactionRequest {
 export declare namespace fromRpc {
   export type ErrorType =
     | AuthorizationTempo.fromRpcList.ErrorType
-    | MultisigWitness.fromRpc.ErrorType
-    | Hex.toNumber.ErrorType
     | Hex.toBigInt.ErrorType
+    | Hex.toNumber.ErrorType
+    | MultisigSimulation.fromRpc.ErrorType
     | Errors.GlobalErrorType
 }
 
@@ -210,8 +212,10 @@ export function toRpc(request: TransactionRequest): Rpc {
     request_rpc.keyAuthorization = KeyAuthorization.toRpc(
       request.keyAuthorization,
     )
-  if (request.multisigWitness)
-    request_rpc.multisigWitness = MultisigWitness.toRpc(request.multisigWitness)
+  if (request.multisigSimulation)
+    request_rpc.multisigSimulation = MultisigSimulation.toRpc(
+      request.multisigSimulation,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = Hex.fromNumber(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -230,7 +234,7 @@ export function toRpc(request: TransactionRequest): Rpc {
     typeof request.feePayer !== 'undefined' ||
     typeof request.feeToken !== 'undefined' ||
     typeof request.keyAuthorization !== 'undefined' ||
-    typeof request.multisigWitness !== 'undefined' ||
+    typeof request.multisigSimulation !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -249,7 +253,7 @@ export function toRpc(request: TransactionRequest): Rpc {
 export declare namespace toRpc {
   export type ErrorType =
     | AuthorizationTempo.toRpcList.ErrorType
-    | MultisigWitness.toRpc.ErrorType
+    | MultisigSimulation.toRpc.ErrorType
     | Hex.fromNumber.ErrorType
     | Errors.GlobalErrorType
 }

package/tempo/index.ts

@@ -160,14 +160,14 @@ export * as MultisigConfig from './MultisigConfig.js'
  */
 export * as MultisigOperation from './MultisigOperation.js'
 /**
- * Native multisig RPC simulation witness utilities.
+ * Native multisig RPC simulation utilities.
  *
- * Converts complete root and nested owner witnesses between their domain and
- * Tempo JSON-RPC representations.
+ * Converts complete root and nested owner specs between their domain and Tempo
+ * JSON-RPC representations.
  *
  * @category Reference
  */
-export * as MultisigWitness from './MultisigWitness.js'
+export * as MultisigSimulation from './MultisigSimulation.js'
 /**
  * Utilities for constructing period durations (in seconds) for recurring spending limits.
  *