@sabaaa1/common 0.2.16

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

@@ -0,0 +1,96 @@
+import { get as c, update as o } from "idb-keyval";
+import { Logger as a } from "../../error-handling/logger.mjs";
+import { caseInsensitiveEqual as d } from "../../functions/utils/caseInsensitive.utils.mjs";
+class T {
+  STORAGE_KEY = "hiddenTokenAddresses";
+  UNHIDDEN_SPAM_KEY = "unhiddenSpamTokens";
+  async getHiddenTokens(e) {
+    try {
+      return (await c(this.STORAGE_KEY))?.[e] || [];
+    } catch (r) {
+      return a.error("Error retrieving hidden tokens", r), [];
+    }
+  }
+  async getHiddenTokenAddresses(e) {
+    try {
+      return (await this.getHiddenTokens(e)).map(({ erc20TokenAddress: s }) => s.toLowerCase());
+    } catch (r) {
+      return a.error("Error retrieving hidden tokens", r), [];
+    }
+  }
+  async filterOutHiddenTokens(e, r) {
+    const s = await this.getHiddenTokens(e);
+    return r.filter(
+      (n) => !s.some(
+        (t) => d(t.erc20TokenAddress, n.erc20TokenAddress)
+      )
+    );
+  }
+  async hideToken(e) {
+    try {
+      await o(this.STORAGE_KEY, (r) => {
+        const s = r ?? {}, { chainId: n } = e;
+        return s[n] || (s[n] = []), s[n].some(
+          ({ erc20TokenAddress: i }) => d(i, e.erc20TokenAddress)
+        ) || s[n].push(e), s;
+      }), e.isSpam && await this.deleteUnhiddenSpamToken(e);
+    } catch (r) {
+      a.error("Error hiding token", r);
+    }
+  }
+  async showToken(e) {
+    try {
+      await o(this.STORAGE_KEY, (r) => {
+        const { chainId: s } = e, n = r ?? {};
+        return n[s] || (n[s] = []), n[s] = n[s].filter(
+          ({ erc20TokenAddress: t }) => !d(t, e.erc20TokenAddress)
+        ), n;
+      }), e.isSpam && await this.storeUnhiddenSpamToken(e);
+    } catch (r) {
+      a.error("Error showing token", r);
+    }
+  }
+  async storeUnhiddenSpamToken(e) {
+    const { chainId: r } = e;
+    try {
+      await o(this.UNHIDDEN_SPAM_KEY, (s) => {
+        const n = s ?? {};
+        return n[r] || (n[r] = []), n[r].some(
+          ({ erc20TokenAddress: i }) => d(i, e.erc20TokenAddress)
+        ) || n[r].push(e), n;
+      });
+    } catch (s) {
+      a.error("Error storing unhidden spam token", s);
+    }
+  }
+  async deleteUnhiddenSpamToken(e) {
+    await o(this.UNHIDDEN_SPAM_KEY, (r) => {
+      const { chainId: s } = e, n = r ?? {};
+      return n[s] = n[s]?.filter(
+        ({ erc20TokenAddress: t }) => !d(t, e.erc20TokenAddress)
+      ), n;
+    });
+  }
+  async getUnhiddenSpamTokens(e) {
+    try {
+      return (await c(this.UNHIDDEN_SPAM_KEY))?.[e] || [];
+    } catch (r) {
+      return a.error("Error retrieving unhidden spam tokens", r), [];
+    }
+  }
+  // From the list of tokens, hide the spam tokens that are not in the unhidden spam tokens list
+  async hideUnnecessarySpamTokens(e, r) {
+    const s = await this.getUnhiddenSpamTokens(e), n = r.filter(({ erc20TokenAddress: t, isSpam: i }) => i ? !s.some(
+      ({ erc20TokenAddress: h }) => d(t, h)
+    ) : !1);
+    await Promise.all(n.map((t) => this.hideToken(t)));
+  }
+  // First hide spam tokens from the list, then fetch the all hidden tokens addresses
+  async hideSpamsAndFetchHiddenTokensAddresses(e, r) {
+    return await this.hideUnnecessarySpamTokens(e, r), this.getHiddenTokenAddresses(e);
+  }
+}
+const y = new T();
+export {
+  y as tokenVisibilityStorage
+};

