@kapa123456789/sdk 0.0.1

package/common/src/data-structures/TokenDBs/EventsPublicTokensDB.mjs

@@ -0,0 +1,144 @@
+import { zeroAddress as e } from "../../constants/protocol.constants.mjs";
+import { StorageKeys as t } from "../../types/cache.types.mjs";
+import { getERC20Token as n, isNFTToken as r, overlayTokenWithRegistryData as i } from "../../functions/utils/erc20tokenFunctions.mjs";
+import { lowerCaseIncludes as a } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { API as o } from "../../API/API.mjs";
+import { Logger as s } from "../../error-handling/logger.mjs";
+import { getStateKey as c } from "../../functions/utils/string.utils.mjs";
+import { tokenVisibilityStorage as l } from "./token-visibility-db.mjs";
+import { createJsonRpcProvider as u } from "../../functions/utils/create-provider.mjs";
+import { EVENTS_INITIAL_BLOCKS as d } from "../../constants/events.constants.mjs";
+import "../../constants/index.mjs";
+import "../../functions/index.mjs";
+import { ethers as f } from "ethers";
+import { get as p, update as m } from "idb-keyval";
+import { Mutex as h } from "async-mutex";
+var g = new class {
+	fetchedTokens = {};
+	updateMutexes = {};
+	transferEventTopic = f.id("Transfer(address,address,uint256)");
+	chunkSize = 2e3;
+	getMutex(e) {
+		return this.updateMutexes[e] || (this.updateMutexes[e] = new h()), this.updateMutexes[e];
+	}
+	withRegistryOverlay(e, t) {
+		let r = n(e.erc20TokenAddress, t);
+		return r ? {
+			...e,
+			name: r.name,
+			symbol: r.symbol,
+			logoURI: r.logoURI,
+			decimals: r.decimals
+		} : e;
+	}
+	async getPublicTokens(e, n) {
+		let r = c(n, e);
+		return ((await p(t.EVENTS_PUBLIC_TOKENS))?.[r] || []).map((t) => i(t, e));
+	}
+	getFetchedTokens(e, t) {
+		let n = c(t, e);
+		return (this.fetchedTokens[n] || []).map((t) => i(t, e));
+	}
+	async fetchAndUpdatePublicTokens(e, n) {
+		let r = c(e, n);
+		await this.getMutex(r).runExclusive(async () => {
+			try {
+				let i = (await this.getPublicTokens(n, e)).map((e) => e.erc20TokenAddress), { toEvents: o, fromEvents: s, latestBlock: c } = await this.getEvents(e, n), u = [...o, ...s], { erc20Tokens: d } = await this.fetchPublicTokens(u, n, i), f = await l.hideSpamsAndFetchHiddenTokensAddresses(n, d), p = d.filter((e) => !a(f, e.erc20TokenAddress));
+				await m(t.EVENTS_PUBLIC_TOKENS, (e = {}) => {
+					let t = e[r] || [], n = t.map((e) => e.erc20TokenAddress), i = p.filter((e) => !a(n, e.erc20TokenAddress));
+					t.push(...i);
+					let c = this.updateTokenIds(s, o, t), l = {
+						...e,
+						[r]: c
+					};
+					return this.fetchedTokens = l, l;
+				}), c && await this.updateLastProcessedBlock(n, e, c);
+			} catch (e) {
+				s.error("public tokens db error", e);
+			}
+		});
+	}
+	async getLastProcessedBlock(e, n) {
+		return (await p(t.PUBLIC_TOKENS_LAST_PROCESSED_BLOCKS) || {})[c(n, e)] || d[e];
+	}
+	async updateLastProcessedBlock(e, n, r) {
+		await m(t.PUBLIC_TOKENS_LAST_PROCESSED_BLOCKS, (t = {}) => {
+			let i = c(n, e);
+			return {
+				...t,
+				[i]: r
+			};
+		});
+	}
+	async getEvents(e, t) {
+		try {
+			let n = u(t), r = await this.getLastProcessedBlock(t, e) + 1, i = await n.getBlockNumber(), a = f.zeroPadValue(e.toLowerCase(), 32), o = [], s = [];
+			for (let e = r; e <= i; e += this.chunkSize) {
+				let t = Math.min(e + this.chunkSize - 1, i), r = {
+					topics: [
+						this.transferEventTopic,
+						null,
+						a
+					],
+					fromBlock: e,
+					toBlock: t
+				}, c = {
+					topics: [
+						this.transferEventTopic,
+						a,
+						null
+					],
+					fromBlock: e,
+					toBlock: t
+				}, [l, u] = await Promise.all([n.getLogs(r), n.getLogs(c)]);
+				o.push(...l), s.push(...u);
+			}
+			return {
+				toEvents: o,
+				fromEvents: s,
+				latestBlock: i
+			};
+		} catch (n) {
+			return s.error("Error fetching events:", n, "chainId", t, "walletAddress", e), {
+				toEvents: [],
+				fromEvents: [],
+				latestBlock: void 0
+			};
+		}
+	}
+	updateTokenIds(e, t, n) {
+		let i = /* @__PURE__ */ new Map();
+		return n.forEach((e) => {
+			if (r(e) && e.tokenIds) {
+				let t = e.erc20TokenAddress.toLowerCase();
+				i.set(t, [...e.tokenIds]);
+			}
+		}), t.forEach((e) => {
+			if (e.topics.length <= 3) return;
+			let t = e.address.toLowerCase(), n = BigInt(e.topics[3]).toString();
+			i.has(t) || i.set(t, []), i.get(t)?.push(n);
+		}), e.forEach((e) => {
+			if (e.topics.length <= 3) return;
+			let t = e.address.toLowerCase(), n = i.get(t);
+			if (n?.length) {
+				let t = BigInt(e.topics[3]).toString(), r = n.indexOf(t);
+				r !== -1 && n.splice(r, 1);
+			}
+		}), n.forEach((e) => {
+			if (r(e)) {
+				let t = e.erc20TokenAddress.toLowerCase(), n = i.get(t);
+				e.tokenIds = n?.length && n.length > 0 ? n : void 0;
+			}
+		}), n;
+	}
+	async fetchPublicTokens(t, n, r) {
+		try {
+			let i = [e, ...new Set(t.map((e) => e.address))].filter((e) => e && !a(r, e));
+			return i.length ? { erc20Tokens: (await o.tokensInfoCall(n, i)).filter((e) => !!e) } : { erc20Tokens: [] };
+		} catch (e) {
+			return s.error("Error fetching public tokens:", e), { erc20Tokens: [] };
+		}
+	}
+}();
+//#endregion
+export { g as eventsPublicTokensDB };

