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

package/src/actions/test/getTxpoolContent.test.ts

@@ -1,45 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, testClient, walletClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { sendTransaction } from '../wallet/sendTransaction'
-
-import { getTxpoolContent } from './getTxpoolContent'
-import { mine } from './mine'
-
-test('gets txpool content (empty)', async () => {
-  await mine(testClient, { blocks: 1 })
-
-  expect(await getTxpoolContent(testClient)).toMatchInlineSnapshot(`
-    {
-      "pending": {},
-      "queued": {},
-    }
-  `)
-})
-
-test('gets txpool content (pending)', async () => {
-  await sendTransaction(walletClient, {
-    from: accounts[0].address,
-    to: accounts[1].address,
-    value: parseEther('2'),
-  })
-  await sendTransaction(walletClient, {
-    from: accounts[2].address,
-    to: accounts[3].address,
-    value: parseEther('3'),
-  })
-  const content1 = await getTxpoolContent(testClient)
-  expect(Object.values(content1.pending).length).toBe(2)
-  expect(Object.values(content1.queued).length).toBe(0)
-  expect(content1.pending[accounts[0].address]).toBeDefined()
-  expect(content1.pending[accounts[2].address]).toBeDefined()
-
-  await mine(testClient, { blocks: 1 })
-
-  const content2 = await getTxpoolContent(testClient)
-  expect(Object.values(content2.pending).length).toBe(0)
-  expect(Object.values(content2.queued).length).toBe(0)
-  expect(content2.pending[accounts[0].address]).toBeUndefined()
-  expect(content2.pending[accounts[2].address]).toBeUndefined()
-})

package/src/actions/test/getTxpoolContent.ts

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

package/src/actions/test/getTxpoolStatus.test.ts

@@ -1,41 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, testClient, walletClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { sendTransaction } from '../wallet/sendTransaction'
-
-import { getTxpoolStatus } from './getTxpoolStatus'
-import { mine } from './mine'
-
-test('gets txpool content (empty)', async () => {
-  await mine(testClient, { blocks: 1 })
-
-  expect(await getTxpoolStatus(testClient)).toMatchInlineSnapshot(`
-    {
-      "pending": 0,
-      "queued": 0,
-    }
-  `)
-})
-
-test('gets txpool content (pending)', async () => {
-  await sendTransaction(walletClient, {
-    from: accounts[0].address,
-    to: accounts[1].address,
-    value: parseEther('2'),
-  })
-  await sendTransaction(walletClient, {
-    from: accounts[2].address,
-    to: accounts[3].address,
-    value: parseEther('3'),
-  })
-  const status1 = await getTxpoolStatus(testClient)
-  expect(status1.pending).toBe(2)
-  expect(status1.queued).toBe(0)
-
-  await mine(testClient, { blocks: 1 })
-
-  const status2 = await getTxpoolStatus(testClient)
-  expect(status2.pending).toBe(0)
-  expect(status2.queued).toBe(0)
-})

package/src/actions/test/getTxpoolStatus.ts

@@ -1,12 +0,0 @@
-import type { TestClient } from '../../clients'
-import { hexToNumber } from '../../utils'
-
-export async function getTxpoolStatus(client: TestClient) {
-  const { pending, queued } = await client.request({
-    method: 'txpool_status',
-  })
-  return {
-    pending: hexToNumber(pending),
-    queued: hexToNumber(queued),
-  }
-}

package/src/actions/test/impersonateAccount.test.ts

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

package/src/actions/test/impersonateAccount.ts

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

package/src/actions/test/increaseTime.test.ts

@@ -1,18 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { publicClient, testClient } from '../../_test'
-
-import { getBlock } from '../public/getBlock'
-import { increaseTime } from './increaseTime'
-import { mine } from './mine'
-
-// TODO: Anvil seems to not register the increased timestamp sometimes.
-test.skip('increases time', async () => {
-  const block1 = await getBlock(publicClient, {
-    blockTag: 'latest',
-  })
-  await increaseTime(testClient, { seconds: 86400 })
-  await mine(testClient, { blocks: 1 })
-  const block2 = await getBlock(publicClient, { blockTag: 'latest' })
-  expect(block2.timestamp).toBeGreaterThan(block1.timestamp + (86400n - 1000n))
-})

