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

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

@@ -0,0 +1,55 @@
+import { expect, test } from 'vitest'
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { baycContractConfig } from '../../_test/abis'
+import { parseEther } from '../../utils'
+import { mine, setBalance } from '../test'
+
+import { deployContract } from './deployContract'
+import { getTransactionReceipt } from '../public'
+
+test('default', async () => {
+  const hash = await deployContract(walletClient, {
+    ...baycContractConfig,
+    args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
+    from: accounts[0].address,
+  })
+  expect(hash).toBeDefined()
+
+  await mine(testClient, { blocks: 1 })
+  const { contractAddress } = await getTransactionReceipt(publicClient, {
+    hash,
+  })
+
+  // expect(
+  //   await simulateContract(publicClient, {
+  //     abi: baycContractConfig.abi,
+  //     address: contractAddress!,
+  //     functionName: 'symbol',
+  //   }),
+  // ).toBe('BAYC')
+})
+
+test('no funds', async () => {
+  await setBalance(testClient, {
+    address: accounts[0].address,
+    value: parseEther('0'),
+  })
+
+  await expect(() =>
+    deployContract(walletClient, {
+      ...baycContractConfig,
+      args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
+      from: accounts[0].address,
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Transaction creation failed.
+
+    Details: Insufficient funds for gas * price + value
+    Version: viem@1.0.2"
+  `)
+
+  await setBalance(testClient, {
+    address: accounts[0].address,
+    value: parseEther('10000'),
+  })
+})

package/src/actions/wallet/deployContract.ts

@@ -0,0 +1,38 @@
+import { Abi, Narrow } from 'abitype'
+import { WalletClient } from '../../clients'
+
+import { Chain, ExtractConstructorArgsFromAbi, Hex } from '../../types'
+import { encodeDeployData } from '../../utils'
+import {
+  sendTransaction,
+  SendTransactionArgs,
+  SendTransactionResponse,
+} from '../wallet'
+
+export type DeployContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+> = Omit<
+  SendTransactionArgs<TChain>,
+  'accessList' | 'to' | 'data' | 'value'
+> & {
+  abi: Narrow<TAbi>
+  bytecode: Hex
+} & ExtractConstructorArgsFromAbi<TAbi>
+
+export type DeployContractResponse = SendTransactionResponse
+
+export function deployContract<TChain extends Chain, TAbi extends Abi>(
+  walletClient: WalletClient,
+  { abi, args, bytecode, ...request }: DeployContractArgs<TChain, TAbi>,
+): Promise<DeployContractResponse> {
+  const calldata = encodeDeployData({
+    abi,
+    args,
+    bytecode,
+  } as unknown as DeployContractArgs<TChain, TAbi>)
+  return sendTransaction(walletClient, {
+    ...request,
+    data: calldata,
+  } as unknown as SendTransactionArgs<TChain>)
+}

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "addChain": [Function],
+      "deployContract": [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

@@ -0,0 +1,36 @@
+export { addChain } from './addChain'
+
+export { deployContract } from './deployContract'
+export type {
+  DeployContractArgs,
+  DeployContractResponse,
+} from './deployContract'
+
+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

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

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

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

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

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