package/data-structures/ValueCache/ValueCache.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e{constructor(t){this.timeoutInMs=t,this.setTimer()}timeoutInMs;values={};setTimer(){if(this.timeoutInMs>0){const t=this;setInterval(()=>{t.onTimeout()},this.timeoutInMs)}}onTimeout(){this.clear()}clear(){this.values={}}}exports.ValueCache=e;

package/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/data-structures/ValueCache/ValueCache.mjs

@@ -0,0 +1,25 @@
+class e {
+  constructor(t) {
+    this.timeoutInMs = t, this.setTimer();
+  }
+  timeoutInMs;
+  values = {};
+  setTimer() {
+    if (this.timeoutInMs > 0) {
+      const t = this;
+      setInterval(() => {
+        t.onTimeout();
+      }, this.timeoutInMs);
+    }
+  }
+  // clear cache when times-up
+  onTimeout() {
+    this.clear();
+  }
+  clear() {
+    this.values = {};
+  }
+}
+export {
+  e as ValueCache
+};

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

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

package/data-structures/cacheDevices/AttachableMemoryCacheDevice.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../functions/utils/serialize.utils.cjs"),n=require("./BaseCacheDevice.cjs");class h extends n.BaseCacheDevice{isAttached=!1;get(e){return this.getInMemory(e)}set(e,t){this.setInMemory(e,t)}serialize(){return Object.fromEntries([...this.inMemoryCache].map(([e,t])=>[e,s.CustomJSONStringify(t)]))}attach(e){if(this.isAttached)throw new Error("can't reattach cache device");return this.isAttached=!0,(...i)=>{const r=s.CustomJSONStringify(i),c=this.get(r);if(c!==void 0)return c;const a=e(...i);return this.set(r,a),a}}}exports.AttachableMemoryCacheDevice=h;

package/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/data-structures/cacheDevices/AttachableMemoryCacheDevice.mjs

@@ -0,0 +1,28 @@
+import { CustomJSONStringify as s } from "../../functions/utils/serialize.utils.mjs";
+import { BaseCacheDevice as h } from "./BaseCacheDevice.mjs";
+class l extends h {
+  isAttached = !1;
+  get(t) {
+    return this.getInMemory(t);
+  }
+  set(t, e) {
+    this.setInMemory(t, e);
+  }
+  serialize() {
+    return Object.fromEntries([...this.inMemoryCache].map(([t, e]) => [t, s(e)]));
+  }
+  attach(t) {
+    if (this.isAttached)
+      throw new Error("can't reattach cache device");
+    return this.isAttached = !0, (...r) => {
+      const a = s(r), c = this.get(a);
+      if (c !== void 0)
+        return c;
+      const i = t(...r);
+      return this.set(a, i), i;
+    };
+  }
+}
+export {
+  l as AttachableMemoryCacheDevice
+};

package/data-structures/cacheDevices/BaseCacheDevice.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../../functions/utils/serialize.utils.cjs");class s{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(e){Object.entries(e).forEach(([t,i])=>{this.set(t,r.CustomJSONParse(i))})}}exports.BaseCacheDevice=s;

package/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/data-structures/cacheDevices/BaseCacheDevice.mjs

@@ -0,0 +1,21 @@
+import { CustomJSONParse as i } from "../../functions/utils/serialize.utils.mjs";
+class h {
+  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(e) {
+    Object.entries(e).forEach(([t, r]) => {
+      this.set(t, i(r));
+    });
+  }
+}
+export {
+  h as BaseCacheDevice
+};

package/data-structures/cacheDevices/FileCacheDevice.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("../../functions/utils/serialize.utils.cjs"),r=require("../../error-handling/logError.cjs"),o=require("./BaseCacheDevice.cjs");class a extends o.BaseCacheDevice{filePath;useFileCache;constructor(e,i){super(),this.useFileCache=!!e,this.filePath=i,this.readFileFromDevice()}readFileFromDevice(){if(this.useFileCache&&this.filePath)try{const e=require("fs");if(e.existsSync(this.filePath)){const i=JSON.parse(e.readFileSync(this.filePath).toString());Object.entries(i).forEach(([s,c])=>{this.setInMemory(s,c)})}}catch(e){r.logError("FileCacheDevice Constructor Error",{err:e})}}get(e){return this.getInMemory(e)}set(e,i){if(this.readFileFromDevice(),this.setInMemory(e,i),this.useFileCache&&this.filePath)try{require("fs").writeFileSync(this.filePath,JSON.stringify(Object.fromEntries(this.inMemoryCache)))}catch(t){r.logError("FileCacheDevice set function",{err:t})}}serialize(){return Object.fromEntries([...this.inMemoryCache].map(([e,i])=>[e,h.CustomJSONStringify(i)]))}}exports.FileCacheDevice=a;

