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

package/src/clients/transports/webSocket.ts

@@ -1,117 +0,0 @@
-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/ens.ts

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

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]
-  `)
-})

package/src/errors/abi.ts

@@ -1,238 +0,0 @@
-import { Hex } from '../types'
-import { BaseError } from './base'
-
-export class AbiConstructorNotFoundError extends BaseError {
-  name = 'AbiConstructorNotFoundError'
-  constructor({ docsPath }: { docsPath: string }) {
-    super(
-      [
-        'A constructor was not found on the ABI.',
-        'Make sure you are using the correct ABI and that the constructor exists on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiConstructorParamsNotFoundError extends BaseError {
-  name = 'AbiConstructorParamsNotFoundError'
-  constructor({ docsPath }: { docsPath: string }) {
-    super(
-      [
-        'Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.',
-        'Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiDecodingDataSizeInvalidError extends BaseError {
-  name = 'AbiDecodingDataSizeInvalidError'
-  constructor(size: number) {
-    super(
-      [
-        `Data size of ${size} bytes is invalid.`,
-        'Size must be in increments of 32 bytes (size % 32 === 0).',
-      ].join('\n'),
-    )
-  }
-}
-
-export class AbiDecodingZeroDataError extends BaseError {
-  name = 'AbiDecodingZeroDataError'
-  constructor() {
-    super('Cannot decode zero data ("0x") with ABI parameters.')
-  }
-}
-
-export class AbiEncodingArrayLengthMismatchError extends BaseError {
-  name = 'AbiEncodingArrayLengthMismatchError'
-  constructor({
-    expectedLength,
-    givenLength,
-    type,
-  }: { expectedLength: number; givenLength: number; type: string }) {
-    super(
-      [
-        `ABI encoding array length mismatch for type ${type}.`,
-        `Expected length: ${expectedLength}`,
-        `Given length: ${givenLength}`,
-      ].join('\n'),
-    )
-  }
-}
-
-export class AbiEncodingLengthMismatchError extends BaseError {
-  name = 'AbiEncodingLengthMismatchError'
-  constructor({
-    expectedLength,
-    givenLength,
-  }: { expectedLength: number; givenLength: number }) {
-    super(
-      [
-        'ABI encoding params/values length mismatch.',
-        `Expected length (params): ${expectedLength}`,
-        `Given length (values): ${givenLength}`,
-      ].join('\n'),
-    )
-  }
-}
-
-export class AbiErrorInputsNotFoundError extends BaseError {
-  name = 'AbiErrorInputsNotFoundError'
-  constructor(errorName: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
-        'Cannot encode error result without knowing what the parameter types are.',
-        'Make sure you are using the correct ABI and that the inputs exist on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiErrorNotFoundError extends BaseError {
-  name = 'AbiErrorNotFoundError'
-  constructor(errorName: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Error "${errorName}" not found on ABI.`,
-        'Make sure you are using the correct ABI and that the error exists on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiErrorSignatureNotFoundError extends BaseError {
-  name = 'AbiErrorSignatureNotFoundError'
-  constructor(signature: Hex, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Encoded error signature "${signature}" not found on ABI.`,
-        'Make sure you are using the correct ABI and that the error exists on it.',
-        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`,
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiEventNotFoundError extends BaseError {
-  name = 'AbiEventNotFoundError'
-  constructor(eventName: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Event "${eventName}" not found on ABI.`,
-        'Make sure you are using the correct ABI and that the event exists on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiFunctionNotFoundError extends BaseError {
-  name = 'AbiFunctionNotFoundError'
-  constructor(functionName: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Function "${functionName}" not found on ABI.`,
-        'Make sure you are using the correct ABI and that the function exists on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiFunctionOutputsNotFoundError extends BaseError {
-  name = 'AbiFunctionOutputsNotFoundError'
-  constructor(functionName: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
-        'Cannot decode function result without knowing what the parameter types are.',
-        'Make sure you are using the correct ABI and that the function exists on it.',
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class AbiFunctionSignatureNotFoundError extends BaseError {
-  name = 'AbiFunctionSignatureNotFoundError'
-  constructor(signature: Hex, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Encoded function signature "${signature}" not found on ABI.`,
-        'Make sure you are using the correct ABI and that the function exists on it.',
-        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`,
-      ].join('\n'),
-      {
-        docsPath,
-      },
-    )
-  }
-}
-
-export class InvalidAbiEncodingTypeError extends BaseError {
-  name = 'InvalidAbiEncodingType'
-  constructor(type: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Type "${type}" is not a valid encoding type.`,
-        'Please provide a valid ABI type.',
-      ].join('\n'),
-      { docsPath },
-    )
-  }
-}
-
-export class InvalidAbiDecodingTypeError extends BaseError {
-  name = 'InvalidAbiDecodingType'
-  constructor(type: string, { docsPath }: { docsPath: string }) {
-    super(
-      [
-        `Type "${type}" is not a valid decoding type.`,
-        'Please provide a valid ABI type.',
-      ].join('\n'),
-      { docsPath },
-    )
-  }
-}
-
-export class InvalidArrayError extends BaseError {
-  name = 'InvalidArrayError'
-  constructor(value: unknown) {
-    super([`Value "${value}" is not a valid array.`].join('\n'))
-  }
-}
-
-export class InvalidDefinitionTypeError extends BaseError {
-  name = 'InvalidDefinitionTypeError'
-  constructor(type: string) {
-    super(
-      [
-        `"${type}" is not a valid definition type.`,
-        'Valid types: "function", "event", "error"',
-      ].join('\n'),
-    )
-  }
-}

package/src/errors/address.test.ts

@@ -1,14 +0,0 @@
-import { expect, test } from 'vitest'
-import { InvalidAddressError } from './address'
-
-test('InvalidAddressError', () => {
-  expect(
-    new InvalidAddressError({
-      address: '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az',
-    }),
-  ).toMatchInlineSnapshot(`
-    [InvalidAddressError: Address "0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az" is invalid.
-
-    Version: viem@1.0.2]
-  `)
-})

package/src/errors/address.ts

@@ -1,9 +0,0 @@
-import { Address } from '../types'
-import { BaseError } from './base'
-
-export class InvalidAddressError extends BaseError {
-  name = 'InvalidAddressError'
-  constructor({ address }: { address: Address }) {
-    super(`Address "${address}" is invalid.`)
-  }
-}