viem 0.0.1-alpha.15 → 0.0.1-alpha.17

package/src/actions/test/setStorageAt.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient } from '../../_test'
+import { setStorageAt } from './setStorageAt'
+
+const targetAccount = accounts[0]
+
+test('sets storage', async () => {
+  await setStorageAt(testClient, {
+    address: targetAccount.address,
+    index: 0,
+    value: '0x0000000000000000000000000000000000000000000000000000000000003039',
+  })
+  expect(
+    await publicClient.request({
+      method: 'eth_getStorageAt',
+      params: [targetAccount.address, '0x0', 'latest'],
+    }),
+  ).toBe('0x0000000000000000000000000000000000000000000000000000000000003039')
+
+  await setStorageAt(testClient, {
+    address: targetAccount.address,
+    index: '0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49',
+    value: '0x0000000000000000000000000000000000000000000000000000000000003039',
+  })
+  expect(
+    await publicClient.request({
+      method: 'eth_getStorageAt',
+      params: [
+        targetAccount.address,
+        '0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49',
+        'latest',
+      ],
+    }),
+  ).toBe('0x0000000000000000000000000000000000000000000000000000000000003039')
+})

package/src/actions/test/setStorageAt.ts

@@ -0,0 +1,26 @@
+import type { TestClient } from '../../clients'
+import type { Address, Hash, Hex } from '../../types'
+import { numberToHex } from '../../utils'
+
+export type SetStorageAtArgs = {
+  /** The account address. */
+  address: Address
+  /** The storage slot (index). Can either be a number or hash value. */
+  index: number | Hash
+  /** The value to store as a 32 byte hex string. */
+  value: Hex
+}
+
+export async function setStorageAt(
+  client: TestClient,
+  { address, index, value }: SetStorageAtArgs,
+) {
+  return await client.request({
+    method: `${client.mode}_setStorageAt`,
+    params: [
+      address,
+      typeof index === 'number' ? numberToHex(index) : index,
+      value,
+    ],
+  })
+}

package/src/actions/test/snapshot.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from 'vitest'
+
+import { accounts, testClient, walletClient } from '../../_test'
+import { parseEther } from '../../utils'
+import { sendTransaction } from '../wallet/sendTransaction'
+import { snapshot } from './snapshot'
+
+const sourceAccount = accounts[0]
+const targetAccount = accounts[1]
+
+test('snapshots', async () => {
+  await sendTransaction(walletClient, {
+    from: sourceAccount.address,
+    to: targetAccount.address,
+    value: parseEther('1'),
+  })
+  expect(await snapshot(testClient)).toBeDefined()
+})

package/src/actions/test/snapshot.ts

@@ -0,0 +1,7 @@
+import type { TestClient } from '../../clients'
+
+export async function snapshot(client: TestClient) {
+  return await client.request({
+    method: 'evm_snapshot',
+  })
+}

package/src/actions/test/stopImpersonatingAccount.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from 'vitest'
+
+import { accounts, testClient, vitalikAddress, walletClient } from '../../_test'
+import { parseEther } from '../../utils'
+import { sendTransaction } from '../wallet/sendTransaction'
+import { impersonateAccount } from './impersonateAccount'
+import { stopImpersonatingAccount } from './stopImpersonatingAccount'
+
+const account = vitalikAddress
+
+test('stops impersonating account', async () => {
+  await impersonateAccount(testClient, { address: account })
+
+  expect(
+    await sendTransaction(walletClient, {
+      from: account,
+      to: accounts[0].address,
+      value: parseEther('1'),
+    }),
+  ).toBeDefined()
+
+  await stopImpersonatingAccount(testClient, { address: account })
+
+  await expect(
+    sendTransaction(walletClient, {
+      from: account,
+      to: accounts[0].address,
+      value: parseEther('1'),
+    }),
+  ).rejects.toThrowError('No Signer available')
+})

package/src/actions/test/stopImpersonatingAccount.ts

@@ -0,0 +1,17 @@
+import type { TestClient } from '../../clients'
+import type { Address } from '../../types'
+
+export type StopImpersonatingAccountArgs = {
+  /** The account to impersonate. */
+  address: Address
+}
+
+export async function stopImpersonatingAccount(
+  client: TestClient,
+  { address }: StopImpersonatingAccountArgs,
+) {
+  return await client.request({
+    method: `${client.mode}_stopImpersonatingAccount`,
+    params: [address],
+  })
+}

