h_test_1 0.0.1

package/data-structures/event-service/solana/AbstractSolanaCommitmentsSnapshotService.mjs

@@ -0,0 +1,96 @@
+import { poseidonFunction as p } from "../../../crypto/poseidon.mjs";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import { MerkleTree as a } from "../../merkle-tree/MerkleTree.mjs";
+import "ethers";
+import "../../../error-handling/error-codes.constants.mjs";
+import { advancedToBigInt as u } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSolanaSnapshotService as l } from "./AbstractSolanaSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as d } from "../../../functions/utils/merkleTree.utils.mjs";
+import { encodeSolanaOnChainUtxo as y, isSolanaOnChainUtxo as O } from "../../crypto-keys/decodeUTXO.mjs";
+class I extends l {
+  constructor(e) {
+    super(e, "NewCommitment");
+  }
+  _merkleTree;
+  _encryptedOutputs;
+  get merkleTree() {
+    return this._merkleTree;
+  }
+  get encryptedOutputs() {
+    return this._encryptedOutputs;
+  }
+  serializeSnapshot(e) {
+    return {
+      merkleTree: e.payload.merkleTree.toJSON(),
+      latestBlockNumber: e.latestBlockNumber,
+      encryptedOutputs: e.payload.encryptedOutputs.map((t) => ({
+        value: t.value,
+        isPositive: String(t.isPositive),
+        isBlocked: t.isBlocked ?? !1
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let t;
+    e.latestBlockNumber && e.merkleTree ? t = d(e.merkleTree) : t = a.create(p, 0n);
+    const n = e.encryptedOutputs?.map((r) => ({
+      value: r.value,
+      isPositive: JSON.parse(r.isPositive),
+      isBlocked: r.isBlocked ?? !1
+    }));
+    return {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      payload: {
+        merkleTree: t,
+        encryptedOutputs: n || []
+      }
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      encryptedOutputs: this._encryptedOutputs
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, encryptedOutputs: t }
+  }) {
+    this._merkleTree = e, this._encryptedOutputs = t;
+  }
+  async mapEvent(e) {
+    const { commitment: t, index: n, encrypted_output: r, on_chain_data: i } = e, s = u(t), o = u(n);
+    if (r.length === 0) {
+      const m = y(i);
+      return {
+        commitment: s,
+        index: o,
+        encryptedOutput: m
+      };
+    }
+    const c = `0x${Buffer.from(r).toString("hex")}`;
+    return {
+      commitment: s,
+      index: o,
+      encryptedOutput: c
+    };
+  }
+  acceptEvent(e, t, n, r) {
+    if (!this.encryptedOutputs.map((i) => i.value).includes(e.encryptedOutput)) {
+      if (!this._merkleTree.insert(e.commitment, e.index >= 0 ? e.index : -1n * e.index))
+        return !1;
+      const s = {
+        value: e.encryptedOutput,
+        isPositive: !O(e.encryptedOutput),
+        isBlocked: r ?? !1
+      };
+      return this._encryptedOutputs.push(s), !0;
+    }
+    return !1;
+  }
+}
+export {
+  I as AbstractSolanaCommitmentsSnapshotService
+};

package/data-structures/event-service/solana/AbstractSolanaEventService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class i{solanaBlockchainEventEmitter;eventName;constructor(e,s){this.solanaBlockchainEventEmitter=e,this.eventName=s,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.solanaBlockchainEventEmitter.latestBlockNumber}intervalClear(){this.solanaBlockchainEventEmitter.intervalClear()}async processEventsPage(e){const s=[],n=new Set;e.forEach(({eventName:t,signature:a})=>{t==="BlockedUtxosCreated"&&n.add(a)});const c=e.filter(t=>t.eventName===this.eventName).map(async t=>{try{const a=await this.mapEvent(t.data),o=n.has(t.signature);return await this.acceptEvent(a,t.slot,t.signature,o)?a:null}catch{return null}}),r=(await Promise.all(c)).filter(t=>t!==null);s.push(...r);const l=s.length;return await this.afterEventsAccepted(l),s.length}}exports.AbstractSolanaEventService=i;

package/data-structures/event-service/solana/AbstractSolanaEventService.d.ts

@@ -0,0 +1,22 @@
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+export interface SolanaEvent {
+    signature: string;
+    slot: number;
+    blockTime: number;
+    programId: any;
+    data: any;
+    eventName: string;
+}
+type PromiseOrValue<T> = T | Promise<T>;
+export declare abstract class AbstractSolanaEventService<EventType, SerializedEventType = unknown> {
+    protected solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter;
+    protected readonly eventName: string;
+    protected constructor(solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter, eventName: string);
+    get latestBlockNumber(): number;
+    intervalClear(): void;
+    private processEventsPage;
+    protected abstract acceptEvent(event: EventType, slot: number, signature?: string, isBlocked?: boolean): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: SerializedEventType): PromiseOrValue<EventType>;
+    protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
+}
+export {};

package/data-structures/event-service/solana/AbstractSolanaEventService.mjs

@@ -0,0 +1,33 @@
+class E {
+  solanaBlockchainEventEmitter;
+  eventName;
+  constructor(e, s) {
+    this.solanaBlockchainEventEmitter = e, this.eventName = s, e.addEventProcessorFunction(this.processEventsPage.bind(this));
+  }
+  get latestBlockNumber() {
+    return this.solanaBlockchainEventEmitter.latestBlockNumber;
+  }
+  intervalClear() {
+    this.solanaBlockchainEventEmitter.intervalClear();
+  }
+  async processEventsPage(e) {
+    const s = [], a = /* @__PURE__ */ new Set();
+    e.forEach(({ eventName: t, signature: n }) => {
+      t === "BlockedUtxosCreated" && a.add(n);
+    });
+    const c = e.filter((t) => t.eventName === this.eventName).map(async (t) => {
+      try {
+        const n = await this.mapEvent(t.data), o = a.has(t.signature);
+        return await this.acceptEvent(n, t.slot, t.signature, o) ? n : null;
+      } catch {
+        return null;
+      }
+    }), r = (await Promise.all(c)).filter((t) => t !== null);
+    s.push(...r);
+    const l = s.length;
+    return await this.afterEventsAccepted(l), s.length;
+  }
+}
+export {
+  E as AbstractSolanaEventService
+};

package/data-structures/event-service/solana/AbstractSolanaNullifierSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("ethers"),i=require("../../../functions/utils/amounts.utils.cjs"),s=require("./AbstractSolanaSnapshotService.cjs");class n extends s.AbstractSolanaSnapshotService{constructor(e){super(e,"Nullified")}_nullifiers;get nullifiers(){return this._nullifiers}serializeSnapshot(e){return{nullifiers:Array.from(e.payload.nullifiers).map(r=>r.toString()),latestBlockNumber:e.latestBlockNumber}}deserializeSnapshot(e){return{latestBlockNumber:e.latestBlockNumber??0,payload:{nullifiers:new Set(e.nullifiers??[])}}}acceptEvent(e,r){try{return this._nullifiers.has(e.nullifier)?!1:(this._nullifiers.add(e.nullifier),!0)}catch(l){return console.error(l),!1}}mapEvent(e){return{nullifier:t.ethers.toBeHex(i.advancedToBigInt(e.nullifier))}}getSnapshotPayload(){return{nullifiers:this._nullifiers}}populateSnapshot({payload:{nullifiers:e}}){this._nullifiers=e}}exports.AbstractSolanaNullifierSnapshotService=n;

package/data-structures/event-service/solana/AbstractSolanaNullifierSnapshotService.d.ts

@@ -0,0 +1,21 @@
+import { NullifierEvent } from '../../../types/commitments.types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+export type SolanaNullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type SolanaNullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractSolanaNullifierSnapshotService extends AbstractSolanaSnapshotService<NullifierEvent<string>, NullifierEvent<number[]>, SolanaNullifierSnapshotPayload, SolanaNullifierSerializedSnapshot> {
+    constructor(solanaEventEmitter: SolanaBlockchainEventEmitter);
+    private _nullifiers;
+    get nullifiers(): Set<string>;
+    protected serializeSnapshot(snapshot: SolanaSnapshot<SolanaNullifierSnapshotPayload>): SolanaNullifierSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: SolanaNullifierSerializedSnapshot): SolanaSnapshot<SolanaNullifierSnapshotPayload>;
+    protected acceptEvent(event: NullifierEvent<string>, _slot: number): boolean;
+    protected mapEvent(event: NullifierEvent<number[]>): NullifierEvent<string>;
+    protected getSnapshotPayload(): SolanaNullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: SolanaSnapshot<SolanaNullifierSnapshotPayload>): void;
+}

