@kapa123456789/sdk 0.0.1

package/common/src/data-structures/http/HttpClient.cjs

@@ -0,0 +1 @@
+var e=new(require(`./BasicHttpClient.cjs`)).BasicHttpClient,t={setHttpClient:t=>{e=t},get:(t,n)=>e.get(t,n),post:(t,n,r)=>e.post(t,n,r),put:(t,n,r)=>e.put(t,n,r),patch:(t,n,r)=>e.patch(t,n,r),delete:(t,n)=>e.delete(t,n)};exports.httpClient=t;

package/common/src/data-structures/http/HttpClient.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../types/http.types';
+declare const httpClient: {
+    setHttpClient: (client: HttpClient) => void;
+    get: <T = any>(url: string, config?: any) => Promise<T>;
+    post: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
+    put: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
+    patch: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
+    delete: <T = any>(url: string, config?: any) => Promise<T>;
+};
+export { httpClient };

package/common/src/data-structures/http/HttpClient.mjs

@@ -0,0 +1,14 @@
+import { BasicHttpClient as e } from "./BasicHttpClient.mjs";
+//#region libs/shared/common/src/data-structures/http/HttpClient.ts
+var t = new e(), n = {
+	setHttpClient: (e) => {
+		t = e;
+	},
+	get: (e, n) => t.get(e, n),
+	post: (e, n, r) => t.post(e, n, r),
+	put: (e, n, r) => t.put(e, n, r),
+	patch: (e, n, r) => t.patch(e, n, r),
+	delete: (e, n) => t.delete(e, n)
+};
+//#endregion
+export { n as httpClient };

package/common/src/data-structures/http/index.cjs

@@ -0,0 +1 @@
+require(`./BasicHttpClient.cjs`),require(`./HttpClient.cjs`);

package/common/src/data-structures/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HttpClient';
+export * from './BasicHttpClient';

package/common/src/data-structures/http/index.mjs

@@ -0,0 +1,2 @@
+import "./BasicHttpClient.mjs";
+import "./HttpClient.mjs";

package/common/src/data-structures/index.d.ts

@@ -0,0 +1,20 @@
+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 './http';
+export * from './ApprovalDBs';
+export * from './BlockchainEvent/BlockchainEvent';
+export * from './AccountActions';

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

