@sabaaa1/common 0.0.9 → 0.0.12

package/src/data-structures/tor/HttpClient.ts

@@ -1,118 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { TorClient } from './TorClient';
-import { createTorAdapter } from './TorAdapter';
-import { Logger } from '../../error-handling/logger';
-import { HttpMethod } from '../../types';
-
-class HttpClient {
-  private torClient?: TorClient;
-
-  private torAxiosInstance?: AxiosInstance;
-
-  private regularAxiosInstance: AxiosInstance;
-
-  private useTor = false;
-
-  constructor() {
-    this.regularAxiosInstance = axios.create();
-  }
-
-  private initializeTorClient = async (): Promise<void> => {
-    if (this.torClient && this.torAxiosInstance) return;
-
-    try {
-      this.torClient = await TorClient.create();
-
-      this.torAxiosInstance = axios.create({
-        adapter: createTorAdapter(this.torClient),
-      });
-    } catch (error) {
-      Logger.error('Failed to initialize Tor client', error);
-      this.torClient = undefined;
-      this.torAxiosInstance = undefined;
-    }
-  };
-
-  setUseTor = async (enabled: boolean): Promise<void> => {
-    this.useTor = enabled;
-    if (enabled) await this.initializeTorClient();
-  };
-
-  getUseTor = (): boolean => {
-    return this.useTor;
-  };
-
-  private buildRequestConfig = (
-    method: HttpMethod,
-    url: string,
-    dataOrConfig?: any,
-    config?: AxiosRequestConfig,
-  ): AxiosRequestConfig => {
-    if (method === HttpMethod.GET || method === HttpMethod.DELETE) {
-      return { ...dataOrConfig, method, url };
-    }
-    return { ...config, method, url, data: dataOrConfig };
-  };
-
-  private request = async <T = any>(
-    method: HttpMethod,
-    url: string,
-    dataOrConfig?: any,
-    config?: AxiosRequestConfig,
-  ): Promise<T> => {
-    const requestConfig = this.buildRequestConfig(method, url, dataOrConfig, config);
-
-    if (this.useTor) {
-      await this.initializeTorClient();
-
-      if (this.torAxiosInstance) {
-        try {
-          const torRequestConfig = { ...requestConfig, timeout: 60 * 1000 };
-          const response = await this.torAxiosInstance.request<T>(torRequestConfig);
-          return response.data;
-        } catch (error) {
-          // Fallback if Tor returns 4xx/5xx errors (CloudFront blocks Tor, etc.)
-        }
-      }
-    }
-
-    // Regular axios
-    const response = await this.regularAxiosInstance.request<T>(requestConfig);
-    return response.data;
-  };
-
-  get = <T = any>(url: string, config?: AxiosRequestConfig): Promise<T> => {
-    return this.request<T>(HttpMethod.GET, url, config);
-  };
-
-  post = <T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> => {
-    return this.request<T>(HttpMethod.POST, url, data, config);
-  };
-
-  put = <T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> => {
-    return this.request<T>(HttpMethod.PUT, url, data, config);
-  };
-
-  patch = <T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> => {
-    return this.request<T>(HttpMethod.PATCH, url, data, config);
-  };
-
-  delete = <T = any>(url: string, config?: AxiosRequestConfig): Promise<T> => {
-    return this.request<T>(HttpMethod.DELETE, url, config);
-  };
-
-  closeTorClient = async (): Promise<void> => {
-    if (this.torClient) {
-      await this.torClient.close();
-      this.torClient = undefined;
-      this.torAxiosInstance = undefined;
-    }
-  };
-
-  resetTorClient = (): void => {
-    this.torClient = undefined;
-    this.torAxiosInstance = undefined;
-  };
-}
-
-export const httpClient = new HttpClient();

package/src/data-structures/tor/TorAdapter.ts

