@hinkal/common 0.2.14 → 0.2.16

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

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

@@ -0,0 +1,90 @@
+import { blockReorgDepth as d } from "../../../constants/reorg-depths.constants.mjs";
+import { getSequence as m, resolveSync as h } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { balanceFetchingMutex as y } from "../../../functions/utils/mutexes.utils.mjs";
+class w {
+  contract;
+  depositOnChainUtxosContract;
+  _latestBlockNumber;
+  _initialBlockNumber;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  eventsFetchingMutex;
+  constructor(t, r, l, s, i, n = y) {
+    this.contract = t, this.depositOnChainUtxosContract = i, this._initialBlockNumber = r, this.maxPageSize = s, this.isServer = l, this.inProgress = !1, this.eventsFetchingMutex = n;
+  }
+  get latestBlockNumber() {
+    return this._latestBlockNumber ?? this._initialBlockNumber;
+  }
+  syncFromAtMost(t) {
+    (this._latestBlockNumber === void 0 || t < this._latestBlockNumber) && (this._latestBlockNumber = t);
+  }
+  intervalClear() {
+    this.isReady = !1, this.eventProcessors = /* @__PURE__ */ 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(t) {
+    if (this.isReady)
+      throw new Error("Can't add event processor after event emitter initialized");
+    this.eventProcessors.add(t);
+  }
+  async getLastBlockNumberForEventRequest() {
+    const t = await this.contract.provider.getBlockNumber();
+    if (!this.isServer)
+      return t;
+    const { chainId: r } = await this.contract.provider.getNetwork();
+    return Math.max(this.latestBlockNumber, t - d[r] + 1);
+  }
+  async retrieveEvents(t, 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 < t)
+          return this.inProgress = !1, !1;
+        const n = m(t, i, this.maxPageSize), o = [];
+        if (await h(
+          n.map(({ from: e, to: a }) => async () => {
+            const c = await this.contract.queryFilter("*", e, a);
+            o.push(...c);
+          })
+        ), this.depositOnChainUtxosContract) {
+          const { depositOnChainUtxosContract: e } = this;
+          await h(
+            n.map(({ from: a, to: c }) => async () => {
+              const v = await e.queryFilter("*", a, c);
+              o.push(...v);
+            })
+          );
+        }
+        const u = await Promise.all(
+          [...this.eventProcessors].map((e) => e(o))
+        );
+        return this._latestBlockNumber = i, s += u.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;
+      }
+    });
+  }
+}
+export {
+  w as BlockchainEventEmitter
+};

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

@@ -1,6 +1,13 @@
-export * from './AbstractAccessTokenSnapshotService';
-export * from './AbstractCommitmentsSnapshotService';
-export * from './AbstractApprovalsSnapshotService';
-export * from './AbstractNullifierSnapshotService';
-export * from './AbstractSnapshotService';
-export * from './AbstractEventService';
+export * from './evm/AbstractAccessTokenSnapshotService';
+export * from './evm/AbstractCommitmentsSnapshotService';
+export * from './evm/AbstractApprovalsSnapshotService';
+export * from './evm/AbstractNullifierSnapshotService';
+export * from './evm/AbstractSnapshotService';
+export * from './evm/AbstractEventService';
+export * from './evm/BlockchainEventEmitter';
+export * from './solana/SolanaBlockchainEventEmitter';
+export * from './solana/AbstractSolanaEventService';
+export * from './solana/AbstractSolanaSnapshotService';
+export * from './solana/AbstractSolanaNullifierSnapshotService';
+export * from './solana/AbstractSolanaCommitmentsSnapshotService';
+export * from './solana/AbstractSolanaAccessTokenSnapshotService';

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../../constants/protocol.constants.cjs"),c=require("../../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const n=require("../../../functions/utils/amounts.utils.cjs"),o=require("../../merkle-tree/MerkleTree.cjs");require("ethers");require("../../../error-handling/error-codes.constants.cjs");const l=require("./AbstractSolanaSnapshotService.cjs"),i=require("../../../functions/utils/merkleTree.utils.cjs"),u=require("@solana/web3.js");class A extends l.AbstractSolanaSnapshotService{constructor(e){super(e,"NewAccessKeyAdded")}_merkleTree;_senderAddresses;_senderAddressIndexMap;get merkleTree(){return this._merkleTree}get senderAddresses(){return this._senderAddresses}get senderAddressIndexMap(){return this._senderAddressIndexMap}serializeSnapshot(e){return{merkleTree:e.payload.merkleTree.toJSON(),senderAddresses:Array.from(e.payload.senderAddresses),latestBlockNumber:e.latestBlockNumber,senderAddressIndexMap:Array.from(e.payload.senderAddressIndexMap).map(([s,r])=>({address:s,index:r}))}}deserializeSnapshot(e){let s,r;return e.latestBlockNumber&&e.merkleTree?s=i.contructMerkleTreeFromSerialized(e.merkleTree):s=o.MerkleTree.create(c.poseidonFunction,0n),e.latestBlockNumber&&e.senderAddressIndexMap?r=new Map(e.senderAddressIndexMap.map(({address:d,index:t})=>[d,t])):r=new Map,{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:s,senderAddresses:e.senderAddresses??[],senderAddressIndexMap:r}}}acceptEvent(e,s){try{return this._merkleTree.insert(e.access_key,e.index),this._senderAddressIndexMap.set(e.sender_address,Math.max(Number(e.index),this._senderAddressIndexMap.get(e.sender_address)??0)),this._senderAddresses.includes(e.sender_address)||this._senderAddresses.push(e.sender_address),e.access_key===0n&&e.sender_address===a.zeroAddress&&this._merkleTree.remove(e.index),!0}catch(r){return console.error(r),!1}}mapEvent(e){const{access_key:s,index:r,sender_address:d}=e;return{access_key:n.advancedToBigInt(s),index:n.advancedToBigInt(r),sender_address:new u.PublicKey(d).toBase58()}}getSnapshotPayload(){return{merkleTree:this._merkleTree,senderAddresses:this._senderAddresses,senderAddressIndexMap:this._senderAddressIndexMap}}populateSnapshot({payload:{merkleTree:e,senderAddresses:s,senderAddressIndexMap:r}}){this._merkleTree=e,this._senderAddresses=s,this._senderAddressIndexMap=r}}exports.AbstractSolanaAccessTokenSnapshotService=A;

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

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

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

