@hinkal/react-native 0.3.1

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 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 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/index.cjs

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

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

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

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

@@ -0,0 +1,2 @@
+import "./MerkleTreeIncompleteError.mjs";
+import "./MerkleTree.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/private-balances/BalanceChangedHandler.cjs

@@ -0,0 +1 @@
+var e=class{listeners=new Set;subscribe(e){return this.listeners.add(e),()=>this.listeners.delete(e)}dispatch(e){this.listeners.forEach(t=>t(e))}},t=new e;exports.BalanceChangedHandler=e,exports.balanceChangedHandler=t;

package/common/src/data-structures/private-balances/BalanceChangedHandler.d.ts

@@ -0,0 +1,9 @@
+import { PrivateBalanceUpdateEventType } from '../../types';
+type BalanceChangeListener = (detail?: PrivateBalanceUpdateEventType) => void;
+export declare class BalanceChangedHandler {
+    private readonly listeners;
+    subscribe(listener: BalanceChangeListener): () => void;
+    dispatch(detail: PrivateBalanceUpdateEventType): void;
+}
+export declare const balanceChangedHandler: BalanceChangedHandler;
+export {};

package/common/src/data-structures/private-balances/BalanceChangedHandler.mjs

@@ -0,0 +1,12 @@
+//#region common/src/data-structures/private-balances/BalanceChangedHandler.ts
+var e = class {
+	listeners = /* @__PURE__ */ new Set();
+	subscribe(e) {
+		return this.listeners.add(e), () => this.listeners.delete(e);
+	}
+	dispatch(e) {
+		this.listeners.forEach((t) => t(e));
+	}
+}, t = new e();
+//#endregion
+export { e as BalanceChangedHandler, t as balanceChangedHandler };