package/common/src/data-structures/TokenDBs/IPublicTokensDB.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+export interface IPublicTokensDB {
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): ERC20Token[];
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+}

package/common/src/data-structures/TokenDBs/PrivateTokensDB.cjs

@@ -0,0 +1 @@
+require(`../../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../types/cache.types.cjs`),t=require(`../../functions/utils/caseInsensitive.utils.cjs`),n=require(`../../API/API.cjs`),r=require(`../../error-handling/logger.cjs`),i=require(`../../functions/utils/string.utils.cjs`),a=require(`./token-visibility-db.cjs`);let o=require(`idb-keyval`);var s=class{fetchedTokens={};initalFetched=!1;async updateFetchedTokens(){let t=await(0,o.get)(e.StorageKeys.PRIVATE_TOKENS);this.fetchedTokens=t??{},this.initalFetched=!0}async getPrivateTokens(t,n){let r=i.getStateKey(n,t);return(await(0,o.get)(e.StorageKeys.PRIVATE_TOKENS))?.[r]||[]}async fetchPrivateTokens(e,i,a){try{let r=[...new Set(i)].filter(e=>e&&!t.lowerCaseIncludes(a,e));if(!r.length)return[];let o=(await n.API.tokensInfoCall(e,r)).filter(e=>!!e),s=new Map;return o.forEach(e=>{s.set(e.erc20TokenAddress.toLowerCase(),e)}),Array.from(s.values())}catch(e){return r.Logger.error(`Error fetching private tokens:`,e),[]}}async fetchAndUpdatePrivateTokens(n,r,s,c){let l=(await this.getPrivateTokens(r,s)).map(e=>e.erc20TokenAddress),u=c??await this.fetchPrivateTokens(r,n,l),d=await a.tokenVisibilityStorage.hideSpamsAndFetchHiddenTokensAddresses(r,u),f=i.getStateKey(s,r);await(0,o.update)(e.StorageKeys.PRIVATE_TOKENS,(e={})=>{let n=e?.[f]||[],r=n.map(e=>e.erc20TokenAddress),i=u.filter(e=>!t.lowerCaseIncludes(r,e.erc20TokenAddress));n.push(...i);let a=n.filter(e=>!t.lowerCaseIncludes(d,e.erc20TokenAddress)),o={...e,[f]:a};return this.fetchedTokens=o,o})}getFetchedTokens(e,t){let n=i.getStateKey(t,e);return this.fetchedTokens[n]||[]}},c=new s;exports.PrivateTokensDB=s,exports.privateTokensDB=c;

package/common/src/data-structures/TokenDBs/PrivateTokensDB.d.ts

@@ -0,0 +1,11 @@
+import { ERC20Token } from '../../types/token.types';
+export declare class PrivateTokensDB {
+    private fetchedTokens;
+    initalFetched: boolean;
+    updateFetchedTokens(): Promise<void>;
+    getPrivateTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    private fetchPrivateTokens;
+    fetchAndUpdatePrivateTokens(erc20Addresses: string[], chainId: number, walletAddress: string, preFetchedTokens?: ERC20Token[]): Promise<void>;
+    getFetchedTokens(chainId: number, walletAddress: string): ERC20Token[];
+}
+export declare const privateTokensDB: PrivateTokensDB;

package/common/src/data-structures/TokenDBs/PrivateTokensDB.mjs

