@sabaaa1/common 0.2.16

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

@@ -0,0 +1,125 @@
+import { utils as l, ethers as g } from "ethers";
+import p from "libsodium-wrappers";
+import { CIRCOM_P as d } from "../../constants/protocol.constants.mjs";
+import { babyJubInstance as K } from "../../crypto/babyJub.mjs";
+import { poseidonHash as a } from "../../crypto/poseidon.mjs";
+import { getCircomSign as h } from "./keyUtils.mjs";
+import { AttachableMemoryCacheDevice as y } from "../cacheDevices/AttachableMemoryCacheDevice.mjs";
+import "../../node_modules/ethers/lib/utils.mjs";
+import { ethers as c } from "ethers-v6h";
+import { networkRegistry as P } from "../../constants/chains.constants.mjs";
+import { __exports as u } from "../../_virtual/utils.mjs";
+const v = new y(), f = new y(), R = {
+  privateKey: "",
+  publicKey: ""
+};
+class W {
+  signature;
+  constructor(e) {
+    this.signature = e;
+  }
+  getSignature() {
+    return this.requireSignature(), this.signature;
+  }
+  setSignature(e) {
+    this.signature = e;
+  }
+  requireSignature() {
+    if (!this.signature)
+      throw Error("No signature provided");
+  }
+  verifyMessage(e) {
+    return this.requireSignature(), l.verifyMessage(e, this.signature);
+  }
+  /**
+   * get shielded private key from message signature used to login to the application,
+   * this private key is used to generate encryption keypairs as well as public key
+   * @retuns 0x-prefixed shielded private key
+   */
+  getShieldedPrivateKey = () => (this.requireSignature(), g.utils.keccak256(this.signature));
+  /**
+   * generate shielded public key from private key
+   * @param privateKey the key used to generate the shielded public key, this should be the signature
+   * that the user provided
+   * @retuns shielded public key in hexstring with 0x prefixed
+   */
+  getShieldedPublicKey = () => (this.requireSignature(), a(this.getShieldedPrivateKey()));
+  /**
+   * generate access token, this accessKey is what should be sent to the server for signing
+   * @returns accessKey in hexstring with 0x prefixed
+   */
+  getAccessKey = () => (this.requireSignature(), a(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
+  static getSignerAddressFromPrivateKey(e) {
+    return new c.Wallet(e).address;
+  }
+  static deriveSignerFromNonce(e, t) {
+    const r = a(t, e.getShieldedPrivateKey(), e.getShieldedPublicKey()), i = u.keccak256(u.toUtf8Bytes(r));
+    return new c.Wallet(i);
+  }
+  static async signMessageFromPrivateKey(e, t) {
+    const r = new c.Wallet(e), i = l.isHexString(t) ? l.arrayify(t) : t;
+    return r.signMessage(i);
+  }
+  static signTypedDataFromPrivateKey(e, t, r, i) {
+    return new c.Wallet(e).signTypedData(t, r, i);
+  }
+  static async authorizeDelegationFromPrivateKey(e, t, r, i) {
+    const n = new c.Wallet(e), s = new c.JsonRpcProvider(P[t].fetchRpcUrl);
+    return n.connect(s).authorize({
+      address: r,
+      ...i !== void 0 && { nonce: i }
+    });
+  }
+  getWalletSalt = (e) => (this.requireSignature(), a(this.getShieldedPublicKey(), this.getShieldedPrivateKey(), e));
+  /**
+   * generate inHinkalAddress - a user unique address linking him with a specific app
+   * @returns inHinkalAddress in bigint
+   */
+  getInHinkalAddress = (e) => {
+    this.requireSignature();
+    const t = a(this.getShieldedPrivateKey(), e);
+    return BigInt(t);
+  };
+  /**
+   * generate backend token, which is used for access control on backend
+   * @returns accessKey in hexstring with 0x prefixed
+   */
+  getBackendToken = () => (this.requireSignature(), a(this.getAccessKey(), this.getShieldedPublicKey()));
+  static getRandomizedStealthPair = v.attach(
+    (e, t) => {
+      const r = K(), i = BigInt(t) % d, n = e * i % d, s = r.mulPointEscalar(r.Base8, e), o = r.mulPointEscalar(r.Base8, n), S = [BigInt(r.F.toString(s[0])), BigInt(r.F.toString(s[1]))], m = [BigInt(r.F.toString(o[0])), BigInt(r.F.toString(o[1]))];
+      return { H0: S, H1: m };
+    }
+  );
+  static getStealthAddressCompressedPoints = (e, t) => {
+    const { H0: r, H1: i } = this.getRandomizedStealthPair(e, t), [n, s] = [r, i].map((o) => BigInt(o[1]) + 2n ** 255n * h(o[0]));
+    return { h0: n, h1: s };
+  };
+  static getStealthAddress = f.attach((e, t) => {
+    const { H0: r, H1: i } = this.getRandomizedStealthPair(e, t), s = [2n * h(r[0]) + h(i[0]), r[1], i[1]];
+    return a(...s);
+  });
+  static getStealthAddressWithEKey = (e, t) => ({ stealthAddress: this.getStealthAddress(e, t), encryptionKey: this.getEncryptionKeyPair(t).publicKey });
+  static checkSignature = (e, t, r, i) => {
+    const { h0: n, h1: s } = this.getStealthAddressCompressedPoints(e, i);
+    return t === n && r === s;
+  };
+  /**
+   * generate private and public keypair
+   * @param seed seed to use to deterministically generate key, must be in DataHexString format
+   * and must correspond to 32 bytes
+   */
+  static getEncryptionKeyPair = (e) => {
+    const t = p.crypto_box_seed_keypair(g.utils.arrayify(e));
+    return {
+      privateKey: g.utils.hexlify(t.privateKey),
+      publicKey: g.utils.hexlify(t.publicKey)
+    };
+  };
+}
+export {
+  R as EncryptionKeyPairDefaultValue,
+  W as UserKeys,
+  f as stealthAddressCacheDevice,
+  v as stealthPairCacheDevice
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class i{tokenRegistry;constructor(){this.tokenRegistry=[]}setTokensFromCache(s){this.tokenRegistry=s}getCustomTokens(s){return this.tokenRegistry.filter(t=>t.chainId===s)}tokenExists(s,t){return s.find(e=>e.erc20TokenAddress===t.erc20TokenAddress||e.symbol===t.symbol||e.name===t.name)}addCustomToken(s){const{chainId:t}=s,e=this.getCustomTokens(t);this.tokenExists(e,s)||this.tokenRegistry.push(s)}removeCustomToken(s){const{chainId:t}=s,r=this.getCustomTokens(t).filter(o=>o.erc20TokenAddress!==s.erc20TokenAddress);this.tokenRegistry=r}}const n=new i;exports.customTokenRegistry=n;

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

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

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

@@ -0,0 +1,29 @@
+class i {
+  tokenRegistry;
+  constructor() {
+    this.tokenRegistry = [];
+  }
+  setTokensFromCache(s) {
+    this.tokenRegistry = s;
+  }
+  getCustomTokens(s) {
+    return this.tokenRegistry.filter((t) => t.chainId === s);
+  }
+  tokenExists(s, t) {
+    return s.find(
+      (e) => e.erc20TokenAddress === t.erc20TokenAddress || e.symbol === t.symbol || e.name === t.name
+    );
+  }
+  addCustomToken(s) {
+    const { chainId: t } = s, e = this.getCustomTokens(t);
+    this.tokenExists(e, s) || this.tokenRegistry.push(s);
+  }
+  removeCustomToken(s) {
+    const { chainId: t } = s, r = this.getCustomTokens(t).filter((n) => n.erc20TokenAddress !== s.erc20TokenAddress);
+    this.tokenRegistry = r;
+  }
+}
+const c = new i();
+export {
+  c as customTokenRegistry
+};

package/data-structures/event-service/AbstractAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../../constants/protocol.constants.cjs"),a=require("../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const t=require("../../functions/utils/amounts.utils.cjs"),o=require("../merkle-tree/MerkleTree.cjs");require("ethers");require("../../error-handling/error-codes.constants.cjs");const l=require("./AbstractSnapshotService.cjs"),i=require("../../functions/utils/merkleTree.utils.cjs");class u extends l.AbstractSnapshotService{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(a.poseidonFunction,0n),e.latestBlockNumber&&e.senderAddressIndexMap?r=new Map(e.senderAddressIndexMap.map(({address:d,index:n})=>[d,n])):r=new Map,{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:s,senderAddresses:e.senderAddresses??[],senderAddressIndexMap:r}}}acceptEvent(e,s){try{return this._merkleTree.insert(e.accessKey,e.index),this._senderAddressIndexMap.set(e.senderAddress,Math.max(Number(e.index),this._senderAddressIndexMap.get(e.senderAddress)??0)),this._senderAddresses.includes(e.senderAddress)||this._senderAddresses.push(e.senderAddress),e.accessKey===0n&&e.senderAddress===c.zeroAddress&&this._merkleTree.remove(e.index),!0}catch(r){return console.error(r),!1}}mapEvent(e){const{accessKey:s,index:r,senderAddress:d}=e;return{accessKey:t.toBigInt(s),index:t.toBigInt(r),senderAddress:d}}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.AbstractAccessTokenSnapshotService=u;

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

@@ -0,0 +1,34 @@
+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;
+}[];
+export type AccessTokenSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly senderAddresses: string[];
+    readonly senderAddressIndexMap: Map<string, number>;
+};
+export type AccessTokenSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    senderAddresses?: string[];
+    senderAddressIndexMap?: SenderAddressIndexMapJson;
+};
+export declare abstract class AbstractAccessTokenSnapshotService extends AbstractSnapshotService<AccessTokenEvent<bigint>, AccessTokenEvent, AccessTokenSnapshotPayload, AccessTokenSerializedSnapshot> {
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter);
+    private _merkleTree;
+    private _senderAddresses;
+    private _senderAddressIndexMap;
+    get merkleTree(): MerkleTree<bigint>;
+    get senderAddresses(): string[];
+    get senderAddressIndexMap(): Map<string, number>;
+    protected serializeSnapshot(snapshot: Snapshot<AccessTokenSnapshotPayload>): AccessTokenSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: AccessTokenSerializedSnapshot): Snapshot<AccessTokenSnapshotPayload>;
+    protected acceptEvent(event: AccessTokenEvent<bigint>, _blockNumber: number): boolean;
+    protected mapEvent(event: AccessTokenEvent): AccessTokenEvent<bigint>;
+    protected getSnapshotPayload(): AccessTokenSnapshotPayload;
+    protected populateSnapshot({ payload: { merkleTree, senderAddresses, senderAddressIndexMap }, }: Snapshot<AccessTokenSnapshotPayload>): void;
+}

