chore: perf tweaks

Author: tmm

.github/workflows/verify.yml

@@ -50,7 +50,7 @@ jobs:
     timeout-minutes: 5
     strategy:
       matrix:
-        version: ['5.0.4', '5.1.6', '5.2.2', '5.3.3', '5.4.5', '5.5.4', '5.6.3', '5.7.3', '5.8.3', '5.9.3', 'latest']
+        version: ['5.0.4', '5.2.2', '5.3.3', '5.4.5', '5.5.4', '5.6.3', '5.7.3', '5.8.3', '5.9.3', 'latest']
 
     steps:
       - name: Clone repository

packages/abitype/src/abi.ts

@@ -248,6 +248,7 @@ export type TypedData = Pretty<
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// update lookup with `pnpm node scripts/genAbiParameterNameLookup.ts`
 // biome-ignore format: no formatting
 export interface AbiParameterTupleNameLookup<type> extends Record<string, [type]> {
   _data: [_data: type]
@@ -262,62 +263,88 @@ export interface AbiParameterTupleNameLookup<type> extends Record<string, [type]
   amount: [amount: type]
   approved: [approved: type]
   approver: [approver: type]
+  ask: [ask: type]
+  asset: [asset: type]
   assets: [assets: type]
   authority: [authority: type]
   available: [available: type]
   b: [b: type]
   balance: [balance: type]
+  bid: [bid: type]
+  buffer: [buffer: type]
   c: [c: type]
+  call: [call: type]
   callData: [callData: type]
   caller: [caller: type]
   calls: [calls: type]
+  clone: [clone: type]
   coinType: [coinType: type]
   count: [count: type]
   currency: [currency: type]
   d: [d: type]
   data: [data: type]
   deadline: [deadline: type]
+  decimals: [decimals: type]
+  dest: [dest: type]
+  divisor: [divisor: type]
   dns: [dns: type]
   dst: [dst: type]
   e: [e: type]
+  endTime: [endTime: type]
   ens: [ens: type]
   errorData: [errorData: type]
   f: [f: type]
   failures: [failures: type]
   from: [from: type]
   funder: [funder: type]
   g: [g: type]
+  gateway: [gateway: type]
   gateways: [gateways: type]
   guy: [guy: type]
   h: [h: type]
   hash: [hash: type]
+  hashes: [hashes: type]
   i: [i: type]
   id: [id: type]
   ids: [ids: type]
   idsLength: [idsLength: type]
+  implementation: [implementation: type]
+  index: [index: type]
   interfaceId: [interfaceId: type]
   j: [j: type]
   k: [k: type]
   key: [key: type]
   l: [l: type]
   label: [label: type]
+  length: [length: type]
+  limit: [limit: type]
   m: [m: type]
+  market: [market: type]
   memo: [memo: type]
   message: [message: type]
   n: [n: type]
   name: [name: type]
   needed: [needed: type]
+  new: [new: type]
+  next: [next: type]
+  nextOwner: [nextOwner: type]
   node: [node: type]
   nonce: [nonce: type]
   nonceKey: [nonceKey: type]
+  numerator: [numerator: type]
   o: [o: type]
+  offerer: [offerer: type]
+  old: [old: type]
   operator: [operator: type]
   order: [order: type]
   orders: [orders: type]
   owner: [owner: type]
   p: [p: type]
   policyId: [policyId: type]
   policyType: [policyType: type]
+  previous: [previous: type]
+  previousOwner: [previousOwner: type]
+  price: [price: type]
   primary: [primary: type]
   proposer: [proposer: type]
   q: [q: type]
@@ -342,7 +369,9 @@ export interface AbiParameterTupleNameLookup<type> extends Record<string, [type]
   shares: [shares: type]
   signature: [signature: type]
   signer: [signer: type]
+  source: [source: type]
   src: [src: type]
+  startTime: [startTime: type]
   status: [status: type]
   success: [success: type]
   symbol: [symbol: type]
@@ -363,7 +392,9 @@ export interface AbiParameterTupleNameLookup<type> extends Record<string, [type]
   version: [version: type]
   w: [w: type]
   wad: [wad: type]
+  weth: [weth: type]
   x: [x: type]
   y: [y: type]
   z: [z: type]
+  zone: [zone: type]
 }

packages/abitype/src/utils.bench-d.ts

