@gurge/sdk 0.2.32

package/data-structures/event-service/evm/BlockchainEventEmitter.mjs

@@ -0,0 +1,104 @@
+import { blockReorgDepth as e } from "../../../constants/reorg-depths.constants.mjs";
+import { Logger as t } from "../../../error-handling/logger.mjs";
+import { getSequence as n, resolveSync as r } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { getProviderFromContract as i } from "../../../functions/utils/getSignerFromContract.mjs";
+import { BlockchainEvent as a } from "../../BlockchainEvent/BlockchainEvent.mjs";
+import { ethers as o } from "ethers";
+//#region libs/shared/common/src/data-structures/event-service/evm/BlockchainEventEmitter.ts
+var s = class {
+	RETRY_MIN_PAGE_SIZE = 100;
+	MAX_RETRIES = 20;
+	_chainId;
+	contract;
+	depositOnChainUtxosContract;
+	_latestBlockNumber;
+	_initialBlockNumber;
+	onEventsProcessed;
+	eventProcessors = /* @__PURE__ */ new Set();
+	maxPageSize;
+	_isReady = !1;
+	isServer;
+	inProgress;
+	eventsFetchingMutex;
+	constructor(e, t, n, r, i, a, o) {
+		this.contract = t, this.depositOnChainUtxosContract = o, this._chainId = e, this._initialBlockNumber = n, this.maxPageSize = a, this.isServer = r, this.inProgress = !1, this.eventsFetchingMutex = i;
+	}
+	get latestBlockNumber() {
+		return this._latestBlockNumber ?? this._initialBlockNumber;
+	}
+	get chainId() {
+		return this._chainId;
+	}
+	get isReady() {
+		return this._isReady;
+	}
+	syncFromAtMost(e) {
+		(this._latestBlockNumber === void 0 || e < this._latestBlockNumber) && (this._latestBlockNumber = e);
+	}
+	advanceLatestBlockNumber(e) {
+		e > (this._latestBlockNumber ?? this._initialBlockNumber) && (this._latestBlockNumber = e);
+	}
+	intervalClear() {
+		this._isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), this.clear();
+	}
+	async init() {
+		if (this._isReady) throw Error("Already initialized");
+		this._isReady = !0, await this.retrieveEvents(this.latestBlockNumber + 1), this.startUpdateListener();
+	}
+	requireReady() {
+		if (!this._isReady) throw Error("Not ready");
+	}
+	async getEventsForSingleContract(e, t, n, r = 0) {
+		try {
+			return (await e.queryFilter("*", t, n)).filter((e) => e instanceof o.EventLog);
+		} catch (i) {
+			if (r < this.MAX_RETRIES && n - t > this.RETRY_MIN_PAGE_SIZE) {
+				let i = Math.floor((t + n) / 2), a = await this.getEventsForSingleContract(e, t, i, r + 1), o = await this.getEventsForSingleContract(e, i + 1, n, r + 1);
+				return [...a, ...o];
+			}
+			throw i;
+		}
+	}
+	addEventProcessorFunction(e) {
+		if (this._isReady) throw Error("Can't add event processor after event emitter initialized");
+		this.eventProcessors.add(e);
+	}
+	async getEventsInRange(e, t) {
+		let i = [], o = n(e, t, this.maxPageSize);
+		await r(o.map(({ from: e, to: t }) => async () => {
+			let n = await this.getEventsForSingleContract(this.contract, e, t);
+			i.push(...n);
+		}));
+		let s = this.depositOnChainUtxosContract;
+		return s && await r(o.map(({ from: e, to: t }) => async () => {
+			let n = await this.getEventsForSingleContract(s, e, t);
+			i.push(...n);
+		})), i.map((e) => a.fromEthers(e));
+	}
+	async getLastBlockNumberForEventRequest() {
+		let t = await i(this.contract).getBlockNumber();
+		if (!this.isServer) return t;
+		let { chainId: n } = await i(this.contract).getNetwork();
+		return Math.max(this.latestBlockNumber, t - e[Number(n)] + 1);
+	}
+	async retrieveEvents(e, n = !1) {
+		return this.requireReady(), await this.eventsFetchingMutex.runExclusive(async () => {
+			try {
+				if (this.inProgress && !n) return !1;
+				this.inProgress = !0;
+				let t = await this.getLastBlockNumberForEventRequest();
+				if (t < e) return this.inProgress = !1, !1;
+				let r = await this.getEventsInRange(e, t);
+				return await this.processEvents(r, t), this._latestBlockNumber = t, this.inProgress = !1, !0;
+			} catch (e) {
+				return t.error("retrieveEvents error", e), this.inProgress = !1, !1;
+			}
+		});
+	}
+	async processEvents(e, t) {
+		let n = (await Promise.all([...this.eventProcessors].map((n) => n(e, t)))).reduce((e, t) => e + t, 0);
+		this.onEventsProcessed?.(n);
+	}
+};
+//#endregion
+export { s as BlockchainEventEmitter };

