@kapa123456789/sdk 0.0.39 → 0.0.40

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/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/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.d.ts

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

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`),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.decodeUtxo=f,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;

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

@@ -0,0 +1,74 @@
+import { isSolanaLike as e } from "../../constants/chains.constants.mjs";
+import { poseidonHash as t } from "../../crypto/poseidon.mjs";
+import { Utxo as n } from "../utxo/Utxo.mjs";
+import { ethers as r } from "ethers";
+import { PublicKey as i } from "@solana/web3.js";
+//#region libs/shared/common/src/data-structures/crypto-keys/decodeUTXO.ts
+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.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.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.toBeHex(BigInt(f)), y = BigInt(p), b = BigInt(m), x = BigInt(h).toString(), S = Array.from(r.getBytes(l)), C = Array.from(r.getBytes(u)), w = new i(Uint8Array.from([...S.slice(16), ...C.slice(16)])).toBase58();
+	return {
+		amount: g,
+		erc20TokenAddress: t(BigInt(l), BigInt(u)),
+		mintAddress: w,
+		randomization: _,
+		stealthAddress: v,
+		H0: y,
+		H1: b,
+		timeStamp: x
+	};
+}, u = (e) => {
+	let t = r.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.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(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(d(e, t, r));
+//#endregion
+export { f as decodeUtxo, s as encodeSolanaOnChainUtxo, c as isSolanaOnChainUtxo };

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

@@ -0,0 +1 @@
+const e=require(`../../../../_virtual/_rolldown/runtime.cjs`);let t=require(`ethers`),n=require(`@solana/web3.js`),r=require(`libsodium-wrappers`);r=e.__toESM(r);var i=e=>e.startsWith(`0x`)?e:`0x${e}`,a=e=>{let a=[Buffer.from(t.ethers.toBeHex(e.amount)),Buffer.from(i(e.erc20TokenAddress)),Buffer.from(t.ethers.toBeHex(e.randomization)),Buffer.from(i(e.getStealthAddress())),Buffer.from(t.ethers.toBeHex(BigInt(e.timeStamp))),Buffer.from(t.ethers.toBeHex(BigInt(e.tokenId??0)))];if(e.mintAddress){let r=new n.PublicKey(e.mintAddress),i=t.ethers.hexlify(r.toBytes());a.push(Buffer.from(i))}let o=Buffer.concat(a);return r.default.crypto_box_seal(o,t.ethers.getBytes(e.getEncryptionKey()))};exports.encryptUtxo=a;

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

@@ -0,0 +1,18 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+import { UserKeys } from './keys';
+/**
+ * encrypt data for the UTXO
+ * @param amount UTXO amount
+ * @param blinding UTXO blinding
+ * @param publicKey sender's encryption public key
+ * @returns returns encrypted data {Uint8Array}
+ */
+export declare const encryptUtxo: (utxo: Utxo) => Uint8Array;
+export declare const decryptUtxoConstructorArgs: (encryptedData: Uint8Array, userKeys: UserKeys) => IUtxoConstructor;
+/**
+ * decrypt UTXO data from events
+ * @param encryptedData encrypted UTXO data {Uint8Array}
+ * @param publicKey/privateKey sender's encryption keys
+ * @returns decrypted UTXO data Object {amount, blinding}
+ */
+export declare const decryptUtxo: (encryptedData: Uint8Array, userKeys: UserKeys) => Utxo;

package/common/src/data-structures/crypto-keys/encryptDecryptUtxo.mjs

@@ -0,0 +1,22 @@
+import { ethers as e } from "ethers";
+import { PublicKey as t } from "@solana/web3.js";
+import n from "libsodium-wrappers";
+//#region libs/shared/common/src/data-structures/crypto-keys/encryptDecryptUtxo.ts
+var r = (e) => e.startsWith("0x") ? e : `0x${e}`, i = (i) => {
+	let a = [
+		Buffer.from(e.toBeHex(i.amount)),
+		Buffer.from(r(i.erc20TokenAddress)),
+		Buffer.from(e.toBeHex(i.randomization)),
+		Buffer.from(r(i.getStealthAddress())),
+		Buffer.from(e.toBeHex(BigInt(i.timeStamp))),
+		Buffer.from(e.toBeHex(BigInt(i.tokenId ?? 0)))
+	];
+	if (i.mintAddress) {
+		let n = new t(i.mintAddress), r = e.hexlify(n.toBytes());
+		a.push(Buffer.from(r));
+	}
+	let o = Buffer.concat(a);
+	return n.crypto_box_seal(o, e.getBytes(i.getEncryptionKey()));
+};
+//#endregion
+export { i as encryptUtxo };

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

@@ -0,0 +1,4 @@
+export * from './decodeUTXO';
+export * from './encryptDecryptUtxo';
+export * from './keys';
+export * from './keyUtils';

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

@@ -0,0 +1 @@
+const e=require(`../../constants/protocol.constants.cjs`);var t=t=>{if(t<0n||t>=21888242871839275222246405745257275088548364400416034343698204186575808495617n)throw RangeError();return t>e.CIRCOM_P_HALF},n=e=>t(e)?1n:0n;exports.getCircomSign=n;

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

@@ -0,0 +1,2 @@
+export declare const isCircomNegative: (n: bigint) => boolean;
+export declare const getCircomSign: (n: bigint) => 0n | 1n;

package/common/src/data-structures/crypto-keys/keyUtils.mjs

@@ -0,0 +1,8 @@
+import { CIRCOM_P_HALF as e } from "../../constants/protocol.constants.mjs";
+//#region libs/shared/common/src/data-structures/crypto-keys/keyUtils.ts
+var t = (t) => {
+	if (t < 0n || t >= 21888242871839275222246405745257275088548364400416034343698204186575808495617n) throw RangeError();
+	return t > e;
+}, n = (e) => t(e) ? 1n : 0n;
+//#endregion
+export { n as getCircomSign };

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

@@ -0,0 +1 @@
+const e=require(`../../../../_virtual/_rolldown/runtime.cjs`),t=require(`../../constants/protocol.constants.cjs`),n=require(`../../crypto/poseidon.cjs`),r=require(`../../crypto/babyJub.cjs`),i=require(`../cacheDevices/AttachableMemoryCacheDevice.cjs`),a=require(`./keyUtils.cjs`);let o=require(`ethers`),s=require(`@solana/web3.js`),c=require(`bs58`);c=e.__toESM(c);let l=require(`libsodium-wrappers`);l=e.__toESM(l);let u=require(`tweetnacl`);u=e.__toESM(u);var d=new i.AttachableMemoryCacheDevice,f=new i.AttachableMemoryCacheDevice,p=class{signature;shieldedPrivateKey;constructor(e,t){this.signature=e,this.shieldedPrivateKey=t}getSignature(){return this.requireSignature(),this.signature}setSignature(e){this.signature=e}requireSignature(){if(!this.signature)throw Error(`No signature provided`)}requireKeyMaterial(){if(!this.signature&&!this.shieldedPrivateKey)throw Error(`No signature or shielded private key provided`)}verifyMessage(e){return this.requireSignature(),o.ethers.verifyMessage(e,this.signature)}verifySolanaMessage(e,t){this.requireSignature();let n=new TextEncoder().encode(e),r=o.ethers.getBytes(this.signature),i=new s.PublicKey(t).toBytes();return u.default.sign.detached.verify(n,r,i)}getShieldedPrivateKey=()=>(this.requireKeyMaterial(),this.shieldedPrivateKey||=o.ethers.keccak256(this.signature),this.shieldedPrivateKey);getShieldedPublicKey=()=>(this.requireKeyMaterial(),n.poseidonHash(this.getShieldedPrivateKey()));getShieldedPrivateKeyFromNonce=e=>{this.requireKeyMaterial();let t=n.poseidonHash(e,this.getShieldedPrivateKey(),this.getShieldedPublicKey());return o.ethers.keccak256(o.ethers.toUtf8Bytes(`hinkal-offchain-shielded-key:${t}`))};getDerivedEthereumAddress=()=>(this.requireKeyMaterial(),new o.ethers.Wallet(this.getShieldedPrivateKey()).address);getDerivedSolanaPublicKey=()=>(this.requireKeyMaterial(),s.Keypair.fromSeed(o.ethers.getBytes(this.getShieldedPrivateKey())).publicKey.toBase58());getAccessKey=()=>(this.requireKeyMaterial(),n.poseidonHash(this.getShieldedPrivateKey(),this.getShieldedPublicKey()));getSignerPrivateKeyFromNonce=e=>{this.requireKeyMaterial();let t=n.poseidonHash(e,this.getShieldedPrivateKey(),this.getShieldedPublicKey());return o.ethers.keccak256(o.ethers.toUtf8Bytes(t))};getSignerSolanaPrivateKeyFromNonce=e=>{let t=this.getSignerPrivateKeyFromNonce(e),n=o.ethers.getBytes(t),r=s.Keypair.fromSeed(n);return c.default.encode(r.secretKey)};getWalletSalt=e=>(this.requireKeyMaterial(),n.poseidonHash(this.getShieldedPublicKey(),this.getShieldedPrivateKey(),e));getInHinkalAddress=e=>{this.requireKeyMaterial();let t=n.poseidonHash(this.getShieldedPrivateKey(),e);return BigInt(t)};getBackendToken=()=>(this.requireKeyMaterial(),n.poseidonHash(this.getAccessKey(),this.getShieldedPublicKey()));static getRandomizedStealthPair=d.attach((e,n)=>{let i=r.babyJubInstance(),a=e*(BigInt(n)%t.CIRCOM_P)%t.CIRCOM_P,o=i.mulPointEscalar(i.Base8,e),s=i.mulPointEscalar(i.Base8,a);return{H0:[BigInt(i.F.toString(o[0])),BigInt(i.F.toString(o[1]))],H1:[BigInt(i.F.toString(s[0])),BigInt(i.F.toString(s[1]))]}});static getStealthAddressCompressedPoints=(e,t)=>{let{H0:n,H1:r}=this.getRandomizedStealthPair(e,t),[i,o]=[n,r].map(e=>BigInt(e[1])+2n**255n*a.getCircomSign(e[0]));return{h0:i,h1:o}};static getStealthAddress=f.attach((e,t)=>{let{H0:r,H1:i}=this.getRandomizedStealthPair(e,t);return n.poseidonHash(2n*a.getCircomSign(r[0])+a.getCircomSign(i[0]),r[1],i[1])});static getStealthAddressWithEKey=(e,t)=>({stealthAddress:this.getStealthAddress(e,t),encryptionKey:this.getEncryptionKeyPair(t).publicKey});static checkSignature=(e,t,n,r)=>{let{h0:i,h1:a}=this.getStealthAddressCompressedPoints(e,r);return t===i&&n===a};static getEncryptionKeyPair=e=>{let t=l.default.crypto_box_seed_keypair(o.ethers.getBytes(e));return{privateKey:o.ethers.hexlify(t.privateKey),publicKey:o.ethers.hexlify(t.publicKey)}}};exports.UserKeys=p,exports.stealthAddressCacheDevice=f,exports.stealthPairCacheDevice=d;

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

@@ -0,0 +1,87 @@
+import { AttachableMemoryCacheDevice } from '../cacheDevices/AttachableMemoryCacheDevice';
+export declare const stealthPairCacheDevice: AttachableMemoryCacheDevice<{
+    H0: [bigint, bigint];
+    H1: [bigint, bigint];
+}>;
+export declare const stealthAddressCacheDevice: AttachableMemoryCacheDevice<string>;
+export interface EncryptionKeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export declare const EncryptionKeyPairDefaultValue: EncryptionKeyPair;
+export declare class UserKeys {
+    private signature;
+    private shieldedPrivateKey;
+    constructor(_signature?: string, _shieldedPrivateKey?: string);
+    getSignature(): string;
+    setSignature(_signature: string): void;
+    private requireSignature;
+    private requireKeyMaterial;
+    verifyMessage(signingMessage: string): string;
+    verifySolanaMessage(signingMessage: string, signerPublicKey: string): boolean;
+    /**
+     * get shielded private key from message signature used to login to the application,
+     * this private key is used to generate encryption keypairs as well as public key
+     * @retuns 0x-prefixed shielded private key
+     */
+    getShieldedPrivateKey: () => string;
+    /**
+     * generate shielded public key from private key
+     * @param privateKey the key used to generate the shielded public key, this should be the signature
+     * that the user provided
+     * @retuns shielded public key in hexstring with 0x prefixed
+     */
+    getShieldedPublicKey: () => string;
+    /**
+     * Currently used for creating shielded private keys for deposit UTXOs, which are encrypted and sent to enclave for private send
+     * @param nonce Used to deterministically generate new shielded private key
+     * @returns new shielded private key in hexstring with 0x prefixed
+     */
+    getShieldedPrivateKeyFromNonce: (nonce: bigint) => string;
+    /**
+     * deterministically derive an EVM address from the shielded private key
+     */
+    getDerivedEthereumAddress: () => string;
+    /**
+     * deterministically derive a Solana public key from the shielded private key
+     */
+    getDerivedSolanaPublicKey: () => string;
+    /**
+     * generate access token, this accessKey is what should be sent to the server for signing
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getAccessKey: () => string;
+    getSignerPrivateKeyFromNonce: (walletNonce: bigint) => string;
+    getSignerSolanaPrivateKeyFromNonce: (walletNonce: bigint) => string;
+    getWalletSalt: (walletNonce: bigint) => string;
+    /**
+     * generate inHinkalAddress - a user unique address linking him with a specific app
+     * @returns inHinkalAddress in bigint
+     */
+    getInHinkalAddress: (interactionAddress: string) => bigint;
+    /**
+     * generate backend token, which is used for access control on backend
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getBackendToken: () => string;
+    static getRandomizedStealthPair: (s: bigint, privateKey: string) => {
+        H0: [bigint, bigint];
+        H1: [bigint, bigint];
+    };
+    static getStealthAddressCompressedPoints: (s: bigint, privateKey: string) => {
+        h0: bigint;
+        h1: bigint;
+    };
+    static getStealthAddress: (s: bigint, privateKey: string) => string;
+    static getStealthAddressWithEKey: (s: bigint, privateKey: string) => {
+        stealthAddress: string;
+        encryptionKey: string;
+    };
+    static checkSignature: (s: bigint, stealthAddressH0: bigint, stealthAddressH1: bigint, privateKey: string) => boolean;
+    /**
+     * generate private and public keypair
+     * @param seed seed to use to deterministically generate key, must be in DataHexString format
+     * and must correspond to 32 bytes
+     */
+    static getEncryptionKeyPair: (privateKey: string) => EncryptionKeyPair;
+}