package/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/data-structures/cacheDevices/FileCacheDevice.mjs

@@ -0,0 +1,41 @@
+import { CustomJSONStringify as h } from "../../functions/utils/serialize.utils.mjs";
+import { logError as r } from "../../error-handling/logError.mjs";
+import { BaseCacheDevice as o } from "./BaseCacheDevice.mjs";
+class m extends o {
+  filePath;
+  useFileCache;
+  constructor(e, i) {
+    super(), this.useFileCache = !!e, this.filePath = i, this.readFileFromDevice();
+  }
+  readFileFromDevice() {
+    if (this.useFileCache && this.filePath)
+      try {
+        const e = require("fs");
+        if (e.existsSync(this.filePath)) {
+          const i = JSON.parse(e.readFileSync(this.filePath).toString());
+          Object.entries(i).forEach(([s, c]) => {
+            this.setInMemory(s, c);
+          });
+        }
+      } catch (e) {
+        r("FileCacheDevice Constructor Error", { err: e });
+      }
+  }
+  get(e) {
+    return this.getInMemory(e);
+  }
+  set(e, i) {
+    if (this.readFileFromDevice(), this.setInMemory(e, i), this.useFileCache && this.filePath)
+      try {
+        require("fs").writeFileSync(this.filePath, JSON.stringify(Object.fromEntries(this.inMemoryCache)));
+      } catch (t) {
+        r("FileCacheDevice set function", { err: t });
+      }
+  }
+  serialize() {
+    return Object.fromEntries([...this.inMemoryCache].map(([e, i]) => [e, h(i)]));
+  }
+}
+export {
+  m as FileCacheDevice
+};

package/data-structures/cacheDevices/LocalStorageCacheDevice.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../functions/utils/serialize.utils.cjs"),r=require("./BaseCacheDevice.cjs");class i extends r.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(){const e=this.localDataStorage?Object.entries(localStorage):[...this.inMemoryCache];return Object.fromEntries(e.map(([t,a])=>[t,o.CustomJSONStringify(a)]))}}exports.LocalStorageCacheDevice=i;

package/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/data-structures/cacheDevices/LocalStorageCacheDevice.mjs

@@ -0,0 +1,21 @@
+import { CustomJSONStringify as o } from "../../functions/utils/serialize.utils.mjs";
+import { BaseCacheDevice as r } from "./BaseCacheDevice.mjs";
+class c extends r {
+  localDataStorage;
+  constructor(t, e) {
+    super(), !t && typeof localStorage < "u" && (this.localDataStorage = localStorage), e && this.mergeWithSerialized(e);
+  }
+  get(t) {
+    return this.localDataStorage ? this.localDataStorage.getItem(t) ?? void 0 : this.getInMemory(t);
+  }
+  set(t, e) {
+    this.localDataStorage ? this.localDataStorage.setItem(t, e) : this.setInMemory(t, e);
+  }
+  serialize() {
+    const t = this.localDataStorage ? Object.entries(localStorage) : [...this.inMemoryCache];
+    return Object.fromEntries(t.map(([e, a]) => [e, o(a)]));
+  }
+}
+export {
+  c as LocalStorageCacheDevice
+};

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

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

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const U=require("ethers"),x=require("../utxo/Utxo.cjs"),l=require("./keys.cjs"),i=e=>{const t=U.ethers.utils.defaultAbiCoder.decode(["uint256","address","tuple(uint256, uint256, uint256, uint256)","uint256","uint256"],e),n=t[0].toBigInt(),r=t[1],s=t[2][0].toBigInt(),o=t[2][1].toHexString(),c=t[2][2].toBigInt(),d=t[2][3].toBigInt(),a=t[3].toString(),g=t[4].toNumber();return{amount:n,erc20TokenAddress:r,randomization:s,stealthAddress:o,H0:c,H1:d,timeStamp:a,tokenId:g}},u=(e,t)=>{const{amount:n,erc20TokenAddress:r,timeStamp:s,tokenId:o,randomization:c,stealthAddress:d}=i(e);return{amount:n,erc20TokenAddress:r,timeStamp:s,tokenId:o,randomization:c,shieldedPrivateKey:t,stealthAddress:d}},m=(e,t)=>new x.Utxo(u(e,t)),h=(e,t)=>{const{randomization:n,H0:r,H1:s}=i(e),o=l.UserKeys.checkSignature(n,r,s,t);if(!o)throw new Error("UTXO doesn't belong to user");return o};exports.abiDecodeUtxo=i;exports.checkUtxoSignature=h;exports.decodeUtxo=m;exports.decodeUtxoConstructorArgs=u;

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

