ox 0.9.5 → 0.9.7

package/core/AbiConstructor.ts

@@ -10,11 +10,6 @@ import type { IsNarrowable } from './internal/types.js'
 /** Root type for an {@link ox#AbiItem.AbiItem} with a `constructor` type. */
 export type AbiConstructor = abitype.AbiConstructor
 
-/** @internal */
-export function decode<const abiConstructor extends AbiConstructor>(
-  abiConstructor: abiConstructor,
-  options: decode.Options,
-): decode.ReturnType<abiConstructor>
 /**
  * ABI-decodes the provided constructor input (`inputs`).
  *
@@ -37,19 +32,63 @@ export function decode<const abiConstructor extends AbiConstructor>(
  * }) // [!code focus]
  * ```
  *
+ * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object as a parameter to `AbiConstructor.decode`.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiConstructor } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ *
+ * const data = AbiConstructor.encode(abi, {
+ *   bytecode: '0x...',
+ *   args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 123n],
+ * })
+ *
+ * const decoded = AbiConstructor.decode(abi, { // [!code focus]
+ *   bytecode: '0x...', // [!code focus]
+ *   data, // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
  * @param abiConstructor - The ABI Constructor to decode.
  * @param options - Decoding options.
  * @returns The decoded constructor inputs.
  */
-export function decode(
-  abiConstructor: AbiConstructor,
+export function decode<
+  const abi extends Abi.Abi | readonly unknown[],
+  abiConstructor extends
+    AbiConstructor = fromAbi.ReturnType<abi> extends AbiConstructor
+    ? fromAbi.ReturnType<abi>
+    : never,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
   options: decode.Options,
-): readonly unknown[] | undefined
-/** @internal */
-export function decode(
-  abiConstructor: AbiConstructor,
+): decode.ReturnType<abiConstructor>
+export function decode<const abiConstructor extends AbiConstructor>(
+  abiConstructor: abiConstructor | AbiConstructor,
   options: decode.Options,
+): decode.ReturnType<abiConstructor>
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function decode(
+  ...parameters:
+    | [abi: Abi.Abi | readonly unknown[], options: decode.Options]
+    | [abiConstructor: AbiConstructor, options: decode.Options]
 ): decode.ReturnType {
+  const [abiConstructor, options] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, options] = parameters as [
+        Abi.Abi | readonly unknown[],
+        decode.Options,
+      ]
+      return [fromAbi(abi), options] as [AbiConstructor, decode.Options]
+    }
+    return parameters as [AbiConstructor, decode.Options]
+  })()
+
   const { bytecode } = options
   if (abiConstructor.inputs.length === 0) return undefined
   const data = options.data.replace(bytecode, '0x') as Hex.Hex
