ox 0.14.44 → 0.14.46

package/core/internal/curves.ts

@@ -0,0 +1,22 @@
+/**
+ * Curve constants, inlined so that modules needing nothing but an order do not
+ * pull a curve implementation into the bundle.
+ *
+ * These are fixed by the curve specifications and are asserted against
+ * `@noble/curves` in `src/core/_test/curves.test.ts`.
+ *
+ * @internal
+ */
+
+/**
+ * Order of the secp256r1 (P-256) curve.
+ *
+ * @see https://www.secg.org/sec2-v2.pdf
+ * @internal
+ */
+export const p256N =
+  0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n
+
+/** Order of the secp256k1 curve. @internal */
+export const secp256k1N =
+  0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n

package/core/internal/quantity.ts

@@ -0,0 +1,16 @@
+import * as Hex from '../Hex.js'
+
+/**
+ * Converts a "numberish" value (`Hex.Hex | bigint | number`) to an RPC quantity
+ * (`Hex.Hex`). Hex values are passed through unchanged; numbers and bigints are
+ * encoded via {@link ox#Hex.(fromNumber:function)}.
+ *
+ * @internal
+ */
+export function fromNumberish(
+  value: Hex.Hex | bigint | number,
+  options?: Hex.fromNumber.Options,
+): Hex.Hex {
+  if (typeof value === 'string') return value
+  return Hex.fromNumber(value, options)
+}

package/erc4337/UserOperationReceipt.ts

@@ -51,12 +51,7 @@ export type Rpc<
   entryPointVersion,
   Hex.Hex,
   Hex.Hex,
-  TransactionReceipt.TransactionReceipt<
-    TransactionReceipt.RpcStatus,
-    TransactionReceipt.RpcType,
-    Hex.Hex,
-    Hex.Hex
-  >
+  TransactionReceipt.Rpc
 >
 
 /**

package/index.ts

@@ -1547,6 +1547,60 @@ export * as Fee from './core/Fee.js'
  * @category Execution Spec
  */
 export * as Filter from './core/Filter.js'
+/**
+ * Utilities for constructing, validating, and encoding [EIP-8141](https://eips.ethereum.org/EIPS/eip-8141) call frames.
+ *
+ * A {@link ox#Frame.Frame} describes a call with an execution mode, approval flags,
+ * and separate execution and state gas limits.
+ *
+ * @example
+ * ### Creating Frames
+ *
+ * Use {@link ox#Frame.(from:function)} to construct a frame with named mode and flags.
+ *
+ * ```ts twoslash
+ * import { Frame } from 'ox'
+ *
+ * const frame = Frame.from({
+ *   flags: 'approveExecutionAndPayment',
+ *   gas: 50_000n,
+ *   mode: 'verify'
+ * })
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as Frame from './core/Frame.js'
+/**
+ * Utilities for converting EIP-8141 frame receipts between RPC and decoded forms.
+ *
+ * Frame receipts include execution gas, state gas, logs, and execution status.
+ *
+ * @category Execution Spec
+ */
+export * as FrameReceipt from './core/FrameReceipt.js'
+/**
+ * Utilities for constructing, validating, and encoding [EIP-8141](https://eips.ethereum.org/EIPS/eip-8141) signature entries.
+ *
+ * Supports {@link ox#FrameSignature.Arbitrary}, {@link ox#FrameSignature.Secp256k1},
+ * and {@link ox#FrameSignature.P256} entries. An empty payload selects the canonical
+ * transaction signing hash.
+ *
+ * @example
+ * ### Creating Signature Entries
+ *
+ * Use {@link ox#FrameSignature.(from:function)} to wrap arbitrary witness bytes.
+ *
+ * ```ts twoslash
+ * import { FrameSignature } from 'ox'
+ *
+ * const entry = FrameSignature.from('0xaabb')
+ * // @log: { payload: '0x', scheme: 'arbitrary', signature: '0xaabb' }
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as FrameSignature from './core/FrameSignature.js'
 /**
  * Utility functions for hashing (keccak256, sha256, etc).
  *
@@ -3270,6 +3324,25 @@ export * as TxEnvelopeEip4844 from './core/TxEnvelopeEip4844.js'
  * @category Transaction Envelopes
  */
 export * as TxEnvelopeEip7702 from './core/TxEnvelopeEip7702.js'
