ox 1.0.0-beta.2 → 1.0.0-beta.20

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.20",
   "main": "./dist/index.js",
   "sideEffects": false,
   "license": "MIT",
@@ -89,6 +89,11 @@
       "types": "./dist/core/AbiItem.d.ts",
       "default": "./dist/core/AbiItem.js"
     },
+    "./AbiParameter": {
+      "src": "./src/core/AbiParameter.ts",
+      "types": "./dist/core/AbiParameter.d.ts",
+      "default": "./dist/core/AbiParameter.js"
+    },
     "./AbiParameters": {
       "src": "./src/core/AbiParameters.ts",
       "types": "./dist/core/AbiParameters.d.ts",
@@ -554,11 +559,6 @@
       "types": "./dist/tempo/Tick.d.ts",
       "default": "./dist/tempo/Tick.js"
     },
-    "./tempo/TokenId": {
-      "src": "./src/tempo/TokenId.ts",
-      "types": "./dist/tempo/TokenId.d.ts",
-      "default": "./dist/tempo/TokenId.js"
-    },
     "./tempo/TokenRole": {
       "src": "./src/tempo/TokenRole.ts",
       "types": "./dist/tempo/TokenRole.d.ts",
@@ -654,6 +654,56 @@
       "types": "./dist/zod/index.d.ts",
       "default": "./dist/zod/index.js"
     },
+    "./zod/Abi": {
+      "src": "./src/zod/Abi.ts",
+      "types": "./dist/zod/Abi.d.ts",
+      "default": "./dist/zod/Abi.js"
+    },
+    "./zod/AbiConstructor": {
+      "src": "./src/zod/AbiConstructor.ts",
+      "types": "./dist/zod/AbiConstructor.d.ts",
+      "default": "./dist/zod/AbiConstructor.js"
+    },
+    "./zod/AbiError": {
+      "src": "./src/zod/AbiError.ts",
+      "types": "./dist/zod/AbiError.d.ts",
+      "default": "./dist/zod/AbiError.js"
+    },
+    "./zod/AbiEvent": {
+      "src": "./src/zod/AbiEvent.ts",
+      "types": "./dist/zod/AbiEvent.d.ts",
+      "default": "./dist/zod/AbiEvent.js"
+    },
+    "./zod/AbiFallback": {
+      "src": "./src/zod/AbiFallback.ts",
+      "types": "./dist/zod/AbiFallback.d.ts",
+      "default": "./dist/zod/AbiFallback.js"
+    },
+    "./zod/AbiFunction": {
+      "src": "./src/zod/AbiFunction.ts",
+      "types": "./dist/zod/AbiFunction.d.ts",
+      "default": "./dist/zod/AbiFunction.js"
+    },
+    "./zod/AbiItem": {
+      "src": "./src/zod/AbiItem.ts",
+      "types": "./dist/zod/AbiItem.d.ts",
+      "default": "./dist/zod/AbiItem.js"
+    },
+    "./zod/AbiParameter": {
+      "src": "./src/zod/AbiParameter.ts",
+      "types": "./dist/zod/AbiParameter.d.ts",
+      "default": "./dist/zod/AbiParameter.js"
+    },
+    "./zod/AbiParameters": {
+      "src": "./src/zod/AbiParameters.ts",
+      "types": "./dist/zod/AbiParameters.d.ts",
+      "default": "./dist/zod/AbiParameters.js"
+    },
+    "./zod/AbiReceive": {
+      "src": "./src/zod/AbiReceive.ts",
+      "types": "./dist/zod/AbiReceive.d.ts",
+      "default": "./dist/zod/AbiReceive.js"
+    },
     "./zod/AccessList": {
       "src": "./src/zod/AccessList.ts",
       "types": "./dist/zod/AccessList.d.ts",
@@ -744,6 +794,11 @@
       "types": "./dist/zod/Signature.d.ts",
       "default": "./dist/zod/Signature.js"
     },
