@hinkal/common 0.2.15 → 0.2.17

package/data-structures/event-service/{AbstractAccessTokenSnapshotService.d.ts → evm/AbstractAccessTokenSnapshotService.d.ts}

@@ -1,7 +1,7 @@
-import { ethers } from 'ethers';
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { AccessTokenEvent } from '../../types';
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { AccessTokenEvent } from '../../../types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type SenderAddressIndexMapJson = {
     address: string;
     index: number;
@@ -13,13 +13,12 @@ export type AccessTokenSnapshotPayload = {
 };
 export type AccessTokenSerializedSnapshot = {
     latestBlockNumber?: number;
-    reserveBlockNumber?: number;
     merkleTree?: MerkleTreeJson;
     senderAddresses?: string[];
     senderAddressIndexMap?: SenderAddressIndexMapJson;
 };
 export declare abstract class AbstractAccessTokenSnapshotService extends AbstractSnapshotService<AccessTokenEvent<bigint>, AccessTokenEvent, AccessTokenSnapshotPayload, AccessTokenSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter);
     private _merkleTree;
     private _senderAddresses;
     private _senderAddressIndexMap;

package/data-structures/event-service/{AbstractAccessTokenSnapshotService.mjs → evm/AbstractAccessTokenSnapshotService.mjs}

@@ -1,27 +1,18 @@
-import { zeroAddress as m } from "../../constants/protocol.constants.mjs";
-import { poseidonFunction as o } from "../../crypto/poseidon.mjs";
+import { zeroAddress as m } from "../../../constants/protocol.constants.mjs";
+import { poseidonFunction as o } from "../../../crypto/poseidon.mjs";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
 import "process";
 import "buffer";
