viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/_test/bench.ts

@@ -0,0 +1,15 @@
+import { providers } from 'ethers'
+import Web3 from 'web3'
+import { JsonRpcProvider } from 'essential-eth'
+
+import { localhost } from '../chains'
+
+export const ethersProvider = new providers.JsonRpcProvider(
+  localhost.rpcUrls.default.http[0],
+)
+
+export const web3Provider = new Web3(localhost.rpcUrls.default.http[0])
+
+export const essentialProvider = new JsonRpcProvider(
+  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 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`
+
+// vitalik.eth
+export const vitalikAddress = '0xd8da6bf26964af9d7eed9e03e53415d37aa96045'
+
+// USDC ERC20 contract
+export const usdcAddress = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'

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,20 @@
+export { wagmiContractConfig } from './abis'
+
+export { essentialProvider, ethersProvider, web3Provider } from './bench'
+
+export {
+  accounts,
+  initialBlockNumber,
+  localHttpUrl,
+  localWsUrl,
+  transfer1Data,
+  usdcAddress,
+  vitalikAddress,
+} from './constants'
+
+export {
+  createHttpServer,
+  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,112 @@
+/* c8 ignore start */
+import { localhost } 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 type { RequestListener } from 'http'
+import { createServer } from 'http'
+import type { AddressInfo } from 'net'
+
+export const publicClient =
+  process.env.VITE_NETWORK_TRANSPORT_MODE === 'webSocket'
+    ? createPublicClient({
+        chain: localhost,
+        pollingInterval: 1_000,
+        transport: webSocket(localWsUrl),
+      })
+    : createPublicClient({
+        chain: localhost,
+        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(localhost.rpcUrls.default.http[0], {
+        body: {
+          method,
+          params,
+        },
+      })
+      return result
+    },
+  }),
+})
+
+export const testClient = createTestClient({
+  chain: localhost,
+  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}` })
+    })
+  })
+}
+/* c8 ignore stop */

package/src/actions/index.test.ts

