ox 1.8.5 → 1.8.7

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,13 +39,22 @@ 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(
     KeyAuthorization.toRpc(signed),
   ).toMatchTypeOf<KeyAuthorization.Rpc>()
 })
+
+test('Tuple: skipped limits slot may be the RLP null placeholder', () => {
+  type Authorization = KeyAuthorization.Tuple[0]
+  type Limits = Extract<Authorization, { length: 5 }>[4]
+  expectTypeOf<'0x'>().toMatchTypeOf<Limits>()
+  expectTypeOf<
+    readonly [token: `0x${string}`, limit: `0x${string}`][]
+  >().toMatchTypeOf<Limits>()
+})