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

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

package/src/actions/wallet/sendTransaction.ts

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

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

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

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

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

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