@sabaaa1/common 0.0.1 → 0.0.2

package/data-structures/snapshot/ClientAccessTokenSnapshotService.mjs

@@ -0,0 +1,37 @@
+import { AbstractAccessTokenSnapshotService as r } from "../event-service/AbstractAccessTokenSnapshotService.mjs";
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../constants/vite.constants.mjs";
+import "../../error-handling/error-codes.constants.mjs";
+import "../../constants/save-depths.mjs";
+import "../../constants/reorg-depths.constants.mjs";
+import "../../functions/utils/mutexes.utils.mjs";
+import { SnapshotFetcherService as o } from "./SnapshotFetcherService.mjs";
+class T extends r {
+  snapshotsService;
+  constructor(e, t) {
+    super(e), this.snapshotsService = t;
+  }
+  async fetchSnapshot() {
+    const { contract: e } = this.blockchainEventEmitter, { chainId: t } = await e.provider.getNetwork();
+    this.snapshotsService || (this.snapshotsService = new o(t, e.address));
+    const s = await this.snapshotsService.getAccessTokens();
+    if (s.accessTokenContractAddress !== e.address || s.chainId !== t)
+      throw Error("Commitment Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: s.latestBlockNumber,
+      merkleTree: s.merkleTree,
+      senderAddresses: s.senderAddresses,
+      senderAddressIndexMap: s.senderAddressIndexMap
+    };
+  }
+  persistSnapshot(e) {
+    return Promise.resolve();
+  }
+}
+export {
+  T as ClientAccessTokenSnapshotService
+};

package/data-structures/snapshot/ClientApprovalsSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../event-service/AbstractApprovalsSnapshotService.cjs");class a extends r.AbstractApprovalsSnapshotService{snapshotsService;constructor(t,e){super(t),this.snapshotsService=e}async fetchSnapshot(){const{contract:t}=this.blockchainEventEmitter,{chainId:e}=await t.provider.getNetwork(),s=await this.snapshotsService.getApprovals();if(s.hinkalAddress!==t.address||s.chainId!==e)throw Error("approvalsSnapshotData Snapshot: incorrect contract or chain id");return{latestBlockNumber:s.latestBlockNumber,approvals:s.approvals,events:s.events}}persistSnapshot(t){return Promise.resolve()}}exports.ClientApprovalsSnapshotService=a;

package/data-structures/snapshot/ClientApprovalsSnapshotService.d.ts

@@ -0,0 +1,9 @@
+import { AbstractApprovalsSnapshotService, ApprovalsSerializedSnapshot } from '../event-service/AbstractApprovalsSnapshotService';
+import { BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+export declare class ClientApprovalsSnapshotService extends AbstractApprovalsSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<ApprovalsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/ClientApprovalsSnapshotService.mjs

@@ -0,0 +1,23 @@
+import { AbstractApprovalsSnapshotService as r } from "../event-service/AbstractApprovalsSnapshotService.mjs";
+class n extends r {
+  snapshotsService;
+  constructor(t, a) {
+    super(t), this.snapshotsService = a;
+  }
+  async fetchSnapshot() {
+    const { contract: t } = this.blockchainEventEmitter, { chainId: a } = await t.provider.getNetwork(), s = await this.snapshotsService.getApprovals();
+    if (s.hinkalAddress !== t.address || s.chainId !== a)
+      throw Error("approvalsSnapshotData Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: s.latestBlockNumber,
+      approvals: s.approvals,
+      events: s.events
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  n as ClientApprovalsSnapshotService
+};

package/data-structures/snapshot/ClientCommitmentsSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../constants/vite.constants.cjs");require("../../error-handling/error-codes.constants.cjs");require("../../constants/save-depths.cjs");const r=require("../event-service/AbstractCommitmentsSnapshotService.cjs");require("../../constants/reorg-depths.constants.cjs");require("../../functions/utils/mutexes.utils.cjs");class s extends r.AbstractCommitmentsSnapshotService{snapshotsService;constructor(e,t){super(e),this.snapshotsService=t}async fetchSnapshot(){const e=await this.snapshotsService.getCommitments();return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,encryptedOutputs:e.encryptedOutputs}}persistSnapshot(e){return Promise.resolve()}}exports.ClientCommitmentsSnapshotService=s;

package/data-structures/snapshot/ClientCommitmentsSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCommitmentsSnapshotService, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<CommitmentsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/ClientCommitmentsSnapshotService.mjs

@@ -0,0 +1,31 @@
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../constants/vite.constants.mjs";
+import "../../error-handling/error-codes.constants.mjs";
+import "../../constants/save-depths.mjs";
+import { AbstractCommitmentsSnapshotService as r } from "../event-service/AbstractCommitmentsSnapshotService.mjs";
+import "../../constants/reorg-depths.constants.mjs";
+import "../../functions/utils/mutexes.utils.mjs";
+class v extends r {
+  snapshotsService;
+  constructor(t, e) {
+    super(t), this.snapshotsService = e;
+  }
+  async fetchSnapshot() {
+    const t = await this.snapshotsService.getCommitments();
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      merkleTree: t.merkleTree,
+      encryptedOutputs: t.encryptedOutputs
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  v as ClientCommitmentsSnapshotService
+};

package/data-structures/snapshot/ClientNullifierSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../constants/vite.constants.cjs");require("../../error-handling/error-codes.constants.cjs");require("../../constants/save-depths.cjs");const i=require("../event-service/AbstractNullifierSnapshotService.cjs");require("../../constants/reorg-depths.constants.cjs");require("../../functions/utils/mutexes.utils.cjs");class s extends i.AbstractNullifierSnapshotService{snapshotsService;constructor(e,r){super(e),this.snapshotsService=r}async fetchSnapshot(){const e=await this.snapshotsService.getNullifiers();return{latestBlockNumber:e.latestBlockNumber,nullifiers:e.nullifiers}}persistSnapshot(e){return Promise.resolve()}}exports.ClientNullifierSnapshotService=s;

package/data-structures/snapshot/ClientNullifierSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractNullifierSnapshotService, BlockchainEventEmitter, NullifierSerializedSnapshot } from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<NullifierSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/ClientNullifierSnapshotService.mjs

@@ -0,0 +1,30 @@
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../constants/vite.constants.mjs";
+import "../../error-handling/error-codes.constants.mjs";
+import "../../constants/save-depths.mjs";
+import { AbstractNullifierSnapshotService as i } from "../event-service/AbstractNullifierSnapshotService.mjs";
+import "../../constants/reorg-depths.constants.mjs";
+import "../../functions/utils/mutexes.utils.mjs";
+class f extends i {
+  snapshotsService;
+  constructor(t, r) {
+    super(t), this.snapshotsService = r;
+  }
+  async fetchSnapshot() {
+    const t = await this.snapshotsService.getNullifiers();
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      nullifiers: t.nullifiers
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  f as ClientNullifierSnapshotService
+};

package/data-structures/snapshot/SnapshotFetcherService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../functions/utils/caseInsensitive.utils.cjs"),i=require("../../API/fetchCommitmentsCache.cjs"),c=5*60*1e3;class r{chainId;contractAddress;snapshotsPromise;lastFetchedAt;cacheDurationMs;constructor(s,t,e=c){this.chainId=s,this.contractAddress=t,this.cacheDurationMs=e}async fetchSnapshots(){return this.lastFetchedAt=Date.now(),i.fetchSnapshots(this.chainId)}async ensureSnapshots(s=!1){const t=Date.now(),e=!this.lastFetchedAt||t-this.lastFetchedAt>this.cacheDurationMs;(s||!this.snapshotsPromise||e)&&(this.snapshotsPromise=this.fetchSnapshots());const n=await this.snapshotsPromise;if(!a.caseInsensitiveEqual(n.commitments.hinkalAddress,this.contractAddress)||n.commitments.chainId!==this.chainId)throw Error("Snapshots: incorrect contract or chain id");return n}async getAll(s=!1){return this.ensureSnapshots(s)}async getCommitments(s=!1){return(await this.ensureSnapshots(s)).commitments}async getAccessTokens(s=!1){return(await this.ensureSnapshots(s)).accessTokens}async getNullifiers(s=!1){return(await this.ensureSnapshots(s)).nullifiers}async getApprovals(s=!1){return(await this.ensureSnapshots(s)).approvals}}exports.SnapshotFetcherService=r;

package/data-structures/snapshot/SnapshotFetcherService.d.ts

@@ -0,0 +1,16 @@
+import { ISnapshotsResponse } from '../../API/fetchCommitmentsCache';
+export declare class SnapshotFetcherService {
+    private chainId;
+    private contractAddress;
+    private snapshotsPromise;
+    private lastFetchedAt;
+    private readonly cacheDurationMs;
+    constructor(chainId: number, contractAddress: string, cacheDurationMs?: number);
+    private fetchSnapshots;
+    private ensureSnapshots;
+    getAll(forceRefresh?: boolean): Promise<ISnapshotsResponse>;
+    getCommitments(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").ICommitmentsTreeSnapshot>;
+    getAccessTokens(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").IAccessTokenTreeSnapshot>;
+    getNullifiers(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").INullifiersSnapshot>;
+    getApprovals(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").IApprovalsSnapshot>;
+}

package/data-structures/snapshot/SnapshotFetcherService.mjs

@@ -0,0 +1,42 @@
+import { caseInsensitiveEqual as n } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { fetchSnapshots as i } from "../../API/fetchCommitmentsCache.mjs";
+const r = 5 * 60 * 1e3;
+class p {
+  chainId;
+  contractAddress;
+  snapshotsPromise;
+  lastFetchedAt;
+  cacheDurationMs;
+  constructor(s, t, e = r) {
+    this.chainId = s, this.contractAddress = t, this.cacheDurationMs = e;
+  }
+  async fetchSnapshots() {
+    return this.lastFetchedAt = Date.now(), i(this.chainId);
+  }
+  async ensureSnapshots(s = !1) {
+    const t = Date.now(), e = !this.lastFetchedAt || t - this.lastFetchedAt > this.cacheDurationMs;
+    (s || !this.snapshotsPromise || e) && (this.snapshotsPromise = this.fetchSnapshots());
+    const a = await this.snapshotsPromise;
+    if (!n(a.commitments.hinkalAddress, this.contractAddress) || a.commitments.chainId !== this.chainId)
+      throw Error("Snapshots: incorrect contract or chain id");
+    return a;
+  }
+  async getAll(s = !1) {
+    return this.ensureSnapshots(s);
+  }
+  async getCommitments(s = !1) {
+    return (await this.ensureSnapshots(s)).commitments;
+  }
+  async getAccessTokens(s = !1) {
+    return (await this.ensureSnapshots(s)).accessTokens;
+  }
+  async getNullifiers(s = !1) {
+    return (await this.ensureSnapshots(s)).nullifiers;
+  }
+  async getApprovals(s = !1) {
+    return (await this.ensureSnapshots(s)).approvals;
+  }
+}
+export {
+  p as SnapshotFetcherService
+};

package/data-structures/token-price-fetcher/TokenChecker.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const S=require("../../constants/protocol.constants.cjs");class b{static isBeefyStakeToken=t=>t.name.includes("-Boost")&&t.symbol.includes("-Boost");static isStakeToken=t=>this.isBeefyStakeToken(t);static isAaveToken=t=>t.aaveToken;static isKinzaToken=t=>t.name.startsWith("Kinza");static isPotentiallyVolatile=t=>t.erc20TokenAddress===S.zeroAddress?!1:t.isVolatile||t.balanceStorageOffset===void 0||t.allowanceStorageOffset===void 0;static isPotentiallySpamToken(t){const{name:s,symbol:o}=t,e=`${s} ${o}`,i=/(?:https?:\/\/|www\.)/i,n=/\.(?:com|io|app|org|net|co|xyz|link|site|top|in|ru|cn|me|biz|info|online|club|tech|to|cloud)(?=[^\w]|$)/i,c=/\b(?:t\.me|discord\.(?:gg|com)|twitter\.com|x\.com|telegram\.(?:me|org))\b/i,a=/@[^\s]+\.[^\s]+/i,r=/\p{Extended_Pictographic}/u,l=/[\u{1F1E6}-\u{1F1FF}]{2}/u,u=/[#*0-9]\uFE0F?\u20E3/u,E=i.test(e),m=n.test(e),d=c.test(e),T=a.test(e),k=r.test(e)||l.test(e)||u.test(e);return E||m||d||T||k}}exports.TokenChecker=b;

package/data-structures/token-price-fetcher/TokenChecker.d.ts

@@ -0,0 +1,9 @@
+import { ERC20Token } from '../../types/token.types';
+export declare class TokenChecker {
+    static isBeefyStakeToken: (token: ERC20Token) => boolean;
+    static isStakeToken: (token: ERC20Token) => boolean;
+    static isAaveToken: (token: ERC20Token) => boolean | undefined;
+    static isKinzaToken: (token: ERC20Token) => boolean;
+    static isPotentiallyVolatile: (token: ERC20Token) => boolean;
+    static isPotentiallySpamToken(token: ERC20Token): boolean;
+}

package/data-structures/token-price-fetcher/TokenChecker.mjs

@@ -0,0 +1,15 @@
+import { zeroAddress as k } from "../../constants/protocol.constants.mjs";
+class _ {
+  static isBeefyStakeToken = (t) => t.name.includes("-Boost") && t.symbol.includes("-Boost");
+  static isStakeToken = (t) => this.isBeefyStakeToken(t);
+  static isAaveToken = (t) => t.aaveToken;
+  static isKinzaToken = (t) => t.name.startsWith("Kinza");
+  static isPotentiallyVolatile = (t) => t.erc20TokenAddress === k ? !1 : t.isVolatile || t.balanceStorageOffset === void 0 || t.allowanceStorageOffset === void 0;
+  static isPotentiallySpamToken(t) {
+    const { name: e, symbol: o } = t, s = `${e} ${o}`, i = /(?:https?:\/\/|www\.)/i, n = /\.(?:com|io|app|org|net|co|xyz|link|site|top|in|ru|cn|me|biz|info|online|club|tech|to|cloud)(?=[^\w]|$)/i, c = /\b(?:t\.me|discord\.(?:gg|com)|twitter\.com|x\.com|telegram\.(?:me|org))\b/i, a = /@[^\s]+\.[^\s]+/i, r = /\p{Extended_Pictographic}/u, l = /[\u{1F1E6}-\u{1F1FF}]{2}/u, m = /[#*0-9]\uFE0F?\u20E3/u, E = i.test(s), u = n.test(s), d = c.test(s), T = a.test(s), f = r.test(s) || l.test(s) || m.test(s);
+    return E || u || d || T || f;
+  }
+}
+export {
+  _ as TokenChecker
+};

package/data-structures/tor/HttpClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("axios"),u=require("./TorClient.cjs"),c=require("./TorAdapter.cjs"),h=require("../../error-handling/logger.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/activities.types.cjs");const i=require("../../types/routing.types.cjs");class l{torClient;torAxiosInstance;regularAxiosInstance;useTor=!1;constructor(){this.regularAxiosInstance=a.create()}initializeTorClient=async()=>{if(!(this.torClient&&this.torAxiosInstance))try{this.torClient=await u.TorClient.create(),this.torAxiosInstance=a.create({adapter:c.createTorAdapter(this.torClient)})}catch(t){h.Logger.error("Failed to initialize Tor client",t),this.torClient=void 0,this.torAxiosInstance=void 0}};setUseTor=async t=>{this.useTor=t,t&&await this.initializeTorClient()};getUseTor=()=>this.useTor;buildRequestConfig=(t,e,r,s)=>t===i.HttpMethod.GET||t===i.HttpMethod.DELETE?{...r,method:t,url:e}:{...s,method:t,url:e,data:r};request=async(t,e,r,s)=>{const o=this.buildRequestConfig(t,e,r,s);if(this.useTor&&(await this.initializeTorClient(),this.torAxiosInstance))try{const n={...o,timeout:6e4};return(await this.torAxiosInstance.request(n)).data}catch{}return(await this.regularAxiosInstance.request(o)).data};get=(t,e)=>this.request(i.HttpMethod.GET,t,e);post=(t,e,r)=>this.request(i.HttpMethod.POST,t,e,r);put=(t,e,r)=>this.request(i.HttpMethod.PUT,t,e,r);patch=(t,e,r)=>this.request(i.HttpMethod.PATCH,t,e,r);delete=(t,e)=>this.request(i.HttpMethod.DELETE,t,e);closeTorClient=async()=>{this.torClient&&(await this.torClient.close(),this.torClient=void 0,this.torAxiosInstance=void 0)};resetTorClient=()=>{this.torClient=void 0,this.torAxiosInstance=void 0}}const T=new l;exports.httpClient=T;

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

@@ -0,0 +1,22 @@
+import { AxiosRequestConfig } from 'axios';
+declare class HttpClient {
+    private torClient?;
+    private torAxiosInstance?;
+    private regularAxiosInstance;
+    private useTor;
+    constructor();
+    private initializeTorClient;
+    setUseTor: (enabled: boolean) => Promise<void>;
+    getUseTor: () => boolean;
+    private buildRequestConfig;
+    private request;
+    get: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    post: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    put: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    patch: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    delete: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    closeTorClient: () => Promise<void>;
+    resetTorClient: () => void;
+}
+export declare const httpClient: HttpClient;
+export {};

package/data-structures/tor/HttpClient.mjs

@@ -0,0 +1,57 @@
+import a from "axios";
+import { TorClient as c } from "./TorClient.mjs";
+import { createTorAdapter as u } from "./TorAdapter.mjs";
+import { Logger as l } from "../../error-handling/logger.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/activities.types.mjs";
+import { HttpMethod as r } from "../../types/routing.types.mjs";
+class h {
+  torClient;
+  torAxiosInstance;
+  regularAxiosInstance;
+  useTor = !1;
+  constructor() {
+    this.regularAxiosInstance = a.create();
+  }
+  initializeTorClient = async () => {
+    if (!(this.torClient && this.torAxiosInstance))
+      try {
+        this.torClient = await c.create(), this.torAxiosInstance = a.create({
+          adapter: u(this.torClient)
+        });
+      } catch (t) {
+        l.error("Failed to initialize Tor client", t), this.torClient = void 0, this.torAxiosInstance = void 0;
+      }
+  };
+  setUseTor = async (t) => {
+    this.useTor = t, t && await this.initializeTorClient();
+  };
+  getUseTor = () => this.useTor;
+  buildRequestConfig = (t, e, i, s) => t === r.GET || t === r.DELETE ? { ...i, method: t, url: e } : { ...s, method: t, url: e, data: i };
+  request = async (t, e, i, s) => {
+    const o = this.buildRequestConfig(t, e, i, s);
+    if (this.useTor && (await this.initializeTorClient(), this.torAxiosInstance))
+      try {
+        const n = { ...o, timeout: 6e4 };
+        return (await this.torAxiosInstance.request(n)).data;
+      } catch {
+      }
+    return (await this.regularAxiosInstance.request(o)).data;
+  };
+  get = (t, e) => this.request(r.GET, t, e);
+  post = (t, e, i) => this.request(r.POST, t, e, i);
+  put = (t, e, i) => this.request(r.PUT, t, e, i);
+  patch = (t, e, i) => this.request(r.PATCH, t, e, i);
+  delete = (t, e) => this.request(r.DELETE, t, e);
+  closeTorClient = async () => {
+    this.torClient && (await this.torClient.close(), this.torClient = void 0, this.torAxiosInstance = void 0);
+  };
+  resetTorClient = () => {
+    this.torClient = void 0, this.torAxiosInstance = void 0;
+  };
+}
+const E = new h();
+export {
+  E as httpClient
+};

package/data-structures/tor/TorAdapter.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const E=require("../../functions/utils/serialize.utils.cjs"),l=i=>async r=>{if(!r.url)throw new Error("URL is required");const{url:d,data:u}=r,h=r.method?.toUpperCase()||"GET",a={};if(r.headers){const s=typeof r.headers.toJSON=="function"?r.headers.toJSON():r.headers;Object.entries(s).forEach(([t,o])=>{o!=null&&(a[t]=String(o))})}try{const s=await i.fetchViaTor(h,d,u,a),t=await s.text();let o=t;if((s.headers.get("content-type")||"").includes("application/json")&&t)try{o=E.CustomJSONParse(t)}catch{}const n={};s.headers.forEach((e,p)=>{n[p]=e});const c={data:o,status:s.status,statusText:s.statusText,headers:n,config:r,request:void 0};if(!(r.validateStatus||(e=>e>=200&&e<300))(s.status)){const e=new Error(`Request failed with status code ${s.status}`);throw e.config=r,e.code="ERR_BAD_REQUEST",e.request=void 0,e.response=c,e.isAxiosError=!0,e.toJSON=()=>({message:e.message,name:e.name,stack:e.stack,config:e.config,code:e.code,status:e.response?.status}),e}return c}catch(s){if(s.isAxiosError)throw s;const t=new Error(s.message||"Network Error");throw t.config=r,t.code="ERR_NETWORK",t.request=void 0,t.isAxiosError=!0,t.toJSON=()=>({message:t.message,name:t.name,stack:t.stack,config:t.config,code:t.code}),t}};exports.createTorAdapter=l;

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

@@ -0,0 +1,3 @@
+import { AxiosAdapter } from 'axios';
+import { TorClient } from './TorClient';
+export declare const createTorAdapter: (torClient: TorClient) => AxiosAdapter;

package/data-structures/tor/TorAdapter.mjs

@@ -0,0 +1,59 @@
+import { CustomJSONParse as E } from "../../functions/utils/serialize.utils.mjs";
+const S = (d) => async (r) => {
+  if (!r.url)
+    throw new Error("URL is required");
+  const { url: i, data: u } = r, h = r.method?.toUpperCase() || "GET", a = {};
+  if (r.headers) {
+    const s = typeof r.headers.toJSON == "function" ? r.headers.toJSON() : r.headers;
+    Object.entries(s).forEach(([t, o]) => {
+      o != null && (a[t] = String(o));
+    });
+  }
+  try {
+    const s = await d.fetchViaTor(h, i, u, a), t = await s.text();
+    let o = t;
+    if ((s.headers.get("content-type") || "").includes("application/json") && t)
+      try {
+        o = E(t);
+      } catch {
+      }
+    const n = {};
+    s.headers.forEach((e, p) => {
+      n[p] = e;
+    });
+    const c = {
+      data: o,
+      status: s.status,
+      statusText: s.statusText,
+      headers: n,
+      config: r,
+      request: void 0
+    };
+    if (!(r.validateStatus || ((e) => e >= 200 && e < 300))(s.status)) {
+      const e = new Error(`Request failed with status code ${s.status}`);
+      throw e.config = r, e.code = "ERR_BAD_REQUEST", e.request = void 0, e.response = c, e.isAxiosError = !0, e.toJSON = () => ({
+        message: e.message,
+        name: e.name,
+        stack: e.stack,
+        config: e.config,
+        code: e.code,
+        status: e.response?.status
+      }), e;
+    }
+    return c;
+  } catch (s) {
+    if (s.isAxiosError)
+      throw s;
+    const t = new Error(s.message || "Network Error");
+    throw t.config = r, t.code = "ERR_NETWORK", t.request = void 0, t.isAxiosError = !0, t.toJSON = () => ({
+      message: t.message,
+      name: t.name,
+      stack: t.stack,
+      config: t.config,
+      code: t.code
+    }), t;
+  }
+};
+export {
+  S as createTorAdapter
+};

package/data-structures/tor/TorClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("@hazae41/echalote"),m=require("@hazae41/cadenas"),S=require("@hazae41/fleche"),p=require("@hazae41/ed25519"),b=require("@hazae41/x25519"),g=require("@hazae41/chacha20poly1305"),y=require("@hazae41/sha1"),u=require("@brumewallet/wallet.wasm"),E=require("./WebSocketDuplex.cjs"),a=require("../../error-handling/logger.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/activities.types.cjs");const _=require("../../types/routing.types.cjs"),x=require("../../functions/utils/serialize.utils.cjs"),k=require("buffer");typeof globalThis.Buffer>"u"&&(globalThis.Buffer=k.Buffer);class w{static initializationPromise;cryptoInitialized=!1;socket;tor;consensus;abortController;middles=[];exits=[];circuits=[];circuitIndex=0;CIRCUIT_POOL_SIZE=5;TOP_RELAY_COUNT=50;static async create(){return this.initializationPromise?this.initializationPromise:(this.initializationPromise=(async()=>{try{const e=new w;return await e.initialize(),e}catch(e){throw this.initializationPromise=void 0,e}})(),this.initializationPromise)}async initialize(){await this.initializeCryptoOrThrow(),this.socket=await this.createSnowflakeSocketOrThrow(),this.tor=await this.createTorClientOrThrow(this.socket),await this.loadConsensus();const e=Array(this.CIRCUIT_POOL_SIZE).fill(null).map((i,r)=>this.createNewCircuit().catch(s=>(a.Logger.error(`Failed to build initial circuit ${r}`,s),null))),t=await Promise.all(e);if(this.circuits=t.filter(i=>i!==null),this.circuits.length===0)throw new Error("Failed to build any circuits")}async initializeCryptoOrThrow(){this.cryptoInitialized||(await u.WalletWasm.initBundled(),y.Sha1.set(y.Sha1.fromWasm(u.WalletWasm)),p.Ed25519.set(await p.Ed25519.fromNativeOrWasm(u.WalletWasm)),b.X25519.set(b.X25519.fromWasm(u.WalletWasm)),g.ChaCha20Poly1305.set(g.ChaCha20Poly1305.fromWasm(u.WalletWasm)),this.cryptoInitialized=!0)}async createSnowflakeSocketOrThrow(){const e=new WebSocket("wss://snowflake.torproject.net/");return e.binaryType="arraybuffer",await new Promise((t,i)=>{e.onopen=t,e.onerror=i}),e}async createTorClientOrThrow(e){const t=new E.WebSocketDuplex(e),i=h.createSnowflakeStream(t),r=new h.TorClientDuplex;return this.abortController=new AbortController,i.outer.readable.pipeTo(r.inner.writable,{signal:this.abortController.signal}).catch(s=>{a.Logger.error("Pipe to Tor failed:",s)}),r.inner.readable.pipeTo(i.outer.writable,{signal:this.abortController.signal}).catch(s=>{a.Logger.error("Pipe to TCP failed:",s)}),await r.waitOrThrow(),r}async loadConsensus(){if(!this.tor)throw new Error("Tor client not initialized");const e=await this.tor.createOrThrow();if(this.consensus=await h.Consensus.fetchOrThrow(e),this.middles=this.consensus.microdescs.filter(t=>t.flags.includes("Fast")&&t.flags.includes("Stable")&&t.flags.includes("V2Dir")),this.middles.sort((t,i)=>{const r=Number(t.bandwidth?.Bandwidth)||0;return(Number(i.bandwidth?.Bandwidth)||0)-r}),this.middles=this.middles.slice(0,this.TOP_RELAY_COUNT),this.exits=this.consensus.microdescs.filter(t=>t.flags.includes("Fast")&&t.flags.includes("Stable")&&t.flags.includes("Exit")&&!t.flags.includes("BadExit")),this.exits.sort((t,i)=>{const r=Number(t.bandwidth?.Bandwidth)||0;return(Number(i.bandwidth?.Bandwidth)||0)-r}),this.exits=this.exits.slice(0,this.TOP_RELAY_COUNT),this.middles.length===0||this.exits.length===0)throw new Error("No suitable relays found")}async createNewCircuit(){if(!this.tor)throw new Error("Tor client not initialized");const e=await this.tor.createOrThrow();try{const t=this.middles[Math.floor(Math.random()*this.middles.length)];if(!t)throw new Error("No middle relays available");const i=await h.Consensus.Microdesc.fetchOrThrow(e,t);await e.extendOrThrow(i);const r=this.exits[Math.floor(Math.random()*this.exits.length)];if(!r)throw new Error("No exit relays available");const s=await h.Consensus.Microdesc.fetchOrThrow(e,r);return await e.extendOrThrow(s),e}catch(t){throw a.Logger.error("Failed to build circuit",t),t}}async openTlsConnectionOrThrow(e,t,i=443){const r=await e.openOrThrow(t,i),s=[m.Ciphers.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,m.Ciphers.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384],n=new m.TlsClientDuplex({host_name:t,ciphers:s});return r.outer.readable.pipeTo(n.inner.writable).catch(()=>{}),n.inner.readable.pipeTo(r.outer.writable).catch(()=>{}),n.outer}async fetchViaTor(e,t,i,r){if(this.circuits.length===0)throw new Error("Circuit pool is empty, client may be closed or failed to init.");const s=new URL(t),n=this.circuits.length;let C;for(let f=0;f<n;f+=1){const c=(this.circuitIndex+f)%n,T=this.circuits[c];if(T)try{const d=await this.openTlsConnectionOrThrow(T,s.hostname,443),o={Host:s.hostname,Connection:"keep-alive",...r},l={method:e,stream:d,headers:o};i&&e!==_.HttpMethod.GET&&(l.body=typeof i=="string"?i:x.CustomJSONStringify(i),!o["Content-Type"]&&!o["content-type"]&&(o["Content-Type"]="application/json"));const O=await S.fetch(t,l);return this.circuitIndex=c,O}catch(d){C=d;const o=d.message?.toLowerCase()||"";a.Logger.error(`[TorClient] Circuit ${c} failed:`,o),(o.includes("circuit")||o.includes("destroyed")||o.includes("closed"))&&this.createNewCircuit().then(l=>{this.circuits[c]=l,a.Logger.log(`[TorClient] Replaced circuit ${c}`)}).catch(l=>{a.Logger.error(`[TorClient] Failed to replace circuit ${c}`,l)})}}throw new Error(`[TorClient] All ${n} circuits failed. Last error: ${C?.message||"unknown"}`)}async close(){this.abortController&&this.abortController.abort(),this.socket&&(this.socket.readyState===WebSocket.OPEN||this.socket.readyState===WebSocket.CONNECTING)&&this.socket.close(),this.circuits=[],this.socket=void 0,this.tor=void 0,this.consensus=void 0,this.abortController=void 0,w.initializationPromise=void 0}}exports.TorClient=w;

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

@@ -0,0 +1,25 @@
+import { HttpMethod } from '../../types';
+export declare class TorClient {
+    private static initializationPromise?;
+    private cryptoInitialized;
+    private socket?;
+    private tor?;
+    private consensus?;
+    private abortController?;
+    private middles;
+    private exits;
+    private circuits;
+    private circuitIndex;
+    private readonly CIRCUIT_POOL_SIZE;
+    private readonly TOP_RELAY_COUNT;
+    static create(): Promise<TorClient>;
+    private initialize;
+    private initializeCryptoOrThrow;
+    private createSnowflakeSocketOrThrow;
+    private createTorClientOrThrow;
+    private loadConsensus;
+    private createNewCircuit;
+    private openTlsConnectionOrThrow;
+    fetchViaTor(method: HttpMethod, url: string, body?: any, headers?: Record<string, string>): Promise<Response>;
+    close(): Promise<void>;
+}

package/data-structures/tor/TorClient.mjs

@@ -0,0 +1,147 @@
+import { createSnowflakeStream as S, TorClientDuplex as E, Consensus as u } from "@hazae41/echalote";
+import { Ciphers as T, TlsClientDuplex as _ } from "@hazae41/cadenas";
+import { fetch as x } from "@hazae41/fleche";
+import { Ed25519 as C } from "@hazae41/ed25519";
+import { X25519 as b } from "@hazae41/x25519";
+import { ChaCha20Poly1305 as y } from "@hazae41/chacha20poly1305";
+import { Sha1 as O } from "@hazae41/sha1";
+import { WalletWasm as h } from "@brumewallet/wallet.wasm";
+import { WebSocketDuplex as k } from "./WebSocketDuplex.mjs";
+import { Logger as a } from "../../error-handling/logger.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/activities.types.mjs";
+import { HttpMethod as P } from "../../types/routing.types.mjs";
+import { CustomJSONStringify as N } from "../../functions/utils/serialize.utils.mjs";
+import { Buffer as z } from "buffer";
+typeof globalThis.Buffer > "u" && (globalThis.Buffer = z);
+class m {
+  static initializationPromise;
+  cryptoInitialized = !1;
+  socket;
+  tor;
+  consensus;
+  abortController;
+  middles = [];
+  exits = [];
+  circuits = [];
+  circuitIndex = 0;
+  CIRCUIT_POOL_SIZE = 5;
+  TOP_RELAY_COUNT = 50;
+  static async create() {
+    return this.initializationPromise ? this.initializationPromise : (this.initializationPromise = (async () => {
+      try {
+        const i = new m();
+        return await i.initialize(), i;
+      } catch (i) {
+        throw this.initializationPromise = void 0, i;
+      }
+    })(), this.initializationPromise);
+  }
+  async initialize() {
+    await this.initializeCryptoOrThrow(), this.socket = await this.createSnowflakeSocketOrThrow(), this.tor = await this.createTorClientOrThrow(this.socket), await this.loadConsensus();
+    const i = Array(this.CIRCUIT_POOL_SIZE).fill(null).map(
+      (r, e) => this.createNewCircuit().catch((o) => (a.error(`Failed to build initial circuit ${e}`, o), null))
+    ), t = await Promise.all(i);
+    if (this.circuits = t.filter((r) => r !== null), this.circuits.length === 0)
+      throw new Error("Failed to build any circuits");
+  }
+  async initializeCryptoOrThrow() {
+    this.cryptoInitialized || (await h.initBundled(), O.set(O.fromWasm(h)), C.set(await C.fromNativeOrWasm(h)), b.set(b.fromWasm(h)), y.set(y.fromWasm(h)), this.cryptoInitialized = !0);
+  }
+  async createSnowflakeSocketOrThrow() {
+    const i = new WebSocket("wss://snowflake.torproject.net/");
+    return i.binaryType = "arraybuffer", await new Promise((t, r) => {
+      i.onopen = t, i.onerror = r;
+    }), i;
+  }
+  async createTorClientOrThrow(i) {
+    const t = new k(i), r = S(t), e = new E();
+    return this.abortController = new AbortController(), r.outer.readable.pipeTo(e.inner.writable, { signal: this.abortController.signal }).catch((o) => {
+      a.error("Pipe to Tor failed:", o);
+    }), e.inner.readable.pipeTo(r.outer.writable, { signal: this.abortController.signal }).catch((o) => {
+      a.error("Pipe to TCP failed:", o);
+    }), await e.waitOrThrow(), e;
+  }
+  async loadConsensus() {
+    if (!this.tor)
+      throw new Error("Tor client not initialized");
+    const i = await this.tor.createOrThrow();
+    if (this.consensus = await u.fetchOrThrow(i), this.middles = this.consensus.microdescs.filter(
+      (t) => t.flags.includes("Fast") && t.flags.includes("Stable") && t.flags.includes("V2Dir")
+    ), this.middles.sort((t, r) => {
+      const e = Number(t.bandwidth?.Bandwidth) || 0;
+      return (Number(r.bandwidth?.Bandwidth) || 0) - e;
+    }), this.middles = this.middles.slice(0, this.TOP_RELAY_COUNT), this.exits = this.consensus.microdescs.filter(
+      (t) => t.flags.includes("Fast") && t.flags.includes("Stable") && t.flags.includes("Exit") && !t.flags.includes("BadExit")
+    ), this.exits.sort((t, r) => {
+      const e = Number(t.bandwidth?.Bandwidth) || 0;
+      return (Number(r.bandwidth?.Bandwidth) || 0) - e;
+    }), this.exits = this.exits.slice(0, this.TOP_RELAY_COUNT), this.middles.length === 0 || this.exits.length === 0)
+      throw new Error("No suitable relays found");
+  }
+  async createNewCircuit() {
+    if (!this.tor)
+      throw new Error("Tor client not initialized");
+    const i = await this.tor.createOrThrow();
+    try {
+      const t = this.middles[Math.floor(Math.random() * this.middles.length)];
+      if (!t)
+        throw new Error("No middle relays available");
+      const r = await u.Microdesc.fetchOrThrow(i, t);
+      await i.extendOrThrow(r);
+      const e = this.exits[Math.floor(Math.random() * this.exits.length)];
+      if (!e)
+        throw new Error("No exit relays available");
+      const o = await u.Microdesc.fetchOrThrow(i, e);
+      return await i.extendOrThrow(o), i;
+    } catch (t) {
+      throw a.error("Failed to build circuit", t), t;
+    }
+  }
+  async openTlsConnectionOrThrow(i, t, r = 443) {
+    const e = await i.openOrThrow(t, r), o = [T.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, T.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384], n = new _({ host_name: t, ciphers: o });
+    return e.outer.readable.pipeTo(n.inner.writable).catch(() => {
+    }), n.inner.readable.pipeTo(e.outer.writable).catch(() => {
+    }), n.outer;
+  }
+  async fetchViaTor(i, t, r, e) {
+    if (this.circuits.length === 0)
+      throw new Error("Circuit pool is empty, client may be closed or failed to init.");
+    const o = new URL(t), n = this.circuits.length;
+    let f;
+    for (let w = 0; w < n; w += 1) {
+      const c = (this.circuitIndex + w) % n, p = this.circuits[c];
+      if (p)
+        try {
+          const d = await this.openTlsConnectionOrThrow(p, o.hostname, 443), s = {
+            Host: o.hostname,
+            Connection: "keep-alive",
+            ...e
+          }, l = {
+            method: i,
+            stream: d,
+            headers: s
+          };
+          r && i !== P.GET && (l.body = typeof r == "string" ? r : N(r), !s["Content-Type"] && !s["content-type"] && (s["Content-Type"] = "application/json"));
+          const g = await x(t, l);
+          return this.circuitIndex = c, g;
+        } catch (d) {
+          f = d;
+          const s = d.message?.toLowerCase() || "";
+          a.error(`[TorClient] Circuit ${c} failed:`, s), (s.includes("circuit") || s.includes("destroyed") || s.includes("closed")) && this.createNewCircuit().then((l) => {
+            this.circuits[c] = l, a.log(`[TorClient] Replaced circuit ${c}`);
+          }).catch((l) => {
+            a.error(`[TorClient] Failed to replace circuit ${c}`, l);
+          });
+        }
+    }
+    throw new Error(`[TorClient] All ${n} circuits failed. Last error: ${f?.message || "unknown"}`);
+  }
+  async close() {
+    this.abortController && this.abortController.abort(), this.socket && (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) && this.socket.close(), this.circuits = [], this.socket = void 0, this.tor = void 0, this.consensus = void 0, this.abortController = void 0, m.initializationPromise = void 0;
+  }
+}
+export {
+  m as TorClient
+};

package/data-structures/tor/WebSocketDuplex.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("@hazae41/binary"),s=require("@hazae41/cascade");class i{duplex;constructor(t){this.duplex=new s.HalfDuplex({output:{write(e){t.send(r.Writable.writeToBytesOrThrow(e))}}}),t.addEventListener("close",()=>this.duplex.close()),t.addEventListener("error",e=>this.duplex.error(e)),t.addEventListener("message",async e=>{if(typeof e.data=="string")return;const u=new Uint8Array(e.data),n=new r.Opaque(u);this.duplex.input.enqueue(n)})}get outer(){return this.duplex.outer}}exports.WebSocketDuplex=i;

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

@@ -0,0 +1,7 @@
+import { Opaque, Writable } from '@hazae41/binary';
+import { HalfDuplex } from '@hazae41/cascade';
+export declare class WebSocketDuplex {
+    readonly duplex: HalfDuplex<Opaque, Writable>;
+    constructor(socket: WebSocket);
+    get outer(): ReadableWritablePair<Opaque<Uint8Array>, Writable>;
+}