package/data-structures/event-service/solana/AbstractSolanaNullifierSnapshotService.mjs

@@ -0,0 +1,49 @@
+import { ethers as i } from "ethers";
+import { advancedToBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSolanaSnapshotService as n } from "./AbstractSolanaSnapshotService.mjs";
+class f extends n {
+  constructor(r) {
+    super(r, "Nullified");
+  }
+  _nullifiers;
+  get nullifiers() {
+    return this._nullifiers;
+  }
+  serializeSnapshot(r) {
+    return {
+      nullifiers: Array.from(r.payload.nullifiers).map((e) => e.toString()),
+      latestBlockNumber: r.latestBlockNumber
+    };
+  }
+  deserializeSnapshot(r) {
+    return {
+      latestBlockNumber: r.latestBlockNumber ?? 0,
+      payload: {
+        nullifiers: new Set(r.nullifiers ?? [])
+      }
+    };
+  }
+  acceptEvent(r, e) {
+    try {
+      return this._nullifiers.has(r.nullifier) ? !1 : (this._nullifiers.add(r.nullifier), !0);
+    } catch (l) {
+      return console.error(l), !1;
+    }
+  }
+  mapEvent(r) {
+    return {
+      nullifier: i.toBeHex(t(r.nullifier))
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      nullifiers: this._nullifiers
+    };
+  }
+  populateSnapshot({ payload: { nullifiers: r } }) {
+    this._nullifiers = r;
+  }
+}
+export {
+  f as AbstractSolanaNullifierSnapshotService
+};