package/data-structures/event-service/evm/ClientBlockchainEventEmitter.cjs

@@ -0,0 +1 @@
+const e=require(`./BlockchainEventEmitter.cjs`),t=require(`../helpers/ClientEventHelper.cjs`);var n=class extends e.BlockchainEventEmitter{clientEventHelper;constructor(e,n,r,i,a,o,s){super(n,r,i,!1,a,o,s),this.clientEventHelper=new t.ClientEventHelper(n,e)}clear(){this.clientEventHelper.clear()}startUpdateListener(){this.clientEventHelper.startUpdateListener(async e=>{await this.eventsFetchingMutex.runExclusive(async()=>{await this.processEvents(e)})},this.latestBlockNumber+1,e=>this.advanceLatestBlockNumber(e))}};exports.ClientBlockchainEventEmitter=n;

package/data-structures/event-service/evm/ClientBlockchainEventEmitter.d.ts

@@ -0,0 +1,11 @@
+import { ethers } from 'ethers';
+import { EventCategory } from '../../../types/events.types';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { Mutex } from 'async-mutex';
+import { ClientEventHelper } from '../helpers/ClientEventHelper';
+export declare class ClientBlockchainEventEmitter extends BlockchainEventEmitter {
+    clientEventHelper: ClientEventHelper;
+    constructor(eventCategory: EventCategory, chainId: number, contract: ethers.Contract, initialBlockNumber: number, eventsFetchingMutex: Mutex, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract);
+    protected clear(): void;
+    protected startUpdateListener(): void;
+}

package/data-structures/event-service/evm/ClientBlockchainEventEmitter.mjs

@@ -0,0 +1,21 @@
+import { BlockchainEventEmitter as e } from "./BlockchainEventEmitter.mjs";
+import { ClientEventHelper as t } from "../helpers/ClientEventHelper.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/ClientBlockchainEventEmitter.ts
+var n = class extends e {
+	clientEventHelper;
+	constructor(e, n, r, i, a, o, s) {
+		super(n, r, i, !1, a, o, s), this.clientEventHelper = new t(n, e);
+	}
+	clear() {
+		this.clientEventHelper.clear();
+	}
+	startUpdateListener() {
+		this.clientEventHelper.startUpdateListener(async (e) => {
+			await this.eventsFetchingMutex.runExclusive(async () => {
+				await this.processEvents(e);
+			});
+		}, this.latestBlockNumber + 1, (e) => this.advanceLatestBlockNumber(e));
+	}
+};
+//#endregion
+export { n as ClientBlockchainEventEmitter };

package/data-structures/event-service/evm/PollingBlockchainEventEmitter.cjs

@@ -0,0 +1 @@
+const e=require(`./BlockchainEventEmitter.cjs`),t=require(`../helpers/PollingEventHelper.cjs`);var n=class extends e.BlockchainEventEmitter{pollingEventHelper=new t.PollingEventHelper(this.isServer);clear(){this.pollingEventHelper.clear()}startUpdateListener(){this.pollingEventHelper.startUpdateListener(async()=>{await this.retrieveEvents(this.latestBlockNumber)})}};exports.PollingBlockchainEventEmitter=n;

package/data-structures/event-service/evm/PollingBlockchainEventEmitter.d.ts

@@ -0,0 +1,6 @@
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export declare class PollingBlockchainEventEmitter extends BlockchainEventEmitter {
+    private pollingEventHelper;
+    protected clear(): void;
+    protected startUpdateListener(): void;
+}

package/data-structures/event-service/evm/PollingBlockchainEventEmitter.mjs