package/src/actions/test/increaseTime.ts

@@ -1,17 +0,0 @@
-import type { TestClient } from '../../clients'
-import { numberToHex } from '../../utils'
-
-export type IncreaseTimeArgs = {
-  /** The amount of seconds to jump forward in time. */
-  seconds: number
-}
-
-export async function increaseTime(
-  client: TestClient,
-  { seconds }: IncreaseTimeArgs,
-) {
-  return await client.request({
-    method: 'evm_increaseTime',
-    params: [numberToHex(seconds)],
-  })
-}

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

@@ -1,38 +0,0 @@
-import { expect, test } from 'vitest'
-
-import * as actions from './index'
-
-test('exports actions', () => {
-  expect(actions).toMatchInlineSnapshot(`
-    {
-      "dropTransaction": [Function],
-      "getAutomine": [Function],
-      "getTxpoolContent": [Function],
-      "getTxpoolStatus": [Function],
-      "impersonateAccount": [Function],
-      "increaseTime": [Function],
-      "inspectTxpool": [Function],
-      "mine": [Function],
-      "removeBlockTimestampInterval": [Function],
-      "reset": [Function],
-      "revert": [Function],
-      "sendUnsignedTransaction": [Function],
-      "setAutomine": [Function],
-      "setBalance": [Function],
-      "setBlockGasLimit": [Function],
-      "setBlockTimestampInterval": [Function],
-      "setCode": [Function],
-      "setCoinbase": [Function],
-      "setIntervalMining": [Function],
-      "setLoggingEnabled": [Function],
-      "setMinGasPrice": [Function],
-      "setNextBlockBaseFeePerGas": [Function],
-      "setNextBlockTimestamp": [Function],
-      "setNonce": [Function],
-      "setRpcUrl": [Function],
-      "setStorageAt": [Function],
-      "snapshot": [Function],
-      "stopImpersonatingAccount": [Function],
-    }
-  `)
-})

package/src/actions/test/index.ts

@@ -1,77 +0,0 @@
-export { dropTransaction } from './dropTransaction'
-export type { DropTransactionArgs } from './dropTransaction'
-
-export { getAutomine } from './getAutomine'
-
-export { getTxpoolContent } from './getTxpoolContent'
-
-export { getTxpoolStatus } from './getTxpoolStatus'
-
-export { impersonateAccount } from './impersonateAccount'
-export type { ImpersonateAccountArgs } from './impersonateAccount'
-
-export { increaseTime } from './increaseTime'
-export type { IncreaseTimeArgs } from './increaseTime'
-
-export { inspectTxpool } from './inspectTxpool'
-
-export { mine } from './mine'
-export type { MineArgs } from './mine'
-
-export { removeBlockTimestampInterval } from './removeBlockTimestampInterval'
-
-export { reset } from './reset'
-export type { ResetArgs } from './reset'
-
-export { revert } from './revert'
-export type { RevertArgs } from './revert'
-
-export { sendUnsignedTransaction } from './sendUnsignedTransaction'
-export type {
-  SendUnsignedTransactionArgs,
-  SendUnsignedTransactionResponse,
-} from './sendUnsignedTransaction'
-
-export { setAutomine } from './setAutomine'
-
-export { setBalance } from './setBalance'
-export type { SetBalanceArgs } from './setBalance'
-
-export { setBlockGasLimit } from './setBlockGasLimit'
-export type { SetBlockGasLimitArgs } from './setBlockGasLimit'
-
-export { setBlockTimestampInterval } from './setBlockTimestampInterval'
-export type { SetBlockTimestampIntervalArgs } from './setBlockTimestampInterval'
-
-export { setCode } from './setCode'
-export type { SetCodeArgs } from './setCode'
-
-export { setCoinbase } from './setCoinbase'
-export type { SetCoinbaseArgs } from './setCoinbase'
-
-export { setIntervalMining } from './setIntervalMining'
-export type { SetIntervalMiningArgs } from './setIntervalMining'
-
-export { setLoggingEnabled } from './setLoggingEnabled'
-
-export { setMinGasPrice } from './setMinGasPrice'
-export type { SetMinGasPriceArgs } from './setMinGasPrice'
-
-export { setNextBlockBaseFeePerGas } from './setNextBlockBaseFeePerGas'
-export type { SetNextBlockBaseFeePerGasArgs } from './setNextBlockBaseFeePerGas'
-
-export { setNextBlockTimestamp } from './setNextBlockTimestamp'
-export type { SetNextBlockTimestampArgs } from './setNextBlockTimestamp'
-
-export { setNonce } from './setNonce'
-export type { SetNonceArgs } from './setNonce'
-
-export { setRpcUrl } from './setRpcUrl'
-
-export { setStorageAt } from './setStorageAt'
-export type { SetStorageAtArgs } from './setStorageAt'
-
-export { snapshot } from './snapshot'
-
-export { stopImpersonatingAccount } from './stopImpersonatingAccount'
-export type { StopImpersonatingAccountArgs } from './stopImpersonatingAccount'

