ox 1.7.1 → 1.7.4

package/src/tempo/AuthorizationTempo.test.ts

@@ -348,6 +348,7 @@ describe('fromRpc', () => {
         type: 'p256',
       },
     })
+    if (typeof result.signature === 'string') throw new Error('unreachable')
     expect(result.signature.type).toBe('p256')
     expect(result.signature).toHaveProperty('prehash', true)
     expect(result.signature).toHaveProperty('publicKey')
@@ -370,6 +371,7 @@ describe('fromRpc', () => {
           '0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d976305000000007b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22222c226f726967696e223a2268747470733a2f2f6578616d706c652e636f6d222c2263726f73734f726967696e223a66616c73657d',
       },
     })
+    if (typeof result.signature === 'string') throw new Error('unreachable')
     expect(result.signature.type).toBe('webAuthn')
     expect(result.signature).toHaveProperty('metadata')
     expect(result.signature).toHaveProperty('publicKey')
@@ -994,6 +996,7 @@ describe('toRpc', () => {
         type: 'p256',
       },
     })
+    if (typeof result.signature === 'string') throw new Error('unreachable')
     expect(result.signature.type).toBe('p256')
   })
 
@@ -1019,6 +1022,7 @@ describe('toRpc', () => {
         type: 'webAuthn',
       },
     })
+    if (typeof result.signature === 'string') throw new Error('unreachable')
     expect(result.signature.type).toBe('webAuthn')
   })
 })

package/src/tempo/KeyAuthorization.test-d.ts

@@ -1,6 +1,7 @@
 import { expectTypeOf, test } from 'vp/test'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as SignatureEnvelope from './SignatureEnvelope.js'