package/src/actions/wallet/addChain.test.ts

@@ -0,0 +1,14 @@
+import { test } from 'vitest'
+
+import { walletClient } from '../../_test'
+import { avalanche } from '../../chains'
+
+import { addChain } from './addChain'
+
+test('default', async () => {
+  await addChain(walletClient!, avalanche)
+})
+
+test('no block explorer', async () => {
+  await addChain(walletClient!, { ...avalanche, blockExplorers: undefined })
+})

package/src/actions/wallet/addChain.ts

@@ -0,0 +1,21 @@
+import type { Chain } from '../../chains'
+import type { WalletClient } from '../../clients'
+import { numberToHex } from '../../utils'
+
+export async function addChain(client: WalletClient, chain: Chain) {
+  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain
+  await client.request({
+    method: 'wallet_addEthereumChain',
+    params: [
+      {
+        chainId: numberToHex(id),
+        chainName: name,
+        nativeCurrency,
+        rpcUrls: rpcUrls.default.http,
+        blockExplorerUrls: blockExplorers
+          ? Object.values(blockExplorers).map(({ url }) => url)
+          : undefined,
+      },
+    ],
+  })
+}

package/src/actions/wallet/getAccounts.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from 'vitest'
+
+import { walletClient } from '../../_test'
+
+import { getAccounts } from './getAccounts'
+
+test('default', async () => {
+  expect(await getAccounts(walletClient!)).toMatchInlineSnapshot(`
+    [
+      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+      "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+      "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+      "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+      "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
+      "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
+      "0x14dC79964da2C08b23698B3D3cc7Ca32193d9955",
+      "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f",
+      "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720",
+    ]
+  `)
+})

package/src/actions/wallet/getAccounts.ts

@@ -0,0 +1,7 @@
+import type { WalletClient } from '../../clients'
+import { checksumAddress } from '../../utils/address'
+
+export async function getAccounts(client: WalletClient) {
+  const addresses = await client.request({ method: 'eth_accounts' })
+  return addresses.map((address) => checksumAddress(address))
+}

package/src/actions/wallet/getPermissions.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from 'vitest'
+
+import { walletClient } from '../../_test'
+
+import { getPermissions } from './getPermissions'
+
+test('default', async () => {
+  expect(await getPermissions(walletClient!)).toMatchInlineSnapshot(`
+    [
+      {
+        "caveats": [
+          {
+            "type": "filterResponse",
+            "value": [
+              "0x0c54fccd2e384b4bb6f2e405bf5cbc15a017aafb",
+            ],
+          },
+        ],
+        "invoker": "https://example.com",
+        "parentCapability": "eth_accounts",
+      },
+    ]
+  `)
+})

package/src/actions/wallet/getPermissions.ts

@@ -0,0 +1,9 @@
+import type { WalletClient } from '../../clients'
+import type { WalletPermission } from '../../types/eip1193'
+
+export type GetPermissionsResponse = WalletPermission[]
+
+export async function getPermissions(client: WalletClient) {
+  const permissions = await client.request({ method: 'wallet_getPermissions' })
+  return permissions
+}

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