@@ -0,0 +1,87 @@
+import { zeroAddress as a } 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 { advancedToBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { MerkleTree as m } from "../../merkle-tree/MerkleTree.mjs";
+import "ethers";
+import "../../../error-handling/error-codes.constants.mjs";
+import { AbstractSolanaSnapshotService as l } from "./AbstractSolanaSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as c } from "../../../functions/utils/merkleTree.utils.mjs";
+import { PublicKey as p } from "@solana/web3.js";
+class B extends l {
+  constructor(e) {
+    super(e, "NewAccessKeyAdded");
+  }
+  _merkleTree;
+  _senderAddresses;
+  _senderAddressIndexMap;
+  get merkleTree() {
+    return this._merkleTree;
+  }
+  get senderAddresses() {
+    return this._senderAddresses;
+  }
+  get senderAddressIndexMap() {
+    return this._senderAddressIndexMap;
+  }
+  serializeSnapshot(e) {
+    return {
+      merkleTree: e.payload.merkleTree.toJSON(),
+      senderAddresses: Array.from(e.payload.senderAddresses),
+      latestBlockNumber: e.latestBlockNumber,
+      senderAddressIndexMap: Array.from(e.payload.senderAddressIndexMap).map(([s, r]) => ({
+        address: s,
+        index: r
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let s, r;
+    return e.latestBlockNumber && e.merkleTree ? s = c(e.merkleTree) : s = m.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,
+      payload: {
+        merkleTree: s,
+        senderAddresses: e.senderAddresses ?? [],
+        senderAddressIndexMap: r
+      }
+    };
+  }
+  acceptEvent(e, s) {
+    try {
+      return this._merkleTree.insert(e.access_key, e.index), this._senderAddressIndexMap.set(
+        e.sender_address,
+        Math.max(Number(e.index), this._senderAddressIndexMap.get(e.sender_address) ?? 0)
+      ), this._senderAddresses.includes(e.sender_address) || this._senderAddresses.push(e.sender_address), e.access_key === 0n && e.sender_address === a && this._merkleTree.remove(e.index), !0;
+    } catch (r) {
+      return console.error(r), !1;
+    }
+  }
+  mapEvent(e) {
+    const { access_key: s, index: r, sender_address: d } = e;
+    return {
+      access_key: t(s),
+      index: t(r),
+      sender_address: new p(d).toBase58()
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      senderAddresses: this._senderAddresses,
+      senderAddressIndexMap: this._senderAddressIndexMap
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, senderAddresses: s, senderAddressIndexMap: r }
+  }) {
+    this._merkleTree = e, this._senderAddresses = s, this._senderAddressIndexMap = r;
+  }
+}
+export {
+  B as AbstractSolanaAccessTokenSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("../../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const m=require("../../merkle-tree/MerkleTree.cjs");require("ethers");require("../../../error-handling/error-codes.constants.cjs");const c=require("../../../functions/utils/amounts.utils.cjs"),d=require("./AbstractSolanaSnapshotService.cjs"),y=require("../../../functions/utils/merkleTree.utils.cjs"),o=require("../../crypto-keys/decodeUTXO.cjs");class O extends d.AbstractSolanaSnapshotService{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=y.contructMerkleTreeFromSerialized(e.merkleTree):t=m.MerkleTree.create(p.poseidonFunction,0n);const n=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:n||[]}}}getSnapshotPayload(){return{merkleTree:this._merkleTree,encryptedOutputs:this._encryptedOutputs}}populateSnapshot({payload:{merkleTree:e,encryptedOutputs:t}}){this._merkleTree=e,this._encryptedOutputs=t}async mapEvent(e){const{commitment:t,index:n,encrypted_output:r,on_chain_data:s}=e,i=c.advancedToBigInt(t),u=c.advancedToBigInt(n);if(r.length===0){const l=o.encodeSolanaOnChainUtxo(s);return{commitment:i,index:u,encryptedOutput:l}}const a=`0x${Buffer.from(r).toString("hex")}`;return{commitment:i,index:u,encryptedOutput:a}}acceptEvent(e,t,n,r){if(!this.encryptedOutputs.map(s=>s.value).includes(e.encryptedOutput)){if(!this._merkleTree.insert(e.commitment,e.index>=0?e.index:-1n*e.index))return!1;const i={value:e.encryptedOutput,isPositive:!o.isSolanaOnChainUtxo(e.encryptedOutput),isBlocked:r??!1};return this._encryptedOutputs.push(i),!0}return!1}}exports.AbstractSolanaCommitmentsSnapshotService=O;

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

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

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

@@ -0,0 +1,96 @@
+import { poseidonFunction as p } from "../../../crypto/poseidon.mjs";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import { MerkleTree as a } from "../../merkle-tree/MerkleTree.mjs";
+import "ethers";
+import "../../../error-handling/error-codes.constants.mjs";
+import { advancedToBigInt as u } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSolanaSnapshotService as l } from "./AbstractSolanaSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as d } from "../../../functions/utils/merkleTree.utils.mjs";
+import { encodeSolanaOnChainUtxo as y, isSolanaOnChainUtxo as O } from "../../crypto-keys/decodeUTXO.mjs";
+class I extends l {
+  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 = d(e.merkleTree) : t = a.create(p, 0n);
+    const n = 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: n || []
+      }
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      encryptedOutputs: this._encryptedOutputs
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, encryptedOutputs: t }
+  }) {
+    this._merkleTree = e, this._encryptedOutputs = t;
+  }
+  async mapEvent(e) {
+    const { commitment: t, index: n, encrypted_output: r, on_chain_data: i } = e, s = u(t), o = u(n);
+    if (r.length === 0) {
+      const m = y(i);
+      return {
+        commitment: s,
+        index: o,
+        encryptedOutput: m
+      };
+    }
+    const c = `0x${Buffer.from(r).toString("hex")}`;
+    return {
+      commitment: s,
+      index: o,
+      encryptedOutput: c
+    };
+  }
+  acceptEvent(e, t, n, 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 s = {
+        value: e.encryptedOutput,
+        isPositive: !O(e.encryptedOutput),
+        isBlocked: r ?? !1
+      };
+      return this._encryptedOutputs.push(s), !0;
+    }
+    return !1;
+  }
+}
+export {
+  I as AbstractSolanaCommitmentsSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class i{solanaBlockchainEventEmitter;eventName;constructor(e,s){this.solanaBlockchainEventEmitter=e,this.eventName=s,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.solanaBlockchainEventEmitter.latestBlockNumber}intervalClear(){this.solanaBlockchainEventEmitter.intervalClear()}async processEventsPage(e){const s=[],n=new Set;e.forEach(({eventName:t,signature:a})=>{t==="BlockedUtxosCreated"&&n.add(a)});const c=e.filter(t=>t.eventName===this.eventName).map(async t=>{try{const a=await this.mapEvent(t.data),o=n.has(t.signature);return await this.acceptEvent(a,t.slot,t.signature,o)?a:null}catch{return null}}),r=(await Promise.all(c)).filter(t=>t!==null);s.push(...r);const l=s.length;return await this.afterEventsAccepted(l),s.length}}exports.AbstractSolanaEventService=i;

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

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