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

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

@@ -0,0 +1,164 @@
+import { assertType, describe, expect, test } from 'vitest'
+import WebSocket from 'isomorphic-ws'
+
+import { localWsUrl } from '../../_test'
+import { localhost } from '../../chains'
+import { wait } from '../../utils/wait'
+import type { WebSocketTransport } from './webSocket'
+import { webSocket } from './webSocket'
+
+test('default', () => {
+  const transport = webSocket(localWsUrl)
+
+  assertType<WebSocketTransport>(transport)
+  assertType<'webSocket'>(transport({}).config.type)
+
+  expect(transport).toMatchInlineSnapshot('[Function]')
+})
+
+describe('config', () => {
+  test('key', () => {
+    const transport = webSocket(localWsUrl, {
+      key: 'mock',
+    })
+
+    expect(transport({})).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "mock",
+          "name": "WebSocket JSON-RPC",
+          "request": [Function],
+          "type": "webSocket",
+        },
+        "value": {
+          "getSocket": [Function],
+          "subscribe": [Function],
+        },
+      }
+    `)
+  })
+
+  test('name', () => {
+    const transport = webSocket(localWsUrl, {
+      name: 'Mock Transport',
+    })
+
+    expect(transport({})).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "webSocket",
+          "name": "Mock Transport",
+          "request": [Function],
+          "type": "webSocket",
+        },
+        "value": {
+          "getSocket": [Function],
+          "subscribe": [Function],
+        },
+      }
+    `)
+  })
+
+  test('url', () => {
+    const transport = webSocket('https://mockapi.com/rpc')
+
+    expect(transport({})).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "webSocket",
+          "name": "WebSocket JSON-RPC",
+          "request": [Function],
+          "type": "webSocket",
+        },
+        "value": {
+          "getSocket": [Function],
+          "subscribe": [Function],
+        },
+      }
+    `)
+  })
+})
+
+test('getSocket', async () => {
+  const transport = webSocket(localWsUrl)
+  const socket = await transport({}).value?.getSocket()
+  expect(socket).toBeDefined()
+  expect(socket?.readyState).toBe(WebSocket.OPEN)
+})
+
+test('request', async () => {
+  const transport = webSocket(undefined, {
+    key: 'jsonRpc',
+    name: 'JSON RPC',
+  })
+
+  expect(
+    await transport({
+      chain: {
+        ...localhost,
+        rpcUrls: {
+          public: { http: [localWsUrl], webSocket: [localWsUrl] },
+          default: { http: [localWsUrl], webSocket: [localWsUrl] },
+        },
+      },
+    }).config.request({
+      method: 'eth_blockNumber',
+    }),
+  ).toBeDefined()
+})
+
+test('subscribe', async () => {
+  const transport = webSocket(localWsUrl, {
+    key: 'jsonRpc',
+    name: 'JSON RPC',
+  })({})
+  if (!transport.value) return
+
+  let blocks: any[] = []
+  const { subscriptionId, unsubscribe } = await transport.value.subscribe({
+    params: ['newHeads'],
+    onData: (data) => blocks.push(data),
+  })
+
+  // Make sure we are subscribed.
+  expect(subscriptionId).toBeDefined()
+
+  // Make sure we are receiving blocks.
+  await wait(2000)
+  expect(blocks.length).toBe(2)
+
+  // Make sure we unsubscribe.
+  const { result } = await unsubscribe()
+  expect(result).toBeDefined()
+
+  // Make sure we are no longer receiving blocks.
+  await wait(2000)
+  expect(blocks.length).toBe(2)
+})
+
+test('throws on bogus subscription', async () => {
+  const transport = webSocket(localWsUrl, {
+    key: 'jsonRpc',
+    name: 'JSON RPC',
+  })
+
+  let errors: any[] = []
+  await expect(() =>
+    transport({}).value?.subscribe({
+      // @ts-expect-error - testing
+      params: ['lol'],
+      onData: () => null,
+      onError: (err) => errors.push(err),
+    }),
+  ).rejects.toThrowError()
+  expect(errors.length).toBeGreaterThan(0)
+})
+
+test('no url', () => {
+  expect(() => webSocket()({})).toThrowErrorMatchingInlineSnapshot(`
+    "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.ts

