viem 0.0.1-alpha.2 → 0.0.1-alpha.20

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,62 @@
+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,22 @@
+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
+    Internal Error: {"code":-4902,"details":"Unrecognized chain."}]
+  `)
+})

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,41 @@
+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
+    Internal Error: {\\"code\\":-32602,\\"details\\":\\"Token type ERC721 not supported.\\"}"
+  `)
+})

package/src/actions/wallet/watchAsset.ts

@@ -0,0 +1,16 @@
+import type { WalletClient } from '../../clients'
+import type { WatchAssetParams } from '../../types/eip1193'
+
+export type WatchAssetArgs = WatchAssetParams
+export type WatchAssetResponse = boolean
+
+export async function watchAsset(
+  client: WalletClient,
+  params: WatchAssetParams,
+): Promise<WatchAssetResponse> {
+  const added = await client.request({
+    method: 'wallet_watchAsset',
+    params: [params],
+  })
+  return added
+}

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

@@ -0,0 +1,54 @@
+import { expect, test } from 'vitest'
+import {
+  accounts,
+  publicClient,
+  testClient,
+  wagmiContractConfig,
+  walletClient,
+} from '../../_test'
+import { simulateContract } from '../public'
+import { mine } from '../test'
+
+import { writeContract } from './writeContract'
+
+test('default', async () => {
+  expect(
+    await writeContract(walletClient, {
+      ...wagmiContractConfig,
+      from: accounts[0].address,
+      functionName: 'mint',
+      args: [69420n],
+    }),
+  ).toBeDefined()
+})
+
+test('w/ simulateContract', async () => {
+  const { request } = await simulateContract(publicClient, {
+    ...wagmiContractConfig,
+    from: accounts[0].address,
+    functionName: 'mint',
+    args: [69420n],
+  })
+  expect(await writeContract(walletClient, request)).toBeDefined()
+
+  await mine(testClient, { blocks: 1 })
+
+  await expect(() =>
+    simulateContract(publicClient, {
+      ...wagmiContractConfig,
+      from: accounts[0].address,
+      functionName: 'mint',
+      args: [69420n],
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Token ID is taken
+     
+    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  mint(uint256 tokenId)
+    Arguments:     (69420)
+
+    Details: execution reverted: Token ID is taken
+    Version: viem@1.0.2"
+  `)
+})

package/src/actions/wallet/writeContract.ts

@@ -0,0 +1,56 @@
+import { Abi } from 'abitype'
+
+import type { WalletClient } from '../../clients'
+import type {
+  Address,
+  Chain,
+  ExtractArgsFromAbi,
+  ExtractFunctionNameFromAbi,
+  GetValue,
+} from '../../types'
+import { EncodeFunctionDataArgs, encodeFunctionData } from '../../utils'
+import {
+  sendTransaction,
+  SendTransactionArgs,
+  SendTransactionResponse,
+} from './sendTransaction'
+
+export type WriteContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {
+  address: Address
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
+export type WriteContractResponse = SendTransactionResponse
+
+export async function writeContract<
+  TChain extends Chain,
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>(
+  client: WalletClient,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...request
+  }: WriteContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<WriteContractResponse> {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)
+  const hash = await sendTransaction(client, {
+    data,
+    to: address,
+    ...request,
+  } as unknown as SendTransactionArgs<TChain>)
+  return hash
+}