ox 1.7.4 → 1.7.5

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.7.4'
+export const version = '1.7.5'

package/src/zod/tempo/KeyAuthorization.ts

@@ -9,16 +9,6 @@ import {
 import * as z from 'zod/mini'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const SignatureRpc = z.union([
-  z_SignatureEnvelope.PrimitiveRpc,
-  z_SignatureEnvelope.MultisigRpc,
-])
-
-const Signature = z.union([
-  z_SignatureEnvelope.Primitive,
-  z_SignatureEnvelope.Multisig,
-])
-
 /** RPC token spending limit schema. */
 export const RpcTokenLimit = z.object({
   limit: z_Hex.Hex,
@@ -39,18 +29,28 @@ export const RpcCallScope = z.object({
 })
 
 /** RPC key authorization schema. */
-export const Rpc = z.object({
-  account: z.optional(z.nullable(z_Address.Address)),
-  allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
-  chainId: z_Hex.Hex,
-  expiry: z.optional(z.nullable(z_Hex.Hex)),
-  isAdmin: z.optional(z.nullable(z.boolean())),
-  keyId: z_Address.Address,
-  keyType: z_SignatureEnvelope.Type,
-  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
-  signature: SignatureRpc,
-  witness: z.optional(z.nullable(z_Hex.Hex)),
-})
+export const Rpc = z
+  .object({
+    account: z.optional(z.nullable(z_Address.Address)),
+    allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
+    chainId: z_Hex.Hex,
+    expiry: z.optional(z.nullable(z_Hex.Hex)),
+    isAdmin: z.optional(z.nullable(z.boolean())),
+    keyId: z_Address.Address,
+    keyType: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
+    limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
+    signature: z.union([
+      z_SignatureEnvelope.PrimitiveRpc,
+      z_SignatureEnvelope.MultisigRpc,
+    ]),
+    witness: z.optional(z.nullable(z_Hex.Hex)),
+  })
+  .check(
+    z.refine(
+      (value) => value.keyType !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Token spending limit schema. */
 export const TokenLimit = z.object({
@@ -79,20 +79,27 @@ const domainShape = {
   expiry: z.optional(z.number()),
   limits: z.optional(z.readonly(z.array(TokenLimit))),
   scopes: z.optional(z.readonly(z.array(Scope))),
-  signature: Signature,
-  type: z_SignatureEnvelope.Type,
+  signature: z.union([
+    z_SignatureEnvelope.Primitive,
+    z_SignatureEnvelope.Multisig,
+  ]),
+  type: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
   witness: z.optional(z_Hex.Hex),
 }
 
-/** Decoded key authorization schema (TIP-1049 admin fields are paired: both or neither). */
-export const Domain = z.union([
-  z.object({
+/** Decoded key authorization schema. */
+export const Domain = z
+  .object({
     ...domainShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 const domainToRpcShape = {
   ...domainShape,
@@ -102,14 +109,18 @@ const domainToRpcShape = {
 }
 
 /** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
-export const DomainToRpc = z.union([
-  z.object({
+export const DomainToRpc = z
+  .object({
     ...domainToRpcShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainToRpcShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {

package/src/zod/tempo/MultisigSimulation.ts

@@ -7,53 +7,17 @@ import * as z from 'zod/mini'
 import * as z_MultisigConfig from './MultisigConfig.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const NestedPrimitiveApproval = z.object({
+const PrimitiveApproval = z.strictObject({
   keyData: z.optional(z_Hex.Hex),
   keyType: z.optional(z_SignatureEnvelope.Type),
   owner: z_Address.Address,
 })
 
-const PrimitiveApproval = z.object({
-  keyData: z.optional(z_Hex.Hex),
-  keyType: z.optional(z_SignatureEnvelope.Type),
-  owner: z_Address.Address,
-  type: z.literal('primitive'),
-})
-
-const NestedSpec = z.object({
-  account: z_Address.Address,
-  approvals: z.readonly(
-    z
-      .array(NestedPrimitiveApproval)
-      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
-  ),
-  config: z_MultisigConfig.Config,
-})
-
-const NestedSpecRpc = z.object({
-  account: z_Address.Address,
-  approvals: z.readonly(
-    z
-      .array(NestedPrimitiveApproval)
-      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
-  ),
-  config: z_Hex.Hex,
-})
-
 /** Native multisig simulation spec schema. */
 export const Domain = z.object({
-  account: z_Address.Address,
   approvals: z.readonly(
     z
-      .array(
-        z.union([
-          PrimitiveApproval,
-          z.object({
-            spec: NestedSpec,
-            type: z.literal('multisig'),
-          }),
-        ]),
-      )
+      .array(PrimitiveApproval)
       .check(z.maxLength(core_MultisigConfig.maxSignatures)),
   ),
   config: z_MultisigConfig.Config,
@@ -61,18 +25,9 @@ export const Domain = z.object({
 
 const Rpc_ = z
   .object({
-    account: z_Address.Address,
     approvals: z.readonly(
       z
-        .array(
-          z.union([
-            PrimitiveApproval,
-            z.object({
-              spec: NestedSpecRpc,
-              type: z.literal('multisig'),
-            }),
-          ]),
-        )
+        .array(PrimitiveApproval)
         .check(z.maxLength(core_MultisigConfig.maxSignatures)),
     ),
     config: z_Hex.Hex,

package/src/zod/tempo/SignatureEnvelope.ts

@@ -72,23 +72,35 @@ export const WebAuthnRpc = z.object({
 export const PrimitiveRpc = z.union([Secp256k1Rpc, P256Rpc, WebAuthnRpc])
 
 /** RPC keychain signature envelope schema. */
-export const KeychainRpc = z.object({
-  keyId: z.optional(z_Address.Address),
-  // `signature` is recursive; type the getter concretely to break the cycle.
-  signature: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
-      Rpc as never,
-  ),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
+export const KeychainRpc = z
+  .object({
+    keyId: z.optional(z_Address.Address),
+    // `signature` is recursive; type the getter concretely to break the cycle.
+    signature: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
+        Rpc as never,
+    ),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_SignatureEnvelope.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'multisig access keys require keychain V2'),
+  )
 
 /** RPC native multisig signature envelope schema. */
 export const MultisigRpc = z_Hex.Hex.check(
   z.refine((value) => {
     try {
-      return core_SignatureEnvelope.fromRpc(value).type === 'multisig'
+      core_SignatureEnvelope.fromRpc(value)
+      return true
     } catch {
       return false
     }
@@ -133,34 +145,34 @@ export const WebAuthn = z.object({
 export const Primitive = z.union([Secp256k1, P256, WebAuthn])
 
 /** Keychain signature envelope schema. */
-export const Keychain = z.object({
-  // `inner` is recursive; type the getter concretely to break the cycle.
-  inner: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
-      Domain as never,
-  ),
-  keyId: z.optional(z_Address.Address),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
+export const Keychain = z
+  .object({
+    // `inner` is recursive; type the getter concretely to break the cycle.
+    inner: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
+        Domain as never,
+    ),
+    keyId: z.optional(z_Address.Address),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
+  })
+  .check(
+    z.refine(
+      (value) => core_SignatureEnvelope.validate(value),
+      'multisig access keys require keychain V2',
+    ),
+  )
 
 /** Native multisig signature envelope schema. */
 export const Multisig = z
   .object({
     account: z_Address.Address,
     config: z_MultisigConfig.Config,
-    // `signatures` is recursive; type the getter concretely to break the cycle.
-    signatures: z.lazy(
-      (): z.ZodMiniType<readonly core_SignatureEnvelope.SignatureEnvelope[]> =>
-        z.readonly(
-          z
-            .array(Domain)
-            .check(
-              z.minLength(1),
-              z.maxLength(core_MultisigConfig.maxSignatures),
-            ),
-        ) as never,
+    signatures: z.readonly(
+      z
+        .array(Primitive)
+        .check(z.minLength(1), z.maxLength(core_MultisigConfig.maxSignatures)),
     ),
     type: z.literal('multisig'),
   })
@@ -189,7 +201,6 @@ function fromRpc(
   value: core_SignatureEnvelope.SignatureEnvelopeRpc,
 ): core_SignatureEnvelope.SignatureEnvelope {
   if (typeof value === 'string') return core_SignatureEnvelope.fromRpc(value)
-
   if (value.type === 'secp256k1') {
     const secp256k1 = value as core_SignatureEnvelope.Secp256k1Rpc
     return {

package/src/zod/tempo/TransactionRequest.ts

@@ -23,6 +23,7 @@ const KeyType = z.union([
   z.literal('secp256k1'),
   z.literal('p256'),
   z.literal('webAuthn'),
+  z.literal('multisig'),
 ])
 
 const SignatureRpc = z.object({
@@ -83,6 +84,7 @@ export const Rpc = z.object({
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Rpc),
   multisigSimulation: z.optional(z_MultisigSimulation.Rpc),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
@@ -136,6 +138,7 @@ export const Domain = z.object({
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Domain),
   multisigSimulation: z.optional(z_MultisigSimulation.Domain),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
@@ -175,6 +178,7 @@ export const DomainToRpc = z.object({
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Domain),
   multisigSimulation: z.optional(z_MultisigSimulation.Domain),
   nonce: z.optional(uintBigintNumberish()),
   nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
@@ -250,6 +254,11 @@ function fromRpc(
   if (typeof request.keyData !== 'undefined') request_.keyData = request.keyData
   if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
   if (typeof request.keyType !== 'undefined') request_.keyType = request.keyType
+  if (typeof request.keyAuthorizationSimulation !== 'undefined')
+    request_.keyAuthorizationSimulation = z.decode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.keyAuthorizationSimulation,
+    )
   if (typeof request.multisigSimulation !== 'undefined')
     request_.multisigSimulation = z.decode(
       z_MultisigSimulation.MultisigSimulation,
@@ -338,6 +347,11 @@ function toRpc(
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
     request_rpc.keyType = request.keyType
+  if (typeof request.keyAuthorizationSimulation !== 'undefined')
+    request_rpc.keyAuthorizationSimulation = z.encode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.keyAuthorizationSimulation,
+    )
   if (typeof request.multisigSimulation !== 'undefined')
     request_rpc.multisigSimulation = z.encode(
       z_MultisigSimulation.MultisigSimulation,

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vp/test'
+import * as core_SignatureEnvelope from '../../../tempo/SignatureEnvelope.js'
 import * as core_KeyAuthorization from '../../../tempo/KeyAuthorization.js'
 import * as z_KeyAuthorization from '../KeyAuthorization.js'
 import * as z from 'zod/mini'
@@ -20,6 +21,35 @@ const rpc = {
 } as const
 
 describe('KeyAuthorization', () => {
+  test('rejects unbound multisig grants through every schema', () => {
+    const domain = {
+      ...z.decode(z_KeyAuthorization.KeyAuthorization, rpc),
+      type: 'multisig',
+    } as const
+    for (const account of [undefined, null])
+      expect(
+        z.safeDecode(z_KeyAuthorization.KeyAuthorization, {
+          ...rpc,
+          keyType: 'multisig',
+          account,
+        }).success,
+      ).toMatchInlineSnapshot(`false`)
+    for (const schema of [
+      z_KeyAuthorization.Domain,
+      z_KeyAuthorization.DomainToRpc,
+    ]) {
+      expect(z.safeParse(schema, domain).success).toMatchInlineSnapshot(`false`)
+      expect(
+        z.safeParse(schema, { ...domain, account: rpc.keyId }).success,
+      ).toMatchInlineSnapshot(`true`)
+    }
+    for (const codec of [
+      z_KeyAuthorization.KeyAuthorization,
+      z_KeyAuthorization.KeyAuthorizationToRpc,
+    ])
+      expect(z.safeEncode(codec, domain).success).toMatchInlineSnapshot(`false`)
+  })
+
   test('decodes an RPC key authorization', () => {
     expect(z.decode(z_KeyAuthorization.KeyAuthorization, rpc)).toEqual(
       core_KeyAuthorization.fromRpc(rpc),
@@ -141,27 +171,15 @@ describe('KeyAuthorization', () => {
     ).toBe(false)
   })
 
-  test('round-trips multisig signatures', () => {
-    const multisigRpc =
-      '0xf89794be95c3f554e9fc85ec51be69a3d807a0d55bcf2cf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d694f39fd6e51aad88f6f4ce6ab8827279cfffb9226601f843b841fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c' as const
-    const withMultisig = { ...rpc, signature: multisigRpc }
-    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, withMultisig)
-    expect(decoded).toEqual(core_KeyAuthorization.fromRpc(withMultisig))
-    expect(z.encode(z_KeyAuthorization.KeyAuthorization, decoded)).toEqual(
-      core_KeyAuthorization.toRpc(decoded),
-    )
-  })
-
-  test('rejects keychain signatures', () => {
-    const keychainRpc = {
-      signature: rpc.signature,
-      type: 'keychain',
-      userAddress: '0x1111111111111111111111111111111111111111',
+  test('rejects legacy multisig signatures', () => {
+    const multisigRpc = {
+      account: '0x1111111111111111111111111111111111111111',
+      signatures: [rpc.signature],
     } as const
     expect(
       z.safeDecode(z_KeyAuthorization.KeyAuthorization, {
         ...rpc,
-        signature: keychainRpc,
+        signature: multisigRpc,
       } as never).success,
     ).toBe(false)
 
@@ -170,11 +188,42 @@ describe('KeyAuthorization', () => {
       z.safeEncode(z_KeyAuthorization.KeyAuthorization, {
         ...authorization,
         signature: {
-          inner: authorization.signature,
-          type: 'keychain',
-          userAddress: keychainRpc.userAddress,
+          account: multisigRpc.account,
+          signatures: [authorization.signature],
+          type: 'multisig',
         },
       } as never).success,
     ).toBe(false)
   })
+  test('round-trips account-bound multisig grants', () => {
+    const signature = core_SignatureEnvelope.from({
+      account: '0x2222222222222222222222222222222222222222',
+      config: {
+        threshold: 1,
+        owners: [
+          { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+        ],
+      },
+      signatures: [
+        core_SignatureEnvelope.fromRpc(
+          rpc.signature,
+        ) as core_SignatureEnvelope.Primitive,
+      ],
+    })
+    const signed = core_KeyAuthorization.from(
+      {
+        account: signature.account,
+        address: '0x3333333333333333333333333333333333333333',
+        chainId: 1n,
+        type: 'multisig',
+      },
+      { signature },
+    )
+    const encoded = z.encode(z_KeyAuthorization.KeyAuthorization, signed)
+    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, encoded)
+    expect(decoded).toEqual(
+      core_KeyAuthorization.fromRpc(core_KeyAuthorization.toRpc(signed)),
+    )
+    expect(decoded.account).toBe(signature.account)
+  })
 })

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

@@ -4,24 +4,11 @@ import * as z_MultisigSimulation from '../MultisigSimulation.js'
 import * as z from 'zod/mini'
 
 const rpc = {
-  account: '0xcccccccccccccccccccccccccccccccccccccccc',
   approvals: [
     {
-      owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      type: 'primitive',
-    },
-    {
-      spec: {
-        account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-        approvals: [
-          {
-            owner: '0xdddddddddddddddddddddddddddddddddddddddd',
-          },
-        ],
-        config:
-          '0xf83ba022222222222222222222222222222222222222222222222222222222222222220201d7d694dddddddddddddddddddddddddddddddddddddddd01',
-      },
-      type: 'multisig',
+      keyType: 'webAuthn',
+      keyData: '0x0005',
+      owner: '0x1111111111111111111111111111111111111111',
     },
   ],
   config:
@@ -46,24 +33,12 @@ describe('MultisigSimulation', () => {
       }).success,
     ).toMatchInlineSnapshot(`false`)
   })
-
-  test('error: rejects more than eight nested approvals', () => {
+  test('error: rejects nested approvals', () => {
     expect(
       z.safeDecode(z_MultisigSimulation.Rpc, {
         ...rpc,
-        approvals: [
-          {
-            ...rpc.approvals[1],
-            spec: {
-              ...rpc.approvals[1].spec,
-              approvals: Array.from(
-                { length: 9 },
-                () => rpc.approvals[1].spec.approvals[0],
-              ),
-            },
-          },
-        ],
-      }).success,
+        approvals: [{ type: 'multisig', spec: rpc }],
+      } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })