@sabaaa1/common 0.2.16

package/data-structures/provider-adapter/IProviderAdapter.d.ts

@@ -0,0 +1,37 @@
+import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { Contract, ethers, Signer } from 'ethers';
+export interface ChainEventListener {
+    onAccountChanged(): void;
+    onChainChanged(chainId?: number): void;
+}
+export interface IProviderAdapter<ConnectorType = unknown> {
+    chainId: number | undefined;
+    initConnector(connector: ConnectorType): void;
+    getSigner(): Signer;
+    initSigner?(signer: Signer): void;
+    init(chainId?: number): Promise<void>;
+    initConfig?(config?: any): Promise<void> | void;
+    connectToConnector(connector: ConnectorType): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    getAddress(): Promise<string>;
+    getSelectedNetwork(): EthereumNetwork | undefined;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    release(): void;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: string): Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: string): Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): Contract;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    switchAccount(signer: ethers.Signer): Promise<void>;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(): Promise<bigint>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+}

package/data-structures/snapshot/ClientAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../event-service/AbstractAccessTokenSnapshotService.cjs");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");require("../../constants/reorg-depths.constants.cjs");require("../../functions/utils/mutexes.utils.cjs");const c=require("./SnapshotFetcherService.cjs");class n extends t.AbstractAccessTokenSnapshotService{snapshotsService;constructor(e,r){super(e),this.snapshotsService=r}async fetchSnapshot(){const{contract:e}=this.blockchainEventEmitter,{chainId:r}=await e.provider.getNetwork();this.snapshotsService||(this.snapshotsService=new c.SnapshotFetcherService(r,e.address));const s=await this.snapshotsService.getAccessTokens();if(s.accessTokenContractAddress!==e.address||s.chainId!==r)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()}}exports.ClientAccessTokenSnapshotService=n;

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

@@ -0,0 +1,8 @@
+import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
+    private snapshotsService;
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<AccessTokenSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: AccessTokenSerializedSnapshot): Promise<unknown>;
+}

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/snapshot/index.d.ts

@@ -0,0 +1 @@
+export * from './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/token-price-fetcher/index.d.ts

@@ -0,0 +1 @@
+export * from './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>;
+}