+    "./zod/Solidity": {
+      "src": "./src/zod/Solidity.ts",
+      "types": "./dist/zod/Solidity.d.ts",
+      "default": "./dist/zod/Solidity.js"
+    },
     "./zod/StateOverrides": {
       "src": "./src/zod/StateOverrides.ts",
       "types": "./dist/zod/StateOverrides.d.ts",
@@ -794,6 +849,11 @@
       "types": "./dist/zod/TxEnvelopeLegacy.d.ts",
       "default": "./dist/zod/TxEnvelopeLegacy.js"
     },
+    "./zod/TypedData": {
+      "src": "./src/zod/TypedData.ts",
+      "types": "./dist/zod/TypedData.d.ts",
+      "default": "./dist/zod/TypedData.js"
+    },
     "./zod/Uint": {
       "src": "./src/zod/Uint.ts",
       "types": "./dist/zod/Uint.d.ts",
@@ -844,11 +904,6 @@
       "types": "./dist/zod/tempo/Tick.d.ts",
       "default": "./dist/zod/tempo/Tick.js"
     },
-    "./zod/tempo/TokenId": {
-      "src": "./src/zod/tempo/TokenId.ts",
-      "types": "./dist/zod/tempo/TokenId.d.ts",
-      "default": "./dist/zod/tempo/TokenId.js"
-    },
     "./zod/tempo/TokenRole": {
       "src": "./src/zod/tempo/TokenRole.ts",
       "types": "./dist/zod/tempo/TokenRole.d.ts",

package/src/CHANGELOG.md

@@ -1,5 +1,23 @@
 # ox
 
+## 0.14.30
+
+### Patch Changes
+
+- [#281](https://github.com/wevm/ox/pull/281) [`da3309e`](https://github.com/wevm/ox/commit/da3309e19907db3e5a497140dee5e9041c05f514) Thanks [@jxom](https://github.com/jxom)! - **Breaking (`ox/tempo`):** Removed the TIP-1061 multisig `config_id` concept to match the updated Tempo reference implementation: multisig account addresses now derive directly from the initial config, owner approval digests bind only `account`, the signature wire format is `0x05 || rlp([account, signatures, init?])`, `MultisigConfig.maxOwners` is now 255 with `u8` weights, and owner approvals may be nested multisig signatures.
+
+  ```diff
+  - const id = MultisigConfig.toId(genesisConfig)
+  - const account = MultisigConfig.getAddress({ genesisConfigId: id })
+  + const account = MultisigConfig.getAddress(genesisConfig)
+
+  - MultisigConfig.getSignPayload({ payload, account, genesisConfigId })
+  + MultisigConfig.getSignPayload({ payload, account })
+
+  - SignatureEnvelope.from({ account, genesisConfigId, signatures })
+  + SignatureEnvelope.from({ account, signatures })
+  ```
+
 ## 0.14.29
 
 ### Patch Changes

package/src/core/Abi.bench.ts

@@ -0,0 +1,30 @@
+import { bench, describe } from 'vp/test'
+import * as Abi from './Abi.js'
+
+const signatures = [
+  'function name() view returns (string)',
+  'function symbol() view returns (string)',
+  'function decimals() view returns (uint8)',
+  'function totalSupply() view returns (uint256)',
+  'function balanceOf(address owner) view returns (uint256)',
+  'function transfer(address to, uint256 amount) returns (bool)',
+  'function transferFrom(address from, address to, uint256 amount) returns (bool)',
+  'function approve(address spender, uint256 amount) returns (bool)',
+  'function allowance(address owner, address spender) view returns (uint256)',
+  'event Transfer(address indexed from, address indexed to, uint256 amount)',
+  'event Approval(address indexed owner, address indexed spender, uint256 amount)',
+] as const
+
+const abi = Abi.from(signatures)
+
+describe('Abi.from', () => {
+  bench('erc20 human-readable ABI', () => {
+    Abi.from(signatures)
+  })
+})
+
+describe('Abi.format', () => {
+  bench('erc20 JSON ABI', () => {
+    Abi.format(abi)
+  })
+})

package/src/core/Abi.ts

@@ -2,10 +2,19 @@ import * as abitype from 'abitype'
 import type * as Errors from './Errors.js'
 import * as internal from './internal/abi.js'
 import type * as AbiItem_internal from './internal/abiItem.js'
+import * as formatAbi from './internal/human-readable/formatAbi.js'
+import * as parseAbi from './internal/human-readable/parseAbi.js'
 
 /** Root type for an ABI. */
 export type Abi = abitype.Abi
 
+export {
+  InvalidSignatureError,
+  InvalidStructSignatureError,
+  UnknownSignatureError,
+} from './internal/human-readable/errors.js'
+export { CircularReferenceError } from './internal/human-readable/errors.js'
+
 /** @internal */
 export function format<const abi extends Abi>(abi: abi): format.ReturnType<abi>
 /**
@@ -44,12 +53,12 @@ export function format<const abi extends Abi>(abi: abi): format.ReturnType<abi>
 export function format(abi: Abi | readonly unknown[]): readonly string[]
 // eslint-disable-next-line jsdoc-js/require-jsdoc
 export function format(abi: Abi | readonly unknown[]): format.ReturnType {
-  return abitype.formatAbi(abi) as never
+  return formatAbi.formatAbi(abi) as never
 }
 
 export declare namespace format {
   type ReturnType<abi extends Abi | readonly unknown[] = Abi> =
-    abitype.FormatAbi<abi>
+    formatAbi.FormatAbi<abi>
 
   type ErrorType = Errors.GlobalErrorType
 }
@@ -113,14 +122,14 @@ export function from<const abi extends Abi | readonly string[]>(
 export function from(abi: Abi | readonly string[]): Abi
 // eslint-disable-next-line jsdoc-js/require-jsdoc
 export function from(abi: Abi | readonly string[]): from.ReturnType {
-  if (internal.isSignatures(abi)) return abitype.parseAbi(abi)
+  if (internal.isSignatures(abi)) return parseAbi.parseAbi(abi)
   return abi
 }
 
 export declare namespace from {
   type ReturnType<
     abi extends Abi | readonly string[] | readonly unknown[] = Abi,
-  > = abi extends readonly string[] ? abitype.ParseAbi<abi> : abi
+  > = abi extends readonly string[] ? parseAbi.ParseAbi<abi> : abi
 
   type ErrorType = Errors.GlobalErrorType
 }

package/src/core/AbiConstructor.ts

@@ -5,6 +5,7 @@ import * as AbiParameters from './AbiParameters.js'
 import * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
 import type * as internal from './internal/abiConstructor.js'
+import * as formatAbiItem from './internal/human-readable/formatAbiItem.js'
 import type { IsNarrowable } from './internal/types.js'
 
 /** Root type for an {@link ox#AbiItem.AbiItem} with a `constructor` type. */
@@ -316,12 +317,12 @@ export function format<const abiConstructor extends AbiConstructor>(
 export function format(abiConstructor: AbiConstructor): string
 /** @internal */
 export function format(abiConstructor: AbiConstructor): format.ReturnType {
-  return abitype.formatAbiItem(abiConstructor)
+  return formatAbiItem.formatAbiItem(abiConstructor)
 }
 
 export declare namespace format {
   type ReturnType<abiConstructor extends AbiConstructor = AbiConstructor> =
-    abitype.FormatAbiItem<abiConstructor>
+    formatAbiItem.FormatAbiItem<abiConstructor>
 
   type ErrorType = Errors.GlobalErrorType
 }

package/src/core/AbiError.ts

@@ -6,6 +6,7 @@ import type * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
 import type * as internal from './internal/abiError.js'
 import type * as AbiItem_internal from './internal/abiItem.js'
+import * as formatAbiItem from './internal/human-readable/formatAbiItem.js'
 import type { IsNarrowable, IsNever } from './internal/types.js'
 
 /** Root type for an {@link ox#AbiItem.AbiItem} with an `error` type. */
@@ -510,11 +511,14 @@ export declare namespace encode {
  */
 export function format<const abiError extends AbiError>(
   abiError: abiError | AbiError,
-): abitype.FormatAbiItem<abiError> {
-  return abitype.formatAbiItem(abiError) as never
+): format.ReturnType<abiError> {
+  return formatAbiItem.formatAbiItem(abiError) as never
 }
 
 export declare namespace format {
+  type ReturnType<abiError extends AbiError = AbiError> =
+    formatAbiItem.FormatAbiItem<abiError>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

package/src/core/AbiEvent.ts

@@ -11,6 +11,7 @@ import type * as internal from './internal/abiEvent.js'
 import type * as AbiItem_internal from './internal/abiItem.js'
 import * as Cursor from './internal/cursor.js'
 import { prettyPrint } from './internal/errors.js'
+import * as formatAbiItem from './internal/human-readable/formatAbiItem.js'
 import type { Compute, IsNarrowable } from './internal/types.js'
 
 /** Root type for an {@link ox#AbiItem.AbiItem} with an `event` type. */
@@ -1334,11 +1335,14 @@ export declare namespace encode {
  */
 export function format<const abiEvent extends AbiEvent>(
   abiEvent: abiEvent | AbiEvent,
-): abitype.FormatAbiItem<abiEvent> {
-  return abitype.formatAbiItem(abiEvent) as never
+): format.ReturnType<abiEvent> {
+  return formatAbiItem.formatAbiItem(abiEvent) as never
 }
 
 export declare namespace format {
+  type ReturnType<abiEvent extends AbiEvent = AbiEvent> =
+    formatAbiItem.FormatAbiItem<abiEvent>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

package/src/core/AbiFunction.ts

@@ -7,6 +7,7 @@ import * as Hex from './Hex.js'
 import type * as internal from './internal/abiFunction.js'
 import type * as AbiItem_internal from './internal/abiItem.js'
 import type * as AbiParameters_internal from './internal/abiParameters.js'
+import * as formatAbiItem from './internal/human-readable/formatAbiItem.js'
 import type { IsNarrowable } from './internal/types.js'
 
 /** Root type for an {@link ox#AbiItem.AbiItem} with a `function` type. */
@@ -864,11 +865,14 @@ export declare namespace encodeResult {
  */
 export function format<const abiFunction extends AbiFunction>(
   abiFunction: abiFunction | AbiFunction,
-): abitype.FormatAbiItem<abiFunction> {
-  return abitype.formatAbiItem(abiFunction) as never
+): format.ReturnType<abiFunction> {
+  return formatAbiItem.formatAbiItem(abiFunction) as never
 }
 
 export declare namespace format {
+  type ReturnType<abiFunction extends AbiFunction = AbiFunction> =
+    formatAbiItem.FormatAbiItem<abiFunction>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

package/src/core/AbiItem.bench.ts

@@ -38,3 +38,22 @@ describe('AbiItem.fromAbi (name)', () => {
     AbiItem.fromAbi(abi200, 'fn179')
   })
 })
+
+describe('AbiItem.from', () => {
+  bench('function transfer(address to, uint256 amount)', () => {
+    AbiItem.from('function transfer(address to, uint256 amount) returns (bool)')
+  })
+
+  bench('struct Foo', () => {
+    AbiItem.from([
+      'struct Foo { address spender; uint256 amount; }',
+      'function approve(Foo foo) returns (bool)',
+    ])
+  })
+})
+
+describe('AbiItem.format', () => {
+  bench('function transfer(address to, uint256 amount)', () => {
+    AbiItem.format(lastFn)
+  })
+})

package/src/core/AbiItem.ts

@@ -1,14 +1,21 @@
-import * as abitype from 'abitype'
 import type * as Abi from './Abi.js'
 import * as Errors from './Errors.js'
 import * as Hash from './Hash.js'
 import * as Hex from './Hex.js'
+import * as formatAbiItem from './internal/human-readable/formatAbiItem.js'
+import * as parseAbiItem from './internal/human-readable/parseAbiItem.js'
 import * as internal from './internal/abiItem.js'
 import type { UnionCompute } from './internal/types.js'
 
 /** Root type for an item on an {@link ox#Abi.Abi}. */
 export type AbiItem = Abi.Abi[number]
 
+export {
+  InvalidAbiItemError,
+  UnknownSolidityTypeError,
+  UnknownTypeError,
+} from './internal/human-readable/errors.js'
+
 /**
  * Extracts an {@link ox#AbiItem.AbiItem} item from an {@link ox#Abi.Abi}, given a name.
  *
@@ -89,11 +96,14 @@ export type ExtractNames<abi extends Abi.Abi> = Extract<
  */
 export function format<const abiItem extends AbiItem>(
   abiItem: abiItem | AbiItem,
-): abitype.FormatAbiItem<abiItem> {
-  return abitype.formatAbiItem(abiItem) as never
+): format.ReturnType<abiItem> {
+  return formatAbiItem.formatAbiItem(abiItem) as never
 }
 
 export declare namespace format {
+  type ReturnType<abiItem extends AbiItem = AbiItem> =
+    formatAbiItem.FormatAbiItem<abiItem>
+
   type ErrorType = Errors.GlobalErrorType
 }
 
@@ -178,9 +188,9 @@ export function from<
 ): from.ReturnType<abiItem> {
   const { prepare = true } = options
   const item = (() => {
-    if (Array.isArray(abiItem)) return abitype.parseAbiItem(abiItem)
+    if (Array.isArray(abiItem)) return parseAbiItem.parseAbiItem(abiItem)
     if (typeof abiItem === 'string')
-      return abitype.parseAbiItem(abiItem as never)
+      return parseAbiItem.parseAbiItem(abiItem as never)
     return abiItem
   })() as AbiItem
   return {
@@ -202,9 +212,9 @@ export declare namespace from {
 
   type ReturnType<abiItem extends AbiItem | string | readonly string[]> =
     abiItem extends string
-      ? abitype.ParseAbiItem<abiItem>
+      ? parseAbiItem.ParseAbiItem<abiItem>
       : abiItem extends readonly string[]
-        ? abitype.ParseAbiItem<abiItem>
+        ? parseAbiItem.ParseAbiItem<abiItem>
         : abiItem
 
   type ErrorType = Errors.GlobalErrorType
@@ -554,7 +564,7 @@ export function getSignature(
   })()
   const signature = (() => {
     if (typeof abiItem === 'string') return abiItem
-    return abitype.formatAbiItem(abiItem)
+    return formatAbiItem.formatAbiItem(abiItem)
   })()
   return internal.normalizeSignature(signature)
 }
@@ -692,8 +702,8 @@ export class AmbiguityError extends Errors.BaseError {
     super('Found ambiguous types in overloaded ABI Items.', {
       metaMessages: [
         // TODO: abitype to add support for signature-formatted ABI items.
-        `\`${x.type}\` in \`${internal.normalizeSignature(abitype.formatAbiItem(x.abiItem))}\`, and`,
-        `\`${y.type}\` in \`${internal.normalizeSignature(abitype.formatAbiItem(y.abiItem))}\``,
+        `\`${x.type}\` in \`${internal.normalizeSignature(formatAbiItem.formatAbiItem(x.abiItem))}\`, and`,
+        `\`${y.type}\` in \`${internal.normalizeSignature(formatAbiItem.formatAbiItem(y.abiItem))}\``,
         '',
         'These types encode differently and cannot be distinguished at runtime.',
         'Remove one of the ambiguous items in the ABI.',

package/src/core/AbiParameter.bench.ts

@@ -0,0 +1,35 @@
+import { bench, describe } from 'vp/test'
+import * as AbiParameter from './AbiParameter.js'
+
+const parameter = { name: 'spender', type: 'address' } as const
+const tuple = {
+  components: [
+    { name: 'spender', type: 'address' },
+    { name: 'amount', type: 'uint256' },
+  ],
+  name: 'foo',
+  type: 'tuple',
+} as const
+
+describe('AbiParameter.from', () => {
+  bench('address spender', () => {
+    AbiParameter.from('address spender')
+  })
+
+  bench('struct Foo', () => {
+    AbiParameter.from([
+      'struct Foo { address spender; uint256 amount; }',
+      'Foo foo',
+    ])
+  })
+})
+
+describe('AbiParameter.format', () => {
+  bench('address spender', () => {
+    AbiParameter.format(parameter)
+  })
+
+  bench('(address spender, uint256 amount) foo', () => {
+    AbiParameter.format(tuple)
+  })
+})

package/src/core/AbiParameter.ts

@@ -0,0 +1,126 @@
+import type * as abitype from 'abitype'
+import type * as Errors from './Errors.js'
+import * as formatAbiParameter from './internal/human-readable/formatAbiParameter.js'
+import * as parseAbiParameter from './internal/human-readable/parseAbiParameter.js'
+
+/** Root type for an ABI parameter. */
+export type AbiParameter = abitype.AbiParameter
+
+/** A parameter on an ABI event. */
+export type AbiEventParameter = abitype.AbiEventParameter
+
+export {
+  InvalidAbiParameterError,
+  InvalidAbiTypeParameterError,
+  InvalidFunctionModifierError,
+  InvalidModifierError,
+  InvalidParameterError,
+  SolidityProtectedKeywordError,
+} from './internal/human-readable/errors.js'
+export { InvalidParenthesisError } from './internal/human-readable/errors.js'
+
+/**
+ * Formats an {@link ox#AbiParameter.AbiParameter} into a **Human Readable ABI Parameter**.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const formatted = AbiParameter.format({
+ *   name: 'spender',
+ *   type: 'address'
+ * })
+ *
+ * formatted
+ * //    ^?
+ * ```
+ *
+ * @param parameter - The ABI Parameter to format.
+ * @returns The formatted ABI Parameter.
+ */
+export function format<
+  const parameter extends AbiParameter | AbiEventParameter,
+>(
+  parameter: parameter | AbiParameter | AbiEventParameter,
+): format.ReturnType<parameter> {
+  return formatAbiParameter.formatAbiParameter(parameter as parameter) as never
+}
+
+export declare namespace format {
+  type ReturnType<
+    parameter extends AbiParameter | AbiEventParameter = AbiParameter,
+  > = formatAbiParameter.FormatAbiParameter<parameter>
+
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Parses an arbitrary **JSON ABI Parameter** or **Human Readable ABI Parameter** into a typed {@link ox#AbiParameter.AbiParameter}.
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const parameter = AbiParameter.from({
+ *   name: 'spender',
+ *   type: 'address'
+ * })
+ *
+ * parameter
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Human Readable Parameters
+ *
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const parameter = AbiParameter.from('address spender')
+ *
+ * parameter
+ * //^?
+ * ```
+ *
+ * @example
+ * It is possible to specify `struct`s along with your definition:
+ *
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const parameter = AbiParameter.from([
+ *   'struct Foo { address spender; uint256 amount; }',
+ *   'Foo foo'
+ * ])
+ *
+ * parameter
+ * //^?
+ * ```
+ *
+ * @param parameter - The ABI Parameter to parse.
+ * @returns The typed ABI Parameter.
+ */
+export function from<
+  const parameter extends AbiParameter | string | readonly string[],
+>(
+  parameter: parameter | AbiParameter | string | readonly string[],
+): from.ReturnType<parameter> {
+  if (Array.isArray(parameter))
+    return parseAbiParameter.parseAbiParameter(parameter) as never
+  if (typeof parameter === 'string')
+    return parseAbiParameter.parseAbiParameter(parameter) as never
+  return parameter as never
+}
+
+export declare namespace from {
+  type ReturnType<parameter extends AbiParameter | string | readonly string[]> =
+    parameter extends string
+      ? parseAbiParameter.ParseAbiParameter<parameter>
+      : parameter extends readonly string[]
+        ? parseAbiParameter.ParseAbiParameter<parameter>
+        : parameter
+
+  type ErrorType = Errors.GlobalErrorType
+}

package/src/core/AbiParameters.bench.ts

@@ -80,3 +80,25 @@ describe('AbiParameters.decode', () => {
     AbiParameters.decode(tuple_nested, tuple_nested_encoded)
   })
 })
+
+describe('AbiParameters.from', () => {
+  bench('address spender, uint256 amount', () => {
+    AbiParameters.from('address spender, uint256 amount')
+  })
+
+  bench('struct Foo', () => {
+    AbiParameters.from([
+      'struct Foo { address spender; uint256 amount; }',
+      'Foo foo, address bar',
+    ])
+  })
+})
+
+describe('AbiParameters.format', () => {
+  bench('address spender, uint256 amount', () => {
+    AbiParameters.format([
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ])
+  })
+})