@@ -274,14 +274,14 @@ type transferFrom = ExtractAbiFunction<
 >['inputs']
 test('basic without named tuple', () => {
   const res = {} as AbiParametersToPrimitiveTypes<transferFrom, 'inputs', false>
-  attest.instantiations([917, 'instantiations'])
+  attest.instantiations([906, 'instantiations'])
   attest<
     readonly [sender: `0x${string}`, recipient: `0x${string}`, amount: bigint]
   >(res)
 })
 test('basic with named tuple', () => {
   const res = {} as AbiParametersToPrimitiveTypes<transferFrom, 'inputs', true>
-  attest.instantiations([1172, 'instantiations'])
+  attest.instantiations([1131, 'instantiations'])
   attest<
     readonly [sender: `0x${string}`, recipient: `0x${string}`, amount: bigint]
   >(res)
@@ -311,9 +311,9 @@ type parameters = readonly [
 ]
 test('without named tuples', () => {
   ;({}) as AbiParametersToPrimitiveTypes<parameters, 'inputs', false>
-  attest.instantiations([1286, 'instantiations'])
+  attest.instantiations([1276, 'instantiations'])
 })
 test('with named tuples', () => {
   ;({}) as AbiParametersToPrimitiveTypes<parameters, 'inputs', true>
-  attest.instantiations([3800, 'instantiations'])
+  attest.instantiations([1998, 'instantiations'])
 })

packages/abitype/src/utils.test-d.ts

@@ -1,6 +1,6 @@
 import { assertType, describe, expectTypeOf, test } from 'vitest'
 
-import type { Abi } from './abi.js'
+import type { Abi, AbiParameterKind } from './abi.js'
 import type {
   customSolidityErrorsAbi,
   ensRegistryWithFallbackAbi,
@@ -424,36 +424,63 @@ describe('AbiParameterToPrimitiveType', () => {
 
 describe('AbiParametersToPrimitiveTypes', () => {
   test('no parameters', () => {
-    type Result = AbiParametersToPrimitiveTypes<[]>
-    assertType<Result>([])
+    type r1 = AbiParametersToPrimitiveTypes<[]>
+    assertType<r1>([])
+    type r2 = AbiParametersToPrimitiveTypes<[], AbiParameterKind, true>
+    assertType<r2>([])
   })
 
   test('single parameter', () => {
-    type Result = AbiParametersToPrimitiveTypes<
+    type r1 = AbiParametersToPrimitiveTypes<
       [
         {
           name: 'tokenId'
           type: 'uint8[2]'
         },
       ]
     >
-    assertType<Result>([[1, 1]])
+    assertType<r1>([[1, 1]])
     //          ^?
+    type r2 = AbiParametersToPrimitiveTypes<
+      [
+        {
+          name: 'tokenId'
+          type: 'uint8[2]'
+        },
+      ],
+      AbiParameterKind,
+      true
+    >
+    expectTypeOf<r2>().toEqualTypeOf<
+      readonly [tokenId: readonly [number, number]]
+    >()
   })
 
   test('multiple parameters', () => {
-    type Result = AbiParametersToPrimitiveTypes<
+    type r1 = AbiParametersToPrimitiveTypes<
       [
         { name: 'to'; type: 'address' },
         { name: 'tokenId'; type: 'uint256' },
         { name: 'trait'; type: 'string[]' },
       ]
     >
-    assertType<Result>([zeroAddress, 1n, ['foo']])
+    assertType<r1>([zeroAddress, 1n, ['foo']])
+    type r2 = AbiParametersToPrimitiveTypes<
+      [
+        { name: 'to'; type: 'address' },
+        { name: 'tokenId'; type: 'uint256' },
+        { name: 'trait'; type: 'string[]' },
+      ],
+      AbiParameterKind,
+      true
+    >
+    expectTypeOf<r2>().toEqualTypeOf<
+      readonly [to: `0x${string}`, tokenId: bigint, readonly string[]]
+    >()
   })
 
   test('deeply nested parameters', () => {
-    type Result = AbiParametersToPrimitiveTypes<
+    type r1 = AbiParametersToPrimitiveTypes<
       [
         {
           name: 's'
@@ -490,7 +517,55 @@ describe('AbiParametersToPrimitiveTypes', () => {
         },
       ]
     >
-    assertType<Result>([
+    assertType<r1>([
+      { a: 1, b: [2], c: [{ x: 1, y: 1 }] },
+      { x: 1, y: 1 },
+      1,
+      [
+        { x: 1n, y: 1n },
+        { x: 1n, y: 1n },
+      ],
+    ])
+    type r2 = AbiParametersToPrimitiveTypes<
+      [
+        {
+          name: 's'
+          type: 'tuple'
+          components: [
+            { name: 'a'; type: 'uint8' },
+            { name: 'b'; type: 'uint8[]' },
+            {
+              name: 'c'
+              type: 'tuple[]'
+              components: [
+                { name: 'x'; type: 'uint8' },
+                { name: 'y'; type: 'uint8' },
+              ]
+            },
+          ]
+        },
+        {
+          name: 't'
+          type: 'tuple'
+          components: [
+            { name: 'x'; type: 'uint8' },
+            { name: 'y'; type: 'uint8' },
+          ]
+        },
+        { name: 'a'; type: 'uint8' },
+        {
+          name: 't'
+          type: 'tuple[2]'
+          components: [
+            { name: 'x'; type: 'uint256' },
+            { name: 'y'; type: 'uint256' },
+          ]
+        },
+      ],
+      AbiParameterKind,
+      true
+    >
+    assertType<r2>([
       { a: 1, b: [2], c: [{ x: 1, y: 1 }] },
       { x: 1, y: 1 },
       1,
@@ -514,14 +589,20 @@ describe('AbiParametersToPrimitiveTypes', () => {
     assertType<AbiParametersToPrimitiveTypes<typeof parameters, 'outputs'>>([
       '0xfoo',
     ])
-    assertType<AbiParametersToPrimitiveTypes<typeof parameters, 'outputs'>>([
-      '0xfoo',
-    ])
+    assertType<
+      AbiParametersToPrimitiveTypes<typeof parameters, 'inputs', true>
+    >(['0xfoo'])
+    assertType<
+      AbiParametersToPrimitiveTypes<typeof parameters, 'outputs', true>
+    >(['0xfoo'])
   })
 
   test('named parameters', () => {
     type Result = AbiParametersToPrimitiveTypes<
-      ExtractAbiFunction<typeof erc20Abi, 'transferFrom'>['inputs']
+      // ^?
+      ExtractAbiFunction<typeof erc20Abi, 'transferFrom'>['inputs'],
+      'inputs',
+      true
     >
     expectTypeOf<Result>().toEqualTypeOf<
       readonly [sender: `0x${string}`, recipient: `0x${string}`, amount: bigint]