viem 0.0.1-alpha.2 → 0.0.1-alpha.21

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

@@ -0,0 +1,284 @@
+import { expect, test } from 'vitest'
+
+import { encodeFunctionResult } from './encodeFunctionResult'
+
+test('returns ()', () => {
+  expect(
+    encodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      result: undefined,
+    }),
+  ).toEqual('0x')
+  expect(
+    encodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      result: [undefined],
+    }),
+  ).toEqual('0x')
+  expect(
+    encodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      result: [],
+    }),
+  ).toEqual('0x')
+})
+
+test('returns (address)', () => {
+  expect(
+    encodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ] as const,
+      functionName: 'foo',
+      result: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+    }),
+  ).toEqual(
+    '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+  )
+})
+
+test('returns (Bar)', () => {
+  expect(
+    encodeFunctionResult({
+      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',
+      result: [
+        {
+          foo: {
+            sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+            x: 69420n,
+            y: true,
+          },
+          sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          z: 69,
+        },
+      ],
+    }),
+  ).toEqual(
+    '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000045',
+  )
+})
+
+test('returns (Bar, string)', () => {
+  expect(
+    encodeFunctionResult({
+      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',
+      result: [
+        {
+          foo: {
+            sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+            x: 69420n,
+            y: true,
+          },
+          sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          z: 69,
+        },
+        'wagmi',
+      ],
+    }),
+  ).toEqual(
+    '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
+  )
+})
+
+test("error: function doesn't exist", () => {
+  expect(() =>
+    encodeFunctionResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'foo',
+          outputs: [
+            {
+              internalType: 'address',
+              name: 'sender',
+              type: 'address',
+            },
+          ],
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'baz',
+      result: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'],
+    }),
+  ).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/encodeFunctionResult
+
+    Version: viem@1.0.2"
+  `,
+  )
+})
+
+test("error: function doesn't exist", () => {
+  expect(() =>
+    encodeFunctionResult({
+      abi: [
+        // @ts-expect-error
+        {
+          inputs: [],
+          name: 'foo',
+          stateMutability: 'pure',
+          type: 'function',
+        },
+      ],
+      functionName: 'foo',
+      result: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'],
+    }),
+  ).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/encodeFunctionResult
+
+    Version: viem@1.0.2"
+  `,
+  )
+})

package/src/utils/abi/encodeFunctionResult.ts

@@ -0,0 +1,39 @@
+import { Abi, ExtractAbiFunctionNames } from 'abitype'
+import {
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+} from '../../errors'
+
+import { ExtractFunctionNameFromAbi, ExtractResultFromAbi } from '../../types'
+import { encodeAbi } from './encodeAbi'
+
+const docsPath = '/docs/contract/encodeFunctionResult'
+
+export type EncodeFunctionResultArgs<
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+> = {
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  result?: ExtractResultFromAbi<TAbi, TFunctionName>
+}
+
+export function encodeFunctionResult<
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>({
+  abi,
+  functionName,
+  result,
+}: EncodeFunctionResultArgs<TAbi, TFunctionName>) {
+  const description = abi.find((x) => 'name' in x && x.name === functionName)
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath })
+  if (!('outputs' in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath })
+
+  let values = Array.isArray(result) ? result : [result]
+  if (description.outputs.length === 0 && !values[0]) values = []
+
+  return encodeAbi({ params: description.outputs, values })
+}

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

@@ -0,0 +1,335 @@
+import { expect, test } from 'vitest'
+
+import { formatAbiItem } from './formatAbiItem'
+
+test('foo()', () => {
+  expect(
+    // @ts-expect-error
+    formatAbiItem({
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo()')
+  expect(
+    formatAbiItem({
+      inputs: [],
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo()')
+})
+
+test('foo(uint256)', () => {
+  expect(
+    formatAbiItem({
+      inputs: [
+        {
+          internalType: 'uint256',
+          name: 'a',
+          type: 'uint256',
+        },
+      ],
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo(uint256)')
+  expect(
+    formatAbiItem(
+      {
+        inputs: [
+          {
+            internalType: 'uint256',
+            name: 'a',
+            type: 'uint256',
+          },
+        ],
+        name: 'foo',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+      },
+      { includeName: true },
+    ),
+  ).toEqual('foo(uint256 a)')
+})
+
+test('getVoter((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItem({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'getVoter',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('getVoter((uint256,bool,address,uint256),string[],bytes)')
+  expect(
+    formatAbiItem(
+      {
+        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',
+          },
+          {
+            internalType: 'string[]',
+            name: 'foo',
+            type: 'string[]',
+          },
+          {
+            internalType: 'bytes',
+            name: 'bar',
+            type: 'bytes',
+          },
+        ],
+        name: 'getVoter',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+      },
+      { includeName: true },
+    ),
+  ).toEqual(
+    'getVoter((uint256 weight, bool voted, address delegate, uint256 vote), string[] foo, bytes bar)',
+  )
+})
+
+test('VoterEvent((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItem({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'VoterEvent',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'event',
+    }),
+  ).toEqual('VoterEvent((uint256,bool,address,uint256),string[],bytes)')
+  expect(
+    formatAbiItem(
+      {
+        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',
+          },
+          {
+            internalType: 'string[]',
+            name: 'foo',
+            type: 'string[]',
+          },
+          {
+            internalType: 'bytes',
+            name: 'bar',
+            type: 'bytes',
+          },
+        ],
+        name: 'VoterEvent',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'event',
+      },
+      { includeName: true },
+    ),
+  ).toEqual(
+    'VoterEvent((uint256 weight, bool voted, address delegate, uint256 vote), string[] foo, bytes bar)',
+  )
+})
+
+test('VoterError((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItem({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'VoterError',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'error',
+    }),
+  ).toEqual('VoterError((uint256,bool,address,uint256),string[],bytes)')
+})
+
+test('error: invalid type', () => {
+  expect(() =>
+    formatAbiItem({
+      inputs: [
+        {
+          internalType: 'bytes32[]',
+          name: 'proposalNames',
+          type: 'bytes32[]',
+        },
+      ],
+      stateMutability: 'nonpayable',
+      type: 'constructor',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "\\"constructor\\" is not a valid definition type.
+    Valid types: \\"function\\", \\"event\\", \\"error\\"
+
+    Version: viem@1.0.2"
+  `)
+})

package/src/utils/abi/formatAbiItem.ts

@@ -0,0 +1,41 @@
+import { AbiParameter } from 'abitype'
+
+import { InvalidDefinitionTypeError } from '../../errors'
+import { AbiItem } from '../../types'
+
+export function formatAbiItem(
+  abiItem: AbiItem,
+  { includeName = false }: { includeName?: boolean } = {},
+) {
+  if (
+    abiItem.type !== 'function' &&
+    abiItem.type !== 'event' &&
+    abiItem.type !== 'error'
+  )
+    throw new InvalidDefinitionTypeError(abiItem.type)
+
+  return `${abiItem.name}(${getParams(abiItem.inputs, { includeName })})`
+}
+
+function getParams(
+  params: readonly AbiParameter[] | undefined,
+  { includeName }: { includeName: boolean },
+): string {
+  if (!params) return ''
+  return params
+    .map((param) => getParam(param, { includeName }))
+    .join(includeName ? ', ' : ',')
+}
+
+function getParam(
+  param: AbiParameter,
+  { includeName }: { includeName: boolean },
+): string {
+  if (param.type.startsWith('tuple')) {
+    return `(${getParams(
+      (param as unknown as { components: AbiParameter[] }).components,
+      { includeName },
+    )})${param.type.slice('tuple'.length)}`
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : '')
+}