viem 0.0.1-alpha.25 → 0.0.1-alpha.26

package/src/_test/bench.ts

@@ -1,15 +0,0 @@
-import { providers } from 'ethers'
-import { JsonRpcProvider } from 'ethers@6'
-import Web3 from 'web3'
-
-import { localhost } from '../chains'
-
-export const ethersProvider = new providers.JsonRpcProvider(
-  localhost.rpcUrls.default.http[0],
-)
-
-export const ethersV6Provider = new JsonRpcProvider(
-  localhost.rpcUrls.default.http[0],
-)
-
-export const web3Provider = new Web3(localhost.rpcUrls.default.http[0])

package/src/_test/constants.ts

@@ -1,63 +0,0 @@
-import type { Hex } from '../types'
-
-export const accounts = [
-  {
-    address: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x90f79bf6eb2c4f870365e785982e1f101e93b906',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x15d34aaf54267db7d7c367839aaf71a00a2c6a65',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x976ea74026e726554db657fa54763abd0c3a0aa9',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x14dc79964da2c08b23698b3d3cc7ca32193d9955',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0x23618e81e3f5cdf7f54c3d65f7fbc0abf5b21e8f',
-    balance: 10000000000000000000000n,
-  },
-  {
-    address: '0xa0ee7a142d267c1f36714e4a8f75612f20a79720',
-    balance: 10000000000000000000000n,
-  },
-] as const
-
-export const address = {
-  burn: '0x0000000000000000000000000000000000000000',
-  usdcHolder: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
-  vitalik: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
-} as const
-
-export const initialBlockNumber = BigInt(
-  Number(process.env.VITE_ANVIL_BLOCK_NUMBER),
-)
-
-export const localHttpUrl = 'http://127.0.0.1:8545'
-export const localWsUrl = 'ws://127.0.0.1:8545'
-
-// ERC20 `transferFrom` method
-export const transfer1Data = (address: string): Hex =>
-  `0xa9059cbb000000000000000000000000${address
-    .slice(2)
-    .toLowerCase()}0000000000000000000000000000000000000000000000000000000000000001`

package/src/_test/globalSetup.ts

@@ -1,11 +0,0 @@
-import { testClient } from './utils'
-import { reset, setAutomine, setIntervalMining } from '../actions'
-
-export async function setup() {
-  await reset(testClient, {
-    blockNumber: BigInt(parseInt(process.env.VITE_ANVIL_BLOCK_NUMBER!)),
-    jsonRpcUrl: process.env.VITE_ANVIL_FORK_URL,
-  })
-  await setAutomine(testClient, false)
-  await setIntervalMining(testClient, { interval: 1 })
-}

package/src/_test/index.ts

@@ -1,25 +0,0 @@
-export {
-  wagmiContractConfig,
-  uniswapV3PositionsContractConfig,
-  usdcContractConfig,
-} from './abis'
-
-export { ethersProvider, ethersV6Provider, web3Provider } from './bench'
-
-export {
-  accounts,
-  address,
-  initialBlockNumber,
-  localHttpUrl,
-  localWsUrl,
-  transfer1Data,
-} from './constants'
-
-export {
-  createHttpServer,
-  deploy,
-  deployBAYC,
-  publicClient,
-  testClient,
-  walletClient,
-} from './utils'

package/src/_test/setup.ts

@@ -1,8 +0,0 @@
-import { beforeEach } from 'vitest'
-
-import { promiseCache, responseCache } from '../utils/promise/withCache'
-
-beforeEach(() => {
-  promiseCache.clear()
-  responseCache.clear()
-})

package/src/_test/utils.ts

