ox 1.7.2 → 1.7.5

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

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_MultisigSimulation from '../../../tempo/MultisigSimulation.js'
+import * as z_MultisigSimulation from '../MultisigSimulation.js'
+import * as z from 'zod/mini'
+
+const rpc = {
+  approvals: [
+    {
+      keyType: 'webAuthn',
+      keyData: '0x0005',
+      owner: '0x1111111111111111111111111111111111111111',
+    },
+  ],
+  config:
+    '0xf852a011111111111111111111111111111111111111111111111111111111111111110102eed694aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa01d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
+} as const satisfies core_MultisigSimulation.Rpc
+
+describe('MultisigSimulation', () => {
+  test('behavior: converts between RPC and domain specs', () => {
+    const spec = z.decode(z_MultisigSimulation.MultisigSimulation, rpc)
+
+    expect(spec).toEqual(core_MultisigSimulation.fromRpc(rpc))
+    expect(
+      z.encode(z_MultisigSimulation.MultisigSimulation, spec),
+    ).toStrictEqual(rpc)
+  })
+
+  test('error: rejects more than eight root approvals', () => {
+    expect(
+      z.safeDecode(z_MultisigSimulation.Rpc, {
+        ...rpc,
+        approvals: Array.from({ length: 9 }, () => rpc.approvals[0]),
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+  test('error: rejects nested approvals', () => {
+    expect(
+      z.safeDecode(z_MultisigSimulation.Rpc, {
+        ...rpc,
+        approvals: [{ type: 'multisig', spec: rpc }],
+      } as never).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('error: rejects malformed encoded configurations', () => {
+    expect(
+      z.safeDecode(z_MultisigSimulation.Rpc, {
+        ...rpc,
+        config: '0x01',
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+})

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,23 +19,22 @@ const p256 = {
   type: 'p256',
 } as const
 
-const config = {
-  owners: [
-    {
-      owner: '0x7e5f4552091a69125d5dfcb7b8c2659029395bdf',
-      weight: 1,
-    },
+const envelope = core_SignatureEnvelope.from({
+  account: '0x2222222222222222222222222222222222222222',
+  config: {
+    version: 2n,
+    threshold: 1,
+    owners: [
+      { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+    ],
+  },
+  signatures: [
+    core_SignatureEnvelope.fromRpc(
+      secp256k1,
+    ) as core_SignatureEnvelope.Primitive,
   ],
-  salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-  threshold: 1,
-  version: '0x0',
-} as const
-
-const multisig = {
-  account: '0x9dba7f426b711d4893c11611eacf7cc334e7146b',
-  config,
-  signatures: [secp256k1],
-} as const
+})
+const multisig = core_SignatureEnvelope.toRpc(envelope)
 
 describe('SignatureEnvelope', () => {
   test('decodes a secp256k1 envelope', () => {
@@ -61,148 +60,128 @@ describe('SignatureEnvelope', () => {
     )
   })
 
-  test('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('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('round-trips versioned multisig RPC bytes', () => {
     const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)
+    expect(decoded).toEqual(envelope)
     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',
+  test('round-trips a multisig delegate in a keychain', () => {
+    const rpc = {
+      type: 'keychain',
+      version: 'v2',
+      userAddress: '0x3333333333333333333333333333333333333333',
+      signature: multisig,
     } as const
-
     expect(
-      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, invalid as never)
-        .success,
-    ).toMatchInlineSnapshot(`false`)
+      z.encode(
+        z_SignatureEnvelope.SignatureEnvelope,
+        z.decode(z_SignatureEnvelope.SignatureEnvelope, rpc),
+      ),
+    ).toEqual(rpc)
   })
 
-  test('rejects legacy multisig approval encoding', () => {
-    expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [
-          core_SignatureEnvelope.serialize(
-            core_SignatureEnvelope.fromRpc(secp256k1),
-          ),
-        ],
-      } as never).success,
-    ).toMatchInlineSnapshot(`false`)
+  test('rejects legacy RPC shapes and malformed bytes', () => {
+    for (const rpc of [
+      { account: envelope.account, signatures: [secp256k1] },
+      '0xc0',
+      '0x',
+    ])
+      expect(
+        z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, rpc as never)
+          .success,
+      ).toMatchInlineSnapshot('false')
   })
 
-  test('rejects multisig approval counts outside protocol limits', () => {
+  test('rejects recursive and empty owner approvals', () => {
+    for (const signatures of [
+      [],
+      [envelope],
+      [{ type: 'keychain', userAddress: envelope.account, inner: envelope }],
+    ])
+      expect(
+        z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+          ...envelope,
+          signatures,
+        } as never).success,
+      ).toMatchInlineSnapshot('false')
+  })
+  test('rejects keychain V1 multisig delegates', () => {
+    const rpc = {
+      type: 'keychain',
+      version: 'v1',
+      userAddress: envelope.account,
+      signature: multisig,
+    } as const
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [],
-      }).success,
-    ).toMatchInlineSnapshot(`false`)
+      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, rpc).success,
+    ).toMatchInlineSnapshot('false')
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: Array.from({ length: 9 }, () => secp256k1),
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        type: 'keychain',
+        version: 'v1',
+        userAddress: envelope.account,
+        inner: envelope,
       }).success,
-    ).toMatchInlineSnapshot(`false`)
+    ).toMatchInlineSnapshot('false')
   })
 
-  test('rejects invalid recursive multisig approvals', () => {
-    const keychain = {
-      signature: secp256k1,
+  test('round-trips primitive RPC envelopes', () => {
+    for (const rpc of [secp256k1, p256])
+      expect(
+        z.encode(
+          z_SignatureEnvelope.SignatureEnvelope,
+          z.decode(z_SignatureEnvelope.SignatureEnvelope, rpc),
+        ),
+      ).toEqual(rpc)
+  })
+})
+
+describe('Keychain', () => {
+  test('rejects V1 wrappers with nested multisig delegates', () => {
+    const inner = {
+      inner: envelope,
       type: 'keychain',
-      userAddress: multisig.account,
+      userAddress: envelope.account,
+      version: 'v2',
     } as const
-    const depth2 = {
-      account: '0x1111111111111111111111111111111111111111',
-      config: { ...config, version: '0x1' },
-      signatures: [secp256k1],
+    const value = {
+      inner,
+      type: 'keychain',
+      userAddress: envelope.account,
+      version: 'v1',
     } as const
-    const depth3 = {
-      account: '0x2222222222222222222222222222222222222222',
-      config: { ...config, version: '0x1' },
-      signatures: [depth2],
+    const rpc = {
+      signature: core_SignatureEnvelope.toRpc(inner),
+      type: 'keychain',
+      userAddress: envelope.account,
+      version: 'v1',
     } as const
-
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [keychain],
-      }).success,
+      z.safeParse(z_SignatureEnvelope.Keychain, value).success,
     ).toMatchInlineSnapshot(`false`)
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        signatures: [depth3],
-      }).success,
+      z.safeParse(z_SignatureEnvelope.KeychainRpc, rpc).success,
     ).toMatchInlineSnapshot(`false`)
-  })
-
-  test('rejects old multisig witness shapes', () => {
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        init: config,
-        account: multisig.account,
-        signatures: [secp256k1],
-      } as never).success,
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, value).success,
     ).toMatchInlineSnapshot(`false`)
-  })
-
-  test('rejects tagged multisig RPC envelopes', () => {
     expect(
-      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisig,
-        type: 'multisig',
-      } as never).success,
+      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, rpc).success,
     ).toMatchInlineSnapshot(`false`)
-  })
-
-  test('rejects an invalid envelope', () => {
+    expect(
+      z.safeEncode(z_SignatureEnvelope.SignatureEnvelope, {
+        ...value,
+        version: 'v2',
+      }).success,
+    ).toMatchInlineSnapshot(`true`)
     expect(
       z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        type: 'secp256k1',
-      } as never).success,
-    ).toBe(false)
+        ...rpc,
+        version: 'v2',
+      }).success,
+    ).toMatchInlineSnapshot(`true`)
   })
 })

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

@@ -63,186 +63,35 @@ 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 = {
       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,
-            },
-          },
+          keyData: '0x0005',
+          owner: '0x1111111111111111111111111111111111111111',
         },
       ],
-      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,
+      keyAuthorizationSimulation: multisigSimulation,
+      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,
+        keyAuthorizationSimulation: multisigSimulation,
+        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.keyAuthorizationSimulation).toStrictEqual(multisigSimulation)
+    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'