package/src/actions/test/inspectTxpool.test.ts

@@ -1,50 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, testClient, walletClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { sendTransaction } from '../wallet/sendTransaction'
-
-import { inspectTxpool } from './inspectTxpool'
-import { mine } from './mine'
-
-test('inspects txpool (empty)', async () => {
-  await mine(testClient, { blocks: 1 })
-
-  expect(await inspectTxpool(testClient)).toMatchInlineSnapshot(`
-    {
-      "pending": {},
-      "queued": {},
-    }
-  `)
-})
-
-test(
-  'inspects txpool (pending)',
-  async () => {
-    await sendTransaction(walletClient, {
-      from: accounts[0].address,
-      to: accounts[1].address,
-      value: parseEther('2'),
-    })
-    await sendTransaction(walletClient, {
-      from: accounts[2].address,
-      to: accounts[3].address,
-      value: parseEther('3'),
-    })
-
-    const txpool1 = await inspectTxpool(testClient)
-    expect(Object.values(txpool1.pending).length).toBe(2)
-    expect(Object.values(txpool1.queued).length).toBe(0)
-    expect(txpool1.pending[accounts[0].address]).toBeDefined()
-    expect(txpool1.pending[accounts[2].address]).toBeDefined()
-
-    await mine(testClient, { blocks: 1 })
-
-    const txpool2 = await inspectTxpool(testClient)
-    expect(Object.values(txpool2.pending).length).toBe(0)
-    expect(Object.values(txpool2.queued).length).toBe(0)
-    expect(txpool2.pending[accounts[0].address]).toBeUndefined()
-    expect(txpool2.pending[accounts[2].address]).toBeUndefined()
-  },
-  { retry: 3 },
-)

package/src/actions/test/inspectTxpool.ts

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

package/src/actions/test/mine.test.ts

@@ -1,20 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { publicClient, testClient } from '../../_test'
-
-import { getBlockNumber } from '../public/getBlockNumber'
-import { mine } from './mine'
-
-test('mines 1 block', async () => {
-  const currentBlockNumber = await getBlockNumber(publicClient, { maxAge: 0 })
-  await mine(testClient, { blocks: 1 })
-  const nextBlockNumber = await getBlockNumber(publicClient, { maxAge: 0 })
-  expect(nextBlockNumber).toEqual(currentBlockNumber + 1n)
-})
-
-test('mines 5 blocks', async () => {
-  const currentBlockNumber = await getBlockNumber(publicClient, { maxAge: 0 })
-  await mine(testClient, { blocks: 5 })
-  const nextBlockNumber = await getBlockNumber(publicClient, { maxAge: 0 })
-  expect(nextBlockNumber).toEqual(currentBlockNumber + 5n)
-})

