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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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