viem 0.0.1-alpha.21 → 0.0.1-alpha.23

package/src/actions/public/watchEvent.test.ts

@@ -2,14 +2,14 @@ import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
 import { wait } from '../../utils/wait'
 import {
   accounts,
+  address,
   publicClient,
   testClient,
   transfer1Data,
   usdcContractConfig,
-  vitalikAddress,
   walletClient,
 } from '../../_test'
-import { impersonateAccount, stopImpersonatingAccount } from '../test'
+import { impersonateAccount, mine, stopImpersonatingAccount } from '../test'
 import { sendTransaction } from '../wallet'
 import * as createEventFilter from './createEventFilter'
 import * as getFilterChanges from './getFilterChanges'
@@ -17,47 +17,52 @@ import { OnLogsResponse, watchEvent } from './watchEvent'
 
 beforeAll(async () => {
   await impersonateAccount(testClient, {
-    address: vitalikAddress,
+    address: address.vitalik,
   })
+  await mine(testClient, { blocks: 1 })
 })
 
 afterAll(async () => {
   await stopImpersonatingAccount(testClient, {
-    address: vitalikAddress,
+    address: address.vitalik,
   })
 })
 
-test('default', async () => {
-  let logs: OnLogsResponse[] = []
+test(
+  'default',
+  async () => {
+    let logs: OnLogsResponse[] = []
 
-  const unwatch = watchEvent(publicClient, {
-    onLogs: (logs_) => logs.push(logs_),
-  })
+    const unwatch = watchEvent(publicClient, {
+      onLogs: (logs_) => logs.push(logs_),
+    })
 
-  await wait(1000)
-  await sendTransaction(walletClient, {
-    from: vitalikAddress,
-    to: usdcContractConfig.address,
-    data: transfer1Data(accounts[0].address),
-  })
-  await sendTransaction(walletClient, {
-    from: vitalikAddress,
-    to: usdcContractConfig.address,
-    data: transfer1Data(accounts[0].address),
-  })
-  await wait(1000)
-  await sendTransaction(walletClient, {
-    from: vitalikAddress,
-    to: usdcContractConfig.address,
-    data: transfer1Data(accounts[1].address),
-  })
-  await wait(2000)
-  unwatch()
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[1].address),
+    })
+    await wait(2000)
+    unwatch()
 
-  expect(logs.length).toBe(2)
-  expect(logs[0].length).toBe(2)
-  expect(logs[1].length).toBe(1)
-})
+    expect(logs.length).toBe(2)
+    expect(logs[0].length).toBe(2)
+    expect(logs[1].length).toBe(1)
+  },
+  { retry: 3 },
+)
 
 test('args: batch', async () => {
   let logs: OnLogsResponse[] = []
@@ -69,18 +74,18 @@ test('args: batch', async () => {
 
   await wait(1000)
   await sendTransaction(walletClient, {
-    from: vitalikAddress,
+    from: address.vitalik,
     to: usdcContractConfig.address,
     data: transfer1Data(accounts[0].address),
   })
   await sendTransaction(walletClient, {
-    from: vitalikAddress,
+    from: address.vitalik,
     to: usdcContractConfig.address,
     data: transfer1Data(accounts[0].address),
   })
   await wait(1000)
   await sendTransaction(walletClient, {
-    from: vitalikAddress,
+    from: address.vitalik,
     to: usdcContractConfig.address,
     data: transfer1Data(accounts[1].address),
   })
@@ -108,7 +113,7 @@ test('args: address', async () => {
 
   await wait(1000)
   await sendTransaction(walletClient, {
-    from: vitalikAddress,
+    from: address.vitalik,
     to: usdcContractConfig.address,
     data: transfer1Data(accounts[0].address),
   })
@@ -137,7 +142,7 @@ test('args: address + event', async () => {
 
   await wait(1000)
   await sendTransaction(walletClient, {
-    from: vitalikAddress,
+    from: address.vitalik,
     to: usdcContractConfig.address,
     data: transfer1Data(accounts[0].address),
   })

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

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

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

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest'
 
-import { accounts, publicClient, testClient, vitalikAddress } from '../../_test'
+import { accounts, address, publicClient, testClient } from '../../_test'
 import { parseEther } from '../../utils'
 import { getBalance } from '../public/getBalance'
 import { mine, setBalance } from '../test'
@@ -8,7 +8,7 @@ import { mine, setBalance } from '../test'
 import { sendUnsignedTransaction } from './sendUnsignedTransaction'
 
 const sourceAccount = {
-  address: vitalikAddress,
+  address: address.vitalik,
 } as const
 const targetAccount = accounts[0]
 

package/src/actions/test/stopImpersonatingAccount.test.ts

@@ -1,29 +1,27 @@
 import { expect, test } from 'vitest'
 
-import { accounts, testClient, vitalikAddress, walletClient } from '../../_test'
+import { address, accounts, testClient, walletClient } from '../../_test'
 import { parseEther } from '../../utils'
 import { sendTransaction } from '../wallet/sendTransaction'
 import { impersonateAccount } from './impersonateAccount'
 import { stopImpersonatingAccount } from './stopImpersonatingAccount'
 
-const account = vitalikAddress
-
 test('stops impersonating account', async () => {
-  await impersonateAccount(testClient, { address: account })
+  await impersonateAccount(testClient, { address: address.vitalik })
 
   expect(
     await sendTransaction(walletClient, {
-      from: account,
+      from: address.vitalik,
       to: accounts[0].address,
       value: parseEther('1'),
     }),
   ).toBeDefined()
 
-  await stopImpersonatingAccount(testClient, { address: account })
+  await stopImpersonatingAccount(testClient, { address: address.vitalik })
 
   await expect(
     sendTransaction(walletClient, {
-      from: account,
+      from: address.vitalik,
       to: accounts[0].address,
       value: parseEther('1'),
     }),

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

@@ -35,7 +35,6 @@ test('hex', async () => {
     "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"
   `,
   )

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

@@ -16,7 +16,6 @@ test('unsupported chain', async () => {
     [UnknownRpcError: An unknown RPC error occurred.
 
     Details: Unrecognized chain.
-    Version: viem@1.0.2
-    Internal Error: {"code":-4902,"details":"Unrecognized chain."}]
+    Version: viem@1.0.2]
   `)
 })

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

@@ -35,7 +35,6 @@ test('errors: unsupported type', async () => {
     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.\\"}"
+    Version: viem@1.0.2"
   `)
 })

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

@@ -12,6 +12,16 @@ 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,
@@ -27,7 +37,26 @@ test('w/ simulateContract', async () => {
     ...wagmiContractConfig,
     from: accounts[0].address,
     functionName: 'mint',
-    args: [69420n],
+  })
+  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()
 
@@ -38,17 +67,18 @@ test('w/ simulateContract', async () => {
       ...wagmiContractConfig,
       from: accounts[0].address,
       functionName: 'mint',
-      args: [69420n],
+      args: [69421n],
     }),
   ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Token ID is taken
-     
-    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+    "The contract function \\"mint\\" reverted with the following reason:
+    Token ID is taken
+
     Contract:  0x0000000000000000000000000000000000000000
     Function:  mint(uint256 tokenId)
-    Arguments:     (69420)
+    Arguments:     (69421)
+    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
 
-    Details: execution reverted: Token ID is taken
+    Docs: https://viem.sh/docs/contract/simulateContract
     Version: viem@1.0.2"
   `)
 })

package/src/actions/wallet/writeContract.ts

@@ -1,13 +1,7 @@
 import { Abi } from 'abitype'
 
 import type { WalletClient } from '../../clients'
-import type {
-  Address,
-  Chain,
-  ExtractArgsFromAbi,
-  ExtractFunctionNameFromAbi,
-  GetValue,
-} from '../../types'
+import type { Chain, ContractConfig, GetValue } from '../../types'
 import { EncodeFunctionDataArgs, encodeFunctionData } from '../../utils'
 import {
   sendTransaction,
@@ -18,20 +12,17 @@ import {
 export type WriteContractArgs<
   TChain extends Chain = Chain,
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = any,
+  TFunctionName extends string = string,
 > = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {
-  address: Address
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
   value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>
-} & ExtractArgsFromAbi<TAbi, TFunctionName>
+} & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
 
 export type WriteContractResponse = SendTransactionResponse
 
 export async function writeContract<
   TChain extends Chain,
-  TAbi extends Abi = Abi,
-  TFunctionName extends string = any,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
 >(
   client: WalletClient,
   {

package/src/clients/transports/fallback.test.ts

@@ -126,6 +126,40 @@ describe('request', () => {
     // ensure `retryCount` on transport is adhered
     expect(count).toBe(6)
   })
+
+  test('error (rpc)', async () => {
+    let count = 0
+    const server1 = await createHttpServer((req, res) => {
+      count++
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+      })
+      res.end(JSON.stringify({ error: 'ngmi' }))
+    })
+    const server2 = await createHttpServer((req, res) => {
+      count++
+      res.writeHead(500)
+      res.end()
+    })
+    const server3 = await createHttpServer((req, res) => {
+      count++
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+      })
+      res.end(JSON.stringify({ result: '0x1' }))
+    })
+
+    let transport = fallback([
+      http(server1.url),
+      http(server2.url),
+      http(server3.url),
+    ])({
+      chain: localhost,
+    })
+    await expect(() =>
+      transport.config.request({ method: 'eth_blockNumber' }),
+    ).rejects.toThrowError()
+  })
 })
 
 describe('client', () => {

package/src/clients/transports/fallback.ts

@@ -1,3 +1,4 @@
+import { HttpRequestError, RpcError } from '../../errors'
 import type { Transport, TransportConfig } from './createTransport'
 import { createTransport } from './createTransport'
 
@@ -31,7 +32,8 @@ export function fallback(
                 params,
               } as any)
             } catch (err) {
-              if (i < transports.length - 1) return fetch(i + 1)
+              if (!(err instanceof RpcError) && i < transports.length - 1)
+                return fetch(i + 1)
               throw err
             }
           }

package/src/clients/transports/http.test.ts

@@ -103,7 +103,6 @@ test('no url', () => {
     "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.
 
     Docs: https://viem.sh/docs/clients/intro
-
     Version: viem@1.0.2"
   `,
   )

package/src/clients/transports/webSocket.test.ts

@@ -158,7 +158,6 @@ test('no url', () => {
     "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.
 
     Docs: https://viem.sh/docs/clients/intro
-
     Version: viem@1.0.2"
   `)
 })

package/src/constants/abis.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from 'vitest'
+
+import * as abis from './abis'
+
+test('exports abis', () => {
+  expect(abis).toMatchInlineSnapshot(`
+    {
+      "multicall3Abi": [
+        {
+          "inputs": [
+            {
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                },
+                {
+                  "name": "allowFailure",
+                  "type": "bool",
+                },
+                {
+                  "name": "callData",
+                  "type": "bytes",
+                },
+              ],
+              "name": "calls",
+              "type": "tuple[]",
+            },
+          ],
+          "name": "aggregate3",
+          "outputs": [
+            {
+              "components": [
+                {
+                  "name": "success",
+                  "type": "bool",
+                },
+                {
+                  "name": "returnData",
+                  "type": "bytes",
+                },
+              ],
+              "name": "returnData",
+              "type": "tuple[]",
+            },
+          ],
+          "stateMutability": "view",
+          "type": "function",
+        },
+      ],
+    }
+  `)
+})

package/src/constants/abis.ts

@@ -0,0 +1,44 @@
+/* [Multicall3](https://github.com/mds1/multicall) */
+export const multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: 'target',
+            type: 'address',
+          },
+          {
+            name: 'allowFailure',
+            type: 'bool',
+          },
+          {
+            name: 'callData',
+            type: 'bytes',
+          },
+        ],
+        name: 'calls',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'aggregate3',
+    outputs: [
+      {
+        components: [
+          {
+            name: 'success',
+            type: 'bool',
+          },
+          {
+            name: 'returnData',
+            type: 'bytes',
+          },
+        ],
+        name: 'returnData',
+        type: 'tuple[]',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const

package/src/constants/index.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest'
+
+import * as index from './index'
+
+test('exports index', () => {
+  expect(Object.keys(index)).toMatchInlineSnapshot(`
+    [
+      "multicall3Abi",
+      "panicReasons",
+      "solidityError",
+      "solidityPanic",
+    ]
+  `)
+})

package/src/constants/index.ts

@@ -0,0 +1,3 @@
+export { multicall3Abi } from './abis'
+
+export { panicReasons, solidityError, solidityPanic } from './solidity'

package/src/constants/solidity.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from 'vitest'
+
+import * as solidity from './solidity'
+
+test('exports solidity constants', () => {
+  expect(solidity).toMatchInlineSnapshot(`
+    {
+      "panicReasons": {
+        "1": "An \`assert\` condition failed.",
+        "17": "Arithmic operation resulted in underflow or overflow.",
+        "18": "Division or modulo by zero (e.g. \`5 / 0\` or \`23 % 0\`).",
+        "33": "Attempted to convert to an invalid type.",
+        "34": "Attempted to access a storage byte array that is incorrectly encoded.",
+        "49": "Performed \`.pop()\` on an empty array",
+        "50": "Array index is out of bounds.",
+        "65": "Allocated too much memory or created an array which is too large.",
+        "81": "Attempted to call a zero-initialized variable of internal function type.",
+      },
+      "solidityError": {
+        "inputs": [
+          {
+            "name": "message",
+            "type": "string",
+          },
+        ],
+        "name": "Error",
+        "type": "error",
+      },
+      "solidityPanic": {
+        "inputs": [
+          {
+            "name": "reason",
+            "type": "uint256",
+          },
+        ],
+        "name": "Panic",
+        "type": "error",
+      },
+    }
+  `)
+})

package/src/constants/solidity.ts

@@ -0,0 +1,35 @@
+import { AbiError } from 'abitype'
+
+// https://docs.soliditylang.org/en/v0.8.16/control-structures.html#panic-via-assert-and-error-via-require
+export const panicReasons = {
+  1: 'An `assert` condition failed.',
+  17: 'Arithmic operation resulted in underflow or overflow.',
+  18: 'Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).',
+  33: 'Attempted to convert to an invalid type.',
+  34: 'Attempted to access a storage byte array that is incorrectly encoded.',
+  49: 'Performed `.pop()` on an empty array',
+  50: 'Array index is out of bounds.',
+  65: 'Allocated too much memory or created an array which is too large.',
+  81: 'Attempted to call a zero-initialized variable of internal function type.',
+} as const
+
+export const solidityError: AbiError = {
+  inputs: [
+    {
+      name: 'message',
+      type: 'string',
+    },
+  ],
+  name: 'Error',
+  type: 'error',
+}
+export const solidityPanic: AbiError = {
+  inputs: [
+    {
+      name: 'reason',
+      type: 'uint256',
+    },
+  ],
+  name: 'Panic',
+  type: 'error',
+}

package/src/ens.ts

@@ -0,0 +1,5 @@
+export {
+  labelhash,
+  namehash,
+  normalize,
+} from './utils'

package/src/errors/abi.test.ts

@@ -25,7 +25,6 @@ test('InvalidAbiDecodingTypeError', () => {
     Please provide a valid ABI type.
 
     Docs: https://viem.sh/lol
-
     Version: viem@1.0.2]
   `)
 })
@@ -69,7 +68,6 @@ test('InvalidAbiEncodingTypeError', () => {
     Please provide a valid ABI type.
 
     Docs: https://viem.sh/lol
-
     Version: viem@1.0.2]
   `)
 })