@@ -1,94 +0,0 @@
-import { AxiosAdapter, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
-import { TorClient } from './TorClient';
-import { HttpMethod } from '../../types';
-import { CustomJSONParse } from '../../functions/utils/serialize.utils';
-
-export const createTorAdapter = (torClient: TorClient): AxiosAdapter => {
-  return async (config: InternalAxiosRequestConfig): Promise<AxiosResponse> => {
-    if (!config.url) {
-      throw new Error('URL is required');
-    }
-    const { url, data } = config;
-    const method = (config.method?.toUpperCase() || 'GET') as HttpMethod;
-
-    const headers: Record<string, string> = {};
-    if (config.headers) {
-      const headersObj = typeof config.headers.toJSON === 'function' ? config.headers.toJSON() : config.headers;
-
-      Object.entries(headersObj).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          headers[key] = String(value);
-        }
-      });
-    }
-
-    try {
-      const response = await torClient.fetchViaTor(method, url, data, headers);
-
-      const responseText = await response.text();
-
-      let responseData = responseText;
-      const contentType = response.headers.get('content-type') || '';
-      if (contentType.includes('application/json') && responseText) {
-        try {
-          responseData = CustomJSONParse(responseText);
-        } catch {
-          // Keep as text if JSON parsing fails
-        }
-      }
-
-      const responseHeaders: Record<string, string> = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-
-      const axiosResponse: AxiosResponse = {
-        data: responseData,
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-        config,
-        request: undefined,
-      };
-
-      const validateStatus = config.validateStatus || ((status) => status >= 200 && status < 300);
-      if (!validateStatus(response.status)) {
-        const error: any = new Error(`Request failed with status code ${response.status}`);
-        error.config = config;
-        error.code = 'ERR_BAD_REQUEST';
-        error.request = undefined;
-        error.response = axiosResponse;
-        error.isAxiosError = true;
-        error.toJSON = () => ({
-          message: error.message,
-          name: error.name,
-          stack: error.stack,
-          config: error.config,
-          code: error.code,
-          status: error.response?.status,
-        });
-        throw error;
-      }
-
-      return axiosResponse;
-    } catch (error: any) {
-      if (error.isAxiosError) {
-        throw error;
-      }
-
-      const axiosError: any = new Error(error.message || 'Network Error');
-      axiosError.config = config;
-      axiosError.code = 'ERR_NETWORK';
-      axiosError.request = undefined;
-      axiosError.isAxiosError = true;
-      axiosError.toJSON = () => ({
-        message: axiosError.message,
-        name: axiosError.name,
-        stack: axiosError.stack,
-        config: axiosError.config,
-        code: axiosError.code,
-      });
-      throw axiosError;
-    }
-  };
-};

package/src/data-structures/tor/TorClient.ts