@@ -0,0 +1,50 @@
+import { StorageKeys as e } from "../../types/cache.types.mjs";
+import { lowerCaseIncludes as t } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { API as n } from "../../API/API.mjs";
+import { Logger as r } from "../../error-handling/logger.mjs";
+import { getStateKey as i } from "../../functions/utils/string.utils.mjs";
+import { tokenVisibilityStorage as a } from "./token-visibility-db.mjs";
+import { get as o, update as s } from "idb-keyval";
+//#region libs/shared/common/src/data-structures/TokenDBs/PrivateTokensDB.ts
+var c = class {
+	fetchedTokens = {};
+	initalFetched = !1;
+	async updateFetchedTokens() {
+		let t = await o(e.PRIVATE_TOKENS);
+		this.fetchedTokens = t ?? {}, this.initalFetched = !0;
+	}
+	async getPrivateTokens(t, n) {
+		let r = i(n, t);
+		return (await o(e.PRIVATE_TOKENS))?.[r] || [];
+	}
+	async fetchPrivateTokens(e, i, a) {
+		try {
+			let r = [...new Set(i)].filter((e) => e && !t(a, e));
+			if (!r.length) return [];
+			let o = (await n.tokensInfoCall(e, r)).filter((e) => !!e), s = /* @__PURE__ */ new Map();
+			return o.forEach((e) => {
+				s.set(e.erc20TokenAddress.toLowerCase(), e);
+			}), Array.from(s.values());
+		} catch (e) {
+			return r.error("Error fetching private tokens:", e), [];
+		}
+	}
+	async fetchAndUpdatePrivateTokens(n, r, o, c) {
+		let l = (await this.getPrivateTokens(r, o)).map((e) => e.erc20TokenAddress), u = c ?? await this.fetchPrivateTokens(r, n, l), d = await a.hideSpamsAndFetchHiddenTokensAddresses(r, u), f = i(o, r);
+		await s(e.PRIVATE_TOKENS, (e = {}) => {
+			let n = e?.[f] || [], r = n.map((e) => e.erc20TokenAddress), i = u.filter((e) => !t(r, e.erc20TokenAddress));
+			n.push(...i);
+			let a = n.filter((e) => !t(d, e.erc20TokenAddress)), o = {
+				...e,
+				[f]: a
+			};
+			return this.fetchedTokens = o, o;
+		});
+	}
+	getFetchedTokens(e, t) {
+		let n = i(t, e);
+		return this.fetchedTokens[n] || [];
+	}
+}, l = new c();
+//#endregion
+export { c as PrivateTokensDB, l as privateTokensDB };

package/common/src/data-structures/TokenDBs/PublicTokensDB.cjs

@@ -0,0 +1 @@
+const e=require(`../../constants/chains.constants.cjs`),t=require(`../../functions/utils/string.utils.cjs`),n=require(`./AlchemyPublicTokensDB.cjs`),r=require(`./EventsPublicTokensDB.cjs`),i=require(`./ArcPublicTokensDB.cjs`);var a=class{useAlternativeDB={};async getPublicTokens(a,o){let s=t.getStateKey(o,a);return a===e.chainIds.arcTestnet?i.arcPublicTokensDB.getPublicTokens(o):this.useAlternativeDB[s]?r.eventsPublicTokensDB.getPublicTokens(a,o):n.alchemyPublicTokensDB.getPublicTokens(a,o)}getFetchedTokens(a,o){let s=t.getStateKey(o,a);return a===e.chainIds.arcTestnet?i.arcPublicTokensDB.getFetchedTokens(o):this.useAlternativeDB[s]?r.eventsPublicTokensDB.getFetchedTokens(a,o):n.alchemyPublicTokensDB.getFetchedTokens(a,o)}async fetchAndUpdatePublicTokens(a,o){let s=t.getStateKey(a,o);try{o===e.chainIds.arcTestnet?await i.arcPublicTokensDB.fetchAndUpdatePublicTokens(a):(await n.alchemyPublicTokensDB.fetchAndUpdatePublicTokens(a,o),this.useAlternativeDB[s]=!1)}catch{if(e.isSolanaLike(o))return;await r.eventsPublicTokensDB.fetchAndUpdatePublicTokens(a,o),this.useAlternativeDB[s]=!0}}};new a,exports.PublicTokensDB=a;

package/common/src/data-structures/TokenDBs/PublicTokensDB.d.ts

@@ -0,0 +1,9 @@
+import { ERC20Token } from '../../types/token.types';
+import { IPublicTokensDB } from './IPublicTokensDB';
+export declare class PublicTokensDB implements IPublicTokensDB {
+    private useAlternativeDB;
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): ERC20Token[];
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+}
+export declare const publicTokensDB: PublicTokensDB;

package/common/src/data-structures/TokenDBs/PublicTokensDB.mjs

