ox 0.8.9 → 0.9.1

package/erc6492/{WrappedSignature.ts → SignatureErc6492.ts}

@@ -3,18 +3,21 @@ import * as AbiParameters from '../core/AbiParameters.js'
 import type * as Address from '../core/Address.js'
 import * as Errors from '../core/Errors.js'
 import * as Hex from '../core/Hex.js'
-import * as Signature from '../core/Signature.js'
+import type * as Signature from '../core/Signature.js'
 
-/** ERC-6492 Wrapped Signature. */
-export type WrappedSignature = {
+/** Unwrapped ERC-6492 signature. */
+export type Unwrapped = {
   /** Calldata to pass to the target address for counterfactual verification. */
   data: Hex.Hex
   /** The original signature. */
-  signature: Signature.Signature
+  signature: Hex.Hex
   /** The target address to use for counterfactual verification. */
   to: Address.Address
 }
 
+/** Wrapped ERC-6492 signature. */
+export type Wrapped = Hex.Hex
+
 /**
  * Magic bytes used to identify ERC-6492 wrapped signatures.
  */
@@ -82,15 +85,15 @@ export const universalSignatureValidatorAbi = [
  *
  * @example
  * ```ts twoslash
- * import { WrappedSignature } from 'ox/erc6492'
+ * import { SignatureErc6492 } from 'ox/erc6492'
  *
- * WrappedSignature.assert('0xdeadbeef')
+ * SignatureErc6492.assert('0xdeadbeef')
  * // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-6492 wrapped signature.
  * ```
  *
  * @param wrapped - The wrapped signature to assert.
  */
-export function assert(wrapped: Hex.Hex) {
+export function assert(wrapped: Wrapped) {
   if (Hex.slice(wrapped, -32) !== magicBytes)
     throw new InvalidWrappedSignatureError(wrapped)
 }
@@ -109,7 +112,7 @@ export declare namespace assert {
  * ```ts twoslash
  * // @noErrors
  * import { Secp256k1 } from 'ox'
- * import { WrappedSignature } from 'ox/erc6492' // [!code focus]
+ * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
  *
  * const signature = Secp256k1.sign({
  *   payload: '0x...',
@@ -117,11 +120,11 @@ export declare namespace assert {
  * })
  *
  * // Instantiate from serialized format. // [!code focus]
- * const wrapped = WrappedSignature.from('0x...') // [!code focus]
+ * const wrapped = SignatureErc6492.from('0x...') // [!code focus]
  * // @log: { data: '0x...', signature: { ... }, to: '0x...', } // [!code focus]
  *
  * // Instantiate from constituent parts. // [!code focus]
- * const wrapped = WrappedSignature.from({ // [!code focus]
+ * const wrapped = SignatureErc6492.from({ // [!code focus]
  *   data: '0x...', // [!code focus]
  *   signature, // [!code focus]
  *   to: '0x...', // [!code focus]
@@ -132,13 +135,13 @@ export declare namespace assert {
  * @param wrapped - Wrapped signature to parse.
  * @returns Wrapped signature.
  */
-export function from(wrapped: WrappedSignature | Hex.Hex): WrappedSignature {
-  if (typeof wrapped === 'string') return fromHex(wrapped)
+export function from(wrapped: Unwrapped | Wrapped): Unwrapped {
+  if (typeof wrapped === 'string') return unwrap(wrapped)
   return wrapped
 }
 
 export declare namespace from {
-  type ReturnType = WrappedSignature
+  type ReturnType = Unwrapped
 
   type ErrorType =
     | AbiParameters.from.ErrorType
@@ -152,28 +155,26 @@ export declare namespace from {
  *
  * @example
  * ```ts twoslash
- * import { WrappedSignature } from 'ox/erc6492'
+ * import { SignatureErc6492 } from 'ox/erc6492'
  *
- * const { data, signature, to } = WrappedSignature.fromHex('0x...')
+ * const { data, signature, to } = SignatureErc6492.unwrap('0x...')
  * ```
  *
  * @param wrapped - Wrapped signature to parse.
  * @returns Wrapped signature.
  */
-export function fromHex(wrapped: Hex.Hex): WrappedSignature {
+export function unwrap(wrapped: Wrapped): Unwrapped {
   assert(wrapped)
 
-  const [to, data, signature_hex] = AbiParameters.decode(
+  const [to, data, signature] = AbiParameters.decode(
     AbiParameters.from('address, bytes, bytes'),
     wrapped,
   )
 
-  const signature = Signature.fromHex(signature_hex)
-
   return { data, signature, to }
 }
 
-export declare namespace fromHex {
+export declare namespace unwrap {
   type ErrorType =
     | AbiParameters.from.ErrorType
     | AbiParameters.decode.ErrorType
@@ -187,14 +188,14 @@ export declare namespace fromHex {
  * @example
  * ```ts twoslash
  * import { Secp256k1 } from 'ox'
- * import { WrappedSignature } from 'ox/erc6492' // [!code focus]
+ * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
  *
  * const signature = Secp256k1.sign({
  *   payload: '0x...',
  *   privateKey: '0x...',
  * })
  *
- * const wrapped = WrappedSignature.toHex({ // [!code focus]
+ * const wrapped = SignatureErc6492.wrap({ // [!code focus]
  *   data: '0xdeadbeef', // [!code focus]
  *   signature, // [!code focus]
  *   to: '0x00000000219ab540356cBB839Cbe05303d7705Fa', // [!code focus]
@@ -204,20 +205,20 @@ export declare namespace fromHex {
  * @param value - Wrapped signature to serialize.
  * @returns Serialized wrapped signature.
  */
-export function toHex(value: WrappedSignature): Hex.Hex {
+export function wrap(value: Unwrapped): Wrapped {
   const { data, signature, to } = value
 
   return Hex.concat(
     AbiParameters.encode(AbiParameters.from('address, bytes, bytes'), [
       to,
       data,
-      Signature.toHex(signature),
+      signature,
     ]),
     magicBytes,
   )
 }
 
-export declare namespace toHex {
+export declare namespace wrap {
   type ErrorType =
     | AbiParameters.encode.ErrorType
     | Hex.concat.ErrorType
@@ -230,16 +231,16 @@ export declare namespace toHex {
  *
  * @example
  * ```ts twoslash
- * import { WrappedSignature } from 'ox/erc6492'
+ * import { SignatureErc6492 } from 'ox/erc6492'
  *
- * const valid = WrappedSignature.validate('0xdeadbeef')
+ * const valid = SignatureErc6492.validate('0xdeadbeef')
  * // @log: false
  * ```
  *
  * @param wrapped - The wrapped signature to validate.
  * @returns `true` if the wrapped signature is valid, `false` otherwise.
  */
-export function validate(wrapped: Hex.Hex): boolean {
+export function validate(wrapped: Wrapped): boolean {
   try {
     assert(wrapped)
     return true
@@ -254,9 +255,9 @@ export declare namespace validate {
 
 /** Thrown when the ERC-6492 wrapped signature is invalid. */
 export class InvalidWrappedSignatureError extends Errors.BaseError {
-  override readonly name = 'WrappedSignature.InvalidWrappedSignatureError'
+  override readonly name = 'SignatureErc6492.InvalidWrappedSignatureError'
 
-  constructor(wrapped: Hex.Hex) {
+  constructor(wrapped: Wrapped) {
     super(`Value \`${wrapped}\` is an invalid ERC-6492 wrapped signature.`)
   }
 }

package/erc6492/index.ts

@@ -8,14 +8,14 @@ export type {}
  * @example
  * ```ts twoslash
  * import { Secp256k1, PersonalMessage } from 'ox'
- * import { WrappedSignature } from 'ox/erc6492' // [!code focus]
+ * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
  *
  * const signature = Secp256k1.sign({
  *   payload: PersonalMessage.getSignPayload('0xdeadbeef'),
  *   privateKey: '0x...',
  * })
  *
- * const wrapped = WrappedSignature.toHex({ // [!code focus]
+ * const wrapped = SignatureErc6492.wrap({ // [!code focus]
  *   data: '0xcafebabe', // [!code focus]
  *   signature, // [!code focus]
  *   to: '0xcafebabecafebabecafebabecafebabecafebabe', // [!code focus]
@@ -25,4 +25,4 @@ export type {}
  *
  * @category ERC-6492
  */
-export * as WrappedSignature from './WrappedSignature.js'
+export * as SignatureErc6492 from './SignatureErc6492.js'

package/erc8010/SignatureErc8010/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/erc8010/SignatureErc8010.d.ts",
+  "main": "../../_cjs/erc8010/SignatureErc8010.js",
+  "module": "../../_esm/erc8010/SignatureErc8010.js"
+}

package/erc8010/SignatureErc8010.ts

@@ -0,0 +1,227 @@
+import * as AbiParameters from '../core/AbiParameters.js'
+import * as Authorization from '../core/Authorization.js'
+import * as Errors from '../core/Errors.js'
+import * as Hex from '../core/Hex.js'
+import * as Signature from '../core/Signature.js'
+
+/** Unwrapped ERC-8010 signature. */
+export type Unwrapped = {
+  /** Authorization signed by the delegatee. */
+  authorization: Authorization.Authorization<true>
+  /** Data to initialize the delegation. */
+  data?: Hex.Hex | undefined
+  /** The original signature. */
+  signature: Hex.Hex
+}
+
+/** Wrapped ERC-8010 signature. */
+export type Wrapped = Hex.Hex
+
+/**
+ * Magic bytes used to identify ERC-8010 wrapped signatures.
+ */
+export const magicBytes =
+  '0x8010801080108010801080108010801080108010801080108010801080108010' as const
+
+/**
+ * Asserts that the wrapped signature is valid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureErc8010 } from 'ox/erc8010'
+ *
+ * SignatureErc8010.assert('0xdeadbeef')
+ * // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-8010 wrapped signature.
+ * ```
+ *
+ * @param value - The value to assert.
+ */
+export function assert(value: Unwrapped | Wrapped) {
+  if (typeof value === 'string') {
+    if (Hex.slice(value, -32) !== magicBytes)
+      throw new InvalidWrappedSignatureError(value)
+  } else Signature.assert(value.authorization)
+}
+
+export declare namespace assert {
+  type ErrorType =
+    | InvalidWrappedSignatureError
+    | Hex.slice.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Parses an [ERC-8010 wrapped signature](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md) into its constituent parts.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1 } from 'ox'
+ * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: '0x...',
+ *   privateKey: '0x...',
+ * })
+ *
+ * // Instantiate from serialized format. // [!code focus]
+ * const wrapped = SignatureErc8010.from('0x...') // [!code focus]
+ * // @log: { authorization: { ... }, data: '0x...', signature: { ... } } // [!code focus]
+ *
+ * // Instantiate from constituent parts. // [!code focus]
+ * const wrapped = SignatureErc8010.from({ // [!code focus]
+ *   authorization: { ... }, // [!code focus]
+ *   data: '0x...', // [!code focus]
+ *   signature, // [!code focus]
+ * })
+ * // @log: { authorization: { ... }, data: '0x...', signature: { ... } }
+ * ```
+ *
+ * @param value - Value to parse.
+ * @returns Parsed value.
+ */
+export function from(value: Unwrapped | Wrapped): Unwrapped {
+  if (typeof value === 'string') return unwrap(value)
+  return value
+}
+
+export declare namespace from {
+  type ErrorType = unwrap.ErrorType | Errors.GlobalErrorType
+}
+
+/**
+ * Unwraps an [ERC-8010 wrapped signature](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md) into its constituent parts.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureErc8010 } from 'ox/erc8010'
+ *
+ * const { authorization, data, signature } = SignatureErc8010.unwrap('0x...')
+ * ```
+ *
+ * @param wrapped - Wrapped signature to unwrap.
+ * @returns Unwrapped signature.
+ */
+export function unwrap(wrapped: Wrapped): Unwrapped {
+  assert(wrapped)
+
+  const suffixLength = Hex.toNumber(Hex.slice(wrapped, -64, -32))
+  const suffix = Hex.slice(wrapped, -suffixLength - 64, -64)
+  const signature = Hex.slice(wrapped, 0, -suffixLength - 64)
+
+  const chainId = Hex.toNumber(Hex.slice(suffix, 0, 32))
+  const delegation = Hex.slice(suffix, 32, 52)
+  const nonce = Hex.toBigInt(Hex.slice(suffix, 52, 84))
+  const yParity = Hex.toNumber(Hex.slice(suffix, 84, 85))
+  const r = Hex.toBigInt(Hex.slice(suffix, 85, 117))
+  const s = Hex.toBigInt(Hex.slice(suffix, 117, 149))
+
+  const authorization = Authorization.from({
+    address: delegation,
+    chainId,
+    nonce,
+    yParity,
+    r,
+    s,
+  })
+  const data = (() => {
+    try {
+      return Hex.slice(suffix, 149)
+    } catch {
+      return undefined
+    }
+  })()
+
+  return { authorization, data, signature }
+}
+
+export declare namespace unwrap {
+  type ErrorType = assert.ErrorType | Errors.GlobalErrorType
+}
+
+/**
+ * Wraps a signature into [ERC-8010 format](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md).
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1 } from 'ox'
+ * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: '0x...',
+ *   privateKey: '0x...',
+ * })
+ *
+ * const wrapped = SignatureErc8010.wrap({ // [!code focus]
+ *   authorization: { ... }, // [!code focus]
+ *   data: '0xdeadbeef', // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @param value - Values to wrap.
+ * @returns Wrapped signature.
+ */
+export function wrap(value: Unwrapped): Wrapped {
+  assert(value)
+
+  const { data, signature } = value
+  const authorization = AbiParameters.encodePacked(
+    ['uint256', 'address', 'uint256', 'uint8', 'uint256', 'uint256'],
+    [
+      BigInt(value.authorization.chainId),
+      value.authorization.address,
+      BigInt(value.authorization.nonce),
+      value.authorization.yParity,
+      value.authorization.r,
+      value.authorization.s,
+    ],
+  )
+  const suffix = AbiParameters.encodePacked(
+    ['bytes', 'bytes'],
+    [authorization, data ?? '0x'],
+  )
+  const suffixLength = Hex.fromNumber(Hex.size(suffix), { size: 32 })
+  return Hex.concat(signature, suffix, suffixLength, magicBytes)
+}
+
+export declare namespace wrap {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Validates a wrapped signature. Returns `true` if the wrapped signature is valid, `false` otherwise.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureErc8010 } from 'ox/erc8010'
+ *
+ * const valid = SignatureErc8010.validate('0xdeadbeef')
+ * // @log: false
+ * ```
+ *
+ * @param value - The value to validate.
+ * @returns `true` if the value is valid, `false` otherwise.
+ */
+export function validate(value: Unwrapped | Wrapped): boolean {
+  try {
+    assert(value)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export declare namespace validate {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/** Thrown when the ERC-8010 wrapped signature is invalid. */
+export class InvalidWrappedSignatureError extends Errors.BaseError {
+  override readonly name = 'SignatureErc8010.InvalidWrappedSignatureError'
+
+  constructor(wrapped: Wrapped) {
+    super(`Value \`${wrapped}\` is an invalid ERC-8010 wrapped signature.`)
+  }
+}

package/erc8010/index.ts

@@ -0,0 +1,43 @@
+/** @entrypointCategory ERCs */
+// biome-ignore lint/complexity/noUselessEmptyExport: tsdoc
+export type {}
+
+/**
+ * Utility functions for working with [ERC-8010 wrapped signatures](https://eips.ethereum.org/EIPS/eip-8010#specification).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Authorization, Secp256k1, PersonalMessage } from 'ox'
+ * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x1234567890abcdef1234567890abcdef12345678',
+ *   chainId: 1,
+ *   nonce: 69n,
+ * })
+ *
+ * const authorizationSignature = Secp256k1.sign({
+ *   payload: Authorization.getSignPayload(authorization),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const authorizationSigned = Authorization.from(authorization, {
+ *   signature: authorizationSignature,
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: PersonalMessage.getSignPayload('0xdeadbeef'),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const wrapped = SignatureErc8010.wrap({ // [!code focus]
+ *   authorization: authorizationSigned, // [!code focus]
+ *   data: '0xcafebabe', // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * // @log: '0x000000000000000000000000cafebabecafebabecafebabecafebabecafebabe000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000004deadbeef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c000000000000000000000000000000000000000000000000000000000000008010801080108010801080108010801080108010801080108010801080108010'
+ * ```
+ *
+ * @category ERC-8010
+ */
+export * as SignatureErc8010 from './SignatureErc8010.js'

package/erc8010/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/erc8010/index.d.ts",
+  "main": "../_cjs/erc8010/index.js",
+  "module": "../_esm/erc8010/index.js"
+}

package/index.docs.ts

@@ -1,5 +1,7 @@
 // @ts-nocheck
 /** Used by api-extractor for docgen. https://github.com/microsoft/rushstack/issues/3557 */
+// biome-ignore assist/source/organizeImports: _
 export * from './index.js'
 export * from './erc4337/index.js'
 export * from './erc6492/index.js'
+export * from './erc8010/index.js'