@feelyourprotocol/util 8141.0.0

package/src/mapDB.ts

@@ -0,0 +1,57 @@
+import { bytesToUnprefixedHex } from './bytes.ts'
+
+import type { BatchDBOp, DB, DBObject } from './db.ts'
+
+export class MapDB<
+  TKey extends Uint8Array | string | number,
+  TValue extends Uint8Array | string | DBObject,
+> implements DB<TKey, TValue>
+{
+  _database: Map<TKey, TValue>
+
+  constructor(database?: Map<TKey, TValue>) {
+    this._database = database ?? new Map<TKey, TValue>()
+  }
+
+  async get(key: TKey): Promise<TValue | undefined> {
+    const dbKey = key instanceof Uint8Array ? bytesToUnprefixedHex(key) : key.toString()
+    return this._database.get(dbKey as TKey)
+  }
+
+  async put(key: TKey, val: TValue): Promise<void> {
+    // Using deprecated bytesToUnprefixedHex for performance: used as Map keys (string encoding).
+    const dbKey = key instanceof Uint8Array ? bytesToUnprefixedHex(key) : key.toString()
+    this._database.set(dbKey as TKey, val)
+  }
+
+  async del(key: TKey): Promise<void> {
+    // Using deprecated bytesToUnprefixedHex for performance: used as Map keys (string encoding).
+    const dbKey = key instanceof Uint8Array ? bytesToUnprefixedHex(key) : key.toString()
+    this._database.delete(dbKey as TKey)
+  }
+
+  async batch(opStack: BatchDBOp<TKey, TValue>[]): Promise<void> {
+    for (const op of opStack) {
+      if (op.type === 'del') {
+        await this.del(op.key)
+      }
+
+      if (op.type === 'put') {
+        await this.put(op.key, op.value)
+      }
+    }
+  }
+
+  /**
+   * Note that the returned shallow copy will share the underlying database with the original
+   *
+   * @returns DB
+   */
+  shallowCopy(): DB<TKey, TValue> {
+    return new MapDB<TKey, TValue>(this._database)
+  }
+
+  open() {
+    return Promise.resolve()
+  }
+}

package/src/provider.ts

@@ -0,0 +1,109 @@
+import { EthereumJSErrorWithoutCode } from './errors.ts'
+
+type rpcParams = {
+  method: string
+  params: (string | string[] | boolean | number)[]
+}
+
+export type FetchFromProviderOptions = {
+  /** Request timeout in milliseconds (default: 60000) */
+  timeout?: number
+}
+
+/**
+ * Makes a simple RPC call to a remote Ethereum JSON-RPC provider and passes through the response.
+ * No parameter or response validation is done.
+ *
+ * @param url the URL for the JSON RPC provider
+ * @param params the parameters for the JSON-RPC method - refer to
+ * https://ethereum.org/en/developers/docs/apis/json-rpc/ for details on RPC methods
+ * @param options optional settings (e.g. timeout)
+ * @returns the `result` field from the JSON-RPC response
+ * @example
+ * ```ts
+ * const provider = 'https://mainnet.infura.io/v3/...'
+ * const params = {
+ *   method: 'eth_getBlockByNumber',
+ *   params: ['latest', false],
+ * }
+ * const block = await fetchFromProvider(provider, params)
+ * ```
+ */
+export const fetchFromProvider = async (
+  url: string,
+  params: rpcParams,
+  options?: FetchFromProviderOptions,
+) => {
+  const timeout = options?.timeout ?? 60_000
+  const data = JSON.stringify({
+    method: params.method,
+    params: params.params,
+    jsonrpc: '2.0',
+    id: 1,
+  })
+
+  let signal: AbortSignal
+  let timer: ReturnType<typeof setTimeout> | undefined
+  if (typeof AbortSignal.timeout === 'function') {
+    signal = AbortSignal.timeout(timeout)
+  } else {
+    const controller = new AbortController()
+    signal = controller.signal
+    timer = setTimeout(() => controller.abort(), timeout)
+  }
+
+  const res = await fetch(url, {
+    headers: {
+      'content-type': 'application/json',
+    },
+    method: 'POST',
+    body: data,
+    signal,
+  }).finally(() => {
+    if (timer !== undefined) clearTimeout(timer)
+  })
+  if (!res.ok) {
+    throw EthereumJSErrorWithoutCode(
+      `JSONRPCError: ${JSON.stringify(
+        {
+          method: params.method,
+          status: res.status,
+          message: await res.text().catch(() => {
+            return 'Could not parse error message likely because of a network error'
+          }),
+        },
+        null,
+        2,
+      )}`,
+    )
+  }
+  const json = await res.json()
+  // TODO we should check json.error here
+  return json.result
+}
+
+/**
+ *
+ * @param provider a URL string or {@link EthersProvider}
+ * @returns the extracted URL string for the JSON-RPC Provider
+ */
+export const getProvider = (provider: string | EthersProvider) => {
+  if (typeof provider === 'string') {
+    return provider
+  } else if (typeof provider === 'object' && provider._getConnection !== undefined) {
+    return provider._getConnection().url
+  } else {
+    throw EthereumJSErrorWithoutCode('Must provide valid provider URL or Web3Provider')
+  }
+}
+
+/**
+ * A partial interface for an `ethers` `JSONRPCProvider`
+ * We only use the url string since we do raw `fetch` calls to
+ * retrieve the necessary data
+ */
+export interface EthersProvider {
+  _getConnection: () => {
+    url: string
+  }
+}

