ox 1.8.6 → 1.8.7

package/src/tempo/{MultisigOperation.ts → AccountOperation.ts}

@@ -2,22 +2,22 @@ import * as Address from '../core/Address.js'
 import * as Errors from '../core/Errors.js'
 import * as Hash from '../core/Hash.js'
 import * as Hex from '../core/Hex.js'
+import * as AccountConfig from './AccountConfig.js'
 import * as KeyAuthorization_ from './KeyAuthorization.js'
-import * as MultisigConfig from './MultisigConfig.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
 
-/** Fields shared by every multisig operation. */
+/** Fields shared by every account operation. */
 export type Base<quantity = bigint> = {
-  /** Root multisig account. */
+  /** Root configurable account. */
   account: Address.Address
   /** Every retained serialized owner approval. */
   approvals: readonly Hex.Hex[]
   /** Root configuration used to verify approvals. */
-  config: MultisigConfig.Config<quantity>
+  config: AccountConfig.Config<quantity>
   /** Unix creation time in milliseconds. */
   createdAt: number
-  /** Deterministic multisig operation hash. */
+  /** Deterministic account operation hash. */
   hash: Hex.Hex
   /** Number of approvals selected for quorum evaluation. */
   signatureCount: number
@@ -29,7 +29,7 @@ export type Base<quantity = bigint> = {
   weight: number
 }
 
-/** Multisig transaction approval operation. */
+/** Account transaction approval operation. */
 export type TransactionOperation<quantity = bigint> = Base<quantity> & {
   /** Time when another relay may reclaim the submission lease. */
   expiresAt?: number | undefined
@@ -45,7 +45,7 @@ export type TransactionOperation<quantity = bigint> = Base<quantity> & {
   type: 'transaction'
 }
 
-/** Multisig key authorization approval operation. */
+/** Account key authorization approval operation. */
 export type KeyAuthorizationOperation<quantity = bigint> = Base<quantity> & {
   /** Canonical serialized key authorization. */
   keyAuthorization: Hex.Hex
@@ -55,29 +55,29 @@ export type KeyAuthorizationOperation<quantity = bigint> = Base<quantity> & {
   type: 'keyAuthorization'
 }
 
-/** Transaction or key authorization multisig operation. */
+/** Transaction or key authorization account operation. */
 export type Operation<quantity = bigint> =
   | TransactionOperation<quantity>
   | KeyAuthorizationOperation<quantity>
 
-/** JSON-RPC multisig transaction operation. */
+/** JSON-RPC account transaction operation. */
 export type TransactionRpc = TransactionOperation<Hex.Hex>
 
-/** JSON-RPC multisig key authorization operation. */
+/** JSON-RPC account key authorization operation. */
 export type KeyAuthorizationRpc = KeyAuthorizationOperation<Hex.Hex>
 
-/** JSON-RPC multisig operation. */
+/** JSON-RPC account operation. */
 export type Rpc = Operation<Hex.Hex>
 
 /**
- * Derives the deterministic hash for a multisig operation.
+ * Derives the deterministic hash for an account operation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const hash = MultisigOperation.getHash({
+ * const hash = AccountOperation.getHash({
  *   account,
  *   config,
  *   transaction,
@@ -85,7 +85,7 @@ export type Rpc = Operation<Hex.Hex>
  * })
  * ```
  *
- * @param options - Operation payload and multisig identity.
+ * @param options - Operation payload and account identity.
  * @returns The operation hash signed by each owner.
  */
 export function getHash(options: getHash.Options): Hex.Hex {
@@ -98,7 +98,7 @@ export function getHash(options: getHash.Options): Hex.Hex {
       : KeyAuthorization_.getSignPayload(
           KeyAuthorization_.deserialize(options.keyAuthorization),
         )
-  return MultisigConfig.getSignPayload({
+  return AccountConfig.getSignPayload({
     account,
     config,
     payload,
@@ -108,10 +108,10 @@ export function getHash(options: getHash.Options): Hex.Hex {
 export declare namespace getHash {
   /** Parameters for `getHash`. */
   export type Options = {
-    /** Root multisig account. */
+    /** Root configurable account. */
     account: Address.Address
-    /** Complete root multisig configuration witness. */
-    config: MultisigConfig.Config
+    /** Complete root account configuration witness. */
+    config: AccountConfig.Config
   } & (
     | {
         /** Canonical serialized key authorization. */
@@ -131,7 +131,7 @@ export declare namespace getHash {
   export type ErrorType =
     | KeyAuthorization_.deserialize.ErrorType
     | KeyAuthorization_.getSignPayload.ErrorType
-    | MultisigConfig.getSignPayload.ErrorType
+    | AccountConfig.getSignPayload.ErrorType
     | TxEnvelopeTempo.deserialize.ErrorType
     | TxEnvelopeTempo.getSignPayload.ErrorType
     | Errors.GlobalErrorType
@@ -148,9 +148,9 @@ export declare namespace getHash {
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const selection = await MultisigOperation.selectApprovals({
+ * const selection = await AccountOperation.selectApprovals({
  *   account,
  *   approvals,
  *   config,
@@ -169,7 +169,7 @@ export async function selectApprovals(
     throw new InvalidApprovalError({ reason: 'account is invalid' })
   if (!Hash.validate(hash))
     throw new InvalidApprovalError({ reason: 'hash is invalid' })
-  const config = MultisigConfig.from(options.config)
+  const config = AccountConfig.from(options.config)
   return selectApprovals_internal({
     account,
     approvals,
@@ -181,12 +181,12 @@ export async function selectApprovals(
 export declare namespace selectApprovals {
   /** Parameters for `selectApprovals`. */
   export type Options = {
-    /** Root multisig account. */
+    /** Root configurable account. */
     account: Address.Address
     /** Serialized primitive owner approvals. */
     approvals: readonly SignatureEnvelope.Serialized[]
-    /** Current root multisig configuration. */
-    config: MultisigConfig.Config
+    /** Current root account configuration. */
+    config: AccountConfig.Config
     /** Deterministic operation hash approved by root owners. */
     hash: Hex.Hex
   }
@@ -208,8 +208,8 @@ export declare namespace selectApprovals {
   /** Error type for `selectApprovals`. */
   export type ErrorType =
     | InvalidApprovalError
-    | MultisigConfig.assert.ErrorType
-    | MultisigConfig.getSignPayload.ErrorType
+    | AccountConfig.assert.ErrorType
+    | AccountConfig.getSignPayload.ErrorType
     | SignatureEnvelope.CoercionError
     | SignatureEnvelope.extractAddress.ErrorType
     | SignatureEnvelope.serialize.ErrorType
@@ -218,15 +218,15 @@ export declare namespace selectApprovals {
 }
 
 /**
- * Serializes a key authorization with selected multisig owner approvals.
+ * Serializes a key authorization with selected owner approvals.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
  * const authorization =
- *   MultisigOperation.serializeKeyAuthorization(
+ *   AccountOperation.serializeKeyAuthorization(
  *     keyAuthorization,
  *     {
  *       account,
@@ -237,7 +237,7 @@ export declare namespace selectApprovals {
  * ```
  *
  * @param keyAuthorization - Canonical serialized unsigned key authorization.
- * @param options - Multisig account, config, and selected approvals.
+ * @param options - Configurable account, config, and selected approvals.
  * @returns The signed serialized key authorization.
  */
 export function serializeKeyAuthorization(
@@ -256,8 +256,8 @@ export function serializeKeyAuthorization(
     throw new InvalidOperationError({
       reason: 'keyAuthorization is not canonically serialized',
     })
-  const config = MultisigConfig.from(options.config)
-  const signatures = SignatureEnvelope.sortMultisigApprovals({
+  const config = AccountConfig.from(options.config)
+  const signatures = SignatureEnvelope.sortApprovals({
     account: options.account,
     config,
     payload: KeyAuthorization_.getSignPayload(authorization),
@@ -279,12 +279,12 @@ export function serializeKeyAuthorization(
 export declare namespace serializeKeyAuthorization {
   /** Options for `serializeKeyAuthorization`. */
   export type Options = {
-    /** Root multisig account. */
+    /** Root configurable account. */
     account: Address.Address
     /** Selected serialized owner approvals. */
     approvals: readonly SignatureEnvelope.Serialized[]
-    /** Complete applicable root multisig config. */
-    config: MultisigConfig.Config
+    /** Complete applicable root account config. */
+    config: AccountConfig.Config
   }
 
   /** Error type for `serializeKeyAuthorization`. */
@@ -294,22 +294,22 @@ export declare namespace serializeKeyAuthorization {
     | KeyAuthorization_.from.ErrorType
     | KeyAuthorization_.getSignPayload.ErrorType
     | KeyAuthorization_.serialize.ErrorType
-    | MultisigConfig.assert.ErrorType
+    | AccountConfig.assert.ErrorType
     | SignatureEnvelope.assert.ErrorType
     | SignatureEnvelope.InvalidSerializedError
-    | SignatureEnvelope.sortMultisigApprovals.ErrorType
+    | SignatureEnvelope.sortApprovals.ErrorType
     | Errors.GlobalErrorType
 }
 
 /**
- * Serializes a multisig transaction operation with selected owner approvals.
+ * Serializes an account transaction operation with selected owner approvals.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const transaction = MultisigOperation.serializeTransaction(
+ * const transaction = AccountOperation.serializeTransaction(
  *   operation,
  *   {
  *     approvals: selection.selectedApprovals
@@ -317,7 +317,7 @@ export declare namespace serializeKeyAuthorization {
  * )
  * ```
  *
- * @param operation - Multisig transaction operation.
+ * @param operation - Account transaction operation.
  * @param options - Transaction serialization options.
  * @returns The signed serialized Tempo transaction.
  */
@@ -333,7 +333,7 @@ export function serializeTransaction(
     assertApproval(value.account, approval, value.config),
   )
   assertRetainedApprovals(value, approvals)
-  const signatures = SignatureEnvelope.sortMultisigApprovals({
+  const signatures = SignatureEnvelope.sortApprovals({
     account: value.account,
     config: value.config,
     payload: TxEnvelopeTempo.getSignPayload(envelope),
@@ -367,7 +367,7 @@ export declare namespace serializeTransaction {
   export type ErrorType =
     | from.ErrorType
     | InvalidOperationError
-    | SignatureEnvelope.sortMultisigApprovals.ErrorType
+    | SignatureEnvelope.sortApprovals.ErrorType
     | TxEnvelopeTempo.deserialize.ErrorType
     | TxEnvelopeTempo.getSignPayload.ErrorType
     | TxEnvelopeTempo.serialize.ErrorType
@@ -375,24 +375,24 @@ export declare namespace serializeTransaction {
 }
 
 /**
- * Validates and normalizes a multisig operation.
+ * Validates and normalizes an account operation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const operation = MultisigOperation.from(value)
+ * const operation = AccountOperation.from(value)
  * ```
  *
- * @param operation - Multisig operation.
+ * @param operation - Account operation.
  * @returns The validated operation.
  */
 export function from<const operation extends Operation>(
   operation: operation,
 ): from.ReturnValue<operation> {
   try {
-    const config = MultisigConfig.from(operation.config)
+    const config = AccountConfig.from(operation.config)
     if (
       typeof config.threshold !== 'number' ||
       config.owners.some((owner) => typeof owner.weight !== 'number')
@@ -425,17 +425,17 @@ export declare namespace from {
 }
 
 /**
- * Converts a JSON-RPC multisig operation to its domain representation.
+ * Converts a JSON-RPC account operation to its domain representation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const operation = MultisigOperation.fromRpc(value)
+ * const operation = AccountOperation.fromRpc(value)
  * ```
  *
- * @param operation - JSON-RPC multisig operation.
+ * @param operation - JSON-RPC account operation.
  * @returns The validated operation.
  */
 export function fromRpc<const operation extends Rpc>(
@@ -454,7 +454,7 @@ export function fromRpc<const operation extends Rpc>(
       })
     return from({
       ...operation,
-      config: MultisigConfig.fromRpc(operation.config),
+      config: AccountConfig.fromRpc(operation.config),
     } as Operation) as never
   } catch (cause) {
     if (cause instanceof InvalidOperationError) throw cause
@@ -474,17 +474,17 @@ export declare namespace fromRpc {
 }
 
 /**
- * Converts a multisig operation to its JSON-RPC representation.
+ * Converts an account operation to its JSON-RPC representation.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { MultisigOperation } from 'ox/tempo'
+ * import { AccountOperation } from 'ox/tempo'
  *
- * const operationRpc = MultisigOperation.toRpc(operation)
+ * const operationRpc = AccountOperation.toRpc(operation)
  * ```
  *
- * @param operation - Multisig operation.
+ * @param operation - Account operation.
  * @returns The JSON-RPC operation.
  */
 export function toRpc<const operation extends Operation>(
@@ -493,7 +493,7 @@ export function toRpc<const operation extends Operation>(
   const value = from(operation)
   return {
     ...value,
-    config: MultisigConfig.toRpc(value.config),
+    config: AccountConfig.toRpc(value.config),
   } as never
 }
 
@@ -505,7 +505,7 @@ export declare namespace toRpc {
       : KeyAuthorizationRpc
 
   /** Error type for `toRpc`. */
-  export type ErrorType = from.ErrorType | MultisigConfig.toRpc.ErrorType
+  export type ErrorType = from.ErrorType | AccountConfig.toRpc.ErrorType
 }
 
 /**
@@ -525,9 +525,9 @@ async function selectApprovals_internal(
   const groups = new Map<string, ApprovalGroup>()
   for (const serialized of options.approvals) {
     const signature = SignatureEnvelope.from(serialized)
-    if (signature.type === 'keychain' || signature.type === 'multisig')
+    if (signature.type === 'keychain' || signature.type === 'configurable')
       throw new InvalidApprovalError({
-        reason: 'only primitive signatures can approve a multisig operation',
+        reason: 'only primitive signatures can approve an account operation',
       })
     const address = SignatureEnvelope.extractAddress({
       payload: options.hash,
@@ -578,7 +578,7 @@ async function selectApprovals_internal(
   )
   const selected: typeof ranked = []
   let weight = 0
-  for (const approval of ranked.slice(0, MultisigConfig.maxSignatures)) {
+  for (const approval of ranked.slice(0, AccountConfig.maxSignatures)) {
     if (weight >= Number(options.config.threshold)) break
     selected.push(approval)
     weight += approval.weight
@@ -654,7 +654,7 @@ function compareHex(a: Hex.Hex, b: Hex.Hex) {
  *
  * @internal
  */
-function assertBase(operation: Operation, config: MultisigConfig.Config): void {
+function assertBase(operation: Operation, config: AccountConfig.Config): void {
   if (!Address.validate(operation.account))
     throw new InvalidOperationError({ reason: 'account is invalid' })
   if (Hex.toBigInt(operation.account) === 0n)
@@ -676,7 +676,7 @@ function assertBase(operation: Operation, config: MultisigConfig.Config): void {
     })
   if (operation.weight > 0xff)
     throw new InvalidOperationError({ reason: 'weight exceeds u8 max' })
-  if (operation.signatureCount > MultisigConfig.maxSignatures)
+  if (operation.signatureCount > AccountConfig.maxSignatures)
     throw new InvalidOperationError({ reason: 'too many selected signatures' })
   if (!Array.isArray(operation.approvals))
     throw new InvalidOperationError({ reason: 'approvals must be an array' })
@@ -837,7 +837,7 @@ function assertTransaction(operation: TransactionOperation): void {
  */
 function assertKeyAuthorization(
   operation: KeyAuthorizationOperation,
-  config: MultisigConfig.Config,
+  config: AccountConfig.Config,
 ): void {
   const transactionFields = operation as KeyAuthorizationOperation & {
     expiresAt?: unknown
@@ -887,9 +887,10 @@ function assertKeyAuthorization(
       reason: 'pending key authorizations must be unsigned',
     })
   if (operation.status === 'success') {
-    if (signature?.type !== 'multisig')
+    if (signature?.type !== 'configurable')
       throw new InvalidOperationError({
-        reason: 'successful key authorizations require a multisig signature',
+        reason:
+          'successful key authorizations require a configurable account signature',
       })
     if (signature.account.toLowerCase() !== operation.account.toLowerCase())
       throw new InvalidOperationError({
@@ -926,10 +927,10 @@ function assertKeyAuthorization(
 function assertApproval(
   account: Address.Address,
   serialized: SignatureEnvelope.Serialized,
-  config: MultisigConfig.Config,
+  config: AccountConfig.Config,
 ): SignatureEnvelope.Primitive {
   const approval = SignatureEnvelope.deserialize(serialized)
-  if (approval.type === 'keychain' || approval.type === 'multisig')
+  if (approval.type === 'keychain' || approval.type === 'configurable')
     throw new InvalidOperationError({
       reason: 'only primitive owner approvals are allowed',
     })
@@ -937,7 +938,7 @@ function assertApproval(
     account,
     config,
     signatures: [approval],
-    type: 'multisig',
+    type: 'configurable',
   })
   if (
     SignatureEnvelope.serialize(approval).toLowerCase() !==
@@ -999,7 +1000,7 @@ function assertSelectedApprovals(
     retained.splice(index, 1)
   }
 
-  const digest = MultisigConfig.getSignPayload({
+  const digest = AccountConfig.getSignPayload({
     account: operation.account,
     config: operation.config,
     payload: KeyAuthorization_.getSignPayload(authorization),
@@ -1049,7 +1050,7 @@ function isWeightReachable(
  * @internal
  */
 function assertOperationHash(operation: Operation, payload: Hex.Hex): void {
-  const hash = MultisigConfig.getSignPayload({
+  const hash = AccountConfig.getSignPayload({
     account: operation.account,
     config: operation.config,
     payload,
@@ -1073,20 +1074,17 @@ function assertInteger(value: unknown, field: string): asserts value is number {
 }
 
 /**
- * Compares normalized multisig configurations.
+ * Compares normalized account configurations.
  *
  * @internal
  */
-function sameConfig(
-  a: MultisigConfig.Config,
-  b: MultisigConfig.Config,
-): boolean {
-  const configA = MultisigConfig.from(a)
-  const configB = MultisigConfig.from(b)
+function sameConfig(a: AccountConfig.Config, b: AccountConfig.Config): boolean {
+  const configA = AccountConfig.from(a)
+  const configB = AccountConfig.from(b)
   return (
     Hex.isEqual(
-      configA.salt ?? MultisigConfig.zeroSalt,
-      configB.salt ?? MultisigConfig.zeroSalt,
+      configA.salt ?? AccountConfig.zeroSalt,
+      configB.salt ?? AccountConfig.zeroSalt,
     ) &&
     configA.threshold === configB.threshold &&
     configA.version === configB.version &&
@@ -1101,18 +1099,18 @@ function sameConfig(
   )
 }
 
-/** Thrown when a multisig owner approval is invalid. */
+/** Thrown when an account operation owner approval is invalid. */
 export class InvalidApprovalError extends Errors.BaseError<Error | undefined> {
-  override readonly name = 'MultisigOperation.InvalidApprovalError'
+  override readonly name = 'AccountOperation.InvalidApprovalError'
 
   /**
-   * Creates an invalid multisig approval error.
+   * Creates an invalid operation approval error.
    *
    * @example
    * ```ts twoslash
-   * import { MultisigOperation } from 'ox/tempo'
+   * import { AccountOperation } from 'ox/tempo'
    *
-   * throw new MultisigOperation.InvalidApprovalError({
+   * throw new AccountOperation.InvalidApprovalError({
    *   reason: 'signature is from a non-owner'
    * })
    * ```
@@ -1122,8 +1120,8 @@ export class InvalidApprovalError extends Errors.BaseError<Error | undefined> {
   constructor(options: InvalidApprovalError.Options = {}) {
     super(
       options.reason
-        ? `Invalid multisig approval: ${options.reason}.`
-        : 'Invalid multisig approval.',
+        ? `Invalid operation approval: ${options.reason}.`
+        : 'Invalid operation approval.',
       { cause: options.cause as Error | undefined },
     )
   }
@@ -1139,18 +1137,18 @@ export declare namespace InvalidApprovalError {
   }
 }
 
-/** Thrown when a multisig operation is malformed or internally inconsistent. */
+/** Thrown when an account operation is malformed or internally inconsistent. */
 export class InvalidOperationError extends Errors.BaseError<Error | undefined> {
-  override readonly name = 'MultisigOperation.InvalidOperationError'
+  override readonly name = 'AccountOperation.InvalidOperationError'
 
   /**
-   * Creates an invalid multisig operation error.
+   * Creates an invalid account operation error.
    *
    * @example
    * ```ts twoslash
-   * import { MultisigOperation } from 'ox/tempo'
+   * import { AccountOperation } from 'ox/tempo'
    *
-   * throw new MultisigOperation.InvalidOperationError({
+   * throw new AccountOperation.InvalidOperationError({
    *   reason: 'hash does not match the operation payload'
    * })
    * ```
@@ -1160,8 +1158,8 @@ export class InvalidOperationError extends Errors.BaseError<Error | undefined> {
   constructor(options: InvalidOperationError.Options = {}) {
     super(
       options.reason
-        ? `Invalid multisig operation: ${options.reason}.`
-        : 'Invalid multisig operation.',
+        ? `Invalid account operation: ${options.reason}.`
+        : 'Invalid account operation.',
       { cause: options.cause as Error | undefined },
     )
   }

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

@@ -1,5 +1,5 @@
 import { expectTypeOf, test } from 'vp/test'
-import * as MultisigSimulation from './MultisigSimulation.js'
+import * as AccountSimulation from './AccountSimulation.js'
 
 const rpc = {
   approvals: [
@@ -11,23 +11,21 @@ const rpc = {
   ],
   config:
     '0xf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d694111111111111111111111111111111111111111101',
-} as const satisfies MultisigSimulation.Rpc
+} as const satisfies AccountSimulation.Rpc
 
 test('fromRpc returns a domain spec', () => {
-  const spec = MultisigSimulation.fromRpc(rpc)
+  const spec = AccountSimulation.fromRpc(rpc)
 
-  expectTypeOf(spec).toEqualTypeOf<MultisigSimulation.Spec>()
+  expectTypeOf(spec).toEqualTypeOf<AccountSimulation.Spec>()
   expectTypeOf(spec.config.version).toEqualTypeOf<bigint>()
 })
 
 test('RPC specs use encoded configurations', () => {
-  expectTypeOf<
-    MultisigSimulation.Rpc['config']
-  >().toEqualTypeOf<`0x${string}`>()
+  expectTypeOf<AccountSimulation.Rpc['config']>().toEqualTypeOf<`0x${string}`>()
 })
 
 test('toRpc returns an RPC spec', () => {
   expectTypeOf(
-    MultisigSimulation.toRpc(MultisigSimulation.fromRpc(rpc)),
-  ).toEqualTypeOf<MultisigSimulation.Rpc>()
+    AccountSimulation.toRpc(AccountSimulation.fromRpc(rpc)),
+  ).toEqualTypeOf<AccountSimulation.Rpc>()
 })