ox 0.9.4 → 0.9.6

package/core/AbiError.ts

@@ -75,6 +75,25 @@ export function decode<
  * ```
  *
  * @example
+ * ### 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 abi = Abi.from([...])
+ *
+ * const value = AbiError.decode(
+ *   abi, // [!code hl]
+ *   'InvalidSignature', // [!code hl]
+ *   '0x...'
+ * )
+ * // @log: [420n, 69n, 1]
+ * ```
+ *
+ * @example
  * ### End-to-end
  *
  * Below is an end-to-end example of using `AbiError.decode` to decode the revert error of an `approve` contract call on the [Wagmi Mint Example contract](https://etherscan.io/address/0xfba3912ca04dd458c843e2ee08967fc04f3579c2).
@@ -139,17 +158,58 @@ export function decode<
  * @param options - Decoding options.
  * @returns The decoded error.
  */
-export function decode(
-  abiError: AbiError,
+export function decode<
+  const abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+  const args extends
+    | AbiItem_internal.ExtractArgs<abi, name>
+    | undefined = undefined,
+  as extends 'Object' | 'Array' = 'Array',
+  //
+  abiError extends AbiError = AbiItem.fromAbi.ReturnType<
+    abi,
+    name,
+    args,
+    AbiError
+  >,
+  allNames = Name<abi>,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
+  name: Hex.Hex | (name extends allNames ? name : never),
   data: Hex.Hex,
-  options?: decode.Options | undefined,
-): unknown | readonly unknown[] | undefined
-/** @internal */
-export function decode(
-  abiError: AbiError,
+  options?: decode.Options<as> | undefined,
+): decode.ReturnType<abiError, as>
+export function decode<
+  const abiError extends AbiError,
+  as extends 'Object' | 'Array' = 'Array',
+>(
+  abiError: abiError | AbiError,
   data: Hex.Hex,
-  options: decode.Options = {},
+  options?: decode.Options<as> | undefined,
+): decode.ReturnType<abiError, as>
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function decode(
+  ...parameters:
+    | [
+        abi: Abi.Abi | readonly unknown[],
+        name: Hex.Hex | string,
+        data: Hex.Hex,
+        options?: decode.Options | undefined,
+      ]
+    | [abiError: AbiError, data: Hex.Hex, options?: decode.Options | undefined]
 ): decode.ReturnType {
+  const [abiError, data, options = {}] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name, data, options] = parameters as [
+        Abi.Abi | readonly unknown[],
+        Hex.Hex | string,
+        Hex.Hex,
+        decode.Options | undefined,
+      ]
+      return [fromAbi(abi, name), data, options]
+    }
+    return parameters as [AbiError, Hex.Hex, decode.Options | undefined]
+  })()
   if (Hex.size(data) < 4) throw new AbiItem.InvalidSelectorSizeError({ data })
   if (abiError.inputs.length === 0) return undefined
 
@@ -223,42 +283,76 @@ 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
  * @param args - Error arguments
  * @returns ABI-encoded error name and arguments
  */