-import { toBigInt as t } from "../../functions/utils/amounts.utils.mjs";
-import { MerkleTree as a } from "../merkle-tree/MerkleTree.mjs";
+import { toBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { MerkleTree as a } from "../../merkle-tree/MerkleTree.mjs";
 import "ethers";
-import "../../error-handling/error-codes.constants.mjs";
-import { AbstractSnapshotService as c } from "./AbstractSnapshotService.mjs";
-import { contructMerkleTreeFromSerialized as l } from "../../functions/utils/merkleTree.utils.mjs";
-class f extends c {
-  constructor(e, s, r, d) {
-    super(
-      e,
-      {
-        name: "NewAccessKeyAdded",
-        args: ["accessKey", "index", "senderAddress"]
-      },
-      s,
-      r,
-      d
-    );
+import "../../../error-handling/error-codes.constants.mjs";
+import { AbstractSnapshotService as l } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as A } from "../../../functions/utils/merkleTree.utils.mjs";
+class b extends l {
+  constructor(e) {
+    super(e, "NewAccessKeyAdded");
   }
   _merkleTree;
   _senderAddresses;
@@ -40,7 +31,6 @@ class f extends c {
       merkleTree: e.payload.merkleTree.toJSON(),
       senderAddresses: Array.from(e.payload.senderAddresses),
       latestBlockNumber: e.latestBlockNumber,
-      reserveBlockNumber: e.reserveBlockNumber,
       senderAddressIndexMap: Array.from(e.payload.senderAddressIndexMap).map(([s, r]) => ({
         address: s,
         index: r
@@ -49,11 +39,10 @@ class f extends c {
   }
   deserializeSnapshot(e) {
     let s, r;
-    return e.latestBlockNumber && e.merkleTree ? s = l(e.merkleTree) : s = a.create(o, 0n), e.latestBlockNumber && e.senderAddressIndexMap ? r = new Map(
+    return e.latestBlockNumber && e.merkleTree ? s = A(e.merkleTree) : s = a.create(o, 0n), e.latestBlockNumber && e.senderAddressIndexMap ? r = new Map(
       e.senderAddressIndexMap.map(({ address: d, index: n }) => [d, n])
     ) : r = /* @__PURE__ */ new Map(), {
       latestBlockNumber: e.latestBlockNumber ?? 0,
-      reserveBlockNumber: e.reserveBlockNumber ?? 0,
       payload: {
         merkleTree: s,
         senderAddresses: e.senderAddresses ?? [],
@@ -93,5 +82,5 @@ class f extends c {
   }
 }
 export {
-  f as AbstractAccessTokenSnapshotService
+  b as AbstractAccessTokenSnapshotService
 };

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("./AbstractSnapshotService.cjs"),v=require("../../../functions/utils/amounts.utils.cjs"),u=require("../../../functions/utils/caseInsensitive.utils.cjs");class A extends c.AbstractSnapshotService{constructor(e){super(e,"NewApprovedUtxo")}_approvals=new Map;events=new Set;get approvals(){return this._approvals}getEventKey(e,t,s){return typeof e!="bigint"||typeof s!="string"||typeof t!="string"?null:`${s}-${t}-${e}`}serializeSnapshot(e){const t=Object.fromEntries(e.payload.approvals),s=Object.entries(t).map(([p,i])=>{const l=i.map(n=>({amount:n.amount.toString(),tokenAddress:n.tokenAddress,inHinkalAddress:n.inHinkalAddress.toString()}));return[p,l]}),r=Object.fromEntries(s);return{latestBlockNumber:e.latestBlockNumber,approvals:r,events:[...this.events]}}deserializeSnapshot(e){const t=e.approvals,s=Object.entries(t).map(([p,i])=>{const l=i.map(n=>({amount:BigInt(n.amount),tokenAddress:n.tokenAddress,inHinkalAddress:BigInt(n.inHinkalAddress)}));return[p,l]}),r=new Map(s);return{latestBlockNumber:e.latestBlockNumber??0,payload:{approvals:r,events:new Set(e.events)}}}getSnapshotPayload(){return{approvals:this._approvals,events:this.events}}populateSnapshot({payload:{approvals:e,events:t}}){this._approvals=e,this.events=t}mapEvent(e){const{approveTo:t,tokenAddress:s,amount:r,inHinkalAddress:p}=e;return{approveTo:t,tokenAddress:s,amount:v.toBigInt(r),inHinkalAddress:v.toBigInt(p)}}acceptEvent(e,t,s){const r=this.getEventKey(e.inHinkalAddress,e.tokenAddress,s);if(r&&!this.events.has(r)){const{amount:p,tokenAddress:i,inHinkalAddress:l}=e,n={amount:p,tokenAddress:i,inHinkalAddress:l};let a=this.approvals.get(e.approveTo)||[],d=!1;for(let o=0;o<a.length;o+=1)u.caseInsensitiveEqual(i,a[o].tokenAddress)&&l===a[o].inHinkalAddress&&(a[o].amount+=p,d=!0);if(a=a.filter(o=>o.amount!==0n),d&&a.length===0)this.approvals.delete(e.approveTo);else{const o=d?a:[...a,n];this.approvals.set(e.approveTo,o)}return s&&this.events.add(r),!0}return!1}}exports.AbstractApprovalsSnapshotService=A;

package/data-structures/event-service/{AbstractApprovalsSnapshotService.d.ts → evm/AbstractApprovalsSnapshotService.d.ts}

@@ -1,19 +1,18 @@
-import { ethers } from 'ethers';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-import { NewApprovedUtxoEvent } from '../../types/commitments.types';
-import { ApprovedUtxo } from '../../types/hinkal.types';
+import { NewApprovedUtxoEvent } from '../../../types/commitments.types';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { ApprovedUtxo } from '../../../types/hinkal.types';
 export type ApprovalsSnapshotPayload = {
     readonly approvals: Map<string, ApprovedUtxo[]>;
     readonly events: Set<string>;
 };
 export type ApprovalsSerializedSnapshot = {
     latestBlockNumber?: number;
-    reserveBlockNumber?: number;
     approvals: Record<string, ApprovedUtxo<string>[]>;
     events: string[];
 };
 export declare abstract class AbstractApprovalsSnapshotService extends AbstractSnapshotService<NewApprovedUtxoEvent, NewApprovedUtxoEvent<string>, ApprovalsSnapshotPayload, ApprovalsSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
     private _approvals;
     events: Set<string>;
     get approvals(): Map<string, ApprovedUtxo[]>;

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

@@ -0,0 +1,92 @@
+import { AbstractSnapshotService as c } from "./AbstractSnapshotService.mjs";
+import { toBigInt as v } from "../../../functions/utils/amounts.utils.mjs";
+import { caseInsensitiveEqual as u } from "../../../functions/utils/caseInsensitive.utils.mjs";
+class g extends c {
+  constructor(e) {
+    super(e, "NewApprovedUtxo");
+  }
+  _approvals = /* @__PURE__ */ new Map();
+  events = /* @__PURE__ */ new Set();
+  get approvals() {
+    return this._approvals;
+  }
+  getEventKey(e, t, s) {
+    return typeof e != "bigint" || typeof s != "string" || typeof t != "string" ? null : `${s}-${t}-${e}`;
+  }
+  serializeSnapshot(e) {
+    const t = Object.fromEntries(e.payload.approvals), s = Object.entries(t).map(([p, i]) => {
+      const l = i.map((n) => ({
+        amount: n.amount.toString(),
+        tokenAddress: n.tokenAddress,
+        inHinkalAddress: n.inHinkalAddress.toString()
+      }));
+      return [p, l];
+    }), r = Object.fromEntries(s);
+    return {
+      latestBlockNumber: e.latestBlockNumber,
+      approvals: r,
+      events: [...this.events]
+    };
+  }
+  deserializeSnapshot(e) {
+    const t = e.approvals, s = Object.entries(t).map(
+      ([p, i]) => {
+        const l = i.map((n) => ({
+          amount: BigInt(n.amount),
+          tokenAddress: n.tokenAddress,
+          inHinkalAddress: BigInt(n.inHinkalAddress)
+        }));
+        return [p, l];
+      }
+    ), r = new Map(s);
+    return {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      payload: {
+        approvals: r,
+        events: new Set(e.events)
+      }
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      approvals: this._approvals,
+      events: this.events
+    };
+  }
+  populateSnapshot({ payload: { approvals: e, events: t } }) {
+    this._approvals = e, this.events = t;
+  }
+  mapEvent(e) {
+    const { approveTo: t, tokenAddress: s, amount: r, inHinkalAddress: p } = e;
+    return {
+      approveTo: t,
+      tokenAddress: s,
+      amount: v(r),
+      inHinkalAddress: v(p)
+    };
+  }
+  acceptEvent(e, t, s) {
+    const r = this.getEventKey(e.inHinkalAddress, e.tokenAddress, s);
+    if (r && !this.events.has(r)) {
+      const { amount: p, tokenAddress: i, inHinkalAddress: l } = e, n = {
+        amount: p,
+        tokenAddress: i,
+        inHinkalAddress: l
+      };
+      let a = this.approvals.get(e.approveTo) || [], d = !1;
+      for (let o = 0; o < a.length; o += 1)
+        u(i, a[o].tokenAddress) && l === a[o].inHinkalAddress && (a[o].amount += p, d = !0);
+      if (a = a.filter((o) => o.amount !== 0n), d && a.length === 0)
+        this.approvals.delete(e.approveTo);
+      else {
+        const o = d ? a : [...a, n];
+        this.approvals.set(e.approveTo, o);
+      }
+      return s && this.events.add(r), !0;
+    }
+    return !1;
+  }
+}
+export {
+  g as AbstractApprovalsSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const l=require("../../merkle-tree/MerkleTree.cjs");require("ethers");require("../../../error-handling/error-codes.constants.cjs");const u=require("../../../functions/utils/amounts.utils.cjs"),o=require("./AbstractSnapshotService.cjs"),p=require("../../../functions/utils/merkleTree.utils.cjs");class a extends o.AbstractSnapshotService{constructor(e){super(e,"NewCommitment")}_merkleTree;_encryptedOutputs;get merkleTree(){return this._merkleTree}get encryptedOutputs(){return this._encryptedOutputs}serializeSnapshot(e){return{merkleTree:e.payload.merkleTree.toJSON(),latestBlockNumber:e.latestBlockNumber,encryptedOutputs:e.payload.encryptedOutputs.map(t=>({value:t.value,isPositive:String(t.isPositive),isBlocked:t.isBlocked??!1}))}}deserializeSnapshot(e){let t;e.latestBlockNumber&&e.merkleTree?t=p.contructMerkleTreeFromSerialized(e.merkleTree):t=l.MerkleTree.create(c.poseidonFunction,0n);const s=e.encryptedOutputs?.map(r=>({value:r.value,isPositive:JSON.parse(r.isPositive),isBlocked:r.isBlocked??!1}));return{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:t,encryptedOutputs:s||[]}}}getSnapshotPayload(){return{merkleTree:this._merkleTree,encryptedOutputs:this._encryptedOutputs}}populateSnapshot({payload:{merkleTree:e,encryptedOutputs:t}}){this._merkleTree=e,this._encryptedOutputs=t}mapEvent(e){const{commitment:t,index:s,encryptedOutput:r}=e;return{commitment:u.toBigInt(t),index:u.toBigInt(s),encryptedOutput:r}}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 n={value:e.encryptedOutput,isPositive:e.index>=0n,isBlocked:r??!1};return this._encryptedOutputs.push(n),!0}return!1}}exports.AbstractCommitmentsSnapshotService=a;

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

@@ -1,19 +1,18 @@
-import { ethers } from 'ethers';
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { CommitmentEvent, EncryptedOutputWithSign } from '../../types';
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithSign } from '../../../types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type CommitmentsSnapshotPayload = {
     readonly merkleTree: MerkleTree<bigint>;
     readonly encryptedOutputs: EncryptedOutputWithSign[];
 };
 export type CommitmentsSerializedSnapshot = {
     latestBlockNumber?: number;
-    reserveBlockNumber?: number;
     merkleTree?: MerkleTreeJson;
     encryptedOutputs?: EncryptedOutputWithSign<string>[];
 };
 export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentEvent, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
     private _merkleTree;
     private _encryptedOutputs;
     get merkleTree(): MerkleTree<bigint>;
@@ -26,5 +25,5 @@ export declare abstract class AbstractCommitmentsSnapshotService extends Abstrac
     };
     protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
     protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
-    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number, _txHash?: string, isBlocked?: boolean): boolean;
 }

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

@@ -0,0 +1,86 @@
+import { poseidonFunction as m } 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 "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");
+  }
+  _merkleTree;
+  _encryptedOutputs;
+  get merkleTree() {
+    return this._merkleTree;
+  }
+  get encryptedOutputs() {
+    return this._encryptedOutputs;
+  }
+  serializeSnapshot(e) {
+    return {
+      merkleTree: e.payload.merkleTree.toJSON(),
+      latestBlockNumber: e.latestBlockNumber,
+      encryptedOutputs: e.payload.encryptedOutputs.map((t) => ({
+        value: t.value,
+        isPositive: String(t.isPositive),
+        isBlocked: t.isBlocked ?? !1
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let t;
+    e.latestBlockNumber && e.merkleTree ? t = 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,
+      payload: {
+        merkleTree: t,
+        encryptedOutputs: s || []
+      }
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      encryptedOutputs: this._encryptedOutputs
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, encryptedOutputs: t }
+  }) {
+    this._merkleTree = e, this._encryptedOutputs = t;
+  }
+  mapEvent(e) {
+    const { commitment: t, index: s, encryptedOutput: r } = e;
+    return {
+      commitment: p(t),
+      index: p(s),
+      encryptedOutput: r
+    };
+  }
+  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;
+    }
+    return !1;
+  }
+}
+export {
+  b as AbstractCommitmentsSnapshotService
+};

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

