ox 0.14.29 → 0.14.31

package/tempo/SignatureEnvelope.test.ts

@@ -3,6 +3,7 @@ import {
   Hex,
   P256,
   PublicKey,
+  Rlp,
   Secp256k1,
   Signature,
   WebAuthnP256,
@@ -1109,7 +1110,7 @@ describe('from', () => {
       ],
     })
 
-    test('behavior: derives `account`/`genesisConfigId` from `genesisConfig`', () => {
+    test('behavior: derives `account` from `genesisConfig`', () => {
       const envelope = SignatureEnvelope.from({
         genesisConfig,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
@@ -1118,7 +1119,6 @@ describe('from', () => {
       expect(envelope).toMatchObject({
         type: 'multisig',
         account: MultisigConfig.getAddress(genesisConfig),
-        genesisConfigId: MultisigConfig.toId(genesisConfig),
       })
       expect('genesisConfig' in envelope).toBe(false)
       expect((envelope as SignatureEnvelope.Multisig).init).toBeUndefined()
@@ -1155,19 +1155,16 @@ describe('from', () => {
       expect((envelope as SignatureEnvelope.Multisig).init).toEqual(otherConfig)
     })
 
-    test('behavior: `{account, genesisConfigId}` form still works', () => {
+    test('behavior: `{ account }` form still works', () => {
       const account = MultisigConfig.getAddress(genesisConfig)
-      const genesisConfigId = MultisigConfig.toId(genesisConfig)
       const envelope = SignatureEnvelope.from({
         account,
-        genesisConfigId,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
       })
 
       expect(envelope).toMatchObject({
         type: 'multisig',
         account,
-        genesisConfigId,
       })
     })
   })
@@ -1836,9 +1833,8 @@ describe('sortMultisigApprovals', () => {
     expect(recovered).toEqual(ascending.map((owner) => owner.address))
   })
 
-  test('behavior: `genesisConfig` and `{account, genesisConfigId}` produce identical ordering', () => {
+  test('behavior: `genesisConfig` and `{ account }` produce identical ordering', () => {
     const account = MultisigConfig.getAddress(genesisConfig)
-    const genesisConfigId = MultisigConfig.toId(genesisConfig)
     const signatures = owners.map((owner) => owner.signature)
 
     const fromConfig = SignatureEnvelope.sortMultisigApprovals({
@@ -1846,13 +1842,12 @@ describe('sortMultisigApprovals', () => {
       payload,
       signatures,
     })
-    const fromIds = SignatureEnvelope.sortMultisigApprovals({
+    const fromAccount = SignatureEnvelope.sortMultisigApprovals({
       account,
-      genesisConfigId,
       payload,
       signatures,
     })
-    expect(fromConfig).toEqual(fromIds)
+    expect(fromConfig).toEqual(fromAccount)
   })
 })
 
@@ -2855,8 +2850,6 @@ describe('CoercionError', () => {
 
 describe('multisig', () => {
   const account = '0x8ba6d26ff5c4e82ba0c8caf8c8ca794e1489a7ae'
-  const genesisConfigId =
-    '0x01781fe551182476f2422c759e82d81c92e3263737afbbad57def6e8b69d21f5'
 
   // P256 signatures do not carry `yParity` in the wire format, so use a clean
   // inner signature for round-trip equality checks.
@@ -2869,7 +2862,6 @@ describe('multisig', () => {
   const envelope = SignatureEnvelope.from({
     type: 'multisig',
     account,
-    genesisConfigId,
     signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
   })
 
@@ -2878,13 +2870,61 @@ describe('multisig', () => {
     expect(serialized.startsWith('0x05')).toBe(true)
   })
 
+  test('serialize: wire shape is `0x05 || rlp([account, signatures])`', () => {
+    const deterministic = SignatureEnvelope.from({
+      type: 'multisig',
+      account,
+      signatures: [innerP256],
+    })
+    expect(SignatureEnvelope.serialize(deterministic)).toMatchInlineSnapshot(
+      `"0x05f89b948ba6d26ff5c4e82ba0c8caf8c8ca794e1489a7aef884b88201ccbb3485d4726235f13cb15ef394fb7158179fb7b1925eccec0147671090c52e77c3c53373cc1e3b05e7c23f609deb17cea8fe097300c45411237e9fe4166b35ad8ac16e167d6992c3e120d7f17d2376bc1cbcf30c46ba6dd00ce07303e742f511edf6ce1c32de66846f56afa7be1cbd729bc35750b6d0cdcf3ec9d75461aba001"`,
+    )
+  })
+
   test('serialize/deserialize round-trip', () => {
     const serialized = SignatureEnvelope.serialize(envelope)
     expect(SignatureEnvelope.deserialize(serialized)).toEqual(envelope)
   })
 
+  test('deserialize: rejects the legacy three-field wire shape', () => {
+    const init = MultisigConfig.toTuple({
+      threshold: 1,
+      owners: [
+        { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+      ],
+    })
+    const legacy = Hex.concat(
+      '0x05',
+      Rlp.fromHex([account, [SignatureEnvelope.serialize(innerP256)], init]),
+    )
+    expect(() => SignatureEnvelope.deserialize(legacy)).toThrowError(
+      SignatureEnvelope.InvalidSerializedError,
+    )
+  })
+
+  test('deserialize: rejects an invalid initialized account', () => {
+    const malformed = Hex.concat(
+      '0x05',
+      Rlp.fromHex(['0x11', [SignatureEnvelope.serialize(innerP256)]]),
+    )
+    expect(() => SignatureEnvelope.deserialize(malformed)).toThrowError(
+      SignatureEnvelope.InvalidSerializedError,
+    )
+  })
+
   test('getType', () => {
     expect(SignatureEnvelope.getType(envelope)).toBe('multisig')
+    expect(
+      SignatureEnvelope.getType({
+        init: {
+          threshold: 1,
+          owners: [
+            { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+          ],
+        },
+        signatures: [innerP256],
+      } as never),
+    ).toBe('multisig')
   })
 
   test('extractAddress returns the multisig account', () => {
@@ -2897,9 +2937,19 @@ describe('multisig', () => {
   })
 
   test('toRpc/fromRpc round-trip', () => {
-    const rpc = SignatureEnvelope.toRpc(envelope)
-    expect(rpc.type).toBe('multisig')
+    const rpc = SignatureEnvelope.toRpc(
+      envelope,
+    ) as SignatureEnvelope.MultisigRpc
+    expect(rpc).toMatchObject({
+      account,
+      signatures: [{ type: 'secp256k1' }, { type: 'p256' }],
+    })
+    expect(rpc.init).toBeUndefined()
+    expect('type' in rpc).toBe(false)
     expect(SignatureEnvelope.fromRpc(rpc)).toEqual(envelope)
+    expect(
+      SignatureEnvelope.fromRpc({ ...rpc, type: 'multisig' } as never),
+    ).toEqual(envelope)
   })
 
   test('assert: missing properties', () => {
@@ -2908,6 +2958,156 @@ describe('multisig', () => {
     ).toThrowError()
   })
 
+  test('assert: rejects empty owner approvals', () => {
+    expect(() =>
+      SignatureEnvelope.assert({
+        type: 'multisig',
+        account,
+        signatures: [],
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig signatures cannot be empty.]`,
+    )
+  })
+
+  test('assert: accepts at most eight owner approvals', () => {
+    expect(() =>
+      SignatureEnvelope.assert({
+        type: 'multisig',
+        account,
+        signatures: Array.from(
+          { length: MultisigConfig.maxSignatures },
+          () => innerP256,
+        ),
+      }),
+    ).not.toThrow()
+
+    expect(() =>
+      SignatureEnvelope.assert({
+        type: 'multisig',
+        account,
+        signatures: Array.from(
+          { length: MultisigConfig.maxSignatures + 1 },
+          () => innerP256,
+        ),
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig signatures exceed 8.]`,
+    )
+  })
+
+  test('assert: rejects oversized owner approvals', () => {
+    const oversized = {
+      ...signature_webauthn,
+      metadata: {
+        ...signature_webauthn.metadata,
+        clientDataJSON: JSON.stringify({ value: 'x'.repeat(2048) }),
+      },
+    }
+    expect(() =>
+      SignatureEnvelope.assert({
+        type: 'multisig',
+        account,
+        signatures: [oversized],
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig owner signature exceeds 2049 bytes.]`,
+    )
+  })
+
+  test('assert: rejects keychain owner approvals', () => {
+    expect(() =>
+      SignatureEnvelope.assert({
+        type: 'multisig',
+        account,
+        signatures: [signature_keychain_secp256k1],
+      } as never),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: keychain owner approvals are not allowed.]`,
+    )
+  })
+
+  describe('nested approvals', () => {
+    const nestedAccount = '0x1111111111111111111111111111111111111111'
+    const nested = SignatureEnvelope.from({
+      type: 'multisig',
+      account: nestedAccount,
+      signatures: [innerP256],
+    })
+
+    test('serialize/deserialize round-trip with a nested multisig approval', () => {
+      const parent = SignatureEnvelope.from({
+        type: 'multisig',
+        account,
+        signatures: [innerP256, nested],
+      })
+      const serialized = SignatureEnvelope.serialize(parent)
+      expect(SignatureEnvelope.deserialize(serialized)).toEqual(parent)
+    })
+
+    test('assert: accepts the maximum nesting depth', () => {
+      const depth2 = SignatureEnvelope.from({
+        type: 'multisig',
+        account,
+        signatures: [nested],
+      })
+      expect(() => SignatureEnvelope.assert(depth2)).not.toThrowError()
+    })
+
+    test('assert: rejects nesting deeper than the maximum', () => {
+      const depth3 = SignatureEnvelope.from({
+        type: 'multisig',
+        account,
+        signatures: [
+          SignatureEnvelope.from({
+            type: 'multisig',
+            account: nestedAccount,
+            signatures: [nested],
+          }),
+        ],
+      })
+      expect(() =>
+        SignatureEnvelope.assert(depth3),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig nesting depth exceeds 2.]`,
+      )
+    })
+
+    test('deserialize: rejects nesting deeper than the maximum during decode', () => {
+      const primitive = SignatureEnvelope.serialize(innerP256)
+      const depth1 = Hex.concat(
+        '0x05',
+        Rlp.fromHex([nestedAccount, [primitive]]),
+      )
+      const depth2 = Hex.concat('0x05', Rlp.fromHex([nestedAccount, [depth1]]))
+      const depth3 = Hex.concat('0x05', Rlp.fromHex([account, [depth2]]))
+
+      expect(() => SignatureEnvelope.deserialize(depth3)).toThrowError(
+        SignatureEnvelope.InvalidSerializedError,
+      )
+    })
+
+    test('assert: rejects nested approvals carrying `init`', () => {
+      expect(() =>
+        SignatureEnvelope.assert({
+          type: 'multisig',
+          account,
+          signatures: [
+            {
+              ...nested,
+              init: {
+                threshold: 1,
+                owners: [{ owner: nestedAccount, weight: 1 }],
+              },
+            },
+          ],
+        } as never),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: nested multisig owner approvals cannot carry \`init\`.]`,
+      )
+    })
+  })
+
   describe('init (bootstrap)', () => {
     const init = {
       salt: `0x${'00'.repeat(32)}` as const,
@@ -2919,11 +3119,11 @@ describe('multisig', () => {
         },
       ],
     }
+    const bootstrapAccount = MultisigConfig.getAddress(init)
 
     const bootstrapEnvelope = SignatureEnvelope.from({
       type: 'multisig',
-      account,
-      genesisConfigId,
+      account: bootstrapAccount,
       signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
       init,
     })
@@ -2935,13 +3135,68 @@ describe('multisig', () => {
       )
     })
 
+    test('deserialize: validates bootstrap init semantics', () => {
+      const invalid = Hex.concat(
+        '0x05',
+        Rlp.fromHex([
+          [MultisigConfig.zeroSalt, '0x01', []],
+          [SignatureEnvelope.serialize(innerP256)],
+        ]),
+      )
+      expect(() => SignatureEnvelope.deserialize(invalid)).toThrowError(
+        MultisigConfig.InvalidConfigError,
+      )
+    })
+
+    test('deserialize: rejects noncanonical bootstrap field widths', () => {
+      const signatures = [SignatureEnvelope.serialize(innerP256)]
+      const shortSalt = Hex.concat(
+        '0x05',
+        Rlp.fromHex([
+          [`0x${'00'.repeat(31)}`, '0x01', [[init.owners[0]!.owner, '0x01']]],
+          signatures,
+        ]),
+      )
+      const wideThreshold = Hex.concat(
+        '0x05',
+        Rlp.fromHex([
+          [init.salt, '0x0001', [[init.owners[0]!.owner, '0x01']]],
+          signatures,
+        ]),
+      )
+      const wideWeight = Hex.concat(
+        '0x05',
+        Rlp.fromHex([
+          [init.salt, '0x01', [[init.owners[0]!.owner, '0x0001']]],
+          signatures,
+        ]),
+      )
+
+      for (const serialized of [shortSalt, wideThreshold, wideWeight])
+        expect(() => SignatureEnvelope.deserialize(serialized)).toThrowError(
+          SignatureEnvelope.InvalidSerializedError,
+        )
+    })
+
+    test('serialize: wire shape is `0x05 || rlp([init, signatures])`', () => {
+      const serialized = SignatureEnvelope.serialize(bootstrapEnvelope)
+      const [address] = Rlp.toHex(Hex.slice(serialized, 1)) as readonly [
+        MultisigConfig.Tuple,
+        readonly Hex.Hex[],
+      ]
+      expect(MultisigConfig.fromTuple(address)).toEqual(init)
+    })
+
     test('serialize/deserialize round-trip preserves non-zero salt', () => {
+      const saltedInit = {
+        ...init,
+        salt: `0x${'42'.repeat(32)}` as const,
+      }
       const salted = SignatureEnvelope.from({
         type: 'multisig',
-        account,
-        genesisConfigId,
+        account: MultisigConfig.getAddress(saltedInit),
         signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
-        init: { ...init, salt: `0x${'42'.repeat(32)}` },
+        init: saltedInit,
       })
       const serialized = SignatureEnvelope.serialize(salted)
       const deserialized = SignatureEnvelope.deserialize(
@@ -2964,27 +3219,52 @@ describe('multisig', () => {
     })
 
     test('toRpc/fromRpc round-trip with init', () => {
-      const rpc = SignatureEnvelope.toRpc(bootstrapEnvelope)
+      const rpc = SignatureEnvelope.toRpc(
+        bootstrapEnvelope,
+      ) as SignatureEnvelope.MultisigRpc
       expect(rpc.init).toEqual(init)
+      expect(rpc.account).toBeUndefined()
+      expect('type' in rpc).toBe(false)
       expect(SignatureEnvelope.fromRpc(rpc)).toEqual(bootstrapEnvelope)
     })
 
-    test('toRpc encodes owner approvals as serialized hex (node `Vec<Bytes>`)', () => {
+    test('toRpc encodes owner approvals as structured RPC envelopes', () => {
       const multisig = bootstrapEnvelope as SignatureEnvelope.Multisig
       const rpc = SignatureEnvelope.toRpc(
         multisig,
       ) as SignatureEnvelope.MultisigRpc
       expect(rpc.signatures).toEqual(
-        multisig.signatures.map((s) => SignatureEnvelope.serialize(s)),
+        multisig.signatures.map((signature) =>
+          SignatureEnvelope.toRpc(signature),
+        ),
       )
     })
 
     test('fromRpc detects multisig by shape (no `type` field)', () => {
       const rpc = SignatureEnvelope.toRpc(bootstrapEnvelope)
-      // The node omits the `type` discriminant; detection is shape-based.
-      const { type: _type, ...untyped } = rpc
-      expect(SignatureEnvelope.fromRpc(untyped as never)).toEqual(
+      expect(SignatureEnvelope.fromRpc(rpc)).toEqual(bootstrapEnvelope)
+    })
+
+    test('fromRpc accepts the opposite static property as undefined', () => {
+      const rpc = SignatureEnvelope.toRpc(
         bootstrapEnvelope,
+      ) as SignatureEnvelope.MultisigRpc
+      expect(
+        SignatureEnvelope.fromRpc({ ...rpc, account: undefined } as never),
+      ).toEqual(bootstrapEnvelope)
+    })
+
+    test('fromRpc rejects the legacy combined account and init shape', () => {
+      const rpc = SignatureEnvelope.toRpc(
+        bootstrapEnvelope,
+      ) as SignatureEnvelope.MultisigRpc
+      expect(() =>
+        SignatureEnvelope.fromRpc({
+          ...rpc,
+          account: bootstrapAccount,
+        } as never),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: RPC multisig must contain exactly one of \`account\` or \`init\`.]`,
       )
     })
 
@@ -2992,12 +3272,24 @@ describe('multisig', () => {
       expect(() =>
         SignatureEnvelope.assert({
           type: 'multisig',
-          account,
-          genesisConfigId,
-          signatures: [],
+          account: bootstrapAccount,
+          signatures: [innerP256],
           init: { threshold: 1, owners: [] },
         } as never),
       ).toThrowError()
     })
+
+    test('assert: init must derive the supplied account', () => {
+      expect(() =>
+        SignatureEnvelope.assert({
+          type: 'multisig',
+          account,
+          signatures: [innerP256],
+          init,
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig init does not derive account.]`,
+      )
+    })
   })
 })