ox 1.7.2 → 1.7.4

package/src/zod/tempo/_test/RpcSchemaTempo.test-d.ts

@@ -1,3 +1,5 @@
+import type * as core_Address from '../../../core/Address.js'
+import type * as core_MultisigConfig from '../../../tempo/MultisigConfig.js'
 import type * as core_MultisigOperation from '../../../tempo/MultisigOperation.js'
 import type * as z from 'zod/mini'
 import { expectTypeOf, test } from 'vp/test'
@@ -23,6 +25,9 @@ test('Tempo namespace exposes tempo_simulateV1', () => {
 })
 
 test('multisig methods have the expected method names', () => {
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_approveKeyAuthorization.method
+  >().toEqualTypeOf<'multisig_approveKeyAuthorization'>()
   expectTypeOf<
     typeof z_RpcSchemaTempo.multisig_approveRawTransaction.method
   >().toEqualTypeOf<'multisig_approveRawTransaction'>()
@@ -30,13 +35,22 @@ test('multisig methods have the expected method names', () => {
     typeof z_RpcSchemaTempo.multisig_approveRawTransactionSync.method
   >().toEqualTypeOf<'multisig_approveRawTransactionSync'>()
   expectTypeOf<
-    typeof z_RpcSchemaTempo.multisig_approveKeyAuthorization.method
-  >().toEqualTypeOf<'multisig_approveKeyAuthorization'>()
+    typeof z_RpcSchemaTempo.multisig_getConfig.method
+  >().toEqualTypeOf<'multisig_getConfig'>()
   expectTypeOf<
     typeof z_RpcSchemaTempo.multisig_getOperation.method
   >().toEqualTypeOf<'multisig_getOperation'>()
 })
 
+test('multisig_getConfig has the expected request and return types', () => {
+  expectTypeOf<
+    z.input<typeof z_RpcSchemaTempo.multisig_getConfig.params>
+  >().toEqualTypeOf<[{ address: core_Address.Address }]>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchemaTempo.multisig_getConfig.returns>
+  >().toEqualTypeOf<core_MultisigConfig.Rpc | null>()
+})
+
 test('multisig return schemas decode RPC operations', () => {
   expectTypeOf<
     z.output<typeof z_RpcSchemaTempo.multisig_approveRawTransactionSync.returns>
@@ -47,6 +61,9 @@ test('multisig return schemas decode RPC operations', () => {
 })
 
 test('Multisig namespace exposes multisig methods', () => {
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.Multisig.multisig_getConfig
+  >().toEqualTypeOf<typeof z_RpcSchemaTempo.multisig_getConfig>()
   expectTypeOf<
     typeof z_RpcSchemaTempo.Multisig.multisig_getOperation
   >().toEqualTypeOf<typeof z_RpcSchemaTempo.multisig_getOperation>()

package/src/zod/tempo/_test/RpcSchemaTempo.test.ts

@@ -56,6 +56,16 @@ describe('tempo_simulateV1', () => {
 })
 
 describe('multisig methods', () => {
+  test('decodes key authorization approval params', () => {
+    expect(
+      z_RpcSchema.decodeParams(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_approveKeyAuthorization',
+        [{ hash: '0x01', signature: '0x02' }],
+      ),
+    ).toEqual([{ hash: '0x01', signature: '0x02' }])
+  })
+
   test('decodes raw transaction params', () => {
     expect(
       z_RpcSchema.decodeParams(
@@ -66,14 +76,46 @@ describe('multisig methods', () => {
     ).toEqual(['0x76', 30_000])
   })
 
-  test('decodes key authorization approval params', () => {
+  test('decodes config params', () => {
     expect(
       z_RpcSchema.decodeParams(
         z_RpcSchemaTempo.Multisig,
-        'multisig_approveKeyAuthorization',
-        [{ hash: '0x01', signature: '0x02' }],
+        'multisig_getConfig',
+        [{ address: '0xcafebabecafebabecafebabecafebabecafebabe' }],
       ),
-    ).toEqual([{ hash: '0x01', signature: '0x02' }])
+    ).toEqual([{ address: '0xcafebabecafebabecafebabecafebabecafebabe' }])
+  })
+
+  test('decodes config result', () => {
+    const config = {
+      owners: [
+        {
+          owner: '0x1111111111111111111111111111111111111111',
+          weight: 1,
+        },
+      ],
+      salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      threshold: 1,
+      version: '0x0',
+    } as const
+
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getConfig',
+        config,
+      ),
+    ).toEqual(config)
+  })
+
+  test('accepts a missing config result', () => {
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getConfig',
+        null,
+      ),
+    ).toBeNull()
   })
 
   test('accepts a missing operation result', () => {

package/src/zod/tempo/_test/SignatureEnvelope.test.ts

@@ -19,38 +19,25 @@ const p256 = {
   type: 'p256',
 } as const
 
-const config = {
-  owners: [
-    {
-      owner: '0x7e5f4552091a69125d5dfcb7b8c2659029395bdf',
-      weight: 1,
-    },
-  ],
-  salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-  threshold: 1,
-  version: '0x0',
-} as const
-
-const multisig = {
-  account: '0x9dba7f426b711d4893c11611eacf7cc334e7146b',
-  config,
-  signatures: [secp256k1],
-} as const
+const multisig =
+  '0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b' as const
+const nestedMultisig =
+  '0xf8f0949969e2243075b27a8eab61009c59b77ab13b83f6f83ba033333333333333333333333333333333333333333333333333333333333333338001d7d6944f9f5b162a7464bcc260ce44d7ae0d935f9c583701f89cb89a05f897944f9f5b162a7464bcc260ce44d7ae0d935f9c5837f83ba022222222222222222222222222222222222222222222222222222222222222228001d7d6946813eb9362372eef6200f3b1dbc3f819671cba6901f843b841032aa6f3ea7b0b7069720d0f3891983c493d149326c5c957d864ed7371b8475e3e95325079b24491f4b6d68920e4b3bacd7c6094df6ed88b8674864ab559c8fb1b' as const
 
 describe('SignatureEnvelope', () => {
-  test('decodes a secp256k1 envelope', () => {
+  test('behavior: decodes a secp256k1 envelope', () => {
     expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)).toEqual(
       core_SignatureEnvelope.fromRpc(secp256k1),
     )
   })
 
-  test('decodes a p256 envelope', () => {
+  test('behavior: decodes a p256 envelope', () => {
     expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, p256)).toEqual(
       core_SignatureEnvelope.fromRpc(p256),
     )
   })
 
-  test('decodes a recursive keychain envelope', () => {
+  test('behavior: decodes a recursive keychain envelope', () => {
     const keychain = {
       signature: secp256k1,
       type: 'keychain',
@@ -61,144 +48,103 @@ describe('SignatureEnvelope', () => {
     )
   })
 
-  test('decodes a multisig envelope', () => {
+  test('behavior: decodes a multisig envelope', () => {
     expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)).toEqual(
       core_SignatureEnvelope.fromRpc(multisig),
     )
   })
 
-  test('decodes recursive multisig approvals', () => {
-    const nested = {
-      ...multisig,
-      signatures: [
-        {
-          account: '0x1111111111111111111111111111111111111111',
-          config: {
-            ...config,
-            version: '0x1',
-          },
-          signatures: [secp256k1],
-        },
-      ],
-    } as const
-    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, nested)).toEqual(
-      core_SignatureEnvelope.fromRpc(nested),
-    )
+  test('behavior: decodes recursive multisig approvals', () => {
+    expect(
+      z.decode(z_SignatureEnvelope.SignatureEnvelope, nestedMultisig),
+    ).toEqual(core_SignatureEnvelope.fromRpc(nestedMultisig))
   })
 
-  test('round-trips secp256k1 via encode', () => {
+  test('behavior: round-trips secp256k1 via encode', () => {
     const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)
     expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
       core_SignatureEnvelope.toRpc(decoded),
     )
   })
 
-  test('round-trips multisig via encode', () => {
+  test('behavior: round-trips multisig via encode', () => {
     const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)
     expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
-      core_SignatureEnvelope.toRpc(decoded),
+      multisig,
     )
   })
 
-  test('rejects invalid recursive multisig domains before encode', () => {
-    const invalid = {
-      account: multisig.account,
-      config: { ...config, version: 0n },
-      signatures: [
-        {
-          inner: core_SignatureEnvelope.fromRpc(secp256k1),
-          type: 'keychain',
-          userAddress: multisig.account,
-        },
-      ],
-      type: 'multisig',
-    } as const
-
-    expect(
-      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, invalid as never)
-        .success,
-    ).toMatchInlineSnapshot(`false`)
-  })
-
-  test('rejects legacy multisig approval encoding', () => {
+  test('error: rejects invalid recursive multisig domains before encode', () => {
+    const decoded = core_SignatureEnvelope.fromRpc(multisig)
+    if (decoded.type !== 'multisig') throw new Error('unreachable')
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        ...decoded,
         signatures: [
-          core_SignatureEnvelope.serialize(
-            core_SignatureEnvelope.fromRpc(secp256k1),
-          ),
+          {
+            inner: core_SignatureEnvelope.fromRpc(secp256k1),
+            type: 'keychain',
+            userAddress: decoded.account,
+          },
         ],
       } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
-  test('rejects multisig approval counts outside protocol limits', () => {
+  test('error: rejects multisig approval counts outside protocol limits', () => {
+    const decoded = core_SignatureEnvelope.fromRpc(multisig)
+    if (decoded.type !== 'multisig') throw new Error('unreachable')
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        ...decoded,
         signatures: [],
-      }).success,
+      } as never).success,
     ).toMatchInlineSnapshot(`false`)
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: Array.from({ length: 9 }, () => secp256k1),
-      }).success,
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        ...decoded,
+        signatures: Array.from({ length: 9 }, () => decoded.signatures[0]),
+      } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
-  test('rejects invalid recursive multisig approvals', () => {
-    const keychain = {
-      signature: secp256k1,
-      type: 'keychain',
-      userAddress: multisig.account,
-    } as const
-    const depth2 = {
-      account: '0x1111111111111111111111111111111111111111',
-      config: { ...config, version: '0x1' },
-      signatures: [secp256k1],
-    } as const
-    const depth3 = {
-      account: '0x2222222222222222222222222222222222222222',
-      config: { ...config, version: '0x1' },
-      signatures: [depth2],
-    } as const
-
-    expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [keychain],
-      }).success,
-    ).toMatchInlineSnapshot(`false`)
+  test('error: rejects excess multisig nesting', () => {
+    const nested = core_SignatureEnvelope.fromRpc(nestedMultisig)
+    if (nested.type !== 'multisig') throw new Error('unreachable')
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [depth3],
-      }).success,
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        account: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        config: {
+          ...nested.config,
+          owners: [{ owner: nested.account, weight: 1 }],
+          version: 1n,
+        },
+        signatures: [nested],
+        type: 'multisig',
+      } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
-  test('rejects old multisig witness shapes', () => {
+  test('error: rejects structured multisig RPC envelopes', () => {
     expect(
       z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        init: config,
-        account: multisig.account,
-        signatures: [secp256k1],
+        account: '0x9dba7f426b711d4893c11611eacf7cc334e7146b',
+        config: {},
+        signatures: [],
       } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
-  test('rejects tagged multisig RPC envelopes', () => {
+  test('error: rejects tagged multisig RPC envelopes', () => {
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        type: 'multisig',
-      } as never).success,
+      z.safeDecode(
+        z_SignatureEnvelope.SignatureEnvelope,
+        `0x05${multisig.slice(2)}`,
+      ).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
-  test('rejects an invalid envelope', () => {
+  test('error: rejects an invalid envelope', () => {
     expect(
       z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
         type: 'secp256k1',

package/src/zod/tempo/_test/TransactionRequest.test.ts

@@ -63,186 +63,45 @@ describe('TransactionRequest', () => {
     expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
   })
 
-  test('multisig witness round-trips', () => {
-    const witness = {
-      account: '0xcccccccccccccccccccccccccccccccccccccccc',
+  test('multisig simulation round-trips', () => {
+    const multisigSimulation = {
+      account: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
       approvals: [
         {
-          keyData: '0x0578',
-          keyType: 'webAuthn',
-          owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+          keyType: 'secp256k1',
+          owner: '0x1111111111111111111111111111111111111111',
           type: 'primitive',
         },
         {
-          type: 'multisig',
-          witness: {
+          spec: {
             account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
             approvals: [
               {
-                keyType: 'secp256k1',
-                owner: '0xdddddddddddddddddddddddddddddddddddddddd',
-              },
-              {
-                owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                keyData: '0x0578',
+                keyType: 'webAuthn',
+                owner: '0x2222222222222222222222222222222222222222',
               },
             ],
-            config: {
-              owners: [
-                {
-                  owner: '0xdddddddddddddddddddddddddddddddddddddddd',
-                  weight: 1,
-                },
-                {
-                  owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
-                  weight: 1,
-                },
-              ],
-              salt: '0x2222222222222222222222222222222222222222222222222222222222222222',
-              threshold: 2,
-              version: 2,
-            },
+            config:
+              '0xf83ba022222222222222222222222222222222222222222222222222222222222222220101d7d694222222222222222222222222222222222222222201',
           },
+          type: 'multisig',
         },
       ],
-      config: {
-        owners: [
-          {
-            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            weight: 1,
-          },
-          {
-            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-            weight: 1,
-          },
-        ],
-        salt: '0x1111111111111111111111111111111111111111111111111111111111111111',
-        threshold: 2,
-        version: 1,
-      },
+      config:
+        '0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
     } as const
 
     const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
       ...rpc,
-      multisigWitness: witness,
+      multisigSimulation,
     })
-    expect(decoded.multisigWitness).toMatchInlineSnapshot(`
-      {
-        "account": "0xcccccccccccccccccccccccccccccccccccccccc",
-        "approvals": [
-          {
-            "keyData": "0x0578",
-            "keyType": "webAuthn",
-            "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-            "type": "primitive",
-          },
-          {
-            "type": "multisig",
-            "witness": {
-              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "approvals": [
-                {
-                  "keyType": "secp256k1",
-                  "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
-                },
-                {
-                  "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                },
-              ],
-              "config": {
-                "owners": [
-                  {
-                    "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
-                    "weight": 1,
-                  },
-                  {
-                    "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                    "weight": 1,
-                  },
-                ],
-                "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
-                "threshold": 2,
-                "version": 2n,
-              },
-            },
-          },
-        ],
-        "config": {
-          "owners": [
-            {
-              "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-              "weight": 1,
-            },
-            {
-              "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "weight": 1,
-            },
-          ],
-          "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
-          "threshold": 2,
-          "version": 1n,
-        },
-      }
-    `)
+    expect(decoded).toEqual(
+      core_TransactionRequest.fromRpc({ ...rpc, multisigSimulation }),
+    )
 
     const encoded = z.encode(z_TransactionRequest.TransactionRequest, decoded)
-    expect(encoded.multisigWitness).toMatchInlineSnapshot(`
-      {
-        "account": "0xcccccccccccccccccccccccccccccccccccccccc",
-        "approvals": [
-          {
-            "keyData": "0x0578",
-            "keyType": "webAuthn",
-            "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-            "type": "primitive",
-          },
-          {
-            "type": "multisig",
-            "witness": {
-              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "approvals": [
-                {
-                  "keyType": "secp256k1",
-                  "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
-                },
-                {
-                  "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                },
-              ],
-              "config": {
-                "owners": [
-                  {
-                    "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
-                    "weight": 1,
-                  },
-                  {
-                    "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                    "weight": 1,
-                  },
-                ],
-                "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
-                "threshold": 2,
-                "version": 2,
-              },
-            },
-          },
-        ],
-        "config": {
-          "owners": [
-            {
-              "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-              "weight": 1,
-            },
-            {
-              "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "weight": 1,
-            },
-          ],
-          "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
-          "threshold": 2,
-          "version": 1,
-        },
-      }
-    `)
+    expect(encoded.multisigSimulation).toStrictEqual(multisigSimulation)
     expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
   })
 

package/src/zod/tempo/z.ts

@@ -3,7 +3,7 @@ export * as AuthorizationTempo from './AuthorizationTempo.js'
 export * as KeyAuthorization from './KeyAuthorization.js'
 export * as MultisigConfig from './MultisigConfig.js'
 export * as MultisigOperation from './MultisigOperation.js'
-export * as MultisigWitness from './MultisigWitness.js'
+export * as MultisigSimulation from './MultisigSimulation.js'
 export * as PoolId from './PoolId.js'
 export * as RpcSchemaTempo from './RpcSchemaTempo.js'
 export * as SignatureEnvelope from './SignatureEnvelope.js'

package/dist/tempo/MultisigWitness.d.ts

@@ -1,106 +0,0 @@
-import type * as Address from '../core/Address.js';
-import * as Errors from '../core/Errors.js';
-import * as Hex from '../core/Hex.js';
-import type { Compute } from '../core/internal/types.js';
-import * as MultisigConfig from './MultisigConfig.js';
-import type * as SignatureEnvelope from './SignatureEnvelope.js';
-/** Native multisig owner approval used for RPC simulation. */
-export type Approval<versionType = bigint> = NestedApproval<versionType> | PrimitiveApproval;
-/** Native multisig witness used to construct an RPC simulation signature. */
-export type MultisigWitness<versionType = bigint> = Compute<{
-    /** Account authorized by this witness. */
-    account: Address.Address;
-    /** Owner approvals to model. */
-    approvals: readonly Approval<versionType>[];
-    /** Complete applicable configuration. */
-    config: MultisigConfig.Config<versionType>;
-}>;
-/** Nested native multisig owner approval used for RPC simulation. */
-export type NestedApproval<versionType = bigint> = {
-    /** Approval type. */
-    type: 'multisig';
-    /** Depth-2 multisig witness. */
-    witness: NestedWitness<versionType>;
-};
-/** Primitive approval in a depth-2 multisig simulation witness. */
-export type NestedPrimitiveApproval = {
-    /** Optional signature-specific gas-estimation data. */
-    keyData?: Hex.Hex | undefined;
-    /** Signature type to model. Omission uses a maximum-size WebAuthn signature. */
-    keyType?: SignatureEnvelope.Type | undefined;
-    /** Configured owner address. */
-    owner: Address.Address;
-};
-/** Depth-2 native multisig witness used for RPC simulation. */
-export type NestedWitness<versionType = bigint> = {
-    /** Nested multisig account. */
-    account: Address.Address;
-    /** Primitive owner approvals to model. */
-    approvals: readonly NestedPrimitiveApproval[];
-    /** Complete applicable configuration. */
-    config: MultisigConfig.Config<versionType>;
-};
-/** Primitive owner approval used for RPC simulation. */
-export type PrimitiveApproval = {
-    /** Optional signature-specific gas-estimation data. */
-    keyData?: Hex.Hex | undefined;
-    /** Signature type to model. Omission uses a maximum-size WebAuthn signature. */
-    keyType?: SignatureEnvelope.Type | undefined;
-    /** Configured owner address. */
-    owner: Address.Address;
-    /** Approval type. */
-    type: 'primitive';
-};
-/** JSON-RPC representation of a native multisig simulation witness. */
-export type Rpc = MultisigWitness<number>;
-/**
- * Converts a JSON-RPC multisig witness to its domain representation.
- *
- * @example
- * ```ts twoslash
- * // @noErrors
- * import { MultisigWitness } from 'ox/tempo'
- *
- * const witness = MultisigWitness.fromRpc(witnessRpc)
- * ```
- *
- * @param witness - JSON-RPC multisig witness.
- * @returns The multisig witness with bigint configuration versions.
- */
-export declare function fromRpc(witness: Rpc): MultisigWitness;
-export declare namespace fromRpc {
-    /** Error type for `fromRpc`. */
-    type ErrorType = InvalidWitnessError | MultisigConfig.assert.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Converts a multisig witness to its JSON-RPC representation.
- *
- * @example
- * ```ts twoslash
- * // @noErrors
- * import { MultisigWitness } from 'ox/tempo'
- *
- * const witnessRpc = MultisigWitness.toRpc(witness)
- * ```
- *
- * @param witness - Multisig witness.
- * @returns The JSON-RPC multisig witness with numeric configuration versions.
- */
-export declare function toRpc(witness: MultisigWitness): Rpc;
-export declare namespace toRpc {
-    /** Error type for `toRpc`. */
-    type ErrorType = Hex.fromNumber.ErrorType | Hex.toNumber.ErrorType | InvalidWitnessError | MultisigConfig.assert.ErrorType | Errors.GlobalErrorType;
-}
-/** Thrown when a native multisig witness is invalid. */
-export declare class InvalidWitnessError extends Errors.BaseError {
-    readonly name = "MultisigWitness.InvalidWitnessError";
-    constructor(options: InvalidWitnessError.Options);
-}
-export declare namespace InvalidWitnessError {
-    /** Error construction options. */
-    type Options = {
-        /** Validation failure. */
-        reason: string;
-    };
-}
-//# sourceMappingURL=MultisigWitness.d.ts.map