@kapa123456789/sdk 0.0.1

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

@@ -0,0 +1,75 @@
+import { isSolanaLike as e } from "../../constants/chains.constants.mjs";
+import { poseidonHash as t } from "../../crypto/poseidon.mjs";
+import "./keys.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 { u as abiDecodeUtxo, l as decodeSolanaOnChainUtxo, f as decodeUtxo, d as decodeUtxoConstructorArgs, 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`);require(`./keys.cjs`),require(`../utxo/Utxo.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,24 @@
+import "./keys.mjs";
+import "../utxo/Utxo.mjs";
+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.cjs

@@ -0,0 +1 @@
+require(`./keyUtils.cjs`),require(`./keys.cjs`),require(`./encryptDecryptUtxo.cjs`),require(`./decodeUTXO.cjs`);

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

@@ -0,0 +1,4 @@
+import "./keyUtils.mjs";
+import "./keys.mjs";
+import "./encryptDecryptUtxo.mjs";
+import "./decodeUTXO.mjs";

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,exports.isCircomNegative=t;

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, t as isCircomNegative };

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;
+}

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

@@ -0,0 +1,99 @@
+import { CIRCOM_P as e } from "../../constants/protocol.constants.mjs";
+import { poseidonHash as t } from "../../crypto/poseidon.mjs";
+import { babyJubInstance as n } from "../../crypto/babyJub.mjs";
+import { AttachableMemoryCacheDevice as r } from "../cacheDevices/AttachableMemoryCacheDevice.mjs";
+import { getCircomSign as i } from "./keyUtils.mjs";
+import { ethers as a } from "ethers";
+import { Keypair as o, PublicKey as s } from "@solana/web3.js";
+import c from "bs58";
+import l from "libsodium-wrappers";
+import u from "tweetnacl";
+//#region libs/shared/common/src/data-structures/crypto-keys/keys.ts
+var d = new r(), f = new r(), 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(), a.verifyMessage(e, this.signature);
+	}
+	verifySolanaMessage(e, t) {
+		this.requireSignature();
+		let n = new TextEncoder().encode(e), r = a.getBytes(this.signature), i = new s(t).toBytes();
+		return u.sign.detached.verify(n, r, i);
+	}
+	getShieldedPrivateKey = () => (this.requireKeyMaterial(), this.shieldedPrivateKey ||= a.keccak256(this.signature), this.shieldedPrivateKey);
+	getShieldedPublicKey = () => (this.requireKeyMaterial(), t(this.getShieldedPrivateKey()));
+	getShieldedPrivateKeyFromNonce = (e) => {
+		this.requireKeyMaterial();
+		let n = t(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+		return a.keccak256(a.toUtf8Bytes(`hinkal-offchain-shielded-key:${n}`));
+	};
+	getDerivedEthereumAddress = () => (this.requireKeyMaterial(), new a.Wallet(this.getShieldedPrivateKey()).address);
+	getDerivedSolanaPublicKey = () => (this.requireKeyMaterial(), o.fromSeed(a.getBytes(this.getShieldedPrivateKey())).publicKey.toBase58());
+	getAccessKey = () => (this.requireKeyMaterial(), t(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
+	getSignerPrivateKeyFromNonce = (e) => {
+		this.requireKeyMaterial();
+		let n = t(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+		return a.keccak256(a.toUtf8Bytes(n));
+	};
+	getSignerSolanaPrivateKeyFromNonce = (e) => {
+		let t = this.getSignerPrivateKeyFromNonce(e), n = a.getBytes(t), r = o.fromSeed(n);
+		return c.encode(r.secretKey);
+	};
+	getWalletSalt = (e) => (this.requireKeyMaterial(), t(this.getShieldedPublicKey(), this.getShieldedPrivateKey(), e));
+	getInHinkalAddress = (e) => {
+		this.requireKeyMaterial();
+		let n = t(this.getShieldedPrivateKey(), e);
+		return BigInt(n);
+	};
+	getBackendToken = () => (this.requireKeyMaterial(), t(this.getAccessKey(), this.getShieldedPublicKey()));
+	static getRandomizedStealthPair = d.attach((t, r) => {
+		let i = n(), a = t * (BigInt(r) % e) % e, o = i.mulPointEscalar(i.Base8, t), 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), [a, o] = [n, r].map((e) => BigInt(e[1]) + 2n ** 255n * i(e[0]));
+		return {
+			h0: a,
+			h1: o
+		};
+	};
+	static getStealthAddress = f.attach((e, n) => {
+		let { H0: r, H1: a } = this.getRandomizedStealthPair(e, n);
+		return t(2n * i(r[0]) + i(a[0]), r[1], a[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.crypto_box_seed_keypair(a.getBytes(e));
+		return {
+			privateKey: a.hexlify(t.privateKey),
+			publicKey: a.hexlify(t.publicKey)
+		};
+	};
+};
+//#endregion
+export { p as UserKeys, f as stealthAddressCacheDevice, d as stealthPairCacheDevice };

package/common/src/data-structures/custom-token-registry/CustomTokenRegistry.cjs

@@ -0,0 +1 @@
+var e=new class{tokenRegistry;constructor(){this.tokenRegistry=[]}setTokensFromCache(e){this.tokenRegistry=e}getCustomTokens(e){return this.tokenRegistry.filter(t=>t.chainId===e)}tokenExists(e,t){return e.find(e=>e.erc20TokenAddress===t.erc20TokenAddress||e.symbol===t.symbol||e.name===t.name)}addCustomToken(e){let{chainId:t}=e,n=this.getCustomTokens(t);this.tokenExists(n,e)||this.tokenRegistry.push(e)}removeCustomToken(e){let{chainId:t}=e,n=this.getCustomTokens(t).filter(t=>t.erc20TokenAddress!==e.erc20TokenAddress);this.tokenRegistry=n}};exports.customTokenRegistry=e;

package/common/src/data-structures/custom-token-registry/CustomTokenRegistry.d.ts

@@ -0,0 +1,12 @@
+import { ERC20Token } from '../../types';
+declare class CustomTokenRegistry {
+    tokenRegistry: ERC20Token[];
+    constructor();
+    setTokensFromCache(newTokenRegistries: ERC20Token[]): void;
+    getCustomTokens(chainId: number): ERC20Token[];
+    tokenExists(registry: ERC20Token[], tokenToCheck: ERC20Token): ERC20Token | undefined;
+    addCustomToken(token: ERC20Token): void;
+    removeCustomToken(tokenToRemove: ERC20Token): void;
+}
+export declare const customTokenRegistry: CustomTokenRegistry;
+export {};

package/common/src/data-structures/custom-token-registry/CustomTokenRegistry.mjs

@@ -0,0 +1,25 @@
+var e = new class {
+	tokenRegistry;
+	constructor() {
+		this.tokenRegistry = [];
+	}
+	setTokensFromCache(e) {
+		this.tokenRegistry = e;
+	}
+	getCustomTokens(e) {
+		return this.tokenRegistry.filter((t) => t.chainId === e);
+	}
+	tokenExists(e, t) {
+		return e.find((e) => e.erc20TokenAddress === t.erc20TokenAddress || e.symbol === t.symbol || e.name === t.name);
+	}
+	addCustomToken(e) {
+		let { chainId: t } = e, n = this.getCustomTokens(t);
+		this.tokenExists(n, e) || this.tokenRegistry.push(e);
+	}
+	removeCustomToken(e) {
+		let { chainId: t } = e, n = this.getCustomTokens(t).filter((t) => t.erc20TokenAddress !== e.erc20TokenAddress);
+		this.tokenRegistry = n;
+	}
+}();
+//#endregion
+export { e as customTokenRegistry };

package/common/src/data-structures/event-service/evm/AbstractAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../../constants/protocol.constants.cjs`),t=require(`../../../functions/utils/amounts.utils.cjs`),n=require(`../../../crypto/poseidon.cjs`),r=require(`../../merkle-tree/MerkleTree.cjs`);require(`../../merkle-tree/index.cjs`),require(`../../../crypto/index.cjs`);const i=require(`./AbstractSnapshotService.cjs`),a=require(`../../../functions/utils/merkleTree.utils.cjs`);var o=class extends i.AbstractSnapshotService{constructor(e){super(e,`NewAccessKeyAdded`)}_merkleTree;_senderAddresses;_senderAddressIndexMap;get merkleTree(){return this._merkleTree}get senderAddresses(){return this._senderAddresses}get senderAddressIndexMap(){return this._senderAddressIndexMap}serializeSnapshot(e){return{merkleTree:e.payload.merkleTree.toJSON(),senderAddresses:Array.from(e.payload.senderAddresses),latestBlockNumber:e.latestBlockNumber,senderAddressIndexMap:Array.from(e.payload.senderAddressIndexMap).map(([e,t])=>({address:e,index:t}))}}deserializeSnapshot(e){let t,i;return t=e.latestBlockNumber&&e.merkleTree?a.contructMerkleTreeFromSerialized(e.merkleTree):r.MerkleTree.create(n.poseidonFunction,0n),i=e.latestBlockNumber&&e.senderAddressIndexMap?new Map(e.senderAddressIndexMap.map(({address:e,index:t})=>[e,t])):new Map,{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:t,senderAddresses:e.senderAddresses??[],senderAddressIndexMap:i}}}acceptEvent(t,n){try{return this._merkleTree.insert(t.accessKey,t.index),this._senderAddressIndexMap.set(t.senderAddress,Math.max(Number(t.index),this._senderAddressIndexMap.get(t.senderAddress)??0)),this._senderAddresses.includes(t.senderAddress)||this._senderAddresses.push(t.senderAddress),t.accessKey===0n&&t.senderAddress===e.zeroAddress&&this._merkleTree.remove(t.index),!0}catch(e){return console.error(e),!1}}mapEvent(e){let n=e.getArg(`accessKey`),r=e.getArg(`index`),i=e.getArg(`senderAddress`);return{accessKey:t.toBigInt(n),index:t.toBigInt(r),senderAddress:i}}getSnapshotPayload(){return{merkleTree:this._merkleTree,senderAddresses:this._senderAddresses,senderAddressIndexMap:this._senderAddressIndexMap}}populateSnapshot({payload:{merkleTree:e,senderAddresses:t,senderAddressIndexMap:n}}){this._merkleTree=e,this._senderAddresses=t,this._senderAddressIndexMap=n}};exports.AbstractAccessTokenSnapshotService=o;

package/common/src/data-structures/event-service/evm/AbstractAccessTokenSnapshotService.d.ts

@@ -0,0 +1,35 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { AccessTokenEvent } from '../../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SenderAddressIndexMapJson = {
+    address: string;
+    index: number;
+}[];
+export type AccessTokenSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly senderAddresses: string[];
+    readonly senderAddressIndexMap: Map<string, number>;
+};
+export type AccessTokenSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    senderAddresses?: string[];
+    senderAddressIndexMap?: SenderAddressIndexMapJson;
+};
+export declare abstract class AbstractAccessTokenSnapshotService extends AbstractSnapshotService<AccessTokenEvent<bigint>, AccessTokenSnapshotPayload, AccessTokenSerializedSnapshot> {
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter);
+    private _merkleTree;
+    private _senderAddresses;
+    private _senderAddressIndexMap;
+    get merkleTree(): MerkleTree<bigint>;
+    get senderAddresses(): string[];
+    get senderAddressIndexMap(): Map<string, number>;
+    protected serializeSnapshot(snapshot: Snapshot<AccessTokenSnapshotPayload>): AccessTokenSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: AccessTokenSerializedSnapshot): Snapshot<AccessTokenSnapshotPayload>;
+    protected acceptEvent(event: AccessTokenEvent<bigint>, _blockNumber: number): boolean;
+    protected mapEvent(event: BlockchainEvent): AccessTokenEvent<bigint>;
+    protected getSnapshotPayload(): AccessTokenSnapshotPayload;
+    protected populateSnapshot({ payload: { merkleTree, senderAddresses, senderAddressIndexMap }, }: Snapshot<AccessTokenSnapshotPayload>): void;
+}

package/common/src/data-structures/event-service/evm/AbstractAccessTokenSnapshotService.mjs

@@ -0,0 +1,75 @@
+import { zeroAddress as e } from "../../../constants/protocol.constants.mjs";
+import { toBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as n } from "../../../crypto/poseidon.mjs";
+import { MerkleTree as r } from "../../merkle-tree/MerkleTree.mjs";
+import "../../merkle-tree/index.mjs";
+import "../../../crypto/index.mjs";
+import { AbstractSnapshotService as i } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as a } from "../../../functions/utils/merkleTree.utils.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractAccessTokenSnapshotService.ts
+var o = class extends i {
+	constructor(e) {
+		super(e, "NewAccessKeyAdded");
+	}
+	_merkleTree;
+	_senderAddresses;
+	_senderAddressIndexMap;
+	get merkleTree() {
+		return this._merkleTree;
+	}
+	get senderAddresses() {
+		return this._senderAddresses;
+	}
+	get senderAddressIndexMap() {
+		return this._senderAddressIndexMap;
+	}
+	serializeSnapshot(e) {
+		return {
+			merkleTree: e.payload.merkleTree.toJSON(),
+			senderAddresses: Array.from(e.payload.senderAddresses),
+			latestBlockNumber: e.latestBlockNumber,
+			senderAddressIndexMap: Array.from(e.payload.senderAddressIndexMap).map(([e, t]) => ({
+				address: e,
+				index: t
+			}))
+		};
+	}
+	deserializeSnapshot(e) {
+		let t, i;
+		return t = e.latestBlockNumber && e.merkleTree ? a(e.merkleTree) : r.create(n, 0n), i = e.latestBlockNumber && e.senderAddressIndexMap ? new Map(e.senderAddressIndexMap.map(({ address: e, index: t }) => [e, t])) : /* @__PURE__ */ new Map(), {
+			latestBlockNumber: e.latestBlockNumber ?? 0,
+			payload: {
+				merkleTree: t,
+				senderAddresses: e.senderAddresses ?? [],
+				senderAddressIndexMap: i
+			}
+		};
+	}
+	acceptEvent(t, n) {
+		try {
+			return this._merkleTree.insert(t.accessKey, t.index), this._senderAddressIndexMap.set(t.senderAddress, Math.max(Number(t.index), this._senderAddressIndexMap.get(t.senderAddress) ?? 0)), this._senderAddresses.includes(t.senderAddress) || this._senderAddresses.push(t.senderAddress), t.accessKey === 0n && t.senderAddress === e && this._merkleTree.remove(t.index), !0;
+		} catch (e) {
+			return console.error(e), !1;
+		}
+	}
+	mapEvent(e) {
+		let n = e.getArg("accessKey"), r = e.getArg("index"), i = e.getArg("senderAddress");
+		return {
+			accessKey: t(n),
+			index: t(r),
+			senderAddress: i
+		};
+	}
+	getSnapshotPayload() {
+		return {
+			merkleTree: this._merkleTree,
+			senderAddresses: this._senderAddresses,
+			senderAddressIndexMap: this._senderAddressIndexMap
+		};
+	}
+	populateSnapshot({ payload: { merkleTree: e, senderAddresses: t, senderAddressIndexMap: n } }) {
+		this._merkleTree = e, this._senderAddresses = t, this._senderAddressIndexMap = n;
+	}
+};
+//#endregion
+export { o as AbstractAccessTokenSnapshotService };

package/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.cjs

@@ -0,0 +1 @@
+const e=require(`../../../functions/utils/amounts.utils.cjs`),t=require(`../../../crypto/poseidon.cjs`),n=require(`../../merkle-tree/MerkleTree.cjs`);require(`../../merkle-tree/index.cjs`),require(`../../../crypto/index.cjs`);const r=require(`./AbstractSnapshotService.cjs`),i=require(`../../../functions/utils/merkleTree.utils.cjs`);var a=class extends r.AbstractSnapshotService{constructor(e){super(e,`NewCommitment`)}_merkleTree;_encryptedOutputs;_encryptedOutputsByCommitment=new Map;get merkleTree(){return this._merkleTree}get encryptedOutputs(){return this._encryptedOutputs}serializeSnapshot(e){return{merkleTree:e.payload.merkleTree.toJSON(),latestBlockNumber:e.latestBlockNumber,encryptedOutputs:e.payload.encryptedOutputs.map(e=>({value:e.value,isPositive:String(e.isPositive),isBlocked:e.isBlocked??!1})),encryptedOutputsByCommitment:Array.from(e.payload.encryptedOutputsByCommitment.entries()).map(([e,t])=>({commitment:e.toString(),encryptedOutput:t}))}}deserializeSnapshot(r){let a;a=r.latestBlockNumber&&r.merkleTree?i.contructMerkleTreeFromSerialized(r.merkleTree):n.MerkleTree.create(t.poseidonFunction,0n);let o=r.encryptedOutputs?.map(e=>({value:e.value,isPositive:JSON.parse(e.isPositive),isBlocked:e.isBlocked??!1})),s=new Map;return r.encryptedOutputsByCommitment?.forEach(({commitment:t,encryptedOutput:n})=>{s.set(e.toBigInt(t),n)}),{latestBlockNumber:r.latestBlockNumber??0,payload:{merkleTree:a,encryptedOutputs:o||[],encryptedOutputsByCommitment:s}}}getSnapshotPayload(){return{merkleTree:this._merkleTree,encryptedOutputs:this._encryptedOutputs,encryptedOutputsByCommitment:this._encryptedOutputsByCommitment}}populateSnapshot({payload:{merkleTree:e,encryptedOutputs:t,encryptedOutputsByCommitment:n}}){this._merkleTree=e,this._encryptedOutputs=t,this._encryptedOutputsByCommitment=n}mapEvent(t){let n=t.getArg(`commitment`),r=t.getArg(`index`),i=t.getArg(`encryptedOutput`);return{commitment:e.toBigInt(n),index:e.toBigInt(r),encryptedOutput:i}}acceptEvent(e,t,n,r){let i=e.index>=0n?e.index:-1n*e.index,a=this._merkleTree.getValue(i);if(a===e.commitment)return!1;this._merkleTree.insert(e.commitment,i);let o=a===void 0?void 0:this._encryptedOutputsByCommitment.get(a);if(a!==void 0&&o!==void 0){let e=this.encryptedOutputs.findIndex(e=>e.value===o);e!==-1&&this.encryptedOutputs.splice(e,1),this._encryptedOutputsByCommitment.delete(a)}if(this._encryptedOutputsByCommitment.set(e.commitment,e.encryptedOutput),this.encryptedOutputs.map(e=>e.value).includes(e.encryptedOutput))return!0;let s={value:e.encryptedOutput,isPositive:e.index>=0n,isBlocked:r??!1};return this._encryptedOutputs.push(s),!0}};exports.AbstractCommitmentsSnapshotService=a;

package/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.d.ts

@@ -0,0 +1,34 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type CommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+    readonly encryptedOutputsByCommitment: Map<bigint, string>;
+};
+export type CommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+    encryptedOutputsByCommitment?: EncryptedOutputWithCommitment[];
+};
+export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    private _encryptedOutputsByCommitment;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: CommitmentsSerializedSnapshot): Snapshot<CommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs, encryptedOutputsByCommitment }, }: Snapshot<CommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: BlockchainEvent): CommitmentEvent<bigint>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number, _txHash?: string, isBlocked?: boolean): boolean;
+}

package/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.mjs

@@ -0,0 +1,93 @@
+import { toBigInt as e } from "../../../functions/utils/amounts.utils.mjs";
+import { poseidonFunction as t } from "../../../crypto/poseidon.mjs";
+import { MerkleTree as n } from "../../merkle-tree/MerkleTree.mjs";
+import "../../merkle-tree/index.mjs";
+import "../../../crypto/index.mjs";
+import { AbstractSnapshotService as r } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as i } from "../../../functions/utils/merkleTree.utils.mjs";
+//#region libs/shared/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.ts
+var a = class extends r {
+	constructor(e) {
+		super(e, "NewCommitment");
+	}
+	_merkleTree;
+	_encryptedOutputs;
+	_encryptedOutputsByCommitment = /* @__PURE__ */ new Map();
+	get merkleTree() {
+		return this._merkleTree;
+	}
+	get encryptedOutputs() {
+		return this._encryptedOutputs;
+	}
+	serializeSnapshot(e) {
+		return {
+			merkleTree: e.payload.merkleTree.toJSON(),
+			latestBlockNumber: e.latestBlockNumber,
+			encryptedOutputs: e.payload.encryptedOutputs.map((e) => ({
+				value: e.value,
+				isPositive: String(e.isPositive),
+				isBlocked: e.isBlocked ?? !1
+			})),
+			encryptedOutputsByCommitment: Array.from(e.payload.encryptedOutputsByCommitment.entries()).map(([e, t]) => ({
+				commitment: e.toString(),
+				encryptedOutput: t
+			}))
+		};
+	}
+	deserializeSnapshot(r) {
+		let a;
+		a = r.latestBlockNumber && r.merkleTree ? i(r.merkleTree) : n.create(t, 0n);
+		let o = r.encryptedOutputs?.map((e) => ({
+			value: e.value,
+			isPositive: JSON.parse(e.isPositive),
+			isBlocked: e.isBlocked ?? !1
+		})), s = /* @__PURE__ */ new Map();
+		return r.encryptedOutputsByCommitment?.forEach(({ commitment: t, encryptedOutput: n }) => {
+			s.set(e(t), n);
+		}), {
+			latestBlockNumber: r.latestBlockNumber ?? 0,
+			payload: {
+				merkleTree: a,
+				encryptedOutputs: o || [],
+				encryptedOutputsByCommitment: s
+			}
+		};
+	}
+	getSnapshotPayload() {
+		return {
+			merkleTree: this._merkleTree,
+			encryptedOutputs: this._encryptedOutputs,
+			encryptedOutputsByCommitment: this._encryptedOutputsByCommitment
+		};
+	}
+	populateSnapshot({ payload: { merkleTree: e, encryptedOutputs: t, encryptedOutputsByCommitment: n } }) {
+		this._merkleTree = e, this._encryptedOutputs = t, this._encryptedOutputsByCommitment = n;
+	}
+	mapEvent(t) {
+		let n = t.getArg("commitment"), r = t.getArg("index"), i = t.getArg("encryptedOutput");
+		return {
+			commitment: e(n),
+			index: e(r),
+			encryptedOutput: i
+		};
+	}
+	acceptEvent(e, t, n, r) {
+		let i = e.index >= 0n ? e.index : -1n * e.index, a = this._merkleTree.getValue(i);
+		if (a === e.commitment) return !1;
+		this._merkleTree.insert(e.commitment, i);
+		let o = a === void 0 ? void 0 : this._encryptedOutputsByCommitment.get(a);
+		if (a !== void 0 && o !== void 0) {
+			let e = this.encryptedOutputs.findIndex((e) => e.value === o);
+			e !== -1 && this.encryptedOutputs.splice(e, 1), this._encryptedOutputsByCommitment.delete(a);
+		}
+		if (this._encryptedOutputsByCommitment.set(e.commitment, e.encryptedOutput), this.encryptedOutputs.map((e) => e.value).includes(e.encryptedOutput)) return !0;
+		let s = {
+			value: e.encryptedOutput,
+			isPositive: e.index >= 0n,
+			isBlocked: r ?? !1
+		};
+		return this._encryptedOutputs.push(s), !0;
+	}
+};
+//#endregion
+export { a as AbstractCommitmentsSnapshotService };