ox 1.8.6 → 1.8.8

package/src/tempo/KeyAuthorization.ts

@@ -29,7 +29,7 @@ import * as SignatureEnvelope from './SignatureEnvelope.js'
  * - `chainId`: Chain ID for replay protection (0 = valid on any chain)
  * - `expiry`: Unix timestamp when the key expires (undefined = never expires)
  * - `limits`: Per-TIP-20 token spending limits (only applies to `transfer()` and `approve()` calls)
- * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `multisig`)
+ * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `configurable`)
  *
  * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
  */
@@ -38,7 +38,7 @@ export type KeyAuthorization<
   bigintType = bigint,
   numberType = number,
 > = {
-  /** Account address this authorization is bound to. Required for multisig grants. */
+  /** Account address this authorization is bound to. Required for configurable account grants. */
   account?: Address.Address | undefined
   /** Address derived from the public key of the key type. */
   address: Address.Address
@@ -64,8 +64,8 @@ export type KeyAuthorization<
    * - `[...]` = only listed contract+selector combinations allowed
    */
   scopes?: readonly Scope[] | undefined
-  /** Key type (secp256k1, P256, WebAuthn, or multisig). */
-  type: SignatureEnvelope.Type | 'multisig'
+  /** Key type (secp256k1, P256, WebAuthn, or configurable account). */
+  type: SignatureEnvelope.Type | 'configurable'
   /**
    * Optional 32-byte witness bound into the signing hash.
    *
@@ -80,23 +80,23 @@ export type KeyAuthorization<
   ? {
       signature:
         | SignatureEnvelope.Primitive<numberType>
-        | SignatureEnvelope.Multisig<numberType>
+        | SignatureEnvelope.Configurable<numberType>
     }
   : {
       signature?:
         | SignatureEnvelope.Primitive<numberType>
-        | SignatureEnvelope.Multisig<numberType>
+        | SignatureEnvelope.Configurable<numberType>
         | undefined
     })
 
 /** Signature that can authorize an access key. */
 export type Signature<numberType = number> =
   | SignatureEnvelope.Primitive<numberType>
-  | SignatureEnvelope.Multisig<numberType>
+  | SignatureEnvelope.Configurable<numberType>
 
 /** RPC-formatted signature that can authorize an access key. */
 export type SignatureRpc =
-  | SignatureEnvelope.MultisigRpc
+  | SignatureEnvelope.ConfigurableRpc
   | SignatureEnvelope.PrimitiveRpc
 
 /** Input type for a Key Authorization. */
@@ -116,12 +116,12 @@ export type Rpc = {
   isAdmin?: boolean | null | undefined
   /** Key identifier. */
   keyId: Address.Address
-  /** Key type. */
+  /** Key type. Configurable accounts use the node's `multisig` key type. */
   keyType: SignatureEnvelope.Type | 'multisig'
   /** Token spending limits (`null`/`undefined` = unlimited, `[]` = no spending allowed). */
   limits?: readonly RpcTokenLimit[] | null | undefined
-  /** Primitive or multisig signature authorizing this key. */
-  signature: SignatureEnvelope.PrimitiveRpc | SignatureEnvelope.MultisigRpc
+  /** Primitive or configurable account signature authorizing this key. */
+  signature: SignatureEnvelope.PrimitiveRpc | SignatureEnvelope.ConfigurableRpc
   /** Optional 32-byte witness (hex). */
   witness?: Hex.Hex | null | undefined
 }
@@ -153,9 +153,9 @@ export type Signed<bigintType = bigint, numberType = number> = KeyAuthorization<
 >
 
 type SignatureValue =
-  | SignatureEnvelope.from.MultisigFromConfig
+  | SignatureEnvelope.from.ConfigurableFromConfig
   | UnionPartialBy<SignatureEnvelope.Primitive, 'prehash' | 'type'>
-  | PartialBy<SignatureEnvelope.Multisig, 'type'>
+  | PartialBy<SignatureEnvelope.Configurable, 'type'>
   | SignatureEnvelope.Secp256k1Flat
   | SignatureEnvelope.Serialized
 
@@ -484,11 +484,11 @@ export declare namespace from {
   type Options<
     signature extends SignatureValue | undefined = SignatureValue | undefined,
   > = {
-    /** The primitive or multisig signature to attach to the Key Authorization. */
+    /** The primitive or configurable account signature to attach to the Key Authorization. */
     signature?:
       | signature
       | SignatureEnvelope.Primitive
-      | SignatureEnvelope.Multisig
+      | SignatureEnvelope.Configurable
       | undefined
   }
 
@@ -503,7 +503,7 @@ export declare namespace from {
             ? {
                 signature: Extract<
                   SignatureEnvelope.from.ReturnValue<signature>,
-                  SignatureEnvelope.Primitive | SignatureEnvelope.Multisig
+                  SignatureEnvelope.Primitive | SignatureEnvelope.Configurable
                 >
               }
             : {})
@@ -551,7 +551,8 @@ export function fromRpc(authorization: Rpc): Signed {
   const witness = authorization.witness ?? undefined
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
-  assertAccountBinding(keyType, account)
+  const type = keyType === 'multisig' ? 'configurable' : keyType
+  assertAccountBinding(type, account)
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
   assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
@@ -586,7 +587,7 @@ export function fromRpc(authorization: Rpc): Signed {
     })),
     ...(scopes ? { scopes } : {}),
     signature,
-    type: keyType,
+    type,
     ...(witness !== undefined ? { witness } : {}),
     ...(account !== undefined ? { account } : {}),
     ...(isAdmin ? { isAdmin: true as const } : {}),
@@ -670,7 +671,7 @@ export function fromTuple<const tuple extends Tuple>(
       case '0x02':
         return 'webAuthn'
       case '0x03':
-        return 'multisig'
+        return 'configurable'
       default:
         throw new Error(`Invalid key type: ${keyType_hex}`)
     }
@@ -1007,7 +1008,7 @@ export function toRpc(authorization: toRpc.Input): Rpc {
     chainId: chainIdHex === '0x0' ? '0x' : chainIdHex,
     expiry: expiry != null ? Quantity.fromNumberish(expiry) : null,
     keyId: address,
-    keyType: type,
+    keyType: type === 'configurable' ? 'multisig' : type,
     limits: limits?.map(({ token, limit, period }) => ({
       token,
       limit: Quantity.fromNumberish(limit),
@@ -1015,7 +1016,7 @@ export function toRpc(authorization: toRpc.Input): Rpc {
     })),
     signature: SignatureEnvelope.toRpc(signature) as
       | SignatureEnvelope.PrimitiveRpc
-      | SignatureEnvelope.MultisigRpc,
+      | SignatureEnvelope.ConfigurableRpc,
     ...(allowedCalls ? { allowedCalls } : {}),
     ...(witness !== undefined ? { witness } : {}),
     ...(isAdmin ? { isAdmin: true } : {}),
@@ -1094,7 +1095,7 @@ export function toTuple<const authorization extends KeyAuthorization>(
         return '0x01'
       case 'webAuthn':
         return '0x02'
-      case 'multisig':
+      case 'configurable':
         return '0x03'
       default:
         throw new Error(`Invalid key type: ${authorization.type}`)
@@ -1218,7 +1219,8 @@ function assertAccountBinding(
   type: KeyAuthorization['type'],
   account: Address.Address | null | undefined,
 ): void {
-  if (type === 'multisig' && account == null) throw new MissingAccountError()
+  if (type === 'configurable' && account == null)
+    throw new MissingAccountError()
 }
 
 function assertWitness(witness: Hex.Hex): void {
@@ -1229,7 +1231,7 @@ function assertSignature<numberType>(
   signature: SignatureEnvelope.SignatureEnvelope<numberType>,
 ): asserts signature is
   | SignatureEnvelope.Primitive<numberType>
-  | SignatureEnvelope.Multisig<numberType> {
+  | SignatureEnvelope.Configurable<numberType> {
   if (signature.type === 'keychain')
     throw new InvalidSignatureTypeError(signature.type)
 }
@@ -1263,15 +1265,15 @@ export class InvalidSignatureTypeError extends Error {
   override readonly name = 'KeyAuthorization.InvalidSignatureTypeError'
   constructor(type: SignatureEnvelope.SignatureEnvelope['type']) {
     super(
-      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.`,
+      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.`,
     )
   }
 }
 
-/** Thrown when a multisig key grant omits its parent account binding. */
+/** Thrown when a configurable account key grant omits its parent account binding. */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'
   constructor() {
-    super('Multisig key grants require a parent account binding.')
+    super('Configurable account key grants require a parent account binding.')
   }
 }

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

@@ -1,76 +1,76 @@
 import type { Provider } from 'ox'
 import type {
+  AccountConfig,
+  AccountSimulation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
-  MultisigSimulation,
+  AccountOperation,
   RpcSchemaTempo,
 } from 'ox/tempo'
 import { expectTypeOf, test } from 'vp/test'
 import type * as Address from '../core/Address.js'
 import type * as Hex from '../core/Hex.js'
 
-declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Multisig }>
+declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Account }>
 declare const tempoProvider: Provider.Provider<{
   schema: RpcSchemaTempo.Tempo
 }>
 declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigSimulation: MultisigSimulation.Rpc
+declare const multisigSimulation: AccountSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
-test('multisig provider methods', () => {
+test('account provider methods', () => {
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ keyAuthorization }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ hash, signature }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransaction',
+      method: 'account_approveRawTransaction',
       params: [serializedTransaction],
     }),
   ).resolves.toEqualTypeOf<Hex.Hex>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransactionSync',
+      method: 'account_approveRawTransactionSync',
       params: [serializedTransaction],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.TransactionRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.TransactionRpc>()
 
   void provider.request({
-    method: 'multisig_approveRawTransactionSync',
+    method: 'account_approveRawTransactionSync',
     params: [serializedTransaction, 30_000],
   })
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getConfig',
+      method: 'account_getConfig',
       params: [{ address }],
     }),