package/common/src/data-structures/private-balances/HinkalPrivateBalanceController.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/web3/etherFunctions.cjs`),t=require(`../../functions/utils/upToDateState.cjs`),n=require(`../../types/balances.types.cjs`),r=require(`../../error-handling/logger.cjs`),i=require(`../../functions/utils/string.utils.cjs`),a=require(`./BalanceChangedHandler.cjs`),o=require(`../IndexedDB/private-balances-db.cjs`),s=require(`../IndexedDB/prices-db.cjs`),c=require(`./privateBalancesReducer.cjs`);var l=class{privateBalancesState={};privateBalancesListeners=new Set;hinkal;unsubscribeBalanceChange;constructor(e){this.hinkal=e,this.unsubscribeBalanceChange=a.balanceChangedHandler.subscribe(e=>{this.applyRefreshFromBalanceChangeEvent(e).catch(e=>{r.Logger.error(`Private balance refresh from balance change failed:`,e)})})}getSnapshot(){return this.privateBalancesState}onPrivateBalancesWithUSDChange(e){return this.privateBalancesListeners.add(e),()=>this.privateBalancesListeners.delete(e)}dispose(){this.unsubscribeBalanceChange(),this.privateBalancesListeners.clear()}async applyRefreshFromBalanceChangeEvent(e){if(!e){await this.refreshInternal(n.PrivateBalanceUpdateType.FreshWithoutLoader);return}let{updateType:t,balanceChangeState:r,chainIdToUpdate:i,resetCacheBefore:a,updateTokensListBefore:o}=e;await this.refreshInternal(t,r,a,o,i)}dispatch(e){this.privateBalancesState=c.privateBalancesReducer(this.privateBalancesState,e);let t=this.privateBalancesState;this.privateBalancesListeners.forEach(e=>e(t))}async getAddressAndChain(e){try{return{ethAdd:e?.ethereumAddress??await this.hinkal.getEthereumAddress(),userKeys:e?.userKeys??this.hinkal.userKeys}}catch{return{ethAdd:void 0,userKeys:void 0}}}async hasCache(e,t){return await o.privateBalancesStorage.getBalancesByWallet(e,t)!==void 0}async getBalancesWithUsdValues(t,n){try{if(!n)return[];let r=t.map(e=>e.token.erc20TokenAddress);if(!r.length)return[];let i=await s.pricesStorage.getAndUpdatePrices(n,r),a=new Map(r.map((e,t)=>[e,i[t]]));return[...t.map(t=>{try{let n=t.token.erc20TokenAddress,r=a.get(n)??0,i=t.balance,o=Number(e.getAmountInToken(t.token,i))*r;return{...t,usdValue:o}}catch{return{...t,usdValue:0}}})]}catch{return r.Logger.log(`Error fetching private token balances`),[]}}handleCached=async(n,a)=>{try{await t.checkAddressNotUpdated(this.hinkal,n),this.dispatch({type:`SET_BALANCES`,chainId:a,balances:void 0});let r=await o.privateBalancesStorage.getBalancesByWallet(n,a),c=await s.pricesStorage.getPrices();if(await t.checkAddressNotUpdated(this.hinkal,n),!r||(this.dispatch({type:`SET_BALANCES`,chainId:a,balances:r}),!c))return;let l=r.map(t=>{let n=i.getTokenStateKey(t.token.erc20TokenAddress,a);return{...t,usdValue:c[n]?Number(e.getAmountInToken(t.token,t.balance))*c[n]:0}});this.dispatch({type:`SET_USD_BALANCES`,chainId:a,balances:l})}catch(e){r.Logger.error(`Error refreshing cached private balance:`,e)}};handleFresh=async(e,n,i,a,s,c)=>{let l=s;try{await t.checkAddressNotUpdated(this.hinkal,e);let r=await this.hasCache(e,n);await t.checkAddressNotUpdated(this.hinkal,e),l=s||!r,l&&this.dispatch({type:`SET_LOADING`,chainId:n,newValue:!0}),await t.checkAddressNotUpdated(this.hinkal,e),a&&await this.hinkal.resetMerkle([n]);let u=await this.hinkal.getTotalBalance(n,i,e,a,c);await t.checkAddressNotUpdated(this.hinkal,e);let d=u.filter(e=>e.balance>0n);this.dispatch({type:`SET_BALANCES`,chainId:n,balances:d}),await o.privateBalancesStorage.setBalances(e,n,d),await t.checkAddressNotUpdated(this.hinkal,e),l&&(this.dispatch({type:`SET_USD_LOADING`,chainId:n,newValue:!0}),this.dispatch({type:`SET_LOADING`,chainId:n,newValue:!1})),await t.checkAddressNotUpdated(this.hinkal,e);let f=await this.getBalancesWithUsdValues(d,n);await t.checkAddressNotUpdated(this.hinkal,e),f.length>0&&this.dispatch({type:`SET_USD_BALANCES`,chainId:n,balances:f})}catch(e){r.Logger.error(`Error refreshing private balance:`,e)}finally{l&&(this.dispatch({type:`SET_LOADING`,chainId:n,newValue:!1}),this.dispatch({type:`SET_USD_LOADING`,chainId:n,newValue:!1}))}};getSupportedChainsToUpdate(e){let t=this.hinkal.getSupportedChains();return e?t.includes(e)?[e]:[]:t}async refreshInternal(e=n.PrivateBalanceUpdateType.FreshWithoutLoader,t,r=!1,i=!1,a){let{ethAdd:o,userKeys:s}=await this.getAddressAndChain(t);!o||!s?.getShieldedPublicKey()||await Promise.all(this.getSupportedChainsToUpdate(a).map(async t=>{switch(e){case n.PrivateBalanceUpdateType.OnlyCache:await this.handleCached(o,t);break;case n.PrivateBalanceUpdateType.Fresh:await this.handleFresh(o,t,s,r,!0,i);break;case n.PrivateBalanceUpdateType.FreshWithoutLoader:await this.handleFresh(o,t,s,r,!1,i);break;default:break}}))}};exports.HinkalPrivateBalanceController=l;

package/common/src/data-structures/private-balances/HinkalPrivateBalanceController.d.ts

@@ -0,0 +1,21 @@
+import { PrivateBalancesState } from '../../types/balances.types';
+import { IHinkal } from '../Hinkal/IHinkal';
+export declare class HinkalPrivateBalanceController {
+    private privateBalancesState;
+    private readonly privateBalancesListeners;
+    private readonly hinkal;
+    private readonly unsubscribeBalanceChange;
+    constructor(hinkal: IHinkal);
+    getSnapshot(): PrivateBalancesState;
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    dispose(): void;
+    private applyRefreshFromBalanceChangeEvent;
+    private dispatch;
+    private getAddressAndChain;
+    private hasCache;
+    private getBalancesWithUsdValues;
+    private handleCached;
+    private handleFresh;
+    private getSupportedChainsToUpdate;
+    private refreshInternal;
+}

package/common/src/data-structures/private-balances/HinkalPrivateBalanceController.mjs

@@ -0,0 +1,183 @@
+import { getAmountInToken as e } from "../../functions/web3/etherFunctions.mjs";
+import { checkAddressNotUpdated as t } from "../../functions/utils/upToDateState.mjs";
+import { PrivateBalanceUpdateType as n } from "../../types/balances.types.mjs";
+import { Logger as r } from "../../error-handling/logger.mjs";
+import { getTokenStateKey as i } from "../../functions/utils/string.utils.mjs";
+import { balanceChangedHandler as a } from "./BalanceChangedHandler.mjs";
+import { privateBalancesStorage as o } from "../IndexedDB/private-balances-db.mjs";
+import { pricesStorage as s } from "../IndexedDB/prices-db.mjs";
+import { privateBalancesReducer as c } from "./privateBalancesReducer.mjs";
+//#region common/src/data-structures/private-balances/HinkalPrivateBalanceController.ts
+var l = class {
+	privateBalancesState = {};
+	privateBalancesListeners = /* @__PURE__ */ new Set();
+	hinkal;
+	unsubscribeBalanceChange;
+	constructor(e) {
+		this.hinkal = e, this.unsubscribeBalanceChange = a.subscribe((e) => {
+			this.applyRefreshFromBalanceChangeEvent(e).catch((e) => {
+				r.error("Private balance refresh from balance change failed:", e);
+			});
+		});
+	}
+	getSnapshot() {
+		return this.privateBalancesState;
+	}
+	onPrivateBalancesWithUSDChange(e) {
+		return this.privateBalancesListeners.add(e), () => this.privateBalancesListeners.delete(e);
+	}
+	dispose() {
+		this.unsubscribeBalanceChange(), this.privateBalancesListeners.clear();
+	}
+	async applyRefreshFromBalanceChangeEvent(e) {
+		if (!e) {
+			await this.refreshInternal(n.FreshWithoutLoader);
+			return;
+		}
+		let { updateType: t, balanceChangeState: r, chainIdToUpdate: i, resetCacheBefore: a, updateTokensListBefore: o } = e;
+		await this.refreshInternal(t, r, a, o, i);
+	}
+	dispatch(e) {
+		this.privateBalancesState = c(this.privateBalancesState, e);
+		let t = this.privateBalancesState;
+		this.privateBalancesListeners.forEach((e) => e(t));
+	}
+	async getAddressAndChain(e) {
+		try {
+			return {
+				ethAdd: e?.ethereumAddress ?? await this.hinkal.getEthereumAddress(),
+				userKeys: e?.userKeys ?? this.hinkal.userKeys
+			};
+		} catch {
+			return {
+				ethAdd: void 0,
+				userKeys: void 0
+			};
+		}
+	}
+	async hasCache(e, t) {
+		return await o.getBalancesByWallet(e, t) !== void 0;
+	}
+	async getBalancesWithUsdValues(t, n) {
+		try {
+			if (!n) return [];
+			let r = t.map((e) => e.token.erc20TokenAddress);
+			if (!r.length) return [];
+			let i = await s.getAndUpdatePrices(n, r), a = new Map(r.map((e, t) => [e, i[t]]));
+			return [...t.map((t) => {
+				try {
+					let n = t.token.erc20TokenAddress, r = a.get(n) ?? 0, i = t.balance, o = Number(e(t.token, i)) * r;
+					return {
+						...t,
+						usdValue: o
+					};
+				} catch {
+					return {
+						...t,
+						usdValue: 0
+					};
+				}
+			})];
+		} catch {
+			return r.log("Error fetching private token balances"), [];
+		}
+	}
+	handleCached = async (n, a) => {
+		try {
+			await t(this.hinkal, n), this.dispatch({
+				type: "SET_BALANCES",
+				chainId: a,
+				balances: void 0
+			});
+			let r = await o.getBalancesByWallet(n, a), c = await s.getPrices();
+			if (await t(this.hinkal, n), !r || (this.dispatch({
+				type: "SET_BALANCES",
+				chainId: a,
+				balances: r
+			}), !c)) return;
+			let l = r.map((t) => {
+				let n = i(t.token.erc20TokenAddress, a);
+				return {
+					...t,
+					usdValue: c[n] ? Number(e(t.token, t.balance)) * c[n] : 0
+				};
+			});
+			this.dispatch({
+				type: "SET_USD_BALANCES",
+				chainId: a,
+				balances: l
+			});
+		} catch (e) {
+			r.error("Error refreshing cached private balance:", e);
+		}
+	};
+	handleFresh = async (e, n, i, a, s, c) => {
+		let l = s;
+		try {
+			await t(this.hinkal, e);
+			let r = await this.hasCache(e, n);
+			await t(this.hinkal, e), l = s || !r, l && this.dispatch({
+				type: "SET_LOADING",
+				chainId: n,
+				newValue: !0
+			}), await t(this.hinkal, e), a && await this.hinkal.resetMerkle([n]);
+			let u = await this.hinkal.getTotalBalance(n, i, e, a, c);
+			await t(this.hinkal, e);
+			let d = u.filter((e) => e.balance > 0n);
+			this.dispatch({
+				type: "SET_BALANCES",
+				chainId: n,
+				balances: d
+			}), await o.setBalances(e, n, d), await t(this.hinkal, e), l && (this.dispatch({
+				type: "SET_USD_LOADING",
+				chainId: n,
+				newValue: !0
+			}), this.dispatch({
+				type: "SET_LOADING",
+				chainId: n,
+				newValue: !1
+			})), await t(this.hinkal, e);
+			let f = await this.getBalancesWithUsdValues(d, n);
+			await t(this.hinkal, e), f.length > 0 && this.dispatch({
+				type: "SET_USD_BALANCES",
+				chainId: n,
+				balances: f
+			});
+		} catch (e) {
+			r.error("Error refreshing private balance:", e);
+		} finally {
+			l && (this.dispatch({
+				type: "SET_LOADING",
+				chainId: n,
+				newValue: !1
+			}), this.dispatch({
+				type: "SET_USD_LOADING",
+				chainId: n,
+				newValue: !1
+			}));
+		}
+	};
+	getSupportedChainsToUpdate(e) {
+		let t = this.hinkal.getSupportedChains();
+		return e ? t.includes(e) ? [e] : [] : t;
+	}
+	async refreshInternal(e = n.FreshWithoutLoader, t, r = !1, i = !1, a) {
+		let { ethAdd: o, userKeys: s } = await this.getAddressAndChain(t);
+		!o || !s?.getShieldedPublicKey() || await Promise.all(this.getSupportedChainsToUpdate(a).map(async (t) => {
+			switch (e) {
+				case n.OnlyCache:
+					await this.handleCached(o, t);
+					break;
+				case n.Fresh:
+					await this.handleFresh(o, t, s, r, !0, i);
+					break;
+				case n.FreshWithoutLoader:
+					await this.handleFresh(o, t, s, r, !1, i);
+					break;
+				default: break;
+			}
+		}));
+	}
+};
+//#endregion
+export { l as HinkalPrivateBalanceController };

package/common/src/data-structures/private-balances/index.cjs

@@ -0,0 +1 @@
+require(`./BalanceChangedHandler.cjs`),require(`./privateBalancesReducer.cjs`),require(`./HinkalPrivateBalanceController.cjs`);

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

@@ -0,0 +1,3 @@
+export * from './BalanceChangedHandler';
+export * from './HinkalPrivateBalanceController';
+export * from './privateBalancesReducer';

package/common/src/data-structures/private-balances/index.mjs

@@ -0,0 +1,3 @@
+import "./BalanceChangedHandler.mjs";
+import "./privateBalancesReducer.mjs";
+import "./HinkalPrivateBalanceController.mjs";

package/common/src/data-structures/private-balances/privateBalancesReducer.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/token-check.utils.cjs`);var t=(t,n)=>{switch(n.type){case`SET_BALANCES`:{let r=t[n.chainId];if(n.balances===void 0){let e={...t};return delete e[n.chainId],Object.keys(e).length>0?e:{}}if(r===void 0)return{...t,[n.chainId]:n.balances};let i=n.balances,a=i.filter(t=>!r.some(n=>e.isSameERC20Token(t.token,n.token))),o=r.map(t=>({...t,balance:i.find(n=>e.isSameERC20Token(n.token,t.token))?.balance??0n})).filter(e=>e.balance>0n);return o=[...o,...a],{...t,[n.chainId]:o}}case`SET_USD_BALANCES`:{let r=t[n.chainId];if(r===void 0||n.balances===void 0)return t;let i=n.balances,a=r.map(t=>({...t,usdValue:i.find(n=>e.isSameERC20Token(n.token,t.token))?.usdValue??0}));return{...t,[n.chainId]:a}}case`CLEAR_BALANCES`:{if(n.chainId===void 0)return{};let e={...t};return delete e[n.chainId],Object.keys(e).length>0?e:{}}case`SET_LOADING`:{let e=t[n.chainId];if(e===void 0)return t;if(e.length===0&&n.newValue)return{...t,[n.chainId]:void 0};let r=e.map(e=>({...e,isBalanceLoading:n.newValue}));return{...t,[n.chainId]:r}}case`SET_USD_LOADING`:{let e=t[n.chainId];if(e===void 0)return t;let r=e.map(e=>({...e,isUsdValueLoading:n.newValue}));return{...t,[n.chainId]:r}}default:return t}};exports.privateBalancesReducer=t;

