@oxyhq/services 5.26.4 → 6.0.0

package/src/shared/utils/networkUtils.ts

@@ -1,248 +0,0 @@
-/**
- * Network Utility Functions
- *
- * Consolidated network utilities including circuit breaker pattern
- * and exponential backoff for resilient API calls.
- *
- * @module shared/utils/networkUtils
- */
-
-/**
- * State for circuit breaker pattern.
- */
-export interface CircuitBreakerState {
-  /** Number of consecutive failures */
-  consecutiveFailures: number;
-  /** Current interval between retries (ms) */
-  currentInterval: number;
-  /** Base interval for retries (ms) */
-  baseInterval: number;
-  /** Maximum interval cap (ms) */
-  maxInterval: number;
-  /** Number of failures before circuit opens */
-  maxFailures: number;
-  /** Whether the circuit is currently open (blocking requests) */
-  isOpen?: boolean;
-  /** Timestamp when circuit was opened */
-  openedAt?: number;
-}
-
-/**
- * Configuration for circuit breaker.
- */
-export interface CircuitBreakerConfig {
-  /** Base interval between retries in milliseconds. Default: 10000 (10s) */
-  baseInterval?: number;
-  /** Maximum interval cap in milliseconds. Default: 60000 (60s) */
-  maxInterval?: number;
-  /** Number of consecutive failures before opening circuit. Default: 5 */
-  maxFailures?: number;
-  /** Time to wait before attempting recovery in milliseconds. Default: 30000 (30s) */
-  recoveryTimeout?: number;
-}
-
-/**
- * Default circuit breaker configuration.
- */
-export const DEFAULT_CIRCUIT_BREAKER_CONFIG: Required<CircuitBreakerConfig> = {
-  baseInterval: 10000,
-  maxInterval: 60000,
-  maxFailures: 5,
-  recoveryTimeout: 30000,
-};
-
-/**
- * Creates initial circuit breaker state.
- *
- * @param config - Optional custom configuration
- * @returns Initial circuit breaker state
- *
- * @example
- * ```ts
- * const state = createCircuitBreakerState({ maxFailures: 3 });
- * ```
- */
-export const createCircuitBreakerState = (
-  config: CircuitBreakerConfig = {}
-): CircuitBreakerState => {
-  const { baseInterval, maxInterval, maxFailures } = {
-    ...DEFAULT_CIRCUIT_BREAKER_CONFIG,
-    ...config,
-  };
-
-  return {
-    consecutiveFailures: 0,
-    currentInterval: baseInterval,
-    baseInterval,
-    maxInterval,
-    maxFailures,
-    isOpen: false,
-  };
-};
-
-/**
- * Calculates next interval using exponential backoff.
- *
- * @param state - Current circuit breaker state
- * @returns Next interval in milliseconds
- *
- * @example
- * ```ts
- * const nextInterval = calculateBackoffInterval(state);
- * await delay(nextInterval);
- * ```
- */
-export const calculateBackoffInterval = (state: CircuitBreakerState): number => {
-  const { consecutiveFailures, baseInterval, maxInterval } = state;
-
-  if (consecutiveFailures === 0) return baseInterval;
-
-  const backoffMultiplier = Math.min(
-    Math.pow(2, consecutiveFailures - 1),
-    maxInterval / baseInterval
-  );
-
-  return Math.min(baseInterval * backoffMultiplier, maxInterval);
-};
-
-/**
- * Records a failure and updates circuit breaker state.
- *
- * @param state - Current circuit breaker state
- * @returns Updated state after recording failure
- *
- * @example
- * ```ts
- * try {
- *   await apiCall();
- *   state = recordSuccess(state);
- * } catch (error) {
- *   state = recordFailure(state);
- * }
- * ```
- */
-export const recordFailure = (state: CircuitBreakerState): CircuitBreakerState => {
-  const newFailures = state.consecutiveFailures + 1;
-  const newInterval = calculateBackoffInterval({
-    ...state,
-    consecutiveFailures: newFailures,
-  });
-
-  const shouldOpenCircuit = newFailures >= state.maxFailures;
-  const finalInterval = shouldOpenCircuit ? state.maxInterval : newInterval;
-
-  return {
-    ...state,
-    consecutiveFailures: newFailures,
-    currentInterval: finalInterval,
-    isOpen: shouldOpenCircuit,
-    openedAt: shouldOpenCircuit ? Date.now() : state.openedAt,
-  };
-};
-
-/**
- * Records a success and resets circuit breaker state.
- *
- * @param state - Current circuit breaker state
- * @returns Reset state after successful request
- */
-export const recordSuccess = (state: CircuitBreakerState): CircuitBreakerState => {
-  return {
-    ...state,
-    consecutiveFailures: 0,
-    currentInterval: state.baseInterval,
-    isOpen: false,
-    openedAt: undefined,
-  };
-};
-
-/**
- * Checks if the circuit breaker should allow a request.
- *
- * When the circuit is open, it will only allow requests after
- * the recovery timeout has passed (half-open state).
- *
- * @param state - Current circuit breaker state
- * @param recoveryTimeout - Time to wait before allowing recovery attempts
- * @returns true if request should be allowed
- */
-export const shouldAllowRequest = (
-  state: CircuitBreakerState,
-  recoveryTimeout: number = DEFAULT_CIRCUIT_BREAKER_CONFIG.recoveryTimeout
-): boolean => {
-  if (!state.isOpen) return true;
-
-  if (!state.openedAt) return true;
-
-  const timeSinceOpen = Date.now() - state.openedAt;
-  return timeSinceOpen >= recoveryTimeout;
-};
-
-/**
- * Delays execution for a specified duration.
- *
- * @param ms - Milliseconds to delay
- * @returns Promise that resolves after the delay
- *
- * @example
- * ```ts
- * await delay(1000); // Wait 1 second
- * ```
- */
-export const delay = (ms: number): Promise<void> =>
-  new Promise(resolve => setTimeout(resolve, ms));
-
-/**
- * Executes a function with exponential backoff retry.
- *
- * @param fn - Async function to execute
- * @param options - Retry options
- * @returns Result of the function
- * @throws Last error if all retries fail
- *
- * @example
- * ```ts
- * const result = await withRetry(
- *   () => fetchData(),
- *   { maxRetries: 3, baseDelay: 1000 }
- * );
- * ```
- */
-export const withRetry = async <T>(
-  fn: () => Promise<T>,
-  options: {
-    maxRetries?: number;
-    baseDelay?: number;
-    maxDelay?: number;
-    shouldRetry?: (error: unknown) => boolean;
-    onRetry?: (error: unknown, attempt: number) => void;
-  } = {}
-): Promise<T> => {
-  const {
-    maxRetries = 3,
-    baseDelay = 1000,
-    maxDelay = 30000,
-    shouldRetry = () => true,
-    onRetry,
-  } = options;
-
-  let lastError: unknown;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-
-      if (attempt === maxRetries || !shouldRetry(error)) {
-        throw error;
-      }
-
-      const delayMs = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
-      onRetry?.(error, attempt + 1);
-      await delay(delayMs);
-    }
-  }
-
-  throw lastError;
-};

