ox 0.10.2 → 0.10.4

package/tempo/SignatureEnvelope.test.ts

@@ -1,4 +1,13 @@
-import { Hex, PublicKey, Secp256k1, Signature, WebAuthnP256 } from 'ox'
+import {
+  Address,
+  Hex,
+  P256,
+  PublicKey,
+  Secp256k1,
+  Signature,
+  WebAuthnP256,
+  WebCryptoP256,
+} from 'ox'
 import { describe, expect, test } from 'vitest'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
@@ -477,6 +486,24 @@ describe('deserialize', () => {
       })
     })
 
+    test('behavior: deserializes signature with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(
+        { signature: signature_secp256k1, type: 'secp256k1' },
+        { magic: true },
+      )
+
+      const envelope = SignatureEnvelope.deserialize(serialized)
+
+      expect(envelope).toMatchObject({
+        signature: {
+          r: signature_secp256k1.r,
+          s: signature_secp256k1.s,
+          yParity: signature_secp256k1.yParity,
+        },
+        type: 'secp256k1',
+      })
+    })
+
     test('error: throws on invalid size', () => {
       expect(() =>
         SignatureEnvelope.deserialize('0xdeadbeef'),
@@ -520,6 +547,26 @@ describe('deserialize', () => {
       })
     })
 
+    test('behavior: deserializes P256 signature with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(signature_p256, {
+        magic: true,
+      })
+      const deserialized = SignatureEnvelope.deserialize(serialized)
+
+      expect(deserialized).toMatchObject({
+        signature: {
+          r: signature_p256.signature.r,
+          s: signature_p256.signature.s,
+        },
+        publicKey: {
+          x: signature_p256.publicKey.x,
+          y: signature_p256.publicKey.y,
+        },
+        prehash: signature_p256.prehash,
+        type: 'p256',
+      })
+    })
+
     test('error: throws on invalid P256 signature length', () => {
       // P256 signature with wrong length (should be 130 bytes total, but only 100)
       const invalidSig = `0x01${'00'.repeat(100)}` as `0x${string}`
@@ -557,6 +604,29 @@ describe('deserialize', () => {
       })
     })
 