@@ -0,0 +1,16 @@
+import { BlockchainEventEmitter as e } from "./BlockchainEventEmitter.mjs";
+import { PollingEventHelper as t } from "../helpers/PollingEventHelper.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/PollingBlockchainEventEmitter.ts
+var n = class extends e {
+	pollingEventHelper = new t(this.isServer);
+	clear() {
+		this.pollingEventHelper.clear();
+	}
+	startUpdateListener() {
+		this.pollingEventHelper.startUpdateListener(async () => {
+			await this.retrieveEvents(this.latestBlockNumber);
+		});
+	}
+};
+//#endregion
+export { n as PollingBlockchainEventEmitter };

package/data-structures/event-service/helpers/ClientEventHelper.cjs

@@ -0,0 +1 @@
+const e=require(`../../../API/API.cjs`),t=require(`../../../error-handling/logger.cjs`),n=require(`../../BlockchainEvent/BlockchainEvent.cjs`);var r=5e3,i=class{chainId;eventCategory;pollIntervalId;constructor(e,t){this.chainId=e,this.eventCategory=t}clear(){this.pollIntervalId!=null&&(clearInterval(this.pollIntervalId),this.pollIntervalId=void 0)}startUpdateListener(i,a,o){let s=a,c=async()=>{try{let{events:t,latestBlockNumber:r}=await e.API.getSnapshotServerEvents(this.chainId,this.eventCategory,s);t.length>0&&await i(t.map(e=>n.BlockchainEvent.fromSerialized(e))),r>=s&&(s=r+1,o(s))}catch(e){t.Logger.error(`Snapshot events poll error`,e)}};this.pollIntervalId=setInterval(c,r)}};exports.ClientEventHelper=i;

package/data-structures/event-service/helpers/ClientEventHelper.d.ts

@@ -0,0 +1,10 @@
+import { EventCategory } from '../../../types/events.types';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export declare class ClientEventHelper {
+    chainId: number;
+    eventCategory: EventCategory;
+    private pollIntervalId;
+    constructor(chainId: number, eventCategory: EventCategory);
+    clear(): void;
+    startUpdateListener(processEvents: (events: BlockchainEvent[]) => Promise<void>, fromBlockNumber: number, onProcessed: (latestBlockNumber: number) => void): void;
+}

package/data-structures/event-service/helpers/ClientEventHelper.mjs

@@ -0,0 +1,28 @@
+import { API as e } from "../../../API/API.mjs";
+import { Logger as t } from "../../../error-handling/logger.mjs";
+import { BlockchainEvent as n } from "../../BlockchainEvent/BlockchainEvent.mjs";
+//#region libs/shared/common/src/data-structures/event-service/helpers/ClientEventHelper.ts
+var r = 5e3, i = class {
+	chainId;
+	eventCategory;
+	pollIntervalId;
+	constructor(e, t) {
+		this.chainId = e, this.eventCategory = t;
+	}
+	clear() {
+		this.pollIntervalId != null && (clearInterval(this.pollIntervalId), this.pollIntervalId = void 0);
+	}
+	startUpdateListener(i, a, o) {
+		let s = a, c = async () => {
+			try {
+				let { events: t, latestBlockNumber: r } = await e.getSnapshotServerEvents(this.chainId, this.eventCategory, s);
+				t.length > 0 && await i(t.map((e) => n.fromSerialized(e))), r >= s && (s = r + 1, o(s));
+			} catch (e) {
+				t.error("Snapshot events poll error", e);
+			}
+		};
+		this.pollIntervalId = setInterval(c, r);
+	}
+};
+//#endregion
+export { i as ClientEventHelper };

package/data-structures/event-service/helpers/PollingEventHelper.cjs

@@ -0,0 +1 @@
+var e=6e4,t=3500,n=class{intervalId;pollIntervalMs;constructor(n){this.pollIntervalMs=n?e:t}clear(){this.intervalId!==void 0&&clearInterval(this.intervalId),this.intervalId=void 0}startUpdateListener(e){this.intervalId=setInterval(async()=>{await e()},this.pollIntervalMs)}};exports.PollingEventHelper=n;

package/data-structures/event-service/helpers/PollingEventHelper.d.ts

@@ -0,0 +1,7 @@
+export declare class PollingEventHelper {
+    private intervalId;
+    private readonly pollIntervalMs;
+    constructor(isServer: boolean);
+    clear(): void;
+    startUpdateListener(retrieveEvents: () => Promise<void> | void): void;
+}

package/data-structures/event-service/helpers/PollingEventHelper.mjs