package/data-structures/event-service/AbstractAccessTokenSnapshotService.mjs

@@ -0,0 +1,86 @@
+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 "ethers";
+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;
+  _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 = 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,
+      payload: {
+        merkleTree: s,
+        senderAddresses: e.senderAddresses ?? [],
+        senderAddressIndexMap: r
+      }
+    };
+  }
+  acceptEvent(e, s) {
+    try {
+      return this._merkleTree.insert(e.accessKey, e.index), this._senderAddressIndexMap.set(
+        e.senderAddress,
+        Math.max(Number(e.index), this._senderAddressIndexMap.get(e.senderAddress) ?? 0)
+      ), this._senderAddresses.includes(e.senderAddress) || this._senderAddresses.push(e.senderAddress), e.accessKey === 0n && e.senderAddress === m && this._merkleTree.remove(e.index), !0;
+    } catch (r) {
+      return console.error(r), !1;
+    }
+  }
+  mapEvent(e) {
+    const { accessKey: s, index: r, senderAddress: d } = e;
+    return {
+      accessKey: t(s),
+      index: t(r),
+      senderAddress: d
+    };
+  }
+  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 AbstractAccessTokenSnapshotService
+};

package/data-structures/event-service/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

@@ -0,0 +1,29 @@
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+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;
+    approvals: Record<string, ApprovedUtxo<string>[]>;
+    events: string[];
+};
+export declare abstract class AbstractApprovalsSnapshotService extends AbstractSnapshotService<NewApprovedUtxoEvent, NewApprovedUtxoEvent<string>, ApprovalsSnapshotPayload, ApprovalsSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _approvals;
+    events: Set<string>;
+    get approvals(): Map<string, ApprovedUtxo[]>;
+    private getEventKey;
+    protected serializeSnapshot(snapshot: Snapshot<ApprovalsSnapshotPayload>): ApprovalsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: ApprovalsSerializedSnapshot): Snapshot<ApprovalsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        approvals: Map<string, ApprovedUtxo[]>;
+        events: Set<string>;
+    };
+    protected populateSnapshot({ payload: { approvals, events } }: Snapshot<ApprovalsSnapshotPayload>): void;
+    protected mapEvent(event: NewApprovedUtxoEvent<string>): NewApprovedUtxoEvent;
+    protected acceptEvent(event: NewApprovedUtxoEvent, _blockNumber: number, txHash: string): boolean;
+}