@@ -0,0 +1,14 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+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) => IUtxoConstructor;
+export declare const decodeUtxo: (encryptedOutput: string, privateKey: string) => Utxo;
+export declare const checkUtxoSignature: (encryptedOutput: string, privateKey: string) => boolean;

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

@@ -0,0 +1,41 @@
+import { ethers as m } from "ethers";
+import { Utxo as g } from "../utxo/Utxo.mjs";
+import { UserKeys as x } from "./keys.mjs";
+const c = (o) => {
+  const t = m.utils.defaultAbiCoder.decode(
+    ["uint256", "address", "tuple(uint256, uint256, uint256, uint256)", "uint256", "uint256"],
+    o
+  ), n = t[0].toBigInt(), r = t[1], s = t[2][0].toBigInt(), e = t[2][1].toHexString(), i = t[2][2].toBigInt(), d = t[2][3].toBigInt(), u = t[3].toString(), a = t[4].toNumber();
+  return {
+    amount: n,
+    erc20TokenAddress: r,
+    randomization: s,
+    stealthAddress: e,
+    H0: i,
+    H1: d,
+    timeStamp: u,
+    tokenId: a
+  };
+}, U = (o, t) => {
+  const { amount: n, erc20TokenAddress: r, timeStamp: s, tokenId: e, randomization: i, stealthAddress: d } = c(o);
+  return {
+    amount: n,
+    erc20TokenAddress: r,
+    timeStamp: s,
+    tokenId: e,
+    randomization: i,
+    shieldedPrivateKey: t,
+    stealthAddress: d
+  };
+}, k = (o, t) => new g(U(o, t)), A = (o, t) => {
+  const { randomization: n, H0: r, H1: s } = c(o), e = x.checkSignature(n, r, s, t);
+  if (!e)
+    throw new Error("UTXO doesn't belong to user");
+  return e;
+};
+export {
+  c as abiDecodeUtxo,
+  A as checkUtxoSignature,
+  k as decodeUtxo,
+  U as decodeUtxoConstructorArgs
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("ethers"),y=require("libsodium-wrappers"),l=require("../utxo/Utxo.cjs"),u=require("./keys.cjs"),p=(e,s)=>{const i=[Buffer.from(t.ethers.utils.hexlify(s?0n:e.amount)),Buffer.from(t.ethers.utils.hexlify(e.erc20TokenAddress)),Buffer.from(t.ethers.utils.hexlify(e.randomization)),Buffer.from(e.getStealthAddress()),Buffer.from(t.ethers.utils.hexlify(BigInt(e.timeStamp)))];e.tokenId>0&&i.push(Buffer.from(t.ethers.utils.hexlify(e.tokenId)));const n=Buffer.concat(i);return y.crypto_box_seal(n,t.ethers.utils.arrayify(e.getEncryptionKey()))},d=(e,s)=>{const{publicKey:i,privateKey:n}=u.UserKeys.getEncryptionKeyPair(s.getShieldedPrivateKey()),c=y.crypto_box_seal_open(e,t.ethers.utils.arrayify(i),t.ethers.utils.arrayify(n)),r=Buffer.from(c).toString("utf-8").split("0x").filter(o=>o.length!==0).map((o,a)=>{let f;return[0,2,4,5].includes(a)?f=BigInt(`0x${o}`):[1,3].includes(a)&&(f=`0x${o}`),f});return{amount:r[0],erc20TokenAddress:r[1],randomization:r[2],stealthAddress:r[3],shieldedPrivateKey:s.getShieldedPrivateKey(),timeStamp:r[4].toString(),tokenId:r[5]?Number(r[5]):0}},h=(e,s)=>new l.Utxo(d(e,s));exports.decryptUtxo=h;exports.decryptUtxoConstructorArgs=d;exports.encryptUtxo=p;

package/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, forceZeroAmount: boolean) => 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/data-structures/crypto-keys/encryptDecryptUtxo.mjs