package/data-structures/event-service/solana/AbstractSolanaSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./AbstractSolanaEventService.cjs"),e=require("../../../constants/save-depths.cjs");class o extends a.AbstractSolanaEventService{savedLatestSlot=0;chainId=0;constructor(t,s){super(t,s)}async init(){await this.loadSnapshot(),this.chainId=this.solanaBlockchainEventEmitter.chainId}async retrieveEventsFromLatestBlock(){await this.solanaBlockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}async loadSnapshot(){const t=await this.fetchSnapshot(),s=this.deserializeSnapshot(t);this.populateSnapshot(s),this.solanaBlockchainEventEmitter.syncFromAtMost(s.latestBlockNumber),this.savedLatestSlot=s.latestBlockNumber}saveSnapshot(){return this.savedLatestSlot=this.latestBlockNumber,this.persistSnapshot(this.serializeSnapshot({latestBlockNumber:this.latestBlockNumber,payload:this.getSnapshotPayload()}))}async afterEventsAccepted(t){(t>0||this.savedLatestSlot+e.saveDepths[this.chainId]<this.latestBlockNumber)&&await this.saveSnapshot()}}exports.AbstractSolanaSnapshotService=o;

package/data-structures/event-service/solana/AbstractSolanaSnapshotService.d.ts

@@ -0,0 +1,22 @@
+import { AbstractSolanaEventService } from './AbstractSolanaEventService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+export interface SolanaSnapshot<SnapshotPayloadType> {
+    readonly latestBlockNumber: number;
+    readonly payload: SnapshotPayloadType;
+}
+export declare abstract class AbstractSolanaSnapshotService<EventType, SerializedEventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractSolanaEventService<EventType, SerializedEventType> {
+    private savedLatestSlot;
+    private chainId;
+    protected constructor(solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter, eventName: string);
+    init(): Promise<void>;
+    retrieveEventsFromLatestBlock(): Promise<void>;
+    private loadSnapshot;
+    protected saveSnapshot(): Promise<unknown>;
+    protected afterEventsAccepted(eventsCount: number): Promise<void>;
+    protected abstract getSnapshotPayload(): SnapshotPayloadType;
+    protected abstract populateSnapshot(snapshot: SolanaSnapshot<SnapshotPayloadType>): void;
+    protected abstract serializeSnapshot(snapshot: SolanaSnapshot<SnapshotPayloadType>): SerializedSnapshotType;
+    protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): SolanaSnapshot<SnapshotPayloadType>;
+    protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
+    protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
+}

