ox 1.7.1 → 1.7.4

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

@@ -19,39 +19,25 @@ const p256 = {
   type: 'p256',
 } as const
 
-const multisig = {
-  account: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
-  signatures: [secp256k1],
-} as const
-
-const multisigBootstrap = {
-  init: {
-    owners: [
-      {
-        owner: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
-        weight: 1,
-      },
-    ],
-    salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-    threshold: 1,
-  },
-  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',
@@ -62,152 +48,103 @@ describe('SignatureEnvelope', () => {
     )
   })
 
-  test('decodes an initialized multisig envelope', () => {
+  test('behavior: decodes a multisig envelope', () => {
     expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)).toEqual(
       core_SignatureEnvelope.fromRpc(multisig),
     )
   })
 
-  test('decodes a bootstrap multisig envelope', () => {
+  test('behavior: decodes recursive multisig approvals', () => {
     expect(
-      z.decode(z_SignatureEnvelope.SignatureEnvelope, multisigBootstrap),
-    ).toEqual(core_SignatureEnvelope.fromRpc(multisigBootstrap))
+      z.decode(z_SignatureEnvelope.SignatureEnvelope, nestedMultisig),
+    ).toEqual(core_SignatureEnvelope.fromRpc(nestedMultisig))
   })
 
-  test('decodes recursive multisig approvals', () => {
-    const nested = {
-      ...multisig,
-      signatures: [
-        {
-          account: '0x1111111111111111111111111111111111111111',
-          signatures: [secp256k1],
-        },
-      ],
-    } as const
-    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, nested)).toEqual(
-      core_SignatureEnvelope.fromRpc(nested),
-    )
-  })
-
-  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 initialized 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),
-    )
-  })
-
-  test('round-trips bootstrap multisig via encode', () => {
-    const decoded = z.decode(
-      z_SignatureEnvelope.SignatureEnvelope,
-      multisigBootstrap,
-    )
-    expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
-      multisigBootstrap,
+      multisig,
     )
   })
 
-  test('rejects invalid recursive multisig domains before encode', () => {
-    const invalid = {
-      account: multisig.account,
-      signatures: [
-        {
-          inner: core_SignatureEnvelope.fromRpc(secp256k1),
-          type: 'keychain',
-          userAddress: multisig.account,
-        },
-      ],
-      type: 'multisig',
-    } as const
-
+  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.safeEncode(z_SignatureEnvelope.SignatureEnvelope, invalid as never)
-        .success,
-    ).toMatchInlineSnapshot(`false`)
-  })
-
-  test('rejects legacy multisig approval encoding', () => {
-    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',
-      signatures: [secp256k1],
-    } as const
-    const depth3 = {
-      account: '0x2222222222222222222222222222222222222222',
-      signatures: [depth2],
-    } as const
-
+  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: [keychain],
-      }).success,
-    ).toMatchInlineSnapshot(`false`)
-    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 mixed multisig initialization fields', () => {
+  test('error: rejects structured multisig RPC envelopes', () => {
     expect(
       z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
-        ...multisigBootstrap,
-        account: multisig.account,
+        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

@@ -44,27 +44,12 @@ describe('TransactionRequest', () => {
     )
   })
 
-  test('gas-model hints and capabilities round-trip', () => {
+  test('capabilities and key hints round-trip', () => {
     const hints = {
       capabilities: { balanceDiffs: true },
       keyData: '0x0578',
       keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
       keyType: 'webAuthn',
-      multisigInit: {
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        threshold: 2,
-        owners: [
-          {
-            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            weight: 1,
-          },
-          {
-            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-            weight: 1,
-          },
-        ],
-      },
-      multisigSignatureCount: 2,
     } as const
 
     const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
@@ -78,6 +63,48 @@ describe('TransactionRequest', () => {
     expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
   })
 
+  test('multisig simulation round-trips', () => {
+    const 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',
+    } as const
+
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
+      ...rpc,
+      multisigSimulation,
+    })
+    expect(decoded).toEqual(
+      core_TransactionRequest.fromRpc({ ...rpc, multisigSimulation }),
+    )
+
+    const encoded = z.encode(z_TransactionRequest.TransactionRequest, decoded)
+    expect(encoded.multisigSimulation).toStrictEqual(multisigSimulation)
+    expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
+  })
+
   test('feeToken is withheld until the fee payer signs (TIP-76)', () => {
     const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
     const pending = z.encode(z_TransactionRequest.TransactionRequest, {

package/src/zod/tempo/z.ts

@@ -2,6 +2,8 @@
 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 MultisigSimulation from './MultisigSimulation.js'
 export * as PoolId from './PoolId.js'
 export * as RpcSchemaTempo from './RpcSchemaTempo.js'
 export * as SignatureEnvelope from './SignatureEnvelope.js'