viem 0.0.1-alpha.25 → 0.0.1-alpha.26

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

package/src/actions/wallet/sendTransaction.ts

@@ -1,77 +0,0 @@
-import type { WalletClient } from '../../clients'
-import { InvalidGasArgumentsError } from '../../errors'
-import type {
-  Chain,
-  Formatter,
-  Hash,
-  MergeIntersectionProperties,
-  TransactionRequest,
-} from '../../types'
-import type { Formatted, TransactionRequestFormatter } from '../../utils'
-import { extract, format, formatTransactionRequest } from '../../utils'
-
-export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = MergeIntersectionProperties<
-  Formatted<TFormatter, TransactionRequest, true>,
-  TransactionRequest
->
-
-export type SendTransactionArgs<TChain extends Chain = Chain> =
-  FormattedTransactionRequest<TransactionRequestFormatter<TChain>> & {
-    chain?: TChain
-  }
-
-export type SendTransactionResponse = Hash
-
-export async function sendTransaction<TChain extends Chain>(
-  client: WalletClient,
-  {
-    chain,
-    from,
-    accessList,
-    data,
-    gas,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    nonce,
-    to,
-    value,
-    ...rest
-  }: SendTransactionArgs<TChain>,
-): Promise<SendTransactionResponse> {
-  if (
-    maxFeePerGas !== undefined &&
-    maxPriorityFeePerGas !== undefined &&
-    maxFeePerGas < maxPriorityFeePerGas
-  )
-    throw new InvalidGasArgumentsError()
-
-  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 hash = await client.request({
-    method: 'eth_sendTransaction',
-    params: [request_],
-  })
-  return hash
-}

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

@@ -1,61 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, walletClient } from '../../_test'
-import { encodeBytes, encodeHex } from '../../utils'
-
-import { signMessage } from './signMessage'
-
-test('hex', async () => {
-  expect(
-    await signMessage(walletClient!, {
-      from: accounts[0].address,
-      data: '0xdeadbeaf',
-    }),
-  ).toMatchInlineSnapshot(
-    '"0x791703250f789557b30c2ed9066cdc9bfcfba4504583d417b61f07891c4c9ace5fa84cb97062712e6e614c29ad59c610e310123efdb40bd7a9c516ace2084cd01c"',
-  )
-
-  expect(
-    await signMessage(walletClient!, {
-      from: accounts[0].address,
-      data: encodeHex('hello world'),
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
-  )
-
-  await expect(
-    signMessage(walletClient!, {
-      from: accounts[0].address,
-      // @ts-expect-error - testing
-      data: 'deadbeaf',
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(
-    `
-    "data (\\"deadbeaf\\") must be a hex value. Encode it first to a hex with the \`encodeHex\` util.
-
-    Docs: https://viem.sh/TODO
-    Version: viem@1.0.2"
-  `,
-  )
-})
-
-test('bytes', async () => {
-  expect(
-    await signMessage(walletClient!, {
-      from: accounts[0].address,
-      data: new Uint8Array([1, 123, 14, 51, 12, 55, 11, 22, 45, 22, 56]),
-    }),
-  ).toMatchInlineSnapshot(
-    '"0x473fb0b83966f3e886af3a5a1403b2db186c432952d26eaab00819674c47a1e003d439eb257fec0d49738976e8ed30cd61bac475edb7e1c93eb08f68f24481d61b"',
-  )
-
-  expect(
-    await signMessage(walletClient!, {
-      from: accounts[0].address,
-      data: encodeBytes('hello world'),
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
-  )
-})

package/src/actions/wallet/signMessage.ts

@@ -1,35 +0,0 @@
-import type { WalletClient } from '../../clients'
-import { BaseError } from '../../errors'
-import type { Address, ByteArray, Hex } from '../../types'
-import { encodeHex } from '../../utils'
-
-export type SignMessageArgs = {
-  from: Address
-  data: Hex | ByteArray
-}
-
-export type SignMessageResponse = Hex
-
-export async function signMessage(
-  client: WalletClient,
-  { from, data: data_ }: SignMessageArgs,
-): Promise<SignMessageResponse> {
-  let data
-  if (typeof data_ === 'string') {
-    if (!data_.startsWith('0x'))
-      throw new BaseError(
-        `data ("${data_}") must be a hex value. Encode it first to a hex with the \`encodeHex\` util.`,
-        {
-          docsPath: '/TODO',
-        },
-      )
-    data = data_
-  } else {
-    data = encodeHex(data_)
-  }
-  const signed = await client.request({
-    method: 'personal_sign',
-    params: [data, from],
-  })
-  return signed
-}

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

@@ -1,21 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { walletClient } from '../../_test'
-import { avalanche, fantom } from '../../chains'
-
-import { switchChain } from './switchChain'
-
-test('default', async () => {
-  await switchChain(walletClient!, avalanche)
-})
-
-test('unsupported chain', async () => {
-  await expect(
-    switchChain(walletClient!, fantom),
-  ).rejects.toMatchInlineSnapshot(`
-    [UnknownRpcError: An unknown RPC error occurred.
-
-    Details: Unrecognized chain.
-    Version: viem@1.0.2]
-  `)
-})

package/src/actions/wallet/switchChain.ts

@@ -1,19 +0,0 @@
-import type { WalletClient } from '../../clients'
-import { Chain } from '../../types'
-import { numberToHex } from '../../utils'
-
-export type SwitchChainArgs = { id: Chain['id'] }
-
-export async function switchChain(
-  client: WalletClient,
-  { id }: SwitchChainArgs,
-) {
-  await client.request({
-    method: 'wallet_switchEthereumChain',
-    params: [
-      {
-        chainId: numberToHex(id),
-      },
-    ],
-  })
-}

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

@@ -1,40 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { walletClient } from '../../_test'
-
-import { watchAsset } from './watchAsset'
-
-test('default', async () => {
-  expect(
-    await watchAsset(walletClient!, {
-      type: 'ERC20',
-      options: {
-        address: '0xb60e8dd61c5d32be8058bb8eb970870f07233155',
-        symbol: 'FOO',
-        decimals: 18,
-        image: 'https://foo.io/token-image.svg',
-      },
-    }),
-  ).toBeTruthy()
-})
-
-test('errors: unsupported type', async () => {
-  await expect(
-    watchAsset(walletClient!, {
-      // @ts-expect-error - test
-      type: 'ERC721',
-      options: {
-        address: '0xb60e8dd61c5d32be8058bb8eb970870f07233155',
-        symbol: 'FOO',
-        decimals: 18,
-        image: 'https://foo.io/token-image.svg',
-      },
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Invalid parameters were provided to the RPC method.
-    Double check you have provided the correct parameters.
-
-    Details: Token type ERC721 not supported.
-    Version: viem@1.0.2"
-  `)
-})