package/src/shared/utils/themeUtils.ts

@@ -1,115 +0,0 @@
-/**
- * Theme Utility Functions
- *
- * Consolidated theme utilities for normalizing and handling color schemes
- * across the OxyServices ecosystem.
- *
- * @module shared/utils/themeUtils
- */
-
-/**
- * Valid theme values in the Oxy ecosystem.
- */
-export type ThemeValue = 'light' | 'dark';
-
-/**
- * Normalizes a theme value to ensure it's always 'light' or 'dark'.
- *
- * @param theme - Theme value (may be 'light' | 'dark' | string | undefined)
- * @returns Normalized 'light' | 'dark' theme (defaults to 'light')
- *
- * @example
- * ```ts
- * normalizeTheme('dark');     // 'dark'
- * normalizeTheme('light');    // 'light'
- * normalizeTheme('unknown');  // 'light'
- * normalizeTheme(undefined);  // 'light'
- * normalizeTheme(null);       // 'light'
- * ```
- */
-export const normalizeTheme = (theme?: string | null): ThemeValue =>
-  theme === 'light' || theme === 'dark' ? theme : 'light';
-
-/**
- * Normalizes a color scheme value with optional fallback chain.
- *
- * Handles null/undefined cases from React Native's useColorScheme() hook
- * with a proper fallback chain.
- *
- * @param colorScheme - The color scheme from useColorScheme() hook (may be null/undefined)
- * @param theme - Optional theme prop as fallback
- * @returns Normalized 'light' | 'dark' color scheme
- *
- * @example
- * ```ts
- * // In a React Native component:
- * const systemScheme = useColorScheme(); // might be null
- * const colorScheme = normalizeColorScheme(systemScheme, props.theme);
- *
- * normalizeColorScheme('dark', 'light');      // 'dark'
- * normalizeColorScheme(null, 'dark');         // 'dark'
- * normalizeColorScheme(undefined, undefined); // 'light'
- * ```
- */
-export const normalizeColorScheme = (
-  colorScheme?: string | null,
-  theme?: string
-): ThemeValue => {
-  if (colorScheme === 'light' || colorScheme === 'dark') {
-    return colorScheme;
-  }
-
-  if (theme === 'light' || theme === 'dark') {
-    return theme;
-  }
-
-  return 'light';
-};
-
-/**
- * Gets the opposite theme value.
- *
- * @param theme - Current theme value
- * @returns The opposite theme ('light' → 'dark', 'dark' → 'light')
- *
- * @example
- * ```ts
- * getOppositeTheme('light'); // 'dark'
- * getOppositeTheme('dark');  // 'light'
- * ```
- */
-export const getOppositeTheme = (theme: ThemeValue): ThemeValue =>
-  theme === 'light' ? 'dark' : 'light';
-
-/**
- * Checks if the system prefers dark mode.
- *
- * This function only works in browser environments.
- * Returns false in non-browser environments (Node.js, React Native).
- *
- * @returns true if system prefers dark mode, false otherwise
- *
- * @example
- * ```ts
- * if (systemPrefersDarkMode()) {
- *   setTheme('dark');
- * }
- * ```
- */
-export const systemPrefersDarkMode = (): boolean => {
-  if (typeof window === 'undefined') return false;
-  return window.matchMedia?.('(prefers-color-scheme: dark)').matches ?? false;
-};
-
-/**
- * Gets the system's preferred color scheme.
- *
- * @returns 'dark' if system prefers dark mode, 'light' otherwise
- *
- * @example
- * ```ts
- * const theme = getSystemColorScheme();
- * ```
- */
-export const getSystemColorScheme = (): ThemeValue =>
-  systemPrefersDarkMode() ? 'dark' : 'light';

