@gurge/sdk 0.2.32

package/data-structures/crypto-keys/keys.mjs

@@ -0,0 +1,157 @@
+import { CIRCOM_P as e } from "../../constants/protocol.constants.mjs";
+import { poseidonHash as t } from "../../crypto/poseidon.mjs";
+import { babyJubInstance as n } from "../../crypto/babyJub.mjs";
+import { eddsaInstance as r } from "../../crypto/eddsa.mjs";
+import { AttachableMemoryCacheDevice as i } from "../cacheDevices/AttachableMemoryCacheDevice.mjs";
+import { getCircomSign as a } from "./keyUtils.mjs";
+import { ethers as o } from "ethers";
+import { Keypair as s, PublicKey as c } from "@solana/web3.js";
+import { Trx as l } from "tronweb";
+import u from "libsodium-wrappers";
+import d from "bs58";
+import f from "tweetnacl";
+//#region libs/shared/common/src/data-structures/crypto-keys/keys.ts
+var p = new i(), m = new i(), h = new i(), g = {
+	privateKey: "",
+	publicKey: ""
+}, _ = class {
+	signature;
+	nullifyingKey;
+	PREFIX_FOR_SPENDING_PAIR = "1";
+	PREFIX_FOR_NULLIFYING_PAIR = "2";
+	constructor(e, t) {
+		this.signature = e, this.nullifyingKey = t;
+	}
+	getSignature() {
+		return this.requireSignature(), this.signature;
+	}
+	setSignature(e) {
+		this.signature = e;
+	}
+	requireSignature() {
+		if (!this.signature) throw Error("No signature provided");
+	}
+	requireKeyMaterial() {
+		if (!this.signature && !this.nullifyingKey) throw Error("No signature or private key provided");
+	}
+	verifyTronMessage(e, t) {
+		return this.requireSignature(), t === l.verifyMessageV2(e, this.signature);
+	}
+	getShieldedPrivateKey = () => (this.requireKeyMaterial(), this.nullifyingKey ||= o.keccak256(this.signature), this.nullifyingKey);
+	getShieldedPublicKey = () => (this.requireKeyMaterial(), t(this.getShieldedPrivateKey()));
+	getSpendingKeyPair = () => {
+		this.requireSignature();
+		let e = r(), i = n(), a = t(this.PREFIX_FOR_SPENDING_PAIR, this.getSignature()), s = Buffer.from(o.getBytes(a)), c = e.prv2pub(s);
+		return {
+			privSpendingKey: a,
+			pubSpendingBJJPoint: [BigInt(i.F.toString(c[0])), BigInt(i.F.toString(c[1]))]
+		};
+	};
+	signEddsa = (e) => {
+		this.requireSignature();
+		let t = n(), i = r(), a = Buffer.from(o.getBytes(this.getSpendingKeyPair().privSpendingKey)), s = t.F.e(e), c = i.signPoseidon(a, s);
+		return {
+			R8: [BigInt(t.F.toString(c.R8[0])), BigInt(t.F.toString(c.R8[1]))],
+			S: BigInt(c.S)
+		};
+	};
+	getShieldedPrivateKeyFromNonce = (e) => {
+		this.requireKeyMaterial();
+		let n = t(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+		return o.keccak256(o.toUtf8Bytes(`hinkal-offchain-shielded-key:${n}`));
+	};
+	getClaimableSignatureFromNonce = (e) => {
+		this.requireKeyMaterial();
+		let n = t(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+		return o.keccak256(o.toUtf8Bytes(`hinkal-claimable-utxo-signature:${n}`));
+	};
+	getDerivedEthereumAddress = () => (this.requireKeyMaterial(), new o.Wallet(this.getShieldedPrivateKey()).address);
+	getDerivedSolanaPublicKey = () => (this.requireKeyMaterial(), s.fromSeed(o.getBytes(this.getShieldedPrivateKey())).publicKey.toBase58());
+	getSignerPrivateKeyFromNonce = (e) => {
+		this.requireKeyMaterial();
+		let n = t(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+		return o.keccak256(o.toUtf8Bytes(n));
+	};
+	getSignerSolanaPrivateKeyFromNonce = (e) => {
+		let t = this.getSignerPrivateKeyFromNonce(e), n = o.getBytes(t), r = s.fromSeed(n);
+		return d.encode(r.secretKey);
+	};
+	verifyMessage(e) {
+		return this.requireSignature(), o.verifyMessage(e, this.signature);
+	}
+	verifySolanaMessage(e, t) {
+		this.requireSignature();
+		let n = new TextEncoder().encode(e), r = o.getBytes(this.signature), i = new c(t).toBytes();
+		return f.sign.detached.verify(n, r, i);
+	}
+	static getRandomizedStealthPairOld = m.attach((t, r) => {
+		let i = n(), a = t * (BigInt(r) % e) % e, o = i.mulPointEscalar(i.Base8, t), s = i.mulPointEscalar(i.Base8, a);
+		return {
+			H0: [BigInt(i.F.toString(o[0])), BigInt(i.F.toString(o[1]))],
+			H1: [BigInt(i.F.toString(s[0])), BigInt(i.F.toString(s[1]))]
+		};
+	});
+	static getRandomizedStealthPair = p.attach((t, r) => {
+		let i = n(), a = BigInt(r) % e, o = i.mulPointEscalar(i.Base8, t), s = i.mulPointEscalar(o, a);
+		return {
+			H0: [BigInt(i.F.toString(o[0])), BigInt(i.F.toString(o[1]))],
+			H1: [BigInt(i.F.toString(s[0])), BigInt(i.F.toString(s[1]))]
+		};
+	});
+	static getStealthAddressCompressedPoints = (e, t) => {
+		let { H0: n, H1: r } = this.getRandomizedStealthPairOld(e, t), [i, o] = [n, r].map((e) => BigInt(e[1]) + 2n ** 255n * a(e[0]));
+		return {
+			h0: i,
+			h1: o
+		};
+	};
+	static checkSignature = (e, t, n, r) => {
+		let { h0: i, h1: a } = this.getStealthAddressCompressedPoints(e, r);
+		return t === i && n === a;
+	};
+	static getStealthAddress = h.attach((e, n) => {
+		let { H0: r, H1: i } = this.getRandomizedStealthPairOld(e, n);
+		return t(2n * a(r[0]) + a(i[0]), r[1], i[1]);
+	});
+	static getH1FromH0 = (t, r) => {
+		let i = n(), a = BigInt(r) % e, o = [i.F.e(t[0]), i.F.e(t[1])], s = i.mulPointEscalar(o, a);
+		return [BigInt(i.F.toString(s[0])), BigInt(i.F.toString(s[1]))];
+	};
+	static verifyStealthPair = (e, t, n, r = !0) => {
+		let i = this.getH1FromH0(e, n);
+		return r ? i[1] === t[1] : i === t;
+	};
+	static getStealthAddressNewStyle = (e, n, r) => {
+		if (r?.length !== 2) throw Error("Spending public key must be an array of 2 elements");
+		let i = this.getH1FromH0(e, n);
+		return t(2n * a(e[0]) + a(i[0]), e[1], i[1], r[0], r[1], n);
+	};
+	static findCorrectRandomization(t, n) {
+		if (!n) throw Error("No Private Shielded Key Provided");
+		let r = BigInt(n) % e, i, a, o = 0n;
+		do
+			i = t * 10n ** o % e, a = i * r % e, o += 1n;
+		while (a >= 2n ** 253n || i >= 2n ** 253n);
+		return i;
+	}
+	static getH0FromRandomization = (e) => {
+		let t = n(), r = t.mulPointEscalar(t.Base8, e);
+		return [BigInt(t.F.toString(r[0])), BigInt(t.F.toString(r[1]))];
+	};
+	static findH0(e, t) {
+		if (!t) return;
+		let { H0: n } = this.getRandomizedStealthPair(e, t);
+		return n;
+	}
+	static getEncryptionKeyPair = (e) => {
+		let t = u.crypto_box_seed_keypair(o.getBytes(e));
+		return {
+			privateKey: o.hexlify(t.privateKey),
+			publicKey: o.hexlify(t.publicKey)
+		};
+	};
+	getAccessKey = () => (this.requireKeyMaterial(), t(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
+	getBackendToken = () => (this.requireKeyMaterial(), t(this.getAccessKey(), this.getShieldedPublicKey()));
+};
+//#endregion
+export { g as EncryptionKeyPairDefaultValue, _ as UserKeys, h as stealthAddressCacheDevice, p as stealthPairCacheDevice, m as stealthPairOldCacheDevice };

package/data-structures/custom-token-registry/CustomTokenRegistry.cjs

@@ -0,0 +1 @@
+var e=new class{tokenRegistry;constructor(){this.tokenRegistry=[]}setTokensFromCache(e){this.tokenRegistry=e}getCustomTokens(e){return this.tokenRegistry.filter(t=>t.chainId===e)}tokenExists(e,t){return e.find(e=>e.erc20TokenAddress===t.erc20TokenAddress||e.symbol===t.symbol||e.name===t.name)}addCustomToken(e){let{chainId:t}=e,n=this.getCustomTokens(t);this.tokenExists(n,e)||this.tokenRegistry.push(e)}removeCustomToken(e){let{chainId:t}=e,n=this.getCustomTokens(t).filter(t=>t.erc20TokenAddress!==e.erc20TokenAddress);this.tokenRegistry=n}};exports.customTokenRegistry=e;

package/data-structures/custom-token-registry/CustomTokenRegistry.d.ts

@@ -0,0 +1,12 @@
+import { ERC20Token } from '../../types';
+declare class CustomTokenRegistry {
+    tokenRegistry: ERC20Token[];
+    constructor();
+    setTokensFromCache(newTokenRegistries: ERC20Token[]): void;
+    getCustomTokens(chainId: number): ERC20Token[];
+    tokenExists(registry: ERC20Token[], tokenToCheck: ERC20Token): ERC20Token | undefined;
+    addCustomToken(token: ERC20Token): void;
+    removeCustomToken(tokenToRemove: ERC20Token): void;
+}
+export declare const customTokenRegistry: CustomTokenRegistry;
+export {};

package/data-structures/custom-token-registry/CustomTokenRegistry.mjs

@@ -0,0 +1,25 @@
+var e = new class {
+	tokenRegistry;
+	constructor() {
+		this.tokenRegistry = [];
+	}
+	setTokensFromCache(e) {
+		this.tokenRegistry = e;
+	}
+	getCustomTokens(e) {
+		return this.tokenRegistry.filter((t) => t.chainId === e);
+	}
+	tokenExists(e, t) {
+		return e.find((e) => e.erc20TokenAddress === t.erc20TokenAddress || e.symbol === t.symbol || e.name === t.name);
+	}
+	addCustomToken(e) {
+		let { chainId: t } = e, n = this.getCustomTokens(t);
+		this.tokenExists(n, e) || this.tokenRegistry.push(e);
+	}
+	removeCustomToken(e) {
+		let { chainId: t } = e, n = this.getCustomTokens(t).filter((t) => t.erc20TokenAddress !== e.erc20TokenAddress);
+		this.tokenRegistry = n;
+	}
+}();
+//#endregion
+export { e as customTokenRegistry };

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

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/amounts.utils.cjs`),t=require(`../../../crypto/poseidon.cjs`);require(`../../../crypto/index.cjs`);const n=require(`../../merkle-tree/MerkleTree.cjs`);require(`../../merkle-tree/index.cjs`);const r=require(`./AbstractSnapshotService.cjs`),i=require(`../../../functions/utils/merkleTree.utils.cjs`);var a=class extends r.AbstractSnapshotService{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(r){let a;a=r.latestBlockNumber&&r.merkleTree?i.contructMerkleTreeFromSerialized(r.merkleTree):n.MerkleTree.create(t.poseidonFunction,0n);let o=r.encryptedOutputs?.map(e=>({value:e.value,isPositive:JSON.parse(e.isPositive),isBlocked:e.isBlocked??!1})),s=new Map;return r.encryptedOutputsByCommitment?.forEach(({commitment:t,encryptedOutput:n})=>{s.set(e.toBigInt(t),n)}),{latestBlockNumber:r.latestBlockNumber??0,payload:{merkleTree:a,encryptedOutputs:o||[],encryptedOutputsByCommitment:s}}}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}mapEvent(t){let n=t.getArg(`commitment`),r=t.getArg(`index`),i=t.getArg(`encryptedOutput`);return{commitment:e.toBigInt(n),index:e.toBigInt(r),encryptedOutput:i}}acceptEvent(e,t,n,r){let i=e.index>=0n?e.index:-1n*e.index,a=this._merkleTree.getValue(i);if(a===e.commitment)return!1;this._merkleTree.insert(e.commitment,i);let o=a===void 0?void 0:this._encryptedOutputsByCommitment.get(a);if(a!==void 0&&o!==void 0){let e=this.encryptedOutputs.findIndex(e=>e.value===o);e!==-1&&this.encryptedOutputs.splice(e,1),this._encryptedOutputsByCommitment.delete(a)}if(this._encryptedOutputsByCommitment.set(e.commitment,e.encryptedOutput),this.encryptedOutputs.map(e=>e.value).includes(e.encryptedOutput))return!0;let s={value:e.encryptedOutput,isPositive:e.index>=0n,isBlocked:r??!1};return this._encryptedOutputs.push(s),!0}};exports.AbstractCommitmentsSnapshotService=a;

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

@@ -0,0 +1,34 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type CommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+    readonly encryptedOutputsByCommitment: Map<bigint, string>;
+};
+export type CommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+    encryptedOutputsByCommitment?: EncryptedOutputWithCommitment[];
+};
+export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    private _encryptedOutputsByCommitment;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: CommitmentsSerializedSnapshot): Snapshot<CommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs, encryptedOutputsByCommitment }, }: Snapshot<CommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: BlockchainEvent): CommitmentEvent<bigint>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number, _txHash?: string, isBlocked?: boolean): boolean;
+}

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

@@ -0,0 +1,93 @@
+import { toBigInt as e } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as t } from "../../../crypto/poseidon.mjs";
+import "../../../crypto/index.mjs";
+import { MerkleTree as n } from "../../merkle-tree/MerkleTree.mjs";
+import "../../merkle-tree/index.mjs";
+import { AbstractSnapshotService as r } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as i } from "../../../functions/utils/merkleTree.utils.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.ts
+var a = class extends r {
+	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(r) {
+		let a;
+		a = r.latestBlockNumber && r.merkleTree ? i(r.merkleTree) : n.create(t, 0n);
+		let o = r.encryptedOutputs?.map((e) => ({
+			value: e.value,
+			isPositive: JSON.parse(e.isPositive),
+			isBlocked: e.isBlocked ?? !1
+		})), s = /* @__PURE__ */ new Map();
+		return r.encryptedOutputsByCommitment?.forEach(({ commitment: t, encryptedOutput: n }) => {
+			s.set(e(t), n);
+		}), {
+			latestBlockNumber: r.latestBlockNumber ?? 0,
+			payload: {
+				merkleTree: a,
+				encryptedOutputs: o || [],
+				encryptedOutputsByCommitment: s
+			}
+		};
+	}
+	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;
+	}
+	mapEvent(t) {
+		let n = t.getArg("commitment"), r = t.getArg("index"), i = t.getArg("encryptedOutput");
+		return {
+			commitment: e(n),
+			index: e(r),
+			encryptedOutput: i
+		};
+	}
+	acceptEvent(e, t, n, r) {
+		let i = e.index >= 0n ? e.index : -1n * e.index, a = this._merkleTree.getValue(i);
+		if (a === e.commitment) return !1;
+		this._merkleTree.insert(e.commitment, i);
+		let o = a === void 0 ? void 0 : this._encryptedOutputsByCommitment.get(a);
+		if (a !== void 0 && o !== void 0) {
+			let e = this.encryptedOutputs.findIndex((e) => e.value === o);
+			e !== -1 && this.encryptedOutputs.splice(e, 1), this._encryptedOutputsByCommitment.delete(a);
+		}
+		if (this._encryptedOutputsByCommitment.set(e.commitment, e.encryptedOutput), this.encryptedOutputs.map((e) => e.value).includes(e.encryptedOutput)) return !0;
+		let s = {
+			value: e.encryptedOutput,
+			isPositive: e.index >= 0n,
+			isBlocked: r ?? !1
+		};
+		return this._encryptedOutputs.push(s), !0;
+	}
+};
+//#endregion
+export { a as AbstractCommitmentsSnapshotService };

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

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/resolve-sync.utils.cjs`);var t=class{blockchainEventEmitter;eventName;constructor(e,t){this.blockchainEventEmitter=e,this.eventName=t,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.blockchainEventEmitter.latestBlockNumber}get chainId(){return this.blockchainEventEmitter.chainId}intervalClear(){this.blockchainEventEmitter.intervalClear()}async processEventsPage(t){let n=new Set;t.forEach(({eventName:e,transactionHash:t})=>{e===`BlockedUtxosCreated`&&n.add(t)});let r=[];await e.resolveSync(t.map(e=>async()=>{if(e.eventName!==this.eventName)return;let{blockNumber:t,transactionHash:i}=e,a=this.mapEvent(e),o=n.has(i);await this.acceptEvent(a,t,i,o)&&r.push(a)}));let i=r.length;return await this.afterEventsAccepted(i),r.length}};exports.AbstractEventService=t;

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

@@ -0,0 +1,14 @@
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export declare abstract class AbstractEventService<EventType> {
+    protected blockchainEventEmitter: BlockchainEventEmitter;
+    protected readonly eventName: string;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
+    get latestBlockNumber(): number;
+    get chainId(): number;
+    intervalClear(): void;
+    private processEventsPage;
+    protected abstract acceptEvent(event: EventType, blockNumber: number, txHash?: string, isBlocked?: boolean): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: BlockchainEvent): EventType;
+    protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+import { resolveSync as e } from "../../../functions/utils/resolve-sync.utils.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractEventService.ts
+var t = class {
+	blockchainEventEmitter;
+	eventName;
+	constructor(e, t) {
+		this.blockchainEventEmitter = e, this.eventName = t, e.addEventProcessorFunction(this.processEventsPage.bind(this));
+	}
+	get latestBlockNumber() {
+		return this.blockchainEventEmitter.latestBlockNumber;
+	}
+	get chainId() {
+		return this.blockchainEventEmitter.chainId;
+	}
+	intervalClear() {
+		this.blockchainEventEmitter.intervalClear();
+	}
+	async processEventsPage(t) {
+		let n = /* @__PURE__ */ new Set();
+		t.forEach(({ eventName: e, transactionHash: t }) => {
+			e === "BlockedUtxosCreated" && n.add(t);
+		});
+		let r = [];
+		await e(t.map((e) => async () => {
+			if (e.eventName !== this.eventName) return;
+			let { blockNumber: t, transactionHash: i } = e, a = this.mapEvent(e), o = n.has(i);
+			await this.acceptEvent(a, t, i, o) && r.push(a);
+		}));
+		let i = r.length;
+		return await this.afterEventsAccepted(i), r.length;
+	}
+};
+//#endregion
+export { t as AbstractEventService };

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

@@ -0,0 +1 @@
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`./AbstractSnapshotService.cjs`);let t=require(`ethers`);var n=class extends e.AbstractSnapshotService{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(e){let n=e.getArg(`nullifier`);return{nullifier:t.ethers.toBeHex(n)}}getSnapshotPayload(){return{nullifiers:this._nullifiers}}populateSnapshot({payload:{nullifiers:e}}){this._nullifiers=e}};exports.AbstractNullifierSnapshotService=n;

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

@@ -0,0 +1,22 @@
+import { NullifierEvent } from '../../../types/commitments.types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type NullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type NullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _nullifiers;
+    get nullifiers(): Set<string>;
+    protected serializeSnapshot(snapshot: Snapshot<NullifierSnapshotPayload>): NullifierSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: NullifierSerializedSnapshot): Snapshot<NullifierSnapshotPayload>;
+    protected acceptEvent(event: NullifierEvent<string>, _blockNumber: number): boolean;
+    protected mapEvent(event: BlockchainEvent): NullifierEvent<string>;
+    protected getSnapshotPayload(): NullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
+}

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

@@ -0,0 +1,43 @@
+import { AbstractSnapshotService as e } from "./AbstractSnapshotService.mjs";
+import { ethers as t } from "ethers";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractNullifierSnapshotService.ts
+var n = class extends e {
+	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(e) {
+		let n = e.getArg("nullifier");
+		return { nullifier: t.toBeHex(n) };
+	}
+	getSnapshotPayload() {
+		return { nullifiers: this._nullifiers };
+	}
+	populateSnapshot({ payload: { nullifiers: e } }) {
+		this._nullifiers = e;
+	}
+};
+//#endregion
+export { n as AbstractNullifierSnapshotService };

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

@@ -0,0 +1 @@
+const e=require(`../../../constants/save-depths.cjs`),t=require(`./AbstractEventService.cjs`);var n=class extends t.AbstractEventService{savedLatestBlockNumber=0;constructor(e,t){super(e,t)}async init(){await this.loadSnapshot()}async retrieveEventsFromLatestBlock(){await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}get isReady(){return this.blockchainEventEmitter.isReady}async loadSnapshot(){let e=await this.fetchSnapshot(),t=this.deserializeSnapshot(e);this.populateSnapshot(t),this.blockchainEventEmitter.syncFromAtMost(t.latestBlockNumber),this.savedLatestBlockNumber=t.latestBlockNumber}saveSnapshot(){return this.savedLatestBlockNumber=this.latestBlockNumber,this.persistSnapshot(this.serializeSnapshot({latestBlockNumber:this.latestBlockNumber,payload:this.getSnapshotPayload()}))}async afterEventsAccepted(t){(t>0||this.savedLatestBlockNumber+e.saveDepths[this.chainId]<this.latestBlockNumber)&&await this.saveSnapshot()}};exports.AbstractSnapshotService=n;

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

@@ -0,0 +1,22 @@
+import { AbstractEventService } from './AbstractEventService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export interface Snapshot<SnapshotPayloadType> {
+    readonly latestBlockNumber: number;
+    readonly payload: SnapshotPayloadType;
+}
+export declare abstract class AbstractSnapshotService<EventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType> {
+    private savedLatestBlockNumber;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
+    init(): Promise<void>;
+    retrieveEventsFromLatestBlock(): Promise<void>;
+    get isReady(): boolean;
+    private loadSnapshot;
+    protected saveSnapshot(): Promise<unknown>;
+    protected afterEventsAccepted(eventsCount: number): Promise<void>;
+    protected abstract getSnapshotPayload(): SnapshotPayloadType;
+    protected abstract populateSnapshot(snapshot: Snapshot<SnapshotPayloadType>): void;
+    protected abstract serializeSnapshot(snapshot: Snapshot<SnapshotPayloadType>): SerializedSnapshotType;
+    protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): Snapshot<SnapshotPayloadType>;
+    protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
+    protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
+}

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