@@ -1,155 +0,0 @@
-/* c8 ignore start */
-import { Abi } from 'abitype'
-import errorsExample from '../../contracts/out/ErrorsExample.sol/ErrorsExample.json'
-import {
-  deployContract,
-  DeployContractArgs,
-  getTransactionReceipt,
-  mine,
-} from '../actions'
-import { Chain, localhost, mainnet } from '../chains'
-import {
-  createPublicClient,
-  createTestClient,
-  createWalletClient,
-  custom,
-  http,
-  webSocket,
-} from '../clients'
-import { rpc } from '../utils'
-import { RpcError } from '../types/eip1193'
-import { accounts, localWsUrl } from './constants'
-import { errorsExampleABI } from './generated'
-
-import type { RequestListener } from 'http'
-import { createServer } from 'http'
-import type { AddressInfo } from 'net'
-import { baycContractConfig } from './abis'
-import { Hex } from '../types'
-
-const anvil = {
-  ...localhost,
-  contracts: mainnet.contracts,
-} as const satisfies Chain
-
-export const publicClient =
-  process.env.VITE_NETWORK_TRANSPORT_MODE === 'webSocket'
-    ? createPublicClient({
-        chain: anvil,
-        pollingInterval: 1_000,
-        transport: webSocket(localWsUrl),
-      })
-    : createPublicClient({
-        chain: anvil,
-        pollingInterval: 1_000,
-        transport: http(),
-      })
-
-export const walletClient = createWalletClient({
-  transport: custom({
-    on: (message: string, listener: (...args: any[]) => null) => {
-      if (message === 'accountsChanged') {
-        listener([accounts[0].address] as any)
-      }
-    },
-    removeListener: () => null,
-    request: async ({ method, params }: any) => {
-      if (method === 'eth_requestAccounts') {
-        return [accounts[0].address]
-      }
-      if (method === 'personal_sign') {
-        method = 'eth_sign'
-        params = [params[1], params[0]]
-      }
-      if (method === 'wallet_watchAsset') {
-        if (params[0].type === 'ERC721') {
-          throw new RpcError(-32602, 'Token type ERC721 not supported.')
-        }
-        return true
-      }
-      if (method === 'wallet_addEthereumChain') return null
-      if (method === 'wallet_switchEthereumChain') {
-        if (params[0].chainId === '0xfa') {
-          throw new RpcError(-4902, 'Unrecognized chain.')
-        }
-        return null
-      }
-      if (
-        method === 'wallet_getPermissions' ||
-        method === 'wallet_requestPermissions'
-      )
-        return [
-          {
-            invoker: 'https://example.com',
-            parentCapability: 'eth_accounts',
-            caveats: [
-              {
-                type: 'filterResponse',
-                value: ['0x0c54fccd2e384b4bb6f2e405bf5cbc15a017aafb'],
-              },
-            ],
-          },
-        ]
-
-      const { result } = await rpc.http(anvil.rpcUrls.default.http[0], {
-        body: {
-          method,
-          params,
-        },
-      })
-      return result
-    },
-  }),
-})
-
-export const testClient = createTestClient({
-  chain: anvil,
-  mode: 'anvil',
-  transport: http(),
-})
-
-export function createHttpServer(
-  handler: RequestListener,
-): Promise<{ close: () => Promise<unknown>; url: string }> {
-  const server = createServer(handler)
-
-  const closeAsync = () =>
-    new Promise((resolve, reject) =>
-      server.close((err) => (err ? reject(err) : resolve(undefined))),
-    )
-
-  return new Promise((resolve) => {
-    server.listen(() => {
-      const { port } = server.address() as AddressInfo
-      resolve({ close: closeAsync, url: `http://localhost:${port}` })
-    })
-  })
-}
-
-export async function deploy<TAbi extends Abi = Abi>(
-  args: DeployContractArgs<Chain, TAbi>,
-) {
-  const hash = await deployContract(walletClient, args)
-  await mine(testClient, { blocks: 1 })
-  const { contractAddress } = await getTransactionReceipt(publicClient, {
-    hash,
-  })
-  return { contractAddress }
-}
-
-export async function deployBAYC() {
-  return deploy({
-    ...baycContractConfig,
-    args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
-    from: accounts[0].address,
-  })
-}
-
-export async function deployErrorExample() {
-  return deploy({
-    abi: errorsExampleABI,
-    bytecode: errorsExample.bytecode.object as Hex,
-    from: accounts[0].address,
-  })
-}
-/* c8 ignore stop */

package/src/actions/ens/getEnsAddress.bench.ts

@@ -1,26 +0,0 @@
-import { bench, describe } from 'vitest'
-
-import {
-  ethersProvider,
-  ethersV6Provider,
-  publicClient,
-  web3Provider,
-} from '../../_test'
-
-import { getEnsAddress } from './getEnsAddress'
-
-describe('Get ENS Name', () => {
-  bench('viem: `getEnsAddress`', async () => {
-    await getEnsAddress(publicClient, {
-      name: 'awkweb.eth',
-    })
-  })
-
-  bench('ethers: `resolveName`', async () => {
-    await ethersProvider.resolveName('awkweb.eth')
-  })
-
-  bench('ethers@6: `resolveName`', async () => {
-    await ethersV6Provider.resolveName('awkweb.eth')
-  })
-})

package/src/actions/ens/getEnsAddress.test.ts

