feat: prepareEncodeFunctionData (#1981)

* feat: `prepareEncodeFunctionData` * chore: format * chore: exports
wevm · Mar 20, 2024 · 86b75c4 · 86b75c4
1 parent 73f80fd
commit 86b75c4
Show file tree

Hide file tree

Showing 9 changed files with 337 additions and 31 deletions.
diff --git a/.changeset/lemon-windows-kick.md b/.changeset/lemon-windows-kick.md
@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Added `prepareEncodeFunctionData`.
diff --git a/site/pages/docs/contract/encodeFunctionData.md b/site/pages/docs/contract/encodeFunctionData.md
@@ -123,6 +123,26 @@ const data = encodeFunctionData({
 })
 ```
 
+### Preparation (Performance Optimization)
+
+If you are calling the same function multiple times, you can prepare the function selector once and reuse it.
+
+```ts
+import { prepareEncodeFunctionData, encodeFunctionData } from 'viem'
+
+const transfer = prepareEncodeFunctionData({
+  abi: erc20Abi,
+  functionName: 'transfer',
+})
+
+for (const address of addresses) {
+  const data = encodeFunctionData({
+    ...transfer,
+    args: [address, 69420n],
+  })
+}
+```
+
 ## Return Value
 
 [`Hex`](/docs/glossary/types#hex)

diff --git a/src/index.test.ts b/src/index.test.ts
@@ -262,6 +262,7 @@ test('exports', () => {
       "encodeErrorResult",
       "encodeEventTopics",
       "encodeFunctionData",
+      "prepareEncodeFunctionData",
       "encodeFunctionResult",
       "parseEventLogs",
       "defineTransaction",

diff --git a/src/index.ts b/src/index.ts
@@ -1087,6 +1087,12 @@ export {
   type EncodeFunctionDataReturnType,
   encodeFunctionData,
 } from './utils/abi/encodeFunctionData.js'
+export {
+  type PrepareEncodeFunctionDataErrorType,
+  type PrepareEncodeFunctionDataParameters,
+  type PrepareEncodeFunctionDataReturnType,
+  prepareEncodeFunctionData,
+} from './utils/abi/prepareEncodeFunctionData.js'
 export {
   type EncodeFunctionResultErrorType,
   type EncodeFunctionResultParameters,

diff --git a/src/utils/abi/encodeFunctionData.test-d.ts b/src/utils/abi/encodeFunctionData.test-d.ts
@@ -2,6 +2,7 @@ import { expectTypeOf, test } from 'vitest'
 
 import { type Abi, parseAbi } from 'abitype'
 import { wagmiContractConfig } from '~test/src/abis.js'
+import type { Hex } from '../../types/misc.js'
 import {
   type EncodeFunctionDataParameters,
   encodeFunctionData,
@@ -123,7 +124,9 @@ test('single abi function, functionName not required', () => {
   })
 
   type Result = EncodeFunctionDataParameters<typeof abi>
-  expectTypeOf<Result['functionName']>().toEqualTypeOf<'approve' | undefined>()
+  expectTypeOf<Result['functionName']>().toEqualTypeOf<
+    'approve' | Hex | undefined
+  >()
 })
 
 test('multiple abi functions, functionName required', () => {
@@ -149,6 +152,7 @@ test('multiple abi functions, functionName required', () => {
     | 'tokenURI'
     | 'totalSupply'
     | 'transferFrom'
+    | Hex
   >()
 })
 

diff --git a/src/utils/abi/encodeFunctionData.test.ts b/src/utils/abi/encodeFunctionData.test.ts
@@ -1,6 +1,8 @@
 import { expect, test } from 'vitest'
 
+import { erc20Abi } from 'abitype/abis'
 import { encodeFunctionData } from './encodeFunctionData.js'
+import { prepareEncodeFunctionData } from './prepareEncodeFunctionData.js'
 
 test('foo()', () => {
   expect(
@@ -131,6 +133,34 @@ test('inferred functionName', () => {
   )
 })
 
+test('selector as functionName', () => {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: '0xa9059cbb',
+    args: ['0x0000000000000000000000000000000000000000', 69420n],
+  })
+  expect(data).toMatchInlineSnapshot(
+    `"0xa9059cbb00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010f2c"`,
+  )
+})
+
+test('prepared', () => {
+  const transfer = prepareEncodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'transfer',
+  })
+  const data_prepared = encodeFunctionData({
+    ...transfer,
+    args: ['0x0000000000000000000000000000000000000000', 69420n],
+  })
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'transfer',
+    args: ['0x0000000000000000000000000000000000000000', 69420n],
+  })
+  expect(data_prepared).toEqual(data)
+})
+
 test("errors: function doesn't exist", () => {
   expect(() =>
     encodeFunctionData({

diff --git a/src/utils/abi/encodeFunctionData.ts b/src/utils/abi/encodeFunctionData.ts
@@ -1,18 +1,12 @@
 import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
-import {
-  AbiFunctionNotFoundError,
-  type AbiFunctionNotFoundErrorType,
-} from '../../errors/abi.js'
+import type { AbiFunctionNotFoundErrorType } from '../../errors/abi.js'
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
 } from '../../types/contract.js'
 import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
-import {
-  type ToFunctionSelectorErrorType,
-  toFunctionSelector,
-} from '../hash/toFunctionSelector.js'
+import type { ToFunctionSelectorErrorType } from '../hash/toFunctionSelector.js'
 
 import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
@@ -21,15 +15,15 @@ import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
 } from './encodeAbiParameters.js'
-import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
-
-const docsPath = '/docs/contract/encodeFunctionData'
+import type { FormatAbiItemErrorType } from './formatAbiItem.js'
+import type { GetAbiItemErrorType } from './getAbiItem.js'
+import { prepareEncodeFunctionData } from './prepareEncodeFunctionData.js'
 
 export type EncodeFunctionDataParameters<
   abi extends Abi | readonly unknown[] = Abi,
   functionName extends
     | ContractFunctionName<abi>
+    | Hex
     | undefined = ContractFunctionName<abi>,
   ///
   hasFunctions = abi extends Abi
@@ -52,9 +46,9 @@ export type EncodeFunctionDataParameters<
 } & UnionEvaluate<
   IsNarrowable<abi, Abi> extends true
     ? abi['length'] extends 1
-      ? { functionName?: functionName | allFunctionNames | undefined }
-      : { functionName: functionName | allFunctionNames }
-    : { functionName?: functionName | allFunctionNames | undefined }
+      ? { functionName?: functionName | allFunctionNames | Hex | undefined }
+      : { functionName: functionName | allFunctionNames | Hex }
+    : { functionName?: functionName | allFunctionNames | Hex | undefined }
 > &
   UnionEvaluate<
     readonly [] extends allArgs
@@ -80,24 +74,20 @@ export function encodeFunctionData<
 >(
   parameters: EncodeFunctionDataParameters<abi, functionName>,
 ): EncodeFunctionDataReturnType {
-  const { abi, args, functionName } = parameters as EncodeFunctionDataParameters
+  const { args } = parameters as EncodeFunctionDataParameters
 
-  let abiItem = abi[0]
-  if (functionName) {
-    const item = getAbiItem({
-      abi,
-      args,
-      name: functionName,
-    })
-    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
-    abiItem = item
-  }
+  const { abi, functionName } = (() => {
+    if (
+      parameters.abi.length === 1 &&
+      parameters.functionName?.startsWith('0x')
+    )
+      return parameters as { abi: Abi; functionName: Hex }
+    return prepareEncodeFunctionData(parameters)
+  })()
 
-  if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, { docsPath })
+  const abiItem = abi[0]
+  const signature = functionName
 
-  const definition = formatAbiItem(abiItem)
-  const signature = toFunctionSelector(definition)
   const data =
     'inputs' in abiItem && abiItem.inputs
       ? encodeAbiParameters(abiItem.inputs, args ?? [])

diff --git a/src/utils/abi/prepareEncodeFunctionData.test.ts b/src/utils/abi/prepareEncodeFunctionData.test.ts
@@ -0,0 +1,138 @@
+import { erc20Abi } from 'abitype/abis'
+import { expect, test } from 'vitest'
+import { prepareEncodeFunctionData } from './prepareEncodeFunctionData.js'
+
+test('default', () => {
+  const prepared = prepareEncodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'transfer',
+  })
+  expect(prepared).toMatchInlineSnapshot(`
+    {
+      "abi": [
+        {
+          "inputs": [
+            {
+              "name": "recipient",
+              "type": "address",
+            },
+            {
+              "name": "amount",
+              "type": "uint256",
+            },
+          ],
+          "name": "transfer",
+          "outputs": [
+            {
+              "name": "",
+              "type": "bool",
+            },
+          ],
+          "stateMutability": "nonpayable",
+          "type": "function",
+        },
+      ],
+      "functionName": "0xa9059cbb",
+    }
+  `)
+})
+
+test('inferred functionName', () => {
+  expect(
+    prepareEncodeFunctionData({
+      abi: [
+        {
+          inputs: [
+            {
+              name: 'a',
+              type: 'uint256',
+            },
+          ],
+          name: 'bar',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ],
+      args: [1n],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "abi": [
+        {
+          "inputs": [
+            {
+              "name": "a",
+              "type": "uint256",
+            },
+          ],
+          "name": "bar",
+          "outputs": [],
+          "stateMutability": "nonpayable",
+          "type": "function",
+        },
+      ],
+      "functionName": "0x0423a132",
+    }
+  `)
+})
+
+test("errors: function doesn't exist", () => {
+  expect(() =>
+    prepareEncodeFunctionData({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ],
+      // @ts-expect-error
+      functionName: 'bar',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    [AbiFunctionNotFoundError: Function "bar" not found on ABI.
+    Make sure you are using the correct ABI and that the function exists on it.
+
+    Docs: https://viem.sh/docs/contract/encodeFunctionData
+    Version: viem@1.0.2]
+  `)
+
+  expect(() =>
+    prepareEncodeFunctionData({
+      abi: erc20Abi,
+      // @ts-expect-error
+      functionName: 'bar',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    [AbiFunctionNotFoundError: Function "bar" not found on ABI.
+    Make sure you are using the correct ABI and that the function exists on it.
+
+    Docs: https://viem.sh/docs/contract/encodeFunctionData
+    Version: viem@1.0.2]
+  `)
+})
+
+test('errors: abi item not a function', () => {
+  expect(() =>
+    // @ts-expect-error abi has no functions
+    prepareEncodeFunctionData({
+      abi: [
+        {
+          inputs: [],
+          name: 'Foo',
+          outputs: [],
+          type: 'error',
+        },
+      ],
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    [AbiFunctionNotFoundError: Function not found on ABI.
+    Make sure you are using the correct ABI and that the function exists on it.
+
+    Docs: https://viem.sh/docs/contract/encodeFunctionData
+    Version: viem@1.0.2]
+  `)
+})