package/data-structures/event-service/solana/AbstractSolanaSnapshotService.mjs

@@ -0,0 +1,33 @@
+import { AbstractSolanaEventService as a } from "./AbstractSolanaEventService.mjs";
+import { saveDepths as e } from "../../../constants/save-depths.mjs";
+class n extends a {
+  savedLatestSlot = 0;
+  chainId = 0;
+  constructor(t, s) {
+    super(t, s);
+  }
+  async init() {
+    await this.loadSnapshot(), this.chainId = this.solanaBlockchainEventEmitter.chainId;
+  }
+  async retrieveEventsFromLatestBlock() {
+    await this.solanaBlockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
+  }
+  async loadSnapshot() {
+    const t = await this.fetchSnapshot(), s = this.deserializeSnapshot(t);
+    this.populateSnapshot(s), this.solanaBlockchainEventEmitter.syncFromAtMost(s.latestBlockNumber), this.savedLatestSlot = s.latestBlockNumber;
+  }
+  saveSnapshot() {
+    return this.savedLatestSlot = this.latestBlockNumber, this.persistSnapshot(
+      this.serializeSnapshot({
+        latestBlockNumber: this.latestBlockNumber,
+        payload: this.getSnapshotPayload()
+      })
+    );
+  }
+  async afterEventsAccepted(t) {
+    (t > 0 || this.savedLatestSlot + e[this.chainId] < this.latestBlockNumber) && await this.saveSnapshot();
+  }
+}
+export {
+  n as AbstractSolanaSnapshotService
+};

package/data-structures/event-service/solana/SolanaBlockchainEventEmitter.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("@coral-xyz/anchor"),m=require("../../../functions/utils/resolve-sync.utils.cjs"),p=require("../../../functions/utils/mutexes.utils.cjs"),l=require("../../../error-handling/logger.cjs"),g=require("../../../constants/chains.constants.cjs"),f=require("../../../functions/utils/caseInsensitive.utils.cjs"),d=1e3;class y{connection;programId;_latestSlot;_initialSlot;onEventsProcessed;eventProcessors=new Set;maxPageSize;isReady=!1;isServer;intervalId;inProgress;anchorParser;eventsFetchingMutex;constructor(e,r,a,s,n,o=p.balanceFetchingMutex){this.connection=e,this.programId=r,this._initialSlot=a,this.maxPageSize=n,this.isServer=s,this.inProgress=!1,this.eventsFetchingMutex=o}get latestBlockNumber(){return this._latestSlot??this._initialSlot}setIdl(e){try{const r=new v.BorshCoder(e);this.anchorParser=new v.EventParser(this.programId,r)}catch(r){l.Logger.error("Failed to initialize Anchor EventParser:",r),this.anchorParser=void 0}}syncFromAtMost(e){(this._latestSlot===void 0||e<this._latestSlot)&&(this._latestSlot=e)}intervalClear(){this.isReady=!1,this.eventProcessors=new Set,clearInterval(this.intervalId)}async init(){if(this.isReady)throw new Error("Already initialized");this.isReady=!0,await this.retrieveEvents(this.latestBlockNumber+1),this.intervalId=setInterval(async()=>{await this.retrieveEvents(this.latestBlockNumber)},3500)}requireReady(){if(!this.isReady)throw new Error("Not ready")}get chainId(){const e=this.connection.rpcEndpoint;return f.caseInsensitiveEqual(e,g.networkRegistry[g.chainIds.solanaMainnet].fetchRpcUrl)?g.chainIds.solanaMainnet:g.chainIds.solanaLocalnet}addEventProcessorFunction(e){if(this.isReady)throw new Error("Can't add event processor after event emitter initialized");this.eventProcessors.add(e)}async getLastSlotForEventRequest(){const e=await this.connection.getSlot();return this.isServer?Math.max(this.latestBlockNumber,e-32+1):e}async retrieveEvents(e,r=!1){const a=e;return this.requireReady(),await this.eventsFetchingMutex.runExclusive(async()=>{try{if(this.inProgress&&!r)return!1;this.inProgress=!0;let n=0;const o=await this.getLastSlotForEventRequest();if(o<a)return this.inProgress=!1,!1;const c=m.getSequence(a,o,this.maxPageSize),h=[];await m.resolveSync(c.map(({from:t,to:u})=>async()=>{const S=await this.getProgramEvents(t,u);h.push(...S)}));const i=await Promise.all([...this.eventProcessors].map(t=>t(h)));return this._latestSlot=o,n+=i.reduce((t,u)=>t+u,0),this.onEventsProcessed?.(n),this.inProgress=!1,!0}catch(n){return l.Logger.error("retrieveEvents error:",n),this.inProgress=!1,!1}})}async getProgramEvents(e,r){const a=[];try{const s=await this.connection.getSignaturesForAddress(this.programId,{limit:d,before:void 0});let n=s.length;for(;n>=d;){const i=s[s.length-1],t=await this.connection.getSignaturesForAddress(this.programId,{limit:d,before:i.signature});if(t.length===0)break;s.push(...t),n=t.length}const c=s.filter(i=>i.slot>=e&&i.slot<=r).map(async i=>{try{const t=await this.connection.getTransaction(i.signature,{commitment:"confirmed",maxSupportedTransactionVersion:0});return t&&t.meta&&t.meta.logMessages?this.parseLogsForEvents(t.meta.logMessages,i.signature,i.slot,t.blockTime||null):[]}catch(t){return l.Logger.error(`Failed to get transaction ${i.signature}:`,t),[]}}),h=await Promise.all(c);a.push(...h.flat())}catch(s){l.Logger.error("Error getting program events:",s)}return a}parseLogsForEvents(e,r,a,s){if(!this.anchorParser)return[];try{return Array.from(this.anchorParser.parseLogs(e)).map(({name:o,data:c})=>({signature:r,slot:a,blockTime:s||0,programId:this.programId,data:c,eventName:o}))}catch(n){return l.Logger.error("Anchor EventParser failed; falling back to generic parsing:",n),[]}}}exports.SolanaBlockchainEventEmitter=y;