package/src/actions/test/mine.ts

@@ -1,16 +0,0 @@
-import type { TestClient } from '../../clients'
-import { numberToHex } from '../../utils'
-
-export type MineArgs = {
-  /** Number of blocks to mine. */
-  blocks: number
-  /** Interval between each block in seconds. */
-  interval?: number
-}
-
-export async function mine(client: TestClient, { blocks, interval }: MineArgs) {
-  return await client.request({
-    method: `${client.mode}_mine`,
-    params: [numberToHex(blocks), numberToHex(interval || 0)],
-  })
-}

package/src/actions/test/removeBlockTimestampInterval.test.ts

@@ -1,23 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { publicClient, testClient } from '../../_test'
-import { wait } from '../../utils/wait'
-
-import { getBlock } from '../public/getBlock'
-import { setBlockTimestampInterval } from './setBlockTimestampInterval'
-import { removeBlockTimestampInterval } from './removeBlockTimestampInterval'
-
-test('removes block timestamp interval', async () => {
-  let interval = 86400
-  await setBlockTimestampInterval(testClient, { interval })
-  const block1 = await getBlock(publicClient, { blockTag: 'latest' })
-  await wait(1000)
-  const block2 = await getBlock(publicClient, { blockTag: 'latest' })
-  expect(block2.timestamp).toEqual(block1.timestamp + BigInt(interval))
-
-  await removeBlockTimestampInterval(testClient)
-  interval = 1
-  await wait(1000)
-  const block3 = await getBlock(publicClient, { blockTag: 'latest' })
-  expect(block3.timestamp).toEqual(block2.timestamp + BigInt(interval))
-})

package/src/actions/test/removeBlockTimestampInterval.ts

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

package/src/actions/test/reset.test.ts

@@ -1,19 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { initialBlockNumber, publicClient, testClient } from '../../_test'
-
-import { getBlockNumber } from '../public/getBlockNumber'
-import { setIntervalMining } from './setIntervalMining'
-import { mine } from './mine'
-import { reset } from './reset'
-
-test('resets the fork', async () => {
-  await setIntervalMining(testClient, { interval: 0 })
-  await mine(testClient, { blocks: 10 })
-  await reset(testClient, {
-    blockNumber: initialBlockNumber,
-  })
-  expect(await getBlockNumber(publicClient)).toBe(initialBlockNumber)
-  await setIntervalMining(testClient, { interval: 1 })
-  await mine(testClient, { blocks: 1 })
-})

package/src/actions/test/reset.ts

@@ -1,18 +0,0 @@
-import type { TestClient } from '../../clients'
-
-export type ResetArgs = {
-  /** The block number to reset from. */
-  blockNumber?: bigint
-  /** The JSON RPC URL. */
-  jsonRpcUrl?: string
-}
-
-export async function reset(
-  client: TestClient,
-  { blockNumber, jsonRpcUrl }: ResetArgs = {},
-) {
-  return await client.request({
-    method: `${client.mode}_reset`,
-    params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }],
-  })
-}

package/src/actions/test/revert.test.ts

@@ -1,39 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, publicClient, testClient, walletClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { getBalance } from '../public/getBalance'
-import { sendTransaction } from '../wallet/sendTransaction'
-import { mine } from './mine'
-import { snapshot } from './snapshot'
-import { revert } from './revert'
-
-const sourceAccount = accounts[0]
-const targetAccount = accounts[1]
-
-test('reverts', async () => {
-  const balance = await getBalance(publicClient, {
-    address: sourceAccount.address,
-  })
-
-  const id = await snapshot(testClient)
-
-  await sendTransaction(walletClient, {
-    from: sourceAccount.address,
-    to: targetAccount.address,
-    value: parseEther('2'),
-  })
-  await mine(testClient, { blocks: 1 })
-  expect(
-    await getBalance(publicClient, {
-      address: sourceAccount.address,
-    }),
-  ).not.toBe(balance)
-
-  await revert(testClient, { id })
-  expect(
-    await getBalance(publicClient, {
-      address: sourceAccount.address,
-    }),
-  ).toBe(balance)
-})