+/**
+ * Utilities for constructing, signing, and encoding EIP-8141 frame transactions.
+ *
+ * @example
+ * ### Basic Usage
+ *
+ * ```ts twoslash
+ * import { TxEnvelopeEip8141 } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip8141.from({
+ *   chainId: 1,
+ *   frames: [{ gas: 50_000n, mode: 'sender' }],
+ *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
+ * })
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeEip8141 from './core/TxEnvelopeEip8141.js'
 /**
  * Utility functions for working
  * with **Legacy Transaction Envelopes**.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.44",
+  "version": "0.14.46",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -222,6 +222,21 @@
       "import": "./_esm/core/Filter.js",
       "default": "./_cjs/core/Filter.js"
     },
+    "./Frame": {
+      "types": "./_types/core/Frame.d.ts",
+      "import": "./_esm/core/Frame.js",
+      "default": "./_cjs/core/Frame.js"
+    },
+    "./FrameReceipt": {
+      "types": "./_types/core/FrameReceipt.d.ts",
+      "import": "./_esm/core/FrameReceipt.js",
+      "default": "./_cjs/core/FrameReceipt.js"
+    },
+    "./FrameSignature": {
+      "types": "./_types/core/FrameSignature.d.ts",
+      "import": "./_esm/core/FrameSignature.js",
+      "default": "./_cjs/core/FrameSignature.js"
+    },
     "./Hash": {
       "types": "./_types/core/Hash.d.ts",
       "import": "./_esm/core/Hash.js",
@@ -372,6 +387,11 @@
       "import": "./_esm/core/TxEnvelopeEip7702.js",
       "default": "./_cjs/core/TxEnvelopeEip7702.js"
     },
+    "./TxEnvelopeEip8141": {
+      "types": "./_types/core/TxEnvelopeEip8141.d.ts",
+      "import": "./_esm/core/TxEnvelopeEip8141.js",
+      "default": "./_cjs/core/TxEnvelopeEip8141.js"
+    },
     "./TxEnvelopeLegacy": {
       "types": "./_types/core/TxEnvelopeLegacy.d.ts",
       "import": "./_esm/core/TxEnvelopeLegacy.js",

package/tempo/AuthorizationTempo.test.ts

@@ -326,7 +326,8 @@ describe('fromRpc', () => {
         type: 'p256',
       },
     })
-    if (typeof result.signature === 'string') throw new Error('unreachable')
+    if (typeof result.signature === 'string')
+      throw new Error('Expected structured primitive signature')
     expect(result.signature.type).toBe('p256')
     expect(result.signature).toHaveProperty('prehash', true)
     expect(result.signature).toHaveProperty('publicKey')
@@ -349,7 +350,8 @@ describe('fromRpc', () => {
           '0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d976305000000007b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22222c226f726967696e223a2268747470733a2f2f6578616d706c652e636f6d222c2263726f73734f726967696e223a66616c73657d',
       },
     })
-    if (typeof result.signature === 'string') throw new Error('unreachable')
+    if (typeof result.signature === 'string')
+      throw new Error('Expected structured primitive signature')
     expect(result.signature.type).toBe('webAuthn')
     expect(result.signature).toHaveProperty('metadata')
     expect(result.signature).toHaveProperty('publicKey')
@@ -951,7 +953,8 @@ describe('toRpc', () => {
         type: 'p256',
       },
     })
-    if (typeof result.signature === 'string') throw new Error('unreachable')
+    if (typeof result.signature === 'string')
+      throw new Error('Expected structured primitive signature')
     expect(result.signature.type).toBe('p256')
   })
 
@@ -973,7 +976,8 @@ describe('toRpc', () => {
         type: 'webAuthn',
       },
     })
-    if (typeof result.signature === 'string') throw new Error('unreachable')
+    if (typeof result.signature === 'string')
+      throw new Error('Expected structured primitive signature')
     expect(result.signature.type).toBe('webAuthn')
   })
 })

package/tempo/KeyAuthorization.test-d.ts

@@ -1,7 +1,7 @@
 import { expectTypeOf, test } from 'vitest'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigConfig from './MultisigConfig.js'
 import type * as SignatureEnvelope from './SignatureEnvelope.js'
+import * as TempoAddress from './TempoAddress.js'
 
 const authorization = {
   address: '0x1111111111111111111111111111111111111111',
@@ -20,26 +20,18 @@ const signature = {
 
 const multisig = {
   account: '0x2222222222222222222222222222222222222222',
-  config: MultisigConfig.from({
+  config: {
+    salt: `0x${'00'.repeat(32)}`,
+    version: 0n,
+    threshold: 1,
     owners: [
-      {
-        owner: '0x1111111111111111111111111111111111111111',
-        weight: 1,
-      },
+      { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
     ],
-    threshold: 1,
-    version: 1n,
-  }),
+  },
   signatures: [signature],
   type: 'multisig',
 } as const satisfies SignatureEnvelope.Multisig
 
-const keychain = {
-  inner: signature,
-  type: 'keychain',
-  userAddress: authorization.address,
-} as const satisfies SignatureEnvelope.Keychain
-
 test('accepts primitive signatures', () => {
   const signed = KeyAuthorization.from(authorization, { signature })
 
@@ -48,27 +40,56 @@ test('accepts primitive signatures', () => {
   >()
 })
 
-test('accepts multisig signatures', () => {
-  const signed = KeyAuthorization.from(authorization, { signature: multisig })
-
-  expectTypeOf(signed.signature).toMatchTypeOf<
-    KeyAuthorization.Signed['signature']
-  >()
-
-  const multisigRpc = '0xf8' as const satisfies SignatureEnvelope.MultisigRpc
-
-  const rpc: KeyAuthorization.Rpc = {
-    chainId: '0x1',
-    expiry: null,
-    keyId: authorization.address,
-    keyType: authorization.type,
-    signature: multisigRpc,
-  }
+test('accepts multisig signatures and account-bound grants', () => {
+  const signed = KeyAuthorization.from(
+    { ...authorization, account: multisig.account, type: 'multisig' },
+    { signature: multisig },
+  )
+  expectTypeOf(signed).toMatchTypeOf<KeyAuthorization.Signed>()
+  expectTypeOf(
+    KeyAuthorization.toRpc(signed),
+  ).toMatchTypeOf<KeyAuthorization.Rpc>()
+})
 
-  expectTypeOf(rpc).toEqualTypeOf<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}`>()
+  expectTypeOf<
+    Omit<Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>, 'account'>
+  >().not.toExtend<KeyAuthorization.Rpc>()
+  expectTypeOf<{
+    address: `0x${string}`
+    chainId: bigint
+    type: 'multisig'
+  }>().not.toExtend<KeyAuthorization.Input>()
+  expectTypeOf<{
+    account: undefined
+    address: `0x${string}`
+    chainId: bigint
+    type: 'multisig'
+  }>().not.toExtend<KeyAuthorization.Input>()
+  expectTypeOf<{
+    account: null
+    chainId: '0x1'
+    expiry: null
+    keyId: `0x${string}`
+    keyType: 'multisig'
+    signature: KeyAuthorization.SignatureRpc
+  }>().not.toExtend<KeyAuthorization.Rpc>()
+  expectTypeOf<
+    Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>['account']
+  >().toEqualTypeOf<`0x${string}`>()
 })
 
 test('rejects keychain signatures', () => {
+  const keychain = {
+    inner: signature,
+    type: 'keychain',
+    userAddress: authorization.address,
+  } as const
   KeyAuthorization.from(authorization, {
     // @ts-expect-error Key authorizations do not accept keychain signatures.
     signature: keychain,
@@ -94,5 +115,19 @@ test('rejects keychain signatures', () => {
     signature: keychainRpc,
   }
 
-  expectTypeOf(rpc).toEqualTypeOf<KeyAuthorization.Rpc>()
+  expectTypeOf(rpc).toMatchTypeOf<KeyAuthorization.Rpc>()
+})
+
+test('resolves Tempo address bindings for multisig grants', () => {
+  const signed = KeyAuthorization.from(
+    {
+      account: TempoAddress.format(authorization.address),
+      address: TempoAddress.format(authorization.address),
+      chainId: 1n,
+      type: 'multisig',
+    },
+    { signature },
+  )
+  expectTypeOf(signed.account).toMatchTypeOf<`0x${string}`>()
+  expectTypeOf(signed.address).toMatchTypeOf<`0x${string}`>()
 })

package/tempo/KeyAuthorization.test.ts

@@ -78,7 +78,89 @@ const signature_keychain = {
   userAddress: address,
 } as const satisfies SignatureEnvelope.Keychain
 
+describe('multisig account binding', () => {
+  test('resolves Tempo account bindings before encoding', () => {
+    const signed = KeyAuthorization.from(
+      { account: `tempox${address}`, address, chainId: 1n, type: 'multisig' },
+      { signature: signature_secp256k1 },
+    )
+    expect(signed.account).toMatchInlineSnapshot(
+      `"0xBE95c3f554e9Fc85ec51bE69a3D807A0D55BCF2C"`,
+    )
+    expect(KeyAuthorization.toRpc(signed).account).toMatchInlineSnapshot(
+      `"0xBE95c3f554e9Fc85ec51bE69a3D807A0D55BCF2C"`,
+    )
+    expect(
+      KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)).account,
+    ).toMatchInlineSnapshot(`"0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c"`)
+  })
+
+  test('rejects unbound grants before signing or encoding', () => {
+    const authorization = { address, chainId: 1n, type: 'multisig' } as const
+    const signed = {
+      ...authorization,
+      signature: SignatureEnvelope.from(signature_secp256k1),
+    }
+    for (const encode of [
+      // @ts-expect-error Deliberately unbound multisig grant.
+      () => KeyAuthorization.from(authorization),
+      // @ts-expect-error Deliberately unbound multisig grant.
+      () => KeyAuthorization.toTuple(authorization),
+      // @ts-expect-error Deliberately unbound multisig grant.
+      () => KeyAuthorization.getSignPayload(authorization),
+      // @ts-expect-error Deliberately unbound multisig grant.
+      () => KeyAuthorization.serialize(authorization),
+      // @ts-expect-error Deliberately unbound multisig grant.
+      () => KeyAuthorization.toRpc(signed),
+    ])
+      expect(encode).toThrowErrorMatchingInlineSnapshot(
+        `[KeyAuthorization.MissingAccountError: Multisig 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' },
+      { signature: signature_secp256k1 },
+    )
+    const rpc = KeyAuthorization.toRpc(signed)
+    for (const account of [undefined, null]) {
+      // @ts-expect-error Deliberately unbound multisig grant.
+      expect(() => KeyAuthorization.fromRpc({ ...rpc, account })).toThrowError(
+        KeyAuthorization.MissingAccountError,
+      )
+    }
+    expect(() =>
+      KeyAuthorization.fromTuple([['0x01', '0x03', address]]),
+    ).toThrowError(KeyAuthorization.MissingAccountError)
+    expect(KeyAuthorization.fromRpc(rpc).account).toBe(address)
+    expect(
+      KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)).account,
+    ).toBe(address)
+  })
+})
+
 describe('from', () => {
+  test('accepts multisig grants and delegates', () => {
+    const signed = KeyAuthorization.from(
+      {
+        address,
+        chainId: 1n,
+        type: 'multisig',
+        account: signature_multisig.account,
+      },
+      { signature: signature_multisig },
+    )
+    expect(
+      KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
+    ).toEqual(signed)
+    expect(KeyAuthorization.fromRpc(KeyAuthorization.toRpc(signed))).toEqual(
+      signed,
+    )
+  })
+})
+
+describe('fromRpc', () => {
   test('default', () => {
     const authorization = KeyAuthorization.from({
       address,
@@ -1154,7 +1236,6 @@ describe('deserialize', () => {
         "account": "0xc4a590afa7337e5cd5eb3aa60cacf91c5400044b",
         "address": "0x1eff47bc3a10a45d4b230b5d10e37751fe6aa718",
         "chainId": 4217n,
-        "isAdmin": false,
         "signature": {
           "account": "0xc4a590afa7337e5cd5eb3aa60cacf91c5400044b",
           "config": {
@@ -2589,11 +2670,11 @@ describe('admin keys (TIP-1049)', () => {
     expect((authTuple as unknown as unknown[]).length).toBe(3)
   })
 
-  test('fromTuple: drops orphan isAdmin without account', () => {
+  test('fromTuple: preserves isAdmin without account', () => {
     const restored = KeyAuthorization.fromTuple([
       ['0x01', '0x', address, '0x', [], [], '0x', '0x01'],
     ])
-    expect(restored.isAdmin).toBeUndefined()
+    expect(restored.isAdmin).toBe(true)
     expect(restored.account).toBeUndefined()
   })
 
@@ -2601,7 +2682,7 @@ describe('admin keys (TIP-1049)', () => {
     const restored = KeyAuthorization.fromTuple([
       ['0x01', '0x', address, '0x', [], [], '0x', '0x', account],
     ])
-    expect(restored.isAdmin).toBe(false)
+    expect(restored.isAdmin).toBeUndefined()
     expect(restored.account).toBe(account)
   })
 
@@ -2647,7 +2728,7 @@ describe('admin keys (TIP-1049)', () => {
     })
     const serialized = KeyAuthorization.serialize(authorization)
     const restored = KeyAuthorization.deserialize(serialized)
-    expect(restored.isAdmin).toBe(false)
+    expect(restored.isAdmin).toBeUndefined()
     expect(restored.account).toBe(account)
   })
 
@@ -2670,14 +2751,14 @@ describe('admin keys (TIP-1049)', () => {
     expect(restored.account).toBe(account)
   })
 
-  test('fromRpc: drops orphan isAdmin without account', () => {
+  test('fromRpc: preserves isAdmin without account', () => {
     const authorization = KeyAuthorization.from(
       { address, chainId: 1n, type: 'secp256k1' },
       { signature: SignatureEnvelope.from(signature_secp256k1) },
     )
     const rpc = KeyAuthorization.toRpc(authorization)
     const restored = KeyAuthorization.fromRpc({ ...rpc, isAdmin: true })
-    expect(restored.isAdmin).toBeUndefined()
+    expect(restored.isAdmin).toBe(true)
     expect(restored.account).toBeUndefined()
   })
 
@@ -2688,7 +2769,7 @@ describe('admin keys (TIP-1049)', () => {
     )
     const rpc = KeyAuthorization.toRpc(authorization)
     const restored = KeyAuthorization.fromRpc({ ...rpc, account })
-    expect(restored.isAdmin).toBe(false)
+    expect(restored.isAdmin).toBeUndefined()
     expect(restored.account).toBe(account)
   })