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

package/src/actions/wallet/sendTransaction.ts

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

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

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

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

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

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

package/src/actions/wallet/watchAsset.ts

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

@@ -1,84 +0,0 @@
-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',
-    }),
-  ).toBeDefined()
-})
-
-test('overloaded function', 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',
-  })
-  expect(await writeContract(walletClient, request)).toBeDefined()
-
-  await mine(testClient, { blocks: 1 })
-
-  expect(
-    await simulateContract(publicClient, {
-      ...wagmiContractConfig,
-      from: accounts[0].address,
-      functionName: 'mint',
-    }),
-  ).toBeDefined()
-})
-
-test('w/ simulateContract (overloaded)', async () => {
-  const { request } = await simulateContract(publicClient, {
-    ...wagmiContractConfig,
-    from: accounts[0].address,
-    functionName: 'mint',
-    args: [69421n],
-  })
-  expect(await writeContract(walletClient, request)).toBeDefined()
-
-  await mine(testClient, { blocks: 1 })
-
-  await expect(() =>
-    simulateContract(publicClient, {
-      ...wagmiContractConfig,
-      from: accounts[0].address,
-      functionName: 'mint',
-      args: [69421n],
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "The contract function \\"mint\\" reverted with the following reason:
-    Token ID is taken
-
-    Contract:  0x0000000000000000000000000000000000000000
-    Function:  mint(uint256 tokenId)
-    Arguments:     (69421)
-    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
-
-    Docs: https://viem.sh/docs/contract/simulateContract
-    Version: viem@1.0.2"
-  `)
-})

package/src/actions/wallet/writeContract.ts

@@ -1,47 +0,0 @@
-import { Abi } from 'abitype'
-
-import type { WalletClient } from '../../clients'
-import type { Chain, ContractConfig, 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 = string,
-> = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {
-  value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>
-} & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
-
-export type WriteContractResponse = SendTransactionResponse
-
-export async function writeContract<
-  TChain extends Chain,
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
->(
-  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
-}