viem 2.0.0-alpha.9 → 2.0.0-beta.1

package/utils/rpc.ts

@@ -1,15 +1,22 @@
-// @ts-ignore - TODO: TypeScript throws an error during CJS compilation here. Need to look into just rolling our own isomorphic-ws.
-import WebSocket from 'isomorphic-ws'
-import type { MessageEvent } from 'isomorphic-ws'
+import { WebSocket } from 'isows'
+import type { MessageEvent } from 'isows'
 
 import {
   HttpRequestError,
+  type HttpRequestErrorType,
   TimeoutError,
+  type TimeoutErrorType,
   WebSocketRequestError,
 } from '../errors/request.js'
-
-import { createBatchScheduler } from './promise/createBatchScheduler.js'
-import { withTimeout } from './promise/withTimeout.js'
+import type { ErrorType } from '../errors/utils.js'
+import {
+  type CreateBatchSchedulerErrorType,
+  createBatchScheduler,
+} from './promise/createBatchScheduler.js'
+import {
+  type WithTimeoutErrorType,
+  withTimeout,
+} from './promise/withTimeout.js'
 import { stringify } from './stringify.js'
 
 let id = 0
@@ -56,7 +63,7 @@ export type RpcResponse<TResult = any, TError = any> = {
 ///////////////////////////////////////////////////
 // HTTP
 
-export type HttpOptions<TBody extends RpcRequest | RpcRequest[] = RpcRequest,> =
+export type HttpOptions<TBody extends RpcRequest | RpcRequest[] = RpcRequest> =
   {
     // The RPC request body.
     body: TBody
@@ -70,6 +77,12 @@ export type HttpReturnType<
   TBody extends RpcRequest | RpcRequest[] = RpcRequest,
 > = TBody extends RpcRequest[] ? RpcResponse[] : RpcResponse
 
+export type HttpErrorType =
+  | HttpRequestErrorType
+  | TimeoutErrorType
+  | WithTimeoutErrorType
+  | ErrorType
+
 async function http<TBody extends RpcRequest | RpcRequest[]>(
   url: string,
   { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions<TBody>,
@@ -146,6 +159,8 @@ export type Socket = WebSocket & {
   subscriptions: CallbackMap
 }
 
+export type GetSocketErrorType = CreateBatchSchedulerErrorType | ErrorType
+
 export const socketsCache = /*#__PURE__*/ new Map<string, Socket>()
 
 export async function getSocket(url: string) {
@@ -157,9 +172,7 @@ export async function getSocket(url: string) {
   const { schedule } = createBatchScheduler<undefined, [Socket]>({
     id: url,
     fn: async () => {
-      let WebSocket_ = WebSocket
-      if (!WebSocket.constructor) WebSocket_ = WebSocket.WebSocket
-      const webSocket = new WebSocket_(url)
+      const webSocket = new WebSocket(url)
 
       // Set up a cache for incoming "synchronous" requests.
       const requests = new Map<Id, CallbackFn>()
@@ -219,6 +232,8 @@ export type WebSocketOptions = {
 
 export type WebSocketReturnType = Socket
 
+export type WebSocketErrorType = WebSocketRequestError | ErrorType
+
 function webSocket(
   socket: Socket,
   { body, onResponse }: WebSocketOptions,
@@ -269,6 +284,12 @@ export type WebSocketAsyncOptions = {
 
 export type WebSocketAsyncReturnType = RpcResponse
 
+export type WebSocketAsyncErrorType =
+  | WebSocketErrorType
+  | TimeoutErrorType
+  | WithTimeoutErrorType
+  | ErrorType
+
 async function webSocketAsync(
   socket: Socket,
   { body, timeout = 10_000 }: WebSocketAsyncOptions,

package/utils/signature/compactSignatureToHex.ts

@@ -0,0 +1,29 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+import type { ErrorType } from '../../errors/utils.js'
+import type { CompactSignature, Hex } from '../../types/misc.js'
+import { type HexToBigIntErrorType, hexToBigInt } from '../encoding/fromHex.js'
+
+export type CompactSignatureToHexErrorType = HexToBigIntErrorType | ErrorType
+
+/**
+ * @description Converts an [EIP-2098 compact signature](https://eips.ethereum.org/EIPS/eip-2098) into hex format.
+ *
+ * @param signature The compact signature to convert.
+ * @returns The compact signature in hex format.
+ *
+ * @example
+ * compactSignatureToHex({
+ *   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
+ *   yParityAndS: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
+ * })
+ * // "0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c"
+ */
+export function compactSignatureToHex({
+  r,
+  yParityAndS,
+}: CompactSignature): Hex {
+  return `0x${new secp256k1.Signature(
+    hexToBigInt(r),
+    hexToBigInt(yParityAndS),
+  ).toCompactHex()}`
+}

package/utils/signature/compactSignatureToSignature.ts

@@ -0,0 +1,37 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { CompactSignature, Signature } from '../../types/misc.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+export type CompactSignatureToSignatureErrorType =
+  | BytesToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+/**
+ * @description Converts an [EIP-2098 compact signature](https://eips.ethereum.org/EIPS/eip-2098) into signature format.
+ *
+ * @param signature The compact signature to convert.
+ * @returns The compact signature in signature format.
+ *
+ * @example
+ * compactSignatureToHex({
+ *   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
+ *   yParityAndS: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
+ * })
+ * // {
+ * //   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
+ * //   s: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
+ * //   v: 27n
+ * // }
+ */
+export function compactSignatureToSignature({
+  r,
+  yParityAndS,
+}: CompactSignature): Signature {
+  const yParityAndS_bytes = hexToBytes(yParityAndS)
+  const v = yParityAndS_bytes[0] & 0x80 ? 28n : 27n
+  const s = yParityAndS_bytes
+  if (v === 28n) s[0] &= 0x7f
+  return { r, s: bytesToHex(s), v }
+}

package/utils/signature/hashMessage.ts

@@ -1,7 +1,13 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
-import { concat } from '../data/concat.js'
-import { stringToBytes, toBytes } from '../encoding/toBytes.js'
-import { keccak256 } from '../hash/keccak256.js'
+import { type ConcatErrorType, concat } from '../data/concat.js'
+import {
+  type StringToBytesErrorType,
+  type ToBytesErrorType,
+  stringToBytes,
+  toBytes,
+} from '../encoding/toBytes.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
 
@@ -9,6 +15,13 @@ export type HashMessage<TTo extends To> =
   | (TTo extends 'bytes' ? ByteArray : never)
   | (TTo extends 'hex' ? Hex : never)
 
+export type HashMessageErrorType =
+  | ConcatErrorType
+  | Keccak256ErrorType
+  | StringToBytesErrorType
+  | ToBytesErrorType
+  | ErrorType
+
 export function hashMessage<TTo extends To = 'hex'>(
   message: SignableMessage,
   to_?: TTo,

package/utils/signature/hashTypedData.ts

@@ -2,13 +2,22 @@
 
 import type { AbiParameter, TypedData, TypedDataDomain } from 'abitype'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { encodeAbiParameters } from '../abi/encodeAbiParameters.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from '../abi/encodeAbiParameters.js'
 import { concat } from '../data/concat.js'
-import { toHex } from '../encoding/toHex.js'
-import { keccak256 } from '../hash/keccak256.js'
-import { getTypesForEIP712Domain, validateTypedData } from '../typedData.js'
+import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import {
+  type GetTypesForEIP712DomainErrorType,
+  type ValidateTypedDataErrorType,
+  getTypesForEIP712Domain,
+  validateTypedData,
+} from '../typedData.js'
 
 type MessageTypeProperty = {
   name: string
@@ -22,6 +31,13 @@ export type HashTypedDataParameters<
 
 export type HashTypedDataReturnType = Hex
 
+export type HashTypedDataErrorType =
+  | GetTypesForEIP712DomainErrorType
+  | HashDomainErrorType
+  | HashStructErrorType
+  | ValidateTypedDataErrorType
+  | ErrorType
+
 export function hashTypedData<
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',
@@ -68,6 +84,8 @@ export function hashTypedData<
   return keccak256(concat(parts))
 }
 
+export type HashDomainErrorType = HashStructErrorType | ErrorType
+
 export function hashDomain({
   domain,
   types,
@@ -82,6 +100,8 @@ export function hashDomain({
   })
 }
 
+type HashStructErrorType = EncodeDataErrorType | Keccak256ErrorType | ErrorType
+
 function hashStruct({
   data,
   primaryType,
@@ -99,6 +119,12 @@ function hashStruct({
   return keccak256(encoded)
 }
 
+type EncodeDataErrorType =
+  | EncodeAbiParametersErrorType
+  | EncodeFieldErrorType
+  | HashTypeErrorType
+  | ErrorType
+
 function encodeData({
   data,
   primaryType,
@@ -125,6 +151,12 @@ function encodeData({
   return encodeAbiParameters(encodedTypes, encodedValues)
 }
 
+type HashTypeErrorType =
+  | ToHexErrorType
+  | EncodeTypeErrorType
+  | Keccak256ErrorType
+  | ErrorType
+
 function hashType({
   primaryType,
   types,
@@ -136,6 +168,8 @@ function hashType({
   return keccak256(encodedHashType)
 }
 
+type EncodeTypeErrorType = FindTypeDependenciesErrorType
+
 function encodeType({
   primaryType,
   types,
@@ -157,6 +191,8 @@ function encodeType({
   return result
 }
 
+type FindTypeDependenciesErrorType = ErrorType
+
 function findTypeDependencies(
   {
     primaryType: primaryType_,
@@ -181,6 +217,12 @@ function findTypeDependencies(
   return results
 }
 
+type EncodeFieldErrorType =
+  | Keccak256ErrorType
+  | EncodeAbiParametersErrorType
+  | ToHexErrorType
+  | ErrorType
+
 function encodeField({
   types,
   name,

package/utils/signature/hexToCompactSignature.ts

@@ -0,0 +1,28 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+
+import type { ErrorType } from '../../errors/utils.js'
+import type { CompactSignature, Hex } from '../../types/misc.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+
+export type HexToCompactSignatureErrorType = NumberToHexErrorType | ErrorType
+
+/**
+ * @description Parses a hex formatted compact signature into a structured compact signature.
+ *
+ * @param signatureHex Signature in hex format.
+ * @returns The structured signature.
+ *
+ * @example
+ * hexToCompactSignature('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c')
+ * // { r: '0x...', yParityAndS: '0x...' }
+ */
+export function hexToCompactSignature(signatureHex: Hex): CompactSignature {
+  const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130))
+  return {
+    r: numberToHex(r, { size: 32 }),
+    yParityAndS: numberToHex(s, { size: 32 }),
+  }
+}

package/utils/signature/hexToSignature.ts

@@ -1,7 +1,13 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex, Signature } from '../../types/misc.js'
-import { numberToHex } from '../../utils/encoding/toHex.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+
+export type HexToSignatureErrorType = NumberToHexErrorType | ErrorType
 
 /**
  * @description Parses a hex formatted signature into a structured signature.

package/utils/signature/recoverAddress.ts

@@ -3,14 +3,18 @@ import type { Address } from 'abitype'
 import { publicKeyToAddress } from '../../accounts/utils/publicKeyToAddress.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import { recoverPublicKey } from './recoverPublicKey.js'
 
 export type RecoverAddressParameters = {
   hash: Hex | ByteArray
   signature: Hex | ByteArray
 }
+
 export type RecoverAddressReturnType = Address
 
+export type RecoverAddressErrorType = ErrorType
+
 export async function recoverAddress({
   hash,
   signature,

package/utils/signature/recoverMessageAddress.ts

@@ -2,15 +2,25 @@ import type { Address } from 'abitype'
 
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 
-import { hashMessage } from './hashMessage.js'
-import { recoverAddress } from './recoverAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type HashMessageErrorType, hashMessage } from './hashMessage.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from './recoverAddress.js'
 
 export type RecoverMessageAddressParameters = {
   message: SignableMessage
   signature: Hex | ByteArray
 }
+
 export type RecoverMessageAddressReturnType = Address
 
+export type RecoverMessageAddressErrorType =
+  | HashMessageErrorType
+  | RecoverAddressErrorType
+  | ErrorType
+
 export async function recoverMessageAddress({
   message,
   signature,

package/utils/signature/recoverPublicKey.ts

@@ -1,14 +1,21 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { hexToNumber } from '../encoding/fromHex.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type HexToNumberErrorType, hexToNumber } from '../encoding/fromHex.js'
 import { toHex } from '../encoding/toHex.js'
 
 export type RecoverPublicKeyParameters = {
   hash: Hex | ByteArray
   signature: Hex | ByteArray
 }
+
 export type RecoverPublicKeyReturnType = Hex
 
+export type RecoverPublicKeyErrorType =
+  | HexToNumberErrorType
+  | IsHexErrorType
+  | ErrorType
+
 export async function recoverPublicKey({
   hash,
   signature,

package/utils/signature/recoverTypedDataAddress.ts

@@ -3,8 +3,12 @@ import type { Address, TypedData } from 'abitype'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
 
-import { hashTypedData } from './hashTypedData.js'
-import { recoverAddress } from './recoverAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type HashTypedDataErrorType, hashTypedData } from './hashTypedData.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from './recoverAddress.js'
 
 export type RecoverTypedDataAddressParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
@@ -12,8 +16,14 @@ export type RecoverTypedDataAddressParameters<
 > = TypedDataDefinition<typedData, primaryType> & {
   signature: Hex | ByteArray
 }
+
 export type RecoverTypedDataAddressReturnType = Address
 
+export type RecoverTypedDataAddressErrorType =
+  | RecoverAddressErrorType
+  | HashTypedDataErrorType
+  | ErrorType
+
 export async function recoverTypedDataAddress<
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',

package/utils/signature/signatureToCompactSignature.ts

@@ -0,0 +1,44 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { CompactSignature, Signature } from '../../types/misc.js'
+import {
+  type BytesToHexErrorType,
+  type HexToBytesErrorType,
+  bytesToHex,
+  hexToBytes,
+} from '../index.js'
+
+export type SignatureToCompactSignatureErrorType =
+  | HexToBytesErrorType
+  | BytesToHexErrorType
+  | ErrorType
+
+/**
+ * @description Converts a signature into an [EIP-2098 compact signature](https://eips.ethereum.org/EIPS/eip-2098).
+ *
+ * @param signature The signature to convert.
+ * @returns The signature in compact format.
+ *
+ * @example
+ * signatureToCompactSignature({
+ *   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
+ *   s: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
+ *   v: 27n
+ * })
+ * // {
+ * //   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
+ * //   yParityAndS: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'
+ * // }
+ */
+export function signatureToCompactSignature(
+  signature: Signature,
+): CompactSignature {
+  const { r, s, v } = signature
+  const yParity = v - 27n
+  let yParityAndS = s
+  if (yParity === 1n) {
+    const bytes = hexToBytes(s)
+    bytes[0] |= 0x80
+    yParityAndS = bytesToHex(bytes)
+  }
+  return { r, yParityAndS }
+}

package/utils/signature/signatureToHex.ts

@@ -1,8 +1,17 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex, Signature } from '../../types/misc.js'
-import { hexToBigInt } from '../../utils/encoding/fromHex.js'
-import { toHex } from '../../utils/encoding/toHex.js'
+import {
+  type HexToBigIntErrorType,
+  hexToBigInt,
+} from '../../utils/encoding/fromHex.js'
+import { type ToHexErrorType, toHex } from '../../utils/encoding/toHex.js'
+
+export type SignatureToHexErrorType =
+  | HexToBigIntErrorType
+  | ToHexErrorType
+  | ErrorType
 
 /**
  * @description Converts a signature into hex format.

package/utils/signature/verifyMessage.ts

@@ -1,10 +1,17 @@
 import type { Address } from 'abitype'
 
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
-import { getAddress } from '../address/getAddress.js'
-import { isAddressEqual } from '../address/isAddressEqual.js'
+import { type GetAddressErrorType, getAddress } from '../address/getAddress.js'
+import {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from '../address/isAddressEqual.js'
 
-import { recoverMessageAddress } from './recoverMessageAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type RecoverMessageAddressErrorType,
+  recoverMessageAddress,
+} from './recoverMessageAddress.js'
 
 export type VerifyMessageParameters = {
   /** The address that signed the original message. */
@@ -17,6 +24,12 @@ export type VerifyMessageParameters = {
 
 export type VerifyMessageReturnType = boolean
 
+export type VerifyMessageErrorType =
+  | IsAddressEqualErrorType
+  | GetAddressErrorType
+  | RecoverMessageAddressErrorType
+  | ErrorType
+
 /**
  * Verify that a message was signed by the provided address.
  *

package/utils/signature/verifyTypedData.ts

@@ -2,9 +2,13 @@ import type { Address, TypedData } from 'abitype'
 
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { getAddress } from '../address/getAddress.js'
-import { isAddressEqual } from '../address/isAddressEqual.js'
+import { type GetAddressErrorType, getAddress } from '../address/getAddress.js'
+import {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from '../address/isAddressEqual.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import {
   type RecoverTypedDataAddressParameters,
   recoverTypedDataAddress,
@@ -22,6 +26,12 @@ export type VerifyTypedDataParameters<
 
 export type VerifyTypedDataReturnType = boolean
 
+export type VerifyTypedDataErrorType =
+  | IsAddressEqualErrorType
+  | GetAddressErrorType
+  | RecoverTypedDataAddressParameters
+  | ErrorType
+
 /**
  * Verify that typed data was signed by the provided address.
  *

package/utils/stringify.ts

@@ -1,3 +1,7 @@
+import type { ErrorType } from '../errors/utils.js'
+
+export type StringifyErrorType = ErrorType
+
 export const stringify: typeof JSON.stringify = (value, replacer, space) =>
   JSON.stringify(
     value,

package/utils/transaction/assertRequest.ts

@@ -1,13 +1,36 @@
-import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
 import type { SendTransactionParameters } from '../../actions/wallet/sendTransaction.js'
-import { InvalidAddressError } from '../../errors/address.js'
-import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
-import { FeeConflictError } from '../../errors/transaction.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import {
+  FeeCapTooHighError,
+  type FeeCapTooHighErrorType,
+  TipAboveFeeCapError,
+  type TipAboveFeeCapErrorType,
+} from '../../errors/node.js'
+import {
+  FeeConflictError,
+  type FeeConflictErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import { isAddress } from '../address/isAddress.js'
 
 export type AssertRequestParameters = Partial<SendTransactionParameters<Chain>>
 
+export type AssertRequestErrorType =
+  | InvalidAddressErrorType
+  | FeeConflictErrorType
+  | FeeCapTooHighErrorType
+  | ParseAccountErrorType
+  | TipAboveFeeCapErrorType
+  | ErrorType
+
 export function assertRequest(args: AssertRequestParameters) {
   const {
     account: account_,