ox 0.0.1 → 0.1.0

package/internal/hex.ts

@@ -0,0 +1,123 @@
+import type * as Errors from '../Errors.js'
+import * as Hex from '../Hex.js'
+
+/** @internal */
+export function assertSize(hex: Hex.Hex, size_: number): void {
+  if (Hex.size(hex) > size_)
+    throw new Hex.SizeOverflowError({
+      givenSize: Hex.size(hex),
+      maxSize: size_,
+    })
+}
+
+/** @internal */
+export declare namespace assertSize {
+  type ErrorType =
+    | Hex.size.ErrorType
+    | Hex.SizeOverflowError
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function assertStartOffset(value: Hex.Hex, start?: number | undefined) {
+  if (typeof start === 'number' && start > 0 && start > Hex.size(value) - 1)
+    throw new Hex.SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: 'start',
+      size: Hex.size(value),
+    })
+}
+
+export declare namespace assertStartOffset {
+  type ErrorType =
+    | Hex.SliceOffsetOutOfBoundsError
+    | Hex.size.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function assertEndOffset(
+  value: Hex.Hex,
+  start?: number | undefined,
+  end?: number | undefined,
+) {
+  if (
+    typeof start === 'number' &&
+    typeof end === 'number' &&
+    Hex.size(value) !== end - start
+  ) {
+    throw new Hex.SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: 'end',
+      size: Hex.size(value),
+    })
+  }
+}
+
+export declare namespace assertEndOffset {
+  type ErrorType =
+    | Hex.SliceOffsetOutOfBoundsError
+    | Hex.size.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function pad(hex_: Hex.Hex, options: pad.Options = {}) {
+  const { dir, size = 32 } = options
+
+  if (size === 0) return hex_
+
+  const hex = hex_.replace('0x', '')
+  if (hex.length > size * 2)
+    throw new Hex.SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size,
+      type: 'Hex',
+    })
+
+  return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}` as Hex.Hex
+}
+
+/** @internal */
+export declare namespace pad {
+  type Options = {
+    dir?: 'left' | 'right' | undefined
+    size?: number | undefined
+  }
+  type ErrorType = Hex.SizeExceedsPaddingSizeError | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function trim(
+  value: Hex.Hex,
+  options: trim.Options = {},
+): trim.ReturnType {
+  const { dir = 'left' } = options
+
+  let data = value.replace('0x', '')
+
+  let sliceLength = 0
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === 'left' ? i : data.length - i - 1]!.toString() === '0')
+      sliceLength++
+    else break
+  }
+  data =
+    dir === 'left'
+      ? data.slice(sliceLength)
+      : data.slice(0, data.length - sliceLength)
+
+  if (data.length === 1 && dir === 'right') data = `${data}0`
+  return `0x${data.length % 2 === 1 ? `0${data}` : data}` as trim.ReturnType
+}
+
+/** @internal */
+export declare namespace trim {
+  type Options = {
+    dir?: 'left' | 'right' | undefined
+  }
+
+  type ReturnType = Hex.Hex
+
+  type ErrorType = Errors.GlobalErrorType
+}

package/internal/lru.ts

@@ -0,0 +1,34 @@
+/**
+ * @internal
+ *
+ * Map with a LRU (Least recently used) policy.
+ * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export class LruMap<value = unknown> extends Map<string, value> {
+  maxSize: number
+
+  constructor(size: number) {
+    super()
+    this.maxSize = size
+  }
+
+  override get(key: string) {
+    const value = super.get(key)
+
+    if (super.has(key) && value !== undefined) {
+      this.delete(key)
+      super.set(key, value)
+    }
+
+    return value
+  }
+
+  override set(key: string, value: value) {
+    super.set(key, value)
+    if (this.maxSize && this.size > this.maxSize) {
+      const firstKey = this.keys().next().value
+      if (firstKey) this.delete(firstKey)
+    }
+    return this
+  }
+}

package/internal/mnemonic/wordlists.ts

@@ -0,0 +1,10 @@
+export { wordlist as czech } from '@scure/bip39/wordlists/czech'
+export { wordlist as english } from '@scure/bip39/wordlists/english'
+export { wordlist as french } from '@scure/bip39/wordlists/french'
+export { wordlist as italian } from '@scure/bip39/wordlists/italian'
+export { wordlist as japanese } from '@scure/bip39/wordlists/japanese'
+export { wordlist as korean } from '@scure/bip39/wordlists/korean'
+export { wordlist as portuguese } from '@scure/bip39/wordlists/portuguese'
+export { wordlist as simplifiedChinese } from '@scure/bip39/wordlists/simplified-chinese'
+export { wordlist as spanish } from '@scure/bip39/wordlists/spanish'
+export { wordlist as traditionalChinese } from '@scure/bip39/wordlists/traditional-chinese'

package/internal/promise.ts

@@ -0,0 +1,66 @@
+import * as Errors from '../Errors.js'
+
+/** @internal */
+export function withTimeout<data>(
+  fn: withTimeout.Fn<data>,
+  options: withTimeout.Options,
+): Promise<data> {
+  const { errorInstance = new TimeoutError(), timeout, signal } = options
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      let timeoutId: any
+      try {
+        const controller = new AbortController()
+        if (timeout > 0)
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort()
+            } else {
+              reject(errorInstance)
+            }
+          }, timeout) as any
+        resolve(await fn({ signal: controller.signal }))
+      } catch (err) {
+        if ((err as Error)?.name === 'AbortError') reject(errorInstance)
+        reject(err)
+      } finally {
+        clearTimeout(timeoutId)
+      }
+    })()
+  })
+}
+
+/** @internal */
+export declare namespace withTimeout {
+  type Fn<data> = ({
+    signal,
+  }: { signal: AbortController['signal'] | null }) => Promise<data>
+
+  type Options = {
+    // The error instance to throw when the timeout is reached.
+    errorInstance?: Error | undefined
+    // The timeout (in ms).
+    timeout: number
+    // Whether or not the timeout should use an abort signal.
+    signal?: boolean | undefined
+  }
+
+  type ErrorType = TimeoutError | Errors.GlobalErrorType
+}
+
+/** @internal */
+withTimeout.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as withTimeout.ErrorType
+
+/**
+ * Thrown when an operation times out.
+ * @internal
+ */
+export class TimeoutError extends Errors.BaseError {
+  override readonly name = 'Promise.TimeoutError'
+
+  constructor() {
+    super('Operation timed out.')
+  }
+}

package/internal/register.ts

@@ -0,0 +1,15 @@
+import type * as RpcSchema from '../RpcSchema.js'
+
+// biome-ignore lint/suspicious/noEmptyInterface:
+export interface Register {}
+
+export type ResolvedRegister = {
+  RpcSchema: Register extends { RpcSchema: infer schema }
+    ? schema
+    : DefaultRegister['RpcSchema']
+}
+
+/** @internal */
+export type DefaultRegister = {
+  RpcSchema: RpcSchema.Eth | RpcSchema.Wallet
+}

package/internal/rpcSchema.ts

@@ -0,0 +1,20 @@
+import type { Generic, MethodNameGeneric } from '../RpcSchema.js'
+import type { Compute, IsNarrowable } from './types.js'
+
+/** @internal */
+export type ExtractRequestOpaque<
+  schema extends Generic,
+  methodName extends MethodNameGeneric<schema> = MethodNameGeneric<schema>,
+> = Compute<
+  Omit<
+    {
+      method: methodName | schema['Request']['method']
+      params?: unknown
+    } & (IsNarrowable<methodName, schema['Request']['method']> extends true
+      ? IsNarrowable<schema, Generic> extends true
+        ? Extract<schema, { Request: { method: methodName } }>['Request']
+        : {}
+      : {}),
+    ''
+  >
+>