+export function encode<
+  const abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+  const args extends
+    | AbiItem_internal.ExtractArgs<abi, name>
+    | undefined = undefined,
+  //
+  abiError extends AbiError = AbiItem.fromAbi.ReturnType<
+    abi,
+    name,
+    args,
+    AbiError
+  >,
+  allNames = Name<abi>,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
+  name: Hex.Hex | (name extends allNames ? name : never),
+  ...args: encode.Args<abiError>
+): encode.ReturnType
 export function encode<const abiError extends AbiError>(
   abiError: abiError,
   ...args: encode.Args<abiError>
-): encode.ReturnType {
+): encode.ReturnType
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function encode(
+  ...parameters:
+    | [
+        abi: Abi.Abi | readonly unknown[],
+        name: Hex.Hex | string,
+        ...args: readonly unknown[],
+      ]
+    | [abiError: AbiError, ...args: readonly unknown[]]
+) {
+  const [abiError, args] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name, ...args] = parameters as [
+        Abi.Abi | readonly unknown[],
+        Hex.Hex | string,
+        ...(readonly unknown[]),
+      ]
+      return [fromAbi(abi, name), args]
+    }
+    const [abiError, ...args] = parameters as [
+      AbiError,
+      ...(readonly unknown[]),
+    ]
+    return [abiError, args]
+  })()
+
   const selector = getSelector(abiError)
 
   const data =

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).
@@ -286,10 +318,51 @@ export declare namespace assertArgs {
  * @param log - `topics` & `data` to decode.
  * @returns The decoded event.
  */
+export function decode<
+  const abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+  const args extends
+    | AbiItem_internal.ExtractArgs<abi, name>
+    | undefined = undefined,
+  //
+  abiEvent extends AbiEvent = AbiItem.fromAbi.ReturnType<
+    abi,
+    name,
+    args,
+    AbiEvent
+  >,
+  allNames = Name<abi>,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
+  name: Hex.Hex | (name extends allNames ? name : never),
+  log: decode.Log,
+): decode.ReturnType<abiEvent>
 export function decode<const abiEvent extends AbiEvent>(
   abiEvent: abiEvent | AbiEvent,
   log: decode.Log,
-): decode.ReturnType<abiEvent> {
+): decode.ReturnType<abiEvent>
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function decode(
+  ...parameters:
+    | [
+        abi: Abi.Abi | readonly unknown[],
+        name: Hex.Hex | string,
+        log: decode.Log,
+      ]
+    | [abiEvent: AbiEvent, log: decode.Log]
+): decode.ReturnType {
+  const [abiEvent, log] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name, log] = parameters as [
+        Abi.Abi | readonly unknown[],
+        Hex.Hex | string,
+        decode.Log,
+      ]
+      return [fromAbi(abi, name), log]
+    }
+    return parameters as [AbiEvent, decode.Log]
+  })()
+
   const { data, topics } = log
 
   const [selector_, ...argTopics] = topics
@@ -449,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).
@@ -496,10 +595,55 @@ export declare namespace decode {
  * @param args - The arguments to encode.
  * @returns The encoded event topics.
  */
+export function encode<
+  const abi extends Abi.Abi | readonly unknown[],
+  name extends Name<abi>,
+  const args extends
+    | AbiItem_internal.ExtractArgs<abi, name>
+    | undefined = undefined,
+  //
+  abiEvent extends AbiEvent = AbiItem.fromAbi.ReturnType<
+    abi,
+    name,
+    args,
+    AbiEvent
+  >,
+  allNames = Name<abi>,
+>(
+  abi: abi | Abi.Abi | readonly unknown[],
+  name: Hex.Hex | (name extends allNames ? name : never),
+  ...[args]: encode.Args<abiEvent>
+): encode.ReturnType
 export function encode<const abiEvent extends AbiEvent>(
   abiEvent: abiEvent | AbiEvent,
   ...[args]: encode.Args<abiEvent>
+): encode.ReturnType
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function encode(
+  ...parameters:
+    | [
+        abi: Abi.Abi | readonly unknown[],
+        name: Hex.Hex | string,
+        args?: readonly unknown[] | Record<string, unknown>,
+      ]
+    | [abiEvent: AbiEvent, args?: readonly unknown[] | Record<string, unknown>]
 ): encode.ReturnType {
+  const [abiEvent, args] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi, name, args] = parameters as [
+        Abi.Abi | readonly unknown[],
+        Hex.Hex | string,
+        readonly unknown[] | Record<string, unknown> | undefined,
+      ]
+      return [fromAbi(abi, name), args]
+    }
+    const [abiEvent, args] = parameters as [
+      AbiEvent,
+      readonly unknown[] | Record<string, unknown> | undefined,
+    ]
+    return [abiEvent, args]
+  })()
+
   let topics: (Hex.Hex | Hex.Hex[] | null)[] = []
   if (args && abiEvent.inputs) {
     const indexedInputs = abiEvent.inputs.filter(