@@ -0,0 +1,29 @@
+import { chainIds as e, isSolanaLike as t } from "../../constants/chains.constants.mjs";
+import { getStateKey as n } from "../../functions/utils/string.utils.mjs";
+import { alchemyPublicTokensDB as r } from "./AlchemyPublicTokensDB.mjs";
+import { eventsPublicTokensDB as i } from "./EventsPublicTokensDB.mjs";
+import { arcPublicTokensDB as a } from "./ArcPublicTokensDB.mjs";
+//#region libs/shared/common/src/data-structures/TokenDBs/PublicTokensDB.ts
+var o = class {
+	useAlternativeDB = {};
+	async getPublicTokens(t, o) {
+		let s = n(o, t);
+		return t === e.arcTestnet ? a.getPublicTokens(o) : this.useAlternativeDB[s] ? i.getPublicTokens(t, o) : r.getPublicTokens(t, o);
+	}
+	getFetchedTokens(t, o) {
+		let s = n(o, t);
+		return t === e.arcTestnet ? a.getFetchedTokens(o) : this.useAlternativeDB[s] ? i.getFetchedTokens(t, o) : r.getFetchedTokens(t, o);
+	}
+	async fetchAndUpdatePublicTokens(o, s) {
+		let c = n(o, s);
+		try {
+			s === e.arcTestnet ? await a.fetchAndUpdatePublicTokens(o) : (await r.fetchAndUpdatePublicTokens(o, s), this.useAlternativeDB[c] = !1);
+		} catch {
+			if (t(s)) return;
+			await i.fetchAndUpdatePublicTokens(o, s), this.useAlternativeDB[c] = !0;
+		}
+	}
+};
+new o();
+//#endregion
+export { o as PublicTokensDB };

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

@@ -0,0 +1 @@
+require(`./token-visibility-db.cjs`),require(`./PrivateTokensDB.cjs`),require(`./ArcPublicTokensDB.cjs`),require(`./PublicTokensDB.cjs`);

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

@@ -0,0 +1,4 @@
+export * from './PrivateTokensDB';
+export * from './PublicTokensDB';
+export * from './token-visibility-db';
+export * from './ArcPublicTokensDB';

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

@@ -0,0 +1,4 @@
+import "./token-visibility-db.mjs";
+import "./PrivateTokensDB.mjs";
+import "./ArcPublicTokensDB.mjs";
+import "./PublicTokensDB.mjs";

package/common/src/data-structures/TokenDBs/token-visibility-db.cjs

@@ -0,0 +1 @@
+require(`../../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../error-handling/logger.cjs`),t=require(`../../functions/utils/token-check.utils.cjs`);let n=require(`idb-keyval`);var r=new class{STORAGE_KEY=`hiddenTokenAddresses`;UNHIDDEN_SPAM_KEY=`unhiddenSpamTokens`;async getHiddenTokens(t){try{return(await(0,n.get)(this.STORAGE_KEY))?.[t]||[]}catch(t){return e.Logger.error(`Error retrieving hidden tokens`,t),[]}}async getHiddenTokenAddresses(t){try{return(await this.getHiddenTokens(t)).map(({erc20TokenAddress:e})=>e.toLowerCase())}catch(t){return e.Logger.error(`Error retrieving hidden tokens`,t),[]}}async filterOutHiddenTokens(e,n){let r=await this.getHiddenTokens(e);return n.filter(e=>!r.some(n=>t.isSameERC20Token(n,e)))}async hideToken(r){try{await(0,n.update)(this.STORAGE_KEY,e=>{let n=e??{},{chainId:i}=r;return n[i]||(n[i]=[]),n[i].some(e=>t.isSameERC20Token(e,r))||n[i].push(r),n}),r.isSpam&&await this.deleteUnhiddenSpamToken(r)}catch(t){e.Logger.error(`Error hiding token`,t)}}async showToken(r){try{await(0,n.update)(this.STORAGE_KEY,e=>{let{chainId:n}=r,i=e??{};return i[n]||(i[n]=[]),i[n]=i[n].filter(e=>!t.isSameERC20Token(e,r)),i}),r.isSpam&&await this.storeUnhiddenSpamToken(r)}catch(t){e.Logger.error(`Error showing token`,t)}}async storeUnhiddenSpamToken(r){let{chainId:i}=r;try{await(0,n.update)(this.UNHIDDEN_SPAM_KEY,e=>{let n=e??{};return n[i]||(n[i]=[]),n[i].some(e=>t.isSameERC20Token(e,r))||n[i].push(r),n})}catch(t){e.Logger.error(`Error storing unhidden spam token`,t)}}async deleteUnhiddenSpamToken(e){await(0,n.update)(this.UNHIDDEN_SPAM_KEY,n=>{let{chainId:r}=e,i=n??{};return i[r]=i[r]?.filter(n=>!t.isSameERC20Token(n,e)),i})}async getUnhiddenSpamTokens(t){try{return(await(0,n.get)(this.UNHIDDEN_SPAM_KEY))?.[t]||[]}catch(t){return e.Logger.error(`Error retrieving unhidden spam tokens`,t),[]}}async hideUnnecessarySpamTokens(e,n){let r=await this.getUnhiddenSpamTokens(e),i=n.filter(e=>e.isSpam?!r.some(n=>t.isSameERC20Token(n,e)):!1);await Promise.all(i.map(e=>this.hideToken(e)))}async hideSpamsAndFetchHiddenTokensAddresses(e,t){return await this.hideUnnecessarySpamTokens(e,t),this.getHiddenTokenAddresses(e)}};exports.tokenVisibilityStorage=r;

package/common/src/data-structures/TokenDBs/token-visibility-db.d.ts