@@ -0,0 +1,18 @@
+//#region libs/shared/common/src/data-structures/event-service/helpers/PollingEventHelper.ts
+var e = 6e4, t = 3500, n = class {
+	intervalId;
+	pollIntervalMs;
+	constructor(n) {
+		this.pollIntervalMs = n ? e : t;
+	}
+	clear() {
+		this.intervalId !== void 0 && clearInterval(this.intervalId), this.intervalId = void 0;
+	}
+	startUpdateListener(e) {
+		this.intervalId = setInterval(async () => {
+			await e();
+		}, this.pollIntervalMs);
+	}
+};
+//#endregion
+export { n as PollingEventHelper };

package/data-structures/event-service/index.cjs

@@ -0,0 +1 @@
+require(`./evm/AbstractEventService.cjs`),require(`./evm/AbstractSnapshotService.cjs`),require(`./evm/AbstractCommitmentsSnapshotService.cjs`),require(`./evm/AbstractNullifierSnapshotService.cjs`),require(`./evm/BlockchainEventEmitter.cjs`),require(`./evm/PollingBlockchainEventEmitter.cjs`),require(`./evm/ClientBlockchainEventEmitter.cjs`),require(`./solana/SolanaBlockchainEventEmitter.cjs`),require(`./solana/ClientSolanaBlockchainEventEmitter.cjs`),require(`./solana/PollingSolanaBlockchainEventEmitter.cjs`),require(`./solana/AbstractSolanaEventService.cjs`),require(`./solana/AbstractSolanaSnapshotService.cjs`),require(`./solana/AbstractSolanaNullifierSnapshotService.cjs`),require(`./solana/AbstractSolanaCommitmentsSnapshotService.cjs`);

package/data-structures/event-service/index.d.ts

@@ -0,0 +1,14 @@
+export * from './evm/AbstractCommitmentsSnapshotService';
+export * from './evm/AbstractNullifierSnapshotService';
+export * from './evm/AbstractSnapshotService';
+export * from './evm/AbstractEventService';
+export * from './evm/BlockchainEventEmitter';
+export * from './evm/PollingBlockchainEventEmitter';
+export * from './evm/ClientBlockchainEventEmitter';
+export * from './solana/SolanaBlockchainEventEmitter';
+export * from './solana/ClientSolanaBlockchainEventEmitter';
+export * from './solana/PollingSolanaBlockchainEventEmitter';
+export * from './solana/AbstractSolanaEventService';
+export * from './solana/AbstractSolanaSnapshotService';
+export * from './solana/AbstractSolanaNullifierSnapshotService';
+export * from './solana/AbstractSolanaCommitmentsSnapshotService';

package/data-structures/event-service/index.mjs

