@hinkal/common 0.2.26 → 0.2.28

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

@@ -1,20 +1,24 @@
 import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
-import { CommitmentEvent, EncryptedOutputWithSign } from '../../../types';
+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>, CommitmentEvent, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+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;
@@ -22,8 +26,9 @@ export declare abstract class AbstractCommitmentsSnapshotService extends Abstrac
     protected getSnapshotPayload(): {
         merkleTree: MerkleTree<bigint>;
         encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
     };
-    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
-    protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
+    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

@@ -1,86 +1,103 @@
-import { poseidonFunction as m } from "../../../crypto/poseidon.mjs";
+import { poseidonFunction as d } from "../../../crypto/poseidon.mjs";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
 import "process";
 import "buffer";
-import { MerkleTree as c } from "../../merkle-tree/MerkleTree.mjs";
+import { MerkleTree as l } from "../../merkle-tree/MerkleTree.mjs";
 import "ethers";
 import "../../../error-handling/error-codes.constants.mjs";
-import { toBigInt as p } from "../../../functions/utils/amounts.utils.mjs";
-import { AbstractSnapshotService as o } from "./AbstractSnapshotService.mjs";
-import { contructMerkleTreeFromSerialized as n } from "../../../functions/utils/merkleTree.utils.mjs";
-class b extends o {
-  constructor(e) {
-    super(e, "NewCommitment");
+import { toBigInt as u } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSnapshotService as y } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as a } from "../../../functions/utils/merkleTree.utils.mjs";
+class v extends y {
+  constructor(t) {
+    super(t, "NewCommitment");
   }
   _merkleTree;
   _encryptedOutputs;
+  _encryptedOutputsByCommitment = /* @__PURE__ */ new Map();
   get merkleTree() {
     return this._merkleTree;
   }
   get encryptedOutputs() {
     return this._encryptedOutputs;
   }
-  serializeSnapshot(e) {
+  serializeSnapshot(t) {
     return {
-      merkleTree: e.payload.merkleTree.toJSON(),
-      latestBlockNumber: e.latestBlockNumber,
-      encryptedOutputs: e.payload.encryptedOutputs.map((t) => ({
-        value: t.value,
-        isPositive: String(t.isPositive),
-        isBlocked: t.isBlocked ?? !1
-      }))
+      merkleTree: t.payload.merkleTree.toJSON(),
+      latestBlockNumber: t.latestBlockNumber,
+      encryptedOutputs: t.payload.encryptedOutputs.map((e) => ({
+        value: e.value,
+        isPositive: String(e.isPositive),
+        isBlocked: e.isBlocked ?? !1
+      })),
+      encryptedOutputsByCommitment: Array.from(t.payload.encryptedOutputsByCommitment.entries()).map(
+        ([e, r]) => ({
+          commitment: e.toString(),
+          encryptedOutput: r
+        })
+      )
     };
   }
-  deserializeSnapshot(e) {
-    let t;
-    e.latestBlockNumber && e.merkleTree ? t = n(e.merkleTree) : t = c.create(m, 0n);
-    const s = e.encryptedOutputs?.map((r) => ({
-      value: r.value,
-      isPositive: JSON.parse(r.isPositive),
-      isBlocked: r.isBlocked ?? !1
-    }));
-    return {
-      latestBlockNumber: e.latestBlockNumber ?? 0,
+  deserializeSnapshot(t) {
+    let e;
+    t.latestBlockNumber && t.merkleTree ? e = a(t.merkleTree) : e = l.create(d, 0n);
+    const r = t.encryptedOutputs?.map((m) => ({
+      value: m.value,
+      isPositive: JSON.parse(m.isPositive),
+      isBlocked: m.isBlocked ?? !1
+    })), n = /* @__PURE__ */ new Map();
+    return t.encryptedOutputsByCommitment?.forEach(({ commitment: m, encryptedOutput: i }) => {
+      n.set(u(m), i);
+    }), {
+      latestBlockNumber: t.latestBlockNumber ?? 0,
       payload: {
-        merkleTree: t,
-        encryptedOutputs: s || []
+        merkleTree: e,
+        encryptedOutputs: r || [],
+        encryptedOutputsByCommitment: n
       }
     };
   }
   getSnapshotPayload() {
     return {
       merkleTree: this._merkleTree,
-      encryptedOutputs: this._encryptedOutputs
+      encryptedOutputs: this._encryptedOutputs,
+      encryptedOutputsByCommitment: this._encryptedOutputsByCommitment
     };
   }
   populateSnapshot({
-    payload: { merkleTree: e, encryptedOutputs: t }
+    payload: { merkleTree: t, encryptedOutputs: e, encryptedOutputsByCommitment: r }
   }) {
-    this._merkleTree = e, this._encryptedOutputs = t;
+    this._merkleTree = t, this._encryptedOutputs = e, this._encryptedOutputsByCommitment = r;
   }
-  mapEvent(e) {
-    const { commitment: t, index: s, encryptedOutput: r } = e;
+  mapEvent(t) {
+    const e = t.getArg("commitment"), r = t.getArg("index"), n = t.getArg("encryptedOutput");
     return {
-      commitment: p(t),
-      index: p(s),
-      encryptedOutput: r
+      commitment: u(e),
+      index: u(r),
+      encryptedOutput: n
     };
   }
-  acceptEvent(e, t, s, r) {
-    if (!this.encryptedOutputs.map((i) => i.value).includes(e.encryptedOutput)) {
-      if (!this._merkleTree.insert(e.commitment, e.index >= 0 ? e.index : -1n * e.index))
-        return !1;
-      const u = {
-        value: e.encryptedOutput,
-        isPositive: e.index >= 0n,
-        isBlocked: r ?? !1
-      };
-      return this._encryptedOutputs.push(u), !0;
+  acceptEvent(t, e, r, n) {
+    const m = t.index >= 0n ? t.index : -1n * t.index, i = this._merkleTree.getValue(m);
+    if (i === t.commitment)
+      return !1;
+    this._merkleTree.insert(t.commitment, m);
+    const s = i !== void 0 ? this._encryptedOutputsByCommitment.get(i) : void 0;
+    if (i !== void 0 && s !== void 0) {
+      const p = this.encryptedOutputs.findIndex((c) => c.value === s);
+      p !== -1 && this.encryptedOutputs.splice(p, 1), this._encryptedOutputsByCommitment.delete(i);
     }
-    return !1;
+    if (this._encryptedOutputsByCommitment.set(t.commitment, t.encryptedOutput), this.encryptedOutputs.map((p) => p.value).includes(t.encryptedOutput))
+      return !0;
+    const o = {
+      value: t.encryptedOutput,
+      isPositive: t.index >= 0n,
+      isBlocked: n ?? !1
+    };
+    return this._encryptedOutputs.push(o), !0;
   }
 }
 export {
-  b as AbstractCommitmentsSnapshotService
+  v as AbstractCommitmentsSnapshotService
 };

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("../../../functions/utils/resolve-sync.utils.cjs");class h{blockchainEventEmitter;eventName;constructor(e,s){this.blockchainEventEmitter=e,this.eventName=s,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.blockchainEventEmitter.latestBlockNumber}intervalClear(){this.blockchainEventEmitter.intervalClear()}async processEventsPage(e){const s=new Set;e.forEach(t=>{t.eventName==="BlockedUtxosCreated"&&s.add(t.transactionHash)});const n=[];await v.resolveSync(e.map(t=>async()=>{if(t.eventName!==this.eventName)return;const{args:c,blockNumber:i,transactionHash:a}=t;if(!c)throw new Error("Wrong event structure");const r=this.mapEvent(c),l=s.has(a);await this.acceptEvent(r,i,a,l)&&n.push(r)}));const o=n.length;return await this.afterEventsAccepted(o),n.length}}exports.AbstractEventService=h;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../../../functions/utils/resolve-sync.utils.cjs");class h{blockchainEventEmitter;eventName;constructor(t,s){this.blockchainEventEmitter=t,this.eventName=s,t.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.blockchainEventEmitter.latestBlockNumber}get chainId(){return this.blockchainEventEmitter.chainId}intervalClear(){this.blockchainEventEmitter.intervalClear()}async processEventsPage(t){const s=new Set;t.forEach(({eventName:e,transactionHash:c})=>{e==="BlockedUtxosCreated"&&s.add(c)});const n=[];await l.resolveSync(t.map(e=>async()=>{if(e.eventName!==this.eventName)return;const{blockNumber:c,transactionHash:a}=e,r=this.mapEvent(e),o=s.has(a);await this.acceptEvent(r,c,a,o)&&n.push(r)}));const i=n.length;return await this.afterEventsAccepted(i),n.length}}exports.AbstractEventService=h;

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

@@ -1,12 +1,14 @@
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
 import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-export declare abstract class AbstractEventService<EventType, SerializedEventType = unknown> {
+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: SerializedEventType): EventType;
+    protected abstract mapEvent(event: BlockchainEvent): EventType;
     protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
-import { resolveSync as v } from "../../../functions/utils/resolve-sync.utils.mjs";
-class u {
+import { resolveSync as h } from "../../../functions/utils/resolve-sync.utils.mjs";
+class m {
   blockchainEventEmitter;
   eventName;
   constructor(t, s) {
@@ -8,30 +8,30 @@ class u {
   get latestBlockNumber() {
     return this.blockchainEventEmitter.latestBlockNumber;
   }
+  get chainId() {
+    return this.blockchainEventEmitter.chainId;
+  }
   intervalClear() {
     this.blockchainEventEmitter.intervalClear();
   }
   async processEventsPage(t) {
     const s = /* @__PURE__ */ new Set();
-    t.forEach((e) => {
-      e.eventName === "BlockedUtxosCreated" && s.add(e.transactionHash);
+    t.forEach(({ eventName: e, transactionHash: c }) => {
+      e === "BlockedUtxosCreated" && s.add(c);
     });
     const n = [];
-    await v(
+    await h(
       t.map((e) => async () => {
         if (e.eventName !== this.eventName)
           return;
-        const { args: a, blockNumber: i, transactionHash: c } = e;
-        if (!a)
-          throw new Error("Wrong event structure");
-        const r = this.mapEvent(a), h = s.has(c);
-        await this.acceptEvent(r, i, c, h) && n.push(r);
+        const { blockNumber: c, transactionHash: a } = e, i = this.mapEvent(e), o = s.has(a);
+        await this.acceptEvent(i, c, a, o) && n.push(i);
       })
     );
-    const o = n.length;
-    return await this.afterEventsAccepted(o), n.length;
+    const r = n.length;
+    return await this.afterEventsAccepted(r), n.length;
   }
 }
 export {
-  u as AbstractEventService
+  m as AbstractEventService
 };

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

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

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

@@ -1,6 +1,7 @@
 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>;
 };
@@ -8,14 +9,14 @@ export type NullifierSerializedSnapshot = {
     latestBlockNumber?: number;
     nullifiers?: string[];
 };
-export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierEvent<bigint>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
+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: NullifierEvent<bigint>): NullifierEvent<string>;
+    protected mapEvent(event: BlockchainEvent): NullifierEvent<string>;
     protected getSnapshotPayload(): NullifierSnapshotPayload;
     protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
 }

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

@@ -1,6 +1,6 @@
-import { ethers as i } from "ethers";
-import { AbstractSnapshotService as t } from "./AbstractSnapshotService.mjs";
-class a extends t {
+import { AbstractSnapshotService as i } from "./AbstractSnapshotService.mjs";
+import { ethers as t } from "ethers";
+class a extends i {
   constructor(r) {
     super(r, "Nullified");
   }
@@ -30,9 +30,9 @@ class a extends t {
     }
   }
   mapEvent(r) {
-    const { nullifier: e } = r;
+    const e = r.getArg("nullifier");
     return {
-      nullifier: i.toBeHex(e)
+      nullifier: t.toBeHex(e)
     };
   }
   getSnapshotPayload() {

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../../constants/save-depths.cjs"),a=require("./AbstractEventService.cjs"),r=require("../../../functions/utils/getSignerFromContract.cjs");class i extends a.AbstractEventService{savedLatestBlockNumber=0;chainId=0;constructor(t,e){super(t,e)}async init(){await this.loadSnapshot();const t=r.getProviderFromContract(this.blockchainEventEmitter.contract);this.chainId=Number((await t.getNetwork()).chainId)}async retrieveEventsFromLatestBlock(){await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}async loadSnapshot(){const t=await this.fetchSnapshot(),e=this.deserializeSnapshot(t);this.populateSnapshot(e),this.blockchainEventEmitter.syncFromAtMost(e.latestBlockNumber),this.savedLatestBlockNumber=e.latestBlockNumber}saveSnapshot(){return this.savedLatestBlockNumber=this.latestBlockNumber,this.persistSnapshot(this.serializeSnapshot({latestBlockNumber:this.latestBlockNumber,payload:this.getSnapshotPayload()}))}async afterEventsAccepted(t){(t>0||this.savedLatestBlockNumber+s.saveDepths[this.chainId]<this.latestBlockNumber)&&await this.saveSnapshot()}}exports.AbstractSnapshotService=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../../constants/save-depths.cjs"),a=require("./AbstractEventService.cjs");class i extends a.AbstractEventService{savedLatestBlockNumber=0;constructor(t,e){super(t,e)}async init(){await this.loadSnapshot()}async retrieveEventsFromLatestBlock(){await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}get isReady(){return this.blockchainEventEmitter.isReady}async loadSnapshot(){const t=await this.fetchSnapshot(),e=this.deserializeSnapshot(t);this.populateSnapshot(e),this.blockchainEventEmitter.syncFromAtMost(e.latestBlockNumber),this.savedLatestBlockNumber=e.latestBlockNumber}saveSnapshot(){return this.savedLatestBlockNumber=this.latestBlockNumber,this.persistSnapshot(this.serializeSnapshot({latestBlockNumber:this.latestBlockNumber,payload:this.getSnapshotPayload()}))}async afterEventsAccepted(t){(t>0||this.savedLatestBlockNumber+s.saveDepths[this.chainId]<this.latestBlockNumber)&&await this.saveSnapshot()}}exports.AbstractSnapshotService=i;

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

@@ -4,12 +4,12 @@ export interface Snapshot<SnapshotPayloadType> {
     readonly latestBlockNumber: number;
     readonly payload: SnapshotPayloadType;
 }
-export declare abstract class AbstractSnapshotService<EventType, SerializedEventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType, SerializedEventType> {
+export declare abstract class AbstractSnapshotService<EventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType> {
     private savedLatestBlockNumber;
-    private chainId;
     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>;

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

@@ -1,20 +1,19 @@
 import { saveDepths as e } from "../../../constants/save-depths.mjs";
 import { AbstractEventService as a } from "./AbstractEventService.mjs";
-import { getProviderFromContract as o } from "../../../functions/utils/getSignerFromContract.mjs";
-class n extends a {
+class h extends a {
   savedLatestBlockNumber = 0;
-  chainId = 0;
   constructor(t, s) {
     super(t, s);
   }
   async init() {
     await this.loadSnapshot();
-    const t = o(this.blockchainEventEmitter.contract);
-    this.chainId = Number((await t.getNetwork()).chainId);
   }
   async retrieveEventsFromLatestBlock() {
     await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
   }
+  get isReady() {
+    return this.blockchainEventEmitter.isReady;
+  }
   async loadSnapshot() {
     const t = await this.fetchSnapshot(), s = this.deserializeSnapshot(t);
     this.populateSnapshot(s), this.blockchainEventEmitter.syncFromAtMost(s.latestBlockNumber), this.savedLatestBlockNumber = s.latestBlockNumber;
@@ -32,5 +31,5 @@ class n extends a {
   }
 }
 export {
-  n as AbstractSnapshotService
+  h as AbstractSnapshotService
 };

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("ethers"),y=require("../../../constants/reorg-depths.constants.cjs"),h=require("../../../functions/utils/resolve-sync.utils.cjs"),f=require("../../../functions/utils/mutexes.utils.cjs"),d=require("../../../functions/utils/getSignerFromContract.cjs");class E{contract;depositOnChainUtxosContract;_latestBlockNumber;_initialBlockNumber;onEventsProcessed;eventProcessors=new Set;maxPageSize;isReady=!1;isServer;intervalId;inProgress;eventsFetchingMutex;constructor(e,r,u,s,i,a=f.balanceFetchingMutex){this.contract=e,this.depositOnChainUtxosContract=i,this._initialBlockNumber=r,this.maxPageSize=s,this.isServer=u,this.inProgress=!1,this.eventsFetchingMutex=a}get latestBlockNumber(){return this._latestBlockNumber??this._initialBlockNumber}syncFromAtMost(e){(this._latestBlockNumber===void 0||e<this._latestBlockNumber)&&(this._latestBlockNumber=e)}intervalClear(){this.isReady=!1,this.eventProcessors=new Set,clearInterval(this.intervalId)}async init(){if(this.isReady)throw new Error("Already initialized");this.isReady=!0,await this.retrieveEvents(this.latestBlockNumber+1),this.intervalId=setInterval(async()=>{await this.retrieveEvents(this.latestBlockNumber)},3500)}requireReady(){if(!this.isReady)throw new Error("Not ready")}addEventProcessorFunction(e){if(this.isReady)throw new Error("Can't add event processor after event emitter initialized");this.eventProcessors.add(e)}async getLastBlockNumberForEventRequest(){const e=await d.getProviderFromContract(this.contract).getBlockNumber();if(!this.isServer)return e;const{chainId:r}=await d.getProviderFromContract(this.contract).getNetwork();return Math.max(this.latestBlockNumber,e-y.blockReorgDepth[Number(r)]+1)}async retrieveEvents(e,r=!1){return this.requireReady(),await this.eventsFetchingMutex.runExclusive(async()=>{try{if(this.inProgress&&!r)return!1;this.inProgress=!0;let s=0;const i=await this.getLastBlockNumberForEventRequest();if(i<e)return this.inProgress=!1,!1;const a=h.getSequence(e,i,this.maxPageSize),o=[];if(await h.resolveSync(a.map(({from:t,to:n})=>async()=>{const c=(await this.contract.queryFilter("*",t,n)).filter(l=>l instanceof v.ethers.EventLog);o.push(...c)})),this.depositOnChainUtxosContract){const{depositOnChainUtxosContract:t}=this;await h.resolveSync(a.map(({from:n,to:c})=>async()=>{const l=(await t.queryFilter("*",n,c)).filter(g=>g instanceof v.ethers.EventLog);o.push(...l)}))}const m=await Promise.all([...this.eventProcessors].map(t=>t(o)));return this._latestBlockNumber=i,s+=m.reduce((t,n)=>t+n,0),this.onEventsProcessed?.(s),this.inProgress=!1,!0}catch(s){return console.log("retrieveEvents error:",{err:s}),this.inProgress=!1,!1}})}}exports.BlockchainEventEmitter=E;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("ethers"),u=require("../../../constants/reorg-depths.constants.cjs"),v=require("../../../error-handling/logger.cjs"),c=require("../../../functions/utils/resolve-sync.utils.cjs"),g=require("../../BlockchainEvent/BlockchainEvent.cjs"),h=require("../../../functions/utils/getSignerFromContract.cjs");class d{RETRY_MIN_PAGE_SIZE=100;MAX_RETRIES=20;_chainId;contract;depositOnChainUtxosContract;_latestBlockNumber;_initialBlockNumber;onEventsProcessed;eventProcessors=new Set;maxPageSize;_isReady=!1;isServer;inProgress;eventsFetchingMutex;constructor(t,s,r,e,i,n,a){this.contract=s,this.depositOnChainUtxosContract=a,this._chainId=t,this._initialBlockNumber=r,this.maxPageSize=n,this.isServer=e,this.inProgress=!1,this.eventsFetchingMutex=i}get latestBlockNumber(){return this._latestBlockNumber??this._initialBlockNumber}get chainId(){return this._chainId}get isReady(){return this._isReady}syncFromAtMost(t){(this._latestBlockNumber===void 0||t<this._latestBlockNumber)&&(this._latestBlockNumber=t)}advanceLatestBlockNumber(t){const s=this._latestBlockNumber??this._initialBlockNumber;t>s&&(this._latestBlockNumber=t)}intervalClear(){this._isReady=!1,this.eventProcessors=new Set,this.clear()}async init(){if(this._isReady)throw new Error("Already initialized");this._isReady=!0,await this.retrieveEvents(this.latestBlockNumber+1),this.startUpdateListener()}requireReady(){if(!this._isReady)throw new Error("Not ready")}async getEventsForSingleContract(t,s,r,e=0){try{return(await t.queryFilter("*",s,r)).filter(i=>i instanceof l.ethers.EventLog)}catch(i){if(e<this.MAX_RETRIES&&r-s>this.RETRY_MIN_PAGE_SIZE){const n=Math.floor((s+r)/2),a=await this.getEventsForSingleContract(t,s,n,e+1),o=await this.getEventsForSingleContract(t,n+1,r,e+1);return[...a,...o]}throw i}}addEventProcessorFunction(t){if(this._isReady)throw new Error("Can't add event processor after event emitter initialized");this.eventProcessors.add(t)}async getEventsInRange(t,s){const r=[],e=c.getSequence(t,s,this.maxPageSize);await c.resolveSync(e.map(({from:n,to:a})=>async()=>{const o=await this.getEventsForSingleContract(this.contract,n,a);r.push(...o)}));const i=this.depositOnChainUtxosContract;return i&&await c.resolveSync(e.map(({from:n,to:a})=>async()=>{const o=await this.getEventsForSingleContract(i,n,a);r.push(...o)})),r.map(n=>g.BlockchainEvent.fromEthers(n))}async getLastBlockNumberForEventRequest(){const t=await h.getProviderFromContract(this.contract).getBlockNumber();if(!this.isServer)return t;const{chainId:s}=await h.getProviderFromContract(this.contract).getNetwork();return Math.max(this.latestBlockNumber,t-u.blockReorgDepth[Number(s)]+1)}async retrieveEvents(t,s=!1){return this.requireReady(),await this.eventsFetchingMutex.runExclusive(async()=>{try{if(this.inProgress&&!s)return!1;this.inProgress=!0;const e=await this.getLastBlockNumberForEventRequest();if(e<t)return this.inProgress=!1,!1;const i=await this.getEventsInRange(t,e);return await this.processEvents(i),this._latestBlockNumber=e,this.inProgress=!1,!0}catch(e){return v.Logger.error("retrieveEvents error",e),this.inProgress=!1,!1}})}async processEvents(t){const r=(await Promise.all([...this.eventProcessors].map(e=>e(t)))).reduce((e,i)=>e+i,0);this.onEventsProcessed?.(r)}}exports.BlockchainEventEmitter=d;

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

@@ -1,7 +1,11 @@
 import { ethers } from 'ethers';
 import { Mutex } from 'async-mutex';
-export type EventProcessorFunction = (events: ethers.EventLog[]) => Promise<number> | number;
-export declare class BlockchainEventEmitter {
+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;
@@ -9,18 +13,25 @@ export declare class BlockchainEventEmitter {
     onEventsProcessed?: (acceptedEventCount: number) => void;
     private eventProcessors;
     private readonly maxPageSize?;
-    private isReady;
+    private _isReady;
     private isServer;
-    private intervalId?;
     private inProgress;
-    private eventsFetchingMutex;
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract, eventsFetchingMutex?: Mutex);
+    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;
-    private getLastBlockNumberForEventRequest;
+    getEventsInRange(fromBlockNumber: number, toBlockNumber: number): Promise<BlockchainEvent[]>;
+    getLastBlockNumberForEventRequest(): Promise<number>;
     retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
+    protected processEvents(events: BlockchainEvent[]): Promise<void>;
+    protected abstract clear(): void;
+    protected abstract startUpdateListener(): void;
 }

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

@@ -1,9 +1,13 @@
-import { ethers as u } from "ethers";
-import { blockReorgDepth as g } from "../../../constants/reorg-depths.constants.mjs";
-import { getSequence as y, resolveSync as v } from "../../../functions/utils/resolve-sync.utils.mjs";
-import { balanceFetchingMutex as E } from "../../../functions/utils/mutexes.utils.mjs";
-import { getProviderFromContract as m } from "../../../functions/utils/getSignerFromContract.mjs";
-class b {
+import { ethers as l } from "ethers";
+import { blockReorgDepth as u } from "../../../constants/reorg-depths.constants.mjs";
+import { Logger as v } from "../../../error-handling/logger.mjs";
+import { getSequence as d, resolveSync as c } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { BlockchainEvent as m } from "../../BlockchainEvent/BlockchainEvent.mjs";
+import { getProviderFromContract as h } from "../../../functions/utils/getSignerFromContract.mjs";
+class k {
+  RETRY_MIN_PAGE_SIZE = 100;
+  MAX_RETRIES = 20;
+  _chainId;
   contract;
   depositOnChainUtxosContract;
   _latestBlockNumber;
@@ -11,84 +15,106 @@ class b {
   onEventsProcessed;
   eventProcessors = /* @__PURE__ */ new Set();
   maxPageSize;
-  isReady = !1;
+  _isReady = !1;
   isServer;
-  intervalId;
   inProgress;
   // to remove race conditions
   eventsFetchingMutex;
-  constructor(t, r, h, s, i, n = E) {
-    this.contract = t, this.depositOnChainUtxosContract = i, this._initialBlockNumber = r, this.maxPageSize = s, this.isServer = h, this.inProgress = !1, this.eventsFetchingMutex = n;
+  constructor(t, s, r, e, i, n, a) {
+    this.contract = s, this.depositOnChainUtxosContract = a, this._chainId = t, this._initialBlockNumber = r, this.maxPageSize = n, this.isServer = e, this.inProgress = !1, this.eventsFetchingMutex = i;
   }
   get latestBlockNumber() {
     return this._latestBlockNumber ?? this._initialBlockNumber;
   }
+  get chainId() {
+    return this._chainId;
+  }
+  get isReady() {
+    return this._isReady;
+  }
   syncFromAtMost(t) {
     (this._latestBlockNumber === void 0 || t < this._latestBlockNumber) && (this._latestBlockNumber = t);
   }
+  advanceLatestBlockNumber(t) {
+    const s = this._latestBlockNumber ?? this._initialBlockNumber;
+    t > s && (this._latestBlockNumber = t);
+  }
   intervalClear() {
-    this.isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), clearInterval(this.intervalId);
+    this._isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), this.clear();
   }
   async init() {
-    if (this.isReady)
+    if (this._isReady)
       throw new Error("Already initialized");
-    this.isReady = !0, await this.retrieveEvents(this.latestBlockNumber + 1), this.intervalId = setInterval(async () => {
-      await this.retrieveEvents(this.latestBlockNumber);
-    }, 3500);
+    this._isReady = !0, await this.retrieveEvents(this.latestBlockNumber + 1), this.startUpdateListener();
   }
   requireReady() {
-    if (!this.isReady)
+    if (!this._isReady)
       throw new Error("Not ready");
   }
+  async getEventsForSingleContract(t, s, r, e = 0) {
+    try {
+      return (await t.queryFilter("*", s, r)).filter(
+        (i) => i instanceof l.EventLog
+      );
+    } catch (i) {
+      if (e < this.MAX_RETRIES && r - s > this.RETRY_MIN_PAGE_SIZE) {
+        const n = Math.floor((s + r) / 2), a = await this.getEventsForSingleContract(t, s, n, e + 1), o = await this.getEventsForSingleContract(t, n + 1, r, e + 1);
+        return [...a, ...o];
+      }
+      throw i;
+    }
+  }
   addEventProcessorFunction(t) {
-    if (this.isReady)
+    if (this._isReady)
       throw new Error("Can't add event processor after event emitter initialized");
     this.eventProcessors.add(t);
   }
+  async getEventsInRange(t, s) {
+    const r = [], e = d(t, s, this.maxPageSize);
+    await c(
+      e.map(({ from: n, to: a }) => async () => {
+        const o = await this.getEventsForSingleContract(this.contract, n, a);
+        r.push(...o);
+      })
+    );
+    const i = this.depositOnChainUtxosContract;
+    return i && await c(
+      e.map(({ from: n, to: a }) => async () => {
+        const o = await this.getEventsForSingleContract(i, n, a);
+        r.push(...o);
+      })
+    ), r.map((n) => m.fromEthers(n));
+  }
   async getLastBlockNumberForEventRequest() {
-    const t = await m(this.contract).getBlockNumber();
+    const t = await h(this.contract).getBlockNumber();
     if (!this.isServer)
       return t;
-    const { chainId: r } = await m(this.contract).getNetwork();
-    return Math.max(this.latestBlockNumber, t - g[Number(r)] + 1);
+    const { chainId: s } = await h(this.contract).getNetwork();
+    return Math.max(this.latestBlockNumber, t - u[Number(s)] + 1);
   }
-  async retrieveEvents(t, r = !1) {
+  async retrieveEvents(t, s = !1) {
     return this.requireReady(), await this.eventsFetchingMutex.runExclusive(async () => {
       try {
-        if (this.inProgress && !r)
+        if (this.inProgress && !s)
           return !1;
         this.inProgress = !0;
-        let s = 0;
-        const i = await this.getLastBlockNumberForEventRequest();
-        if (i < t)
+        const e = await this.getLastBlockNumberForEventRequest();
+        if (e < t)
           return this.inProgress = !1, !1;
-        const n = y(t, i, this.maxPageSize), o = [];
-        if (await v(
-          n.map(({ from: e, to: a }) => async () => {
-            const c = (await this.contract.queryFilter("*", e, a)).filter(
-              (l) => l instanceof u.EventLog
-            );
-            o.push(...c);
-          })
-        ), this.depositOnChainUtxosContract) {
-          const { depositOnChainUtxosContract: e } = this;
-          await v(
-            n.map(({ from: a, to: c }) => async () => {
-              const l = (await e.queryFilter("*", a, c)).filter((f) => f instanceof u.EventLog);
-              o.push(...l);
-            })
-          );
-        }
-        const d = await Promise.all(
-          [...this.eventProcessors].map((e) => e(o))
-        );
-        return this._latestBlockNumber = i, s += d.reduce((e, a) => e + a, 0), this.onEventsProcessed?.(s), this.inProgress = !1, !0;
-      } catch (s) {
-        return console.log("retrieveEvents error:", { err: s }), this.inProgress = !1, !1;
+        const i = await this.getEventsInRange(t, e);
+        return await this.processEvents(i), this._latestBlockNumber = e, this.inProgress = !1, !0;
+      } catch (e) {
+        return v.error("retrieveEvents error", e), this.inProgress = !1, !1;
       }
     });
   }
+  async processEvents(t) {
+    const r = (await Promise.all(
+      [...this.eventProcessors].map((e) => e(t))
+    )).reduce((e, i) => e + i, 0);
+    this.onEventsProcessed?.(r);
+  }
 }
 export {
-  b as BlockchainEventEmitter
+  k as BlockchainEventEmitter
 };

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("./BlockchainEventEmitter.cjs"),a=require("../helpers/ClientEventHelper.cjs");class E extends c.BlockchainEventEmitter{clientEventHelper;constructor(e,t,n,i,r,s,l){super(t,n,i,!1,r,s,l),this.clientEventHelper=new a.ClientEventHelper(t,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=E;

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;
+}