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

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

@@ -0,0 +1,101 @@
+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"
+  `)
+})

package/src/actions/ens/getEnsName.ts

@@ -0,0 +1,106 @@
+import { PublicClient } from '../../clients'
+import { panicReasons } from '../../constants'
+import {
+  ChainDoesNotSupportContract,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+} from '../../errors'
+import type { Address, Prettify } from '../../types'
+import { encodeHex } from '../../utils'
+import { packetToBytes } from '../../utils/ens'
+import { readContract, ReadContractArgs } from '../public'
+
+export type GetEnsNameArgs = Prettify<
+  Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
+    /** Address to get ENS name for. */
+    address: Address
+    /** Address of ENS Universal Resolver Contract. */
+    universalResolverAddress?: Address
+  }
+>
+
+/**
+ * @description Gets primary name for specified address.
+ *
+ * - Calls `reverse(bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensName = await getEnsName(publicClient, {
+ *   address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
+ * })
+ * // 'wagmi-dev.eth'
+ */
+export async function getEnsName(
+  client: PublicClient,
+  {
+    address,
+    blockNumber,
+    blockTag,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsNameArgs,
+) {
+  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 reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
+  try {
+    const res = await readContract(client, {
+      address: universalResolverAddress,
+      abi: [
+        {
+          name: 'reverse',
+          type: 'function',
+          stateMutability: 'view',
+          inputs: [{ type: 'bytes', name: 'reverseName' }],
+          outputs: [
+            { type: 'string', name: 'resolvedName' },
+            { type: 'address', name: 'resolvedAddress' },
+            { type: 'address', name: 'reverseResolver' },
+            { type: 'address', name: 'resolver' },
+          ],
+        },
+      ],
+      functionName: 'reverse',
+      args: [encodeHex(packetToBytes(reverseNode))],
+      blockNumber,
+      blockTag,
+    })
+    return res[0]
+  } catch (error) {
+    if (
+      error instanceof ContractFunctionExecutionError &&
+      (error.cause as ContractFunctionRevertedError).reason === panicReasons[50]
+    )
+      // No primary name set for address.
+      return null
+    throw error
+  }
+}

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

@@ -0,0 +1,12 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "getEnsAddress": [Function],
+      "getEnsName": [Function],
+    }
+  `)
+})

package/src/actions/ens/index.ts

@@ -0,0 +1,3 @@
+export { getEnsAddress, type GetEnsAddressArgs } from './getEnsAddress'
+
+export { getEnsName, type GetEnsNameArgs } from './getEnsName'

package/src/actions/index.test.ts

@@ -0,0 +1,81 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "addChain": [Function],
+      "call": [Function],
+      "createBlockFilter": [Function],
+      "createContractEventFilter": [Function],
+      "createEventFilter": [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],
+      "getLogs": [Function],
+      "getPermissions": [Function],
+      "getStorageAt": [Function],
+      "getTransaction": [Function],
+      "getTransactionConfirmations": [Function],
+      "getTransactionCount": [Function],
+      "getTransactionReceipt": [Function],
+      "getTxpoolContent": [Function],
+      "getTxpoolStatus": [Function],
+      "impersonateAccount": [Function],
+      "increaseTime": [Function],
+      "inspectTxpool": [Function],
+      "mine": [Function],
+      "multicall": [Function],
+      "readContract": [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],
+      "simulateContract": [Function],
+      "snapshot": [Function],
+      "stopImpersonatingAccount": [Function],
+      "switchChain": [Function],
+      "uninstallFilter": [Function],
+      "waitForTransactionReceipt": [Function],
+      "watchAsset": [Function],
+      "watchBlockNumber": [Function],
+      "watchBlocks": [Function],
+      "watchContractEvent": [Function],
+      "watchEvent": [Function],
+      "watchPendingTransactions": [Function],
+      "writeContract": [Function],
+    }
+  `)
+})

package/src/actions/index.ts

@@ -0,0 +1,182 @@
+export {
+  call,
+  createBlockFilter,
+  createContractEventFilter,
+  createEventFilter,
+  createPendingTransactionFilter,
+  estimateGas,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockNumberCache,
+  getBlockTransactionCount,
+  getBytecode,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getFilterLogs,
+  getGasPrice,
+  getLogs,
+  getStorageAt,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  multicall,
+  readContract,
+  simulateContract,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchContractEvent,
+  watchEvent,
+  watchPendingTransactions,
+} from './public'
+export type {
+  CallArgs,
+  CallResponse,
+  CreateBlockFilterResponse,
+  CreateContractEventFilterArgs,
+  CreateContractEventFilterResponse,
+  CreateEventFilterArgs,
+  CreateEventFilterResponse,
+  CreatePendingTransactionFilterResponse,
+  EstimateGasArgs,
+  EstimateGasResponse,
+  GetBalanceArgs,
+  GetBalanceResponse,
+  GetBlockArgs,
+  GetBlockNumberArgs,
+  GetBlockNumberResponse,
+  GetBlockResponse,
+  GetBlockTransactionCountArgs,
+  GetBlockTransactionCountResponse,
+  GetBytecodeArgs,
+  GetBytecodeResponse,
+  GetFeeHistoryArgs,
+  GetFeeHistoryResponse,
+  GetFilterChangesArgs,
+  GetFilterChangesResponse,
+  GetFilterLogsArgs,
+  GetFilterLogsResponse,
+  GetGasPriceResponse,
+  GetLogsArgs,
+  GetLogsResponse,
+  GetStorageAtArgs,
+  GetStorageAtResponse,
+  GetTransactionArgs,
+  GetTransactionConfirmationsArgs,
+  GetTransactionConfirmationsResponse,
+  GetTransactionCountArgs,
+  GetTransactionCountResponse,
+  GetTransactionReceiptArgs,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  MulticallArgs,
+  OnBlock,
+  OnBlockNumber,
+  OnBlockNumberResponse,
+  OnBlockResponse,
+  OnLogs,
+  OnLogsResponse,
+  OnTransactions,
+  OnTransactionsResponse,
+  ReadContractArgs,
+  ReadContractResponse,
+  ReplacementReason,
+  ReplacementResponse,
+  SimulateContractArgs,
+  SimulateContractResponse,
+  UninstallFilterArgs,
+  UninstallFilterResponse,
+  WaitForTransactionReceiptArgs,
+  WaitForTransactionReceiptResponse,
+  WatchBlockNumberArgs,
+  WatchBlocksArgs,
+  WatchContractEventArgs,
+  WatchEventArgs,
+  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,
+  deployContract,
+  getAccounts,
+  getPermissions,
+  requestAccounts,
+  requestPermissions,
+  sendTransaction,
+  signMessage,
+  switchChain,
+  watchAsset,
+  writeContract,
+} from './wallet'
+export type {
+  DeployContractArgs,
+  DeployContractResponse,
+  FormattedTransactionRequest,
+  GetPermissionsResponse,
+  RequestPermissionsResponse,
+  SendTransactionArgs,
+  SendTransactionResponse,
+  SignMessageArgs,
+  SignMessageResponse,
+  SwitchChainArgs,
+  WatchAssetArgs,
+  WatchAssetResponse,
+  WriteContractArgs,
+  WriteContractResponse,
+} from './wallet'

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

@@ -0,0 +1,48 @@
+import { bench, describe } from 'vitest'
+
+import {
+  accounts,
+  ethersProvider,
+  ethersV6Provider,
+  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('ethers@6: `call`', async () => {
+    await ethersV6Provider.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,
+    })
+  })
+})

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')
+})