+    test('behavior: deserializes WebAuthn signature with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(signature_webauthn, {
+        magic: true,
+      })
+      const deserialized = SignatureEnvelope.deserialize(serialized)
+
+      expect(deserialized).toMatchObject({
+        signature: {
+          r: signature_webauthn.signature.r,
+          s: signature_webauthn.signature.s,
+        },
+        publicKey: {
+          x: signature_webauthn.publicKey.x,
+          y: signature_webauthn.publicKey.y,
+        },
+        metadata: {
+          authenticatorData: signature_webauthn.metadata.authenticatorData,
+          clientDataJSON: signature_webauthn.metadata.clientDataJSON,
+        },
+        type: 'webAuthn',
+      })
+    })
+
     test('error: throws on invalid WebAuthn signature length', () => {
       // WebAuthn signature too short (must be at least 129 bytes: 1 type + 128 signature data)
       const invalidSig = `0x02${'00'.repeat(100)}` as const
@@ -676,6 +746,20 @@ describe('deserialize', () => {
       `)
     })
 
+    test('behavior: deserializes keychain signature with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(
+        signature_keychain_secp256k1,
+        { magic: true },
+      )
+      const deserialized = SignatureEnvelope.deserialize(serialized)
+
+      expect(deserialized).toMatchObject({
+        userAddress: signature_keychain_secp256k1.userAddress,
+        inner: SignatureEnvelope.from(signature_secp256k1),
+        type: 'keychain',
+      })
+    })
+
     test('error: throws on invalid keychain signature length', () => {
       // Keychain signature too short (must be at least 21 bytes: 1 type + 20 address)
       const invalidSig = `0x03${'00'.repeat(10)}` as const
@@ -916,6 +1000,20 @@ describe('serialize', () => {
 
       expect(serialized).toBe(Signature.toHex(signature_secp256k1))
     })
+
+    test('behavior: serializes with magic identifier', () => {
+      const envelope: SignatureEnvelope.SignatureEnvelope = {
+        signature: signature_secp256k1,
+        type: 'secp256k1',
+      }
+
+      const serialized = SignatureEnvelope.serialize(envelope, { magic: true })
+
+      expect(serialized.endsWith(SignatureEnvelope.magicBytes.slice(2))).toBe(
+        true,
+      )
+      expect(Hex.size(serialized)).toBe(65 + 32) // signature + magic identifier
+    })
   })
 
   describe('p256', () => {
@@ -936,6 +1034,17 @@ describe('serialize', () => {
       // Last byte should be 0x00 for false
       expect(serialized.slice(-2)).toBe('00')
     })
+
+    test('behavior: serializes with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(signature_p256, {
+        magic: true,
+      })
+
+      expect(serialized.endsWith(SignatureEnvelope.magicBytes.slice(2))).toBe(
+        true,
+      )
+      expect(Hex.size(serialized)).toBe(130 + 32) // signature + magic identifier
+    })
   })
 
   describe('webAuthn', () => {
@@ -966,6 +1075,23 @@ describe('serialize', () => {
         signature_webauthn.metadata.clientDataJSON,
       )
     })
+
+    test('behavior: serializes with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(signature_webauthn, {
+        magic: true,
+      })
+
+      expect(serialized.endsWith(SignatureEnvelope.magicBytes.slice(2))).toBe(
+        true,
+      )
+
+      const authDataLength =
+        (signature_webauthn.metadata.authenticatorData.length - 2) / 2
+      const clientDataLength = signature_webauthn.metadata.clientDataJSON.length
+      const expectedSize = 1 + authDataLength + clientDataLength + 128 + 32 // type + data + signature components + magic
+
+      expect(Hex.size(serialized)).toBe(expectedSize)
+    })
   })
 
   describe('keychain', () => {
@@ -1043,6 +1169,18 @@ describe('serialize', () => {
         },
       })
     })
+
+    test('behavior: serializes with magic identifier', () => {
+      const serialized = SignatureEnvelope.serialize(
+        signature_keychain_secp256k1,
+        { magic: true },
+      )
+
+      expect(serialized.endsWith(SignatureEnvelope.magicBytes.slice(2))).toBe(
+        true,
+      )
+      expect(Hex.size(serialized)).toBe(1 + 20 + 65 + 32) // type + address + secp256k1 + magic
+    })
   })
 
   describe('roundtrip', () => {
@@ -1065,6 +1203,27 @@ describe('serialize', () => {
           type: 'secp256k1',
         })
       })
+
+      test('behavior: roundtrips serialize with magic -> deserialize', () => {
+        const envelope: SignatureEnvelope.Secp256k1 = {
+          signature: signature_secp256k1,
+          type: 'secp256k1',
+        }
+
+        const serialized = SignatureEnvelope.serialize(envelope, {
+          magic: true,
+        })
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject({
+          signature: {
+            r: signature_secp256k1.r,
+            s: signature_secp256k1.s,
+            yParity: signature_secp256k1.yParity,
+          },
+          type: 'secp256k1',
+        })
+      })
     })
 
     describe('p256', () => {
@@ -1093,6 +1252,26 @@ describe('serialize', () => {
 
         expect(deserialized.prehash).toBe(false)
       })
+
+      test('behavior: roundtrips serialize with magic -> deserialize', () => {
+        const serialized = SignatureEnvelope.serialize(signature_p256, {
+          magic: true,
+        })
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject({
+          signature: {
+            r: signature_p256.signature.r,
+            s: signature_p256.signature.s,
+          },
+          publicKey: {
+            x: signature_p256.publicKey.x,
+            y: signature_p256.publicKey.y,
+          },
+          prehash: signature_p256.prehash,
+          type: 'p256',
+        })
+      })
     })
 
     describe('webAuthn', () => {
@@ -1137,6 +1316,29 @@ describe('serialize', () => {
 
         expect(deserialized.metadata?.clientDataJSON).toBe(longClientData)
       })
+
+      test('behavior: roundtrips serialize with magic -> deserialize', () => {
+        const serialized = SignatureEnvelope.serialize(signature_webauthn, {
+          magic: true,
+        })
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject({
+          signature: {
+            r: signature_webauthn.signature.r,
+            s: signature_webauthn.signature.s,
+          },
+          publicKey: {
+            x: signature_webauthn.publicKey.x,
+            y: signature_webauthn.publicKey.y,
+          },
+          metadata: {
+            authenticatorData: signature_webauthn.metadata.authenticatorData,
+            clientDataJSON: signature_webauthn.metadata.clientDataJSON,
+          },
+          type: 'webAuthn',
+        })
+      })
     })
 
     describe('keychain', () => {
@@ -1203,6 +1405,69 @@ describe('serialize', () => {
           }
         `)
       })
+
+      test('behavior: roundtrips serialize with magic -> deserialize with secp256k1 inner', () => {
+        const serialized = SignatureEnvelope.serialize(
+          signature_keychain_secp256k1,
+          { magic: true },
+        )
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject(signature_keychain_secp256k1)
+      })
+
+      test('behavior: roundtrips serialize with magic -> deserialize with p256 inner', () => {
+        const serialized = SignatureEnvelope.serialize(
+          signature_keychain_p256,
+          { magic: true },
+        )
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject({
+          type: 'keychain',
+          userAddress: signature_keychain_p256.userAddress,
+          inner: {
+            type: 'p256',
+            prehash: signature_p256.prehash,
+            publicKey: {
+              x: signature_p256.publicKey.x,
+              y: signature_p256.publicKey.y,
+            },
+            signature: {
+              r: signature_p256.signature.r,
+              s: signature_p256.signature.s,
+            },
+          },
+        })
+      })
+
+      test('behavior: roundtrips serialize with magic -> deserialize with webAuthn inner', () => {
+        const serialized = SignatureEnvelope.serialize(
+          signature_keychain_webauthn,
+          { magic: true },
+        )
+        const deserialized = SignatureEnvelope.deserialize(serialized)
+
+        expect(deserialized).toMatchObject({
+          type: 'keychain',
+          userAddress: signature_keychain_webauthn.userAddress,
+          inner: {
+            type: 'webAuthn',
+            metadata: {
+              authenticatorData: signature_webauthn.metadata.authenticatorData,
+              clientDataJSON: signature_webauthn.metadata.clientDataJSON,
+            },
+            publicKey: {
+              x: signature_webauthn.publicKey.x,
+              y: signature_webauthn.publicKey.y,
+            },
+            signature: {
+              r: signature_webauthn.signature.r,
+              s: signature_webauthn.signature.s,
+            },
+          },
+        })
+      })
     })
   })
 
