ox 0.14.55 → 0.14.57

package/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 'vitest'
 
 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,43 +49,43 @@ 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(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: noncanonical config encoding.]`,
+      `[AccountSimulation.InvalidSimulationError: Invalid account simulation: noncanonical config encoding.]`,
     )
   })
 
   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,17 +105,37 @@ 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: round-trips the grant signer', () => {
+    const signer = '0x2222222222222222222222222222222222222222'
+    const spec = AccountSimulation.fromRpc({ ...rpc, signer })
+    expect(spec.signer).toBe(signer)
+    expect(AccountSimulation.toRpc(spec).signer).toBe(signer)
+    expect(
+      'signer' in AccountSimulation.toRpc(AccountSimulation.fromRpc(rpc)),
+    ).toBe(false)
+  })
+
+  test('error: rejects an invalid grant signer', () => {
+    expect(() =>
+      AccountSimulation.fromRpc({ ...rpc, signer: '0x1234' }),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [Address.InvalidAddressError: Address "0x1234" is invalid.
+
+      Details: Address is not a 20 byte (40 hexadecimal character) value.]
+    `)
+  })
+
   test('behavior: encodes configurations and shims long key data', () => {
     expect(
-      MultisigSimulation.toRpc(MultisigSimulation.fromRpc(rpc)),
+      AccountSimulation.toRpc(AccountSimulation.fromRpc(rpc)),
     ).toMatchInlineSnapshot(`
         {
           "approvals": [
@@ -131,12 +151,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,14 +167,38 @@ describe('toRpc', () => {
     `)
   })
 
+  test('behavior: shims key data that is not a valid length hint', () => {
+    const keyData = (keyData: `0x${string}`) =>
+      AccountSimulation.toRpc(
+        AccountSimulation.fromRpc({
+          ...rpc,
+          approvals: [{ ...rpc.approvals[0], keyData }],
+        }),
+      ).approvals[0]?.keyData
+
+    expect({
+      empty: keyData('0x'),
+      four: keyData('0x01020304'),
+      one: keyData('0x01'),
+      three: keyData('0x010203'),
+    }).toMatchInlineSnapshot(`
+      {
+        "empty": "0x0000",
+        "four": "0x01020304",
+        "one": "0x01",
+        "three": "0x0003",
+      }
+    `)
+  })
+
   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',
@@ -162,7 +206,7 @@ describe('toRpc', () => {
             },
           ],
           threshold: 1,
-          version: MultisigConfig.maxVersion,
+          version: AccountConfig.maxVersion,
         }),
       }).config,
     ).toMatchInlineSnapshot(
@@ -171,25 +215,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/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,70 +22,81 @@ 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[]
   /** Canonical RLP-encoded applicable configuration. */
   config: Hex.Hex
+  /** Account that signs the modeled key authorization. Omitted for a direct signature. */
+  signer?: Address.Address | undefined
 }>
 
-/** 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
+  /** Account that signs the modeled key authorization. Omitted for a direct signature. */
+  signer?: Address.Address | undefined
 }>
 
 /**
- * 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
+  const { approvals, config, signer } = spec
   assertApprovals(approvals)
-  return { approvals, config: deserializeConfig(config) }
+  if (signer !== undefined) Address.assert(signer)
+  return {
+    approvals,
+    config: deserializeConfig(config),
+    ...(signer !== undefined ? { signer } : {}),
+  }
 }
 
 export declare namespace fromRpc {
   /** Error type for `fromRpc`. */
   export type ErrorType =
+    | Address.assert.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
+  const { approvals, config, signer } = spec
   assertApprovals(approvals)
+  if (signer !== undefined) Address.assert(signer)
   return {
     approvals: approvals.map(({ keyData, keyType, owner }) => ({
       ...(keyData !== undefined ? { keyData: shimKeyData(keyData) } : {}),
@@ -93,15 +104,17 @@ export function toRpc(spec: Spec): Rpc {
       owner,
     })),
     config: serializeConfig(config),
+    ...(signer !== undefined ? { signer } : {}),
   }
 }
 
 export declare namespace toRpc {
   /** Error type for `toRpc`. */
   export type ErrorType =
+    | Address.assert.ErrorType
     | Hex.fromNumber.ErrorType
     | InvalidSimulationError
-    | MultisigConfig.assert.ErrorType
+    | AccountConfig.assert.ErrorType
     | Rlp.fromHex.ErrorType
     | Errors.GlobalErrorType
 }