@@ -0,0 +1,33 @@
+import { saveDepths as e } from "../../../constants/save-depths.mjs";
+import { AbstractEventService as t } from "./AbstractEventService.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractSnapshotService.ts
+var n = class extends t {
+	savedLatestBlockNumber = 0;
+	constructor(e, t) {
+		super(e, t);
+	}
+	async init() {
+		await this.loadSnapshot();
+	}
+	async retrieveEventsFromLatestBlock() {
+		await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
+	}
+	get isReady() {
+		return this.blockchainEventEmitter.isReady;
+	}
+	async loadSnapshot() {
+		let e = await this.fetchSnapshot(), t = this.deserializeSnapshot(e);
+		this.populateSnapshot(t), this.blockchainEventEmitter.syncFromAtMost(t.latestBlockNumber), this.savedLatestBlockNumber = t.latestBlockNumber;
+	}
+	saveSnapshot() {
+		return this.savedLatestBlockNumber = this.latestBlockNumber, this.persistSnapshot(this.serializeSnapshot({
+			latestBlockNumber: this.latestBlockNumber,
+			payload: this.getSnapshotPayload()
+		}));
+	}
+	async afterEventsAccepted(t) {
+		(t > 0 || this.savedLatestBlockNumber + e[this.chainId] < this.latestBlockNumber) && await this.saveSnapshot();
+	}
+};
+//#endregion
+export { n as AbstractSnapshotService };

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