@@ -1326,6 +1591,294 @@ describe('validate', () => {
   })
 })
 
+describe('verify', () => {
+  describe('secp256k1', () => {
+    test('behavior: verifies valid signature with publicKey', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const publicKey = Secp256k1.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = Secp256k1.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from(signature)
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: verifies valid signature with address', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const publicKey = Secp256k1.getPublicKey({ privateKey })
+      const address = Address.fromPublicKey(publicKey)
+      const payload = '0xdeadbeef' as const
+
+      const signature = Secp256k1.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from(signature)
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          address,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: returns false for wrong publicKey', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const wrongPrivateKey = Secp256k1.randomPrivateKey()
+      const wrongPublicKey = Secp256k1.getPublicKey({
+        privateKey: wrongPrivateKey,
+      })
+      const payload = '0xdeadbeef' as const
+
+      const signature = Secp256k1.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from(signature)
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey: wrongPublicKey,
+        }),
+      ).toBe(false)
+    })
+
+    test('behavior: returns false for wrong payload', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const publicKey = Secp256k1.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = Secp256k1.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from(signature)
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload: '0xcafebabe',
+          publicKey,
+        }),
+      ).toBe(false)
+    })
+  })
+
+  describe('p256', () => {
+    test('behavior: verifies valid signature with publicKey', () => {
+      const privateKey = P256.randomPrivateKey()
+      const publicKey = P256.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = P256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: false,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: verifies valid signature with address', () => {
+      const privateKey = P256.randomPrivateKey()
+      const publicKey = P256.getPublicKey({ privateKey })
+      const address = Address.fromPublicKey(publicKey)
+      const payload = '0xdeadbeef' as const
+
+      const signature = P256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: false,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          address,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: returns false for mismatched publicKey', () => {
+      const privateKey = P256.randomPrivateKey()
+      const publicKey = P256.getPublicKey({ privateKey })
+      const wrongPrivateKey = P256.randomPrivateKey()
+      const wrongPublicKey = P256.getPublicKey({ privateKey: wrongPrivateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = P256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: false,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey: wrongPublicKey,
+        }),
+      ).toBe(false)
+    })
+
+    test('behavior: returns false for wrong payload', () => {
+      const privateKey = P256.randomPrivateKey()
+      const publicKey = P256.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = P256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: false,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload: '0xcafebabe',
+          publicKey,
+        }),
+      ).toBe(false)
+    })
+  })
+
+  describe('webCryptoP256', () => {
+    test('behavior: verifies valid signature with publicKey', async () => {
+      const { privateKey, publicKey } = await WebCryptoP256.createKeyPair()
+      const payload = '0xdeadbeef' as const
+
+      const signature = await WebCryptoP256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: true,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: verifies valid signature with address', async () => {
+      const { privateKey, publicKey } = await WebCryptoP256.createKeyPair()
+      const address = Address.fromPublicKey(publicKey)
+      const payload = '0xdeadbeef' as const
+
+      const signature = await WebCryptoP256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: true,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          address,
+        }),
+      ).toBe(true)
+    })
+
+    test('behavior: returns false for mismatched publicKey', async () => {
+      const { privateKey, publicKey } = await WebCryptoP256.createKeyPair()
+      const { publicKey: wrongPublicKey } = await WebCryptoP256.createKeyPair()
+      const payload = '0xdeadbeef' as const
+
+      const signature = await WebCryptoP256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: true,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey: wrongPublicKey,
+        }),
+      ).toBe(false)
+    })
+
+    test('behavior: returns false for wrong payload', async () => {
+      const { privateKey, publicKey } = await WebCryptoP256.createKeyPair()
+      const payload = '0xdeadbeef' as const
+
+      const signature = await WebCryptoP256.sign({ payload, privateKey })
+      const envelope = SignatureEnvelope.from({
+        prehash: true,
+        publicKey,
+        signature,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload: '0xcafebabe',
+          publicKey,
+        }),
+      ).toBe(false)
+    })
+  })
+
+  describe('webAuthn', () => {
+    test('behavior: returns false for mismatched publicKey', () => {
+      const wrongPrivateKey = P256.randomPrivateKey()
+      const wrongPublicKey = P256.getPublicKey({ privateKey: wrongPrivateKey })
+      const payload = '0xdeadbeef' as const
+
+      expect(
+        SignatureEnvelope.verify(signature_webauthn, {
+          payload,
+          publicKey: wrongPublicKey,
+        }),
+      ).toBe(false)
+    })
+
+    test('behavior: returns false for mismatched address', () => {
+      const wrongPrivateKey = P256.randomPrivateKey()
+      const wrongPublicKey = P256.getPublicKey({ privateKey: wrongPrivateKey })
+      const wrongAddress = Address.fromPublicKey(wrongPublicKey)
+      const payload = '0xdeadbeef' as const
+
+      expect(
+        SignatureEnvelope.verify(signature_webauthn, {
+          payload,
+          address: wrongAddress,
+        }),
+      ).toBe(false)
+    })
+  })
+
+  describe('keychain', () => {
+    test('behavior: returns false for keychain signatures', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const secp256k1PublicKey = Secp256k1.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef' as const
+
+      const signature = Secp256k1.sign({ payload, privateKey })
+      const innerEnvelope = SignatureEnvelope.from(signature)
+      const envelope = SignatureEnvelope.from({
+        userAddress: '0x1234567890123456789012345678901234567890',
+        inner: innerEnvelope,
+      })
+
+      expect(
+        SignatureEnvelope.verify(envelope, {
+          payload,
+          publicKey: secp256k1PublicKey,
+        }),
+      ).toBe(false)
+    })
+  })
+})
+
 describe('fromRpc', () => {
   describe('secp256k1', () => {
     test('behavior: converts RPC secp256k1 signature', () => {