@@ -0,0 +1 @@
+const e=require(`../../constants/protocol.constants.cjs`),t=require(`../../error-handling/logError.cjs`),n=require(`./MerkleTreeIncompleteError.cjs`);var r=class r{tree;count;index;reverseTree;static createWithData(e,t,n,i,a,o,s){return new r(a,o,s,e,t,n,i)}static create(t,n,i=e.MERKLE_LEVELS){return new r(t,i,n)}createReverseTree(){let e=new Map;for(let t=this.getStartIndex();t<this.getStartIndex()+this.count;t+=1n){let n=this.tree.get(t);n!==void 0&&e.set(n,t)}return e}constructor(e,t,n,r,i,a,o){this.hashFunction=e,this.levels=t,this.defaultNodeValue=n,this.tree=r??new Map,this.count=o??0n,this.index=a??2n**(t-1n),i?this.reverseTree=i:this.reverseTree=this.createReverseTree()}getStartIndex(){return 2n**(this.levels-1n)}logarithm2(e){let t=0n;for(;2n**t<e;)t+=1n;return t}bigIntMax(e,t){return e>t?e:t}forceInsert(e,t){if(t<this.getStartIndex())throw RangeError();this.tree.set(t,e),this.reverseTree.set(e,t);let n=this.index-this.getStartIndex(),r=this.logarithm2(n),i=t;for(let e=1n;e<=r;e+=1n){i/=2n;let e=this.hashFunction(this.tree.get(i*2n)||this.defaultNodeValue,this.tree.get(i*2n+1n)||this.defaultNodeValue);this.tree.set(i,e)}}insert(e,n){let r=!1;this.tree.has(n)&&(r=!0,t.logError(`Editing commitment index: ${n} `)),r||(this.count+=1n),this.index=this.bigIntMax(this.index,n+1n),this.forceInsert(e,n)}remove(e){this.forceInsert(this.defaultNodeValue,e)}completenessCheck(){if(this.count!==this.index-this.getStartIndex())throw new n.MerkleTreeIncompleteError}getRootHash(){this.completenessCheck();for(let e=1n;e<2n**this.levels;e*=2n)if(this.tree.get(e))return this.tree.get(e);return this.defaultNodeValue}getMerkleData(){return this.completenessCheck(),new Map(this.tree)}getValue(e){return this.tree.get(e)}getSiblingIndex(e){return e===1n?1n:e%2n==1n?e-1n:e+1n}getSiblingHashesForVerification(e){this.completenessCheck();let t=this.reverseTree.get(e);if(t===void 0)return Array(25).fill(0n);let n=[];for(;t!==0n;)n.push(this.tree.get(this.getSiblingIndex(t))||this.defaultNodeValue),t/=2n;return n.slice(0,25)}getSiblingSides(e){this.completenessCheck();let t=this.reverseTree.get(e);if(t===void 0)return Array(25).fill(0n);let n=[];for(;t!==0n;){let e=t%2n==0n?0n:1n;n.push(e),t/=2n}return n.slice(0,25)}toJSON(){let{tree:e,reverseTree:t,count:n,index:r}=this;return{tree:Object.fromEntries(e),reverseTree:Object.fromEntries(t),count:n.toString(),index:r.toString()}}toJSONLite(){let{tree:e,count:t,index:n}=this;return{tree:Object.fromEntries(e),count:t.toString(),index:n.toString()}}clone(){return r.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=r;

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

@@ -0,0 +1,82 @@
+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()
+     * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+     */
+    insert(value: T, nodeIndex: bigint): void;
+    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>;
+    getValue(index: bigint): T | undefined;
+    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;
+    toJSONLite(): MerkleTreeJson;
+    clone(): MerkleTree<T>;
+    getIndex(): bigint;
+}

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

@@ -0,0 +1,116 @@
+import { MERKLE_LEVELS as e } from "../../constants/protocol.constants.mjs";
+import { logError as t } from "../../error-handling/logError.mjs";
+import { MerkleTreeIncompleteError as n } from "./MerkleTreeIncompleteError.mjs";
+//#region libs/shared/common/src/data-structures/merkle-tree/MerkleTree.ts
+var r = class r {
+	tree;
+	count;
+	index;
+	reverseTree;
+	static createWithData(e, t, n, i, a, o, s) {
+		return new r(a, o, s, e, t, n, i);
+	}
+	static create(t, n, i = e) {
+		return new r(t, i, n);
+	}
+	createReverseTree() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t = this.getStartIndex(); t < this.getStartIndex() + this.count; t += 1n) {
+			let n = this.tree.get(t);
+			n !== void 0 && e.set(n, t);
+		}
+		return e;
+	}
+	constructor(e, t, n, r, i, a, o) {
+		this.hashFunction = e, this.levels = t, this.defaultNodeValue = n, this.tree = r ?? /* @__PURE__ */ new Map(), this.count = o ?? 0n, this.index = a ?? 2n ** (t - 1n), i ? this.reverseTree = i : this.reverseTree = this.createReverseTree();
+	}
+	getStartIndex() {
+		return 2n ** (this.levels - 1n);
+	}
+	logarithm2(e) {
+		let t = 0n;
+		for (; 2n ** t < e;) t += 1n;
+		return t;
+	}
+	bigIntMax(e, t) {
+		return e > t ? e : t;
+	}
+	forceInsert(e, t) {
+		if (t < this.getStartIndex()) throw RangeError();
+		this.tree.set(t, e), this.reverseTree.set(e, t);
+		let n = this.index - this.getStartIndex(), r = this.logarithm2(n), i = t;
+		for (let e = 1n; e <= r; e += 1n) {
+			i /= 2n;
+			let e = this.hashFunction(this.tree.get(i * 2n) || this.defaultNodeValue, this.tree.get(i * 2n + 1n) || this.defaultNodeValue);
+			this.tree.set(i, e);
+		}
+	}
+	insert(e, n) {
+		let r = !1;
+		this.tree.has(n) && (r = !0, t(`Editing commitment index: ${n} `)), r || (this.count += 1n), this.index = this.bigIntMax(this.index, n + 1n), this.forceInsert(e, n);
+	}
+	remove(e) {
+		this.forceInsert(this.defaultNodeValue, e);
+	}
+	completenessCheck() {
+		if (this.count !== this.index - this.getStartIndex()) throw new n();
+	}
+	getRootHash() {
+		this.completenessCheck();
+		for (let e = 1n; e < 2n ** this.levels; e *= 2n) if (this.tree.get(e)) return this.tree.get(e);
+		return this.defaultNodeValue;
+	}
+	getMerkleData() {
+		return this.completenessCheck(), new Map(this.tree);
+	}
+	getValue(e) {
+		return this.tree.get(e);
+	}
+	getSiblingIndex(e) {
+		return e === 1n ? 1n : e % 2n == 1n ? e - 1n : e + 1n;
+	}
+	getSiblingHashesForVerification(e) {
+		this.completenessCheck();
+		let t = this.reverseTree.get(e);
+		if (t === void 0) return Array(25).fill(0n);
+		let n = [];
+		for (; t !== 0n;) n.push(this.tree.get(this.getSiblingIndex(t)) || this.defaultNodeValue), t /= 2n;
+		return n.slice(0, 25);
+	}
+	getSiblingSides(e) {
+		this.completenessCheck();
+		let t = this.reverseTree.get(e);
+		if (t === void 0) return Array(25).fill(0n);
+		let n = [];
+		for (; t !== 0n;) {
+			let e = t % 2n == 0n ? 0n : 1n;
+			n.push(e), t /= 2n;
+		}
+		return n.slice(0, 25);
+	}
+	toJSON() {
+		let { tree: e, reverseTree: t, count: n, index: r } = this;
+		return {
+			tree: Object.fromEntries(e),
+			reverseTree: Object.fromEntries(t),
+			count: n.toString(),
+			index: r.toString()
+		};
+	}
+	toJSONLite() {
+		let { tree: e, count: t, index: n } = this;
+		return {
+			tree: Object.fromEntries(e),
+			count: t.toString(),
+			index: n.toString()
+		};
+	}
+	clone() {
+		return r.createWithData(new Map(this.tree), new Map(this.reverseTree), this.index, this.count, this.hashFunction, this.levels, this.defaultNodeValue);
+	}
+	getIndex() {
+		return this.index;
+	}
+};
+//#endregion
+export { r as MerkleTree };

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