@@ -0,0 +1,118 @@
+import WebSocket from 'isomorphic-ws'
+import { UrlRequiredError } from '../../errors'
+import type { Hash } from '../../types'
+import type { RpcResponse } from '../../utils/rpc'
+import { getSocket, rpc } from '../../utils/rpc'
+import type { Transport, TransportConfig } from './createTransport'
+import { createTransport } from './createTransport'
+
+type WebSocketTransportSubscribeArgs = {
+  onData: (data: RpcResponse) => void
+  onError?: (error: any) => void
+}
+
+type WebSocketTransportSubscribeResponse = {
+  subscriptionId: Hash
+  unsubscribe: () => Promise<RpcResponse<boolean>>
+}
+
+type WebSocketTransportSubscribe = {
+  subscribe(
+    args: WebSocketTransportSubscribeArgs & {
+      /**
+       * @description Add information about compiled contracts
+       * @link https://hardhat.org/hardhat-network/docs/reference#hardhat_addcompilationresult
+       */
+      params: ['newHeads']
+    },
+  ): Promise<WebSocketTransportSubscribeResponse>
+}
+
+export type WebSocketTransportConfig = {
+  /** The key of the WebSocket transport. */
+  key?: TransportConfig['key']
+  /** The name of the WebSocket transport. */
+  name?: TransportConfig['name']
+}
+
+export type WebSocketTransport = Transport<
+  'webSocket',
+  {
+    getSocket(): Promise<WebSocket>
+    subscribe: WebSocketTransportSubscribe['subscribe']
+  }
+>
+
+/**
+ * @description Creates a WebSocket transport that connects to a JSON-RPC API.
+ */
+export function webSocket(
+  /** URL of the JSON-RPC API. Defaults to the chain's public RPC URL. */
+  url?: string,
+  {
+    key = 'webSocket',
+    name = 'WebSocket JSON-RPC',
+  }: WebSocketTransportConfig = {},
+): WebSocketTransport {
+  return ({ chain }) => {
+    const url_ = url || chain?.rpcUrls.default.webSocket?.[0]
+    if (!url_) throw new UrlRequiredError()
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const socket = await getSocket(url_)
+          const { result } = await rpc.webSocketAsync(socket, {
+            body: { method, params },
+          })
+          return result
+        },
+        type: 'webSocket',
+      },
+      {
+        getSocket() {
+          return getSocket(url_)
+        },
+        async subscribe({ params, onData, onError }: any) {
+          const socket = await getSocket(url_)
+          const { result: subscriptionId } = await new Promise<any>(
+            (resolve, reject) =>
+              rpc.webSocket(socket, {
+                body: {
+                  method: 'eth_subscribe',
+                  params,
+                },
+                onData: (data) => {
+                  if (typeof data.id === 'number') {
+                    resolve(data)
+                    return
+                  }
+                  onData(data)
+                },
+                onError: (error) => {
+                  reject(error)
+                  onError?.(error)
+                },
+              }),
+          )
+          return {
+            subscriptionId,
+            async unsubscribe() {
+              return new Promise<any>((resolve, reject) =>
+                rpc.webSocket(socket, {
+                  body: {
+                    method: 'eth_unsubscribe',
+                    params: [subscriptionId],
+                  },
+                  onData: resolve,
+                  onError: reject,
+                }),
+              )
+            },
+          }
+        },
+      },
+    )
+  }
+}

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/contract.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest'
+
+import * as contract from './contract'
+
+test('exports contract actions', () => {
+  expect(Object.keys(contract)).toMatchInlineSnapshot(`
+    [
+      "getBytecode",
+      "getStorageAt",
+      "multicall",
+      "readContract",
+      "simulateContract",
+      "watchContractEvent",
+      "deployContract",
+      "writeContract",
+      "decodeAbi",
+      "decodeErrorResult",
+      "decodeEventLog",
+      "decodeFunctionData",
+      "decodeFunctionResult",
+      "encodeAbi",
+      "encodeDeployData",
+      "encodeErrorResult",
+      "encodeEventTopics",
+      "encodeFunctionData",
+      "encodeFunctionResult",
+      "formatAbiItemWithArgs",
+      "formatAbiItem",
+      "getAbiItem",
+    ]
+  `)
+})

package/src/contract.ts