@@ -1,283 +0,0 @@
-import { Circuit, Consensus, createSnowflakeStream, TorClientDuplex } from '@hazae41/echalote';
-import { Ciphers, TlsClientDuplex } from '@hazae41/cadenas';
-import { fetch, FetchParams } from '@hazae41/fleche';
-import { Opaque, Writable } from '@hazae41/binary';
-import { Ed25519 } from '@hazae41/ed25519';
-import { X25519 } from '@hazae41/x25519';
-import { ChaCha20Poly1305 } from '@hazae41/chacha20poly1305';
-import { Sha1 } from '@hazae41/sha1';
-import { WalletWasm } from '@brumewallet/wallet.wasm';
-import { WebSocketDuplex } from './WebSocketDuplex';
-import { Logger } from '../../error-handling/logger';
-import { HttpMethod } from '../../types';
-import { CustomJSONStringify } from '../../functions/utils/serialize.utils';
-import { Buffer } from 'buffer';
-
-if (typeof globalThis.Buffer === 'undefined') {
-  globalThis.Buffer = Buffer;
-}
-
-export class TorClient {
-  private static initializationPromise?: Promise<TorClient>;
-
-  private cryptoInitialized = false;
-
-  private socket?: WebSocket;
-
-  private tor?: TorClientDuplex;
-
-  private consensus?: Consensus;
-
-  private abortController?: AbortController;
-
-  private middles: Consensus.Microdesc.Head[] = [];
-
-  private exits: Consensus.Microdesc.Head[] = [];
-
-  private circuits: Circuit[] = [];
-
-  private circuitIndex = 0;
-
-  private readonly CIRCUIT_POOL_SIZE = 5;
-
-  private readonly TOP_RELAY_COUNT = 50;
-
-  static async create(): Promise<TorClient> {
-    if (this.initializationPromise) {
-      return this.initializationPromise;
-    }
-
-    this.initializationPromise = (async () => {
-      try {
-        const client = new TorClient();
-        await client.initialize();
-        return client;
-      } catch (error) {
-        this.initializationPromise = undefined;
-        throw error;
-      }
-    })();
-
-    return this.initializationPromise;
-  }
-
-  private async initialize(): Promise<void> {
-    await this.initializeCryptoOrThrow();
-    this.socket = await this.createSnowflakeSocketOrThrow();
-    this.tor = await this.createTorClientOrThrow(this.socket);
-    await this.loadConsensus();
-
-    const buildPromises = Array(this.CIRCUIT_POOL_SIZE)
-      .fill(null)
-      .map((_, i) =>
-        this.createNewCircuit().catch((err) => {
-          Logger.error(`Failed to build initial circuit ${i}`, err);
-          return null;
-        }),
-      );
-
-    const circuits = await Promise.all(buildPromises);
-    this.circuits = circuits.filter((c): c is Circuit => c !== null);
-
-    if (this.circuits.length === 0) {
-      throw new Error('Failed to build any circuits');
-    }
-  }
-
-  private async initializeCryptoOrThrow(): Promise<void> {
-    if (this.cryptoInitialized) return;
-
-    await WalletWasm.initBundled();
-    Sha1.set(Sha1.fromWasm(WalletWasm));
-    Ed25519.set(await Ed25519.fromNativeOrWasm(WalletWasm));
-    X25519.set(X25519.fromWasm(WalletWasm));
-    ChaCha20Poly1305.set(ChaCha20Poly1305.fromWasm(WalletWasm));
-    this.cryptoInitialized = true;
-  }
-
-  private async createSnowflakeSocketOrThrow(): Promise<WebSocket> {
-    const socket = new WebSocket('wss://snowflake.torproject.net/');
-    socket.binaryType = 'arraybuffer';
-
-    await new Promise((resolve, reject) => {
-      socket.onopen = resolve;
-      socket.onerror = reject;
-    });
-
-    return socket;
-  }
-
-  private async createTorClientOrThrow(socket: WebSocket): Promise<TorClientDuplex> {
-    const stream = new WebSocketDuplex(socket);
-    const tcp = createSnowflakeStream(stream);
-    const tor = new TorClientDuplex();
-
-    this.abortController = new AbortController();
-
-    tcp.outer.readable.pipeTo(tor.inner.writable, { signal: this.abortController.signal }).catch((error) => {
-      Logger.error('Pipe to Tor failed:', error);
-    });
-    tor.inner.readable.pipeTo(tcp.outer.writable, { signal: this.abortController.signal }).catch((error) => {
-      Logger.error('Pipe to TCP failed:', error);
-    });
-
-    await tor.waitOrThrow();
-    return tor;
-  }
-
-  private async loadConsensus(): Promise<void> {
-    if (!this.tor) throw new Error('Tor client not initialized');
-
-    const tempCircuit = await this.tor.createOrThrow();
-    this.consensus = await Consensus.fetchOrThrow(tempCircuit);
-
-    this.middles = this.consensus.microdescs.filter(
-      (it) => it.flags.includes('Fast') && it.flags.includes('Stable') && it.flags.includes('V2Dir'),
-    );
-
-    this.middles.sort((a, b) => {
-      const bwA = Number(a.bandwidth?.['Bandwidth']) || 0;
-      const bwB = Number(b.bandwidth?.['Bandwidth']) || 0;
-      return bwB - bwA;
-    });
-
-    this.middles = this.middles.slice(0, this.TOP_RELAY_COUNT);
-
-    this.exits = this.consensus.microdescs.filter(
-      (it) =>
-        it.flags.includes('Fast') &&
-        it.flags.includes('Stable') &&
-        it.flags.includes('Exit') &&
-        !it.flags.includes('BadExit'),
-    );
-
-    this.exits.sort((a, b) => {
-      const bwA = Number(a.bandwidth?.['Bandwidth']) || 0;
-      const bwB = Number(b.bandwidth?.['Bandwidth']) || 0;
-      return bwB - bwA;
-    });
-
-    this.exits = this.exits.slice(0, this.TOP_RELAY_COUNT);
-
-    if (this.middles.length === 0 || this.exits.length === 0) {
-      throw new Error('No suitable relays found');
-    }
-  }
-
-  private async createNewCircuit(): Promise<Circuit> {
-    if (!this.tor) throw new Error('Tor client not initialized');
-
-    const circuit = await this.tor.createOrThrow();
-
-    try {
-      const middle = this.middles[Math.floor(Math.random() * this.middles.length)];
-      if (!middle) throw new Error('No middle relays available');
-      const middleDesc = await Consensus.Microdesc.fetchOrThrow(circuit, middle);
-      await circuit.extendOrThrow(middleDesc);
-
-      const exit = this.exits[Math.floor(Math.random() * this.exits.length)];
-      if (!exit) throw new Error('No exit relays available');
-      const exitDesc = await Consensus.Microdesc.fetchOrThrow(circuit, exit);
-      await circuit.extendOrThrow(exitDesc);
-
-      return circuit;
-    } catch (error) {
-      Logger.error('Failed to build circuit', error);
-      throw error;
-    }
-  }
-
-  private async openTlsConnectionOrThrow(
-    circuit: Circuit,
-    hostname: string,
-    port = 443,
-  ): Promise<{ readable: ReadableStream<Opaque>; writable: WritableStream<Writable> }> {
-    const ttcp = await circuit.openOrThrow(hostname, port);
-    const ciphers = [Ciphers.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, Ciphers.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384];
-    const ttls = new TlsClientDuplex({ host_name: hostname, ciphers });
-
-    ttcp.outer.readable.pipeTo(ttls.inner.writable).catch(() => {});
-    ttls.inner.readable.pipeTo(ttcp.outer.writable).catch(() => {});
-
-    return ttls.outer;
-  }
-
-  async fetchViaTor(method: HttpMethod, url: string, body?: any, headers?: Record<string, string>): Promise<Response> {
-    if (this.circuits.length === 0) throw new Error('Circuit pool is empty, client may be closed or failed to init.');
-
-    const parsedUrl = new URL(url);
-
-    const totalCircuits = this.circuits.length;
-    let lastError: any;
-
-    for (let attempt = 0; attempt < totalCircuits; attempt += 1) {
-      const circuitIndex = (this.circuitIndex + attempt) % totalCircuits;
-      const circuit = this.circuits[circuitIndex];
-      if (circuit) {
-        try {
-          // eslint-disable-next-line no-await-in-loop
-          const tlsStream = await this.openTlsConnectionOrThrow(circuit, parsedUrl.hostname, 443);
-
-          const requestHeaders: Record<string, string> = {
-            Host: parsedUrl.hostname,
-            Connection: 'keep-alive',
-            ...headers,
-          };
-
-          const fetchOptions: RequestInit & FetchParams = {
-            method,
-            stream: tlsStream,
-            headers: requestHeaders,
-          };
-
-          if (body && method !== HttpMethod.GET) {
-            fetchOptions.body = typeof body === 'string' ? body : CustomJSONStringify(body);
-            if (!requestHeaders['Content-Type'] && !requestHeaders['content-type'])
-              requestHeaders['Content-Type'] = 'application/json';
-          }
-
-          // eslint-disable-next-line no-await-in-loop
-          const response = await fetch(url, fetchOptions);
-
-          this.circuitIndex = circuitIndex;
-          return response;
-        } catch (error: any) {
-          lastError = error;
-          const msg = error.message?.toLowerCase() || '';
-          Logger.error(`[TorClient] Circuit ${circuitIndex} failed:`, msg);
-
-          // Background rebuild if it looks like a dead circuit
-          if (msg.includes('circuit') || msg.includes('destroyed') || msg.includes('closed')) {
-            this.createNewCircuit()
-              .then((newCircuit) => {
-                this.circuits[circuitIndex] = newCircuit;
-                Logger.log(`[TorClient] Replaced circuit ${circuitIndex}`);
-              })
-              .catch((err) => {
-                Logger.error(`[TorClient] Failed to replace circuit ${circuitIndex}`, err);
-              });
-          }
-        }
-      }
-    }
-
-    // All circuits failed
-    throw new Error(`[TorClient] All ${totalCircuits} circuits failed. Last error: ${lastError?.message || 'unknown'}`);
-  }
-
-  async close(): Promise<void> {
-    if (this.abortController) this.abortController.abort();
-
-    if (this.socket && (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING))
-      this.socket.close();
-
-    this.circuits = [];
-
-    this.socket = undefined;
-    this.tor = undefined;
-    this.consensus = undefined;
-    this.abortController = undefined;
-
-    TorClient.initializationPromise = undefined;
-  }
-}