@@ -0,0 +1 @@
+var e=class extends Error{constructor(){super(`Merkle tree is incomplete`),this.name=`MerkleTreeIncompleteError`}};exports.MerkleTreeIncompleteError=e;

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

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

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

@@ -0,0 +1,8 @@
+//#region libs/shared/common/src/data-structures/merkle-tree/MerkleTreeIncompleteError.ts
+var e = class extends Error {
+	constructor() {
+		super("Merkle tree is incomplete"), this.name = "MerkleTreeIncompleteError";
+	}
+};
+//#endregion
+export { e as MerkleTreeIncompleteError };

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

@@ -0,0 +1 @@
+const e=require(`../../crypto/poseidon.cjs`),t=require(`../../functions/web3/etherFunctions.cjs`),n=require(`./MerkleTree.cjs`);var r=(r,i,a,o)=>{if(!o||a){let r=n.MerkleTree.create(e.poseidonFunction,0n);return r.insert(BigInt(i),r.getStartIndex()),o||r.insert(t.randomBigInt(31),r.getStartIndex()+1n),r}return r};exports.getPatchedAccessTokenMerkleTree=r;

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

@@ -0,0 +1,2 @@
+import { MerkleTree } from './MerkleTree';
+export declare const getPatchedAccessTokenMerkleTree: (merkleTreeAccessToken: MerkleTree<bigint>, accessKey: string, patchAccessTokenMerkleTree: boolean, kycRequired: boolean) => MerkleTree<bigint>;

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

@@ -0,0 +1,13 @@
+import { poseidonFunction as e } from "../../crypto/poseidon.mjs";
+import { randomBigInt as t } from "../../functions/web3/etherFunctions.mjs";
+import { MerkleTree as n } from "./MerkleTree.mjs";
+//#region libs/shared/common/src/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.ts
+var r = (r, i, a, o) => {
+	if (!o || a) {
+		let r = n.create(e, 0n);
+		return r.insert(BigInt(i), r.getStartIndex()), o || r.insert(t(31), r.getStartIndex() + 1n), r;
+	}
+	return r;
+};
+//#endregion
+export { r as getPatchedAccessTokenMerkleTree };