@@ -0,0 +1,17 @@
+import { ERC20Token } from '../../types/token.types';
+declare class TokenVisibilityStorage {
+    private readonly STORAGE_KEY;
+    private readonly UNHIDDEN_SPAM_KEY;
+    getHiddenTokens(chainId: number): Promise<ERC20Token[]>;
+    private getHiddenTokenAddresses;
+    filterOutHiddenTokens(chainId: number, tokens: ERC20Token[]): Promise<ERC20Token[]>;
+    hideToken(token: ERC20Token): Promise<void>;
+    showToken(token: ERC20Token): Promise<void>;
+    private storeUnhiddenSpamToken;
+    private deleteUnhiddenSpamToken;
+    getUnhiddenSpamTokens(chainId: number): Promise<ERC20Token[]>;
+    private hideUnnecessarySpamTokens;
+    hideSpamsAndFetchHiddenTokensAddresses(chainId: number, tokens: ERC20Token[]): Promise<string[]>;
+}
+export declare const tokenVisibilityStorage: TokenVisibilityStorage;
+export {};

package/common/src/data-structures/TokenDBs/token-visibility-db.mjs

@@ -0,0 +1,78 @@
+import { Logger as e } from "../../error-handling/logger.mjs";
+import { isSameERC20Token as t } from "../../functions/utils/token-check.utils.mjs";
+import { get as n, update as r } from "idb-keyval";
+var i = new class {
+	STORAGE_KEY = "hiddenTokenAddresses";
+	UNHIDDEN_SPAM_KEY = "unhiddenSpamTokens";
+	async getHiddenTokens(t) {
+		try {
+			return (await n(this.STORAGE_KEY))?.[t] || [];
+		} catch (t) {
+			return e.error("Error retrieving hidden tokens", t), [];
+		}
+	}
+	async getHiddenTokenAddresses(t) {
+		try {
+			return (await this.getHiddenTokens(t)).map(({ erc20TokenAddress: e }) => e.toLowerCase());
+		} catch (t) {
+			return e.error("Error retrieving hidden tokens", t), [];
+		}
+	}
+	async filterOutHiddenTokens(e, n) {
+		let r = await this.getHiddenTokens(e);
+		return n.filter((e) => !r.some((n) => t(n, e)));
+	}
+	async hideToken(n) {
+		try {
+			await r(this.STORAGE_KEY, (e) => {
+				let r = e ?? {}, { chainId: i } = n;
+				return r[i] || (r[i] = []), r[i].some((e) => t(e, n)) || r[i].push(n), r;
+			}), n.isSpam && await this.deleteUnhiddenSpamToken(n);
+		} catch (t) {
+			e.error("Error hiding token", t);
+		}
+	}
+	async showToken(n) {
+		try {
+			await r(this.STORAGE_KEY, (e) => {
+				let { chainId: r } = n, i = e ?? {};
+				return i[r] || (i[r] = []), i[r] = i[r].filter((e) => !t(e, n)), i;
+			}), n.isSpam && await this.storeUnhiddenSpamToken(n);
+		} catch (t) {
+			e.error("Error showing token", t);
+		}
+	}
+	async storeUnhiddenSpamToken(n) {
+		let { chainId: i } = n;
+		try {
+			await r(this.UNHIDDEN_SPAM_KEY, (e) => {
+				let r = e ?? {};
+				return r[i] || (r[i] = []), r[i].some((e) => t(e, n)) || r[i].push(n), r;
+			});
+		} catch (t) {
+			e.error("Error storing unhidden spam token", t);
+		}
+	}
+	async deleteUnhiddenSpamToken(e) {
+		await r(this.UNHIDDEN_SPAM_KEY, (n) => {
+			let { chainId: r } = e, i = n ?? {};
+			return i[r] = i[r]?.filter((n) => !t(n, e)), i;
+		});
+	}
+	async getUnhiddenSpamTokens(t) {
+		try {
+			return (await n(this.UNHIDDEN_SPAM_KEY))?.[t] || [];
+		} catch (t) {
+			return e.error("Error retrieving unhidden spam tokens", t), [];
+		}
+	}
+	async hideUnnecessarySpamTokens(e, n) {
+		let r = await this.getUnhiddenSpamTokens(e), i = n.filter((e) => e.isSpam ? !r.some((n) => t(n, e)) : !1);
+		await Promise.all(i.map((e) => this.hideToken(e)));
+	}
+	async hideSpamsAndFetchHiddenTokensAddresses(e, t) {
+		return await this.hideUnnecessarySpamTokens(e, t), this.getHiddenTokenAddresses(e);
+	}
+}();
+//#endregion
+export { i as tokenVisibilityStorage };

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

@@ -0,0 +1,10 @@
+export declare class ValueCache<T> {
+    constructor(timeoutInMs: number);
+    protected timeoutInMs: number;
+    values: {
+        [key: string]: T;
+    };
+    private setTimer;
+    private onTimeout;
+    clear(): void;
+}

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

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

