ox 1.8.8 → 1.8.9

package/src/tempo/KeyAuthorization.ts

@@ -38,7 +38,7 @@ export type KeyAuthorization<
   bigintType = bigint,
   numberType = number,
 > = {
-  /** Account address this authorization is bound to. Required for configurable account grants. */
+  /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
   account?: Address.Address | undefined
   /** Address derived from the public key of the key type. */
   address: Address.Address
@@ -116,8 +116,8 @@ export type Rpc = {
   isAdmin?: boolean | null | undefined
   /** Key identifier. */
   keyId: Address.Address
-  /** Key type. Configurable accounts use the node's `multisig` key type. */
-  keyType: SignatureEnvelope.Type | 'multisig'
+  /** Key type. Configurable accounts use the node's `configurableAccount` key type. */
+  keyType: SignatureEnvelope.Type | 'configurableAccount'
   /** Token spending limits (`null`/`undefined` = unlimited, `[]` = no spending allowed). */
   limits?: readonly RpcTokenLimit[] | null | undefined
   /** Primitive or configurable account signature authorizing this key. */
@@ -445,7 +445,6 @@ export function from<
   options: from.Options<signature> = {},
 ): from.ReturnType<authorization, signature> {
   if ('keyId' in authorization) return fromRpc(authorization as Rpc) as never
-  assertAccountBinding(authorization.type, authorization.account)
   const auth = authorization as KeyAuthorization & {
     limits?: readonly { limit: bigint; token: Address.Address }[]
     scopes?: readonly {
@@ -509,10 +508,7 @@ export declare namespace from {
             : {})
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -551,8 +547,7 @@ export function fromRpc(authorization: Rpc): Signed {
   const witness = authorization.witness ?? undefined
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
-  const type = keyType === 'multisig' ? 'configurable' : keyType
-  assertAccountBinding(type, account)
+  const type = keyType === 'configurableAccount' ? 'configurable' : keyType
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
   assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
@@ -595,10 +590,7 @@ export function fromRpc(authorization: Rpc): Signed {
 }
 
 export declare namespace fromRpc {
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -728,7 +720,6 @@ export function fromTuple<const tuple extends Tuple>(
   const account = isAbsent(rawAccount)
     ? undefined
     : (rawAccount as Address.Address)
-  assertAccountBinding(keyType, account)
   const args: KeyAuthorization = {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
@@ -753,10 +744,7 @@ export declare namespace fromTuple {
     KeyAuthorization<authorization extends Tuple<true> ? true : false>
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -962,7 +950,6 @@ export declare namespace serialize {
  * @returns An RPC-formatted Key Authorization.
  */
 export function toRpc(authorization: toRpc.Input): Rpc {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     scopes,
@@ -1008,7 +995,7 @@ export function toRpc(authorization: toRpc.Input): Rpc {
     chainId: chainIdHex === '0x0' ? '0x' : chainIdHex,
     expiry: expiry != null ? Quantity.fromNumberish(expiry) : null,
     keyId: address,
-    keyType: type === 'configurable' ? 'multisig' : type,
+    keyType: type === 'configurable' ? 'configurableAccount' : type,
     limits: limits?.map(({ token, limit, period }) => ({
       token,
       limit: Quantity.fromNumberish(limit),
@@ -1028,10 +1015,7 @@ export declare namespace toRpc {
   /** Numberish input accepted by {@link ox#KeyAuthorization.(toRpc:function)}. */
   type Input = Signed<Hex.Hex | bigint | number, Hex.Hex | number>
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -1070,7 +1054,6 @@ export declare namespace toRpc {
 export function toTuple<const authorization extends KeyAuthorization>(
   authorization: authorization,
 ): toTuple.ReturnType<authorization> {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     chainId,
@@ -1178,10 +1161,7 @@ export declare namespace toTuple {
   type ReturnType<authorization extends KeyAuthorization = KeyAuthorization> =
     Compute<Tuple<authorization extends KeyAuthorization<true> ? true : false>>
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 function bigintToHex(value: bigint): Hex.Hex {
@@ -1215,14 +1195,6 @@ function resolveSelector(
   return AbiItem.getSelector(selector)
 }
 
-function assertAccountBinding(
-  type: KeyAuthorization['type'],
-  account: Address.Address | null | undefined,
-): void {
-  if (type === 'configurable' && account == null)
-    throw new MissingAccountError()
-}
-
 function assertWitness(witness: Hex.Hex): void {
   if (Hex.size(witness) !== 32) throw new InvalidWitnessSizeError(witness)
 }
@@ -1270,7 +1242,12 @@ export class InvalidSignatureTypeError extends Error {
   }
 }
 
-/** Thrown when a configurable account key grant omits its parent account binding. */
+/**
+ * Thrown when a configurable account key grant omits its parent account binding.
+ *
+ * @deprecated No longer thrown. The Tempo node only requires `account` on grants
+ * signed by an admin access key, which it checks against the transaction sender.
+ */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'
   constructor() {

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

@@ -17,7 +17,7 @@ declare const tempoProvider: Provider.Provider<{
 declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigSimulation: AccountSimulation.Rpc
+declare const configurableAccountSimulation: AccountSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
@@ -79,7 +79,7 @@ test('tempo simulation accepts account simulation specs', () => {
           {
             calls: [
               {
-                multisigSimulation,
+                configurableAccountSimulation,
               },
             ],
           },

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

@@ -53,19 +53,19 @@ describe('TransactionRequest type', () => {
     expectTypeOf<
       TransactionRequest.TransactionRequest['accountSimulation']
     >().toEqualTypeOf<AccountSimulation.Spec | undefined>()
-    expectTypeOf<TransactionRequest.Rpc['multisigSimulation']>().toEqualTypeOf<
-      AccountSimulation.Rpc | undefined
-    >()
+    expectTypeOf<
+      TransactionRequest.Rpc['configurableAccountSimulation']
+    >().toEqualTypeOf<AccountSimulation.Rpc | undefined>()
   })
 
-  test('maps the configurable key type to the RPC multisig key type', () => {
+  test('maps the configurable key type to the RPC configurableAccount key type', () => {
     expectTypeOf<
       TransactionRequest.TransactionRequest['keyType']
     >().toEqualTypeOf<
       'configurable' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
     >()
     expectTypeOf<TransactionRequest.Rpc['keyType']>().toEqualTypeOf<
-      'multisig' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
+      'configurableAccount' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
     >()
   })
 })

package/src/tempo/TransactionRequest.test.ts

@@ -139,9 +139,9 @@ describe('fromRpc', () => {
     `)
   })
 
-  test('behavior: multisig key type decodes as configurable', () => {
+  test('behavior: configurableAccount key type decodes as configurable', () => {
     const request = TransactionRequest.fromRpc({
-      keyType: 'multisig',
+      keyType: 'configurableAccount',
       type: '0x76',
     })
     expect(request.keyType).toMatchInlineSnapshot(`"configurable"`)
@@ -150,7 +150,7 @@ describe('fromRpc', () => {
   test('behavior: account simulation', () => {
     const request = TransactionRequest.fromRpc({
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigSimulation: accountSimulationRpc,
+      configurableAccountSimulation: accountSimulationRpc,
       type: '0x76',
     })
 
@@ -266,11 +266,11 @@ describe('toRpc', () => {
     `)
   })
 
-  test('behavior: configurable key type encodes as multisig', () => {
+  test('behavior: configurable key type encodes as configurableAccount', () => {
     const request = TransactionRequest.toRpc({
       keyType: 'configurable',
     })
-    expect(request.keyType).toMatchInlineSnapshot(`"multisig"`)
+    expect(request.keyType).toMatchInlineSnapshot(`"configurableAccount"`)
   })
 
   test('behavior: account simulation', () => {
@@ -288,8 +288,7 @@ describe('toRpc', () => {
             "value": "0x",
           },
         ],
-        "from": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-        "multisigSimulation": {
+        "configurableAccountSimulation": {
           "approvals": [
             {
               "keyData": "0x0005",
@@ -299,6 +298,7 @@ describe('toRpc', () => {
           ],
           "config": "0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01",
         },
+        "from": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "type": "0x76",
       }
     `)
@@ -445,7 +445,7 @@ describe('roundtrip', () => {
       nonceKey: '0xff',
       gas: '0x186a0',
       keyAuthorizationSimulation: accountSimulationRpc,
-      multisigSimulation: accountSimulationRpc,
+      configurableAccountSimulation: accountSimulationRpc,
       type: '0x76',
     }
 
@@ -461,7 +461,9 @@ describe('roundtrip', () => {
     expect(rpc.keyAuthorizationSimulation).toEqual(
       original.keyAuthorizationSimulation,
     )
-    expect(rpc.multisigSimulation).toEqual(original.multisigSimulation)
+    expect(rpc.configurableAccountSimulation).toEqual(
+      original.configurableAccountSimulation,
+    )
     expect(rpc.type).toBe('0x76')
   })
 })

package/src/tempo/TransactionRequest.ts

@@ -70,9 +70,9 @@ export type Rpc = Omit<
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
   keyAuthorizationSimulation?: AccountSimulation.Rpc | undefined
-  /** Key type. Configurable accounts use the node's `multisig` key type. */
-  keyType?: SignatureEnvelope.Type | 'multisig' | undefined
-  multisigSimulation?: AccountSimulation.Rpc | undefined
+  /** Key type. Configurable accounts use the node's `configurableAccount` key type. */
+  keyType?: SignatureEnvelope.Type | 'configurableAccount' | undefined
+  configurableAccountSimulation?: AccountSimulation.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
   signature?: SignatureEnvelope.SignatureEnvelopeRpc | undefined
 }
@@ -104,7 +104,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
     authorizationList: _,
     keyAuthorizationSimulation: __,
     keyType: ___,
-    multisigSimulation: ____,
+    configurableAccountSimulation: ____,
     ...rest
   } = request
   const request_ = ox_TransactionRequest.fromRpc(
@@ -147,10 +147,12 @@ export function fromRpc(request: Rpc): TransactionRequest {
     )
   if (typeof request.keyType !== 'undefined')
     request_.keyType =
-      request.keyType === 'multisig' ? 'configurable' : request.keyType
-  if (request.multisigSimulation)
+      request.keyType === 'configurableAccount'
+        ? 'configurable'
+        : request.keyType
+  if (request.configurableAccountSimulation)
     request_.accountSimulation = AccountSimulation.fromRpc(
-      request.multisigSimulation,
+      request.configurableAccountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = Hex.toNumber(request.validBefore as Hex.Hex)
@@ -292,13 +294,15 @@ export function toRpc(request: toRpc.Input): Rpc {
   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 = AccountSimulation.toRpc(
       request.keyAuthorizationSimulation,
     )
   if (typeof request.accountSimulation !== 'undefined')
-    request_rpc.multisigSimulation = AccountSimulation.toRpc(
+    request_rpc.configurableAccountSimulation = AccountSimulation.toRpc(
       request.accountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.8.8'
+export const version = '1.8.9'

package/src/zod/tempo/AccountSimulation.ts

@@ -21,6 +21,7 @@ export const Domain = z.object({
       .check(z.maxLength(core_AccountConfig.maxSignatures)),
   ),
   config: z_AccountConfig.Config,
+  signer: z.optional(z_Address.Address),
 })
 
 const Rpc_ = z
@@ -31,6 +32,7 @@ const Rpc_ = z
         .check(z.maxLength(core_AccountConfig.maxSignatures)),
     ),
     config: z_Hex.Hex,
+    signer: z.optional(z_Address.Address),
   })
   .check(
     z.refine((value) => {

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))
   })