@hinkal/react-native 0.3.1

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

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

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): Promise<ERC20Token[]>;
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+}
+export declare const publicTokensDB: PublicTokensDB;

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

@@ -0,0 +1,32 @@
+import { chainIds as e, isSolanaLike as t, isTempo as n, isTronLike as r } from "../../constants/chains.constants.mjs";
+import { Logger as i } from "../../error-handling/logger.mjs";
+import { getStateKey as a } from "../../functions/utils/string.utils.mjs";
+import { alchemyPublicTokensDB as o } from "./AlchemyPublicTokensDB.mjs";
+import { eventsPublicTokensDB as s } from "./EventsPublicTokensDB.mjs";
+import { arcPublicTokensDB as c } from "./ArcPublicTokensDB.mjs";
+import { tronPublicTokensDB as l } from "./TronPublicTokensDB.mjs";
+import { tempoPublicTokensDB as u } from "./TempoPublicTokensDB.mjs";
+//#region common/src/data-structures/TokenDBs/PublicTokensDB.ts
+var d = class {
+	useAlternativeDB = {};
+	async getPublicTokens(t, i) {
+		let d = a(i, t);
+		return this.useAlternativeDB[d] ? s.getPublicTokens(t, i) : t === e.arcTestnet ? c.getPublicTokens(i) : r(t) ? l.getPublicTokens(i, t) : n(t) ? u.getPublicTokens(i, t) : o.getPublicTokens(t, i);
+	}
+	async getFetchedTokens(t, i) {
+		let d = a(i, t);
+		return this.useAlternativeDB[d] ? s.getFetchedTokens(t, i) : t === e.arcTestnet ? c.getFetchedTokens(i) : r(t) ? l.getFetchedTokens(i, t) : n(t) ? u.getFetchedTokens(i, t) : o.getFetchedTokens(t, i);
+	}
+	async fetchAndUpdatePublicTokens(d, f) {
+		let p = a(d, f);
+		try {
+			f === e.arcTestnet ? await c.fetchAndUpdatePublicTokens(d) : r(f) ? await l.fetchAndUpdatePublicTokens(d, f) : n(f) ? await u.fetchAndUpdatePublicTokens(d, f) : await o.fetchAndUpdatePublicTokens(d, f), this.useAlternativeDB[p] = !1;
+		} catch (e) {
+			if (i.error("error", e), t(f)) return;
+			await s.fetchAndUpdatePublicTokens(d, f), this.useAlternativeDB[p] = !0;
+		}
+	}
+};
+new d();
+//#endregion
+export { d as PublicTokensDB };

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

@@ -0,0 +1 @@
+const e=require(`../../functions/utils/caseInsensitive.utils.cjs`),t=require(`../../../../shims/idb-keyval.cjs`),n=require(`../../types/cache.types.cjs`),r=require(`../../API/API.cjs`),i=require(`../../functions/utils/string.utils.cjs`),a=require(`./token-visibility-db.cjs`),o=require(`../../functions/utils/erc20tokenFunctions.cjs`),s=require(`../../functions/utils/publicBalance.utils.cjs`);var c=t.default,l=class{fetchedTokens={};async getPublicTokens(e,t){let r=i.getStateKey(e,t);return o.overlayTokensWithRegistryData((await(0,c.get)(n.StorageKeys.TEMPO_PUBLIC_TOKENS))?.[r]||[],t)}async getFetchedTokens(e,t){let n=i.getStateKey(e,t);return o.overlayTokensWithRegistryData(this.fetchedTokens[n]||[],t)}async fetchAndUpdatePublicTokens(t,o){let s=i.getStateKey(t,o),l=await this.getHeldTokenAddresses(t,o);if(!l.length)return;let u=(await r.API.tokensInfoCall(o,l)).filter(e=>!!e),d=await a.tokenVisibilityStorage.hideSpamsAndFetchHiddenTokensAddresses(o,u),f=u.filter(t=>!e.lowerCaseIncludes(d,t.erc20TokenAddress));await(0,c.update)(n.StorageKeys.TEMPO_PUBLIC_TOKENS,(e={})=>{let t={...e,[s]:f};return this.fetchedTokens=t,t})}async getHeldTokenAddresses(e,t){let n=await o.getErc20TokensForChainAPI(t),r=await Promise.all(n.map(async n=>{let r=await s.getPublicBalanceByTokenAddress(t,e,n.erc20TokenAddress);return r&&r>0n?n.erc20TokenAddress:null}));return Array.from(new Set(r.filter(e=>!!e)))}},u=new l;exports.TempoPublicTokensDB=l,exports.tempoPublicTokensDB=u;

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

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

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