package/common/src/data-structures/cacheDevices/AttachableMemoryCacheDevice.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/serialize.utils.cjs`),t=require(`./BaseCacheDevice.cjs`);var n=class extends t.BaseCacheDevice{isAttached=!1;get(e){return this.getInMemory(e)}set(e,t){this.setInMemory(e,t)}serialize(){return Object.fromEntries([...this.inMemoryCache].map(([t,n])=>[t,e.CustomJSONStringify(n)]))}attach(t){if(this.isAttached)throw Error(`can't reattach cache device`);return this.isAttached=!0,(...n)=>{let r=e.CustomJSONStringify(n),i=this.get(r);if(i!==void 0)return i;let a=t(...n);return this.set(r,a),a}}};exports.AttachableMemoryCacheDevice=n;

package/common/src/data-structures/cacheDevices/AttachableMemoryCacheDevice.d.ts

@@ -0,0 +1,8 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class AttachableMemoryCacheDevice<T> extends BaseCacheDevice<T> {
+    private isAttached;
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    serialize(): Record<string, string>;
+    attach<ArgsType extends unknown[]>(func: (...args: ArgsType) => T): (...args: ArgsType) => T;
+}

package/common/src/data-structures/cacheDevices/AttachableMemoryCacheDevice.mjs

@@ -0,0 +1,26 @@
+import { CustomJSONStringify as e } from "../../functions/utils/serialize.utils.mjs";
+import { BaseCacheDevice as t } from "./BaseCacheDevice.mjs";
+//#region libs/shared/common/src/data-structures/cacheDevices/AttachableMemoryCacheDevice.ts
+var n = class extends t {
+	isAttached = !1;
+	get(e) {
+		return this.getInMemory(e);
+	}
+	set(e, t) {
+		this.setInMemory(e, t);
+	}
+	serialize() {
+		return Object.fromEntries([...this.inMemoryCache].map(([t, n]) => [t, e(n)]));
+	}
+	attach(t) {
+		if (this.isAttached) throw Error("can't reattach cache device");
+		return this.isAttached = !0, (...n) => {
+			let r = e(n), i = this.get(r);
+			if (i !== void 0) return i;
+			let a = t(...n);
+			return this.set(r, a), a;
+		};
+	}
+};
+//#endregion
+export { n as AttachableMemoryCacheDevice };

package/common/src/data-structures/cacheDevices/BaseCacheDevice.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/serialize.utils.cjs`);var t=class{inMemoryCache=new Map;constructor(e){e&&this.mergeWithSerialized(e)}getInMemory(e){return this.inMemoryCache.get(e)??void 0}setInMemory(e,t){this.inMemoryCache.set(e,t)}mergeWithSerialized(t){Object.entries(t).forEach(([t,n])=>{this.set(t,e.CustomJSONParse(n))})}};exports.BaseCacheDevice=t;

package/common/src/data-structures/cacheDevices/BaseCacheDevice.d.ts

@@ -0,0 +1,11 @@
+import { ICacheDevice } from '../../types/ICacheDevice';
+export declare abstract class BaseCacheDevice<T = string> implements ICacheDevice<T> {
+    protected inMemoryCache: Map<string, T>;
+    constructor(serialized?: Record<string, string>);
+    protected getInMemory(key: string): T | undefined;
+    protected setInMemory(key: string, value: T): void;
+    abstract get(key: string): T | undefined;
+    abstract set(key: string, value: T): void;
+    abstract serialize(): Record<string, string>;
+    mergeWithSerialized(serialized: Record<string, string>): void;
+}

package/common/src/data-structures/cacheDevices/BaseCacheDevice.mjs

@@ -0,0 +1,21 @@
+import { CustomJSONParse as e } from "../../functions/utils/serialize.utils.mjs";
+//#region libs/shared/common/src/data-structures/cacheDevices/BaseCacheDevice.ts
+var t = class {
+	inMemoryCache = /* @__PURE__ */ new Map();
+	constructor(e) {
+		e && this.mergeWithSerialized(e);
+	}
+	getInMemory(e) {
+		return this.inMemoryCache.get(e) ?? void 0;
+	}
+	setInMemory(e, t) {
+		this.inMemoryCache.set(e, t);
+	}
+	mergeWithSerialized(t) {
+		Object.entries(t).forEach(([t, n]) => {
+			this.set(t, e(n));
+		});
+	}
+};
+//#endregion
+export { t as BaseCacheDevice };

package/common/src/data-structures/cacheDevices/FileCacheDevice.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/serialize.utils.cjs`),t=require(`./BaseCacheDevice.cjs`),n=require(`../../error-handling/logError.cjs`);var r=class extends t.BaseCacheDevice{filePath;useFileCache;constructor(e,t){super(),this.useFileCache=!!e,this.filePath=t,this.readFileFromDevice()}readFileFromDevice(){if(this.useFileCache&&this.filePath)try{let e=require(`fs`);if(e.existsSync(this.filePath)){let t=JSON.parse(e.readFileSync(this.filePath).toString());Object.entries(t).forEach(([e,t])=>{this.setInMemory(e,t)})}}catch(e){n.logError(`FileCacheDevice Constructor Error`,{err:e})}}get(e){return this.getInMemory(e)}set(t,r){if(this.readFileFromDevice(),this.setInMemory(t,r),this.useFileCache&&this.filePath)try{require(`fs`).writeFileSync(this.filePath,e.safeJsonStringify(Object.fromEntries(this.inMemoryCache)))}catch(e){n.logError(`FileCacheDevice set function`,{err:e})}}serialize(){return Object.fromEntries([...this.inMemoryCache].map(([t,n])=>[t,e.CustomJSONStringify(n)]))}};exports.FileCacheDevice=r;

