@sabaaa1/common 0.1.6 → 0.1.14

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

@@ -1,17 +1,21 @@
-import { utils as g, ethers as h } from "ethers";
-import m from "libsodium-wrappers";
-import { CIRCOM_P as d } from "../../constants/protocol.constants.mjs";
-import { babyJubInstance as p } from "../../crypto/babyJub.mjs";
-import { poseidonHash as a } from "../../crypto/poseidon.mjs";
-import { getCircomSign as l } from "./keyUtils.mjs";
-import { AttachableMemoryCacheDevice as u } from "../cacheDevices/AttachableMemoryCacheDevice.mjs";
-import { ethers as c } from "ethers-v6h";
-import { networkRegistry as K } from "../../constants/chains.constants.mjs";
-const P = new u(), v = new u(), C = {
+import { utils as o, ethers as d } from "ethers";
+import w from "libsodium-wrappers";
+import { CIRCOM_P as m } from "../../constants/protocol.constants.mjs";
+import { babyJubInstance as b } from "../../crypto/babyJub.mjs";
+import { poseidonHash as c } from "../../crypto/poseidon.mjs";
+import { getCircomSign as y } from "./keyUtils.mjs";
+import { AttachableMemoryCacheDevice as v } from "../cacheDevices/AttachableMemoryCacheDevice.mjs";
+import { ethers as u, hexlify as F } from "ethers-v6h";
+import { isSolanaLike as h, networkRegistry as p } from "../../constants/chains.constants.mjs";
+import { Keypair as g, VersionedTransaction as K } from "@solana/web3.js";
+import k from "tweetnacl";
+import P from "bs58";
+import { createCustomSolanaConnection as A } from "../../functions/utils/create-provider.mjs";
+const E = new v(), R = new v(), L = {
   privateKey: "",
   publicKey: ""
 };
-class D {
+class l {
   signature;
   constructor(e) {
     this.signature = e;
@@ -27,80 +31,133 @@ class D {
       throw Error("No signature provided");
   }
   verifyMessage(e) {
-    return this.requireSignature(), g.verifyMessage(e, this.signature);
+    return this.requireSignature(), o.verifyMessage(e, this.signature);
   }
   /**
    * 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 = () => (this.requireSignature(), h.utils.keccak256(this.signature));
+  getShieldedPrivateKey = () => (this.requireSignature(), d.utils.keccak256(this.signature));
   /**
    * 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 = () => (this.requireSignature(), a(this.getShieldedPrivateKey()));
+  getShieldedPublicKey = () => (this.requireSignature(), c(this.getShieldedPrivateKey()));
+  /**
+   * deterministically derive an EVM address from the shielded private key
+   */
+  getDerivedEthereumAddress = () => (this.requireSignature(), new u.Wallet(this.getShieldedPrivateKey()).address);
+  /**
+   * deterministically derive a Solana public key from the shielded private key
+   */
+  getDerivedSolanaPublicKey = () => (this.requireSignature(), g.fromSeed(o.arrayify(this.getShieldedPrivateKey())).publicKey.toBase58());
   /**
    * generate access token, this accessKey is what should be sent to the server for signing
    * @returns accessKey in hexstring with 0x prefixed
    */
-  getAccessKey = () => (this.requireSignature(), a(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
-  static getSignerAddressFromPrivateKey(e) {
-    return new c.Wallet(e).address;
-  }
-  static deriveSignerFromNonce(e, t) {
-    const r = a(t, e.getShieldedPrivateKey(), e.getShieldedPublicKey()), i = g.keccak256(g.toUtf8Bytes(r));
-    return new c.Wallet(i);
-  }
-  static async signMessageFromPrivateKey(e, t) {
-    const r = new c.Wallet(e), i = g.isHexString(t) ? g.arrayify(t) : t;
-    return r.signMessage(i);
-  }
-  static signTypedDataFromPrivateKey(e, t, r, i) {
-    return new c.Wallet(e).signTypedData(t, r, i);
-  }
-  static async authorizeDelegationFromPrivateKey(e, t, r, i) {
-    const n = new c.Wallet(e), s = new c.JsonRpcProvider(K[t].fetchRpcUrl);
-    return n.connect(s).authorize({
-      address: r,
-      ...i !== void 0 && { nonce: i }
-    });
+  getAccessKey = () => (this.requireSignature(), c(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
+  getSignerPrivateKeyFromNonce = (e) => {
+    this.requireSignature();
+    const r = c(e, this.getShieldedPrivateKey(), this.getShieldedPublicKey());
+    return o.keccak256(o.toUtf8Bytes(r));
+  };
+  getSignerSolanaPrivateKeyFromNonce = (e) => {
+    const r = this.getSignerPrivateKeyFromNonce(e), t = o.arrayify(r), i = g.fromSeed(t);
+    return P.encode(i.secretKey);
+  };
+  getEvmPrivateKeyFromSolanaPrivateKey = (e) => {
+    const t = P.decode(e).slice(0, 32);
+    return F(t);
+  };
+  static getSignerFromPrivateKey = (e, r) => {
+    if (h(e)) {
+      const i = o.arrayify(r);
+      return g.fromSeed(i);
+    }
+    return new u.Wallet(r);
+  };
+  static getSignerAddressFromPrivateKey(e, r) {
+    const t = l.getSignerFromPrivateKey(e, r);
+    return t instanceof g ? t.publicKey.toString() : t.address;
   }
-  getWalletSalt = (e) => (this.requireSignature(), a(this.getShieldedPublicKey(), this.getShieldedPrivateKey(), e));
+  static signMessageFromPrivateKey = async (e, r, t) => {
+    const i = l.getSignerFromPrivateKey(e, r);
+    if (i instanceof g) {
+      const a = o.isHexString(t) ? o.arrayify(t) : new TextEncoder().encode(t), s = k.sign.detached(a, i.secretKey);
+      return `0x${Buffer.from(s).toString("hex")}`;
+    }
+    const n = o.isHexString(t) ? o.arrayify(t) : t;
+    return i.signMessage(n);
+  };
+  static signSolanaTransactionFromPrivateKey = (e, r, t) => {
+    if (!h(e))
+      throw new Error("Solana transaction signing is only available for Solana chains");
+    const i = l.getSignerFromPrivateKey(e, r);
+    if (!(i instanceof g))
+      throw new Error("Unable to derive Solana keypair for signing");
+    t.sign([i]);
+  };
+  static sendAndSignTransactionFromPrivateKey = async (e, r, t) => {
+    const i = l.getSignerFromPrivateKey(e, r), { fetchRpcUrl: n } = p[e];
+    if (!n)
+      throw new Error("No RPC URL found for chainId");
+    if (i instanceof g) {
+      if (!(t instanceof K))
+        throw new Error("Invalid transaction type for Solana");
+      return t.sign([i]), await A(n).sendRawTransaction(t.serialize());
+    }
+    if (t instanceof K)
+      throw new Error("Invalid transaction type for EVM");
+    const a = new u.JsonRpcProvider(n);
+    return (await i.connect(a).sendTransaction(t)).hash;
+  };
+  static signTypedDataFromPrivateKey = async (e, r, t, i, n) => {
+    if (h(e))
+      throw new Error("Solana does not support typed data");
+    return await l.getSignerFromPrivateKey(e, r).signTypedData(t, i, n);
+  };
+  static authorizeDelegation = async (e, r, t, i) => {
+    if (h(e))
+      throw new Error("Solana does not support delegation");
+    const n = new u.JsonRpcProvider(p[e].fetchRpcUrl);
+    return await l.getSignerFromPrivateKey(e, r).connect(n).authorize({ address: t, ...i !== void 0 && { nonce: i } });
+  };
+  getWalletSalt = (e) => (this.requireSignature(), c(this.getShieldedPublicKey(), this.getShieldedPrivateKey(), e));
   /**
    * generate inHinkalAddress - a user unique address linking him with a specific app
    * @returns inHinkalAddress in bigint
    */
   getInHinkalAddress = (e) => {
     this.requireSignature();
-    const t = a(this.getShieldedPrivateKey(), e);
-    return BigInt(t);
+    const r = c(this.getShieldedPrivateKey(), e);
+    return BigInt(r);
   };
   /**
    * generate backend token, which is used for access control on backend
    * @returns accessKey in hexstring with 0x prefixed
    */
-  getBackendToken = () => (this.requireSignature(), a(this.getAccessKey(), this.getShieldedPublicKey()));
-  static getRandomizedStealthPair = P.attach(
-    (e, t) => {
-      const r = p(), i = BigInt(t) % d, n = e * i % d, s = r.mulPointEscalar(r.Base8, e), o = r.mulPointEscalar(r.Base8, n), y = [BigInt(r.F.toString(s[0])), BigInt(r.F.toString(s[1]))], S = [BigInt(r.F.toString(o[0])), BigInt(r.F.toString(o[1]))];
-      return { H0: y, H1: S };
+  getBackendToken = () => (this.requireSignature(), c(this.getAccessKey(), this.getShieldedPublicKey()));
+  static getRandomizedStealthPair = E.attach(
+    (e, r) => {
+      const t = b(), i = BigInt(r) % m, n = e * i % m, a = t.mulPointEscalar(t.Base8, e), s = t.mulPointEscalar(t.Base8, n), S = [BigInt(t.F.toString(a[0])), BigInt(t.F.toString(a[1]))], f = [BigInt(t.F.toString(s[0])), BigInt(t.F.toString(s[1]))];
+      return { H0: S, H1: f };
     }
   );
-  static getStealthAddressCompressedPoints = (e, t) => {
-    const { H0: r, H1: i } = this.getRandomizedStealthPair(e, t), [n, s] = [r, i].map((o) => BigInt(o[1]) + 2n ** 255n * l(o[0]));
-    return { h0: n, h1: s };
+  static getStealthAddressCompressedPoints = (e, r) => {
+    const { H0: t, H1: i } = this.getRandomizedStealthPair(e, r), [n, a] = [t, i].map((s) => BigInt(s[1]) + 2n ** 255n * y(s[0]));
+    return { h0: n, h1: a };
   };
-  static getStealthAddress = v.attach((e, t) => {
-    const { H0: r, H1: i } = this.getRandomizedStealthPair(e, t), s = [2n * l(r[0]) + l(i[0]), r[1], i[1]];
-    return a(...s);
+  static getStealthAddress = R.attach((e, r) => {
+    const { H0: t, H1: i } = this.getRandomizedStealthPair(e, r), a = [2n * y(t[0]) + y(i[0]), t[1], i[1]];
+    return c(...a);
   });
-  static getStealthAddressWithEKey = (e, t) => ({ stealthAddress: this.getStealthAddress(e, t), encryptionKey: this.getEncryptionKeyPair(t).publicKey });
-  static checkSignature = (e, t, r, i) => {
-    const { h0: n, h1: s } = this.getStealthAddressCompressedPoints(e, i);
-    return t === n && r === s;
+  static getStealthAddressWithEKey = (e, r) => ({ stealthAddress: this.getStealthAddress(e, r), encryptionKey: this.getEncryptionKeyPair(r).publicKey });
+  static checkSignature = (e, r, t, i) => {
+    const { h0: n, h1: a } = this.getStealthAddressCompressedPoints(e, i);
+    return r === n && t === a;
   };
   /**
    * generate private and public keypair
@@ -108,16 +165,16 @@ class D {
    * and must correspond to 32 bytes
    */
   static getEncryptionKeyPair = (e) => {
-    const t = m.crypto_box_seed_keypair(h.utils.arrayify(e));
+    const r = w.crypto_box_seed_keypair(d.utils.arrayify(e));
     return {
-      privateKey: h.utils.hexlify(t.privateKey),
-      publicKey: h.utils.hexlify(t.publicKey)
+      privateKey: d.utils.hexlify(r.privateKey),
+      publicKey: d.utils.hexlify(r.publicKey)
     };
   };
 }
 export {
-  C as EncryptionKeyPairDefaultValue,
-  D as UserKeys,
-  v as stealthAddressCacheDevice,
-  P as stealthPairCacheDevice
+  L as EncryptionKeyPairDefaultValue,
+  l as UserKeys,
+  R as stealthAddressCacheDevice,
+  E as stealthPairCacheDevice
 };

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../../../constants/protocol.constants.cjs"),a=require("../../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const t=require("../../../functions/utils/amounts.utils.cjs"),o=require("../../merkle-tree/MerkleTree.cjs");require("ethers");require("../../../error-handling/error-codes.constants.cjs");const l=require("./AbstractSnapshotService.cjs"),i=require("../../../functions/utils/merkleTree.utils.cjs");class u extends l.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(([s,r])=>({address:s,index:r}))}}deserializeSnapshot(e){let s,r;return e.latestBlockNumber&&e.merkleTree?s=i.contructMerkleTreeFromSerialized(e.merkleTree):s=o.MerkleTree.create(a.poseidonFunction,0n),e.latestBlockNumber&&e.senderAddressIndexMap?r=new Map(e.senderAddressIndexMap.map(({address:d,index:n})=>[d,n])):r=new Map,{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:s,senderAddresses:e.senderAddresses??[],senderAddressIndexMap:r}}}acceptEvent(e,s){try{return this._merkleTree.insert(e.accessKey,e.index),this._senderAddressIndexMap.set(e.senderAddress,Math.max(Number(e.index),this._senderAddressIndexMap.get(e.senderAddress)??0)),this._senderAddresses.includes(e.senderAddress)||this._senderAddresses.push(e.senderAddress),e.accessKey===0n&&e.senderAddress===c.zeroAddress&&this._merkleTree.remove(e.index),!0}catch(r){return console.error(r),!1}}mapEvent(e){const{accessKey:s,index:r,senderAddress:d}=e;return{accessKey:t.toBigInt(s),index:t.toBigInt(r),senderAddress:d}}getSnapshotPayload(){return{merkleTree:this._merkleTree,senderAddresses:this._senderAddresses,senderAddressIndexMap:this._senderAddressIndexMap}}populateSnapshot({payload:{merkleTree:e,senderAddresses:s,senderAddressIndexMap:r}}){this._merkleTree=e,this._senderAddresses=s,this._senderAddressIndexMap=r}}exports.AbstractAccessTokenSnapshotService=u;

package/data-structures/event-service/{AbstractAccessTokenSnapshotService.d.ts → evm/AbstractAccessTokenSnapshotService.d.ts}

@@ -1,5 +1,5 @@
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { AccessTokenEvent } from '../../types';
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { AccessTokenEvent } from '../../../types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
 import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type SenderAddressIndexMapJson = {

package/data-structures/event-service/{AbstractAccessTokenSnapshotService.mjs → evm/AbstractAccessTokenSnapshotService.mjs}

@@ -1,15 +1,15 @@
-import { zeroAddress as m } from "../../constants/protocol.constants.mjs";
-import { poseidonFunction as o } from "../../crypto/poseidon.mjs";
+import { zeroAddress as m } from "../../../constants/protocol.constants.mjs";
+import { poseidonFunction as o } from "../../../crypto/poseidon.mjs";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
 import "process";
 import "buffer";
-import { toBigInt as t } from "../../functions/utils/amounts.utils.mjs";
-import { MerkleTree as a } from "../merkle-tree/MerkleTree.mjs";
+import { toBigInt as t } from "../../../functions/utils/amounts.utils.mjs";
+import { MerkleTree as a } from "../../merkle-tree/MerkleTree.mjs";
 import "ethers";
-import "../../error-handling/error-codes.constants.mjs";
+import "../../../error-handling/error-codes.constants.mjs";
 import { AbstractSnapshotService as l } from "./AbstractSnapshotService.mjs";
-import { contructMerkleTreeFromSerialized as A } from "../../functions/utils/merkleTree.utils.mjs";
+import { contructMerkleTreeFromSerialized as A } from "../../../functions/utils/merkleTree.utils.mjs";
 class b extends l {
   constructor(e) {
     super(e, "NewAccessKeyAdded");

package/data-structures/event-service/evm/AbstractApprovalsSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("./AbstractSnapshotService.cjs"),v=require("../../../functions/utils/amounts.utils.cjs"),u=require("../../../functions/utils/caseInsensitive.utils.cjs");class A extends c.AbstractSnapshotService{constructor(e){super(e,"NewApprovedUtxo")}_approvals=new Map;events=new Set;get approvals(){return this._approvals}getEventKey(e,t,s){return typeof e!="bigint"||typeof s!="string"||typeof t!="string"?null:`${s}-${t}-${e}`}serializeSnapshot(e){const t=Object.fromEntries(e.payload.approvals),s=Object.entries(t).map(([p,i])=>{const l=i.map(n=>({amount:n.amount.toString(),tokenAddress:n.tokenAddress,inHinkalAddress:n.inHinkalAddress.toString()}));return[p,l]}),r=Object.fromEntries(s);return{latestBlockNumber:e.latestBlockNumber,approvals:r,events:[...this.events]}}deserializeSnapshot(e){const t=e.approvals,s=Object.entries(t).map(([p,i])=>{const l=i.map(n=>({amount:BigInt(n.amount),tokenAddress:n.tokenAddress,inHinkalAddress:BigInt(n.inHinkalAddress)}));return[p,l]}),r=new Map(s);return{latestBlockNumber:e.latestBlockNumber??0,payload:{approvals:r,events:new Set(e.events)}}}getSnapshotPayload(){return{approvals:this._approvals,events:this.events}}populateSnapshot({payload:{approvals:e,events:t}}){this._approvals=e,this.events=t}mapEvent(e){const{approveTo:t,tokenAddress:s,amount:r,inHinkalAddress:p}=e;return{approveTo:t,tokenAddress:s,amount:v.toBigInt(r),inHinkalAddress:v.toBigInt(p)}}acceptEvent(e,t,s){const r=this.getEventKey(e.inHinkalAddress,e.tokenAddress,s);if(r&&!this.events.has(r)){const{amount:p,tokenAddress:i,inHinkalAddress:l}=e,n={amount:p,tokenAddress:i,inHinkalAddress:l};let a=this.approvals.get(e.approveTo)||[],d=!1;for(let o=0;o<a.length;o+=1)u.caseInsensitiveEqual(i,a[o].tokenAddress)&&l===a[o].inHinkalAddress&&(a[o].amount+=p,d=!0);if(a=a.filter(o=>o.amount!==0n),d&&a.length===0)this.approvals.delete(e.approveTo);else{const o=d?a:[...a,n];this.approvals.set(e.approveTo,o)}return s&&this.events.add(r),!0}return!1}}exports.AbstractApprovalsSnapshotService=A;

package/data-structures/event-service/{AbstractApprovalsSnapshotService.d.ts → evm/AbstractApprovalsSnapshotService.d.ts}

@@ -1,7 +1,7 @@
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-import { NewApprovedUtxoEvent } from '../../types/commitments.types';
+import { NewApprovedUtxoEvent } from '../../../types/commitments.types';
 import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-import { ApprovedUtxo } from '../../types/hinkal.types';
+import { ApprovedUtxo } from '../../../types/hinkal.types';
 export type ApprovalsSnapshotPayload = {
     readonly approvals: Map<string, ApprovedUtxo[]>;
     readonly events: Set<string>;

package/data-structures/event-service/{AbstractApprovalsSnapshotService.mjs → evm/AbstractApprovalsSnapshotService.mjs}

@@ -1,6 +1,6 @@
 import { AbstractSnapshotService as c } from "./AbstractSnapshotService.mjs";
-import { toBigInt as v } from "../../functions/utils/amounts.utils.mjs";
-import { caseInsensitiveEqual as u } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { toBigInt as v } from "../../../functions/utils/amounts.utils.mjs";
+import { caseInsensitiveEqual as u } from "../../../functions/utils/caseInsensitive.utils.mjs";
 class g extends c {
   constructor(e) {
     super(e, "NewApprovedUtxo");

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../../../crypto/poseidon.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const l=require("../../merkle-tree/MerkleTree.cjs");require("ethers");require("../../../error-handling/error-codes.constants.cjs");const u=require("../../../functions/utils/amounts.utils.cjs"),o=require("./AbstractSnapshotService.cjs"),p=require("../../../functions/utils/merkleTree.utils.cjs");class a extends o.AbstractSnapshotService{constructor(e){super(e,"NewCommitment")}_merkleTree;_encryptedOutputs;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(t=>({value:t.value,isPositive:String(t.isPositive),isBlocked:t.isBlocked??!1}))}}deserializeSnapshot(e){let t;e.latestBlockNumber&&e.merkleTree?t=p.contructMerkleTreeFromSerialized(e.merkleTree):t=l.MerkleTree.create(c.poseidonFunction,0n);const s=e.encryptedOutputs?.map(r=>({value:r.value,isPositive:JSON.parse(r.isPositive),isBlocked:r.isBlocked??!1}));return{latestBlockNumber:e.latestBlockNumber??0,payload:{merkleTree:t,encryptedOutputs:s||[]}}}getSnapshotPayload(){return{merkleTree:this._merkleTree,encryptedOutputs:this._encryptedOutputs}}populateSnapshot({payload:{merkleTree:e,encryptedOutputs:t}}){this._merkleTree=e,this._encryptedOutputs=t}mapEvent(e){const{commitment:t,index:s,encryptedOutput:r}=e;return{commitment:u.toBigInt(t),index:u.toBigInt(s),encryptedOutput:r}}acceptEvent(e,t,s,r){if(!this.encryptedOutputs.map(i=>i.value).includes(e.encryptedOutput)){if(!this._merkleTree.insert(e.commitment,e.index>=0?e.index:-1n*e.index))return!1;const n={value:e.encryptedOutput,isPositive:e.index>=0n,isBlocked:r??!1};return this._encryptedOutputs.push(n),!0}return!1}}exports.AbstractCommitmentsSnapshotService=a;

package/data-structures/event-service/{AbstractCommitmentsSnapshotService.d.ts → evm/AbstractCommitmentsSnapshotService.d.ts}

@@ -1,5 +1,5 @@
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { CommitmentEvent, EncryptedOutputWithSign } from '../../types';
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithSign } from '../../../types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
 import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type CommitmentsSnapshotPayload = {
@@ -25,5 +25,5 @@ export declare abstract class AbstractCommitmentsSnapshotService extends Abstrac
     };
     protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
     protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
-    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number, _txHash?: string, isBlocked?: boolean): boolean;
 }

package/data-structures/event-service/{AbstractCommitmentsSnapshotService.mjs → evm/AbstractCommitmentsSnapshotService.mjs}

@@ -1,15 +1,15 @@
-import { poseidonFunction as p } from "../../crypto/poseidon.mjs";
+import { poseidonFunction as m } from "../../../crypto/poseidon.mjs";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
 import "process";
 import "buffer";
-import { MerkleTree as s } from "../merkle-tree/MerkleTree.mjs";
+import { MerkleTree as c } from "../../merkle-tree/MerkleTree.mjs";
 import "ethers";
-import "../../error-handling/error-codes.constants.mjs";
-import { toBigInt as i } from "../../functions/utils/amounts.utils.mjs";
-import { AbstractSnapshotService as m } from "./AbstractSnapshotService.mjs";
-import { contructMerkleTreeFromSerialized as n } from "../../functions/utils/merkleTree.utils.mjs";
-class S extends m {
+import "../../../error-handling/error-codes.constants.mjs";
+import { toBigInt as p } from "../../../functions/utils/amounts.utils.mjs";
+import { AbstractSnapshotService as o } from "./AbstractSnapshotService.mjs";
+import { contructMerkleTreeFromSerialized as n } from "../../../functions/utils/merkleTree.utils.mjs";
+class b extends o {
   constructor(e) {
     super(e, "NewCommitment");
   }
@@ -27,22 +27,24 @@ class S extends m {
       latestBlockNumber: e.latestBlockNumber,
       encryptedOutputs: e.payload.encryptedOutputs.map((t) => ({
         value: t.value,
-        isPositive: String(t.isPositive)
+        isPositive: String(t.isPositive),
+        isBlocked: t.isBlocked ?? !1
       }))
     };
   }
   deserializeSnapshot(e) {
     let t;
-    e.latestBlockNumber && e.merkleTree ? t = n(e.merkleTree) : t = s.create(p, 0n);
-    const r = e.encryptedOutputs?.map((u) => ({
-      value: u.value,
-      isPositive: JSON.parse(u.isPositive)
+    e.latestBlockNumber && e.merkleTree ? t = n(e.merkleTree) : t = c.create(m, 0n);
+    const s = e.encryptedOutputs?.map((r) => ({
+      value: r.value,
+      isPositive: JSON.parse(r.isPositive),
+      isBlocked: r.isBlocked ?? !1
     }));
     return {
       latestBlockNumber: e.latestBlockNumber ?? 0,
       payload: {
         merkleTree: t,
-        encryptedOutputs: r || []
+        encryptedOutputs: s || []
       }
     };
   }
@@ -58,20 +60,21 @@ class S extends m {
     this._merkleTree = e, this._encryptedOutputs = t;
   }
   mapEvent(e) {
-    const { commitment: t, index: r, encryptedOutput: u } = e;
+    const { commitment: t, index: s, encryptedOutput: r } = e;
     return {
-      commitment: i(t),
-      index: i(r),
-      encryptedOutput: u
+      commitment: p(t),
+      index: p(s),
+      encryptedOutput: r
     };
   }
-  acceptEvent(e, t) {
-    if (!this.encryptedOutputs.map((r) => r.value).includes(e.encryptedOutput)) {
+  acceptEvent(e, t, s, r) {
+    if (!this.encryptedOutputs.map((i) => i.value).includes(e.encryptedOutput)) {
       if (!this._merkleTree.insert(e.commitment, e.index >= 0 ? e.index : -1n * e.index))
         return !1;
       const u = {
         value: e.encryptedOutput,
-        isPositive: e.index >= 0n
+        isPositive: e.index >= 0n,
+        isBlocked: r ?? !1
       };
       return this._encryptedOutputs.push(u), !0;
     }
@@ -79,5 +82,5 @@ class S extends m {
   }
 }
 export {
-  S as AbstractCommitmentsSnapshotService
+  b as AbstractCommitmentsSnapshotService
 };

package/data-structures/event-service/evm/AbstractEventService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("../../../functions/utils/resolve-sync.utils.cjs");class h{blockchainEventEmitter;eventName;constructor(e,t){this.blockchainEventEmitter=e,this.eventName=t,e.addEventProcessorFunction(this.processEventsPage.bind(this))}get latestBlockNumber(){return this.blockchainEventEmitter.latestBlockNumber}intervalClear(){this.blockchainEventEmitter.intervalClear()}async processEventsPage(e){const t=new Set;e.forEach(({event:s,transactionHash:n})=>{s==="BlockedUtxosCreated"&&t.add(n)});const c=[];await v.resolveSync(e.map(s=>async()=>{if(s.event!==this.eventName)return;const{args:n,blockNumber:i,transactionHash:r}=s;if(!n)throw new Error("Wrong event structure");const a=this.mapEvent(n),l=t.has(r);await this.acceptEvent(a,i,r,l)&&c.push(a)}));const o=c.length;return await this.afterEventsAccepted(o),c.length}}exports.AbstractEventService=h;

package/data-structures/event-service/{AbstractEventService.d.ts → evm/AbstractEventService.d.ts}

@@ -6,7 +6,7 @@ export declare abstract class AbstractEventService<EventType, SerializedEventTyp
     get latestBlockNumber(): number;
     intervalClear(): void;
     private processEventsPage;
-    protected abstract acceptEvent(event: EventType, blockNumber: number, txHash?: string): boolean | Promise<boolean>;
+    protected abstract acceptEvent(event: EventType, blockNumber: number, txHash?: string, isBlocked?: boolean): boolean | Promise<boolean>;
     protected abstract mapEvent(event: SerializedEventType): EventType;
     protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
 }

package/data-structures/event-service/evm/AbstractEventService.mjs

@@ -0,0 +1,37 @@
+import { resolveSync as v } from "../../../functions/utils/resolve-sync.utils.mjs";
+class u {
+  blockchainEventEmitter;
+  eventName;
+  constructor(t, e) {
+    this.blockchainEventEmitter = t, this.eventName = e, t.addEventProcessorFunction(this.processEventsPage.bind(this));
+  }
+  get latestBlockNumber() {
+    return this.blockchainEventEmitter.latestBlockNumber;
+  }
+  intervalClear() {
+    this.blockchainEventEmitter.intervalClear();
+  }
+  async processEventsPage(t) {
+    const e = /* @__PURE__ */ new Set();
+    t.forEach(({ event: s, transactionHash: n }) => {
+      s === "BlockedUtxosCreated" && e.add(n);
+    });
+    const c = [];
+    await v(
+      t.map((s) => async () => {
+        if (s.event !== this.eventName)
+          return;
+        const { args: n, blockNumber: i, transactionHash: a } = s;
+        if (!n)
+          throw new Error("Wrong event structure");
+        const r = this.mapEvent(n), h = e.has(a);
+        await this.acceptEvent(r, i, a, h) && c.push(r);
+      })
+    );
+    const o = c.length;
+    return await this.afterEventsAccepted(o), c.length;
+  }
+}
+export {
+  u as AbstractEventService
+};

package/data-structures/event-service/{AbstractNullifierSnapshotService.d.ts → evm/AbstractNullifierSnapshotService.d.ts}

@@ -1,5 +1,5 @@
 import { BigNumber } from 'ethers';
-import { NullifierEvent } from '../../types/commitments.types';
+import { NullifierEvent } from '../../../types/commitments.types';
 import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
 import { BlockchainEventEmitter } from './BlockchainEventEmitter';
 export type NullifierSnapshotPayload = {

package/data-structures/event-service/evm/AbstractSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../../constants/save-depths.cjs"),a=require("./AbstractEventService.cjs");class i extends a.AbstractEventService{savedLatestBlockNumber=0;chainId=0;constructor(t,e){super(t,e)}async init(){await this.loadSnapshot(),this.chainId=(await this.blockchainEventEmitter.contract.provider.getNetwork()).chainId}async retrieveEventsFromLatestBlock(){await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber)}async loadSnapshot(){const t=await this.fetchSnapshot(),e=this.deserializeSnapshot(t);this.populateSnapshot(e),this.blockchainEventEmitter.syncFromAtMost(e.latestBlockNumber),this.savedLatestBlockNumber=e.latestBlockNumber}saveSnapshot(){return this.savedLatestBlockNumber=this.latestBlockNumber,this.persistSnapshot(this.serializeSnapshot({latestBlockNumber:this.latestBlockNumber,payload:this.getSnapshotPayload()}))}async afterEventsAccepted(t){(t>0||this.savedLatestBlockNumber+s.saveDepths[this.chainId]<this.latestBlockNumber)&&await this.saveSnapshot()}}exports.AbstractSnapshotService=i;

package/data-structures/event-service/{AbstractSnapshotService.mjs → evm/AbstractSnapshotService.mjs}

@@ -1,4 +1,4 @@
-import { saveDepths as e } from "../../constants/save-depths.mjs";
+import { saveDepths as e } from "../../../constants/save-depths.mjs";
 import { AbstractEventService as a } from "./AbstractEventService.mjs";
 class c extends a {
   savedLatestBlockNumber = 0;

package/data-structures/event-service/evm/BlockchainEventEmitter.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("../../../constants/reorg-depths.constants.cjs"),c=require("../../../functions/utils/resolve-sync.utils.cjs"),m=require("../../../functions/utils/mutexes.utils.cjs");class y{contract;depositOnChainUtxosContract;_latestBlockNumber;_initialBlockNumber;onEventsProcessed;eventProcessors=new Set;maxPageSize;isReady=!1;isServer;intervalId;inProgress;constructor(e,r,l,s,i){this.contract=e,this.depositOnChainUtxosContract=i,this._initialBlockNumber=r,this.maxPageSize=s,this.isServer=l,this.inProgress=!1}get latestBlockNumber(){return this._latestBlockNumber??this._initialBlockNumber}syncFromAtMost(e){(this._latestBlockNumber===void 0||e<this._latestBlockNumber)&&(this._latestBlockNumber=e)}intervalClear(){this.isReady=!1,this.eventProcessors=new Set,clearInterval(this.intervalId)}async init(){if(this.isReady)throw new Error("Already initialized");this.isReady=!0,await this.retrieveEvents(this.latestBlockNumber+1),this.intervalId=setInterval(async()=>{await this.retrieveEvents(this.latestBlockNumber)},3500)}requireReady(){if(!this.isReady)throw new Error("Not ready")}addEventProcessorFunction(e){if(this.isReady)throw new Error("Can't add event processor after event emitter initialized");this.eventProcessors.add(e)}async getLastBlockNumberForEventRequest(){const e=await this.contract.provider.getBlockNumber();if(!this.isServer)return e;const{chainId:r}=await this.contract.provider.getNetwork();return Math.max(this.latestBlockNumber,e-d.blockReorgDepth[r]+1)}async retrieveEvents(e,r=!1){return this.requireReady(),await m.balanceFetchingMutex.runExclusive(async()=>{try{if(this.inProgress&&!r)return!1;this.inProgress=!0;let s=0;const i=await this.getLastBlockNumberForEventRequest();if(i<e)return this.inProgress=!1,!1;const h=c.getSequence(e,i,this.maxPageSize),n=[];if(await c.resolveSync(h.map(({from:t,to:a})=>async()=>{const o=await this.contract.queryFilter("*",t,a);n.push(...o)})),this.depositOnChainUtxosContract){const{depositOnChainUtxosContract:t}=this;await c.resolveSync(h.map(({from:a,to:o})=>async()=>{const v=await t.queryFilter("*",a,o);n.push(...v)}))}const u=await Promise.all([...this.eventProcessors].map(t=>t(n)));return this._latestBlockNumber=i,s+=u.reduce((t,a)=>t+a,0),this.onEventsProcessed?.(s),this.inProgress=!1,!0}catch(s){return console.log("retrieveEvents error:",{err:s}),this.inProgress=!1,!1}})}}exports.BlockchainEventEmitter=y;

package/data-structures/event-service/{BlockchainEventEmitter.d.ts → evm/BlockchainEventEmitter.d.ts}

@@ -2,6 +2,7 @@ import { ethers } from 'ethers';
 export type EventProcessorFunction = (events: ethers.Event[]) => Promise<number> | number;
 export declare class BlockchainEventEmitter {
     readonly contract: ethers.Contract;
+    readonly depositOnChainUtxosContract?: ethers.Contract;
     private _latestBlockNumber;
     private _initialBlockNumber;
     onEventsProcessed?: (acceptedEventCount: number) => void;
@@ -11,7 +12,7 @@ export declare class BlockchainEventEmitter {
     private isServer;
     private intervalId?;
     private inProgress;
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract);
     get latestBlockNumber(): number;
     syncFromAtMost(blockNumber: number): void;
     intervalClear(): void;

package/data-structures/event-service/evm/BlockchainEventEmitter.mjs

@@ -0,0 +1,89 @@
+import { blockReorgDepth as d } from "../../../constants/reorg-depths.constants.mjs";
+import { getSequence as m, resolveSync as h } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { balanceFetchingMutex as y } from "../../../functions/utils/mutexes.utils.mjs";
+class g {
+  contract;
+  depositOnChainUtxosContract;
+  _latestBlockNumber;
+  _initialBlockNumber;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  constructor(t, r, c, s, i) {
+    this.contract = t, this.depositOnChainUtxosContract = i, this._initialBlockNumber = r, this.maxPageSize = s, this.isServer = c, this.inProgress = !1;
+  }
+  get latestBlockNumber() {
+    return this._latestBlockNumber ?? this._initialBlockNumber;
+  }
+  syncFromAtMost(t) {
+    (this._latestBlockNumber === void 0 || t < this._latestBlockNumber) && (this._latestBlockNumber = t);
+  }
+  intervalClear() {
+    this.isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), clearInterval(this.intervalId);
+  }
+  async init() {
+    if (this.isReady)
+      throw new Error("Already initialized");
+    this.isReady = !0, await this.retrieveEvents(this.latestBlockNumber + 1), this.intervalId = setInterval(async () => {
+      await this.retrieveEvents(this.latestBlockNumber);
+    }, 3500);
+  }
+  requireReady() {
+    if (!this.isReady)
+      throw new Error("Not ready");
+  }
+  addEventProcessorFunction(t) {
+    if (this.isReady)
+      throw new Error("Can't add event processor after event emitter initialized");
+    this.eventProcessors.add(t);
+  }
+  async getLastBlockNumberForEventRequest() {
+    const t = await this.contract.provider.getBlockNumber();
+    if (!this.isServer)
+      return t;
+    const { chainId: r } = await this.contract.provider.getNetwork();
+    return Math.max(this.latestBlockNumber, t - d[r] + 1);
+  }
+  async retrieveEvents(t, r = !1) {
+    return this.requireReady(), await y.runExclusive(async () => {
+      try {
+        if (this.inProgress && !r)
+          return !1;
+        this.inProgress = !0;
+        let s = 0;
+        const i = await this.getLastBlockNumberForEventRequest();
+        if (i < t)
+          return this.inProgress = !1, !1;
+        const l = m(t, i, this.maxPageSize), n = [];
+        if (await h(
+          l.map(({ from: e, to: a }) => async () => {
+            const o = await this.contract.queryFilter("*", e, a);
+            n.push(...o);
+          })
+        ), this.depositOnChainUtxosContract) {
+          const { depositOnChainUtxosContract: e } = this;
+          await h(
+            l.map(({ from: a, to: o }) => async () => {
+              const v = await e.queryFilter("*", a, o);
+              n.push(...v);
+            })
+          );
+        }
+        const u = await Promise.all(
+          [...this.eventProcessors].map((e) => e(n))
+        );
+        return this._latestBlockNumber = i, s += u.reduce((e, a) => e + a, 0), this.onEventsProcessed?.(s), this.inProgress = !1, !0;
+      } catch (s) {
+        return console.log("retrieveEvents error:", { err: s }), this.inProgress = !1, !1;
+      }
+    });
+  }
+}
+export {
+  g as BlockchainEventEmitter
+};

package/data-structures/event-service/index.d.ts

@@ -1,7 +1,13 @@
-export * from './AbstractAccessTokenSnapshotService';
-export * from './AbstractCommitmentsSnapshotService';
-export * from './AbstractApprovalsSnapshotService';
-export * from './AbstractNullifierSnapshotService';
-export * from './AbstractSnapshotService';
-export * from './AbstractEventService';
-export * from './BlockchainEventEmitter';
+export * from './evm/AbstractAccessTokenSnapshotService';
+export * from './evm/AbstractCommitmentsSnapshotService';
+export * from './evm/AbstractApprovalsSnapshotService';
+export * from './evm/AbstractNullifierSnapshotService';
+export * from './evm/AbstractSnapshotService';
+export * from './evm/AbstractEventService';
+export * from './evm/BlockchainEventEmitter';
+export * from './solana/SolanaBlockchainEventEmitter';
+export * from './solana/AbstractSolanaEventService';
+export * from './solana/AbstractSolanaSnapshotService';
+export * from './solana/AbstractSolanaNullifierSnapshotService';
+export * from './solana/AbstractSolanaCommitmentsSnapshotService';
+export * from './solana/AbstractSolanaAccessTokenSnapshotService';