package/common/src/data-structures/merkle-tree/index.cjs

@@ -0,0 +1 @@
+require(`./MerkleTreeIncompleteError.cjs`),require(`./MerkleTree.cjs`),require(`./getPatchedAccessTokenMerkleTree.cjs`);

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

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

package/common/src/data-structures/merkle-tree/index.mjs

@@ -0,0 +1,3 @@
+import "./MerkleTreeIncompleteError.mjs";
+import "./MerkleTree.mjs";
+import "./getPatchedAccessTokenMerkleTree.mjs";

package/common/src/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.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.EventLog | ethers.Log)[]>;
+    onEvent(eventName: string, handleEvent: ethers.Listener): void;
+}

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

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

package/common/src/data-structures/provider-adapter/IProviderAdapter.d.ts

@@ -0,0 +1,40 @@
+import { ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { ethers } from 'ethers';
+import { Call } from '../../types/eip5792.types';
+import { Transaction } from '@solana/web3.js';
+export interface ChainEventListener {
+    onAccountChanged(): void;
+    onChainChanged(chainId?: number): void;
+}
+export interface IProviderAdapter<ConnectorType = unknown> {
+    initConnector(connector: ConnectorType): void;
+    initSigner?(signer: ethers.Signer): void;
+    init(chainId?: number): Promise<void>;
+    initConfig?(config?: any): Promise<void> | void;
+    connectToConnector(connector: ConnectorType): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+    getChainId(): number | undefined;
+    waitForTransaction(chainId: number, transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    release(): void;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithSigner(chainId: number, contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(chainId: number, contract: ContractType, contractAddress?: string): ethers.Contract;
+    sendTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(chainId: number): Promise<bigint>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    sendBatchCallsTransaction?(chainId: number, calls: Call[]): Promise<ethers.TransactionResponse>;
+    supportsBatchCall?(chainId: number): Promise<boolean>;
+    signTransactionWithoutBroadcast?(tx: Transaction): Promise<{
+        signature: string;
+        transactionMessageB64: string;
+    }>;
+    isSolanaLedger?(): boolean;
+}

package/common/src/data-structures/snapshot/SnapshotFetcherService.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/caseInsensitive.utils.cjs`),t=require(`../../API/fetchCommitmentsCache.cjs`);var n=300*1e3,r=class{chainId;contractAddress;snapshotsPromise;lastFetchedAt;cacheDurationMs;constructor(e,t,r=n){this.chainId=e,this.contractAddress=t,this.cacheDurationMs=r}async fetchSnapshots(){return this.lastFetchedAt=Date.now(),t.fetchSnapshots(this.chainId)}async ensureSnapshots(t=!1){let n=Date.now(),r=!this.lastFetchedAt||n-this.lastFetchedAt>this.cacheDurationMs;(t||!this.snapshotsPromise||r)&&(this.snapshotsPromise=this.fetchSnapshots());let i=await this.snapshotsPromise;if(!e.caseInsensitiveEqual(i.commitments.hinkalAddress,this.contractAddress)||i.commitments.chainId!==this.chainId)throw Error(`Snapshots: incorrect contract or chain id`);return i}async getAll(e=!1){return this.ensureSnapshots(e)}async getCommitments(e=!1){return(await this.ensureSnapshots(e)).commitments}async getAccessTokens(e=!1){return(await this.ensureSnapshots(e)).accessTokens}async getNullifiers(e=!1){return(await this.ensureSnapshots(e)).nullifiers}};exports.SnapshotFetcherService=r;

package/common/src/data-structures/snapshot/SnapshotFetcherService.d.ts

@@ -0,0 +1,15 @@
+import { ISnapshotsResponse } from '../../API/fetchCommitmentsCache';
+export declare class SnapshotFetcherService {
+    private chainId;
+    private contractAddress;
+    private snapshotsPromise;
+    private lastFetchedAt;
+    private readonly cacheDurationMs;
+    constructor(chainId: number, contractAddress: string, cacheDurationMs?: number);
+    private fetchSnapshots;
+    private ensureSnapshots;
+    getAll(forceRefresh?: boolean): Promise<ISnapshotsResponse>;
+    getCommitments(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').ICommitmentsTreeSnapshot>;
+    getAccessTokens(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').IAccessTokenTreeSnapshot>;
+    getNullifiers(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').INullifiersSnapshot>;
+}

package/common/src/data-structures/snapshot/SnapshotFetcherService.mjs

@@ -0,0 +1,37 @@
+import { caseInsensitiveEqual as e } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { fetchSnapshots as t } from "../../API/fetchCommitmentsCache.mjs";
+//#region libs/shared/common/src/data-structures/snapshot/SnapshotFetcherService.ts
+var n = 300 * 1e3, r = class {
+	chainId;
+	contractAddress;
+	snapshotsPromise;
+	lastFetchedAt;
+	cacheDurationMs;
+	constructor(e, t, r = n) {
+		this.chainId = e, this.contractAddress = t, this.cacheDurationMs = r;
+	}
+	async fetchSnapshots() {
+		return this.lastFetchedAt = Date.now(), t(this.chainId);
+	}
+	async ensureSnapshots(t = !1) {
+		let n = Date.now(), r = !this.lastFetchedAt || n - this.lastFetchedAt > this.cacheDurationMs;
+		(t || !this.snapshotsPromise || r) && (this.snapshotsPromise = this.fetchSnapshots());
+		let i = await this.snapshotsPromise;
+		if (!e(i.commitments.hinkalAddress, this.contractAddress) || i.commitments.chainId !== this.chainId) throw Error("Snapshots: incorrect contract or chain id");
+		return i;
+	}
+	async getAll(e = !1) {
+		return this.ensureSnapshots(e);
+	}
+	async getCommitments(e = !1) {
+		return (await this.ensureSnapshots(e)).commitments;
+	}
+	async getAccessTokens(e = !1) {
+		return (await this.ensureSnapshots(e)).accessTokens;
+	}
+	async getNullifiers(e = !1) {
+		return (await this.ensureSnapshots(e)).nullifiers;
+	}
+};
+//#endregion
+export { r as SnapshotFetcherService };

package/common/src/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/getContractAddress.cjs`),t=require(`../../../functions/utils/getSignerFromContract.cjs`),n=require(`../../event-service/evm/AbstractAccessTokenSnapshotService.cjs`);require(`../../event-service/index.cjs`);const r=require(`../SnapshotFetcherService.cjs`);var i=class extends n.AbstractAccessTokenSnapshotService{snapshotsService;constructor(e,t){super(e),this.snapshotsService=t}async fetchSnapshot(){let{contract:n}=this.blockchainEventEmitter,{chainId:i}=await t.getProviderFromContract(n).getNetwork(),a=Number(i);this.snapshotsService||=new r.SnapshotFetcherService(a,e.getContractAddress(n));let o=await this.snapshotsService.getAccessTokens();if(o.accessTokenContractAddress!==e.getContractAddress(n)||o.chainId!==a)throw Error(`Commitment Snapshot: incorrect contract or chain id`);return{latestBlockNumber:o.latestBlockNumber,merkleTree:o.merkleTree,senderAddresses:o.senderAddresses,senderAddressIndexMap:o.senderAddressIndexMap}}persistSnapshot(e){return Promise.resolve()}};exports.ClientAccessTokenSnapshotService=i;

package/common/src/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
+    private snapshotsService;
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<AccessTokenSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: AccessTokenSerializedSnapshot): Promise<unknown>;
+}