package/src/actions/test/revert.ts

@@ -1,14 +0,0 @@
-import type { TestClient } from '../../clients'
-import type { Quantity } from '../../types'
-
-export type RevertArgs = {
-  /** The snapshot ID to revert to. */
-  id: Quantity
-}
-
-export async function revert(client: TestClient, { id }: RevertArgs) {
-  return await client.request({
-    method: 'evm_revert',
-    params: [id],
-  })
-}

package/src/actions/test/sendUnsignedTransaction.test.ts

@@ -1,52 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, address, publicClient, testClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { getBalance } from '../public/getBalance'
-import { mine, setBalance } from '../test'
-
-import { sendUnsignedTransaction } from './sendUnsignedTransaction'
-
-const sourceAccount = {
-  address: address.vitalik,
-} as const
-const targetAccount = accounts[0]
-
-test('sends unsigned transaction', async () => {
-  await setBalance(testClient, {
-    address: targetAccount.address,
-    value: targetAccount.balance,
-  })
-  await setBalance(testClient, {
-    address: sourceAccount.address,
-    value: parseEther('10000'),
-  })
-
-  const balance = await getBalance(publicClient, {
-    address: sourceAccount.address,
-  })
-
-  expect(
-    await sendUnsignedTransaction(testClient, {
-      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(balance)
-})

package/src/actions/test/sendUnsignedTransaction.ts

@@ -1,19 +0,0 @@
-import type { TestClient } from '../../clients'
-import type { Hash, TransactionRequest } from '../../types'
-import { formatTransactionRequest } from '../../utils'
-
-export type SendUnsignedTransactionArgs = TransactionRequest
-
-export type SendUnsignedTransactionResponse = Hash
-
-export async function sendUnsignedTransaction(
-  client: TestClient,
-  request: SendUnsignedTransactionArgs,
-): Promise<SendUnsignedTransactionResponse> {
-  const request_ = formatTransactionRequest(request)
-  const hash = await client.request({
-    method: 'eth_sendUnsignedTransaction',
-    params: [request_],
-  })
-  return hash
-}

package/src/actions/test/setAutomine.test.ts

@@ -1,14 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { testClient } from '../../_test'
-
-import { getAutomine } from './getAutomine'
-import { setAutomine } from './setAutomine'
-
-// TODO: Anvil sometimes stops interval mining when automining is programatically set.
-test.skip('sets automine status', async () => {
-  await setAutomine(testClient, true)
-  expect(await getAutomine(testClient)).toEqual(true)
-  await setAutomine(testClient, false)
-  expect(await getAutomine(testClient)).toEqual(false)
-})

package/src/actions/test/setAutomine.ts

@@ -1,8 +0,0 @@
-import type { TestClient } from '../../clients'
-
-export async function setAutomine(client: TestClient, enabled: boolean) {
-  return await client.request({
-    method: 'evm_setAutomine',
-    params: [enabled],
-  })
-}

package/src/actions/test/setBalance.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { accounts, publicClient, testClient } from '../../_test'
-import { parseEther } from '../../utils'
-import { getBalance } from '../public/getBalance'
-import { setBalance } from '../test/setBalance'
-
-const targetAccount = accounts[0]
-
-test('sets balance', async () => {
-  await setBalance(testClient, {
-    address: targetAccount.address,
-    value: parseEther('420'),
-  })
-  expect(
-    await getBalance(publicClient, {
-      address: targetAccount.address,
-    }),
-  ).toMatchInlineSnapshot('420000000000000000000n')
-  await setBalance(testClient, {
-    address: targetAccount.address,
-    value: parseEther('69'),
-  })
-  expect(
-    await getBalance(publicClient, {
-      address: targetAccount.address,
-    }),
-  ).toMatchInlineSnapshot('69000000000000000000n')
-})