package/data-structures/event-service/solana/SolanaBlockchainEventEmitter.d.ts

@@ -0,0 +1,41 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import type { Idl } from '@coral-xyz/anchor';
+import { Mutex } from 'async-mutex';
+interface SolanaEvent {
+    signature: string;
+    slot: number;
+    blockTime: number;
+    programId: PublicKey;
+    data: any;
+    eventName: string;
+}
+export type SolanaEventProcessorFunction = (events: SolanaEvent[]) => Promise<number> | number;
+export declare class SolanaBlockchainEventEmitter {
+    readonly connection: Connection;
+    readonly programId: PublicKey;
+    private _latestSlot;
+    private _initialSlot;
+    onEventsProcessed?: (acceptedEventCount: number) => void;
+    private eventProcessors;
+    private readonly maxPageSize?;
+    private isReady;
+    private isServer;
+    private intervalId?;
+    private inProgress;
+    private anchorParser?;
+    private eventsFetchingMutex;
+    constructor(connection: Connection, programId: PublicKey, initialSlot: number, isServer: boolean, maxPageSize?: number, eventsFetchingMutex?: Mutex);
+    get latestBlockNumber(): number;
+    setIdl(idl: Idl): void;
+    syncFromAtMost(slot: number): void;
+    intervalClear(): void;
+    init(): Promise<void>;
+    private requireReady;
+    get chainId(): number;
+    addEventProcessorFunction(eventProcessorFunction: SolanaEventProcessorFunction): void;
+    private getLastSlotForEventRequest;
+    retrieveEvents(fromBlock: number, useForce?: boolean): Promise<boolean>;
+    private getProgramEvents;
+    private parseLogsForEvents;
+}
+export {};

package/data-structures/event-service/solana/SolanaBlockchainEventEmitter.mjs