@@ -0,0 +1,14 @@
+import "./evm/AbstractEventService.mjs";
+import "./evm/AbstractSnapshotService.mjs";
+import "./evm/AbstractCommitmentsSnapshotService.mjs";
+import "./evm/AbstractNullifierSnapshotService.mjs";
+import "./evm/BlockchainEventEmitter.mjs";
+import "./evm/PollingBlockchainEventEmitter.mjs";
+import "./evm/ClientBlockchainEventEmitter.mjs";
+import "./solana/SolanaBlockchainEventEmitter.mjs";
+import "./solana/ClientSolanaBlockchainEventEmitter.mjs";
+import "./solana/PollingSolanaBlockchainEventEmitter.mjs";
+import "./solana/AbstractSolanaEventService.mjs";
+import "./solana/AbstractSolanaSnapshotService.mjs";
+import "./solana/AbstractSolanaNullifierSnapshotService.mjs";
+import "./solana/AbstractSolanaCommitmentsSnapshotService.mjs";

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

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/amounts.utils.cjs`),t=require(`../../../crypto/poseidon.cjs`);require(`../../../crypto/index.cjs`);const n=require(`../../crypto-keys/decodeUTXO.cjs`),r=require(`../../merkle-tree/MerkleTree.cjs`);require(`../../merkle-tree/index.cjs`);const i=require(`../../../functions/utils/merkleTree.utils.cjs`),a=require(`./AbstractSolanaSnapshotService.cjs`);var o=class extends a.AbstractSolanaSnapshotService{constructor(e){super(e,`NewCommitment`)}_merkleTree;_encryptedOutputs;_encryptedOutputsByCommitment=new Map;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(e=>({value:e.value,isPositive:String(e.isPositive),isBlocked:e.isBlocked??!1})),encryptedOutputsByCommitment:Array.from(e.payload.encryptedOutputsByCommitment.entries()).map(([e,t])=>({commitment:e.toString(),encryptedOutput:t}))}}deserializeSnapshot(e){let n;n=e.latestBlockNumber&&e.merkleTree?i.contructMerkleTreeFromSerialized(e.merkleTree):r.MerkleTree.create(t.poseidonFunction,0n);let a=e.encryptedOutputs?.map(e=>({value:e.value,isPositive:JSON.parse(e.isPositive),isBlocked:e.isBlocked??!1})),o=new Map;return e.encryptedOutputsByCommitment?.forEach(({commitment:e,encryptedOutput:t})=>{o.set(BigInt(e),t)}),{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:n,encryptedOutputs:a||[],encryptedOutputsByCommitment:o}}}getSnapshotPayload(){return{merkleTree:this._merkleTree,encryptedOutputs:this._encryptedOutputs,encryptedOutputsByCommitment:this._encryptedOutputsByCommitment}}populateSnapshot({payload:{merkleTree:e,encryptedOutputs:t,encryptedOutputsByCommitment:n}}){this._merkleTree=e,this._encryptedOutputs=t,this._encryptedOutputsByCommitment=n}async mapEvent(t){let r=t.getArg(`commitment`),i=t.getArg(`index`),a=t.getArg(`encrypted_output`),o=t.getArg(`on_chain_data`),s=e.advancedToBigInt(r),c=e.advancedToBigInt(i);return a.length===0?{commitment:s,index:c,encryptedOutput:n.encodeSolanaOnChainUtxo(o)}:{commitment:s,index:c,encryptedOutput:`0x${Buffer.from(a).toString(`hex`)}`}}acceptEvent(e,t,r,i){let a=e.index>=0n?e.index:-1n*e.index,o=this._merkleTree.getValue(a);if(o===e.commitment)return!1;this._merkleTree.insert(e.commitment,a);let s=o===void 0?void 0:this._encryptedOutputsByCommitment.get(o);if(o!==void 0&&s!==void 0){let e=this.encryptedOutputs.findIndex(e=>e.value===s);e!==-1&&this.encryptedOutputs.splice(e,1),this._encryptedOutputsByCommitment.delete(o)}if(this._encryptedOutputsByCommitment.set(e.commitment,e.encryptedOutput),this.encryptedOutputs.map(e=>e.value).includes(e.encryptedOutput))return!0;let c={value:e.encryptedOutput,isPositive:!n.isSolanaOnChainUtxo(e.encryptedOutput),isBlocked:i??!1};return this._encryptedOutputs.push(c),!0}};exports.AbstractSolanaCommitmentsSnapshotService=o;

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

@@ -0,0 +1,34 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../../../types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SolanaCommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+    readonly encryptedOutputsByCommitment: Map<bigint, string>;
+};
+export type SolanaCommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+    encryptedOutputsByCommitment?: EncryptedOutputWithCommitment[];
+};
+export declare abstract class AbstractSolanaCommitmentsSnapshotService extends AbstractSolanaSnapshotService<CommitmentEvent<bigint>, SolanaCommitmentsSnapshotPayload, SolanaCommitmentsSerializedSnapshot> {
+    constructor(solanaEventEmitter: SolanaBlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    private _encryptedOutputsByCommitment;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: SolanaSnapshot<SolanaCommitmentsSnapshotPayload>): SolanaCommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: SolanaCommitmentsSerializedSnapshot): SolanaSnapshot<SolanaCommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs, encryptedOutputsByCommitment }, }: SolanaSnapshot<SolanaCommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: BlockchainEvent): Promise<CommitmentEvent<bigint>>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _slot: number, _signature?: string, isBlocked?: boolean): boolean;
+}

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

@@ -0,0 +1,98 @@
+import { advancedToBigInt as e } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as t } from "../../../crypto/poseidon.mjs";
+import "../../../crypto/index.mjs";
+import { encodeSolanaOnChainUtxo as n, isSolanaOnChainUtxo as r } from "../../crypto-keys/decodeUTXO.mjs";
+import { MerkleTree as i } from "../../merkle-tree/MerkleTree.mjs";
+import "../../merkle-tree/index.mjs";
+import { contructMerkleTreeFromSerialized as a } from "../../../functions/utils/merkleTree.utils.mjs";
+import { AbstractSolanaSnapshotService as o } from "./AbstractSolanaSnapshotService.mjs";
+//#region libs/shared/common/src/data-structures/event-service/solana/AbstractSolanaCommitmentsSnapshotService.ts
+var s = class extends o {
+	constructor(e) {
+		super(e, "NewCommitment");
+	}
+	_merkleTree;
+	_encryptedOutputs;
+	_encryptedOutputsByCommitment = /* @__PURE__ */ new Map();
+	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((e) => ({
+				value: e.value,
+				isPositive: String(e.isPositive),
+				isBlocked: e.isBlocked ?? !1
+			})),
+			encryptedOutputsByCommitment: Array.from(e.payload.encryptedOutputsByCommitment.entries()).map(([e, t]) => ({
+				commitment: e.toString(),
+				encryptedOutput: t
+			}))
+		};
+	}
+	deserializeSnapshot(e) {
+		let n;
+		n = e.latestBlockNumber && e.merkleTree ? a(e.merkleTree) : i.create(t, 0n);
+		let r = e.encryptedOutputs?.map((e) => ({
+			value: e.value,
+			isPositive: JSON.parse(e.isPositive),
+			isBlocked: e.isBlocked ?? !1
+		})), o = /* @__PURE__ */ new Map();
+		return e.encryptedOutputsByCommitment?.forEach(({ commitment: e, encryptedOutput: t }) => {
+			o.set(BigInt(e), t);
+		}), {
+			latestBlockNumber: e.latestBlockNumber ?? 0,
+			payload: {
+				merkleTree: n,
+				encryptedOutputs: r || [],
+				encryptedOutputsByCommitment: o
+			}
+		};
+	}
+	getSnapshotPayload() {
+		return {
+			merkleTree: this._merkleTree,
+			encryptedOutputs: this._encryptedOutputs,
+			encryptedOutputsByCommitment: this._encryptedOutputsByCommitment
+		};
+	}
+	populateSnapshot({ payload: { merkleTree: e, encryptedOutputs: t, encryptedOutputsByCommitment: n } }) {
+		this._merkleTree = e, this._encryptedOutputs = t, this._encryptedOutputsByCommitment = n;
+	}
+	async mapEvent(t) {
+		let r = t.getArg("commitment"), i = t.getArg("index"), a = t.getArg("encrypted_output"), o = t.getArg("on_chain_data"), s = e(r), c = e(i);
+		return a.length === 0 ? {
+			commitment: s,
+			index: c,
+			encryptedOutput: n(o)
+		} : {
+			commitment: s,
+			index: c,
+			encryptedOutput: `0x${Buffer.from(a).toString("hex")}`
+		};
+	}
+	acceptEvent(e, t, n, i) {
+		let a = e.index >= 0n ? e.index : -1n * e.index, o = this._merkleTree.getValue(a);
+		if (o === e.commitment) return !1;
+		this._merkleTree.insert(e.commitment, a);
+		let s = o === void 0 ? void 0 : this._encryptedOutputsByCommitment.get(o);
+		if (o !== void 0 && s !== void 0) {
+			let e = this.encryptedOutputs.findIndex((e) => e.value === s);
+			e !== -1 && this.encryptedOutputs.splice(e, 1), this._encryptedOutputsByCommitment.delete(o);
+		}
+		if (this._encryptedOutputsByCommitment.set(e.commitment, e.encryptedOutput), this.encryptedOutputs.map((e) => e.value).includes(e.encryptedOutput)) return !0;
+		let c = {
+			value: e.encryptedOutput,
+			isPositive: !r(e.encryptedOutput),
+			isBlocked: i ?? !1
+		};
+		return this._encryptedOutputs.push(c), !0;
+	}
+};
+//#endregion
+export { s as AbstractSolanaCommitmentsSnapshotService };

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

@@ -0,0 +1 @@
+var e=class{solanaBlockchainEventEmitter;eventName;constructor(e,t){this.solanaBlockchainEventEmitter=e,this.eventName=t,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.solanaBlockchainEventEmitter.latestBlockNumber}get isReady(){return this.solanaBlockchainEventEmitter.isReady}get chainId(){return this.solanaBlockchainEventEmitter.chainId}intervalClear(){this.solanaBlockchainEventEmitter.intervalClear()}async processEventsPage(e){let t=[],n=new Set;e.forEach(({eventName:e,transactionHash:t})=>{e===`BlockedUtxosCreated`&&n.add(t)});let r=e.filter(e=>e.eventName===this.eventName).map(async e=>{try{let t=await this.mapEvent(e),r=n.has(e.transactionHash);return await this.acceptEvent(t,e.blockNumber,e.transactionHash,r)?t:null}catch{return null}}),i=(await Promise.all(r)).filter(e=>e!==null);t.push(...i);let a=t.length;return await this.afterEventsAccepted(a),t.length}};exports.AbstractSolanaEventService=e;

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

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

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

@@ -0,0 +1,39 @@
+//#region libs/shared/common/src/data-structures/event-service/solana/AbstractSolanaEventService.ts
+var e = class {
+	solanaBlockchainEventEmitter;
+	eventName;
+	constructor(e, t) {
+		this.solanaBlockchainEventEmitter = e, this.eventName = t, e.addEventProcessorFunction(this.processEventsPage.bind(this));
+	}
+	get latestBlockNumber() {
+		return this.solanaBlockchainEventEmitter.latestBlockNumber;
+	}
+	get isReady() {
+		return this.solanaBlockchainEventEmitter.isReady;
+	}
+	get chainId() {
+		return this.solanaBlockchainEventEmitter.chainId;
+	}
+	intervalClear() {
+		this.solanaBlockchainEventEmitter.intervalClear();
+	}
+	async processEventsPage(e) {
+		let t = [], n = /* @__PURE__ */ new Set();
+		e.forEach(({ eventName: e, transactionHash: t }) => {
+			e === "BlockedUtxosCreated" && n.add(t);
+		});
+		let r = e.filter((e) => e.eventName === this.eventName).map(async (e) => {
+			try {
+				let t = await this.mapEvent(e), r = n.has(e.transactionHash);
+				return await this.acceptEvent(t, e.blockNumber, e.transactionHash, r) ? t : null;
+			} catch {
+				return null;
+			}
+		}), i = (await Promise.all(r)).filter((e) => e !== null);
+		t.push(...i);
+		let a = t.length;
+		return await this.afterEventsAccepted(a), t.length;
+	}
+};
+//#endregion
+export { e as AbstractSolanaEventService };

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

@@ -0,0 +1 @@
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../../functions/utils/amounts.utils.cjs`),t=require(`./AbstractSolanaSnapshotService.cjs`);let n=require(`ethers`);var r=class extends t.AbstractSolanaSnapshotService{constructor(e){super(e,`Nullified`)}_nullifiers;get nullifiers(){return this._nullifiers}serializeSnapshot(e){return{nullifiers:Array.from(e.payload.nullifiers).map(e=>e.toString()),latestBlockNumber:e.latestBlockNumber}}deserializeSnapshot(e){return{latestBlockNumber:e.latestBlockNumber??0,payload:{nullifiers:new Set(e.nullifiers??[])}}}acceptEvent(e,t){try{return this._nullifiers.has(e.nullifier)?!1:(this._nullifiers.add(e.nullifier),!0)}catch(e){return console.error(e),!1}}mapEvent(t){return{nullifier:n.ethers.toBeHex(e.advancedToBigInt(t.getArg(`nullifier`)))}}getSnapshotPayload(){return{nullifiers:this._nullifiers}}populateSnapshot({payload:{nullifiers:e}}){this._nullifiers=e}};exports.AbstractSolanaNullifierSnapshotService=r;

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