@@ -0,0 +1,72 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "addChain": [Function],
+      "call": [Function],
+      "callContract": [Function],
+      "createBlockFilter": [Function],
+      "createPendingTransactionFilter": [Function],
+      "deployContract": [Function],
+      "dropTransaction": [Function],
+      "estimateGas": [Function],
+      "getAccounts": [Function],
+      "getAutomine": [Function],
+      "getBalance": [Function],
+      "getBlock": [Function],
+      "getBlockNumber": [Function],
+      "getBlockNumberCache": [Function],
+      "getBlockTransactionCount": [Function],
+      "getBytecode": [Function],
+      "getChainId": [Function],
+      "getFeeHistory": [Function],
+      "getFilterChanges": [Function],
+      "getFilterLogs": [Function],
+      "getGasPrice": [Function],
+      "getPermissions": [Function],
+      "getTransaction": [Function],
+      "getTransactionConfirmations": [Function],
+      "getTransactionCount": [Function],
+      "getTransactionReceipt": [Function],
+      "getTxpoolContent": [Function],
+      "getTxpoolStatus": [Function],
+      "impersonateAccount": [Function],
+      "increaseTime": [Function],
+      "inspectTxpool": [Function],
+      "mine": [Function],
+      "removeBlockTimestampInterval": [Function],
+      "requestAccounts": [Function],
+      "requestPermissions": [Function],
+      "reset": [Function],
+      "revert": [Function],
+      "sendTransaction": [Function],
+      "sendUnsignedTransaction": [Function],
+      "setAutomine": [Function],
+      "setBalance": [Function],
+      "setBlockGasLimit": [Function],
+      "setBlockTimestampInterval": [Function],
+      "setCode": [Function],
+      "setCoinbase": [Function],
+      "setIntervalMining": [Function],
+      "setLoggingEnabled": [Function],
+      "setMinGasPrice": [Function],
+      "setNextBlockBaseFeePerGas": [Function],
+      "setNextBlockTimestamp": [Function],
+      "setNonce": [Function],
+      "setStorageAt": [Function],
+      "signMessage": [Function],
+      "snapshot": [Function],
+      "stopImpersonatingAccount": [Function],
+      "switchChain": [Function],
+      "uninstallFilter": [Function],
+      "waitForTransactionReceipt": [Function],
+      "watchAsset": [Function],
+      "watchBlockNumber": [Function],
+      "watchBlocks": [Function],
+      "watchPendingTransactions": [Function],
+    }
+  `)
+})

package/src/actions/index.ts

@@ -0,0 +1,156 @@
+export {
+  call,
+  callContract,
+  createBlockFilter,
+  createPendingTransactionFilter,
+  deployContract,
+  estimateGas,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockNumberCache,
+  getBlockTransactionCount,
+  getBytecode,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getFilterLogs,
+  getGasPrice,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchPendingTransactions,
+} from './public'
+export type {
+  CallArgs,
+  CallContractArgs,
+  CallContractResponse,
+  CallResponse,
+  CreateBlockFilterResponse,
+  CreatePendingTransactionFilterResponse,
+  DeployContractArgs,
+  DeployContractResponse,
+  EstimateGasArgs,
+  EstimateGasResponse,
+  GetBalanceArgs,
+  GetBalanceResponse,
+  GetBlockArgs,
+  GetBlockNumberArgs,
+  GetBlockNumberResponse,
+  GetBlockResponse,
+  GetBlockTransactionCountArgs,
+  GetBlockTransactionCountResponse,
+  GetBytecodeArgs,
+  GetBytecodeResponse,
+  GetFeeHistoryArgs,
+  GetFeeHistoryResponse,
+  GetFilterChangesArgs,
+  GetFilterChangesResponse,
+  GetFilterLogsArgs,
+  GetFilterLogsResponse,
+  GetGasPriceResponse,
+  GetTransactionArgs,
+  GetTransactionConfirmationsArgs,
+  GetTransactionConfirmationsResponse,
+  GetTransactionCountArgs,
+  GetTransactionCountResponse,
+  GetTransactionReceiptArgs,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  OnBlock,
+  OnBlockNumber,
+  OnBlockNumberResponse,
+  OnBlockResponse,
+  OnTransactions,
+  OnTransactionsResponse,
+  ReplacementReason,
+  ReplacementResponse,
+  UninstallFilterArgs,
+  UninstallFilterResponse,
+  WaitForTransactionReceiptArgs,
+  WaitForTransactionReceiptResponse,
+  WatchBlockNumberArgs,
+  WatchBlocksArgs,
+  WatchPendingTransactionsArgs,
+} from './public'
+
+export {
+  dropTransaction,
+  getAutomine,
+  getTxpoolContent,
+  getTxpoolStatus,
+  impersonateAccount,
+  increaseTime,
+  inspectTxpool,
+  mine,
+  removeBlockTimestampInterval,
+  reset,
+  revert,
+  sendUnsignedTransaction,
+  setAutomine,
+  setBalance,
+  setBlockGasLimit,
+  setBlockTimestampInterval,
+  setCode,
+  setCoinbase,
+  setIntervalMining,
+  setLoggingEnabled,
+  setMinGasPrice,
+  setNextBlockBaseFeePerGas,
+  setNextBlockTimestamp,
+  setNonce,
+  setStorageAt,
+  snapshot,
+  stopImpersonatingAccount,
+} from './test'
+export type {
+  DropTransactionArgs,
+  ImpersonateAccountArgs,
+  IncreaseTimeArgs,
+  MineArgs,
+  ResetArgs,
+  RevertArgs,
+  SendUnsignedTransactionArgs,
+  SendUnsignedTransactionResponse,
+  SetBalanceArgs,
+  SetBlockGasLimitArgs,
+  SetBlockTimestampIntervalArgs,
+  SetCodeArgs,
+  SetCoinbaseArgs,
+  SetIntervalMiningArgs,
+  SetMinGasPriceArgs,
+  SetNextBlockBaseFeePerGasArgs,
+  SetNextBlockTimestampArgs,
+  SetNonceArgs,
+  SetStorageAtArgs,
+  StopImpersonatingAccountArgs,
+} from './test'
+
+export {
+  addChain,
+  getAccounts,
+  getPermissions,
+  requestAccounts,
+  requestPermissions,
+  sendTransaction,
+  signMessage,
+  switchChain,
+  watchAsset,
+} from './wallet'
+export type {
+  FormattedTransactionRequest,
+  GetPermissionsResponse,
+  RequestPermissionsResponse,
+  SendTransactionArgs,
+  SendTransactionResponse,
+  SignMessageArgs,
+  SignMessageResponse,
+  SwitchChainArgs,
+  WatchAssetArgs,
+  WatchAssetResponse,
+} from './wallet'

package/src/actions/public/call.bench.ts

@@ -0,0 +1,48 @@
+import { bench, describe } from 'vitest'
+
+import {
+  accounts,
+  essentialProvider,
+  ethersProvider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+
+import { call } from './call'
+
+const wagmiContractAddress = '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2'
+const name4bytes = '0x06fdde03'
+
+describe('Call', () => {
+  bench('viem: `call`', async () => {
+    await call(publicClient, {
+      data: name4bytes,
+      from: accounts[0].address,
+      to: wagmiContractAddress,
+    })
+  })
+
+  bench('ethers: `call`', async () => {
+    await ethersProvider.call({
+      data: name4bytes,
+      from: accounts[0].address,
+      to: wagmiContractAddress,
+    })
+  })
+
+  bench('web3.js: `call`', async () => {
+    await web3Provider.eth.call({
+      data: name4bytes,
+      from: accounts[0].address,
+      to: wagmiContractAddress,
+    })
+  })
+
+  bench('essential-eth: `call`', async () => {
+    await essentialProvider.call({
+      data: name4bytes,
+      from: accounts[0].address,
+      to: wagmiContractAddress,
+    })
+  })
+})

package/src/actions/public/call.test.ts

@@ -0,0 +1,99 @@
+import { expect, test } from 'vitest'
+
+import { accounts, publicClient } from '../../_test'
+import { celo } from '../../chains'
+import { createPublicClient, http } from '../../clients'
+import { numberToHex, parseGwei } from '../../utils'
+
+import { call } from './call'
+
+const wagmiContractAddress = '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2'
+const name4bytes = '0x06fdde03'
+const mint4bytes = '0x1249c58b'
+const mintWithParams4bytes = '0xa0712d68'
+const fourTwenty =
+  '00000000000000000000000000000000000000000000000000000000000001a4'
+
+const sourceAccount = accounts[0]
+
+test('default', async () => {
+  const { data } = await call(publicClient, {
+    data: name4bytes,
+    from: sourceAccount.address,
+    to: wagmiContractAddress,
+  })
+  expect(data).toMatchInlineSnapshot(
+    '"0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000"',
+  )
+})
+
+test('custom formatter', async () => {
+  const client = createPublicClient({
+    chain: celo,
+    transport: http(),
+  })
+
+  const { data } = await call(client, {
+    chain: celo,
+    gatewayFee: numberToHex(1n),
+    data: name4bytes,
+    from: sourceAccount.address,
+    to: wagmiContractAddress,
+  })
+  expect(data).toBeUndefined()
+})
+
+test('zero data', async () => {
+  const { data } = await call(publicClient, {
+    data: mint4bytes,
+    from: sourceAccount.address,
+    to: wagmiContractAddress,
+  })
+  expect(data).toMatchInlineSnapshot('undefined')
+})
+
+test('args: blockNumber', async () => {
+  const { data } = await call(publicClient, {
+    blockNumber: 15564164n,
+    data: `${mintWithParams4bytes}${fourTwenty}`,
+    from: sourceAccount.address,
+    to: wagmiContractAddress,
+  })
+  expect(data).toMatchInlineSnapshot('undefined')
+})
+
+test('errors: maxFeePerGas less than maxPriorityFeePerGas', async () => {
+  await expect(
+    call(publicClient, {
+      data: `${mintWithParams4bytes}${fourTwenty}`,
+      from: sourceAccount.address,
+      to: wagmiContractAddress,
+      maxFeePerGas: parseGwei('20'),
+      maxPriorityFeePerGas: parseGwei('22'),
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "\`maxFeePerGas\` cannot be less than \`maxPriorityFeePerGas\`
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('errors: contract revert (contract error)', async () => {
+  await expect(
+    call(publicClient, {
+      data: `${mintWithParams4bytes}${fourTwenty}`,
+      from: sourceAccount.address,
+      to: wagmiContractAddress,
+    }),
+  ).rejects.toThrowError('execution reverted: Token ID is taken')
+})
+
+test('errors: contract revert (insufficient params)', async () => {
+  await expect(
+    call(publicClient, {
+      data: mintWithParams4bytes,
+      from: sourceAccount.address,
+      to: wagmiContractAddress,
+    }),
+  ).rejects.toThrowError('execution reverted')
+})

package/src/actions/public/call.ts

@@ -0,0 +1,96 @@
+import type { Chain, Formatter } from '../../chains'
+import type { PublicClient } from '../../clients'
+import { InvalidGasArgumentsError } from '../../errors'
+import type {
+  Address,
+  BlockTag,
+  Hex,
+  MergeIntersectionProperties,
+  TransactionRequest,
+} from '../../types'
+import { extract, Formatted, TransactionRequestFormatter } from '../../utils'
+import { format, formatTransactionRequest, numberToHex } from '../../utils'
+
+export type FormattedCall<
+  TFormatter extends Formatter | undefined = Formatter,
+> = MergeIntersectionProperties<
+  Formatted<TFormatter, TransactionRequest, true>,
+  TransactionRequest
+>
+
+export type CallArgs<TChain extends Chain = Chain> = FormattedCall<
+  TransactionRequestFormatter<TChain>
+> & {
+  chain?: TChain
+  from?: Address
+} & (
+    | {
+        /** The balance of the account at a block number. */
+        blockNumber?: bigint
+        blockTag?: never
+      }
+    | {
+        blockNumber?: never
+        /** The balance of the account at a block tag. */
+        blockTag?: BlockTag
+      }
+  )
+
+export type CallResponse = { data: Hex | undefined }
+
+export async function call<TChain extends Chain>(
+  client: PublicClient,
+  {
+    blockNumber,
+    blockTag = 'latest',
+    chain,
+    from,
+    accessList,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  }: CallArgs<TChain>,
+): Promise<CallResponse> {
+  if (
+    maxFeePerGas !== undefined &&
+    maxPriorityFeePerGas !== undefined &&
+    maxFeePerGas < maxPriorityFeePerGas
+  )
+    throw new InvalidGasArgumentsError()
+
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+
+  const formatter = chain?.formatters?.transactionRequest
+  const request_ = format(
+    {
+      from,
+      accessList,
+      data,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      value,
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { formatter }),
+    } as TransactionRequest,
+    {
+      formatter: formatter || formatTransactionRequest,
+    },
+  )
+
+  const response = await client.request({
+    method: 'eth_call',
+    params: [request_, blockNumberHex || blockTag],
+  })
+  if (response === '0x') return { data: undefined }
+  return { data: response }
+}