@@ -0,0 +1,154 @@
+import { BorshCoder as v, EventParser as p } from "@coral-xyz/anchor";
+import { getSequence as f, resolveSync as S } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { balanceFetchingMutex as P } from "../../../functions/utils/mutexes.utils.mjs";
+import { Logger as l } from "../../../error-handling/logger.mjs";
+import { networkRegistry as y, chainIds as u } from "../../../constants/chains.constants.mjs";
+import { caseInsensitiveEqual as E } from "../../../functions/utils/caseInsensitive.utils.mjs";
+const d = 1e3;
+class A {
+  connection;
+  programId;
+  _latestSlot;
+  _initialSlot;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  anchorParser;
+  eventsFetchingMutex;
+  constructor(t, r, a, s, n, o = P) {
+    this.connection = t, this.programId = r, this._initialSlot = a, this.maxPageSize = n, this.isServer = s, this.inProgress = !1, this.eventsFetchingMutex = o;
+  }
+  get latestBlockNumber() {
+    return this._latestSlot ?? this._initialSlot;
+  }
+  setIdl(t) {
+    try {
+      const r = new v(t);
+      this.anchorParser = new p(this.programId, r);
+    } catch (r) {
+      l.error("Failed to initialize Anchor EventParser:", r), this.anchorParser = void 0;
+    }
+  }
+  syncFromAtMost(t) {
+    (this._latestSlot === void 0 || t < this._latestSlot) && (this._latestSlot = t);
+  }
+  intervalClear() {
+    this.isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), clearInterval(this.intervalId);
+  }
+  async init() {
+    if (this.isReady)
+      throw new Error("Already initialized");
+    this.isReady = !0, await this.retrieveEvents(this.latestBlockNumber + 1), this.intervalId = setInterval(async () => {
+      await this.retrieveEvents(this.latestBlockNumber);
+    }, 3500);
+  }
+  requireReady() {
+    if (!this.isReady)
+      throw new Error("Not ready");
+  }
+  get chainId() {
+    const t = this.connection.rpcEndpoint;
+    return E(t, y[u.solanaMainnet].fetchRpcUrl) ? u.solanaMainnet : u.solanaLocalnet;
+  }
+  addEventProcessorFunction(t) {
+    if (this.isReady)
+      throw new Error("Can't add event processor after event emitter initialized");
+    this.eventProcessors.add(t);
+  }
+  async getLastSlotForEventRequest() {
+    const t = await this.connection.getSlot();
+    return this.isServer ? Math.max(this.latestBlockNumber, t - 32 + 1) : t;
+  }
+  // Implementation for IBlockchainEventEmitter interface (blockNumber terminology)
+  async retrieveEvents(t, r = !1) {
+    const a = t;
+    return this.requireReady(), await this.eventsFetchingMutex.runExclusive(async () => {
+      try {
+        if (this.inProgress && !r)
+          return !1;
+        this.inProgress = !0;
+        let n = 0;
+        const o = await this.getLastSlotForEventRequest();
+        if (o < a)
+          return this.inProgress = !1, !1;
+        const c = f(a, o, this.maxPageSize), h = [];
+        await S(
+          c.map(({ from: e, to: g }) => async () => {
+            const m = await this.getProgramEvents(e, g);
+            h.push(...m);
+          })
+        );
+        const i = await Promise.all(
+          [...this.eventProcessors].map((e) => e(h))
+        );
+        return this._latestSlot = o, n += i.reduce((e, g) => e + g, 0), this.onEventsProcessed?.(n), this.inProgress = !1, !0;
+      } catch (n) {
+        return l.error("retrieveEvents error:", n), this.inProgress = !1, !1;
+      }
+    });
+  }
+  async getProgramEvents(t, r) {
+    const a = [];
+    try {
+      const s = await this.connection.getSignaturesForAddress(this.programId, {
+        limit: d,
+        before: void 0
+        // Start from the latest
+      });
+      let n = s.length;
+      for (; n >= d; ) {
+        const i = s[s.length - 1], e = await this.connection.getSignaturesForAddress(this.programId, {
+          limit: d,
+          before: i.signature
+        });
+        if (e.length === 0)
+          break;
+        s.push(...e), n = e.length;
+      }
+      const c = s.filter((i) => i.slot >= t && i.slot <= r).map(async (i) => {
+        try {
+          const e = await this.connection.getTransaction(i.signature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+          });
+          return e && e.meta && e.meta.logMessages ? this.parseLogsForEvents(
+            e.meta.logMessages,
+            i.signature,
+            i.slot,
+            e.blockTime || null
+          ) : [];
+        } catch (e) {
+          return l.error(`Failed to get transaction ${i.signature}:`, e), [];
+        }
+      }), h = await Promise.all(c);
+      a.push(...h.flat());
+    } catch (s) {
+      l.error("Error getting program events:", s);
+    }
+    return a;
+  }
+  parseLogsForEvents(t, r, a, s) {
+    if (!this.anchorParser)
+      return [];
+    try {
+      return Array.from(this.anchorParser.parseLogs(t)).map(({ name: o, data: c }) => ({
+        signature: r,
+        slot: a,
+        blockTime: s || 0,
+        programId: this.programId,
+        data: c,
+        eventName: o
+      }));
+    } catch (n) {
+      return l.error("Anchor EventParser failed; falling back to generic parsing:", n), [];
+    }
+  }
+}
+export {
+  A as SolanaBlockchainEventEmitter
+};

