@kapa123456789/sdk 0.0.39 → 0.0.40

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

@@ -0,0 +1,104 @@
+import { Logger as e } from "../../../error-handling/logger.mjs";
+import { getSequence as t, resolveSync as n } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { blockReorgDepth as r } from "../../../constants/reorg-depths.constants.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, r) {
+		let i = [], o = t(e, r, this.maxPageSize);
+		await n(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 n(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 e = await i(this.contract).getBlockNumber();
+		if (!this.isServer) return e;
+		let { chainId: t } = await i(this.contract).getNetwork();
+		return Math.max(this.latestBlockNumber, e - r[Number(t)] + 1);
+	}
+	async retrieveEvents(t, n = !1) {
+		return this.requireReady(), await this.eventsFetchingMutex.runExclusive(async () => {
+			try {
+				if (this.inProgress && !n) return !1;
+				this.inProgress = !0;
+				let e = await this.getLastBlockNumberForEventRequest();
+				if (e < t) return this.inProgress = !1, !1;
+				let r = await this.getEventsInRange(t, e);
+				return await this.processEvents(r), this._latestBlockNumber = e, this.inProgress = !1, !0;
+			} catch (t) {
+				return e.error("retrieveEvents error", t), this.inProgress = !1, !1;
+			}
+		});
+	}
+	async processEvents(e) {
+		let t = (await Promise.all([...this.eventProcessors].map((t) => t(e)))).reduce((e, t) => e + t, 0);
+		this.onEventsProcessed?.(t);
+	}
+};
+//#endregion
+export { s as BlockchainEventEmitter };

package/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/data-structures/event-service/index.d.ts

@@ -0,0 +1,16 @@
+export * from './evm/AbstractAccessTokenSnapshotService';
+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';
+export * from './solana/AbstractSolanaAccessTokenSnapshotService';

package/common/src/data-structures/event-service/solana/AbstractSolanaAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+require(`../../../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../../constants/protocol.constants.cjs`),t=require(`../../../functions/utils/amounts.utils.cjs`),n=require(`../../../crypto/poseidon.cjs`),r=require(`../../merkle-tree/MerkleTree.cjs`),i=require(`../../../functions/utils/merkleTree.utils.cjs`),a=require(`./AbstractSolanaSnapshotService.cjs`);let o=require(`@solana/web3.js`);var s=class extends a.AbstractSolanaSnapshotService{constructor(e){super(e,`NewAccessKeyAdded`)}_merkleTree;_senderAddresses;_senderAddressIndexMap;get merkleTree(){return this._merkleTree}get senderAddresses(){return this._senderAddresses}get senderAddressIndexMap(){return this._senderAddressIndexMap}serializeSnapshot(e){return{merkleTree:e.payload.merkleTree.toJSON(),senderAddresses:Array.from(e.payload.senderAddresses),latestBlockNumber:e.latestBlockNumber,senderAddressIndexMap:Array.from(e.payload.senderAddressIndexMap).map(([e,t])=>({address:e,index:t}))}}deserializeSnapshot(e){let t,a;return t=e.latestBlockNumber&&e.merkleTree?i.contructMerkleTreeFromSerialized(e.merkleTree):r.MerkleTree.create(n.poseidonFunction,0n),a=e.latestBlockNumber&&e.senderAddressIndexMap?new Map(e.senderAddressIndexMap.map(({address:e,index:t})=>[e,t])):new Map,{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:t,senderAddresses:e.senderAddresses??[],senderAddressIndexMap:a}}}acceptEvent(t,n){try{return this._merkleTree.insert(t.access_key,t.index),this._senderAddressIndexMap.set(t.sender_address,Math.max(Number(t.index),this._senderAddressIndexMap.get(t.sender_address)??0)),this._senderAddresses.includes(t.sender_address)||this._senderAddresses.push(t.sender_address),t.access_key===0n&&t.sender_address===e.zeroAddress&&this._merkleTree.remove(t.index),!0}catch(e){return console.error(e),!1}}mapEvent(e){let n=e.getArg(`access_key`),r=e.getArg(`index`),i=e.getArg(`sender_address`);return{access_key:t.advancedToBigInt(n),index:t.advancedToBigInt(r),sender_address:new o.PublicKey(i).toBase58()}}getSnapshotPayload(){return{merkleTree:this._merkleTree,senderAddresses:this._senderAddresses,senderAddressIndexMap:this._senderAddressIndexMap}}populateSnapshot({payload:{merkleTree:e,senderAddresses:t,senderAddressIndexMap:n}}){this._merkleTree=e,this._senderAddresses=t,this._senderAddressIndexMap=n}};exports.AbstractSolanaAccessTokenSnapshotService=s;

package/common/src/data-structures/event-service/solana/AbstractSolanaAccessTokenSnapshotService.d.ts