@@ -0,0 +1,40 @@
+import { ethers as t } from "ethers";
+import l from "libsodium-wrappers";
+import { Utxo as c } from "../utxo/Utxo.mjs";
+import { UserKeys as d } from "./keys.mjs";
+const B = (e, i) => {
+  const o = [
+    Buffer.from(t.utils.hexlify(i ? 0n : e.amount)),
+    Buffer.from(t.utils.hexlify(e.erc20TokenAddress)),
+    Buffer.from(t.utils.hexlify(e.randomization)),
+    Buffer.from(e.getStealthAddress()),
+    Buffer.from(t.utils.hexlify(BigInt(e.timeStamp)))
+  ];
+  e.tokenId > 0 && o.push(Buffer.from(t.utils.hexlify(e.tokenId)));
+  const n = Buffer.concat(o);
+  return l.crypto_box_seal(n, t.utils.arrayify(e.getEncryptionKey()));
+}, m = (e, i) => {
+  const { publicKey: o, privateKey: n } = d.getEncryptionKeyPair(i.getShieldedPrivateKey()), a = l.crypto_box_seal_open(
+    e,
+    t.utils.arrayify(o),
+    t.utils.arrayify(n)
+  ), r = Buffer.from(a).toString("utf-8").split("0x").filter((f) => f.length !== 0).map((f, y) => {
+    let s;
+    return [0, 2, 4, 5].includes(y) ? s = BigInt(`0x${f}`) : [1, 3].includes(y) && (s = `0x${f}`), s;
+  });
+  return {
+    amount: r[0],
+    erc20TokenAddress: r[1],
+    randomization: r[2],
+    stealthAddress: r[3],
+    shieldedPrivateKey: i.getShieldedPrivateKey(),
+    timeStamp: r[4].toString(),
+    tokenId: r[5] ? Number(r[5]) : 0
+    // tokenId
+  };
+}, x = (e, i) => new c(m(e, i));
+export {
+  x as decryptUtxo,
+  m as decryptUtxoConstructorArgs,
+  B as encryptUtxo
+};

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

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

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../../constants/protocol.constants.cjs"),o=e=>{if(e<0n||e>=t.CIRCOM_P)throw new RangeError;return e>t.CIRCOM_P_HALF},r=e=>o(e)?1n:0n;exports.getCircomSign=r;exports.isCircomNegative=o;

package/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/data-structures/crypto-keys/keyUtils.mjs