package/data-structures/http/BasicHttpClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("axios");class o{axiosInstance;constructor(){this.axiosInstance=n.create()}async get(s,t){return(await this.axiosInstance.get(s,t)).data}async post(s,t,e){return(await this.axiosInstance.post(s,t,e)).data}async put(s,t,e){return(await this.axiosInstance.put(s,t,e)).data}async patch(s,t,e){return(await this.axiosInstance.patch(s,t,e)).data}async delete(s,t){return(await this.axiosInstance.delete(s,t)).data}}exports.BasicHttpClient=o;

package/data-structures/http/BasicHttpClient.d.ts

@@ -0,0 +1,11 @@
+import { AxiosRequestConfig } from 'axios';
+import { HttpClient } from '../../types/http.types';
+export declare class BasicHttpClient implements HttpClient {
+    private axiosInstance;
+    constructor();
+    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>;
+}

package/data-structures/http/BasicHttpClient.mjs

@@ -0,0 +1,25 @@
+import n from "axios";
+class c {
+  axiosInstance;
+  constructor() {
+    this.axiosInstance = n.create();
+  }
+  async get(s, t) {
+    return (await this.axiosInstance.get(s, t)).data;
+  }
+  async post(s, t, a) {
+    return (await this.axiosInstance.post(s, t, a)).data;
+  }
+  async put(s, t, a) {
+    return (await this.axiosInstance.put(s, t, a)).data;
+  }
+  async patch(s, t, a) {
+    return (await this.axiosInstance.patch(s, t, a)).data;
+  }
+  async delete(s, t) {
+    return (await this.axiosInstance.delete(s, t)).data;
+  }
+}
+export {
+  c as BasicHttpClient
+};

package/data-structures/http/HttpClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./BasicHttpClient.cjs");let n=new i.BasicHttpClient;const l={setHttpClient:t=>{n=t},get:(t,e)=>n.get(t,e),post:(t,e,p)=>n.post(t,e,p),put:(t,e,p)=>n.put(t,e,p),patch:(t,e,p)=>n.patch(t,e,p),delete:(t,e)=>n.delete(t,e)};exports.httpClient=l;

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

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../types/http.types';
+declare const httpClient: {
+    setHttpClient: (client: HttpClient) => void;
+    get: <T = any>(url: string, config?: any) => Promise<T>;
+    post: <T_1 = any>(url: string, data?: any, config?: any) => Promise<T_1>;
+    put: <T_2 = any>(url: string, data?: any, config?: any) => Promise<T_2>;
+    patch: <T_3 = any>(url: string, data?: any, config?: any) => Promise<T_3>;
+    delete: <T_4 = any>(url: string, config?: any) => Promise<T_4>;
+};
+export { httpClient };

package/data-structures/http/HttpClient.mjs

@@ -0,0 +1,15 @@
+import { BasicHttpClient as l } from "./BasicHttpClient.mjs";
+let p = new l();
+const o = {
+  setHttpClient: (t) => {
+    p = t;
+  },
+  get: (t, e) => p.get(t, e),
+  post: (t, e, n) => p.post(t, e, n),
+  put: (t, e, n) => p.put(t, e, n),
+  patch: (t, e, n) => p.patch(t, e, n),
+  delete: (t, e) => p.delete(t, e)
+};
+export {
+  o as httpClient
+};

package/data-structures/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HttpClient';
+export * from './BasicHttpClient';

package/data-structures/index.d.ts

