@sabaaa1/common 0.0.1

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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,283 @@
+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

@@ -0,0 +1,32 @@
+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/tor/index.ts

@@ -0,0 +1,3 @@
+export * from './TorClient';
+export * from './WebSocketDuplex';
+export * from './HttpClient';

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

@@ -0,0 +1,14 @@
+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 };

package/src/data-structures/transactions-manager/index.ts

@@ -0,0 +1 @@
+export * from './history/history.types';