-  ).resolves.toEqualTypeOf<MultisigConfig.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountConfig.Rpc | null>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getOperation',
+      method: 'account_getOperation',
       params: [hash],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountOperation.Rpc | null>()
 })
 
-test('tempo simulation accepts multisig specs', () => {
+test('tempo simulation accepts account simulation specs', () => {
   void tempoProvider.request({
     method: 'tempo_simulateV1',
     params: [

package/src/tempo/RpcSchemaTempo.ts

@@ -5,9 +5,9 @@ import type * as Hex from '../core/Hex.js'
 import type * as Log from '../core/Log.js'
 import type * as RpcSchema from '../core/RpcSchema.js'
 import type * as StateOverrides from '../core/StateOverrides.js'
+import type * as AccountConfig from './AccountConfig.js'
 import type * as KeyAuthorization from './KeyAuthorization.js'
-import type * as MultisigConfig from './MultisigConfig.js'
-import type * as MultisigOperation from './MultisigOperation.js'
+import type * as AccountOperation from './AccountOperation.js'
 import type * as TransactionRequest from './TransactionRequest.js'
 
 /**
@@ -58,44 +58,44 @@ export type Tempo = RpcSchema.From<{
   }
 }>
 
-/** Union of all JSON-RPC methods for the `multisig_` namespace. */
-export type Multisig = RpcSchema.From<
+/** Union of all JSON-RPC methods for the `account_` namespace. */
+export type Account = RpcSchema.From<
   | {
       Request: {
-        method: 'multisig_approveKeyAuthorization'
+        method: 'account_approveKeyAuthorization'
         params: [
           | { keyAuthorization: KeyAuthorization.Rpc }
           | { hash: Hex.Hex; signature: Hex.Hex },
         ]
       }
-      ReturnType: MultisigOperation.KeyAuthorizationRpc
+      ReturnType: AccountOperation.KeyAuthorizationRpc
     }
   | {
       Request: {
-        method: 'multisig_approveRawTransaction'
+        method: 'account_approveRawTransaction'
         params: [serializedTransaction: Hex.Hex]
       }
       ReturnType: Hex.Hex
     }
   | {
       Request: {
-        method: 'multisig_approveRawTransactionSync'
+        method: 'account_approveRawTransactionSync'
         params: [serializedTransaction: Hex.Hex, timeout?: number]
       }
-      ReturnType: MultisigOperation.TransactionRpc
+      ReturnType: AccountOperation.TransactionRpc
     }
   | {
       Request: {
-        method: 'multisig_getConfig'
+        method: 'account_getConfig'
         params: [{ address: Address.Address }]
       }
-      ReturnType: MultisigConfig.Rpc | null
+      ReturnType: AccountConfig.Rpc | null
     }
   | {
       Request: {
-        method: 'multisig_getOperation'
+        method: 'account_getOperation'
         params: [hash: Hex.Hex]
       }
-      ReturnType: MultisigOperation.Rpc | null
+      ReturnType: AccountOperation.Rpc | null
     }
 >

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

@@ -15,24 +15,24 @@ const envelope = SignatureEnvelope.from({
   signatures: [primitive],
 })
 
-test('preserves primitive and multisig RPC types', () => {
+test('preserves primitive and configurable RPC types', () => {
   expectTypeOf(
     SignatureEnvelope.toRpc(primitive),
   ).toEqualTypeOf<SignatureEnvelope.Secp256k1Rpc>()
   expectTypeOf(SignatureEnvelope.toRpc(envelope)).toEqualTypeOf<Hex.Hex>()
   expectTypeOf<
     SignatureEnvelope.GetType<typeof envelope>
-  >().toEqualTypeOf<'multisig'>()
-  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Multisig>()
+  >().toEqualTypeOf<'configurable'>()
+  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Configurable>()
 })
 
 test('requires config and primitive approvals', () => {
-  // @ts-expect-error Every multisig signature carries its current config.
+  // @ts-expect-error Every configurable signature carries its current config.
   SignatureEnvelope.from({ account: envelope.account, signatures: [primitive] })
-  // @ts-expect-error Multisig owners cannot recursively approve with multisigs.
+  // @ts-expect-error Configurable owners cannot recursively approve with configurable signatures.
   SignatureEnvelope.from({ ...envelope, signatures: [envelope] })
-  // @ts-expect-error Multisig RPC signatures are hex-encoded RLP.
-  const rpc: SignatureEnvelope.MultisigRpc = {
+  // @ts-expect-error Configurable RPC signatures are hex-encoded RLP.
+  const rpc: SignatureEnvelope.ConfigurableRpc = {
     account: envelope.account,
     signatures: [],
   }

package/src/tempo/SignatureEnvelope.test.ts

@@ -10,7 +10,7 @@ import {
   WebCryptoP256,
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
-import * as MultisigConfig from './MultisigConfig.js'
+import * as AccountConfig from './AccountConfig.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
 const publicKey = PublicKey.from({
@@ -530,7 +530,7 @@ describe('deserialize', () => {
         SignatureEnvelope.deserialize('0xdeadbeef'),
       ).toThrowErrorMatchingInlineSnapshot(
         `
-        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xde. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Multisig)
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xde. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Configurable)
 
         Serialized: 0xdeadbeef]
       `,
@@ -690,7 +690,7 @@ describe('deserialize', () => {
         SignatureEnvelope.deserialize(unknownType),
       ).toThrowErrorMatchingInlineSnapshot(
         `
-        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xff. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Multisig)
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xff. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Configurable)
 
         Serialized: 0xff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
       `,
@@ -1115,7 +1115,7 @@ describe('from', () => {
     })
   })
 
-  describe('multisig', () => {
+  describe('configurable', () => {
     test('normalizes the current config', () => {
       const envelope = SignatureEnvelope.from({
         account: '0x2222222222222222222222222222222222222222',
@@ -1750,7 +1750,7 @@ describe('serialize', () => {
   })
 })
 
-describe('sortMultisigApprovals', () => {
+describe('sortApprovals', () => {
   // Build owner key pairs first so we can construct a real genesis config
   // whose owner set matches the keys that produce the approvals below.
   const ownerKeys = Array.from({ length: 3 }, () => {
@@ -1764,16 +1764,16 @@ describe('sortMultisigApprovals', () => {
     Hex.toBigInt(a.address) < Hex.toBigInt(b.address) ? -1 : 1,
   )
 
-  const genesisConfig = MultisigConfig.from({
+  const genesisConfig = AccountConfig.from({
     threshold: 2,
     owners: ascendingOwners.map((o) => ({ owner: o.address, weight: 1 })),
   })
   const payload = `0x${'42'.repeat(32)}` as const
-  const account = MultisigConfig.getAddress(genesisConfig, {
+  const account = AccountConfig.getAddress(genesisConfig, {
     factory: '0x7171717171717171717171717171717171717171',
   })
   const version = 3n
-  const digest = MultisigConfig.getSignPayload({
+  const digest = AccountConfig.getSignPayload({
     payload,
     account,
     config: { version },
@@ -1791,7 +1791,7 @@ describe('sortMultisigApprovals', () => {
   }))
 
   test('behavior: orders approvals ascending by recovered owner address', () => {
-    const ordered = SignatureEnvelope.sortMultisigApprovals({
+    const ordered = SignatureEnvelope.sortApprovals({
       account,
       config: { version },
       payload,
@@ -1804,7 +1804,7 @@ describe('sortMultisigApprovals', () => {
   test('behavior: already-sorted input is unchanged', () => {
     const signatures = ascending.map((owner) => owner.signature)
     expect(
-      SignatureEnvelope.sortMultisigApprovals({
+      SignatureEnvelope.sortApprovals({
         account,
         config: { version },
         payload,
@@ -1814,7 +1814,7 @@ describe('sortMultisigApprovals', () => {
   })
 
   test('behavior: recovered order matches the config owner order', () => {
-    const ordered = SignatureEnvelope.sortMultisigApprovals({
+    const ordered = SignatureEnvelope.sortApprovals({
       account,
       config: { version },
       payload,
@@ -2832,9 +2832,9 @@ describe('CoercionError', () => {
   })
 })
 
-describe('multisig', () => {
+describe('configurable', () => {
   const account = '0x2222222222222222222222222222222222222222'
-  const config = MultisigConfig.from({
+  const config = AccountConfig.from({
     threshold: 1,
     owners: [
       { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -2853,7 +2853,7 @@ describe('multisig', () => {
     expect(Rlp.toHex(Hex.slice(serialized, 1))).toEqual([
       account,
       [
-        MultisigConfig.zeroSalt,
+        AccountConfig.zeroSalt,
         '0x',
         '0x01',
         [['0x1111111111111111111111111111111111111111', '0x01']],
@@ -2894,7 +2894,7 @@ describe('multisig', () => {
   })
 
   test('rejects old wire and RPC shapes', () => {
-    for (const first of [account, MultisigConfig.toTuple(config)] as const)
+    for (const first of [account, AccountConfig.toTuple(config)] as const)
       expect(() =>
         SignatureEnvelope.deserialize(
           Hex.concat(
@@ -2909,7 +2909,7 @@ describe('multisig', () => {
   })
 
   test('rejects malformed configs', () => {
-    const valid = MultisigConfig.toTuple(config)
+    const valid = AccountConfig.toTuple(config)
     for (const tuple of [
       ['0x00', ...valid.slice(1)],
       [valid[0], '0x00', valid[2], valid[3]],
@@ -2929,7 +2929,7 @@ describe('multisig', () => {
             ]),
           ),
         ),
-      ).toThrowError(MultisigConfig.InvalidConfigError)
+      ).toThrowError(AccountConfig.InvalidConfigError)
   })
 
   test('rejects invalid accounts, missing configs, and invalid approval counts', () => {
@@ -2955,7 +2955,7 @@ describe('multisig', () => {
       config: { ...config, owners: [{ owner: account, weight: 1 }] },
     } as const
     expect(() => SignatureEnvelope.assert(self)).toThrowError(
-      SignatureEnvelope.InvalidMultisigApprovalError,
+      SignatureEnvelope.InvalidApprovalError,
     )
     expect(() =>
       SignatureEnvelope.assert({
@@ -2972,12 +2972,12 @@ describe('multisig', () => {
           ...envelope,
           signatures: [signature],
         } as never),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       const wire = Hex.concat(
         '0x05',
         Rlp.fromHex([
           account,
-          MultisigConfig.toTuple(config),
+          AccountConfig.toTuple(config),
           [SignatureEnvelope.serialize(signature)],
         ]),
       )
@@ -2997,9 +2997,9 @@ describe('multisig', () => {
     }
     expect(() =>
       SignatureEnvelope.assert({ ...envelope, signatures: [oversized] }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
   })
-  test('requires keychain V2 for multisig delegates', () => {
+  test('requires keychain V2 for configurable delegates', () => {
     const keychain = SignatureEnvelope.from({
       userAddress: account,
       version: 'v2',
@@ -3009,12 +3009,12 @@ describe('multisig', () => {
     expect(SignatureEnvelope.deserialize(serialized)).toEqual(keychain)
     expect(() =>
       SignatureEnvelope.serialize({ ...keychain, version: 'v1' }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     expect(() =>
       SignatureEnvelope.deserialize(
         Hex.concat('0x03', Hex.slice(serialized, 1)),
       ),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     expect(() =>
       SignatureEnvelope.fromRpc({
         type: 'keychain',
@@ -3022,9 +3022,9 @@ describe('multisig', () => {
         version: 'v1',
         signature: SignatureEnvelope.toRpc(envelope),
       }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
   })
-  test('rejects V1 wrappers around recursively nested multisig delegates', () => {
+  test('rejects V1 wrappers around recursively nested configurable delegates', () => {
     let inner: SignatureEnvelope.SignatureEnvelope = envelope
     for (let depth = 0; depth < 3; depth++) {
       inner = { inner, type: 'keychain', userAddress: account, version: 'v2' }
@@ -3038,10 +3038,10 @@ describe('multisig', () => {
       expect(SignatureEnvelope.validate(valid)).toBe(true)
       expect(SignatureEnvelope.validate(invalid)).toBe(false)
       expect(() => SignatureEnvelope.serialize(invalid)).toThrowError(
-        SignatureEnvelope.InvalidMultisigApprovalError,
+        SignatureEnvelope.InvalidApprovalError,
       )
       expect(() => SignatureEnvelope.toRpc(invalid)).toThrowError(
-        SignatureEnvelope.InvalidMultisigApprovalError,
+        SignatureEnvelope.InvalidApprovalError,
       )
       expect(() =>
         SignatureEnvelope.fromRpc({
@@ -3050,15 +3050,15 @@ describe('multisig', () => {
           version: 'v1',
           signature: SignatureEnvelope.toRpc(inner),
         }),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       expect(() =>
         SignatureEnvelope.deserialize(
           Hex.concat('0x03', account, SignatureEnvelope.serialize(inner)),
         ),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       expect(() =>
         SignatureEnvelope.serialize({ ...valid, inner: invalid }),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     }
     expect(
       SignatureEnvelope.validate({
@@ -3123,7 +3123,7 @@ describe('multisig', () => {
   })
 })
 
-describe('multisig vectors', () => {
+describe('configurable vectors', () => {
   const initial =
     '0x05f89794c4a590afa7337e5cd5eb3aa60cacf91c5400044bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b' as const
   const current =
@@ -3156,7 +3156,7 @@ describe('multisig vectors', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
     expect(SignatureEnvelope.serialize(envelope)).toBe(initial)
@@ -3189,7 +3189,7 @@ describe('multisig vectors', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
     expect(SignatureEnvelope.serialize(envelope)).toBe(current)