@@ -0,0 +1,41 @@
+import { lowerCaseIncludes as e } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { require_idb_keyval as t } from "../../../../shims/idb-keyval.mjs";
+import { StorageKeys as n } from "../../types/cache.types.mjs";
+import { API as r } from "../../API/API.mjs";
+import { getStateKey as i } from "../../functions/utils/string.utils.mjs";
+import { tokenVisibilityStorage as a } from "./token-visibility-db.mjs";
+import { getErc20TokensForChainAPI as o, overlayTokensWithRegistryData as s } from "../../functions/utils/erc20tokenFunctions.mjs";
+import { getPublicBalanceByTokenAddress as c } from "../../functions/utils/publicBalance.utils.mjs";
+//#region common/src/data-structures/TokenDBs/TempoPublicTokensDB.ts
+var l = t(), u = class {
+	fetchedTokens = {};
+	async getPublicTokens(e, t) {
+		let r = i(e, t);
+		return s((await (0, l.get)(n.TEMPO_PUBLIC_TOKENS))?.[r] || [], t);
+	}
+	async getFetchedTokens(e, t) {
+		let n = i(e, t);
+		return s(this.fetchedTokens[n] || [], t);
+	}
+	async fetchAndUpdatePublicTokens(t, o) {
+		let s = i(t, o), c = await this.getHeldTokenAddresses(t, o);
+		if (!c.length) return;
+		let u = (await r.tokensInfoCall(o, c)).filter((e) => !!e), d = await a.hideSpamsAndFetchHiddenTokensAddresses(o, u), f = u.filter((t) => !e(d, t.erc20TokenAddress));
+		await (0, l.update)(n.TEMPO_PUBLIC_TOKENS, (e = {}) => {
+			let t = {
+				...e,
+				[s]: f
+			};
+			return this.fetchedTokens = t, t;
+		});
+	}
+	async getHeldTokenAddresses(e, t) {
+		let n = await o(t), r = await Promise.all(n.map(async (n) => {
+			let r = await c(t, e, n.erc20TokenAddress);
+			return r && r > 0n ? n.erc20TokenAddress : null;
+		}));
+		return Array.from(new Set(r.filter((e) => !!e)));
+	}
+}, d = new u();
+//#endregion
+export { u as TempoPublicTokensDB, d as tempoPublicTokensDB };

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

@@ -0,0 +1 @@
+const e=require(`../../constants/protocol.constants.cjs`),t=require(`../../functions/utils/caseInsensitive.utils.cjs`),n=require(`../../../../shims/idb-keyval.cjs`),r=require(`../../types/cache.types.cjs`),i=require(`../http/HttpClient.cjs`);require(`../http/index.cjs`);const a=require(`../../functions/utils/tron.utils.cjs`),o=require(`../../API/API.cjs`),s=require(`../../functions/utils/string.utils.cjs`),c=require(`./token-visibility-db.cjs`),l=require(`../../functions/utils/erc20tokenFunctions.cjs`);var u=n.default,d=class{fetchedTokens={};async getPublicTokens(e,t){let n=s.getStateKey(e,t);return l.overlayTokensWithRegistryData((await(0,u.get)(r.StorageKeys.TRON_PUBLIC_TOKENS))?.[n]||[],t)}async getFetchedTokens(e,t){let n=s.getStateKey(e,t);return l.overlayTokensWithRegistryData(this.fetchedTokens[n]||[],t)}async fetchAndUpdatePublicTokens(e,n){let i=s.getStateKey(e,n),a=await this.getHeldTokenAddresses(e,n);if(!a.length)return;let l=(await o.API.tokensInfoCall(n,a)).filter(e=>!!e),d=await c.tokenVisibilityStorage.hideSpamsAndFetchHiddenTokensAddresses(n,l),f=l.filter(e=>!t.lowerCaseIncludes(d,e.erc20TokenAddress));await(0,u.update)(r.StorageKeys.TRON_PUBLIC_TOKENS,(e={})=>{let t={...e,[i]:f};return this.fetchedTokens=t,t})}async getHeldTokenAddresses(t,n){let r=a.toTronBase58IfHex(t),o=`${a.getTronWalletRpcUrl(n)}/v1/accounts/${r}`,s=(await i.httpClient.get(o))?.data?.[0];if(!s)return[];let c=[];return s.balance&&s.balance>0&&c.push(e.zeroAddress),(s.trc20??[]).forEach(e=>{Object.entries(e).forEach(([e,t])=>{BigInt(t)>0n&&c.push(a.addressToHexFormat(e))})}),Array.from(new Set(c))}},f=new d;exports.TronPublicTokensDB=d,exports.tronPublicTokensDB=f;

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

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

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