package/src/data-structures/tor/WebSocketDuplex.ts

@@ -1,32 +0,0 @@
-import { Opaque, Writable } from '@hazae41/binary';
-import { HalfDuplex } from '@hazae41/cascade';
-
-export class WebSocketDuplex {
-  readonly duplex: HalfDuplex<Opaque, Writable>;
-
-  constructor(socket: WebSocket) {
-    this.duplex = new HalfDuplex<Opaque, Writable>({
-      output: {
-        write(message) {
-          socket.send(Writable.writeToBytesOrThrow(message));
-        },
-      },
-    });
-
-    socket.addEventListener('close', () => this.duplex.close());
-    socket.addEventListener('error', (e) => this.duplex.error(e));
-
-    socket.addEventListener('message', async (e: MessageEvent<string | ArrayBuffer>) => {
-      if (typeof e.data === 'string') return;
-
-      const bytes = new Uint8Array(e.data);
-      const opaque = new Opaque(bytes);
-
-      this.duplex.input.enqueue(opaque);
-    });
-  }
-
-  get outer() {
-    return this.duplex.outer;
-  }
-}

package/src/data-structures/transactions-manager/history/history.types.ts

@@ -1,14 +0,0 @@
-import { TokenBalance } from '../../../types';
-
-export enum TransactionType {
-  DEPOSIT,
-  WITHDRAW,
-  SWAP,
-  UNKNOWN,
-}
-
-export interface TransactionDetails {
-  type: TransactionType;
-}
-
-export type HistoryTokenBalance = TokenBalance | { token: { erc20TokenAddress: string }; balance: bigint };