@@ -0,0 +1,68 @@
+export type {
+  GetBytecodeArgs,
+  GetBytecodeResponse,
+  GetStorageAtArgs,
+  GetStorageAtResponse,
+  MulticallArgs,
+  MulticallResponse,
+  OnLogs,
+  OnLogsResponse,
+  ReadContractArgs,
+  ReadContractResponse,
+  SimulateContractArgs,
+  SimulateContractResponse,
+  WatchContractEventArgs,
+} from './actions/public'
+export {
+  getBytecode,
+  getStorageAt,
+  multicall,
+  readContract,
+  simulateContract,
+  watchContractEvent,
+} from './actions/public'
+
+export type {
+  DeployContractArgs,
+  DeployContractResponse,
+  WriteContractArgs,
+  WriteContractResponse,
+} from './actions/wallet'
+export {
+  deployContract,
+  writeContract,
+} from './actions/wallet'
+
+export type {
+  DecodeAbiArgs,
+  DecodeErrorResultArgs,
+  DecodeErrorResultResponse,
+  DecodeEventLogArgs,
+  DecodeEventLogResponse,
+  DecodeFunctionDataArgs,
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+  EncodeAbiArgs,
+  EncodeDeployDataArgs,
+  EncodeErrorResultArgs,
+  EncodeEventTopicsArgs,
+  EncodeFunctionDataArgs,
+  EncodeFunctionResultArgs,
+  GetAbiItemArgs,
+} from './utils'
+export {
+  decodeAbi,
+  decodeErrorResult,
+  decodeEventLog,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeAbi,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  formatAbiItemWithArgs,
+  formatAbiItem,
+  getAbiItem,
+} from './utils'

package/src/ens.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest'
+
+import * as ens from './ens'
+
+test('exports ens', () => {
+  expect(ens).toMatchInlineSnapshot(`
+    {
+      "getEnsAddress": [Function],
+      "getEnsName": [Function],
+      "labelhash": [Function],
+      "namehash": [Function],
+      "normalize": [Function],
+    }
+  `)
+})

package/src/ens.ts

@@ -0,0 +1,8 @@
+export type { GetEnsAddressArgs, GetEnsNameArgs } from './actions/ens'
+export { getEnsAddress, getEnsName } from './actions/ens'
+
+export {
+  labelhash,
+  namehash,
+  normalize,
+} from './utils/ens'

package/src/errors/abi.test.ts

@@ -0,0 +1,81 @@
+import { expect, test } from 'vitest'
+import {
+  AbiDecodingDataSizeInvalidError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  InvalidAbiDecodingTypeError,
+  InvalidAbiEncodingTypeError,
+  InvalidArrayError,
+} from './abi'
+
+test('AbiDecodingDataSizeInvalidError', () => {
+  expect(new AbiDecodingDataSizeInvalidError(69)).toMatchInlineSnapshot(`
+    [AbiDecodingDataSizeInvalidError: Data size of 69 bytes is invalid.
+    Size must be in increments of 32 bytes (size % 32 === 0).
+
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidAbiDecodingTypeError', () => {
+  expect(
+    new InvalidAbiDecodingTypeError('lol', { docsPath: '/lol' }),
+  ).toMatchInlineSnapshot(`
+    [InvalidAbiDecodingType: Type "lol" is not a valid decoding type.
+    Please provide a valid ABI type.
+
+    Docs: https://viem.sh/lol
+    Version: viem@1.0.2]
+  `)
+})
+
+test('AbiEncodingArrayLengthMismatchError', () => {
+  expect(
+    new AbiEncodingArrayLengthMismatchError({
+      expectedLength: 69,
+      givenLength: 420,
+      type: 'uint256[3]',
+    }),
+  ).toMatchInlineSnapshot(`
+    [AbiEncodingArrayLengthMismatchError: ABI encoding array length mismatch for type uint256[3].
+    Expected length: 69
+    Given length: 420
+
+    Version: viem@1.0.2]
+  `)
+})
+
+test('AbiEncodingLengthMismatchError', () => {
+  expect(
+    new AbiEncodingLengthMismatchError({
+      expectedLength: 69,
+      givenLength: 420,
+    }),
+  ).toMatchInlineSnapshot(`
+    [AbiEncodingLengthMismatchError: ABI encoding params/values length mismatch.
+    Expected length (params): 69
+    Given length (values): 420
+
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidAbiEncodingTypeError', () => {
+  expect(
+    new InvalidAbiEncodingTypeError('lol', { docsPath: '/lol' }),
+  ).toMatchInlineSnapshot(`
+    [InvalidAbiEncodingType: Type "lol" is not a valid encoding type.
+    Please provide a valid ABI type.
+
+    Docs: https://viem.sh/lol
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidArrayError', () => {
+  expect(new InvalidArrayError('lol')).toMatchInlineSnapshot(`
+    [InvalidArrayError: Value "lol" is not a valid array.
+
+    Version: viem@1.0.2]
+  `)
+})