viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/abi/decodeFunctionData.test.ts

@@ -0,0 +1,138 @@
+import { expect, test } from 'vitest'
+
+import { decodeFunctionData } from './decodeFunctionData'
+
+test('foo()', () => {
+  expect(
+    decodeFunctionData({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ] as const,
+      data: '0xc2985578',
+    }),
+  ).toEqual({ args: undefined, functionName: 'foo' })
+  expect(
+    decodeFunctionData({
+      abi: [
+        {
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ] as const,
+      data: '0xc2985578',
+    }),
+  ).toEqual({ args: undefined, functionName: 'foo' })
+})
+
+test('bar(uint256)', () => {
+  expect(
+    decodeFunctionData({
+      abi: [
+        {
+          inputs: [
+            {
+              internalType: 'uint256',
+              name: 'a',
+              type: 'uint256',
+            },
+          ],
+          name: 'bar',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ] as const,
+      data: '0x0423a1320000000000000000000000000000000000000000000000000000000000000001',
+    }),
+  ).toEqual({
+    args: [1n],
+    functionName: 'bar',
+  })
+})
+
+test('getVoter((uint256,bool,address,uint256))', () => {
+  expect(
+    decodeFunctionData({
+      abi: [
+        {
+          inputs: [
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'weight',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'voted',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'delegate',
+                  type: 'address',
+                },
+                {
+                  internalType: 'uint256',
+                  name: 'vote',
+                  type: 'uint256',
+                },
+              ],
+              internalType: 'struct Ballot.Voter',
+              name: 'voter',
+              type: 'tuple',
+            },
+          ],
+          name: 'getVoter',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ] as const,
+      data: '0xf37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
+    }),
+  ).toEqual({
+    args: [
+      {
+        delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+        vote: 41n,
+        voted: true,
+        weight: 69420n,
+      },
+    ],
+    functionName: 'getVoter',
+  })
+})
+
+test("errors: function doesn't exist", () => {
+  expect(() =>
+    decodeFunctionData({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ] as const,
+      data: '0xa37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Encoded function signature \\"0xa3741467\\" not found on ABI.
+    Make sure you are using the correct ABI and that the function exists on it.
+    You can look up the signature here: https://openchain.xyz/signatures?query=0xa3741467.
+
+    Docs: https://viem.sh/docs/contract/decodeFunctionData
+    Version: viem@1.0.2"
+  `)
+})

package/src/utils/abi/decodeFunctionData.ts

@@ -0,0 +1,32 @@
+import { Abi } from 'abitype'
+
+import { AbiFunctionSignatureNotFoundError } from '../../errors'
+import { Hex } from '../../types'
+import { slice } from '../data'
+import { getFunctionSignature } from '../hash'
+import { decodeAbi } from './decodeAbi'
+import { formatAbiItem } from './formatAbiItem'
+
+export type DecodeFunctionDataArgs = {
+  abi: Abi | readonly unknown[]
+  data: Hex
+}
+
+export function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs) {
+  const signature = slice(data, 0, 4)
+  const description = (abi as Abi).find(
+    (x) => signature === getFunctionSignature(formatAbiItem(x)),
+  )
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: '/docs/contract/decodeFunctionData',
+    })
+  return {
+    functionName: (description as { name: string }).name,
+    args: ('inputs' in description &&
+    description.inputs &&
+    description.inputs.length > 0
+      ? decodeAbi({ data: slice(data, 4), params: description.inputs })
+      : undefined) as readonly unknown[] | undefined,
+  }
+}

package/src/utils/abi/decodeFunctionResult.test.ts

@@ -0,0 +1,333 @@
+import { expect, test } from 'vitest'
+
+import { decodeFunctionResult } from './decodeFunctionResult'
+
+test('returns ()', () => {
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      data: '0x',
+    }),
+  ).toEqual(undefined)
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      // @ts-expect-error
+      data: '',
+    }),
+  ).toEqual(undefined)
+})
+
+test('returns (address)', () => {
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+    }),
+  ).toEqual('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
+})
+
+test('returns (Bar)', () => {
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'bar',
+          outputs: [
+            {
+              components: [
+                {
+                  components: [
+                    {
+                      internalType: 'address',
+                      name: 'sender',
+                      type: 'address',
+                    },
+                    {
+                      internalType: 'uint256',
+                      name: 'x',
+                      type: 'uint256',
+                    },
+                    {
+                      internalType: 'bool',
+                      name: 'y',
+                      type: 'bool',
+                    },
+                  ],
+                  internalType: 'struct Example.Foo',
+                  name: 'foo',
+                  type: 'tuple',
+                },
+                {
+                  internalType: 'address',
+                  name: 'sender',
+                  type: 'address',
+                },
+                {
+                  internalType: 'uint32',
+                  name: 'z',
+                  type: 'uint32',
+                },
+              ],
+              internalType: 'struct Example.Bar',
+              name: 'res',
+              type: 'tuple',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'bar',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000045',
+    }),
+  ).toEqual({
+    foo: {
+      sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+      x: 69420n,
+      y: true,
+    },
+    sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+    z: 69,
+  })
+})
+
+test('returns (Bar, string)', () => {
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'baz',
+          outputs: [
+            {
+              components: [
+                {
+                  components: [
+                    {
+                      internalType: 'address',
+                      name: 'sender',
+                      type: 'address',
+                    },
+                    {
+                      internalType: 'uint256',
+                      name: 'x',
+                      type: 'uint256',
+                    },
+                    {
+                      internalType: 'bool',
+                      name: 'y',
+                      type: 'bool',
+                    },
+                  ],
+                  internalType: 'struct Example.Foo',
+                  name: 'foo',
+                  type: 'tuple',
+                },
+                {
+                  internalType: 'address',
+                  name: 'sender',
+                  type: 'address',
+                },
+                {
+                  internalType: 'uint32',
+                  name: 'z',
+                  type: 'uint32',
+                },
+              ],
+              internalType: 'struct Example.Bar',
+              name: 'res',
+              type: 'tuple',
+            },
+            {
+              internalType: 'string',
+              name: 'bob',
+              type: 'string',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'baz',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
+    }),
+  ).toEqual([
+    {
+      foo: {
+        sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+        x: 69420n,
+        y: true,
+      },
+      sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+      z: 69,
+    },
+    'wagmi',
+  ])
+})
+
+test('overloads', () => {
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [{ internalType: 'uint256', name: 'x', type: 'uint256' }],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'uint256',
+              name: 'x',
+              type: 'uint256',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+    }),
+  ).toEqual('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
+
+  expect(
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [{ internalType: 'uint256', name: 'x', type: 'uint256' }],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'uint256',
+              name: 'x',
+              type: 'uint256',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      data: '0x0000000000000000000000000000000000000000000000000000000000000069',
+      args: [10n],
+    }),
+  ).toEqual(105n)
+})
+
+test("error: function doesn't exist", () => {
+  expect(() =>
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      // @ts-expect-error
+      functionName: 'baz',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    "Function \\"baz\\" 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/decodeFunctionResult
+    Version: viem@1.0.2"
+  `,
+  )
+})
+
+test("error: function doesn't exist", () => {
+  expect(() =>
+    decodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    "Function \\"foo\\" does not contain any \`outputs\` on ABI.
+    Cannot decode function result without knowing what the parameter types are.
+    Make sure you are using the correct ABI and that the function exists on it.
+
+    Docs: https://viem.sh/docs/contract/decodeFunctionResult
+    Version: viem@1.0.2"
+  `,
+  )
+})

package/src/utils/abi/decodeFunctionResult.ts

@@ -0,0 +1,57 @@
+import { Abi, Narrow } from 'abitype'
+import {
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+} from '../../errors'
+import {
+  ExtractArgsFromAbi,
+  ExtractFunctionNameFromAbi,
+  ExtractResultFromAbi,
+  Hex,
+} from '../../types'
+import { decodeAbi } from './decodeAbi'
+import { getAbiItem, GetAbiItemArgs } from './getAbiItem'
+
+const docsPath = '/docs/contract/decodeFunctionResult'
+
+export type DecodeFunctionResultArgs<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+> = {
+  abi: Narrow<TAbi>
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  data: Hex
+} & Partial<ExtractArgsFromAbi<TAbi, TFunctionName>>
+
+export type DecodeFunctionResultResponse<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+> = ExtractResultFromAbi<TAbi, TFunctionName>
+
+export function decodeFunctionResult<
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
+>({
+  abi,
+  args,
+  functionName,
+  data,
+}: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<
+  TAbi,
+  TFunctionName
+> {
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName,
+  } as GetAbiItemArgs)
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath })
+  if (!('outputs' in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath })
+
+  const values = decodeAbi({ data, params: description.outputs })
+  if (values && values.length > 1) return values as any
+  if (values && values.length === 1) return values[0] as any
+  return undefined as any
+}