@@ -120,14 +133,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,35 +164,34 @@ 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))
 }
 
 /**
- * Shims long key data into the length hint accepted by Tempo's gas estimator.
+ * Shims key data into the 1-, 2-, or 4-byte length hint accepted by Tempo's
+ * gas estimator. Other sizes are replaced by a 2-byte hint of their length.
  * @internal
  */
 function shimKeyData(data: Hex.Hex): Hex.Hex {
   const size = Hex.size(data)
-  if (size <= 4) return data
+  if (size === 1 || size === 2 || size === 4) return data
   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/tempo/KeyAuthorization.test-d.ts

@@ -18,7 +18,7 @@ const signature = {
   type: 'secp256k1',
 } as const satisfies SignatureEnvelope.Secp256k1
 
-const multisig = {
+const configurable = {
   account: '0x2222222222222222222222222222222222222222',
   config: {
     salt: `0x${'00'.repeat(32)}`,
@@ -29,8 +29,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 })
@@ -40,10 +40,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(
@@ -51,37 +51,27 @@ test('accepts multisig signatures and account-bound grants', () => {
   ).toMatchTypeOf<KeyAuthorization.Rpc>()
 })
 
-test('requires an account for multisig grants', () => {
-  type Multisig = Extract<KeyAuthorization.Input, { type: 'multisig' }>
-  expectTypeOf<Multisig['account']>().toEqualTypeOf<TempoAddress.Address>()
-  expectTypeOf<
-    Extract<KeyAuthorization.Signed, { type: 'multisig' }>['account']
-  >().toEqualTypeOf<`0x${string}`>()
+test('allows configurable grants without an account', () => {
+  type Configurable = Extract<KeyAuthorization.Input, { type: 'configurable' }>
+  expectTypeOf<Configurable['account']>().toEqualTypeOf<
+    TempoAddress.Address | undefined
+  >()
   expectTypeOf<
-    Omit<Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>, 'account'>
-  >().not.toExtend<KeyAuthorization.Rpc>()
-  expectTypeOf<{
-    address: `0x${string}`
-    chainId: bigint
-    type: 'multisig'
-  }>().not.toExtend<KeyAuthorization.Input>()
+    Extract<KeyAuthorization.Signed, { type: 'configurable' }>['account']
+  >().toEqualTypeOf<`0x${string}` | undefined>()
   expectTypeOf<{
-    account: undefined
     address: `0x${string}`
     chainId: bigint
-    type: 'multisig'
-  }>().not.toExtend<KeyAuthorization.Input>()
+    type: 'configurable'
+  }>().toExtend<KeyAuthorization.Input>()
   expectTypeOf<{
     account: null
     chainId: '0x1'
     expiry: null
     keyId: `0x${string}`
-    keyType: 'multisig'
+    keyType: 'configurableAccount'
     signature: KeyAuthorization.SignatureRpc
-  }>().not.toExtend<KeyAuthorization.Rpc>()
-  expectTypeOf<
-    Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>['account']
-  >().toEqualTypeOf<`0x${string}`>()
+  }>().toExtend<KeyAuthorization.Rpc>()
 })
 
 test('rejects keychain signatures', () => {
@@ -118,13 +108,13 @@ test('rejects keychain signatures', () => {
   expectTypeOf(rpc).toMatchTypeOf<KeyAuthorization.Rpc>()
 })
 
-test('resolves Tempo address bindings for multisig grants', () => {
+test('resolves Tempo address bindings for configurable grants', () => {
   const signed = KeyAuthorization.from(
     {
       account: TempoAddress.format(authorization.address),
       address: TempoAddress.format(authorization.address),
       chainId: 1n,
-      type: 'multisig',
+      type: 'configurable',
     },
     { signature },
   )