package/common/src/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.mjs

@@ -0,0 +1,29 @@
+import { getContractAddress as e } from "../../../functions/utils/getContractAddress.mjs";
+import { getProviderFromContract as t } from "../../../functions/utils/getSignerFromContract.mjs";
+import { AbstractAccessTokenSnapshotService as n } from "../../event-service/evm/AbstractAccessTokenSnapshotService.mjs";
+import "../../event-service/index.mjs";
+import { SnapshotFetcherService as r } from "../SnapshotFetcherService.mjs";
+//#region libs/shared/common/src/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.ts
+var i = class extends n {
+	snapshotsService;
+	constructor(e, t) {
+		super(e), this.snapshotsService = t;
+	}
+	async fetchSnapshot() {
+		let { contract: n } = this.blockchainEventEmitter, { chainId: i } = await t(n).getNetwork(), a = Number(i);
+		this.snapshotsService ||= new r(a, e(n));
+		let o = await this.snapshotsService.getAccessTokens();
+		if (o.accessTokenContractAddress !== e(n) || o.chainId !== a) throw Error("Commitment Snapshot: incorrect contract or chain id");
+		return {
+			latestBlockNumber: o.latestBlockNumber,
+			merkleTree: o.merkleTree,
+			senderAddresses: o.senderAddresses,
+			senderAddressIndexMap: o.senderAddressIndexMap
+		};
+	}
+	persistSnapshot(e) {
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { i as ClientAccessTokenSnapshotService };

package/common/src/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../event-service/evm/AbstractCommitmentsSnapshotService.cjs`);require(`../../event-service/index.cjs`);var t=class extends e.AbstractCommitmentsSnapshotService{snapshotsService;constructor(e,t){super(e),this.snapshotsService=t}async fetchSnapshot(){let e=await this.snapshotsService.getCommitments();return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,encryptedOutputs:e.encryptedOutputs,encryptedOutputsByCommitment:e.encryptedOutputsByCommitment}}persistSnapshot(e){return Promise.resolve()}};exports.ClientCommitmentsSnapshotService=t;

package/common/src/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCommitmentsSnapshotService, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<CommitmentsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/common/src/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.mjs

@@ -0,0 +1,23 @@
+import { AbstractCommitmentsSnapshotService as e } from "../../event-service/evm/AbstractCommitmentsSnapshotService.mjs";
+import "../../event-service/index.mjs";
+//#region libs/shared/common/src/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.ts
+var t = class extends e {
+	snapshotsService;
+	constructor(e, t) {
+		super(e), this.snapshotsService = t;
+	}
+	async fetchSnapshot() {
+		let e = await this.snapshotsService.getCommitments();
+		return {
+			latestBlockNumber: e.latestBlockNumber,
+			merkleTree: e.merkleTree,
+			encryptedOutputs: e.encryptedOutputs,
+			encryptedOutputsByCommitment: e.encryptedOutputsByCommitment
+		};
+	}
+	persistSnapshot(e) {
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { t as ClientCommitmentsSnapshotService };

package/common/src/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../event-service/evm/AbstractNullifierSnapshotService.cjs`);require(`../../event-service/index.cjs`);var t=class extends e.AbstractNullifierSnapshotService{snapshotsService;constructor(e,t){super(e),this.snapshotsService=t}async fetchSnapshot(){let e=await this.snapshotsService.getNullifiers();return{latestBlockNumber:e.latestBlockNumber,nullifiers:e.nullifiers}}persistSnapshot(e){return Promise.resolve()}};exports.ClientNullifierSnapshotService=t;

package/common/src/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractNullifierSnapshotService, BlockchainEventEmitter, NullifierSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<NullifierSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown>;
+}