package/common/src/data-structures/cacheDevices/FileCacheDevice.d.ts

@@ -0,0 +1,10 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class FileCacheDevice extends BaseCacheDevice {
+    private filePath;
+    private useFileCache;
+    constructor(useFileCache: boolean | undefined, filePath: string);
+    private readFileFromDevice;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    serialize(): Record<string, string>;
+}

package/common/src/data-structures/cacheDevices/FileCacheDevice.mjs

@@ -0,0 +1,40 @@
+import { __require as e } from "../../../../_virtual/_rolldown/runtime.mjs";
+import { CustomJSONStringify as t, safeJsonStringify as n } from "../../functions/utils/serialize.utils.mjs";
+import { BaseCacheDevice as r } from "./BaseCacheDevice.mjs";
+import { logError as i } from "../../error-handling/logError.mjs";
+//#region libs/shared/common/src/data-structures/cacheDevices/FileCacheDevice.ts
+var a = class extends r {
+	filePath;
+	useFileCache;
+	constructor(e, t) {
+		super(), this.useFileCache = !!e, this.filePath = t, this.readFileFromDevice();
+	}
+	readFileFromDevice() {
+		if (this.useFileCache && this.filePath) try {
+			let t = e("fs");
+			if (t.existsSync(this.filePath)) {
+				let e = JSON.parse(t.readFileSync(this.filePath).toString());
+				Object.entries(e).forEach(([e, t]) => {
+					this.setInMemory(e, t);
+				});
+			}
+		} catch (e) {
+			i("FileCacheDevice Constructor Error", { err: e });
+		}
+	}
+	get(e) {
+		return this.getInMemory(e);
+	}
+	set(t, r) {
+		if (this.readFileFromDevice(), this.setInMemory(t, r), this.useFileCache && this.filePath) try {
+			e("fs").writeFileSync(this.filePath, n(Object.fromEntries(this.inMemoryCache)));
+		} catch (e) {
+			i("FileCacheDevice set function", { err: e });
+		}
+	}
+	serialize() {
+		return Object.fromEntries([...this.inMemoryCache].map(([e, n]) => [e, t(n)]));
+	}
+};
+//#endregion
+export { a as FileCacheDevice };