@@ -0,0 +1,18 @@
+export * from './ValueCache';
+export * from './crypto-keys';
+export * from './Hinkal';
+export * from './merkle-tree';
+export * from './provider-adapter/IProviderAdapter';
+export * from './event-service';
+export * from './utxo/Utxo';
+export * from './custom-token-registry/CustomTokenRegistry';
+export * from './token-price-fetcher';
+export * from './transactions-manager';
+export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
+export * from './cacheDevices';
+export * from './IndexedDB';
+export * from './TokenDBs';
+export * from './presale';
+export * from './snapshot';
+export * from './http';
+export * from './ApprovalDBs';

package/data-structures/merkle-tree/MerkleTree.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../constants/protocol.constants.cjs"),c=require("../../error-handling/logError.cjs"),u=require("./MerkleTreeIncompleteError.cjs");class l{constructor(t,e,r,n,s,i,h){this.hashFunction=t,this.levels=e,this.defaultNodeValue=r,this.tree=n??new Map,this.count=h??0n,this.index=i??2n**(e-1n),s?this.reverseTree=s:this.reverseTree=this.createReverseTree()}tree;count;index;reverseTree;static createWithData(t,e,r,n,s,i,h){return new l(s,i,h,t,e,r,n)}static create(t,e,r=o.MERKLE_LEVELS){return new l(t,r,e)}createReverseTree(){const t=new Map;for(let e=this.getStartIndex();e<this.getStartIndex()+this.count;e+=1n){const r=this.tree.get(e);r!==void 0&&t.set(r,e)}return t}getStartIndex(){return 2n**(this.levels-1n)}logarithm2(t){let e=0n;for(;2n**e<t;)e+=1n;return e}bigIntMax(t,e){return t>e?t:e}forceInsert(t,e){if(e<this.getStartIndex())throw new RangeError;this.tree.set(e,t),this.reverseTree.set(t,e);const r=this.index-this.getStartIndex(),n=this.logarithm2(r);let s=e;for(let i=1n;i<=n;i+=1n){s/=2n;const h=this.hashFunction(this.tree.get(s*2n)||this.defaultNodeValue,this.tree.get(s*2n+1n)||this.defaultNodeValue);this.tree.set(s,h)}}insert(t,e){let r=!1;return this.tree.has(e)&&(r=!0,c.logError(`Editing commitment index: ${e} `)),r||(this.count+=1n),this.index=this.bigIntMax(this.index,e+1n),this.forceInsert(t,e),!0}remove(t){this.forceInsert(this.defaultNodeValue,t)}completenessCheck(){if(this.count!==this.index-this.getStartIndex())throw new u.MerkleTreeIncompleteError}getRootHash(){this.completenessCheck();for(let t=1n;t<2n**this.levels;t*=2n)if(this.tree.get(t))return this.tree.get(t);return this.defaultNodeValue}getMerkleData(){return this.completenessCheck(),new Map(this.tree)}getSiblingIndex(t){return t===1n?1n:t%2n===1n?t-1n:t+1n}getSiblingHashesForVerification(t){this.completenessCheck();let e=this.reverseTree.get(t);if(e===void 0)return new Array(Number(o.CIRCOM_MERKLE_LENGTH)).fill(0n);const r=[];for(;e!==0n;)r.push(this.tree.get(this.getSiblingIndex(e))||this.defaultNodeValue),e/=2n;return r.slice(0,o.CIRCOM_MERKLE_LENGTH)}getSiblingSides(t){this.completenessCheck();let e=this.reverseTree.get(t);if(e===void 0)return new Array(Number(o.CIRCOM_MERKLE_LENGTH)).fill(0n);const r=[];for(;e!==0n;){const n=e%2n===0n?0n:1n;r.push(n),e/=2n}return r.slice(0,o.CIRCOM_MERKLE_LENGTH)}toJSON(){const{tree:t,reverseTree:e,count:r,index:n}=this;return{tree:Object.fromEntries(t),reverseTree:Object.fromEntries(e),count:r.toString(),index:n.toString()}}clone(){return l.createWithData(new Map(this.tree),new Map(this.reverseTree),this.index,this.count,this.hashFunction,this.levels,this.defaultNodeValue)}getIndex(){return this.index}}exports.MerkleTree=l;