+import * as MultisigConfig from './MultisigConfig.js'
+import type * as SignatureEnvelope from './SignatureEnvelope.js'
 
 const authorization = {
   address: '0x1111111111111111111111111111111111111111',
@@ -19,6 +20,16 @@ const signature = {
 
 const multisig = {
   account: '0x2222222222222222222222222222222222222222',
+  config: MultisigConfig.from({
+    owners: [
+      {
+        owner: '0x1111111111111111111111111111111111111111',
+        weight: 1,
+      },
+    ],
+    threshold: 1,
+    version: 1n,
+  }),
   signatures: [signature],
   type: 'multisig',
 } as const satisfies SignatureEnvelope.Multisig
@@ -44,17 +55,7 @@ test('accepts multisig signatures', () => {
     KeyAuthorization.Signed['signature']
   >()
 
-  const multisigRpc = {
-    account: multisig.account,
-    signatures: [
-      {
-        r: '0x01',
-        s: '0x02',
-        type: 'secp256k1',
-        yParity: '0x0',
-      },
-    ],
-  } as const satisfies SignatureEnvelope.MultisigRpc
+  const multisigRpc = '0xf8' as const satisfies SignatureEnvelope.MultisigRpc
 
   const rpc: KeyAuthorization.Rpc = {
     chainId: '0x1',

package/src/tempo/KeyAuthorization.test.ts

@@ -9,6 +9,7 @@ import {
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
 import * as KeyAuthorization from './KeyAuthorization.js'
+import * as MultisigConfig from './MultisigConfig.js'
 import * as Period from './Period.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
@@ -55,9 +56,21 @@ const signature_webauthn = SignatureEnvelope.from({
 
 const signature_multisig = {
   account: address,
+  config: MultisigConfig.from({
+    owners: [
+      {
+        owner: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        weight: 1,
+      },
+    ],
+    threshold: 1,
+    version: 1n,
+  }),
   signatures: [SignatureEnvelope.from(signature_secp256k1)],
   type: 'multisig',
 } as const satisfies SignatureEnvelope.Multisig
+const signature_multisig_rpc =
+  '0xf89794be95c3f554e9fc85ec51be69a3d807a0d55bcf2cf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d694f39fd6e51aad88f6f4ce6ab8827279cfffb9226601f843b841fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c' as const
 
 const signature_keychain = {
   inner: SignatureEnvelope.from(signature_secp256k1),
@@ -491,16 +504,42 @@ describe('from', () => {
 })
 
 describe('fromRpc', () => {
-  test('multisig', () => {
+  test('behavior: multisig', () => {
     const authorization = KeyAuthorization.fromRpc({
       chainId: '0x1',
       expiry: null,
       keyId: address,
       keyType: 'secp256k1',
-      signature: SignatureEnvelope.toRpc(signature_multisig),
+      signature: signature_multisig_rpc,
     })
 
-    expect(authorization.signature).toEqual(signature_multisig)
+    expect(authorization.signature).toMatchInlineSnapshot(`
+      {
+        "account": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
+        "config": {
+          "owners": [
+            {
+              "owner": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+              "weight": 1,
+            },
+          ],
+          "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
+          "threshold": 1,
+          "version": 1n,
+        },
+        "signatures": [
+          {
+            "signature": {
+              "r": "0xfa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7",
+              "s": "0x780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d0",
+              "yParity": 1,
+            },
+            "type": "secp256k1",
+          },
+        ],
+        "type": "multisig",
+      }
+    `)
   })
 
   test('rejects a keychain signature', () => {
@@ -1071,6 +1110,60 @@ describe('getSignPayload', () => {
 })
 
 describe('deserialize', () => {
+  test('example: matches the frozen multisig witness vector', () => {
+    const serialized =
+      '0xf8f1f85382107980941eff47bc3a10a45d4b230b5d10e37751fe6aa718808080a0535353535353535353535353535353535353535353535353535353535353535380949dba7f426b711d4893c11611eacf7cc334e7146bb89a05f897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b8412cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e21451b' as const
+    const authorization = KeyAuthorization.deserialize(serialized)
+
+    expect(authorization).toMatchInlineSnapshot(`
+      {
+        "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+        "address": "0x1eff47bc3a10a45d4b230b5d10e37751fe6aa718",
+        "chainId": 4217n,
+        "isAdmin": false,
+        "signature": {
+          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+          "config": {
+            "owners": [
+              {
+                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "threshold": 1,
+            "version": 0n,
+          },
+          "signatures": [
+            {
+              "signature": {
+                "r": "0x2cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8",
+                "s": "0x359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e2145",
+                "yParity": 0,
+              },
+              "type": "secp256k1",
+            },
+          ],
+          "type": "multisig",
+        },
+        "type": "secp256k1",
+        "witness": "0x5353535353535353535353535353535353535353535353535353535353535353",
+      }
+    `)
+    expect(KeyAuthorization.serialize(authorization)).toBe(serialized)
+  })
+
+  test('multisig', () => {
+    const serialized = Rlp.fromHex([
+      ['0x1', '0x', address],
+      SignatureEnvelope.serialize(signature_multisig),
+    ])
+
+    expect(KeyAuthorization.deserialize(serialized).signature).toEqual(
+      signature_multisig,
+    )
+  })
+
   test('default', () => {
     const authorization = KeyAuthorization.from({
       address,
@@ -1241,6 +1334,19 @@ describe('serialize', () => {
 })
 
 describe('toRpc', () => {
+  test('behavior: multisig', () => {
+    const authorization = KeyAuthorization.toRpc({
+      address,
+      chainId: 1n,
+      signature: signature_multisig,
+      type: 'secp256k1',
+    })
+
+    expect(authorization.signature).toMatchInlineSnapshot(
+      `"${signature_multisig_rpc}"`,
+    )
+  })
+
   test('secp256k1', () => {
     const authorization = KeyAuthorization.from({
       address,

package/src/tempo/KeyAuthorization.ts

@@ -90,9 +90,9 @@ export type Signature<numberType = number> = OneOf<
 >
 
 /** RPC-formatted signature that can authorize an access key. */
-export type SignatureRpc = OneOf<
-  SignatureEnvelope.PrimitiveRpc | SignatureEnvelope.MultisigRpc
->
+export type SignatureRpc =
+  | SignatureEnvelope.MultisigRpc
+  | SignatureEnvelope.PrimitiveRpc
 
 /** Input type for a Key Authorization. */
 export type Input = KeyAuthorization<false, bigint, number>
@@ -151,7 +151,7 @@ type SignatureValue =
   | UnionPartialBy<Signature, 'prehash' | 'type'>
   | SignatureEnvelope.Secp256k1Flat
   | SignatureEnvelope.Serialized
-  | SignatureEnvelope.from.MultisigFromInitialConfig
+  | SignatureEnvelope.from.MultisigFromConfig
 
 type BaseTuple = readonly [
   chainId: Hex.Hex,

package/src/tempo/MultisigConfig.test-d.ts

@@ -0,0 +1,52 @@
+import { expectTypeOf, test } from 'vp/test'
+import * as MultisigConfig from './MultisigConfig.js'
+
+const input = {
+  owners: [
+    {
+      owner: '0x1111111111111111111111111111111111111111',
+      weight: 1,
+    },
+  ],
+  threshold: 1,
+} as const satisfies MultisigConfig.Input
+
+test('from returns a complete configuration', () => {
+  const config = MultisigConfig.from(input)
+  const numeric = MultisigConfig.from({ ...input, version: 1 })
+  const zero = MultisigConfig.from({ ...input, version: 0 })
+
+  expectTypeOf(config).toMatchTypeOf<MultisigConfig.Config>()
+  expectTypeOf(config.version).toEqualTypeOf<0n>()
+  expectTypeOf(numeric.version).toEqualTypeOf<bigint>()
+  expectTypeOf(zero.version).toEqualTypeOf<0n>()
+})
+
+test('RPC configurations use hexadecimal versions', () => {
+  const rpc = MultisigConfig.toRpc(MultisigConfig.from(input))
+
+  expectTypeOf(rpc).toEqualTypeOf<MultisigConfig.Rpc>()
+  expectTypeOf(rpc.version).toEqualTypeOf<`0x${string}`>()
+})
+
+test('complete configurations require a version', () => {
+  // @ts-expect-error Complete configurations include their version.
+  const config: MultisigConfig.Config = input
+
+  expectTypeOf(config).toEqualTypeOf<MultisigConfig.Config>()
+})
+
+test('sign payloads take the version from config', () => {
+  MultisigConfig.getSignPayload({
+    account: '0x2222222222222222222222222222222222222222',
+    config: { version: 1 },
+    payload: '0x1234',
+  })
+
+  MultisigConfig.getSignPayload({
+    account: '0x2222222222222222222222222222222222222222',
+    // @ts-expect-error A configuration version is required.
+    config: {},
+    payload: '0x1234',
+  })
+})