@@ -0,0 +1 @@
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../../constants/reorg-depths.constants.cjs`),t=require(`../../../error-handling/logger.cjs`),n=require(`../../../functions/utils/resolve-sync.utils.cjs`),r=require(`../../../functions/utils/getSignerFromContract.cjs`),i=require(`../../BlockchainEvent/BlockchainEvent.cjs`);let a=require(`ethers`);var o=class{RETRY_MIN_PAGE_SIZE=100;MAX_RETRIES=20;_chainId;contract;depositOnChainUtxosContract;_latestBlockNumber;_initialBlockNumber;onEventsProcessed;eventProcessors=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=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 a.ethers.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 r=[],a=n.getSequence(e,t,this.maxPageSize);await n.resolveSync(a.map(({from:e,to:t})=>async()=>{let n=await this.getEventsForSingleContract(this.contract,e,t);r.push(...n)}));let o=this.depositOnChainUtxosContract;return o&&await n.resolveSync(a.map(({from:e,to:t})=>async()=>{let n=await this.getEventsForSingleContract(o,e,t);r.push(...n)})),r.map(e=>i.BlockchainEvent.fromEthers(e))}async getLastBlockNumberForEventRequest(){let t=await r.getProviderFromContract(this.contract).getBlockNumber();if(!this.isServer)return t;let{chainId:n}=await r.getProviderFromContract(this.contract).getNetwork();return Math.max(this.latestBlockNumber,t-e.blockReorgDepth[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.Logger.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)}};exports.BlockchainEventEmitter=o;

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

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers';
+import { Mutex } from 'async-mutex';
+import { EventProcessorFunction } from '../../../types/events.types';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export declare abstract class BlockchainEventEmitter {
+    private readonly RETRY_MIN_PAGE_SIZE;
+    private readonly MAX_RETRIES;
+    private readonly _chainId;
+    readonly contract: ethers.Contract;
+    readonly depositOnChainUtxosContract?: ethers.Contract;
+    private _latestBlockNumber;
+    private _initialBlockNumber;
+    onEventsProcessed?: (acceptedEventCount: number) => void;
+    private eventProcessors;
+    private readonly maxPageSize?;
+    private _isReady;
+    protected isServer: boolean;
+    private inProgress;
+    protected eventsFetchingMutex: Mutex;
+    constructor(chainId: number, contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, eventsFetchingMutex: Mutex, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract);
+    get latestBlockNumber(): number;
+    get chainId(): number;
+    get isReady(): boolean;
+    syncFromAtMost(blockNumber: number): void;
+    protected advanceLatestBlockNumber(blockNumber: number): void;
+    intervalClear(): void;
+    init(): Promise<void>;
+    private requireReady;
+    private getEventsForSingleContract;
+    addEventProcessorFunction(eventProcessorFunction: EventProcessorFunction): void;
+    getEventsInRange(fromBlockNumber: number, toBlockNumber: number): Promise<BlockchainEvent[]>;
+    getLastBlockNumberForEventRequest(): Promise<number>;
+    retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
+    protected processEvents(events: BlockchainEvent[], scannedToBlock?: number): Promise<void>;
+    protected abstract clear(): void;
+    protected abstract startUpdateListener(): void;
+}