package/src/request.ts

@@ -0,0 +1,48 @@
+import { concatBytes } from './bytes.ts'
+
+import type { PrefixedHexString } from './types.ts'
+
+export type RequestBytes = Uint8Array
+
+export type CLRequestType = (typeof CLRequestType)[keyof typeof CLRequestType]
+
+export const CLRequestType = {
+  Deposit: 0,
+  Withdrawal: 1,
+  Consolidation: 2,
+} as const
+
+export interface RequestJSON {
+  type: PrefixedHexString
+  data: PrefixedHexString
+}
+
+export class CLRequest<T extends CLRequestType> {
+  // for easy use
+  public readonly bytes: Uint8Array
+
+  get type() {
+    return this.bytes[0] as T
+  }
+
+  get data() {
+    return this.bytes.subarray(1)
+  }
+
+  constructor(requestType: T, requestData: Uint8Array) {
+    this.bytes = concatBytes(new Uint8Array([requestType]), requestData)
+  }
+}
+
+export function createCLRequest(bytes: Uint8Array): CLRequest<CLRequestType> {
+  switch (bytes[0]) {
+    case CLRequestType.Deposit:
+      return new CLRequest(CLRequestType.Deposit, bytes.subarray(1))
+    case CLRequestType.Withdrawal:
+      return new CLRequest(CLRequestType.Withdrawal, bytes.subarray(1))
+    case CLRequestType.Consolidation:
+      return new CLRequest(CLRequestType.Consolidation, bytes.subarray(1))
+    default:
+      throw Error(`Invalid request type=${bytes[0]}`)
+  }
+}

package/src/signature.ts

