viem 0.0.1-alpha.24 → 0.0.1-alpha.26

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

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

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

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

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

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

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

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

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

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

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

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

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