viem 0.0.1-alpha.2 → 0.0.1-alpha.20

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

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

@@ -0,0 +1,440 @@
+import { describe, expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { celo, defineChain, localhost } from '../../chains'
+import { hexToNumber, numberToHex, parseEther, parseGwei } from '../../utils'
+import { getBalance, getBlock } from '..'
+import { mine, setBalance } from '../test'
+
+import { sendTransaction } from './sendTransaction'
+
+const sourceAccount = accounts[0]
+const targetAccount = accounts[1]
+
+async function setup() {
+  await setBalance(testClient, {
+    address: sourceAccount.address,
+    value: sourceAccount.balance,
+  })
+  await setBalance(testClient, {
+    address: targetAccount.address,
+    value: targetAccount.balance,
+  })
+  await mine(testClient, { blocks: 1 })
+}
+
+test('sends transaction', async () => {
+  await setup()
+
+  expect(
+    await sendTransaction(walletClient, {
+      from: sourceAccount.address,
+      to: targetAccount.address,
+      value: parseEther('1'),
+    }),
+  ).toBeDefined()
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+
+  await mine(testClient, { blocks: 1 })
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10001000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toBeLessThan(sourceAccount.balance)
+})
+
+test('sends transaction (w/ formatter)', async () => {
+  await setup()
+
+  const chain = defineChain({
+    ...localhost,
+    formatters: {
+      transactionRequest: celo.formatters.transactionRequest,
+    },
+  })
+
+  expect(
+    await sendTransaction(walletClient, {
+      chain,
+      from: sourceAccount.address,
+      to: targetAccount.address,
+      value: parseEther('1'),
+    }),
+  ).toBeDefined()
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+
+  await mine(testClient, { blocks: 1 })
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10001000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toBeLessThan(sourceAccount.balance)
+})
+
+test('sends transaction w/ no value', async () => {
+  await setup()
+
+  expect(
+    await sendTransaction(walletClient, {
+      from: sourceAccount.address,
+      to: targetAccount.address,
+    }),
+  ).toBeDefined()
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+
+  await mine(testClient, { blocks: 1 })
+
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+  expect(
+    await getBalance(publicClient, { address: sourceAccount.address }),
+  ).toBeLessThan(sourceAccount.balance)
+})
+
+describe('args: gas', () => {
+  test('sends transaction', async () => {
+    await setup()
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gas: 1_000_000n,
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('sends transaction with too little gas', async () => {
+    await setup()
+
+    expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gas: 100n,
+      }),
+    ).rejects.toThrowError('intrinsic gas too low')
+  })
+
+  test('sends transaction with too much gas', async () => {
+    await setup()
+
+    await expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gas: 100_000_000n,
+      }),
+    ).rejects.toThrowError('intrinsic gas too high')
+  })
+})
+
+describe('args: gasPrice', () => {
+  test('sends transaction', async () => {
+    await setup()
+
+    const block = await getBlock(publicClient)
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gasPrice: BigInt(block.baseFeePerGas ?? 0),
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('errors when gas price is less than block base fee', async () => {
+    await setup()
+
+    await testClient.request({
+      method: 'anvil_setNextBlockBaseFeePerGas',
+      params: [numberToHex(69n)],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    await expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gasPrice: 1n,
+      }),
+    ).rejects.toThrowError('max fee per gas less than block base fee')
+  })
+
+  test('errors when account has insufficient funds', async () => {
+    await setup()
+
+    const block = await getBlock(publicClient)
+
+    await expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        gasPrice: BigInt(block.baseFeePerGas ?? 0) + parseEther('10000'),
+      }),
+    ).rejects.toThrowError('Insufficient funds for gas * price + value')
+  })
+})
+
+describe('args: maxFeePerGas', () => {
+  test('sends transaction', async () => {
+    await setup()
+
+    const block = await getBlock(publicClient)
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxFeePerGas: BigInt(block.baseFeePerGas ?? 0),
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('errors when gas price is less than block base fee', async () => {
+    await setup()
+
+    await expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxFeePerGas: 1n,
+      }),
+    ).rejects.toThrowError('max fee per gas less than block base fee')
+  })
+
+  test('errors when account has insufficient funds', async () => {
+    await setup()
+
+    const block = await getBlock(publicClient)
+
+    await expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxFeePerGas: BigInt(block.baseFeePerGas ?? 0) + parseEther('10000'),
+      }),
+    ).rejects.toThrowError('Insufficient funds for gas * price + value')
+  })
+})
+
+describe('args: maxPriorityFeePerGas', () => {
+  test('sends transaction', async () => {
+    await setup()
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxPriorityFeePerGas: parseGwei('1'),
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('maxPriorityFeePerGas + maxFeePerGas: sends transaction', async () => {
+    await setup()
+
+    const block = await getBlock(publicClient)
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxPriorityFeePerGas: parseGwei('10'),
+        maxFeePerGas: BigInt(block.baseFeePerGas ?? 0) + parseGwei('10'),
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('maxPriorityFeePerGas + maxFeePerGas: maxFeePerGas below baseFeePerGas + maxPriorityFeePerGas', () => {
+    expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        maxPriorityFeePerGas: parseGwei('11'),
+        maxFeePerGas: parseGwei('10'),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `
+      "\`maxFeePerGas\` cannot be less than \`maxPriorityFeePerGas\`
+
+      Version: viem@1.0.2"
+    `,
+    )
+  })
+})
+
+describe('args: nonce', () => {
+  test('sends transaction', async () => {
+    await setup()
+
+    const transactionCount = (await publicClient.request({
+      method: 'eth_getTransactionCount',
+      params: [sourceAccount.address, 'latest'],
+    }))!
+
+    expect(
+      await sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        nonce: hexToNumber(transactionCount),
+      }),
+    ).toBeDefined()
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toMatchInlineSnapshot('10000000000000000000000n')
+
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      await getBalance(publicClient, { address: targetAccount.address }),
+    ).toMatchInlineSnapshot('10001000000000000000000n')
+    expect(
+      await getBalance(publicClient, { address: sourceAccount.address }),
+    ).toBeLessThan(sourceAccount.balance)
+  })
+
+  test('errors when incorrect nonce provided', () => {
+    expect(() =>
+      sendTransaction(walletClient, {
+        from: sourceAccount.address,
+        to: targetAccount.address,
+        value: parseEther('1'),
+        nonce: 1,
+      }),
+    ).rejects.toThrowError('nonce too low')
+  })
+})
+
+test('insufficient funds: errors when user is out of funds', async () => {
+  await setup()
+
+  await expect(
+    sendTransaction(walletClient, {
+      from: sourceAccount.address,
+      to: targetAccount.address,
+      value: parseEther('100000'),
+    }),
+  ).rejects.toThrow('Insufficient funds for gas * price + value')
+})