@@ -0,0 +1,202 @@
+import { secp256k1 } from '@noble/curves/secp256k1.js'
+import { keccak_256 } from '@noble/hashes/sha3.js'
+
+import {
+  bigIntToBytes,
+  bytesToBigInt,
+  bytesToHex,
+  bytesToInt,
+  concatBytes,
+  hexToBytes,
+  setLengthLeft,
+  utf8ToBytes,
+} from './bytes.ts'
+import {
+  BIGINT_0,
+  BIGINT_1,
+  BIGINT_2,
+  BIGINT_27,
+  SECP256K1_ORDER,
+  SECP256K1_ORDER_DIV_2,
+} from './constants.ts'
+import { EthereumJSErrorWithoutCode } from './errors.ts'
+import { assertIsBytes } from './helpers.ts'
+
+import type { PrefixedHexString } from './types.ts'
+
+export function calculateSigRecovery(v: bigint, chainId?: bigint): bigint {
+  if (v === BIGINT_0 || v === BIGINT_1) return v
+
+  if (chainId === undefined) {
+    return v - BIGINT_27
+  }
+  return v - (chainId * BIGINT_2 + BigInt(35))
+}
+
+function isValidSigRecovery(recovery: bigint): boolean {
+  return recovery === BIGINT_0 || recovery === BIGINT_1
+}
+
+/**
+ * ECDSA public key recovery from signature.
+ * NOTE: Accepts `v === 0 | v === 1` for EIP1559 transactions
+ * @returns Recovered public key
+ */
+export const ecrecover = function (
+  msgHash: Uint8Array,
+  v: bigint,
+  r: Uint8Array,
+  s: Uint8Array,
+  chainId?: bigint,
+): Uint8Array {
+  const signature = concatBytes(setLengthLeft(r, 32), setLengthLeft(s, 32))
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw EthereumJSErrorWithoutCode('Invalid signature v value')
+  }
+
+  const sig = secp256k1.Signature.fromBytes(signature).addRecoveryBit(Number(recovery))
+  const senderPubKey = sig.recoverPublicKey(msgHash)
+  return senderPubKey.toBytes(false).slice(1)
+}
+
+/**
+ * Convert signature parameters into the format of `eth_sign` RPC method.
+ * NOTE: Accepts `v === 0 | v === 1` for EIP1559 transactions
+ * @returns Signature
+ */
+export const toRPCSig = function (
+  v: bigint,
+  r: Uint8Array,
+  s: Uint8Array,
+  chainId?: bigint,
+): string {
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw EthereumJSErrorWithoutCode('Invalid signature v value')
+  }
+
+  // geth (and the RPC eth_sign method) uses the 65 byte format used by Bitcoin
+
+  return bytesToHex(concatBytes(setLengthLeft(r, 32), setLengthLeft(s, 32), bigIntToBytes(v)))
+}
+
+/**
+ * Convert signature parameters into the format of Compact Signature Representation (EIP-2098).
+ * NOTE: Accepts `v === 0 | v === 1` for EIP1559 transactions
+ * @returns Signature
+ */
+export const toCompactSig = function (
+  v: bigint,
+  r: Uint8Array,
+  s: Uint8Array,
+  chainId?: bigint,
+): string {
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw EthereumJSErrorWithoutCode('Invalid signature v value')
+  }
+
+  const ss = Uint8Array.from([...s])
+  if ((v > BigInt(28) && v % BIGINT_2 === BIGINT_1) || v === BIGINT_1 || v === BigInt(28)) {
+    ss[0] |= 0x80
+  }
+
+  return bytesToHex(concatBytes(setLengthLeft(r, 32), setLengthLeft(ss, 32)))
+}
+
+/**
+ * Convert signature format of the `eth_sign` RPC method to signature parameters
+ *
+ * NOTE: For an extracted `v` value < 27 (see Geth bug https://github.com/ethereum/go-ethereum/issues/2053)
+ * `v + 27` is returned for the `v` value
+ * NOTE: After EIP1559, `v` could be `0` or `1` but this function assumes
+ * it's a signed message (EIP-191 or EIP-712) adding `27` at the end. Remove if needed.
+ */
+export const fromRPCSig = function (sig: PrefixedHexString): {
+  v: bigint
+  r: Uint8Array
+  s: Uint8Array
+} {
+  const bytes: Uint8Array = hexToBytes(sig)
+
+  let r: Uint8Array
+  let s: Uint8Array
+  let v: bigint
+  if (bytes.length >= 65) {
+    r = bytes.subarray(0, 32)
+    s = bytes.subarray(32, 64)
+    v = bytesToBigInt(bytes.subarray(64))
+  } else if (bytes.length === 64) {
+    // Compact Signature Representation (https://eips.ethereum.org/EIPS/eip-2098)
+    r = bytes.subarray(0, 32)
+    s = bytes.subarray(32, 64)
+    v = BigInt(bytesToInt(bytes.subarray(32, 33)) >> 7)
+    s[0] &= 0x7f
+  } else {
+    throw EthereumJSErrorWithoutCode('Invalid signature length')
+  }
+
+  // support both versions of `eth_sign` responses
+  if (v < 27) {
+    // TODO: verify this behavior, and verify in which context this method (`fromRPCSig`) is used
+    v = v + BIGINT_27
+  }
+
+  return {
+    v,
+    r,
+    s,
+  }
+}
+
+/**
+ * Validate a ECDSA signature.
+ * NOTE: Accepts `v === 0 | v === 1` for EIP1559 transactions
+ * @param homesteadOrLater Indicates whether this is being used on either the homestead hardfork or a later one
+ */
+export const isValidSignature = function (
+  v: bigint,
+  r: Uint8Array,
+  s: Uint8Array,
+  homesteadOrLater: boolean = true,
+  chainId?: bigint,
+): boolean {
+  if (r.length !== 32 || s.length !== 32) {
+    return false
+  }
+
+  if (!isValidSigRecovery(calculateSigRecovery(v, chainId))) {
+    return false
+  }
+
+  const rBigInt = bytesToBigInt(r)
+  const sBigInt = bytesToBigInt(s)
+
+  if (
+    rBigInt === BIGINT_0 ||
+    rBigInt >= SECP256K1_ORDER ||
+    sBigInt === BIGINT_0 ||
+    sBigInt >= SECP256K1_ORDER
+  ) {
+    return false
+  }
+
+  if (homesteadOrLater && sBigInt >= SECP256K1_ORDER_DIV_2) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Returns the keccak-256 hash of `message`, prefixed with the header used by the `eth_sign` RPC call.
+ * The output of this function can be fed into `ecsign` to produce the same signature as the `eth_sign`
+ * call for a given `message`, or fed to `ecrecover` along with a signature to recover the public key
+ * used to produce the signature.
+ */
+export const hashPersonalMessage = function (message: Uint8Array): Uint8Array {
+  assertIsBytes(message)
+  const prefix = utf8ToBytes(`\u0019Ethereum Signed Message:\n${message.length}`)
+  return keccak_256(concatBytes(prefix, message))
+}

package/src/tasks.ts

@@ -0,0 +1,59 @@
+interface Task {
+  priority: number
+  fn: Function
+}
+
+export class PrioritizedTaskExecutor {
+  /** The maximum size of the pool */
+  private maxPoolSize: number
+  /** The current size of the pool */
+  private currentPoolSize: number
+  /** The task queue */
+  private queue: Task[]
+
+  /**
+   * Executes tasks up to maxPoolSize at a time, other items are put in a priority queue.
+   * @class PrioritizedTaskExecutor
+   * @private
+   * @param maxPoolSize The maximum size of the pool
+   */
+  constructor(maxPoolSize: number) {
+    this.maxPoolSize = maxPoolSize
+    this.currentPoolSize = 0
+    this.queue = []
+  }
+
+  /**
+   * Executes the task or queues it if no spots are available.
+   * When a task is added, check if there are spots left in the pool.
+   * If a spot is available, claim that spot and give back the spot once the asynchronous task has been resolved.
+   * When no spots are available, add the task to the task queue. The task will be executed at some point when another task has been resolved.
+   * @private
+   * @param priority The priority of the task
+   * @param fn The function that accepts the callback, which must be called upon the task completion.
+   */
+  executeOrQueue(priority: number, fn: Function) {
+    if (this.currentPoolSize < this.maxPoolSize) {
+      this.currentPoolSize++
+      fn(() => {
+        this.currentPoolSize--
+        if (this.queue.length > 0) {
+          this.queue.sort((a, b) => b.priority - a.priority)
+          const item = this.queue.shift()
+          this.executeOrQueue(item!.priority, item!.fn)
+        }
+      })
+    } else {
+      this.queue.push({ priority, fn })
+    }
+  }
+
+  /**
+   * Checks if the taskExecutor is finished.
+   * @private
+   * @returns Returns `true` if the taskExecutor is finished, otherwise returns `false`.
+   */
+  finished(): boolean {
+    return this.currentPoolSize === 0
+  }
+}

package/src/types.ts

@@ -0,0 +1,177 @@
+import { bytesToBigInt, bytesToHex, toBytes } from './bytes.ts'
+import { EthereumJSErrorWithoutCode } from './errors.ts'
+import { isHexString } from './internal.ts'
+
+import type { Address } from './address.ts'
+import type { ToBytesInputTypes } from './bytes.ts'
+
+/*
+ * A type that represents an input that can be converted to a BigInt.
+ */
+export type BigIntLike = bigint | PrefixedHexString | number | Uint8Array
+
+/*
+ * A type that represents an input that can be converted to a Uint8Array.
+ */
+export type BytesLike =
+  | Uint8Array
+  | number[]
+  | number
+  | bigint
+  | TransformableToBytes
+  | PrefixedHexString
+
+/*
+ * A type that represents a number-like string.
+ */
+export type NumericString = `${number}`
+
+/*
+ * A type that represents a `0x`-prefixed hex string.
+ */
+export type PrefixedHexString = `0x${string}`
+
+/**
+ * A type that represents an input that can be converted to an Address.
+ */
+export type AddressLike = Address | Uint8Array | PrefixedHexString
+
+export interface TransformableToBytes {
+  toBytes?(): Uint8Array
+}
+
+export type NestedUint8Array = Array<Uint8Array | NestedUint8Array>
+
+export function isNestedUint8Array(value: unknown): value is NestedUint8Array {
+  if (!Array.isArray(value)) {
+    return false
+  }
+  for (const item of value) {
+    if (Array.isArray(item)) {
+      if (!isNestedUint8Array(item)) {
+        return false
+      }
+    } else if (!(item instanceof Uint8Array)) {
+      return false
+    }
+  }
+  return true
+}
+
+export type TypeOutput = (typeof TypeOutput)[keyof typeof TypeOutput]
+
+export const TypeOutput = {
+  Number: 0,
+  BigInt: 1,
+  Uint8Array: 2,
+  PrefixedHexString: 3,
+} as const
+
+export type TypeOutputReturnType = {
+  [TypeOutput.Number]: number
+  [TypeOutput.BigInt]: bigint
+  [TypeOutput.Uint8Array]: Uint8Array
+  [TypeOutput.PrefixedHexString]: PrefixedHexString
+}
+
+/**
+ * Convert an input to a specified type.
+ * Input of null/undefined returns null/undefined regardless of the output type.
+ * @param input value to convert
+ * @param outputType type to output
+ */
+export function toType<T extends TypeOutput>(input: null, outputType: T): null
+export function toType<T extends TypeOutput>(input: undefined, outputType: T): undefined
+export function toType<T extends TypeOutput>(
+  input: ToBytesInputTypes,
+  outputType: T,
+): TypeOutputReturnType[T]
+export function toType<T extends TypeOutput>(
+  input: ToBytesInputTypes,
+  outputType: T,
+): TypeOutputReturnType[T] | undefined | null {
+  if (input === null) {
+    return null
+  }
+  if (input === undefined) {
+    return undefined
+  }
+
+  if (typeof input === 'string' && !isHexString(input)) {
+    throw EthereumJSErrorWithoutCode(`A string must be provided with a 0x-prefix, given: ${input}`)
+  } else if (typeof input === 'number' && !Number.isSafeInteger(input)) {
+    throw EthereumJSErrorWithoutCode(
+      'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)',
+    )
+  }
+
+  const output = toBytes(input)
+
+  switch (outputType) {
+    case TypeOutput.Uint8Array:
+      return output as TypeOutputReturnType[T]
+    case TypeOutput.BigInt:
+      return bytesToBigInt(output) as TypeOutputReturnType[T]
+    case TypeOutput.Number: {
+      const bigInt = bytesToBigInt(output)
+      if (bigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw EthereumJSErrorWithoutCode(
+          'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative output type)',
+        )
+      }
+      return Number(bigInt) as TypeOutputReturnType[T]
+    }
+    case TypeOutput.PrefixedHexString:
+      return bytesToHex(output) as TypeOutputReturnType[T]
+    default:
+      throw EthereumJSErrorWithoutCode('unknown outputType')
+  }
+}
+
+/**
+ * EIP-7702 Authorization list types
+ */
+export type EOACode7702AuthorizationListItemUnsigned = {
+  chainId: PrefixedHexString
+  address: PrefixedHexString
+  nonce: PrefixedHexString
+}
+
+export type EOACode7702AuthorizationListItem = {
+  yParity: PrefixedHexString
+  r: PrefixedHexString
+  s: PrefixedHexString
+} & EOACode7702AuthorizationListItemUnsigned
+
+// Tuple of [chain_id, address, nonce, y_parity, r, s]
+export type EOACode7702AuthorizationListBytesItem = [
+  Uint8Array,
+  Uint8Array,
+  Uint8Array,
+  Uint8Array,
+  Uint8Array,
+  Uint8Array,
+]
+export type EOACode7702AuthorizationListBytes = EOACode7702AuthorizationListBytesItem[]
+export type EOACode7702AuthorizationList = EOACode7702AuthorizationListItem[]
+
+export type EOACode7702AuthorizationListBytesItemUnsigned = [Uint8Array, Uint8Array, Uint8Array]
+
+export function isEOACode7702AuthorizationListBytes(
+  input: EOACode7702AuthorizationListBytes | EOACode7702AuthorizationList,
+): input is EOACode7702AuthorizationListBytes {
+  if (input.length === 0) {
+    return true
+  }
+  const firstItem = input[0]
+  if (Array.isArray(firstItem)) {
+    return true
+  }
+  return false
+}
+
+export function isEOACode7702AuthorizationList(
+  input: EOACode7702AuthorizationListBytes | EOACode7702AuthorizationList,
+): input is EOACode7702AuthorizationList {
+  return !isEOACode7702AuthorizationListBytes(input) // This is exactly the same method, except the output is negated.
+}

package/src/units.ts

@@ -0,0 +1,56 @@
+import { BIGINT_0, BIGINT_1 } from './constants.ts'
+import { EthereumJSErrorWithoutCode } from './errors.ts'
+
+/** Conversion constants to wei */
+export const GWEI_TO_WEI = BigInt(10 ** 9) // Multiplier to convert from Gwei to Wei
+export const ETHER_TO_WEI = BigInt(10 ** 18) // Multiplier to convert from Ether to Wei
+
+export function formatBigDecimal(
+  numerator: bigint,
+  denominator: bigint,
+  maxDecimalFactor: bigint,
+): string {
+  if (denominator === BIGINT_0) {
+    denominator = BIGINT_1
+  }
+
+  const full = numerator / denominator
+  const fraction = ((numerator - full * denominator) * maxDecimalFactor) / denominator
+
+  // zeros to be added post decimal are number of zeros in maxDecimalFactor - number of digits in fraction
+  const zerosPostDecimal = String(maxDecimalFactor).length - 1 - String(fraction).length
+  return `${full}.${'0'.repeat(zerosPostDecimal)}${fraction}`
+}
+
+export class Units {
+  static validateInput(amount: number | bigint): void {
+    if (typeof amount === 'number' && !Number.isInteger(amount)) {
+      throw EthereumJSErrorWithoutCode('Input must be an integer number')
+    }
+    if (BigInt(amount) < 0) {
+      throw EthereumJSErrorWithoutCode('Input must be a positive number')
+    }
+  }
+
+  /**
+   * Convert a number or bigint input of ether to wei
+   *
+   * @param {number | bigint} amount amount of units of ether to convert to wei
+   * @returns {bigint} amount of units in wei
+   */
+  static ether(amount: number | bigint): bigint {
+    Units.validateInput(amount)
+    return BigInt(amount) * ETHER_TO_WEI
+  }
+
+  /**
+   * Convert a number or bigint input of gwei to wei
+   *
+   * @param amount amount of units of gwei to convert to wei
+   * @returns {bigint} amount of units in wei
+   */
+  static gwei(amount: number | bigint): bigint {
+    Units.validateInput(amount)
+    return BigInt(amount) * GWEI_TO_WEI
+  }
+}