viem 0.0.1-sushi.26 → 0.1.0

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

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

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

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

@@ -1,44 +0,0 @@
-/* [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

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

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

package/src/constants/solidity.test.ts

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

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

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

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

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

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

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