@@ -1,97 +0,0 @@
-import { expect, test } from 'vitest'
-import { optimism } from '../../chains'
-import { createPublicClient, http } from '../../clients'
-
-import { localHttpUrl, publicClient } from '../../_test'
-import { getEnsAddress } from './getEnsAddress'
-
-test('gets address for name', async () => {
-  await expect(
-    getEnsAddress(publicClient, { name: 'awkweb.eth' }),
-  ).resolves.toMatchInlineSnapshot(
-    '"0xA0Cf798816D4b9b9866b5330EEa46a18382f251e"',
-  )
-})
-
-test('name without address', async () => {
-  await expect(
-    getEnsAddress(publicClient, { name: 'unregistered-name.eth' }),
-  ).resolves.toMatchInlineSnapshot(
-    '"0x0000000000000000000000000000000000000000"',
-  )
-})
-
-test('custom universal resolver address', async () => {
-  await expect(
-    getEnsAddress(publicClient, {
-      name: 'awkweb.eth',
-      universalResolverAddress: '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',
-    }),
-  ).resolves.toMatchInlineSnapshot(
-    '"0xA0Cf798816D4b9b9866b5330EEa46a18382f251e"',
-  )
-})
-
-test('chain not provided', async () => {
-  await expect(
-    getEnsAddress(
-      createPublicClient({
-        transport: http(localHttpUrl),
-      }),
-      { name: 'awkweb.eth' },
-    ),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(
-    '"client chain not configured. universalResolverAddress is required."',
-  )
-})
-
-test('universal resolver contract not configured for chain', async () => {
-  await expect(
-    getEnsAddress(
-      createPublicClient({
-        chain: optimism,
-        transport: http(),
-      }),
-      { name: 'awkweb.eth' },
-    ),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Chain \\"Optimism\\" does not support contract \\"ensUniversalResolver\\".
-
-    This could be due to any of the following:
-    - The chain does not have the contract \\"ensUniversalResolver\\" configured.
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test('universal resolver contract deployed on later block', async () => {
-  await expect(
-    getEnsAddress(publicClient, { name: 'awkweb.eth', blockNumber: 14353601n }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Chain \\"Localhost\\" does not support contract \\"ensUniversalResolver\\".
-
-    This could be due to any of the following:
-    - The contract \\"ensUniversalResolver\\" was not deployed until block 16172161 (current block 14353601).
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test('invalid universal resolver address', async () => {
-  await expect(
-    getEnsAddress(publicClient, {
-      name: 'awkweb.eth',
-      universalResolverAddress: '0xecb504d39723b0be0e3a9aa33d646642d1051ee1',
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "The contract function \\"resolve\\" reverted with the following reason:
-    execution reverted
-
-    Contract:  0x0000000000000000000000000000000000000000
-    Function:  resolve(bytes name, bytes data)
-    Arguments:        (0x0661776b7765620365746800, 0x3b3b57de52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c)
-
-    Docs: https://viem.sh/docs/contract/readContract
-    Version: viem@1.0.2"
-  `)
-})

package/src/actions/ens/getEnsAddress.ts

@@ -1,122 +0,0 @@
-import { PublicClient } from '../../clients'
-import { ChainDoesNotSupportContract } from '../../errors'
-import type { Address, Prettify } from '../../types'
-import {
-  decodeFunctionResult,
-  encodeFunctionData,
-  encodeHex,
-} from '../../utils'
-import { namehash, packetToBytes } from '../../utils/ens'
-import { readContract, ReadContractArgs } from '../public'
-
-export type GetEnsAddressArgs = Prettify<
-  Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
-    /** ENS name to get address. */
-    name: string
-    /** Address of ENS Universal Resolver Contract */
-    universalResolverAddress?: Address
-  }
->
-
-/**
- * @description Gets address for ENS name.
- *
- * - Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.
- *
- * @example
- * const ensAddress = await getEnsAddress(publicClient, {
- *   name: 'wagmi-dev.eth',
- * })
- * // '0xd2135CfB216b74109775236E36d4b433F1DF507B'
- */
-export async function getEnsAddress(
-  client: PublicClient,
-  {
-    blockNumber,
-    blockTag,
-    name,
-    universalResolverAddress: universalResolverAddress_,
-  }: GetEnsAddressArgs,
-) {
-  let universalResolverAddress = universalResolverAddress_
-  if (!universalResolverAddress) {
-    if (!client.chain)
-      throw new Error(
-        'client chain not configured. universalResolverAddress is required.',
-      )
-
-    const contract = client.chain?.contracts?.ensUniversalResolver
-    if (!contract)
-      throw new ChainDoesNotSupportContract({
-        chain: client.chain,
-        contract: { name: 'ensUniversalResolver' },
-      })
-
-    if (
-      blockNumber &&
-      contract.blockCreated &&
-      contract.blockCreated > blockNumber
-    )
-      throw new ChainDoesNotSupportContract({
-        blockNumber,
-        chain: client.chain,
-        contract: {
-          name: 'ensUniversalResolver',
-          blockCreated: contract.blockCreated,
-        },
-      })
-
-    universalResolverAddress = contract.address
-  }
-
-  const res = await readContract(client, {
-    address: universalResolverAddress,
-    abi: [
-      {
-        name: 'resolve',
-        type: 'function',
-        stateMutability: 'view',
-        inputs: [
-          { name: 'name', type: 'bytes' },
-          { name: 'data', type: 'bytes' },
-        ],
-        outputs: [
-          { name: '', type: 'bytes' },
-          { name: 'address', type: 'address' },
-        ],
-      },
-    ],
-    functionName: 'resolve',
-    args: [
-      encodeHex(packetToBytes(name)),
-      encodeFunctionData({
-        abi: [
-          {
-            name: 'addr',
-            type: 'function',
-            stateMutability: 'view',
-            inputs: [{ name: 'name', type: 'bytes32' }],
-            outputs: [],
-          },
-        ],
-        functionName: 'addr',
-        args: [namehash(name)],
-      }),
-    ],
-    blockNumber,
-    blockTag,
-  })
-  return decodeFunctionResult({
-    abi: [
-      {
-        name: 'addr',
-        type: 'function',
-        stateMutability: 'view',
-        inputs: [],
-        outputs: [{ name: 'name', type: 'address' }],
-      },
-    ],
-    functionName: 'addr',
-    data: res[0],
-  })
-}

package/src/actions/ens/getEnsName.bench.ts

@@ -1,30 +0,0 @@
-import { bench, describe } from 'vitest'
-
-import {
-  ethersProvider,
-  ethersV6Provider,
-  publicClient,
-  web3Provider,
-} from '../../_test'
-
-import { getEnsName } from './getEnsName'
-
-describe('Get ENS Name', () => {
-  bench('viem: `getEnsName`', async () => {
-    await getEnsName(publicClient, {
-      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-    })
-  })
-
-  bench('ethers: `lookupAddress`', async () => {
-    await ethersProvider.lookupAddress(
-      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-    )
-  })
-
-  bench('ethers@6: `lookupAddress`', async () => {
-    await ethersV6Provider.lookupAddress(
-      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-    )
-  })
-})

package/src/actions/ens/getEnsName.test.ts

@@ -1,101 +0,0 @@
-import { expect, test } from 'vitest'
-import { localhost, mainnet, optimism } from '../../chains'
-import { createPublicClient, http } from '../../clients'
-
-import { address, localHttpUrl, publicClient } from '../../_test'
-
-import { getEnsName } from './getEnsName'
-
-test('gets primary name for address', async () => {
-  await expect(
-    getEnsName(publicClient, {
-      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-    }),
-  ).resolves.toMatchInlineSnapshot('"awkweb.eth"')
-})
-
-test('address with no primary name', async () => {
-  await expect(
-    getEnsName(publicClient, {
-      address: address.burn,
-    }),
-  ).resolves.toMatchInlineSnapshot('null')
-})
-
-test('custom universal resolver address', async () => {
-  await expect(
-    getEnsName(publicClient, {
-      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-      universalResolverAddress: '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',
-    }),
-  ).resolves.toMatchInlineSnapshot('"awkweb.eth"')
-})
-
-test('chain not provided', async () => {
-  await expect(
-    getEnsName(
-      createPublicClient({
-        transport: http(localHttpUrl),
-      }),
-      { address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e' },
-    ),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(
-    '"client chain not configured. universalResolverAddress is required."',
-  )
-})
-
-test('universal resolver contract not configured for chain', async () => {
-  await expect(
-    getEnsName(
-      createPublicClient({
-        chain: optimism,
-        transport: http(),
-      }),
-      {
-        address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-      },
-    ),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Chain \\"Optimism\\" does not support contract \\"ensUniversalResolver\\".
-
-    This could be due to any of the following:
-    - The chain does not have the contract \\"ensUniversalResolver\\" configured.
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test('universal resolver contract deployed on later block', async () => {
-  await expect(
-    getEnsName(publicClient, {
-      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-      blockNumber: 14353601n,
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Chain \\"Localhost\\" does not support contract \\"ensUniversalResolver\\".
-
-    This could be due to any of the following:
-    - The contract \\"ensUniversalResolver\\" was not deployed until block 16172161 (current block 14353601).
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test('invalid universal resolver address', async () => {
-  await expect(
-    getEnsName(publicClient, {
-      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-      universalResolverAddress: '0xecb504d39723b0be0e3a9aa33d646642d1051ee1',
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "The contract function \\"reverse\\" reverted with the following reason:
-    execution reverted
-
-    Contract:  0x0000000000000000000000000000000000000000
-    Function:  reverse(bytes reverseName)
-    Arguments:        (0x28613063663739383831366434623962393836366235333330656561343661313833383266323531650461646472077265766572736500)
-
-    Docs: https://viem.sh/docs/contract/readContract
-    Version: viem@1.0.2"
-  `)
-})