package/common/src/data-structures/cacheDevices/LocalStorageCacheDevice.cjs

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/serialize.utils.cjs`),t=require(`./BaseCacheDevice.cjs`);var n=class extends t.BaseCacheDevice{localDataStorage;constructor(e,t){super(),!e&&typeof localStorage<`u`&&(this.localDataStorage=localStorage),t&&this.mergeWithSerialized(t)}get(e){return this.localDataStorage?this.localDataStorage.getItem(e)??void 0:this.getInMemory(e)}set(e,t){this.localDataStorage?this.localDataStorage.setItem(e,t):this.setInMemory(e,t)}serialize(){let t=this.localDataStorage?Object.entries(localStorage):[...this.inMemoryCache];return Object.fromEntries(t.map(([t,n])=>[t,e.CustomJSONStringify(n)]))}};exports.LocalStorageCacheDevice=n;

package/common/src/data-structures/cacheDevices/LocalStorageCacheDevice.d.ts

@@ -0,0 +1,8 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class LocalStorageCacheDevice extends BaseCacheDevice {
+    private localDataStorage;
+    constructor(disableCaching?: boolean, serializedCache?: Record<string, string>);
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    serialize(): Record<string, string>;
+}

package/common/src/data-structures/cacheDevices/LocalStorageCacheDevice.mjs

@@ -0,0 +1,21 @@
+import { CustomJSONStringify as e } from "../../functions/utils/serialize.utils.mjs";
+import { BaseCacheDevice as t } from "./BaseCacheDevice.mjs";
+//#region libs/shared/common/src/data-structures/cacheDevices/LocalStorageCacheDevice.ts
+var n = class extends t {
+	localDataStorage;
+	constructor(e, t) {
+		super(), !e && typeof localStorage < "u" && (this.localDataStorage = localStorage), t && this.mergeWithSerialized(t);
+	}
+	get(e) {
+		return this.localDataStorage ? this.localDataStorage.getItem(e) ?? void 0 : this.getInMemory(e);
+	}
+	set(e, t) {
+		this.localDataStorage ? this.localDataStorage.setItem(e, t) : this.setInMemory(e, t);
+	}
+	serialize() {
+		let t = this.localDataStorage ? Object.entries(localStorage) : [...this.inMemoryCache];
+		return Object.fromEntries(t.map(([t, n]) => [t, e(n)]));
+	}
+};
+//#endregion
+export { n as LocalStorageCacheDevice };

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

@@ -0,0 +1 @@
+require(`./FileCacheDevice.cjs`),require(`./LocalStorageCacheDevice.cjs`);

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

@@ -0,0 +1,2 @@
+export * from './FileCacheDevice';
+export * from './LocalStorageCacheDevice';

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

@@ -0,0 +1,2 @@
+import "./FileCacheDevice.mjs";
+import "./LocalStorageCacheDevice.mjs";

package/common/src/data-structures/crypto-keys/decodeUTXO.cjs

@@ -0,0 +1 @@
+require(`../../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../constants/chains.constants.cjs`),t=require(`../../crypto/poseidon.cjs`);require(`./keys.cjs`);const n=require(`../utxo/Utxo.cjs`);let r=require(`ethers`),i=require(`@solana/web3.js`);var a=`solana-on-chain-utxo:`,o=8,s=e=>{if(e.length!==o)throw Error(`Expected ${o} on-chain fields, received ${e.length}`);let t=e.map((e,t)=>{let n=e instanceof Uint8Array?e:Uint8Array.from(e);if(n.length!==32)throw Error(`Expected bytes32 length 32 at position ${t}, got ${n.length}`);return`0x${Buffer.from(n).toString(`hex`)}`});return`${a}${r.ethers.AbiCoder.defaultAbiCoder().encode([`bytes32[8]`],[t])}`},c=e=>e.startsWith(a),l=e=>{if(!c(e))throw Error(`Invalid encoded Solana UTXO payload`);let[n]=r.ethers.AbiCoder.defaultAbiCoder().decode([`bytes32[8]`],e.slice(21)),a=n;if(!Array.isArray(a)||a.length!==o)throw Error(`Malformed encoded Solana UTXO payload`);let[s,l,u,d,f,p,m,h]=a,g=BigInt(s),_=BigInt(d),v=r.ethers.toBeHex(BigInt(f)),y=BigInt(p),b=BigInt(m),x=BigInt(h).toString(),S=Array.from(r.ethers.getBytes(l)),C=Array.from(r.ethers.getBytes(u)),w=new i.PublicKey(Uint8Array.from([...S.slice(16),...C.slice(16)])).toBase58();return{amount:g,erc20TokenAddress:t.poseidonHash(BigInt(l),BigInt(u)),mintAddress:w,randomization:_,stealthAddress:v,H0:y,H1:b,timeStamp:x}},u=e=>{let t=r.ethers.AbiCoder.defaultAbiCoder().decode([`uint256`,`address`,`tuple(uint256, uint256, uint256, uint256)`,`uint256`,`uint256`],e);return{amount:BigInt(t[0]),erc20TokenAddress:t[1],randomization:BigInt(t[2][0]),stealthAddress:r.ethers.toBeHex(BigInt(t[2][1])),H0:BigInt(t[2][2]),H1:BigInt(t[2][3]),timeStamp:BigInt(t[3]).toString(),tokenId:Number(t[4])}},d=(t,n,r)=>{if(e.isSolanaLike(r)){let{amount:e,erc20TokenAddress:r,mintAddress:i,randomization:a,stealthAddress:o,timeStamp:s}=l(t);return{amount:e,erc20TokenAddress:r,mintAddress:i,timeStamp:s,tokenId:0,randomization:a,shieldedPrivateKey:n,stealthAddress:o}}let{amount:i,erc20TokenAddress:a,timeStamp:o,tokenId:s,randomization:c,stealthAddress:d}=u(t);return{amount:i,erc20TokenAddress:a,timeStamp:o,tokenId:s,randomization:c,shieldedPrivateKey:n,stealthAddress:d}},f=(e,t,r)=>new n.Utxo(d(e,t,r));exports.abiDecodeUtxo=u,exports.decodeSolanaOnChainUtxo=l,exports.decodeUtxo=f,exports.decodeUtxoConstructorArgs=d,exports.encodeSolanaOnChainUtxo=s,exports.isSolanaOnChainUtxo=c;

package/common/src/data-structures/crypto-keys/decodeUTXO.d.ts

@@ -0,0 +1,26 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+export declare const encodeSolanaOnChainUtxo: (onChainData: number[][]) => string;
+export declare const isSolanaOnChainUtxo: (encodedOutput: string) => boolean;
+export declare const decodeSolanaOnChainUtxo: (encodedOutput: string) => {
+    amount: bigint;
+    erc20TokenAddress: string;
+    mintAddress: string;
+    randomization: bigint;
+    stealthAddress: string;
+    H0: bigint;
+    H1: bigint;
+    timeStamp: string;
+};
+export declare const abiDecodeUtxo: (encryptedOutput: string) => {
+    amount: bigint;
+    erc20TokenAddress: string;
+    randomization: bigint;
+    stealthAddress: string;
+    H0: bigint;
+    H1: bigint;
+    timeStamp: string;
+    tokenId: number;
+};
+export declare const decodeUtxoConstructorArgs: (encryptedOutput: string, privateKey: string, chainId: number) => IUtxoConstructor;
+export declare const decodeUtxo: (encryptedOutput: string, privateKey: string, chainId: number) => Utxo;
+export declare const checkUtxoSignature: (encryptedOutput: string, privateKey: string, chainId: number) => boolean;