@@ -0,0 +1,47 @@
+import { zeroAddress as e } from "../../constants/protocol.constants.mjs";
+import { lowerCaseIncludes as t } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { require_idb_keyval as n } from "../../../../shims/idb-keyval.mjs";
+import { StorageKeys as r } from "../../types/cache.types.mjs";
+import { httpClient as i } from "../http/HttpClient.mjs";
+import "../http/index.mjs";
+import { addressToHexFormat as a, getTronWalletRpcUrl as o, toTronBase58IfHex as s } from "../../functions/utils/tron.utils.mjs";
+import { API as c } from "../../API/API.mjs";
+import { getStateKey as l } from "../../functions/utils/string.utils.mjs";
+import { tokenVisibilityStorage as u } from "./token-visibility-db.mjs";
+import { overlayTokensWithRegistryData as d } from "../../functions/utils/erc20tokenFunctions.mjs";
+//#region common/src/data-structures/TokenDBs/TronPublicTokensDB.ts
+var f = n(), p = class {
+	fetchedTokens = {};
+	async getPublicTokens(e, t) {
+		let n = l(e, t);
+		return d((await (0, f.get)(r.TRON_PUBLIC_TOKENS))?.[n] || [], t);
+	}
+	async getFetchedTokens(e, t) {
+		let n = l(e, t);
+		return d(this.fetchedTokens[n] || [], t);
+	}
+	async fetchAndUpdatePublicTokens(e, n) {
+		let i = l(e, n), a = await this.getHeldTokenAddresses(e, n);
+		if (!a.length) return;
+		let o = (await c.tokensInfoCall(n, a)).filter((e) => !!e), s = await u.hideSpamsAndFetchHiddenTokensAddresses(n, o), d = o.filter((e) => !t(s, e.erc20TokenAddress));
+		await (0, f.update)(r.TRON_PUBLIC_TOKENS, (e = {}) => {
+			let t = {
+				...e,
+				[i]: d
+			};
+			return this.fetchedTokens = t, t;
+		});
+	}
+	async getHeldTokenAddresses(t, n) {
+		let r = s(t), c = `${o(n)}/v1/accounts/${r}`, l = (await i.get(c))?.data?.[0];
+		if (!l) return [];
+		let u = [];
+		return l.balance && l.balance > 0 && u.push(e), (l.trc20 ?? []).forEach((e) => {
+			Object.entries(e).forEach(([e, t]) => {
+				BigInt(t) > 0n && u.push(a(e));
+			});
+		}), Array.from(new Set(u));
+	}
+}, m = new p();
+//#endregion
+export { p as TronPublicTokensDB, m as tronPublicTokensDB };

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

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

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

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

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

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

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

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

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,79 @@
+import { require_idb_keyval as e } from "../../../../shims/idb-keyval.mjs";
+import { Logger as t } from "../../error-handling/logger.mjs";
+import { isSameERC20Token as n } from "../../functions/utils/token-check.utils.mjs";
+//#region common/src/data-structures/TokenDBs/token-visibility-db.ts
+var r = e(), i = new class {
+	STORAGE_KEY = "hiddenTokenAddresses";
+	UNHIDDEN_SPAM_KEY = "unhiddenSpamTokens";
+	async getHiddenTokens(e) {
+		try {
+			return (await (0, r.get)(this.STORAGE_KEY))?.[e] || [];
+		} catch (e) {
+			return t.error("Error retrieving hidden tokens", e), [];
+		}
+	}
+	async getHiddenTokenAddresses(e) {
+		try {
+			return (await this.getHiddenTokens(e)).map(({ erc20TokenAddress: e }) => e.toLowerCase());
+		} catch (e) {
+			return t.error("Error retrieving hidden tokens", e), [];
+		}
+	}
+	async filterOutHiddenTokens(e, t) {
+		let r = await this.getHiddenTokens(e);
+		return t.filter((e) => !r.some((t) => n(t, e)));
+	}
+	async hideToken(e) {
+		try {
+			await (0, r.update)(this.STORAGE_KEY, (t) => {
+				let r = t ?? {}, { chainId: i } = e;
+				return r[i] || (r[i] = []), r[i].some((t) => n(t, e)) || r[i].push(e), r;
+			}), e.isSpam && await this.deleteUnhiddenSpamToken(e);
+		} catch (e) {
+			t.error("Error hiding token", e);
+		}
+	}
+	async showToken(e) {
+		try {
+			await (0, r.update)(this.STORAGE_KEY, (t) => {
+				let { chainId: r } = e, i = t ?? {};
+				return i[r] || (i[r] = []), i[r] = i[r].filter((t) => !n(t, e)), i;
+			}), e.isSpam && await this.storeUnhiddenSpamToken(e);
+		} catch (e) {
+			t.error("Error showing token", e);
+		}
+	}
+	async storeUnhiddenSpamToken(e) {
+		let { chainId: i } = e;
+		try {
+			await (0, r.update)(this.UNHIDDEN_SPAM_KEY, (t) => {
+				let r = t ?? {};
+				return r[i] || (r[i] = []), r[i].some((t) => n(t, e)) || r[i].push(e), r;
+			});
+		} catch (e) {
+			t.error("Error storing unhidden spam token", e);
+		}
+	}
+	async deleteUnhiddenSpamToken(e) {
+		await (0, r.update)(this.UNHIDDEN_SPAM_KEY, (t) => {
+			let { chainId: r } = e, i = t ?? {};
+			return i[r] = i[r]?.filter((t) => !n(t, e)), i;
+		});
+	}
+	async getUnhiddenSpamTokens(e) {
+		try {
+			return (await (0, r.get)(this.UNHIDDEN_SPAM_KEY))?.[e] || [];
+		} catch (e) {
+			return t.error("Error retrieving unhidden spam tokens", e), [];
+		}
+	}
+	async hideUnnecessarySpamTokens(e, t) {
+		let r = await this.getUnhiddenSpamTokens(e), i = t.filter((e) => e.isSpam ? !r.some((t) => n(t, 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/WalletManager/WalletManager.d.ts

@@ -0,0 +1,51 @@
+export declare class WalletManager {
+    private mainWallet;
+    private tronMainWallet;
+    private mnemonicPhrase;
+    private readonly ethDerivationBasePath;
+    private readonly tronDerivationBasePath;
+    generateMnemonic(wordCount?: 12 | 24): string[];
+    isValidMnemonic(mnemonic: string): boolean;
+    isValidWord(word: string): boolean;
+    createEvmWallet(index: number): {
+        address: string;
+        privateKey: string;
+    };
+    createTronWallet(index: number): {
+        address: string;
+        privateKey: string;
+    };
+    createSolanaAccount(accountIndex?: number): Promise<{
+        publicKey: string;
+        secretKey: string;
+    }>;
+    createChildWallet(index: number): Promise<{
+        ethereum: {
+            address: string;
+            privateKey: string;
+        };
+        tron: {
+            address: string;
+            privateKey: string;
+        };
+        solana: {
+            publicKey: string;
+            secretKey: string;
+        };
+    }>;
+    private deriveEd25519Path;
+    createMainWallet(mnemonic: string): Promise<{
+        ethereum: {
+            address: string;
+            privateKey: string;
+        };
+        tron: {
+            address: string;
+            privateKey: string;
+        };
+        solana: {
+            publicKey: string;
+            secretKey: string;
+        };
+    }>;
+}

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

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

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 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 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(`../../../../shims/fs.cjs`),n=require(`./BaseCacheDevice.cjs`),r=require(`../../error-handling/logError.cjs`);var i=class extends n.BaseCacheDevice{filePath;useFileCache;constructor(e,t){super(),this.useFileCache=!!e,this.filePath=t,this.readFileFromDevice()}readFileFromDevice(){if(this.useFileCache&&this.filePath)try{let e=t.default;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){r.logError(`FileCacheDevice Constructor Error`,{err:e})}}get(e){return this.getInMemory(e)}set(n,i){if(this.readFileFromDevice(),this.setInMemory(n,i),this.useFileCache&&this.filePath)try{t.default.writeFileSync(this.filePath,e.safeJsonStringify(Object.fromEntries(this.inMemoryCache)))}catch(e){r.logError(`FileCacheDevice set function`,{err:e})}}serialize(){return Object.fromEntries([...this.inMemoryCache].map(([t,n])=>[t,e.CustomJSONStringify(n)]))}};exports.FileCacheDevice=i;

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 { CustomJSONStringify as e, safeJsonStringify as t } from "../../functions/utils/serialize.utils.mjs";
+import { require_fs as n } from "../../../../shims/fs.mjs";
+import { BaseCacheDevice as r } from "./BaseCacheDevice.mjs";
+import { logError as i } from "../../error-handling/logError.mjs";
+//#region 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 e = n();
+			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) {
+			i("FileCacheDevice Constructor Error", { err: e });
+		}
+	}
+	get(e) {
+		return this.getInMemory(e);
+	}
+	set(e, r) {
+		if (this.readFileFromDevice(), this.setInMemory(e, r), this.useFileCache && this.filePath) try {
+			n().writeFileSync(this.filePath, t(Object.fromEntries(this.inMemoryCache)));
+		} catch (e) {
+			i("FileCacheDevice set function", { err: e });
+		}
+	}
+	serialize() {
+		return Object.fromEntries([...this.inMemoryCache].map(([t, n]) => [t, e(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 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`),r=require(`../../functions/utils/bit.operations.cjs`);let i=require(`ethers`),a=require(`@solana/web3.js`);var o=`solana-on-chain-utxo:`,s=8,c=e=>{if(e.length!==s)throw Error(`Expected ${s} 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`${o}${i.ethers.AbiCoder.defaultAbiCoder().encode([`bytes32[8]`],[t])}`},l=e=>e.startsWith(o),u=e=>{if(!l(e))throw Error(`Invalid encoded Solana UTXO payload`);let[n]=i.ethers.AbiCoder.defaultAbiCoder().decode([`bytes32[8]`],e.slice(21)),o=n;if(!Array.isArray(o)||o.length!==s)throw Error(`Malformed encoded Solana UTXO payload`);let[c,u,d,f,p,m,h,g]=o,_=BigInt(c),v=BigInt(f),y=r.extractHighestBit(v)===1n,b=r.takeOffHighestBit(v),x=i.ethers.toBeHex(BigInt(p)),S=BigInt(m),C=BigInt(h),w=BigInt(g).toString(),T=Array.from(i.ethers.getBytes(u)),E=Array.from(i.ethers.getBytes(d)),D=new a.PublicKey(Uint8Array.from([...T.slice(16),...E.slice(16)])).toBase58();return{amount:_,erc20TokenAddress:t.poseidonHash(BigInt(u),BigInt(d)),mintAddress:D,randomization:b,stealthAddress:x,H0:S,H1:C,timeStamp:w,isNewStyle:y}},d=e=>{let t=i.ethers.AbiCoder.defaultAbiCoder().decode([`uint256`,`address`,`tuple(uint256, uint256, uint256, uint256)`,`uint256`,`uint256`],e),n=BigInt(t[0]),a=t[1],o=BigInt(t[2][0]),s=r.extractHighestBit(o),c=r.takeOffHighestBit(o),l=i.ethers.toBeHex(BigInt(t[2][1])),u=BigInt(t[2][2]),d=BigInt(t[2][3]),f=BigInt(t[3]).toString(),p=Number(t[4]);return{amount:n,erc20TokenAddress:a,randomization:c,isNewStyle:s===1n,stealthAddress:l,H0:u,H1:d,timeStamp:f,tokenId:p}},f=(t,n,r)=>{if(e.isSolanaLike(r)){let{amount:e,erc20TokenAddress:r,mintAddress:i,randomization:a,stealthAddress:o,timeStamp:s,isNewStyle:c,H0:l}=u(t);return{amount:e,erc20TokenAddress:r,mintAddress:i,timeStamp:s,nullifyingKey:n,stealthAddress:o,isNewStyle:c,...c?{H0:[a,l]}:{randomization:a}}}let{amount:i,erc20TokenAddress:a,timeStamp:o,randomization:s,isNewStyle:c,stealthAddress:l,H0:f}=d(t);return{amount:i,erc20TokenAddress:a,timeStamp:o,nullifyingKey:n,stealthAddress:l,isNewStyle:c,...c?{H0:[s,f]}:{randomization:s}}},p=(e,t,r)=>new n.Utxo(f(e,t,r));exports.decodeEvmUtxo=d,exports.decodeSolanaUtxo=u,exports.decodeUtxo=p,exports.decodeUtxoConstructorArgs=f,exports.encodeSolanaOnChainUtxo=c,exports.isSolanaOnChainUtxo=l;

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

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