@@ -0,0 +1,35 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { SolanaAccessTokenEvent } from '../../../types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SolanaSenderAddressIndexMapJson = {
+    address: string;
+    index: number;
+}[];
+export type SolanaAccessTokenSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly senderAddresses: string[];
+    readonly senderAddressIndexMap: Map<string, number>;
+};
+export type SolanaAccessTokenSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    senderAddresses?: string[];
+    senderAddressIndexMap?: SolanaSenderAddressIndexMapJson;
+};
+export declare abstract class AbstractSolanaAccessTokenSnapshotService extends AbstractSolanaSnapshotService<SolanaAccessTokenEvent<bigint, string>, SolanaAccessTokenSnapshotPayload, SolanaAccessTokenSerializedSnapshot> {
+    constructor(accessTokenEventFetcher: SolanaBlockchainEventEmitter);
+    private _merkleTree;
+    private _senderAddresses;
+    private _senderAddressIndexMap;
+    get merkleTree(): MerkleTree<bigint>;
+    get senderAddresses(): string[];
+    get senderAddressIndexMap(): Map<string, number>;
+    protected serializeSnapshot(snapshot: SolanaSnapshot<SolanaAccessTokenSnapshotPayload>): SolanaAccessTokenSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: SolanaAccessTokenSerializedSnapshot): SolanaSnapshot<SolanaAccessTokenSnapshotPayload>;
+    protected acceptEvent(event: SolanaAccessTokenEvent<bigint, string>, _slot: number): boolean;
+    protected mapEvent(event: BlockchainEvent): SolanaAccessTokenEvent<bigint, string>;
+    protected getSnapshotPayload(): SolanaAccessTokenSnapshotPayload;
+    protected populateSnapshot({ payload: { merkleTree, senderAddresses, senderAddressIndexMap }, }: SolanaSnapshot<SolanaAccessTokenSnapshotPayload>): void;
+}

package/common/src/data-structures/event-service/solana/AbstractSolanaAccessTokenSnapshotService.mjs

@@ -0,0 +1,74 @@
+import { zeroAddress as e } from "../../../constants/protocol.constants.mjs";
+import { advancedToBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as n } from "../../../crypto/poseidon.mjs";
+import { MerkleTree as r } from "../../merkle-tree/MerkleTree.mjs";
+import { contructMerkleTreeFromSerialized as i } from "../../../functions/utils/merkleTree.utils.mjs";
+import { AbstractSolanaSnapshotService as a } from "./AbstractSolanaSnapshotService.mjs";
+import { PublicKey as o } from "@solana/web3.js";
+//#region libs/shared/common/src/data-structures/event-service/solana/AbstractSolanaAccessTokenSnapshotService.ts
+var s = class extends a {
+	constructor(e) {
+		super(e, "NewAccessKeyAdded");
+	}
+	_merkleTree;
+	_senderAddresses;
+	_senderAddressIndexMap;
+	get merkleTree() {
+		return this._merkleTree;
+	}
+	get senderAddresses() {
+		return this._senderAddresses;
+	}
+	get senderAddressIndexMap() {
+		return this._senderAddressIndexMap;
+	}
+	serializeSnapshot(e) {
+		return {
+			merkleTree: e.payload.merkleTree.toJSON(),
+			senderAddresses: Array.from(e.payload.senderAddresses),
+			latestBlockNumber: e.latestBlockNumber,
+			senderAddressIndexMap: Array.from(e.payload.senderAddressIndexMap).map(([e, t]) => ({
+				address: e,
+				index: t
+			}))
+		};
+	}
+	deserializeSnapshot(e) {
+		let t, a;
+		return t = e.latestBlockNumber && e.merkleTree ? i(e.merkleTree) : r.create(n, 0n), a = e.latestBlockNumber && e.senderAddressIndexMap ? new Map(e.senderAddressIndexMap.map(({ address: e, index: t }) => [e, t])) : /* @__PURE__ */ new Map(), {
+			latestBlockNumber: e.latestBlockNumber ?? 0,
+			payload: {
+				merkleTree: t,
+				senderAddresses: e.senderAddresses ?? [],
+				senderAddressIndexMap: a
+			}
+		};
+	}
+	acceptEvent(t, n) {
+		try {
+			return this._merkleTree.insert(t.access_key, t.index), this._senderAddressIndexMap.set(t.sender_address, Math.max(Number(t.index), this._senderAddressIndexMap.get(t.sender_address) ?? 0)), this._senderAddresses.includes(t.sender_address) || this._senderAddresses.push(t.sender_address), t.access_key === 0n && t.sender_address === e && this._merkleTree.remove(t.index), !0;
+		} catch (e) {
+			return console.error(e), !1;
+		}
+	}
+	mapEvent(e) {
+		let n = e.getArg("access_key"), r = e.getArg("index"), i = e.getArg("sender_address");
+		return {
+			access_key: t(n),
+			index: t(r),
+			sender_address: new o(i).toBase58()
+		};
+	}
+	getSnapshotPayload() {
+		return {
+			merkleTree: this._merkleTree,
+			senderAddresses: this._senderAddresses,
+			senderAddressIndexMap: this._senderAddressIndexMap
+		};
+	}
+	populateSnapshot({ payload: { merkleTree: e, senderAddresses: t, senderAddressIndexMap: n } }) {
+		this._merkleTree = e, this._senderAddresses = t, this._senderAddressIndexMap = n;
+	}
+};
+//#endregion
+export { s as AbstractSolanaAccessTokenSnapshotService };

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

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/amounts.utils.cjs`),t=require(`../../../crypto/poseidon.cjs`),n=require(`../../crypto-keys/decodeUTXO.cjs`),r=require(`../../merkle-tree/MerkleTree.cjs`),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/common/src/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/common/src/data-structures/event-service/solana/AbstractSolanaCommitmentsSnapshotService.mjs

@@ -0,0 +1,96 @@
+import { advancedToBigInt as e } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as t } from "../../../crypto/poseidon.mjs";
+import { encodeSolanaOnChainUtxo as n, isSolanaOnChainUtxo as r } from "../../crypto-keys/decodeUTXO.mjs";
+import { MerkleTree as i } from "../../merkle-tree/MerkleTree.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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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/common/src/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>;
+}