@sabaaa1/common 0.2.16

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { ethers } from 'ethers';
+export type EventProcessorFunction = (events: ethers.Event[]) => Promise<number> | number;
+export declare class BlockchainEventEmitter {
+    readonly contract: ethers.Contract;
+    private _latestBlockNumber;
+    private _initialBlockNumber;
+    onEventsProcessed?: (acceptedEventCount: number) => void;
+    private eventProcessors;
+    private readonly maxPageSize?;
+    private isReady;
+    private isServer;
+    private intervalId?;
+    private inProgress;
+    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    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/BlockchainEventEmitter.mjs

@@ -0,0 +1,80 @@
+import { blockReorgDepth as u } from "../../constants/reorg-depths.constants.mjs";
+import { getSequence as v, resolveSync as m } from "../../functions/utils/resolve-sync.utils.mjs";
+import { balanceFetchingMutex as d } from "../../functions/utils/mutexes.utils.mjs";
+class B {
+  contract;
+  _latestBlockNumber;
+  _initialBlockNumber;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  constructor(e, r, n, t) {
+    this.contract = e, this._initialBlockNumber = r, this.maxPageSize = t, this.isServer = n, this.inProgress = !1;
+  }
+  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 = /* @__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(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 - u[r] + 1);
+  }
+  async retrieveEvents(e, r = !1) {
+    return this.requireReady(), await d.runExclusive(async () => {
+      try {
+        if (this.inProgress && !r)
+          return !1;
+        this.inProgress = !0;
+        let t = 0;
+        const i = await this.getLastBlockNumberForEventRequest();
+        if (i < e)
+          return this.inProgress = !1, !1;
+        const c = v(e, i, this.maxPageSize), o = [];
+        await m(
+          c.map(({ from: s, to: a }) => async () => {
+            const h = await this.contract.queryFilter("*", s, a);
+            o.push(...h);
+          })
+        );
+        const l = await Promise.all(
+          [...this.eventProcessors].map((s) => s(o))
+        );
+        return this._latestBlockNumber = i, t += l.reduce((s, a) => s + a, 0), this.onEventsProcessed?.(t), this.inProgress = !1, !0;
+      } catch (t) {
+        return console.log("retrieveEvents error:", { err: t }), this.inProgress = !1, !1;
+      }
+    });
+  }
+}
+export {
+  B as BlockchainEventEmitter
+};

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

@@ -0,0 +1,7 @@
+export * from './AbstractAccessTokenSnapshotService';
+export * from './AbstractCommitmentsSnapshotService';
+export * from './AbstractApprovalsSnapshotService';
+export * from './AbstractNullifierSnapshotService';
+export * from './AbstractSnapshotService';
+export * from './AbstractEventService';
+export * from './BlockchainEventEmitter';

package/data-structures/index.d.ts

@@ -0,0 +1,18 @@
+export * from './ValueCache';
+export * from './crypto-keys';
+export * from './Hinkal';
+export * from './merkle-tree';
+export * from './provider-adapter/IProviderAdapter';
+export * from './event-service';
+export * from './utxo/Utxo';
+export * from './custom-token-registry/CustomTokenRegistry';
+export * from './token-price-fetcher';
+export * from './transactions-manager';
+export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
+export * from './cacheDevices';
+export * from './IndexedDB';
+export * from './TokenDBs';
+export * from './presale';
+export * from './snapshot';
+export * from './tor';
+export * from './ApprovalDBs';

package/data-structures/merkle-tree/MerkleTree.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../constants/protocol.constants.cjs"),c=require("../../error-handling/logError.cjs"),u=require("./MerkleTreeIncompleteError.cjs");class l{constructor(t,e,r,n,s,i,h){this.hashFunction=t,this.levels=e,this.defaultNodeValue=r,this.tree=n??new Map,this.count=h??0n,this.index=i??2n**(e-1n),s?this.reverseTree=s:this.reverseTree=this.createReverseTree()}tree;count;index;reverseTree;static createWithData(t,e,r,n,s,i,h){return new l(s,i,h,t,e,r,n)}static create(t,e,r=o.MERKLE_LEVELS){return new l(t,r,e)}createReverseTree(){const t=new Map;for(let e=this.getStartIndex();e<this.getStartIndex()+this.count;e+=1n){const r=this.tree.get(e);r!==void 0&&t.set(r,e)}return t}getStartIndex(){return 2n**(this.levels-1n)}logarithm2(t){let e=0n;for(;2n**e<t;)e+=1n;return e}bigIntMax(t,e){return t>e?t:e}forceInsert(t,e){if(e<this.getStartIndex())throw new RangeError;this.tree.set(e,t),this.reverseTree.set(t,e);const r=this.index-this.getStartIndex(),n=this.logarithm2(r);let s=e;for(let i=1n;i<=n;i+=1n){s/=2n;const h=this.hashFunction(this.tree.get(s*2n)||this.defaultNodeValue,this.tree.get(s*2n+1n)||this.defaultNodeValue);this.tree.set(s,h)}}insert(t,e){let r=!1;return this.tree.has(e)&&(r=!0,c.logError(`Editing commitment index: ${e} `)),r||(this.count+=1n),this.index=this.bigIntMax(this.index,e+1n),this.forceInsert(t,e),!0}remove(t){this.forceInsert(this.defaultNodeValue,t)}completenessCheck(){if(this.count!==this.index-this.getStartIndex())throw new u.MerkleTreeIncompleteError}getRootHash(){this.completenessCheck();for(let t=1n;t<2n**this.levels;t*=2n)if(this.tree.get(t))return this.tree.get(t);return this.defaultNodeValue}getMerkleData(){return this.completenessCheck(),new Map(this.tree)}getSiblingIndex(t){return t===1n?1n:t%2n===1n?t-1n:t+1n}getSiblingHashesForVerification(t){this.completenessCheck();let e=this.reverseTree.get(t);if(e===void 0)return new Array(Number(o.CIRCOM_MERKLE_LENGTH)).fill(0n);const r=[];for(;e!==0n;)r.push(this.tree.get(this.getSiblingIndex(e))||this.defaultNodeValue),e/=2n;return r.slice(0,o.CIRCOM_MERKLE_LENGTH)}getSiblingSides(t){this.completenessCheck();let e=this.reverseTree.get(t);if(e===void 0)return new Array(Number(o.CIRCOM_MERKLE_LENGTH)).fill(0n);const r=[];for(;e!==0n;){const n=e%2n===0n?0n:1n;r.push(n),e/=2n}return r.slice(0,o.CIRCOM_MERKLE_LENGTH)}toJSON(){const{tree:t,reverseTree:e,count:r,index:n}=this;return{tree:Object.fromEntries(t),reverseTree:Object.fromEntries(e),count:r.toString(),index:n.toString()}}clone(){return l.createWithData(new Map(this.tree),new Map(this.reverseTree),this.index,this.count,this.hashFunction,this.levels,this.defaultNodeValue)}getIndex(){return this.index}}exports.MerkleTree=l;

package/data-structures/merkle-tree/MerkleTree.d.ts

@@ -0,0 +1,81 @@
+export type MerkleTreeJson = {
+    tree: Record<string, string>;
+    reverseTree?: Record<string, string>;
+    count: string;
+    index: string;
+};
+/**
+ * Merkle tree implementation that allows the user to insert in specific places in the tree
+ *
+ */
+export declare class MerkleTree<T> {
+    private hashFunction;
+    private levels;
+    private defaultNodeValue;
+    /**
+     * the map where the items are stored
+     */
+    private readonly tree;
+    /**
+     * amount of elements inserted inside the bottom row of the tree
+     */
+    private count;
+    /**
+     * the maximum index inserted into the tree
+     * used together with count to make sure that the merkle tree is complete.
+     * meaning that there aren't any missing elements between getStartIndex() and index
+     */
+    private index;
+    private reverseTree;
+    static createWithData<T>(tree: Map<bigint, T>, reverseTree: Map<T, bigint> | undefined, index: bigint, count: bigint, hashFunction: (a: T, b: T) => T, levels: bigint, defaultNodeValue: T): MerkleTree<T>;
+    /**
+     * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+     * @param levels the amount of layers in the merkle tree
+     * @param defaultNodeValue the default value of an empty node in the merkle tree
+     */
+    static create<T>(hashFunction: (a: T, b: T) => T, defaultNodeValue: T, levels?: bigint): MerkleTree<T>;
+    private createReverseTree;
+    private constructor();
+    /**
+     * get starting nodeIndex from which inserts are allowed
+     */
+    getStartIndex(): bigint;
+    /**
+     * implementation of logarithm2 function from merkle contract
+     */
+    logarithm2(a: bigint): bigint;
+    bigIntMax(a: bigint, b: bigint): bigint;
+    private forceInsert;
+    /**
+     * insert value into the merkle tree
+     * @param value the value to insert
+     * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+     * @return true - if added, false - if already exists
+     * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+     */
+    insert(value: T, nodeIndex: bigint): boolean;
+    remove(nodeIndex: bigint): void;
+    private completenessCheck;
+    /**
+     * get root hash of the merkle tree
+     * @returns the hash, if the merkle tree is empty, will return
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getRootHash(): T | undefined;
+    getMerkleData(): Map<bigint, T>;
+    getSiblingIndex(index: bigint): bigint;
+    /**
+     * get sibling hashes needed by main.circom
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getSiblingHashesForVerification(item: T): bigint[] | T[];
+    /**
+     * get item's sibling hashes side
+     * @returns sibling's indexes
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getSiblingSides(item: T): bigint[];
+    toJSON(): MerkleTreeJson;
+    clone(): MerkleTree<T>;
+    getIndex(): bigint;
+}

package/data-structures/merkle-tree/MerkleTree.mjs

@@ -0,0 +1,168 @@
+import { MERKLE_LEVELS as a, CIRCOM_MERKLE_LENGTH as o } from "../../constants/protocol.constants.mjs";
+import { logError as u } from "../../error-handling/logError.mjs";
+import { MerkleTreeIncompleteError as c } from "./MerkleTreeIncompleteError.mjs";
+class l {
+  constructor(t, e, r, i, s, n, h) {
+    this.hashFunction = t, this.levels = e, this.defaultNodeValue = r, this.tree = i ?? /* @__PURE__ */ new Map(), this.count = h ?? 0n, this.index = n ?? 2n ** (e - 1n), s ? this.reverseTree = s : this.reverseTree = this.createReverseTree();
+  }
+  /**
+   * the map where the items are stored
+   */
+  tree;
+  /**
+   * amount of elements inserted inside the bottom row of the tree
+   */
+  count;
+  /**
+   * the maximum index inserted into the tree
+   * used together with count to make sure that the merkle tree is complete.
+   * meaning that there aren't any missing elements between getStartIndex() and index
+   */
+  index;
+  reverseTree;
+  static createWithData(t, e, r, i, s, n, h) {
+    return new l(s, n, h, t, e, r, i);
+  }
+  /**
+   * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+   * @param levels the amount of layers in the merkle tree
+   * @param defaultNodeValue the default value of an empty node in the merkle tree
+   */
+  static create(t, e, r = a) {
+    return new l(t, r, e);
+  }
+  createReverseTree() {
+    const t = /* @__PURE__ */ new Map();
+    for (let e = this.getStartIndex(); e < this.getStartIndex() + this.count; e += 1n) {
+      const r = this.tree.get(e);
+      r !== void 0 && t.set(r, e);
+    }
+    return t;
+  }
+  /**
+   * get starting nodeIndex from which inserts are allowed
+   */
+  getStartIndex() {
+    return 2n ** (this.levels - 1n);
+  }
+  /**
+   * implementation of logarithm2 function from merkle contract
+   */
+  logarithm2(t) {
+    let e = 0n;
+    for (; 2n ** e < t; )
+      e += 1n;
+    return e;
+  }
+  bigIntMax(t, e) {
+    return t > e ? t : e;
+  }
+  forceInsert(t, e) {
+    if (e < this.getStartIndex())
+      throw new RangeError();
+    this.tree.set(e, t), this.reverseTree.set(t, e);
+    const r = this.index - this.getStartIndex(), i = this.logarithm2(r);
+    let s = e;
+    for (let n = 1n; n <= i; n += 1n) {
+      s /= 2n;
+      const h = this.hashFunction(
+        this.tree.get(s * 2n) || this.defaultNodeValue,
+        this.tree.get(s * 2n + 1n) || this.defaultNodeValue
+      );
+      this.tree.set(s, h);
+    }
+  }
+  /**
+   * insert value into the merkle tree
+   * @param value the value to insert
+   * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+   * @return true - if added, false - if already exists
+   * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+   */
+  insert(t, e) {
+    let r = !1;
+    return this.tree.has(e) && (r = !0, u(`Editing commitment index: ${e} `)), r || (this.count += 1n), this.index = this.bigIntMax(this.index, e + 1n), this.forceInsert(t, e), !0;
+  }
+  remove(t) {
+    this.forceInsert(this.defaultNodeValue, t);
+  }
+  completenessCheck() {
+    if (this.count !== this.index - this.getStartIndex())
+      throw new c();
+  }
+  /**
+   * get root hash of the merkle tree
+   * @returns the hash, if the merkle tree is empty, will return
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getRootHash() {
+    this.completenessCheck();
+    for (let t = 1n; t < 2n ** this.levels; t *= 2n)
+      if (this.tree.get(t))
+        return this.tree.get(t);
+    return this.defaultNodeValue;
+  }
+  getMerkleData() {
+    return this.completenessCheck(), new Map(this.tree);
+  }
+  getSiblingIndex(t) {
+    return t === 1n ? 1n : t % 2n === 1n ? t - 1n : t + 1n;
+  }
+  /**
+   * get sibling hashes needed by main.circom
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingHashesForVerification(t) {
+    this.completenessCheck();
+    let e = this.reverseTree.get(t);
+    if (e === void 0)
+      return new Array(Number(o)).fill(0n);
+    const r = [];
+    for (; e !== 0n; )
+      r.push(this.tree.get(this.getSiblingIndex(e)) || this.defaultNodeValue), e /= 2n;
+    return r.slice(0, o);
+  }
+  /**
+   * get item's sibling hashes side
+   * @returns sibling's indexes
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingSides(t) {
+    this.completenessCheck();
+    let e = this.reverseTree.get(t);
+    if (e === void 0)
+      return new Array(Number(o)).fill(0n);
+    const r = [];
+    for (; e !== 0n; ) {
+      const i = e % 2n === 0n ? 0n : 1n;
+      r.push(i), e /= 2n;
+    }
+    return r.slice(0, o);
+  }
+  toJSON() {
+    const { tree: t, reverseTree: e, count: r, index: i } = this;
+    return {
+      tree: Object.fromEntries(t),
+      reverseTree: Object.fromEntries(e),
+      count: r.toString(),
+      index: i.toString()
+    };
+  }
+  clone() {
+    return l.createWithData(
+      new Map(this.tree),
+      new Map(this.reverseTree),
+      this.index,
+      this.count,
+      this.hashFunction,
+      this.levels,
+      this.defaultNodeValue
+    );
+  }
+  getIndex() {
+    return this.index;
+  }
+}
+export {
+  l as MerkleTree
+};

package/data-structures/merkle-tree/MerkleTreeIncompleteError.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e extends Error{constructor(){super("Merkle tree is incomplete"),this.name="MerkleTreeIncompleteError"}}exports.MerkleTreeIncompleteError=e;

package/data-structures/merkle-tree/MerkleTreeIncompleteError.d.ts

@@ -0,0 +1,3 @@
+export declare class MerkleTreeIncompleteError extends Error {
+    constructor();
+}

package/data-structures/merkle-tree/MerkleTreeIncompleteError.mjs

@@ -0,0 +1,8 @@
+class r extends Error {
+  constructor() {
+    super("Merkle tree is incomplete"), this.name = "MerkleTreeIncompleteError";
+  }
+}
+export {
+  r as MerkleTreeIncompleteError
+};

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../functions/web3/etherFunctions.cjs"),c=require("../../crypto/poseidon.cjs"),i=require("./MerkleTree.cjs"),g=(r,n,o,t)=>{if(!t||o){const e=i.MerkleTree.create(c.poseidonFunction,0n);return e.insert(BigInt(n.getAccessKey()),e.getStartIndex()),t||e.insert(s.randomBigInt(31),e.getStartIndex()+1n),e}return r};exports.getPatchedAccessTokenMerkleTree=g;

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.d.ts

@@ -0,0 +1,3 @@
+import { UserKeys } from '../crypto-keys/keys';
+import { MerkleTree } from './MerkleTree';
+export declare const getPatchedAccessTokenMerkleTree: (merkleTreeAccessToken: MerkleTree<bigint>, userKeys: UserKeys, patchAccessTokenMerkleTree: boolean, kycRequired: boolean) => MerkleTree<bigint>;

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.mjs

@@ -0,0 +1,13 @@
+import { randomBigInt as i } from "../../functions/web3/etherFunctions.mjs";
+import { poseidonFunction as s } from "../../crypto/poseidon.mjs";
+import { MerkleTree as c } from "./MerkleTree.mjs";
+const f = (r, n, o, t) => {
+  if (!t || o) {
+    const e = c.create(s, 0n);
+    return e.insert(BigInt(n.getAccessKey()), e.getStartIndex()), t || e.insert(i(31), e.getStartIndex() + 1n), e;
+  }
+  return r;
+};
+export {
+  f as getPatchedAccessTokenMerkleTree
+};

package/data-structures/merkle-tree/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MerkleTree';
+export * from './getPatchedAccessTokenMerkleTree';
+export * from './MerkleTreeIncompleteError';

package/data-structures/presale/PresaleContractWrapper.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../../constants/presale.constants.cjs"),s=require("ethers");class o{contract;eventsFrom;constructor(t,e){const{address:r,eventsFrom:a}=n.presaleContractInfoByChain[e];this.contract=new s.ethers.Contract(r,n.presaleABI,t),this.eventsFrom=a}deposit(t,e,r){return this.contract.deposit(t.erc20TokenAddress,e,r)}withdraw(t,e){return this.contract.withdraw(t,e)}moveToNextStage(t){return this.contract.moveToNextStage(t||{})}async estimateMoveToNextStageGas(){return(await this.contract.estimateGas.moveToNextStage()).toBigInt()}async getTotalDeposit(){return(await this.contract.totalDeposit()).toBigInt()}async getDeposits(t,e){return(await this.contract.deposits(t,e.erc20TokenAddress)).toBigInt()}async getTotalHINK(t){return(await this.contract.totalHINK(t)).toBigInt()}async getCurrentPresaleStageIndex(){const t=await this.contract.currentPresaleStageIndex();return Number(t)}async getCurrentMaxDepositAmount(){return(await this.contract.currentMaxDepositAmount()).toBigInt()}async currentPresaleStage(){const[t,e]=await this.contract.currentPresaleStage(),[r,a]=[t,e].map(BigInt);return{amountToRaise:r,priceMultiplier:a}}async calculateHINK(t){return(await this.contract.calculateHINK(t)).toBigInt()}async queryDeposits(){return this.contract.queryFilter(this.contract.filters.Deposit(),this.eventsFrom)}onEvent(t,e){this.contract.on(t,e)}}exports.PresaleContractWrapper=o;

package/data-structures/presale/PresaleContractWrapper.d.ts

@@ -0,0 +1,23 @@
+import { ERC20Token } from '../../types/token.types';
+import { ethers } from 'ethers';
+export declare class PresaleContractWrapper {
+    contract: ethers.Contract;
+    eventsFrom: number;
+    constructor(signerOrProvider: ethers.Signer | ethers.providers.Provider, chainId: number);
+    deposit(token: ERC20Token, amount: bigint, minHINK: bigint): Promise<ethers.ContractTransaction>;
+    withdraw(token: string, amount: bigint): Promise<ethers.ContractTransaction>;
+    moveToNextStage(overrides?: ethers.Overrides): Promise<ethers.ContractTransaction>;
+    estimateMoveToNextStageGas(): Promise<bigint>;
+    getTotalDeposit(): Promise<bigint>;
+    getDeposits(depositor: string, token: ERC20Token): Promise<bigint>;
+    getTotalHINK(depositor: string): Promise<bigint>;
+    getCurrentPresaleStageIndex(): Promise<number>;
+    getCurrentMaxDepositAmount(): Promise<bigint>;
+    currentPresaleStage(): Promise<{
+        amountToRaise: bigint;
+        priceMultiplier: bigint;
+    }>;
+    calculateHINK(amount: bigint): Promise<bigint>;
+    queryDeposits(): Promise<ethers.Event[]>;
+    onEvent(eventName: string, handleEvent: ethers.providers.Listener): void;
+}

package/data-structures/presale/PresaleContractWrapper.mjs

@@ -0,0 +1,54 @@
+import { presaleContractInfoByChain as n, presaleABI as o } from "../../constants/presale.constants.mjs";
+import { ethers as s } from "ethers";
+class l {
+  contract;
+  eventsFrom;
+  constructor(t, e) {
+    const { address: r, eventsFrom: a } = n[e];
+    this.contract = new s.Contract(r, o, t), this.eventsFrom = a;
+  }
+  deposit(t, e, r) {
+    return this.contract.deposit(t.erc20TokenAddress, e, r);
+  }
+  withdraw(t, e) {
+    return this.contract.withdraw(t, e);
+  }
+  moveToNextStage(t) {
+    return this.contract.moveToNextStage(t || {});
+  }
+  async estimateMoveToNextStageGas() {
+    return (await this.contract.estimateGas.moveToNextStage()).toBigInt();
+  }
+  async getTotalDeposit() {
+    return (await this.contract.totalDeposit()).toBigInt();
+  }
+  async getDeposits(t, e) {
+    return (await this.contract.deposits(t, e.erc20TokenAddress)).toBigInt();
+  }
+  async getTotalHINK(t) {
+    return (await this.contract.totalHINK(t)).toBigInt();
+  }
+  async getCurrentPresaleStageIndex() {
+    const t = await this.contract.currentPresaleStageIndex();
+    return Number(t);
+  }
+  async getCurrentMaxDepositAmount() {
+    return (await this.contract.currentMaxDepositAmount()).toBigInt();
+  }
+  async currentPresaleStage() {
+    const [t, e] = await this.contract.currentPresaleStage(), [r, a] = [t, e].map(BigInt);
+    return { amountToRaise: r, priceMultiplier: a };
+  }
+  async calculateHINK(t) {
+    return (await this.contract.calculateHINK(t)).toBigInt();
+  }
+  async queryDeposits() {
+    return this.contract.queryFilter(this.contract.filters.Deposit(), this.eventsFrom);
+  }
+  onEvent(t, e) {
+    this.contract.on(t, e);
+  }
+}
+export {
+  l as PresaleContractWrapper
+};

package/data-structures/presale/index.d.ts

@@ -0,0 +1 @@
+export * from './PresaleContractWrapper';