@@ -0,0 +1,22 @@
+import { NullifierEvent } from '../../../types/commitments.types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SolanaNullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type SolanaNullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractSolanaNullifierSnapshotService extends AbstractSolanaSnapshotService<NullifierEvent<string>, 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: BlockchainEvent): NullifierEvent<string>;
+    protected getSnapshotPayload(): SolanaNullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: SolanaSnapshot<SolanaNullifierSnapshotPayload>): void;
+}

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

@@ -0,0 +1,43 @@
+import { advancedToBigInt as e } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSolanaSnapshotService as t } from "./AbstractSolanaSnapshotService.mjs";
+import { ethers as n } from "ethers";
+//#region libs/shared/common/src/data-structures/event-service/solana/AbstractSolanaNullifierSnapshotService.ts
+var r = class extends t {
+	constructor(e) {
+		super(e, "Nullified");
+	}
+	_nullifiers;
+	get nullifiers() {
+		return this._nullifiers;
+	}
+	serializeSnapshot(e) {
+		return {
+			nullifiers: Array.from(e.payload.nullifiers).map((e) => e.toString()),
+			latestBlockNumber: e.latestBlockNumber
+		};
+	}
+	deserializeSnapshot(e) {
+		return {
+			latestBlockNumber: e.latestBlockNumber ?? 0,
+			payload: { nullifiers: new Set(e.nullifiers ?? []) }
+		};
+	}
+	acceptEvent(e, t) {
+		try {
+			return this._nullifiers.has(e.nullifier) ? !1 : (this._nullifiers.add(e.nullifier), !0);
+		} catch (e) {
+			return console.error(e), !1;
+		}
+	}
+	mapEvent(t) {
+		return { nullifier: n.toBeHex(e(t.getArg("nullifier"))) };
+	}
+	getSnapshotPayload() {
+		return { nullifiers: this._nullifiers };
+	}
+	populateSnapshot({ payload: { nullifiers: e } }) {
+		this._nullifiers = e;
+	}
+};
+//#endregion
+export { r as AbstractSolanaNullifierSnapshotService };

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

