ox 1.8.6 → 1.8.8

package/src/tempo/{MultisigSimulation.test.ts → AccountSimulation.test.ts}

@@ -1,4 +1,4 @@
-import { MultisigConfig, MultisigSimulation } from 'ox/tempo'
+import { AccountConfig, AccountSimulation } from 'ox/tempo'
 import { describe, expect, test } from 'vp/test'
 
 const config =
@@ -12,11 +12,11 @@ const rpc = {
     },
   ],
   config,
-} as const satisfies MultisigSimulation.Rpc
+} as const satisfies AccountSimulation.Rpc
 
 describe('fromRpc', () => {
   test('behavior: decodes the configuration', () => {
-    expect(MultisigSimulation.fromRpc(rpc)).toMatchInlineSnapshot(`
+    expect(AccountSimulation.fromRpc(rpc)).toMatchInlineSnapshot(`
       {
         "approvals": [
           {
@@ -49,35 +49,35 @@ describe('fromRpc', () => {
       '0xf843a0000000000000000000000000000000000000000000000000000000000000000088ffffffffffffffff01d7d694111111111111111111111111111111111111111101' as const
 
     expect(
-      MultisigSimulation.fromRpc({ ...rpc, approvals: [], config }).config
+      AccountSimulation.fromRpc({ ...rpc, approvals: [], config }).config
         .version,
     ).toMatchInlineSnapshot(`18446744073709551615n`)
   })
 
   test('error: rejects excess root approvals', () => {
     expect(() =>
-      MultisigSimulation.fromRpc({
+      AccountSimulation.fromRpc({
         ...rpc,
         approvals: Array.from({ length: 9 }, () => rpc.approvals[0]),
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: approval count exceeds 8.]`,
     )
   })
   test('error: rejects nested approvals', () => {
     expect(() =>
-      MultisigSimulation.fromRpc({
+      AccountSimulation.fromRpc({
         ...rpc,
-        approvals: [{ type: 'multisig', spec: rpc }],
+        approvals: [{ type: 'configurable', spec: rpc }],
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: only untagged primitive owner approvals are allowed.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: only untagged primitive owner approvals are allowed.]`,
     )
   })
 
   test('error: rejects trailing configuration bytes', () => {
     expect(() =>
-      MultisigSimulation.fromRpc({ ...rpc, config: `${config}00` }),
+      AccountSimulation.fromRpc({ ...rpc, config: `${config}00` }),
     ).toThrowErrorMatchingInlineSnapshot(
       `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`1\` trailing byte remains.]`,
     )
@@ -85,7 +85,7 @@ describe('fromRpc', () => {
 
   test('error: rejects malformed configuration RLP', () => {
     expect(() =>
-      MultisigSimulation.fromRpc({ ...rpc, config: '0xf8' }),
+      AccountSimulation.fromRpc({ ...rpc, config: '0xf8' }),
     ).toThrowErrorMatchingInlineSnapshot(
       `[Cursor.PositionOutOfBoundsError: Position \`1\` is out of bounds (\`0 < position < 1\`).]`,
     )
@@ -93,9 +93,9 @@ describe('fromRpc', () => {
 
   test('error: rejects a non-list configuration', () => {
     expect(() =>
-      MultisigSimulation.fromRpc({ ...rpc, config: '0x01' }),
+      AccountSimulation.fromRpc({ ...rpc, config: '0x01' }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: invalid config encoding.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: invalid config encoding.]`,
     )
   })
 
@@ -105,16 +105,16 @@ describe('fromRpc', () => {
       .replace('118002', '11810002') as `0x${string}`
 
     expect(() =>
-      MultisigSimulation.fromRpc({ ...rpc, config: noncanonical }),
+      AccountSimulation.fromRpc({ ...rpc, config: noncanonical }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: invalid config encoding.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: invalid config encoding.]`,
     )
   })
 })
 
 describe('toRpc', () => {
   test('behavior: encodes configurations and shims long key data', () => {
-    expect(MultisigSimulation.toRpc(MultisigSimulation.fromRpc(rpc)))
+    expect(AccountSimulation.toRpc(AccountSimulation.fromRpc(rpc)))
       .toMatchInlineSnapshot(`
         {
           "approvals": [
@@ -130,12 +130,12 @@ describe('toRpc', () => {
   })
 
   test('behavior: preserves short key data', () => {
-    const spec = MultisigSimulation.fromRpc({
+    const spec = AccountSimulation.fromRpc({
       ...rpc,
       approvals: [{ ...rpc.approvals[0], keyData: '0x0102' }],
     })
 
-    expect(MultisigSimulation.toRpc(spec).approvals).toMatchInlineSnapshot(`
+    expect(AccountSimulation.toRpc(spec).approvals).toMatchInlineSnapshot(`
       [
         {
           "keyData": "0x0102",
@@ -147,13 +147,13 @@ describe('toRpc', () => {
   })
 
   test('behavior: encodes the maximum uint64 configuration version', () => {
-    const spec = MultisigSimulation.fromRpc(rpc)
+    const spec = AccountSimulation.fromRpc(rpc)
 
     expect(
-      MultisigSimulation.toRpc({
+      AccountSimulation.toRpc({
         ...spec,
         approvals: [],
-        config: MultisigConfig.from({
+        config: AccountConfig.from({
           owners: [
             {
               owner: '0x1111111111111111111111111111111111111111',
@@ -161,7 +161,7 @@ describe('toRpc', () => {
             },
           ],
           threshold: 1,
-          version: MultisigConfig.maxVersion,
+          version: AccountConfig.maxVersion,
         }),
       }).config,
     ).toMatchInlineSnapshot(
@@ -170,25 +170,25 @@ describe('toRpc', () => {
   })
 
   test('error: rejects excess root approvals', () => {
-    const spec = MultisigSimulation.fromRpc(rpc)
+    const spec = AccountSimulation.fromRpc(rpc)
 
     expect(() =>
-      MultisigSimulation.toRpc({
+      AccountSimulation.toRpc({
         ...spec,
         approvals: Array.from({ length: 9 }, () => spec.approvals[0]!),
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: approval count exceeds 8.]`,
     )
   })
   test('error: rejects nested approvals', () => {
     expect(() =>
-      MultisigSimulation.toRpc({
+      AccountSimulation.toRpc({
         ...rpc,
-        approvals: [{ type: 'multisig', spec: rpc }],
+        approvals: [{ type: 'configurable', spec: rpc }],
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: only untagged primitive owner approvals are allowed.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: only untagged primitive owner approvals are allowed.]`,
     )
   })
 })

package/src/tempo/{MultisigSimulation.ts → AccountSimulation.ts}

@@ -3,13 +3,13 @@ import * as Errors from '../core/Errors.js'
 import * as Hex from '../core/Hex.js'
 import type { Compute } from '../core/internal/types.js'
 import * as Rlp from '../core/Rlp.js'
-import * as MultisigConfig from './MultisigConfig.js'
+import * as AccountConfig from './AccountConfig.js'
 import type * as SignatureEnvelope from './SignatureEnvelope.js'
 
-/** Native multisig owner approval used for RPC simulation. */
+/** Configurable account owner approval used for RPC simulation. */
 export type Approval = PrimitiveApproval
 
-/** JSON-RPC native multisig owner approval used for RPC simulation. */
+/** JSON-RPC configurable account owner approval used for RPC simulation. */
 export type ApprovalRpc = PrimitiveApproval
 
 /** Primitive owner approval used for RPC simulation. */
@@ -22,7 +22,7 @@ export type PrimitiveApproval = {
   owner: Address.Address
 }
 
-/** JSON-RPC representation of a native multisig simulation spec. */
+/** JSON-RPC representation of an account simulation spec. */
 export type Rpc = Compute<{
   /** Owner approvals to model. */
   approvals: readonly ApprovalRpc[]
@@ -30,27 +30,27 @@ export type Rpc = Compute<{
   config: Hex.Hex
 }>
 
-/** Native multisig spec used to construct an RPC simulation signature. */
+/** Account simulation spec used to construct an RPC simulation signature. */
 export type Spec = Compute<{
   /** Owner approvals to model. */
   approvals: readonly Approval[]
   /** Complete applicable configuration. */
-  config: MultisigConfig.Config
+  config: AccountConfig.Config
 }>
 
 /**
- * Converts a JSON-RPC multisig simulation spec to its domain representation.
+ * Converts a JSON-RPC account simulation spec to its domain representation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigSimulation } from 'ox/tempo'
+ * import { AccountSimulation } from 'ox/tempo'
  *
- * const spec = MultisigSimulation.fromRpc(specRpc)
+ * const spec = AccountSimulation.fromRpc(specRpc)
  * ```
  *
- * @param spec - JSON-RPC multisig simulation spec.
- * @returns The multisig simulation spec with decoded configurations.
+ * @param spec - JSON-RPC account simulation spec.
+ * @returns The account simulation spec with decoded configurations.
  */
 export function fromRpc(spec: Rpc): Spec {
   const { approvals, config } = spec
@@ -63,25 +63,25 @@ export declare namespace fromRpc {
   export type ErrorType =
     | Hex.isEqual.ErrorType
     | InvalidSimulationError
-    | MultisigConfig.assert.ErrorType
+    | AccountConfig.assert.ErrorType
     | Rlp.fromHex.ErrorType
     | Rlp.toHex.ErrorType
     | Errors.GlobalErrorType
 }
 
 /**
- * Converts a multisig simulation spec to its JSON-RPC representation.
+ * Converts an account simulation spec to its JSON-RPC representation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigSimulation } from 'ox/tempo'
+ * import { AccountSimulation } from 'ox/tempo'
  *
- * const specRpc = MultisigSimulation.toRpc(spec)
+ * const specRpc = AccountSimulation.toRpc(spec)
  * ```
  *
- * @param spec - Multisig simulation spec.
- * @returns The JSON-RPC multisig simulation spec with encoded configurations.
+ * @param spec - Account simulation spec.
+ * @returns The JSON-RPC account simulation spec with encoded configurations.
  */
 export function toRpc(spec: Spec): Rpc {
   const { approvals, config } = spec
@@ -101,7 +101,7 @@ export declare namespace toRpc {
   export type ErrorType =
     | Hex.fromNumber.ErrorType
     | InvalidSimulationError
-    | MultisigConfig.assert.ErrorType
+    | AccountConfig.assert.ErrorType
     | Rlp.fromHex.ErrorType
     | Errors.GlobalErrorType
 }
@@ -120,14 +120,14 @@ function assertApprovals(approvals: readonly unknown[]) {
     throw new InvalidSimulationError({
       reason: 'only untagged primitive owner approvals are allowed',
     })
-  if (approvals.length > MultisigConfig.maxSignatures)
+  if (approvals.length > AccountConfig.maxSignatures)
     throw new InvalidSimulationError({
-      reason: `approval count exceeds ${MultisigConfig.maxSignatures}`,
+      reason: `approval count exceeds ${AccountConfig.maxSignatures}`,
     })
 }
 
 /** @internal */
-function deserializeConfig(config: Hex.Hex): MultisigConfig.Config {
+function deserializeConfig(config: Hex.Hex): AccountConfig.Config {
   const tuple = Rlp.toHex(config)
   if (!Array.isArray(tuple) || tuple.length !== 4)
     throw new InvalidSimulationError({ reason: 'invalid config encoding' })
@@ -151,18 +151,16 @@ function deserializeConfig(config: Hex.Hex): MultisigConfig.Config {
     )
   )
     throw new InvalidSimulationError({ reason: 'invalid config encoding' })
-  const value = MultisigConfig.fromTuple(
-    tuple as unknown as MultisigConfig.Tuple,
-  )
-  MultisigConfig.assert(value)
+  const value = AccountConfig.fromTuple(tuple as unknown as AccountConfig.Tuple)
+  AccountConfig.assert(value)
   if (!Hex.isEqual(config, serializeConfig(value)))
     throw new InvalidSimulationError({ reason: 'noncanonical config encoding' })
   return value
 }
 
 /** @internal */
-function serializeConfig(config: MultisigConfig.Input): Hex.Hex {
-  return Rlp.fromHex(MultisigConfig.toTuple(config))
+function serializeConfig(config: AccountConfig.Input): Hex.Hex {
+  return Rlp.fromHex(AccountConfig.toTuple(config))
 }
 
 /**
@@ -175,11 +173,11 @@ function shimKeyData(data: Hex.Hex): Hex.Hex {
   return Hex.fromNumber(size, { size: 2 })
 }
 
-/** Thrown when a native multisig simulation spec is invalid. */
+/** Thrown when an account simulation spec is invalid. */
 export class InvalidSimulationError extends Errors.BaseError {
-  override readonly name = 'MultisigSimulation.InvalidSimulationError'
+  override readonly name = 'AccountSimulation.InvalidSimulationError'
   constructor(options: InvalidSimulationError.Options) {
-    super(`Invalid multisig simulation: ${options.reason}.`)
+    super(`Invalid account simulation: ${options.reason}.`)
   }
 }
 

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

@@ -17,7 +17,7 @@ const signature = {
   type: 'secp256k1',
 } as const satisfies SignatureEnvelope.Secp256k1
 
-const multisig = {
+const configurable = {
   account: '0x2222222222222222222222222222222222222222',
   config: {
     salt: `0x${'00'.repeat(32)}`,
@@ -28,8 +28,8 @@ const multisig = {
     ],
   },
   signatures: [signature],
-  type: 'multisig',
-} as const satisfies SignatureEnvelope.Multisig
+  type: 'configurable',
+} as const satisfies SignatureEnvelope.Configurable
 
 test('accepts primitive signatures', () => {
   const signed = KeyAuthorization.from(authorization, { signature })
@@ -39,10 +39,10 @@ test('accepts primitive signatures', () => {
   >()
 })
 
-test('accepts multisig signatures and account-bound grants', () => {
+test('accepts configurable signatures and account-bound grants', () => {
   const signed = KeyAuthorization.from(
-    { ...authorization, account: multisig.account, type: 'multisig' },
-    { signature: multisig },
+    { ...authorization, account: configurable.account, type: 'configurable' },
+    { signature: configurable },
   )
   expectTypeOf(signed).toMatchTypeOf<KeyAuthorization.Signed>()
   expectTypeOf(

package/src/tempo/KeyAuthorization.test.ts

@@ -8,8 +8,8 @@ import {
   WebAuthnP256,
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
+import * as AccountConfig from './AccountConfig.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigConfig from './MultisigConfig.js'
 import * as Period from './Period.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
@@ -71,9 +71,9 @@ const signature_webauthn = SignatureEnvelope.from({
   },
 })
 
-const signature_multisig = {
+const signature_configurable = {
   account: address,
-  config: MultisigConfig.from({
+  config: AccountConfig.from({
     owners: [
       {
         owner: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
@@ -84,9 +84,9 @@ const signature_multisig = {
     version: 1n,
   }),
   signatures: [SignatureEnvelope.from(signature_secp256k1)],
-  type: 'multisig',
-} as const satisfies SignatureEnvelope.Multisig
-const signature_multisig_rpc =
+  type: 'configurable',
+} as const satisfies SignatureEnvelope.Configurable
+const signature_configurable_rpc =
   '0xf89794be95c3f554e9fc85ec51be69a3d807a0d55bcf2cf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d694f39fd6e51aad88f6f4ce6ab8827279cfffb9226601f843b841fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c' as const
 
 const signature_keychain = {
@@ -95,9 +95,13 @@ const signature_keychain = {
   userAddress: address,
 } as const satisfies SignatureEnvelope.Keychain
 
-describe('multisig account binding', () => {
+describe('configurable account binding', () => {
   test('rejects unbound grants before signing or encoding', () => {
-    const authorization = { address, chainId: 1n, type: 'multisig' } as const
+    const authorization = {
+      address,
+      chainId: 1n,
+      type: 'configurable',
+    } as const
     const signed = {
       ...authorization,
       signature: SignatureEnvelope.from(signature_secp256k1),
@@ -110,13 +114,13 @@ describe('multisig account binding', () => {
       () => KeyAuthorization.toRpc(signed),
     ])
       expect(encode).toThrowErrorMatchingInlineSnapshot(
-        `[KeyAuthorization.MissingAccountError: Multisig key grants require a parent account binding.]`,
+        `[KeyAuthorization.MissingAccountError: Configurable account key grants require a parent account binding.]`,
       )
   })
 
   test('rejects unbound RPC and RLP grants', () => {
     const signed = KeyAuthorization.from(
-      { account: address, address, chainId: 1n, type: 'multisig' },
+      { account: address, address, chainId: 1n, type: 'configurable' },
       { signature: signature_secp256k1 },
     )
     const rpc = KeyAuthorization.toRpc(signed)
@@ -156,15 +160,15 @@ describe('from', () => {
     }).toEqual(limitsVectors)
   })
 
-  test('accepts multisig grants and delegates', () => {
+  test('accepts configurable grants and delegates', () => {
     const signed = KeyAuthorization.from(
       {
         address,
         chainId: 1n,
-        type: 'multisig',
-        account: signature_multisig.account,
+        type: 'configurable',
+        account: signature_configurable.account,
       },
-      { signature: signature_multisig },
+      { signature: signature_configurable },
     )
     expect(
       KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
@@ -539,7 +543,7 @@ describe('fromRpc', () => {
     `)
   })
 
-  test('with signature (multisig)', () => {
+  test('with signature (configurable)', () => {
     const authorization = KeyAuthorization.from({
       address,
       chainId: 1n,
@@ -547,20 +551,20 @@ describe('fromRpc', () => {
     })
 
     const signed = KeyAuthorization.from(authorization, {
-      signature: signature_multisig,
+      signature: signature_configurable,
     })
-    expect(signed.signature).toEqual(signature_multisig)
+    expect(signed.signature).toEqual(signature_configurable)
     expect(
       KeyAuthorization.from(authorization, {
-        signature: SignatureEnvelope.serialize(signature_multisig),
+        signature: SignatureEnvelope.serialize(signature_configurable),
       }).signature,
-    ).toEqual(signature_multisig)
+    ).toEqual(signature_configurable)
     expect(
       KeyAuthorization.from({
         ...authorization,
-        signature: signature_multisig,
+        signature: signature_configurable,
       }).signature,
-    ).toEqual(signature_multisig)
+    ).toEqual(signature_configurable)
     expect(
       KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
     ).toEqual(signed)
@@ -578,7 +582,7 @@ describe('fromRpc', () => {
         signature: signature_keychain as never,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
 
     expect(() =>
@@ -586,7 +590,7 @@ describe('fromRpc', () => {
         signature: SignatureEnvelope.serialize(signature_keychain),
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
 
     expect(() =>
@@ -595,19 +599,19 @@ describe('fromRpc', () => {
         signature: signature_keychain,
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
   })
 })
 
 describe('fromRpc', () => {
-  test('behavior: multisig', () => {
+  test('behavior: configurable', () => {
     const authorization = KeyAuthorization.fromRpc({
       chainId: '0x1',
       expiry: null,
       keyId: address,
       keyType: 'secp256k1',
-      signature: signature_multisig_rpc,
+      signature: signature_configurable_rpc,
     })
 
     expect(authorization.signature).toMatchInlineSnapshot(`
@@ -634,7 +638,7 @@ describe('fromRpc', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
   })
@@ -649,7 +653,7 @@ describe('fromRpc', () => {
         signature: SignatureEnvelope.toRpc(signature_keychain),
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
   })
 
@@ -1223,7 +1227,7 @@ describe('getSignPayload', () => {
 })
 
 describe('deserialize', () => {
-  test('example: matches the frozen multisig witness vector', () => {
+  test('example: matches the frozen configurable witness vector', () => {
     const serialized =
       '0xf8f1f85382107980941eff47bc3a10a45d4b230b5d10e37751fe6aa718808080a053535353535353535353535353535353535353535353535353535353535353538094c4a590afa7337e5cd5eb3aa60cacf91c5400044bb89a05f89794c4a590afa7337e5cd5eb3aa60cacf91c5400044bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b8412cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e21451b' as const
     const authorization = KeyAuthorization.deserialize(serialized)
@@ -1256,7 +1260,7 @@ describe('deserialize', () => {
               "type": "secp256k1",
             },
           ],
-          "type": "multisig",
+          "type": "configurable",
         },
         "type": "secp256k1",
         "witness": "0x5353535353535353535353535353535353535353535353535353535353535353",
@@ -1265,14 +1269,14 @@ describe('deserialize', () => {
     expect(KeyAuthorization.serialize(authorization)).toBe(serialized)
   })
 
-  test('multisig', () => {
+  test('configurable', () => {
     const serialized = Rlp.fromHex([
       ['0x1', '0x', address],
-      SignatureEnvelope.serialize(signature_multisig),
+      SignatureEnvelope.serialize(signature_configurable),
     ])
 
     expect(KeyAuthorization.deserialize(serialized).signature).toEqual(
-      signature_multisig,
+      signature_configurable,
     )
   })
 
@@ -1446,16 +1450,28 @@ describe('serialize', () => {
 })
 
 describe('toRpc', () => {
-  test('behavior: multisig', () => {
+  test('behavior: configurable key type uses the RPC multisig key type', () => {
+    const authorization = KeyAuthorization.from(
+      { account: address, address, chainId: 1n, type: 'configurable' },
+      { signature: signature_secp256k1 },
+    )
+    const rpc = KeyAuthorization.toRpc(authorization)
+    expect(rpc.keyType).toMatchInlineSnapshot(`"multisig"`)
+    expect(KeyAuthorization.fromRpc(rpc).type).toMatchInlineSnapshot(
+      `"configurable"`,
+    )
+  })
+
+  test('behavior: configurable', () => {
     const authorization = KeyAuthorization.toRpc({
       address,
       chainId: 1n,
-      signature: signature_multisig,
+      signature: signature_configurable,
       type: 'secp256k1',
     })
 
     expect(authorization.signature).toMatchInlineSnapshot(
-      `"${signature_multisig_rpc}"`,
+      `"${signature_configurable_rpc}"`,
     )
   })