@@ -0,0 +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,t){this.blockchainEventEmitter=e,this.eventName=t,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.blockchainEventEmitter.latestBlockNumber}intervalClear(){this.blockchainEventEmitter.intervalClear()}async processEventsPage(e){const t=new Set;e.forEach(({event:s,transactionHash:n})=>{s==="BlockedUtxosCreated"&&t.add(n)});const c=[];await v.resolveSync(e.map(s=>async()=>{if(s.event!==this.eventName)return;const{args:n,blockNumber:i,transactionHash:r}=s;if(!n)throw new Error("Wrong event structure");const a=this.mapEvent(n),l=t.has(r);await this.acceptEvent(a,i,r,l)&&c.push(a)}));const o=c.length;return await this.afterEventsAccepted(o),c.length}}exports.AbstractEventService=h;

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

@@ -0,0 +1,12 @@
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export declare abstract class AbstractEventService<EventType, SerializedEventType = unknown> {
+    protected blockchainEventEmitter: BlockchainEventEmitter;
+    protected readonly eventName: string;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
+    get latestBlockNumber(): 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 afterEventsAccepted(eventsCount: number): Promise<void>;
+}

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

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

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./AbstractSnapshotService.cjs");class i 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{nullifier:r}=e;return{nullifier:r.toHexString()}}getSnapshotPayload(){return{nullifiers:this._nullifiers}}populateSnapshot({payload:{nullifiers:e}}){this._nullifiers=e}}exports.AbstractNullifierSnapshotService=i;

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