package/data-structures/event-service/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/AbstractCommitmentsSnapshotService.cjs

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

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

@@ -0,0 +1,29 @@
+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;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+};
+export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentEvent, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: CommitmentsSerializedSnapshot): Snapshot<CommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean;
+}

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

@@ -0,0 +1,83 @@
+import { poseidonFunction as p } from "../../crypto/poseidon.mjs";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import { MerkleTree as s } from "../merkle-tree/MerkleTree.mjs";
+import "ethers";
+import "../../error-handling/error-codes.constants.mjs";
+import { toBigInt as i } from "../../functions/utils/amounts.utils.mjs";
+import { AbstractSnapshotService as m } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as n } from "../../functions/utils/merkleTree.utils.mjs";
+class S extends m {
+  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)
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let t;
+    e.latestBlockNumber && e.merkleTree ? t = n(e.merkleTree) : t = s.create(p, 0n);
+    const r = e.encryptedOutputs?.map((u) => ({
+      value: u.value,
+      isPositive: JSON.parse(u.isPositive)
+    }));
+    return {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      payload: {
+        merkleTree: t,
+        encryptedOutputs: r || []
+      }
+    };
+  }
+  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: r, encryptedOutput: u } = e;
+    return {
+      commitment: i(t),
+      index: i(r),
+      encryptedOutput: u
+    };
+  }
+  acceptEvent(e, t) {
+    if (!this.encryptedOutputs.map((r) => r.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
+      };
+      return this._encryptedOutputs.push(u), !0;
+    }
+    return !1;
+  }
+}
+export {
+  S as AbstractCommitmentsSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../functions/utils/resolve-sync.utils.cjs");class v{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=[];await o.resolveSync(e.map(s=>async()=>{if(s.event!==this.eventName)return;const{args:n,blockNumber:a,transactionHash:i}=s;if(!n)throw new Error("Wrong event structure");const r=this.mapEvent(n);await this.acceptEvent(r,a,i)&&t.push(r)}));const c=t.length;return await this.afterEventsAccepted(c),t.length}}exports.AbstractEventService=v;

package/data-structures/event-service/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): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: SerializedEventType): EventType;
+    protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+import { resolveSync as o } from "../../functions/utils/resolve-sync.utils.mjs";
+class E {
+  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 = [];
+    await o(
+      e.map((s) => async () => {
+        if (s.event !== this.eventName)
+          return;
+        const { args: n, blockNumber: a, transactionHash: i } = s;
+        if (!n)
+          throw new Error("Wrong event structure");
+        const r = this.mapEvent(n);
+        await this.acceptEvent(r, a, i) && t.push(r);
+      })
+    );
+    const c = t.length;
+    return await this.afterEventsAccepted(c), t.length;
+  }
+}
+export {
+  E as AbstractEventService
+};

package/data-structures/event-service/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

@@ -0,0 +1,22 @@
+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;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierEvent<BigNumber>, 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<BigNumber>): NullifierEvent<string>;
+    protected getSnapshotPayload(): NullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
+}