@@ -0,0 +1,10 @@
+import { CIRCOM_P as o, CIRCOM_P_HALF as t } from "../../constants/protocol.constants.mjs";
+const e = (r) => {
+  if (r < 0n || r >= o)
+    throw new RangeError();
+  return r > t;
+}, n = (r) => e(r) ? 1n : 0n;
+export {
+  n as getCircomSign,
+  e as isCircomNegative
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("ethers"),K=require("libsodium-wrappers"),l=require("../../constants/protocol.constants.cjs"),v=require("../../crypto/babyJub.cjs"),c=require("../../crypto/poseidon.cjs"),u=require("./keyUtils.cjs"),g=require("../cacheDevices/AttachableMemoryCacheDevice.cjs");require("../../node_modules/ethers/lib/utils.cjs");const h=require("ethers-v6h"),b=require("../../constants/chains.constants.cjs"),d=require("../../_virtual/utils.cjs"),y=new g.AttachableMemoryCacheDevice,S=new g.AttachableMemoryCacheDevice,m={privateKey:"",publicKey:""};class q{signature;constructor(e){this.signature=e}getSignature(){return this.requireSignature(),this.signature}setSignature(e){this.signature=e}requireSignature(){if(!this.signature)throw Error("No signature provided")}verifyMessage(e){return this.requireSignature(),a.utils.verifyMessage(e,this.signature)}getShieldedPrivateKey=()=>(this.requireSignature(),a.ethers.utils.keccak256(this.signature));getShieldedPublicKey=()=>(this.requireSignature(),c.poseidonHash(this.getShieldedPrivateKey()));getAccessKey=()=>(this.requireSignature(),c.poseidonHash(this.getShieldedPrivateKey(),this.getShieldedPublicKey()));static getSignerAddressFromPrivateKey(e){return new h.ethers.Wallet(e).address}static deriveSignerFromNonce(e,t){const r=c.poseidonHash(t,e.getShieldedPrivateKey(),e.getShieldedPublicKey()),s=d.__exports.keccak256(d.__exports.toUtf8Bytes(r));return new h.ethers.Wallet(s)}static async signMessageFromPrivateKey(e,t){const r=new h.ethers.Wallet(e),s=a.utils.isHexString(t)?a.utils.arrayify(t):t;return r.signMessage(s)}static signTypedDataFromPrivateKey(e,t,r,s){return new h.ethers.Wallet(e).signTypedData(t,r,s)}static async authorizeDelegationFromPrivateKey(e,t,r,s){const n=new h.ethers.Wallet(e),i=new h.ethers.JsonRpcProvider(b.networkRegistry[t].fetchRpcUrl);return n.connect(i).authorize({address:r,...s!==void 0&&{nonce:s}})}getWalletSalt=e=>(this.requireSignature(),c.poseidonHash(this.getShieldedPublicKey(),this.getShieldedPrivateKey(),e));getInHinkalAddress=e=>{this.requireSignature();const t=c.poseidonHash(this.getShieldedPrivateKey(),e);return BigInt(t)};getBackendToken=()=>(this.requireSignature(),c.poseidonHash(this.getAccessKey(),this.getShieldedPublicKey()));static getRandomizedStealthPair=y.attach((e,t)=>{const r=v.babyJubInstance(),s=BigInt(t)%l.CIRCOM_P,n=e*s%l.CIRCOM_P,i=r.mulPointEscalar(r.Base8,e),o=r.mulPointEscalar(r.Base8,n),p=[BigInt(r.F.toString(i[0])),BigInt(r.F.toString(i[1]))],P=[BigInt(r.F.toString(o[0])),BigInt(r.F.toString(o[1]))];return{H0:p,H1:P}});static getStealthAddressCompressedPoints=(e,t)=>{const{H0:r,H1:s}=this.getRandomizedStealthPair(e,t),[n,i]=[r,s].map(o=>BigInt(o[1])+2n**255n*u.getCircomSign(o[0]));return{h0:n,h1:i}};static getStealthAddress=S.attach((e,t)=>{const{H0:r,H1:s}=this.getRandomizedStealthPair(e,t),i=[2n*u.getCircomSign(r[0])+u.getCircomSign(s[0]),r[1],s[1]];return c.poseidonHash(...i)});static getStealthAddressWithEKey=(e,t)=>({stealthAddress:this.getStealthAddress(e,t),encryptionKey:this.getEncryptionKeyPair(t).publicKey});static checkSignature=(e,t,r,s)=>{const{h0:n,h1:i}=this.getStealthAddressCompressedPoints(e,s);return t===n&&r===i};static getEncryptionKeyPair=e=>{const t=K.crypto_box_seed_keypair(a.ethers.utils.arrayify(e));return{privateKey:a.ethers.utils.hexlify(t.privateKey),publicKey:a.ethers.utils.hexlify(t.publicKey)}}}exports.EncryptionKeyPairDefaultValue=m;exports.UserKeys=q;exports.stealthAddressCacheDevice=S;exports.stealthPairCacheDevice=y;

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

@@ -0,0 +1,75 @@
+import { ethers } from 'ethers';
+import { AttachableMemoryCacheDevice } from '../cacheDevices/AttachableMemoryCacheDevice';
+import { ethers as ethersV6 } from 'ethers-v6h';
+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;
+    constructor(_signature?: string);
+    getSignature(): string;
+    setSignature(_signature: string): void;
+    private requireSignature;
+    verifyMessage(signingMessage: string): string;
+    /**
+     * 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;
+    /**
+     * generate access token, this accessKey is what should be sent to the server for signing
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getAccessKey: () => string;
+    static getSignerAddressFromPrivateKey(privateKey: string): string;
+    static deriveSignerFromNonce(userKeys: UserKeys, walletNonce: bigint): ethersV6.Wallet;
+    static signMessageFromPrivateKey(privateKey: string, message: string): Promise<string>;
+    static signTypedDataFromPrivateKey(privateKey: string, domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, value: Record<string, any>): Promise<string>;
+    static authorizeDelegationFromPrivateKey(privateKey: string, chainId: number, implementation: string, nonce?: number): Promise<ethersV6.Authorization>;
+    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;
+}