package/common/src/data-structures/private-balances/privateBalancesReducer.d.ts

@@ -0,0 +1,2 @@
+import { PrivateBalancesAction, PrivateBalancesState } from '../../types/balances.types';
+export declare const privateBalancesReducer: (currentState: PrivateBalancesState, action: PrivateBalancesAction) => PrivateBalancesState;

package/common/src/data-structures/private-balances/privateBalancesReducer.mjs

@@ -0,0 +1,73 @@
+import { isSameERC20Token as e } from "../../functions/utils/token-check.utils.mjs";
+//#region common/src/data-structures/private-balances/privateBalancesReducer.ts
+var t = (t, n) => {
+	switch (n.type) {
+		case "SET_BALANCES": {
+			let r = t[n.chainId];
+			if (n.balances === void 0) {
+				let e = { ...t };
+				return delete e[n.chainId], Object.keys(e).length > 0 ? e : {};
+			}
+			if (r === void 0) return {
+				...t,
+				[n.chainId]: n.balances
+			};
+			let i = n.balances, a = i.filter((t) => !r.some((n) => e(t.token, n.token))), o = r.map((t) => ({
+				...t,
+				balance: i.find((n) => e(n.token, t.token))?.balance ?? 0n
+			})).filter((e) => e.balance > 0n);
+			return o = [...o, ...a], {
+				...t,
+				[n.chainId]: o
+			};
+		}
+		case "SET_USD_BALANCES": {
+			let r = t[n.chainId];
+			if (r === void 0 || n.balances === void 0) return t;
+			let i = n.balances, a = r.map((t) => ({
+				...t,
+				usdValue: i.find((n) => e(n.token, t.token))?.usdValue ?? 0
+			}));
+			return {
+				...t,
+				[n.chainId]: a
+			};
+		}
+		case "CLEAR_BALANCES": {
+			if (n.chainId === void 0) return {};
+			let e = { ...t };
+			return delete e[n.chainId], Object.keys(e).length > 0 ? e : {};
+		}
+		case "SET_LOADING": {
+			let e = t[n.chainId];
+			if (e === void 0) return t;
+			if (e.length === 0 && n.newValue) return {
+				...t,
+				[n.chainId]: void 0
+			};
+			let r = e.map((e) => ({
+				...e,
+				isBalanceLoading: n.newValue
+			}));
+			return {
+				...t,
+				[n.chainId]: r
+			};
+		}
+		case "SET_USD_LOADING": {
+			let e = t[n.chainId];
+			if (e === void 0) return t;
+			let r = e.map((e) => ({
+				...e,
+				isUsdValueLoading: n.newValue
+			}));
+			return {
+				...t,
+				[n.chainId]: r
+			};
+		}
+		default: return t;
+	}
+};
+//#endregion
+export { t as privateBalancesReducer };

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 getNullifiers(e=!1){return(await this.ensureSnapshots(e)).nullifiers}};exports.SnapshotFetcherService=r;

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

@@ -0,0 +1,14 @@
+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>;
+    getNullifiers(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').INullifiersSnapshot>;
+}