viem 0.0.1-alpha.24 → 0.0.1-alpha.26

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

@@ -1,279 +0,0 @@
-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',
-    }),
-  ).toEqual('0x')
-})
-
-test('returns (address)', () => {
-  expect(
-    encodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'address',
-              name: 'sender',
-              type: 'address',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      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',
-        },
-      ],
-      // @ts-expect-error
-      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: [
-        {
-          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

@@ -1,41 +0,0 @@
-import { Abi, ExtractAbiFunctionNames, Narrow } 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 | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = {
-  abi: Narrow<TAbi>
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  result?: ExtractResultFromAbi<TAbi, TFunctionName>
-}
-
-export function encodeFunctionResult<
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
->({
-  abi,
-  functionName,
-  result,
-}: EncodeFunctionResultArgs<TAbi, TFunctionName>) {
-  const description = (abi as 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

@@ -1,335 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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}` : '')
-}