@@ -91,6 +130,23 @@ export declare namespace decode {
  * ```
  *
  * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object as a parameter to `AbiConstructor.encode`.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiConstructor } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ *
+ * const data = AbiConstructor.encode(abi, { // [!code focus]
+ *   bytecode: '0x...', // [!code focus]
+ *   args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 123n], // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @example
  * ### End-to-end
  *
  * Below is an end-to-end example of using `AbiConstructor.encode` to encode the constructor of a contract and deploy it.
@@ -128,10 +184,38 @@ export declare namespace decode {
  * @param options - Encoding options.
  * @returns The encoded constructor.
  */
+export function encode<
+  const abi extends Abi.Abi | readonly unknown[],
+  abiConstructor extends
+    AbiConstructor = fromAbi.ReturnType<abi> extends AbiConstructor
+    ? fromAbi.ReturnType<abi>
+    : never,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
+  options: encode.Options<abiConstructor>,
+): encode.ReturnType
 export function encode<const abiConstructor extends AbiConstructor>(
-  abiConstructor: abiConstructor,
+  abiConstructor: abiConstructor | AbiConstructor,
   options: encode.Options<abiConstructor>,
+): encode.ReturnType
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function encode(
+  ...parameters:
+    | [abi: Abi.Abi | readonly unknown[], options: encode.Options]
+    | [abiConstructor: AbiConstructor, options: encode.Options]
 ): encode.ReturnType {
+  const [abiConstructor, options] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, options] = parameters as [
+        Abi.Abi | readonly unknown[],
+        encode.Options,
+      ]
+      return [fromAbi(abi), options] as [AbiConstructor, encode.Options]
+    }
+
+    return parameters as [AbiConstructor, encode.Options]
+  })()
+
   const { bytecode, args } = options
   return Hex.concat(
     bytecode,

package/core/AbiError.ts

@@ -59,35 +59,37 @@ export function decode<
  * ```
  *
  * @example
- * Or define the ABI and error name as parameters to {@link ox#AbiError.(decode:function)}:
+ * You can pass the error `data` to the `name` property of {@link ox#AbiError.(fromAbi:function)} to extract and infer the error by its 4-byte selector:
  *
  * ```ts twoslash
  * // @noErrors
  * import { Abi, AbiError } from 'ox'
  *
+ * const data = '0xecde634900000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001'
+ *
  * const abi = Abi.from([...])
+ * const error = AbiError.fromAbi(abi, data) // [!code hl]
  *
- * const value = AbiError.decode(
- *   abi, // [!code hl]
- *   'InvalidSignature', // [!code hl]
- *   '0x...'
- * )
+ * const value = AbiError.decode(error, data)
  * // @log: [420n, 69n, 1]
  * ```
  *
  * @example
- * You can pass the error `data` to the `name` property of {@link ox#AbiError.(fromAbi:function)} to extract and infer the error by its 4-byte selector:
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object as a parameter to {@link ox#AbiError.(decode:function)}:
  *
  * ```ts twoslash
  * // @noErrors
  * import { Abi, AbiError } from 'ox'
  *
- * const data = '0xecde634900000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001'
- *
  * const abi = Abi.from([...])
- * const error = AbiError.fromAbi(abi, data) // [!code hl]
  *
- * const value = AbiError.decode(error, data)
+ * const value = AbiError.decode(
+ *   abi, // [!code hl]
+ *   'InvalidSignature', // [!code hl]
+ *   '0x...'
+ * )
  * // @log: [420n, 69n, 1]
  * ```
  *
@@ -281,32 +283,21 @@ export declare namespace decode {
  * ```
  *
  * @example
- * You can extract an ABI Error from a JSON ABI with {@link ox#AbiError.(fromAbi:function)}:
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and an error name as parameters to `AbiError.encode`.
  *
  * ```ts twoslash
  * // @noErrors
  * import { Abi, AbiError } from 'ox'
  *
- * const abi = Abi.from([ // [!code hl]
- *   // ... // [!code hl]
- *   { // [!code hl]
- *     name: 'InvalidSignature', // [!code hl]
- *     type: 'error', // [!code hl]
- *     inputs: [ // [!code hl]
- *       { name: 'r', type: 'uint256' }, // [!code hl]
- *       { name: 's', type: 'uint256' }, // [!code hl]
- *       { name: 'yParity', type: 'uint8' }, // [!code hl]
- *     ], // [!code hl]
- *   }, // [!code hl]
- *   // ... // [!code hl]
- * ]) // [!code hl]
- * const error = AbiError.fromAbi(abi, 'InvalidSignature') // [!code hl]
+ * const abi = Abi.from([...])
  *
  * const data = AbiError.encode(
- *   error,
- *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]
+ *   abi, // [!code hl]
+ *   'InvalidSignature', // [!code hl]
+ *   [1n, 2n, 0]
  * )
- * // @log: '0x095ea7b3000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa960450000000000000000000000000000000000000000000000000000000000010f2c'
  * ```
  *
  * @param abiError - ABI Error to encode

package/core/AbiEvent.ts

@@ -237,6 +237,38 @@ export declare namespace assertArgs {
  * ```
  *
  * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and an event name as parameters to {@link ox#AbiEvent.(decode:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiEvent } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ * const log = {
+ *   // ...
+ *   data: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *   topics: [
+ *     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+ *     '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ *     '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ *   ],
+ * } as const
+ *
+ * const decoded = AbiEvent.decode(
+ *   abi, // [!code focus]
+ *   'Transfer', // [!code focus]
+ *   log
+ * )
+ * // @log: {
+ * // @log:   from: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ * // @log:   to: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ * // @log:   value: 1n
+ * // @log: }
+ * ```
+ *
+ * @example
  * ### End-to-end
  *
  * Below is an end-to-end example of using `AbiEvent.decode` to decode the topics of a `Transfer` event on the [Wagmi Mint Example contract](https://etherscan.io/address/0xfba3912ca04dd458c843e2ee08967fc04f3579c2).
@@ -490,6 +522,32 @@ export declare namespace decode {
  * ```
  *
  * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and an event name as parameters to {@link ox#AbiEvent.(encode:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiEvent } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ *
+ * const { topics } = AbiEvent.encode(
+ *   abi, // [!code focus]
+ *   'Transfer', // [!code focus]
+ *   {
+ *     from: '0xf39fd6e51aad88f6f4ce6ab882779cfffb92266', // [!code focus]
+ *     to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   }
+ * )
+ * // @log: [
+ * // @log:   '0x406dade31f7ae4b5dbc276258c28dde5ae6d5c2773c5745802c493a2360e55e0',
+ * // @log:   '0x00000000000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+ * // @log:   '0x0000000000000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8'
+ * // @log: ]
+ * ```
+ *
+ * @example
  * ### End-to-end
  *
  * Below is an end-to-end example of using `AbiEvent.encode` to encode the topics of a `Transfer` event and query for events matching the encoded topics on the [Wagmi Mint Example contract](https://etherscan.io/address/0xfba3912ca04dd458c843e2ee08967fc04f3579c2).

package/core/AbiFunction.ts

@@ -90,6 +90,26 @@ export type ExtractNames<
  * // @log: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]
  * ```
  *
+ * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and a function name as parameters to {@link ox#AbiFunction.(decodeData:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiFunction } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ * const data = '0x...
+ *
+ * const input = AbiFunction.decodeData(
+ *   abi, // [!code focus]
+ *   'approve', // [!code focus]
+ *   data
+ * )
+ * // @log: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]
+ * ```
+ *
  * @param abiFunction - The ABI Item to decode.
  * @param data - The data to decode.
  */
@@ -211,7 +231,9 @@ export declare namespace decodeData {
  * ```
  *
  * @example
- * Or define the ABI and function name as parameters to {@link ox#AbiFunction.(decodeResult:function)}:
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and a function name as parameters to {@link ox#AbiFunction.(decodeResult:function)}:
  *
  * ```ts twoslash
  * // @noErrors
@@ -222,8 +244,8 @@ export declare namespace decodeData {
  * const erc20Abi = Abi.from([...])
  *
  * const output = AbiFunction.decodeResult(
- *   erc20Abi, // [!code hl]
- *   'totalSupply', // [!code hl]
+ *   erc20Abi, // [!code focus]
+ *   'totalSupply', // [!code focus]
  *   data
  * )
  * // @log: 42n
@@ -433,7 +455,9 @@ export declare namespace decodeResult {
  * ```
  *
  * @example
- * Or define the ABI and function name as parameters to {@link ox#AbiFunction.(encodeData:function)}:
+ * ### ABI-shorthand
+ *
+ * You can specify an entire ABI object and a function name as parameters to {@link ox#AbiFunction.(encodeData:function)}:
  *
  * ```ts twoslash
  * // @noErrors
@@ -442,8 +466,8 @@ export declare namespace decodeResult {
  * const erc20Abi = Abi.from([...])
  *
  * const data = AbiFunction.encodeData(
- *   erc20Abi, // [!code hl]
- *   'approve', // [!code hl]
+ *   erc20Abi, // [!code focus]
+ *   'approve', // [!code focus]
  *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]
  * )
  * ```
@@ -603,6 +627,25 @@ export declare namespace encodeData {
  * // @log: '0x000000000000000000000000000000000000000000000000000000000000002a'
  * ```
  *
+ * @example
+ * ### ABI-shorthand
+ *
+ * You can also specify an entire ABI object and a function name as parameters to {@link ox#AbiFunction.(encodeResult:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiFunction } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ *
+ * const data = AbiFunction.encodeResult(
+ *   abi, // [!code focus]
+ *   'totalSupply', // [!code focus]
+ *   42n
+ * )
+ * // @log: '0x000000000000000000000000000000000000000000000000000000000000002a'
+ * ```
+ *
  * @param abiFunction - The ABI item to encode the function output for.
  * @param output - The function output to encode.
  * @param options - Encoding options.

package/core/AbiItem.ts

@@ -493,6 +493,17 @@ export declare namespace fromAbi {
  *
  * @example
  * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiItem } from 'ox'
+ *
+ * const erc20Abi = Abi.from([...])
+ *
+ * const selector = AbiItem.getSelector(erc20Abi, 'ownerOf')
+ * // @log: '0x6352211e'
+ * ```
+ *
+ * @example
+ * ```ts twoslash
  * import { AbiItem } from 'ox'
  *
  * const selector = AbiItem.getSelector({
@@ -508,7 +519,24 @@ export declare namespace fromAbi {
  * @param abiItem - The ABI item to compute the selector for. Can be a signature or an ABI item for an error, event, function, etc.
  * @returns The first 4 bytes of the {@link ox#Hash.(keccak256:function)} hash of the function signature.
  */
-export function getSelector(abiItem: string | AbiItem): Hex.Hex {
+export function getSelector<
+  abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+>(abi: abi | Abi.Abi | readonly unknown[], name: name): Hex.Hex
+export function getSelector(abiItem: string | AbiItem): Hex.Hex
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function getSelector(
+  ...parameters:
+    | [abi: Abi.Abi | readonly unknown[], name: string]
+    | [string | AbiItem]
+): Hex.Hex {
+  const abiItem = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name] = parameters as [Abi.Abi | readonly unknown[], string]
+      return fromAbi(abi, name)
+    }
+    return parameters[0] as string | AbiItem
+  })()
   return Hex.slice(getSignatureHash(abiItem), 0, 4)
 }
 
@@ -532,6 +560,17 @@ export declare namespace getSelector {
  *
  * @example
  * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiItem } from 'ox'
+ *
+ * const erc20Abi = Abi.from([...])
+ *
+ * const signature = AbiItem.getSignature(erc20Abi, 'ownerOf')
+ * // @log: 'ownerOf(uint256)'
+ * ```
+ *
+ * @example
+ * ```ts twoslash
  * import { AbiItem } from 'ox'
  *
  * const signature = AbiItem.getSignature({
@@ -547,7 +586,24 @@ export declare namespace getSelector {
  * @param abiItem - The ABI Item to compute the signature for.
  * @returns The stringified signature of the ABI Item.
  */
-export function getSignature(abiItem: string | AbiItem): string {
+export function getSignature<
+  abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+>(abi: abi | Abi.Abi | readonly unknown[], name: name): string
+export function getSignature(abiItem: string | AbiItem): string
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function getSignature(
+  ...parameters:
+    | [abi: Abi.Abi | readonly unknown[], name: string]
+    | [string | AbiItem]
+): string {
+  const abiItem = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name] = parameters as [Abi.Abi | readonly unknown[], string]
+      return fromAbi(abi, name)
+    }
+    return parameters[0] as string | AbiItem
+  })()
   const signature = (() => {
     if (typeof abiItem === 'string') return abiItem
     return abitype.formatAbiItem(abiItem)
@@ -576,6 +632,17 @@ export declare namespace getSignature {
  *
  * @example
  * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiItem } from 'ox'
+ *
+ * const erc20Abi = Abi.from([...])
+ *
+ * const hash = AbiItem.getSignatureHash(erc20Abi, 'Transfer')
+ * // @log: '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+ * ```
+ *
+ * @example
+ * ```ts twoslash
  * import { AbiItem } from 'ox'
  *
  * const hash = AbiItem.getSignatureHash({
@@ -593,7 +660,24 @@ export declare namespace getSignature {
  * @param abiItem - The ABI Item to compute the signature hash for.
  * @returns The {@link ox#Hash.(keccak256:function)} hash of the ABI item's signature.
  */
-export function getSignatureHash(abiItem: string | AbiItem): Hex.Hex {
+export function getSignatureHash<
+  abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+>(abi: abi | Abi.Abi | readonly unknown[], name: name): Hex.Hex
+export function getSignatureHash(abiItem: string | AbiItem): Hex.Hex
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function getSignatureHash(
+  ...parameters:
+    | [abi: Abi.Abi | readonly unknown[], name: string]
+    | [string | AbiItem]
+): Hex.Hex {
+  const abiItem = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name] = parameters as [Abi.Abi | readonly unknown[], string]
+      return fromAbi(abi, name)
+    }
+    return parameters[0] as string | AbiItem
+  })()
   if (typeof abiItem !== 'string' && 'hash' in abiItem && abiItem.hash)
     return abiItem.hash as Hex.Hex
   return Hash.keccak256(Hex.fromString(getSignature(abiItem)))

package/core/Bytes.ts

@@ -231,7 +231,7 @@ export function fromHex(value: Hex.Hex, options: fromHex.Options = {}): Bytes {
         `Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`,
       )
     }
-    bytes[index] = nibbleLeft * 16 + nibbleRight
+    bytes[index] = (nibbleLeft << 4) | nibbleRight
   }
   return bytes
 }

package/core/Hex.ts

@@ -256,7 +256,7 @@ export function fromNumber(
   }
 
   const stringValue = (
-    signed && value_ < 0 ? (1n << BigInt(size * 8)) + BigInt(value_) : value_
+    signed && value_ < 0 ? BigInt.asUintN(size * 8, BigInt(value_)) : value_
   ).toString(16)
 
   const hex = `0x${stringValue}` as Hex

package/core/Rlp.ts

@@ -359,9 +359,9 @@ function getEncodableBytes(bytesOrHex: Bytes.Bytes | Hex.Hex): Encodable {
 }
 
 function getSizeOfLength(length: number) {
-  if (length < 2 ** 8) return 1
-  if (length < 2 ** 16) return 2
-  if (length < 2 ** 24) return 3
-  if (length < 2 ** 32) return 4
+  if (length <= 0xff) return 1
+  if (length <= 0xff_ff) return 2
+  if (length <= 0xff_ff_ff) return 3
+  if (length <= 0xff_ff_ff_ff) return 4
   throw new Errors.BaseError('Length is too large.')
 }

package/core/TransactionRequest.ts

@@ -4,6 +4,7 @@ import * as Authorization from './Authorization.js'
 import type * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
 import type { Compute } from './internal/types.js'
+import * as Transaction from './Transaction.js'
 
 /** A Transaction Request that is generic to all transaction types, as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423). */
 export type TransactionRequest<
@@ -132,7 +133,11 @@ export function toRpc(request: TransactionRequest): Rpc {
   if (typeof request.nonce !== 'undefined')
     request_rpc.nonce = Hex.fromNumber(request.nonce)
   if (typeof request.to !== 'undefined') request_rpc.to = request.to
-  if (typeof request.type !== 'undefined') request_rpc.type = request.type
+  if (typeof request.type !== 'undefined')
+    request_rpc.type =
+      Transaction.toRpcType[
+        request.type as keyof typeof Transaction.toRpcType
+      ] || request.type
   if (typeof request.value !== 'undefined')
     request_rpc.value = Hex.fromNumber(request.value)
 

package/erc6492/SignatureErc6492.ts

@@ -187,7 +187,7 @@ export declare namespace unwrap {
  *
  * @example
  * ```ts twoslash
- * import { Secp256k1 } from 'ox'
+ * import { Secp256k1, Signature } from 'ox'
  * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
  *
  * const signature = Secp256k1.sign({
@@ -197,7 +197,7 @@ export declare namespace unwrap {
  *
  * const wrapped = SignatureErc6492.wrap({ // [!code focus]
  *   data: '0xdeadbeef', // [!code focus]
- *   signature, // [!code focus]
+ *   signature: Signature.toHex(signature), // [!code focus]
  *   to: '0x00000000219ab540356cBB839Cbe05303d7705Fa', // [!code focus]
  * }) // [!code focus]
  * ```

package/erc6492/index.ts

@@ -7,7 +7,7 @@ export type {}
  *
  * @example
  * ```ts twoslash
- * import { Secp256k1, PersonalMessage } from 'ox'
+ * import { PersonalMessage, Secp256k1, Signature } from 'ox'
  * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
  *
  * const signature = Secp256k1.sign({
@@ -17,7 +17,7 @@ export type {}
  *
  * const wrapped = SignatureErc6492.wrap({ // [!code focus]
  *   data: '0xcafebabe', // [!code focus]
- *   signature, // [!code focus]
+ *   signature: Signature.toHex(signature), // [!code focus]
  *   to: '0xcafebabecafebabecafebabecafebabecafebabe', // [!code focus]
  * }) // [!code focus]
  * // @log: '0x000000000000000000000000cafebabecafebabecafebabecafebabecafebabe000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000004deadbeef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c000000000000000000000000000000000000000000000000000000000000006492649264926492649264926492649264926492649264926492649264926492'

package/erc8010/SignatureErc8010.ts

@@ -146,7 +146,7 @@ export declare namespace unwrap {
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Secp256k1 } from 'ox'
+ * import { Secp256k1, Signature } from 'ox'
  * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]
  *
  * const signature = Secp256k1.sign({
@@ -157,7 +157,7 @@ export declare namespace unwrap {
  * const wrapped = SignatureErc8010.wrap({ // [!code focus]
  *   authorization: { ... }, // [!code focus]
  *   data: '0xdeadbeef', // [!code focus]
- *   signature, // [!code focus]
+ *   signature: Signature.toHex(signature), // [!code focus]
  * }) // [!code focus]
  * ```
  *

package/erc8010/index.ts

@@ -7,7 +7,7 @@ export type {}
  *
  * @example
  * ```ts twoslash
- * import { Authorization, Secp256k1, PersonalMessage } from 'ox'
+ * import { Authorization, PersonalMessage, Secp256k1, Signature } from 'ox'
  * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]
  *
  * const authorization = Authorization.from({
@@ -33,7 +33,7 @@ export type {}
  * const wrapped = SignatureErc8010.wrap({ // [!code focus]
  *   authorization: authorizationSigned, // [!code focus]
  *   data: '0xcafebabe', // [!code focus]
- *   signature, // [!code focus]
+ *   signature: Signature.toHex(signature), // [!code focus]
  * }) // [!code focus]
  * // @log: '0x000000000000000000000000cafebabecafebabecafebabecafebabecafebabe000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000004deadbeef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c000000000000000000000000000000000000000000000000000000000000008010801080108010801080108010801080108010801080108010801080108010'
  * ```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.9.5'
+export const version = '0.9.7'