package/common/src/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.mjs

@@ -0,0 +1,21 @@
+import { AbstractNullifierSnapshotService as e } from "../../event-service/evm/AbstractNullifierSnapshotService.mjs";
+import "../../event-service/index.mjs";
+//#region libs/shared/common/src/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.ts
+var t = class extends e {
+	snapshotsService;
+	constructor(e, t) {
+		super(e), this.snapshotsService = t;
+	}
+	async fetchSnapshot() {
+		let e = await this.snapshotsService.getNullifiers();
+		return {
+			latestBlockNumber: e.latestBlockNumber,
+			nullifiers: e.nullifiers
+		};
+	}
+	persistSnapshot(e) {
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { t as ClientNullifierSnapshotService };

package/common/src/data-structures/snapshot/index.cjs

@@ -0,0 +1 @@
+require(`./SnapshotFetcherService.cjs`),require(`./solana-snapshots/ClientSolanaCommitmentsSnapshotService.cjs`),require(`./solana-snapshots/ClientSolanaNullifierSnapshotService.cjs`),require(`./solana-snapshots/ClientSolanaAccessTokenSnapshotService.cjs`),require(`./evm-snapshots/ClientAccessTokenSnapshotService.cjs`),require(`./evm-snapshots/ClientCommitmentsSnapshotService.cjs`),require(`./evm-snapshots/ClientNullifierSnapshotService.cjs`);

package/common/src/data-structures/snapshot/index.d.ts

@@ -0,0 +1,7 @@
+export * from './SnapshotFetcherService';
+export * from './solana-snapshots/ClientSolanaCommitmentsSnapshotService';
+export * from './solana-snapshots/ClientSolanaNullifierSnapshotService';
+export * from './solana-snapshots/ClientSolanaAccessTokenSnapshotService';
+export * from './evm-snapshots/ClientAccessTokenSnapshotService';
+export * from './evm-snapshots/ClientCommitmentsSnapshotService';
+export * from './evm-snapshots/ClientNullifierSnapshotService';

package/common/src/data-structures/snapshot/index.mjs

@@ -0,0 +1,7 @@
+import "./SnapshotFetcherService.mjs";
+import "./solana-snapshots/ClientSolanaCommitmentsSnapshotService.mjs";
+import "./solana-snapshots/ClientSolanaNullifierSnapshotService.mjs";
+import "./solana-snapshots/ClientSolanaAccessTokenSnapshotService.mjs";
+import "./evm-snapshots/ClientAccessTokenSnapshotService.mjs";
+import "./evm-snapshots/ClientCommitmentsSnapshotService.mjs";
+import "./evm-snapshots/ClientNullifierSnapshotService.mjs";

package/common/src/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../event-service/solana/AbstractSolanaAccessTokenSnapshotService.cjs`);require(`../../event-service/index.cjs`);const t=require(`../SnapshotFetcherService.cjs`);var n=class extends e.AbstractSolanaAccessTokenSnapshotService{snapshotsService;constructor(e,t){super(e),this.snapshotsService=t}async fetchSnapshot(){let{chainId:e}=this.solanaBlockchainEventEmitter;this.snapshotsService||=new t.SnapshotFetcherService(e,this.solanaBlockchainEventEmitter.programId.toString());let n=await this.snapshotsService.getAccessTokens();return{latestBlockNumber:n.latestBlockNumber,merkleTree:n.merkleTree,senderAddresses:n.senderAddresses,senderAddressIndexMap:n.senderAddressIndexMap}}persistSnapshot(e){return Promise.resolve()}};exports.ClientSolanaAccessTokenSnapshotService=n;

package/common/src/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractSolanaAccessTokenSnapshotService, SolanaAccessTokenSerializedSnapshot, SolanaBlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientSolanaAccessTokenSnapshotService extends AbstractSolanaAccessTokenSnapshotService {
+    private snapshotsService;
+    constructor(accessTokenEventEmitter: SolanaBlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<SolanaAccessTokenSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: SolanaAccessTokenSerializedSnapshot): Promise<unknown>;
+}

package/common/src/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.mjs

@@ -0,0 +1,26 @@
+import { AbstractSolanaAccessTokenSnapshotService as e } from "../../event-service/solana/AbstractSolanaAccessTokenSnapshotService.mjs";
+import "../../event-service/index.mjs";
+import { SnapshotFetcherService as t } from "../SnapshotFetcherService.mjs";
+//#region libs/shared/common/src/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.ts
+var n = class extends e {
+	snapshotsService;
+	constructor(e, t) {
+		super(e), this.snapshotsService = t;
+	}
+	async fetchSnapshot() {
+		let { chainId: e } = this.solanaBlockchainEventEmitter;
+		this.snapshotsService ||= new t(e, this.solanaBlockchainEventEmitter.programId.toString());
+		let n = await this.snapshotsService.getAccessTokens();
+		return {
+			latestBlockNumber: n.latestBlockNumber,
+			merkleTree: n.merkleTree,
+			senderAddresses: n.senderAddresses,
+			senderAddressIndexMap: n.senderAddressIndexMap
+		};
+	}
+	persistSnapshot(e) {
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { n as ClientSolanaAccessTokenSnapshotService };