package/src/types/bip39.d.ts

@@ -1,32 +0,0 @@
-declare module 'bip39' {
-  export interface Wordlist {
-    [index: number]: string;
-    length: number;
-    getWord(index: number): string;
-    getWordIndex(word: string): number;
-  }
-
-  export const wordlists: {
-    english: string[];
-    chinese_simplified: string[];
-    chinese_traditional: string[];
-    french: string[];
-    italian: string[];
-    japanese: string[];
-    korean: string[];
-    spanish: string[];
-  };
-
-  // Use Uint8Array instead of Buffer for React Native compatibility
-  // In Node.js, Buffer extends Uint8Array so this is compatible
-  export function generateMnemonic(strength?: number, rng?: (size: number) => Uint8Array, wordlist?: string[]): string;
-  export function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
-  export function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
-  export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string;
-  export function entropyToMnemonic(entropy: string, wordlist?: string[]): string;
-  export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;
-  export function mnemonicToSeedHex(mnemonic: string, passphrase?: string): Promise<string>;
-  export function mnemonicToSeedHexSync(mnemonic: string, passphrase?: string): string;
-}
-
-

package/src/types/buffer.d.ts

@@ -1,97 +0,0 @@
-declare module 'buffer' {
-  export class Buffer extends Uint8Array {
-    constructor(str: string, encoding?: string);
-    constructor(size: number);
-    constructor(array: Uint8Array);
-    constructor(arrayBuffer: ArrayBuffer);
-    constructor(array: ReadonlyArray<number>);
-    constructor(buffer: Buffer);
-    
-    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
-    static from(data: Uint8Array | ReadonlyArray<number>): Buffer;
-    static from(str: string, encoding?: BufferEncoding): Buffer;
-    static from(object: { valueOf(): string | object } | { [Symbol.toPrimitive](hint: 'string'): string }, offsetOrEncoding?: number | string, length?: number): Buffer;
-    
-    static alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
-    static allocUnsafe(size: number): Buffer;
-    static allocUnsafeSlow(size: number): Buffer;
-    
-    static isBuffer(obj: unknown): obj is Buffer;
-    static isEncoding(encoding: string): encoding is BufferEncoding;
-    static byteLength(string: string | Buffer | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
-    static concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
-    static compare(buf1: Uint8Array, buf2: Uint8Array): number;
-    
-    write(string: string, encoding?: BufferEncoding): number;
-    write(string: string, offset: number, encoding?: BufferEncoding): number;
-    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
-    
-    toString(encoding?: BufferEncoding, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer'; data: number[] };
-    
-    equals(otherBuffer: Uint8Array): boolean;
-    compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
-    copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
-    
-    slice(start?: number, end?: number): Buffer;
-    subarray(start?: number, end?: number): Buffer;
-    
-    readBigInt64BE(offset?: number): bigint;
-    readBigInt64LE(offset?: number): bigint;
-    readBigUInt64BE(offset?: number): bigint;
-    readBigUInt64LE(offset?: number): bigint;
-    readDoubleBE(offset?: number): number;
-    readDoubleLE(offset?: number): number;
-    readFloatBE(offset?: number): number;
-    readFloatLE(offset?: number): number;
-    readInt8(offset?: number): number;
-    readInt16BE(offset?: number): number;
-    readInt16LE(offset?: number): number;
-    readInt32BE(offset?: number): number;
-    readInt32LE(offset?: number): number;
-    readIntBE(offset: number, byteLength: number): number;
-    readIntLE(offset: number, byteLength: number): number;
-    readUInt8(offset?: number): number;
-    readUInt16BE(offset?: number): number;
-    readUInt16LE(offset?: number): number;
-    readUInt32BE(offset?: number): number;
-    readUInt32LE(offset?: number): number;
-    readUIntBE(offset: number, byteLength: number): number;
-    readUIntLE(offset: number, byteLength: number): number;
-    
-    swap16(): Buffer;
-    swap32(): Buffer;
-    swap64(): Buffer;
-    
-    writeBigInt64BE(value: bigint, offset?: number): number;
-    writeBigInt64LE(value: bigint, offset?: number): number;
-    writeBigUInt64BE(value: bigint, offset?: number): number;
-    writeBigUInt64LE(value: bigint, offset?: number): number;
-    writeDoubleBE(value: number, offset?: number): number;
-    writeDoubleLE(value: number, offset?: number): number;
-    writeFloatBE(value: number, offset?: number): number;
-    writeFloatLE(value: number, offset?: number): number;
-    writeInt8(value: number, offset?: number): number;
-    writeInt16BE(value: number, offset?: number): number;
-    writeInt16LE(value: number, offset?: number): number;
-    writeInt32BE(value: number, offset?: number): number;
-    writeInt32LE(value: number, offset?: number): number;
-    writeIntBE(value: number, offset: number, byteLength: number): number;
-    writeIntLE(value: number, offset: number, byteLength: number): number;
-    writeUInt8(value: number, offset?: number): number;
-    writeUInt16BE(value: number, offset?: number): number;
-    writeUInt16LE(value: number, offset?: number): number;
-    writeUInt32BE(value: number, offset?: number): number;
-    writeUInt32LE(value: number, offset?: number): number;
-    writeUIntBE(value: number, offset: number, byteLength: number): number;
-    writeUIntLE(value: number, offset: number, byteLength: number): number;
-    
-    fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
-    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
-    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
-    includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
-  }
-
-  type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
-}
-

package/src/types/color.d.ts

@@ -1,20 +0,0 @@
-declare module 'color' {
-  interface Color {
-    (color: string | Color | undefined, model?: string): Color;
-    rgb(): Color;
-    rgba(): Color;
-    alpha(): number;
-    alpha(val: number): Color;
-    fade(val: number): Color;
-    lighten(val: number): Color;
-    darken(val: number): Color;
-    string(): string;
-    hex(): string;
-    toString(): string;
-  }
-
-  function color(color: string | Color | undefined, model?: string): Color;
-  export default color;
-}
-
-

package/src/types/elliptic.d.ts

@@ -1,62 +0,0 @@
-declare module 'elliptic' {
-  export interface KeyPair {
-    getPrivate(enc?: 'hex' | 'array' | 'bn'): string | number[] | any;
-    getPublic(enc?: 'hex'): string;
-    getPublic(enc?: 'array'): number[];
-    getPublic(compressed: boolean, enc?: 'hex'): string;
-    getPublic(compressed: boolean, enc?: 'array'): number[];
-    sign(msg: string | number[]): Signature;
-    verify(msg: string | number[], signature: Signature | string | { r: string | number[]; s: string | number[] }): boolean;
-  }
-
-  export interface Signature {
-    r: any;
-    s: any;
-    recoveryParam: number | null;
-    toDER(enc?: 'hex'): string;
-    toCompact(enc?: 'hex', param?: number): string;
-  }
-
-  export interface Curve {
-    n: any;
-    red: any;
-    g: Point;
-    decodePoint(bytes: string | number[], enc?: string): Point;
-  }
-
-  export interface Point {
-    x: any;
-    y: any;
-    inf: boolean;
-    getX(): any;
-    getY(): any;
-    encode(enc?: string, compressed?: boolean): string | number[];
-    add(p: Point): Point;
-    mul(k: any): Point;
-    eq(p: Point): boolean;
-  }
-
-  export class EC {
-    constructor(curve: string | Curve);
-    keyFromPrivate(priv: string | number[], enc?: string): KeyPair;
-    keyFromPublic(pub: string | number[] | Point, enc?: string): KeyPair;
-    genKeyPair(opts?: { entropy?: string | number[]; pers?: string | number[] }): KeyPair;
-    keyPair(opts?: { priv?: string | number[]; pub?: string | number[] | Point; privEnc?: string; pubEnc?: string }): KeyPair;
-    curve: Curve;
-    n: any;
-    nh: any;
-    g: Point;
-  }
-
-  export type ECKeyPair = KeyPair;
-
-  // ec can be called as a function or used as a constructor
-  export interface ECConstructor {
-    new (curve: string | Curve): EC;
-    (curve: string | Curve): EC;
-  }
-  
-  export const ec: ECConstructor;
-}
-
-