@@ -1,16 +1,16 @@
-import { BigNumber, ethers } from 'ethers';
-import { NullifierEvent } from '../../types/commitments.types';
+import { BigNumber } from 'ethers';
+import { NullifierEvent } from '../../../types/commitments.types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type NullifierSnapshotPayload = {
     readonly nullifiers: Set<string>;
 };
 export type NullifierSerializedSnapshot = {
     latestBlockNumber?: number;
-    reserveBlockNumber?: number;
     nullifiers?: string[];
 };
 export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierEvent<BigNumber>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
     private _nullifiers;
     get nullifiers(): Set<string>;
     protected serializeSnapshot(snapshot: Snapshot<NullifierSnapshotPayload>): NullifierSerializedSnapshot;

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

@@ -0,0 +1,48 @@
+import { AbstractSnapshotService as i } from "./AbstractSnapshotService.mjs";
+class n extends i {
+  constructor(r) {
+    super(r, "Nullified");
+  }
+  _nullifiers;
+  get nullifiers() {
+    return this._nullifiers;
+  }
+  serializeSnapshot(r) {
+    return {
+      nullifiers: Array.from(r.payload.nullifiers).map((e) => e.toString()),
+      latestBlockNumber: r.latestBlockNumber
+    };
+  }
+  deserializeSnapshot(r) {
+    return {
+      latestBlockNumber: r.latestBlockNumber ?? 0,
+      payload: {
+        nullifiers: new Set(r.nullifiers ?? [])
+      }
+    };
+  }
+  acceptEvent(r, e) {
+    try {
+      return this._nullifiers.has(r.nullifier) ? !1 : (this._nullifiers.add(r.nullifier), !0);
+    } catch (l) {
+      return console.error(l), !1;
+    }
+  }
+  mapEvent(r) {
+    const { nullifier: e } = r;
+    return {
+      nullifier: e.toHexString()
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      nullifiers: this._nullifiers
+    };
+  }
+  populateSnapshot({ payload: { nullifiers: r } }) {
+    this._nullifiers = r;
+  }
+}
+export {
+  n as AbstractNullifierSnapshotService
+};

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

