ox 1.8.7 → 1.8.9

package/src/zod/tempo/KeyAuthorization.ts

@@ -29,28 +29,24 @@ 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.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.ConfigurableRpc,
-    ]),
-    witness: z.optional(z.nullable(z_Hex.Hex)),
-  })
-  .check(
-    z.refine(
-      (value) => value.keyType !== 'multisig' || value.account != null,
-      'configurable account key grants require a parent account binding',
-    ),
-  )
+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('configurableAccount'),
+  ]),
+  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
+  signature: z.union([
+    z_SignatureEnvelope.PrimitiveRpc,
+    z_SignatureEnvelope.ConfigurableRpc,
+  ]),
+  witness: z.optional(z.nullable(z_Hex.Hex)),
+})
 
 /** Token spending limit schema. */
 export const TokenLimit = z.object({
@@ -88,18 +84,11 @@ const domainShape = {
 }
 
 /** Decoded key authorization schema. */
-export const Domain = z
-  .object({
-    ...domainShape,
-    account: z.optional(z_Address.Address),
-    isAdmin: z.optional(z.boolean()),
-  })
-  .check(
-    z.refine(
-      (value) => value.type !== 'configurable' || value.account != null,
-      'configurable account key grants require a parent account binding',
-    ),
-  )
+export const Domain = z.object({
+  ...domainShape,
+  account: z.optional(z_Address.Address),
+  isAdmin: z.optional(z.boolean()),
+})
 
 const domainToRpcShape = {
   ...domainShape,
@@ -109,18 +98,11 @@ const domainToRpcShape = {
 }
 
 /** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
-export const DomainToRpc = z
-  .object({
-    ...domainToRpcShape,
-    account: z.optional(z_Address.Address),
-    isAdmin: z.optional(z.boolean()),
-  })
-  .check(
-    z.refine(
-      (value) => value.type !== 'configurable' || value.account != null,
-      'configurable account key grants require a parent account binding',
-    ),
-  )
+export const DomainToRpc = z.object({
+  ...domainToRpcShape,
+  account: z.optional(z_Address.Address),
+  isAdmin: z.optional(z.boolean()),
+})
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {

package/src/zod/tempo/TransactionRequest.ts

@@ -26,12 +26,12 @@ const KeyType = z.union([
   z.literal('configurable'),
 ])
 
-// The node's wire format names the configurable account key type `multisig`.
+// The node's wire format names the configurable account key type `configurableAccount`.
 const KeyTypeRpc = z.union([
   z.literal('secp256k1'),
   z.literal('p256'),
   z.literal('webAuthn'),
-  z.literal('multisig'),
+  z.literal('configurableAccount'),
 ])
 
 const SignatureRpc = z.object({
@@ -93,7 +93,7 @@ export const Rpc = z.object({
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
   keyAuthorizationSimulation: z.optional(z_AccountSimulation.Rpc),
-  multisigSimulation: z.optional(z_AccountSimulation.Rpc),
+  configurableAccountSimulation: z.optional(z_AccountSimulation.Rpc),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -218,7 +218,11 @@ export const TransactionRequestToRpc = z.codec(Rpc, DomainToRpc, {
 function fromRpc(
   request: core_TransactionRequest.Rpc,
 ): core_TransactionRequest.TransactionRequest {
-  const { authorizationList: _, multisigSimulation: __, ...rest } = request
+  const {
+    authorizationList: _,
+    configurableAccountSimulation: __,
+    ...rest
+  } = request
   const request_ = z.decode(
     z_TransactionRequest.TransactionRequest,
     rest as never,
@@ -263,16 +267,18 @@ function fromRpc(
   if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
     request_.keyType =
-      request.keyType === 'multisig' ? 'configurable' : request.keyType
+      request.keyType === 'configurableAccount'
+        ? 'configurable'
+        : request.keyType
   if (typeof request.keyAuthorizationSimulation !== 'undefined')
     request_.keyAuthorizationSimulation = z.decode(
       z_AccountSimulation.AccountSimulation,
       request.keyAuthorizationSimulation,
     )
-  if (typeof request.multisigSimulation !== 'undefined')
+  if (typeof request.configurableAccountSimulation !== 'undefined')
     request_.accountSimulation = z.decode(
       z_AccountSimulation.AccountSimulation,
-      request.multisigSimulation,
+      request.configurableAccountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = core_Hex.toNumber(request.validBefore)
@@ -357,14 +363,16 @@ function toRpc(
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
     request_rpc.keyType =
-      request.keyType === 'configurable' ? 'multisig' : request.keyType
+      request.keyType === 'configurable'
+        ? 'configurableAccount'
+        : request.keyType
   if (typeof request.keyAuthorizationSimulation !== 'undefined')
     request_rpc.keyAuthorizationSimulation = z.encode(
       z_AccountSimulation.AccountSimulation,
       request.keyAuthorizationSimulation,
     )
   if (typeof request.accountSimulation !== 'undefined')
-    request_rpc.multisigSimulation = z.encode(
+    request_rpc.configurableAccountSimulation = z.encode(
       z_AccountSimulation.AccountSimulation,
       request.accountSimulation,
     )

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

@@ -24,7 +24,7 @@ const rpc = {
     version: '0x1',
   },
   createdAt: 1,
-  hash: '0xcdbc24a8fb192f799c5d166b13a99fb29cbb15e71a5e730988d6f8b3c5959d02',
+  hash: '0x2b7a9f98ab46088ccfbd145553b5ec804cd6a24eab46a21f023cbe68385f0fb4',
   signatureCount: 1,
   status: 'pending',
   threshold: 2,

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

@@ -21,7 +21,7 @@ const rpc = {
 } as const
 
 describe('KeyAuthorization', () => {
-  test('rejects unbound configurable grants through every schema', () => {
+  test('accepts unbound configurable grants through every schema', () => {
     const domain = {
       ...z.decode(z_KeyAuthorization.KeyAuthorization, rpc),
       type: 'configurable',
@@ -30,15 +30,15 @@ describe('KeyAuthorization', () => {
       expect(
         z.safeDecode(z_KeyAuthorization.KeyAuthorization, {
           ...rpc,
-          keyType: 'multisig',
+          keyType: 'configurableAccount',
           account,
         }).success,
-      ).toMatchInlineSnapshot(`false`)
+      ).toMatchInlineSnapshot(`true`)
     for (const schema of [
       z_KeyAuthorization.Domain,
       z_KeyAuthorization.DomainToRpc,
     ]) {
-      expect(z.safeParse(schema, domain).success).toMatchInlineSnapshot(`false`)
+      expect(z.safeParse(schema, domain).success).toMatchInlineSnapshot(`true`)
       expect(
         z.safeParse(schema, { ...domain, account: rpc.keyId }).success,
       ).toMatchInlineSnapshot(`true`)
@@ -47,7 +47,7 @@ describe('KeyAuthorization', () => {
       z_KeyAuthorization.KeyAuthorization,
       z_KeyAuthorization.KeyAuthorizationToRpc,
     ])
-      expect(z.safeEncode(codec, domain).success).toMatchInlineSnapshot(`false`)
+      expect(z.safeEncode(codec, domain).success).toMatchInlineSnapshot(`true`)
   })
 
   test('decodes an RPC key authorization', () => {

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

@@ -79,13 +79,13 @@ describe('TransactionRequest', () => {
     const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
       ...rpc,
       keyAuthorizationSimulation: accountSimulationRpc,
-      multisigSimulation: accountSimulationRpc,
+      configurableAccountSimulation: accountSimulationRpc,
     })
     expect(decoded).toEqual(
       core_TransactionRequest.fromRpc({
         ...rpc,
         keyAuthorizationSimulation: accountSimulationRpc,
-        multisigSimulation: accountSimulationRpc,
+        configurableAccountSimulation: accountSimulationRpc,
       }),
     )
     expect(decoded.accountSimulation).toEqual(
@@ -96,22 +96,27 @@ describe('TransactionRequest', () => {
     expect(encoded.keyAuthorizationSimulation).toStrictEqual(
       accountSimulationRpc,
     )
-    expect(encoded.multisigSimulation).toStrictEqual(accountSimulationRpc)
+    expect(encoded.configurableAccountSimulation).toStrictEqual(
+      accountSimulationRpc,
+    )
     expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
   })
 
-  test('configurable key type maps to the multisig RPC key type', () => {
+  test('configurable key type maps to the configurableAccount RPC key type', () => {
     const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
       ...rpc,
-      keyType: 'multisig',
+      keyType: 'configurableAccount',
     })
     expect(decoded.keyType).toBe('configurable')
     expect(decoded).toEqual(
-      core_TransactionRequest.fromRpc({ ...rpc, keyType: 'multisig' }),
+      core_TransactionRequest.fromRpc({
+        ...rpc,
+        keyType: 'configurableAccount',
+      }),
     )
 
     const encoded = z.encode(z_TransactionRequest.TransactionRequest, decoded)
-    expect(encoded.keyType).toBe('multisig')
+    expect(encoded.keyType).toBe('configurableAccount')
     expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
   })