@@ -0,0 +1 @@
+const e=require(`../../../constants/save-depths.cjs`),t=require(`./AbstractSolanaEventService.cjs`);var n=class extends t.AbstractSolanaEventService{savedLatestSlot=0;constructor(e,t){super(e,t)}async init(){await this.loadSnapshot()}async retrieveEventsFromLatestBlock(){await this.solanaBlockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}async loadSnapshot(){let e=await this.fetchSnapshot(),t=this.deserializeSnapshot(e);this.populateSnapshot(t),this.solanaBlockchainEventEmitter.syncFromAtMost(t.latestBlockNumber),this.savedLatestSlot=t.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=n;

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

@@ -0,0 +1,21 @@
+import { AbstractSolanaEventService } from './AbstractSolanaEventService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+export interface SolanaSnapshot<SnapshotPayloadType> {
+    readonly latestBlockNumber: number;
+    readonly payload: SnapshotPayloadType;
+}
+export declare abstract class AbstractSolanaSnapshotService<EventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractSolanaEventService<EventType> {
+    private savedLatestSlot;
+    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,30 @@
+import { saveDepths as e } from "../../../constants/save-depths.mjs";
+import { AbstractSolanaEventService as t } from "./AbstractSolanaEventService.mjs";
+//#region libs/shared/common/src/data-structures/event-service/solana/AbstractSolanaSnapshotService.ts
+var n = class extends t {
+	savedLatestSlot = 0;
+	constructor(e, t) {
+		super(e, t);
+	}
+	async init() {
+		await this.loadSnapshot();
+	}
+	async retrieveEventsFromLatestBlock() {
+		await this.solanaBlockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
+	}
+	async loadSnapshot() {
+		let e = await this.fetchSnapshot(), t = this.deserializeSnapshot(e);
+		this.populateSnapshot(t), this.solanaBlockchainEventEmitter.syncFromAtMost(t.latestBlockNumber), this.savedLatestSlot = t.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();
+	}
+};
+//#endregion
+export { n as AbstractSolanaSnapshotService };

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

@@ -0,0 +1 @@
+const e=require(`../../../types/events.types.cjs`),t=require(`../helpers/ClientEventHelper.cjs`),n=require(`./SolanaBlockchainEventEmitter.cjs`);var r=class extends n.SolanaBlockchainEventEmitter{clientEventHelper;constructor(n,r,i,a,o,s,c){super(n,r,i,a,!1,o,s),c&&this.setIdl(c),this.clientEventHelper=new t.ClientEventHelper(n,e.EventCategory.MainContractEvents)}clear(){this.clientEventHelper.clear()}startUpdateListener(){this.clientEventHelper.startUpdateListener(async e=>{await this.eventsFetchingMutex.runExclusive(async()=>{await this.processEvents(e)})},this.latestBlockNumber+1,e=>this.advanceLatestBlockNumber(e))}};exports.ClientSolanaBlockchainEventEmitter=r;

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

@@ -0,0 +1,11 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { Idl } from '@coral-xyz/anchor';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { Mutex } from 'async-mutex';
+import { ClientEventHelper } from '../helpers/ClientEventHelper';
+export declare class ClientSolanaBlockchainEventEmitter extends SolanaBlockchainEventEmitter {
+    clientEventHelper: ClientEventHelper;
+    constructor(chainId: number, connection: Connection, programId: PublicKey, initialSlot: number, eventsFetchingMutex: Mutex, maxPageSize?: number, idl?: Idl);
+    protected clear(): void;
+    protected startUpdateListener(): void;
+}