@@ -0,0 +1 @@
+"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;chainId=0;constructor(t,e){super(t,e)}async init(){await this.loadSnapshot(),this.chainId=(await this.blockchainEventEmitter.contract.provider.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;

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

@@ -1,19 +1,18 @@
-import { ethers } from 'ethers';
-import { AbstractEventService, EventConfig } from './AbstractEventService';
+import { AbstractEventService } from './AbstractEventService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export interface Snapshot<SnapshotPayloadType> {
     readonly latestBlockNumber: number;
-    readonly reserveBlockNumber: number;
     readonly payload: SnapshotPayloadType;
 }
 export declare abstract class AbstractSnapshotService<EventType, SerializedEventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType, SerializedEventType> {
-    protected reserveBlockNumber: number;
-    protected constructor(contract: ethers.Contract, eventConfig: EventConfig, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    private savedLatestBlockNumber;
+    private chainId;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
     init(): Promise<void>;
     retrieveEventsFromLatestBlock(): Promise<void>;
-    restoreSnapshotState(): Promise<void>;
     private loadSnapshot;
     protected saveSnapshot(): Promise<unknown>;
-    protected afterEventsAccepted(): 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;

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

@@ -0,0 +1,33 @@
+import { saveDepths as e } from "../../../constants/save-depths.mjs";
+import { AbstractEventService as a } from "./AbstractEventService.mjs";
+class c extends a {
+  savedLatestBlockNumber = 0;
+  chainId = 0;
+  constructor(t, s) {
+    super(t, s);
+  }
+  async init() {
+    await this.loadSnapshot(), this.chainId = (await this.blockchainEventEmitter.contract.provider.getNetwork()).chainId;
+  }
+  async retrieveEventsFromLatestBlock() {
+    await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
+  }
+  async loadSnapshot() {
+    const t = await this.fetchSnapshot(), s = this.deserializeSnapshot(t);
+    this.populateSnapshot(s), this.blockchainEventEmitter.syncFromAtMost(s.latestBlockNumber), this.savedLatestBlockNumber = s.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();
+  }
+}
+export {
+  c as AbstractSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("../../../constants/reorg-depths.constants.cjs"),l=require("../../../functions/utils/resolve-sync.utils.cjs"),m=require("../../../functions/utils/mutexes.utils.cjs");class y{contract;depositOnChainUtxosContract;_latestBlockNumber;_initialBlockNumber;onEventsProcessed;eventProcessors=new Set;maxPageSize;isReady=!1;isServer;intervalId;inProgress;eventsFetchingMutex;constructor(e,r,h,s,i,a=m.balanceFetchingMutex){this.contract=e,this.depositOnChainUtxosContract=i,this._initialBlockNumber=r,this.maxPageSize=s,this.isServer=h,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 this.contract.provider.getBlockNumber();if(!this.isServer)return e;const{chainId:r}=await this.contract.provider.getNetwork();return Math.max(this.latestBlockNumber,e-d.blockReorgDepth[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=l.getSequence(e,i,this.maxPageSize),o=[];if(await l.resolveSync(a.map(({from:t,to:n})=>async()=>{const c=await this.contract.queryFilter("*",t,n);o.push(...c)})),this.depositOnChainUtxosContract){const{depositOnChainUtxosContract:t}=this;await l.resolveSync(a.map(({from:n,to:c})=>async()=>{const v=await t.queryFilter("*",n,c);o.push(...v)}))}const u=await Promise.all([...this.eventProcessors].map(t=>t(o)));return this._latestBlockNumber=i,s+=u.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=y;

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

@@ -0,0 +1,26 @@
+import { ethers } from 'ethers';
+import { Mutex } from 'async-mutex';
+export type EventProcessorFunction = (events: ethers.Event[]) => Promise<number> | number;
+export declare class BlockchainEventEmitter {
+    readonly contract: ethers.Contract;
+    readonly depositOnChainUtxosContract?: ethers.Contract;
+    private _latestBlockNumber;
+    private _initialBlockNumber;
+    onEventsProcessed?: (acceptedEventCount: number) => void;
+    private eventProcessors;
+    private readonly maxPageSize?;
+    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);
+    get latestBlockNumber(): number;
+    syncFromAtMost(blockNumber: number): void;
+    intervalClear(): void;
+    init(): Promise<void>;
+    private requireReady;
+    addEventProcessorFunction(eventProcessorFunction: EventProcessorFunction): void;
+    private getLastBlockNumberForEventRequest;
+    retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
+}