@@ -0,0 +1,20 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "addChain": [Function],
+      "getAccounts": [Function],
+      "getPermissions": [Function],
+      "requestAccounts": [Function],
+      "requestPermissions": [Function],
+      "sendTransaction": [Function],
+      "signMessage": [Function],
+      "switchChain": [Function],
+      "watchAsset": [Function],
+      "writeContract": [Function],
+    }
+  `)
+})

package/src/actions/wallet/index.ts

@@ -0,0 +1,30 @@
+export { addChain } from './addChain'
+
+export { getAccounts } from './getAccounts'
+
+export { getPermissions } from './getPermissions'
+export type { GetPermissionsResponse } from './getPermissions'
+
+export { requestAccounts } from './requestAccounts'
+
+export { requestPermissions } from './requestPermissions'
+export type { RequestPermissionsResponse } from './requestPermissions'
+
+export { sendTransaction } from './sendTransaction'
+export type {
+  FormattedTransactionRequest,
+  SendTransactionArgs,
+  SendTransactionResponse,
+} from './sendTransaction'
+
+export { signMessage } from './signMessage'
+export type { SignMessageArgs, SignMessageResponse } from './signMessage'
+
+export { switchChain } from './switchChain'
+export type { SwitchChainArgs } from './switchChain'
+
+export { watchAsset } from './watchAsset'
+export type { WatchAssetArgs, WatchAssetResponse } from './watchAsset'
+
+export { writeContract } from './writeContract'
+export type { WriteContractArgs, WriteContractResponse } from './writeContract'

package/src/actions/wallet/requestAccounts.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from 'vitest'
+
+import { walletClient } from '../../_test'
+
+import { requestAccounts } from './requestAccounts'
+
+test('requests accounts', async () => {
+  expect(await requestAccounts(walletClient!)).toMatchInlineSnapshot(`
+      [
+        "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      ]
+    `)
+})

package/src/actions/wallet/requestAccounts.ts

@@ -0,0 +1,7 @@
+import type { WalletClient } from '../../clients'
+import { getAddress } from '../../utils'
+
+export async function requestAccounts(client: WalletClient) {
+  const addresses = await client.request({ method: 'eth_requestAccounts' })
+  return addresses.map((address) => getAddress(address))
+}

package/src/actions/wallet/requestPermissions.test.ts

@@ -0,0 +1,26 @@
+import { expect, test } from 'vitest'
+
+import { walletClient } from '../../_test'
+
+import { requestPermissions } from './requestPermissions'
+
+test('default', async () => {
+  expect(
+    await requestPermissions(walletClient!, { eth_accounts: {} }),
+  ).toMatchInlineSnapshot(`
+    [
+      {
+        "caveats": [
+          {
+            "type": "filterResponse",
+            "value": [
+              "0x0c54fccd2e384b4bb6f2e405bf5cbc15a017aafb",
+            ],
+          },
+        ],
+        "invoker": "https://example.com",
+        "parentCapability": "eth_accounts",
+      },
+    ]
+  `)
+})

package/src/actions/wallet/requestPermissions.ts

@@ -0,0 +1,19 @@
+import type { WalletClient } from '../../clients'
+import type { WalletPermission } from '../../types/eip1193'
+
+export type RequestPermissionsArgs = {
+  eth_accounts: Record<string, any>
+} & {
+  [key: string]: Record<string, any>
+}
+export type RequestPermissionsResponse = WalletPermission[]
+
+export async function requestPermissions(
+  client: WalletClient,
+  permissions: RequestPermissionsArgs,
+) {
+  return client.request({
+    method: 'wallet_requestPermissions',
+    params: [permissions],
+  })
+}

package/src/actions/wallet/sendTransaction.bench.ts

@@ -0,0 +1,57 @@
+import { beforeAll, bench, describe } from 'vitest'
+
+import {
+  accounts,
+  ethersProvider,
+  publicClient,
+  walletClient,
+  web3Provider,
+} from '../../_test'
+import { parseEther } from '../../utils'
+import { getTransactionCount } from '../public'
+
+import { sendTransaction } from './sendTransaction'
+
+let nonce: number
+
+beforeAll(async () => {
+  nonce = await getTransactionCount(publicClient, {
+    address: accounts[0].address,
+  })
+})
+
+describe('Send Transaction', () => {
+  bench('viem: `sendTransaction`', async () => {
+    await sendTransaction(walletClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+      nonce: nonce++,
+    })
+  })
+
+  bench('ethers: `sendTransaction`', async () => {
+    await ethersProvider.getSigner(accounts[0].address).sendTransaction({
+      to: accounts[1].address,
+      value: parseEther('1'),
+      nonce: nonce++,
+    })
+  })
+
+  bench(
+    'web3.js: `sendTransaction`',
+    async () => {
+      await new Promise((resolve) => {
+        web3Provider.eth
+          .sendTransaction({
+            from: accounts[0].address,
+            to: accounts[1].address,
+            value: '1000000000000000',
+            nonce: nonce++,
+          })
+          .on('transactionHash', resolve)
+      })
+    },
+    { iterations: 10 },
+  )
+})