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

package/src/_test/bench.ts

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

@@ -0,0 +1,63 @@
+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/generated.ts

@@ -0,0 +1,128 @@
+// Generated by @wagmi/cli@0.1.6 on 11/02/2023 at 9:20:25 pm
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// ErrorsExample
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const errorsExampleABI = [
+  {
+    type: 'error',
+    inputs: [
+      {
+        name: 'foo',
+        internalType: 'struct ErrorsExample.Foo',
+        type: 'tuple',
+        components: [
+          { name: 'sender', internalType: 'address', type: 'address' },
+          { name: 'bar', internalType: 'uint256', type: 'uint256' },
+        ],
+      },
+      { name: 'message', internalType: 'string', type: 'string' },
+      { name: 'number', internalType: 'uint256', type: 'uint256' },
+    ],
+    name: 'ComplexError',
+  },
+  {
+    type: 'error',
+    inputs: [{ name: 'message', internalType: 'string', type: 'string' }],
+    name: 'SimpleError',
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'assertRead',
+    outputs: [],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'assertWrite',
+    outputs: [],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'complexCustomRead',
+    outputs: [],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'complexCustomWrite',
+    outputs: [],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'divideByZeroRead',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'divideByZeroWrite',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'overflowRead',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'overflowWrite',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'requireRead',
+    outputs: [],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'requireWrite',
+    outputs: [],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'revertRead',
+    outputs: [],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'revertWrite',
+    outputs: [],
+  },
+  {
+    stateMutability: 'pure',
+    type: 'function',
+    inputs: [],
+    name: 'simpleCustomRead',
+    outputs: [],
+  },
+  {
+    stateMutability: 'nonpayable',
+    type: 'function',
+    inputs: [],
+    name: 'simpleCustomWrite',
+    outputs: [],
+  },
+] as const

package/src/_test/globalSetup.ts

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

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

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

package/src/_test/utils.ts

@@ -0,0 +1,155 @@
+/* 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

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

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

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

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