@0xpolygonid/js-sdk 1.6.1 → 1.7.0

package/dist/browser/esm/index.js

@@ -5,7 +5,7 @@ import { Merklizer, Path, getDocumentLoader } from '@iden3/js-jsonld-merklizatio
 import * as jsJsonldMerklization from '@iden3/js-jsonld-merklization';
 export { jsJsonldMerklization as jsonLDMerklizer };
 import { PrivateKey, Hex, base58ToBytes as base58ToBytes$2, base58FromBytes, Signature as Signature$5, PublicKey, poseidon, sha256 as sha256$3, getRandomBytes, Poseidon } from '@iden3/js-crypto';
-import { Hash as Hash$1, Proof, ZERO_HASH, swapEndianness as swapEndianness$1, newHashFromString, verifyProof, rootFromProof, testBit, newHashFromBigInt, NodeLeaf, NODE_TYPE_LEAF, hashElems, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage } from '@iden3/js-merkletree';
+import { Hash as Hash$1, Proof, ZERO_HASH, swapEndianness as swapEndianness$1, newHashFromString, verifyProof, rootFromProof, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage } from '@iden3/js-merkletree';
 import { groth16 } from 'snarkjs';
 import { getCurveFromName } from 'ffjavascript';
 import { Token, Header, ProvingMethodAlg, proving } from '@iden3/js-jwz';
@@ -31665,6 +31665,39 @@ function spelunkMessage(value) {
 }
 
 var abi$2 = [
+	{
+		inputs: [
+		],
+		name: "MAX_SMT_DEPTH",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "key",
+				type: "uint256"
+			}
+		],
+		name: "getNode",
+		outputs: [
+			{
+				internalType: "uint256[]",
+				name: "",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
 	{
 		inputs: [
 			{
@@ -31705,7 +31738,7 @@ var abi$2 = [
 								type: "uint256"
 							}
 						],
-						internalType: "structIOnchainCredentialStatusResolver.IdentityStateRoots",
+						internalType: "struct IOnchainCredentialStatusResolver.IdentityStateRoots",
 						name: "issuer",
 						type: "tuple"
 					},
@@ -31752,12 +31785,12 @@ var abi$2 = [
 								type: "uint256"
 							}
 						],
-						internalType: "structIOnchainCredentialStatusResolver.Proof",
+						internalType: "struct IOnchainCredentialStatusResolver.Proof",
 						name: "mtp",
 						type: "tuple"
 					}
 				],
-				internalType: "structIOnchainCredentialStatusResolver.CredentialStatus",
+				internalType: "struct IOnchainCredentialStatusResolver.CredentialStatus",
 				name: "",
 				type: "tuple"
 			}
@@ -31810,7 +31843,7 @@ var abi$2 = [
 								type: "uint256"
 							}
 						],
-						internalType: "structIOnchainCredentialStatusResolver.IdentityStateRoots",
+						internalType: "struct IOnchainCredentialStatusResolver.IdentityStateRoots",
 						name: "issuer",
 						type: "tuple"
 					},
@@ -31857,18 +31890,46 @@ var abi$2 = [
 								type: "uint256"
 							}
 						],
-						internalType: "structIOnchainCredentialStatusResolver.Proof",
+						internalType: "struct IOnchainCredentialStatusResolver.Proof",
 						name: "mtp",
 						type: "tuple"
 					}
 				],
-				internalType: "structIOnchainCredentialStatusResolver.CredentialStatus",
+				internalType: "struct IOnchainCredentialStatusResolver.CredentialStatus",
 				name: "",
 				type: "tuple"
 			}
 		],
 		stateMutability: "view",
 		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256[][]",
+				name: "nodes",
+				type: "uint256[][]"
+			}
+		],
+		name: "saveNodes",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	}
 ];
 
@@ -31887,9 +31948,16 @@ class OnChainRevocationStorage {
      * @param {string} - onhcain contract address
      * @param {string} - rpc url to connect to the blockchain
      */
-    constructor(config, contractAddress) {
-        this.provider = new JsonRpcProvider(config.url);
-        this.onchainContract = new Contract(contractAddress, abi$2, this.provider);
+    constructor(_config, contractAddress, _signer) {
+        this._config = _config;
+        this._signer = _signer;
+        this._provider = new JsonRpcProvider(_config.url);
+        let contract = new Contract(contractAddress, abi$2, this._provider);
+        if (this._signer) {
+            this._signer = this._signer.connect(this._provider);
+            contract = contract.connect(this._signer);
+        }
+        this._contract = contract;
     }
     /**
      * Get revocation status by issuerId, issuerState and nonce from the onchain.
@@ -31897,7 +31965,7 @@ class OnChainRevocationStorage {
      * @returns Promise<RevocationStatus>
      */
     async getRevocationStatusByIdAndState(issuerID, state, nonce) {
-        const response = await this.onchainContract.getRevocationStatusByIdAndState(issuerID, state, nonce);
+        const response = await this._contract.getRevocationStatusByIdAndState(issuerID, state, nonce);
         const issuer = OnChainRevocationStorage.convertIssuerInfo(response.issuer);
         const mtp = OnChainRevocationStorage.convertSmtProofToProof(response.mtp);
         return {
@@ -31911,7 +31979,7 @@ class OnChainRevocationStorage {
      * @returns Promise<RevocationStatus>
      */
     async getRevocationStatus(issuerID, nonce) {
-        const response = await this.onchainContract.getRevocationStatus(issuerID, nonce);
+        const response = await this._contract.getRevocationStatus(issuerID, nonce);
         const issuer = OnChainRevocationStorage.convertIssuerInfo(response.issuer);
         const mtp = OnChainRevocationStorage.convertSmtProofToProof(response.mtp);
         return {
@@ -31919,6 +31987,39 @@ class OnChainRevocationStorage {
             mtp
         };
     }
+    async saveNodes(payload) {
+        if (!this._signer) {
+            throw new Error('No signer provided');
+        }
+        const feeData = await this._provider.getFeeData();
+        const maxFeePerGas = this._config.maxFeePerGas
+            ? BigInt(this._config.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = this._config.maxPriorityFeePerGas
+            ? BigInt(this._config.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const gasLimit = await this._contract.saveNodes.estimateGas(payload);
+        const txData = await this._contract.saveNodes.populateTransaction(payload);
+        const request = {
+            to: txData.to,
+            data: txData.data,
+            gasLimit,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        const tx = await this._signer.sendTransaction(request);
+        return tx.wait().then((txReceipt) => {
+            if (!txReceipt) {
+                throw new Error(`transaction: ${tx.hash} failed to mine`);
+            }
+            const status = txReceipt.status;
+            const txnHash = txReceipt.hash;
+            if (!status) {
+                throw new Error(`transaction: ${txnHash} failed to mine`);
+            }
+            return txReceipt;
+        });
+    }
     static convertIssuerInfo(issuer) {
         const [state, claimsTreeRoot, revocationTreeRoot, rootOfRoots] = issuer.map((i) => Hash$1.fromBigInt(i).hex());
         return {
@@ -32298,12 +32399,12 @@ const QueryOperators = {
 };
 const allOperations = Object.values(QueryOperators);
 const availableTypesOperators = new Map([
-    [XSDNS.Boolean, [QueryOperators.$eq, QueryOperators.$ne]],
+    [XSDNS.Boolean, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$sd]],
     [XSDNS.Integer, allOperations],
     [XSDNS.NonNegativeInteger, allOperations],
     [XSDNS.PositiveInteger, allOperations],
-    [XSDNS.Double, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
-    [XSDNS.String, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
+    [XSDNS.Double, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin, QueryOperators.$sd]],
+    [XSDNS.String, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin, QueryOperators.$sd]],
     [XSDNS.DateTime, allOperations]
 ]);
 /**
@@ -33265,6 +33366,16 @@ const getUserDIDFromCredential = (issuerDID, credential) => {
     }
     return DID.parse(credential.credentialSubject.id);
 };
+const getKMSIdByAuthCredential = (credential) => {
+    if (!credential.type.includes('AuthBJJCredential')) {
+        throw new Error("can't sign with not AuthBJJCredential credential");
+    }
+    const x = credential.credentialSubject['x'];
+    const y = credential.credentialSubject['y'];
+    const pb = new PublicKey([BigInt(x), BigInt(y)]);
+    const kp = keyPath(KmsKeyType.BabyJubJub, pb.hex());
+    return { type: KmsKeyType.BabyJubJub, id: kp };
+};
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
@@ -36998,6 +37109,84 @@ function buildRevocationMessageRequest(from, to, revocationNonce) {
     };
 }
 
+/**
+ * Registry for managing credential status publishers.
+ */
+class CredentialStatusPublisherRegistry {
+    constructor() {
+        this._publishers = new Map();
+    }
+    /**
+     * Registers one or more credential status publishers for a given type.
+     * @param type - The credential status type.
+     * @param publisher - One or more credential status publishers.
+     */
+    register(type, ...publisher) {
+        const publishers = this._publishers.get(type) ?? [];
+        publishers.push(...publisher);
+        this._publishers.set(type, publishers);
+    }
+    /**
+     * Retrieves the credential status publishers for a given type.
+     * @param type - The credential status type.
+     * @returns An array of credential status publishers or undefined if none are registered for the given type.
+     */
+    get(type) {
+        return this._publishers.get(type);
+    }
+}
+/**
+ * Implementation of the ICredentialStatusPublisher interface for publishing on-chain credential status.
+ */
+class Iden3OnchainSmtCredentialStatusPublisher {
+    constructor(_storage) {
+        this._storage = _storage;
+    }
+    /**
+     * Publishes the credential status to the blockchain.
+     * @param params - The parameters for publishing the credential status.
+     */
+    async publish(params) {
+        if (![CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023].includes(params.credentialStatusType)) {
+            throw new Error(`On-chain publishing is not supported for credential status type ${params.credentialStatusType}`);
+        }
+        const nodesBigInts = params.nodes.map((n) => n.children.map((c) => c.bigInt()));
+        const txPromise = this._storage.saveNodes(nodesBigInts);
+        if (params.onChain?.txCallback) {
+            const cb = params.onChain?.txCallback;
+            txPromise.then((receipt) => cb(receipt));
+            return;
+        }
+        await txPromise;
+    }
+}
+/**
+ * Implementation of the ICredentialStatusPublisher interface for publishing off-chain credential status.
+ */
+class Iden3SmtRhsCredentialStatusPublisher {
+    /**
+     * Publishes the credential status to a specified node URL.
+     * @param params - The parameters for publishing the credential status.
+     * @param params.nodes - The proof nodes to be published.
+     * @param params.rhsUrl - The URL of the node to publish the credential status to.
+     * @returns A promise that resolves when the credential status is successfully published.
+     * @throws An error if the publishing fails.
+     */
+    async publish(params) {
+        if (![CredentialStatusType.Iden3ReverseSparseMerkleTreeProof].includes(params.credentialStatusType)) {
+            throw new Error(`On-chain publishing is not supported for credential status type ${params.credentialStatusType}`);
+        }
+        const nodesJSON = params.nodes.map((n) => n.toJSON());
+        const resp = await fetch(params.rhsUrl + '/node', {
+            method: 'post',
+            body: JSON.stringify(nodesJSON)
+        });
+        if (resp.status !== 200) {
+            throw new Error(`Failed to publish credential status. Status: ${resp.status}`);
+        }
+    }
+}
+
 // ErrAllClaimsRevoked all claims are revoked.
 const ErrAllClaimsRevoked = 'all claims are revoked';
 /**
@@ -37050,7 +37239,7 @@ class CredentialWallet {
                 id: request.credentialSchema,
                 type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
             };
-            cr.credentialStatus = this.buildCredentialStatus(request);
+            cr.credentialStatus = this.buildCredentialStatus(request, issuer);
             return cr;
         };
         // if no credential status resolvers are provided
@@ -37116,7 +37305,7 @@ class CredentialWallet {
      * @param {CredentialRequest} request
      * @returns `CredentialStatus`
      */
-    buildCredentialStatus(request) {
+    buildCredentialStatus(request, issuer) {
         const credentialStatus = {
             id: request.revocationOpts.id,
             type: request.revocationOpts.type,
@@ -37135,6 +37324,23 @@ class CredentialWallet {
                         ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
                         : `${credentialStatus.id.replace(/\/$/, '')}`
                 };
+            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                const issuerId = DID.idFromDID(issuer);
+                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
+                const searchParams = [
+                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
+                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
+                    ['state', request.revocationOpts.issuerState || '']
+                ]
+                    .filter(([, value]) => Boolean(value))
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join('&');
+                return {
+                    ...credentialStatus,
+                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
+                    id: `${issuer.string()}/credentialStatus?${searchParams}`
+                };
+            }
             default:
                 return credentialStatus;
         }
@@ -37207,6 +37413,7 @@ class CredentialWallet {
  * A reverse hash service (RHS) is a centralized or decentralized service for storing publicly available data about identity.
  * Such data are identity state and state of revocation tree and roots tree root tree.
  *
+ * @deprecated Use `pushHashesToReverseHashService` instead.
  * @param {Hash} state - current state of identity
  * @param {TreesModel} trees - current trees of identity (claims, revocation, rootOfRoots )
  * @param {string} rhsUrl - URL of service
@@ -37214,6 +37421,23 @@ class CredentialWallet {
  * @returns void
  */
 async function pushHashesToRHS(state, trees, rhsUrl, revokedNonces) {
+    const nodes = await getNodesRepresentation(revokedNonces, trees, state);
+    const publisher = new Iden3SmtRhsCredentialStatusPublisher();
+    await publisher.publish({
+        nodes,
+        credentialStatusType: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+        rhsUrl: rhsUrl
+    });
+}
+/**
+ * Retrieves the representation of nodes for generating a proof.
+ *
+ * @param revokedNonces - An array of revoked nonces.
+ * @param trees - The TreesModel object containing the necessary trees.
+ * @param state - The hash of the state.
+ * @returns A Promise that resolves to an array of ProofNode objects.
+ */
+async function getNodesRepresentation(revokedNonces, trees, state) {
     const nb = new NodesBuilder();
     if (revokedNonces) {
         await addRevocationNode(nb, trees, revokedNonces);
@@ -37227,15 +37451,7 @@ async function pushHashesToRHS(state, trees, rhsUrl, revokedNonces) {
             await trees.rootsTree.root()
         ]));
     }
-    if (nb.nodes.length > 0) {
-        await saveNodes(nb.nodes, rhsUrl);
-    }
-}
-async function saveNodes(nodes, nodeUrl) {
-    const nodesJSON = nodes.map((n) => n.toJSON());
-    const resp = await fetch(nodeUrl + '/node', { method: 'post', body: JSON.stringify(nodesJSON) });
-    const status = resp.status;
-    return status === 200;
+    return nb.nodes;
 }
 async function addRoRNode(nb, trees) {
     const currentRootsTree = trees.rootsTree;
@@ -37261,8 +37477,8 @@ class NodesBuilder {
     }
     async addKey(tree, nodeKey) {
         const { value: nodeValue, siblings } = await tree.get(nodeKey);
-        const nodeKeyHash = newHashFromBigInt(nodeKey);
-        const nodeValueHash = newHashFromBigInt(nodeValue);
+        const nodeKeyHash = Hash$1.fromBigInt(nodeKey);
+        const nodeValueHash = Hash$1.fromBigInt(nodeValue);
         const node = new NodeLeaf(nodeKeyHash, nodeValueHash);
         const newNodes = await buildNodesUp(siblings, node);
         for (const n of newNodes) {
@@ -37292,7 +37508,7 @@ async function buildNodesUp(siblings, node) {
         nodes[index] = new ProofNode();
     }
     nodes[sl].hash = prevHash;
-    const hashOfOne = newHashFromBigInt(BigInt(1));
+    const hashOfOne = Hash$1.fromBigInt(BigInt(1));
     nodes[sl].children = [node.entry[0], node.entry[1], hashOfOne];
     const pathKey = node.entry[0];
     for (let i = sl - 1; i >= 0; i--) {
@@ -37306,7 +37522,7 @@ async function buildNodesUp(siblings, node) {
             nodes[i].children[0] = prevHash;
             nodes[i].children[1] = siblings[i];
         }
-        nodes[i].hash = await hashElems([nodes[i].children[0].bigInt(), nodes[i].children[1].bigInt()]);
+        nodes[i].hash = hashElems([nodes[i].children[0].bigInt(), nodes[i].children[1].bigInt()]);
         prevHash = nodes[i].hash;
     }
     return nodes;
@@ -59571,466 +59787,6 @@ const cacheLoader = (opts) => {
     };
 };
 
-/**
- * Type of MerkleTree
- *
- * @enum {number}
- */
-var MerkleTreeType;
-(function (MerkleTreeType) {
-    // Claims is merkle tree type for claims tree
-    MerkleTreeType[MerkleTreeType["Claims"] = 0] = "Claims";
-    // Revocations is merkle tree type for revocations tree
-    MerkleTreeType[MerkleTreeType["Revocations"] = 1] = "Revocations";
-    // Roots is merkle tree type for roots tree
-    MerkleTreeType[MerkleTreeType["Roots"] = 2] = "Roots";
-})(MerkleTreeType || (MerkleTreeType = {}));
-
-/**
- * @public
- * Wallet instance to manage the digital identity based on iden3 protocol
- * allows to: create identity/profile, sign payloads (bigint / bytes), generate keys,
- * generate Merkle tree proofs of inclusion / non-inclusion to Merkle trees, issue credentials with a BJJSignature and Iden3SparseMerkleTree Proofs,
- * revoke credentials, add credentials to Merkle trees, push states to reverse hash service
- *
- *
- * @class IdentityWallet - class
- * @implements implements IIdentityWallet interface
- */
-class IdentityWallet {
-    /**
-     * Constructs a new instance of the `IdentityWallet` class
-     *
-     * @param {KMS} _kms - Key Management System that allows signing data with BJJ key
-     * @param {IDataStorage} _storage - data storage to access credential / identity / Merkle tree data
-     * @param {ICredentialWallet} _credentialWallet - credential wallet instance to quickly access credential CRUD functionality
-     * @public
-     */
-    constructor(_kms, _storage, _credentialWallet) {
-        this._kms = _kms;
-        this._storage = _storage;
-        this._credentialWallet = _credentialWallet;
-    }
-    /**
-     * {@inheritDoc IIdentityWallet.createIdentity}
-     */
-    async createIdentity(opts) {
-        const tmpIdentifier = opts.seed ? v5$1(Hex.encode(sha256$3(opts.seed)), nil) : v4();
-        opts.method = opts.method ?? DidMethod.Iden3;
-        opts.blockchain = opts.blockchain ?? Blockchain.Polygon;
-        opts.networkId = opts.networkId ?? NetworkId.Mumbai;
-        await this._storage.mt.createIdentityMerkleTrees(tmpIdentifier);
-        opts.seed = opts.seed ?? getRandomBytes(32);
-        const keyId = await this._kms.createKeyFromSeed(KmsKeyType.BabyJubJub, opts.seed);
-        const pubKeyHex = await this._kms.publicKey(keyId);
-        const pubKey = PublicKey.newFromHex(pubKeyHex);
-        const schemaHash = SchemaHash.authSchemaHash;
-        const authClaim = Claim.newClaim(schemaHash, ClaimOptions.withIndexDataInts(pubKey.p[0], pubKey.p[1]), ClaimOptions.withRevocationNonce(BigInt(0)));
-        const revNonce = opts.revocationOpts.nonce ?? 0;
-        authClaim.setRevocationNonce(BigInt(revNonce));
-        await this._storage.mt.addToMerkleTree(tmpIdentifier, MerkleTreeType.Claims, authClaim.hiHv().hi, authClaim.hiHv().hv);
-        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(tmpIdentifier, MerkleTreeType.Claims);
-        const currentState = hashElems([
-            (await claimsTree.root()).bigInt(),
-            ZERO_HASH.bigInt(),
-            ZERO_HASH.bigInt()
-        ]);
-        const didType = buildDIDType(opts.method, opts.blockchain, opts.networkId);
-        const identifier = Id.idGenesisFromIdenState(didType, currentState.bigInt());
-        const did = DID.parseFromId(identifier);
-        await this._storage.mt.bindMerkleTreeToNewIdentifier(tmpIdentifier, did.string());
-        const schema = JSON.parse(VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON);
-        const authData = authClaim.getExpirationDate();
-        const expiration = authData ? getUnixTimestamp(authData) : 0;
-        const request = {
-            credentialSchema: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON_URL,
-            type: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_TYPE,
-            credentialSubject: {
-                x: pubKey.p[0].toString(),
-                y: pubKey.p[1].toString()
-            },
-            subjectPosition: subjectPositionIndex(authClaim.getIdPosition()),
-            version: 0,
-            expiration,
-            revocationOpts: {
-                nonce: revNonce,
-                id: opts.revocationOpts.id.replace(/\/$/, ''),
-                type: opts.revocationOpts.type,
-                issuerState: currentState.hex()
-            }
-        };
-        let credential = new W3CCredential();
-        try {
-            credential = this._credentialWallet.createCredential(did, request, schema);
-        }
-        catch (e) {
-            throw new Error(`Error create w3c credential ${e.message}`);
-        }
-        const index = authClaim.hIndex();
-        const ctr = await claimsTree.root();
-        const { proof } = await claimsTree.generateProof(index, ctr);
-        const mtpProof = new Iden3SparseMerkleTreeProof({
-            mtp: proof,
-            issuerData: {
-                id: did,
-                state: {
-                    rootOfRoots: ZERO_HASH,
-                    revocationTreeRoot: ZERO_HASH,
-                    claimsTreeRoot: ctr,
-                    value: currentState
-                }
-            },
-            coreClaim: authClaim
-        });
-        credential.proof = [mtpProof];
-        if (opts.revocationOpts.type === CredentialStatusType.Iden3ReverseSparseMerkleTreeProof) {
-            await this.publishStateToRHS(did, opts.revocationOpts.id);
-        }
-        await this._storage.identity.saveIdentity({
-            did: did.string(),
-            state: currentState,
-            isStatePublished: false,
-            isStateGenesis: true
-        });
-        await this._credentialWallet.save(credential);
-        return {
-            did,
-            credential
-        };
-    }
-    /** {@inheritDoc IIdentityWallet.getGenesisDIDMetadata} */
-    async getGenesisDIDMetadata(did) {
-        // check if it is a genesis identity
-        const identity = await this._storage.identity.getIdentity(did.string());
-        if (identity) {
-            return { nonce: 0, genesisDID: DID.parse(identity.did) };
-        }
-        const profile = await this._storage.identity.getProfileById(did.string());
-        if (!profile) {
-            throw new Error('profile or identity not found');
-        }
-        return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
-    }
-    /** {@inheritDoc IIdentityWallet.createProfile} */
-    async createProfile(did, nonce, verifier) {
-        const profileDID = generateProfileDID(did, nonce);
-        const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
-        const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
-        if (existingProfile) {
-            throw new Error('profile with given nonce or verifier already exists');
-        }
-        await this._storage.identity.saveProfile({
-            id: profileDID.string(),
-            nonce,
-            genesisIdentifier: did.string(),
-            verifier
-        });
-        return profileDID;
-    }
-    /**
-     *
-     * gets profile identity by genesis identifiers
-     *
-     * @param {string} genesisIdentifier - genesis identifier from which profile has been derived
-     * @returns `{Promise<Profile[]>}`
-     */
-    async getProfilesByDID(did) {
-        return this._storage.identity.getProfilesByGenesisIdentifier(did.string());
-    }
-    /** {@inheritDoc IIdentityWallet.generateKey} */
-    async generateKey(keyType) {
-        const key = await this._kms.createKeyFromSeed(keyType, getRandomBytes(32));
-        return key;
-    }
-    async getProfileByVerifier(verifier) {
-        return this._storage.identity.getProfileByVerifier(verifier);
-    }
-    /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
-    async getDIDTreeModel(did) {
-        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Claims);
-        const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Revocations);
-        const rootsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Roots);
-        const state = await hashElems([
-            (await claimsTree.root()).bigInt(),
-            (await revocationTree.root()).bigInt(),
-            (await rootsTree.root()).bigInt()
-        ]);
-        return {
-            state,
-            claimsTree,
-            revocationTree,
-            rootsTree
-        };
-    }
-    /** {@inheritDoc IIdentityWallet.generateClaimMtp} */
-    async generateCredentialMtp(did, credential, treeState) {
-        const coreClaim = await this.getCoreClaimFromCredential(credential);
-        // todo: Parser.parseClaim
-        const treesModel = await this.getDIDTreeModel(did);
-        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Claims);
-        const claimsRoot = await treesModel.claimsTree.root();
-        const rootOfRoots = await treesModel.rootsTree.root();
-        const revocationRoot = await treesModel.revocationTree.root();
-        const { proof } = await claimsTree.generateProof(coreClaim.hIndex(), treeState ? treeState.claimsRoot : claimsRoot);
-        return {
-            proof,
-            treeState: treeState ?? {
-                state: treesModel.state,
-                claimsRoot,
-                rootOfRoots,
-                revocationRoot
-            }
-        };
-    }
-    /** {@inheritDoc IIdentityWallet.generateNonRevocationMtp} */
-    async generateNonRevocationMtp(did, credential, treeState) {
-        const coreClaim = await this.getCoreClaimFromCredential(credential);
-        const revNonce = coreClaim.getRevocationNonce();
-        const treesModel = await this.getDIDTreeModel(did);
-        const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Revocations);
-        const claimsRoot = await treesModel.claimsTree.root();
-        const rootOfRoots = await treesModel.rootsTree.root();
-        const revocationRoot = await treesModel.revocationTree.root();
-        const { proof } = await revocationTree.generateProof(revNonce, treeState ? treeState.revocationRoot : revocationRoot);
-        return {
-            proof,
-            treeState: treeState ?? {
-                state: treesModel.state,
-                claimsRoot,
-                rootOfRoots,
-                revocationRoot
-            }
-        };
-    }
-    /** {@inheritDoc IIdentityWallet.sign} */
-    async sign(message, credential) {
-        const keyKMSId = this.getKMSIdByAuthCredential(credential);
-        const payload = poseidon.hashBytes(message);
-        const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(payload));
-        return Signature$5.newFromCompressed(signature);
-    }
-    /** {@inheritDoc IIdentityWallet.signChallenge} */
-    async signChallenge(challenge, credential) {
-        const keyKMSId = this.getKMSIdByAuthCredential(credential);
-        const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(challenge));
-        return Signature$5.newFromCompressed(signature);
-    }
-    /** {@inheritDoc IIdentityWallet.issueCredential} */
-    async issueCredential(issuerDID, req, opts) {
-        req.revocationOpts.id = req.revocationOpts.id.replace(/\/$/, '');
-        let schema;
-        const loader = opts?.documentLoader ?? cacheLoader(opts);
-        try {
-            schema = (await loader(req.credentialSchema)).document;
-        }
-        catch (e) {
-            throw new Error(`can't load credential schema ${req.credentialSchema}`);
-        }
-        const jsonSchema = schema;
-        let credential = new W3CCredential();
-        const issuerRoots = await this.getDIDTreeModel(issuerDID);
-        req.revocationOpts.issuerState = issuerRoots.state.hex();
-        req.revocationOpts.nonce =
-            typeof req.revocationOpts.nonce === 'number'
-                ? req.revocationOpts.nonce
-                : Math.round(Math.random() * 10000);
-        req.subjectPosition = req.subjectPosition ?? SubjectPosition.Index;
-        try {
-            credential = this._credentialWallet.createCredential(issuerDID, req, jsonSchema);
-            const encodedCred = byteEncoder.encode(JSON.stringify(credential));
-            const encodedSchema = byteEncoder.encode(JSON.stringify(schema));
-            await new JsonSchemaValidator().validate(encodedCred, encodedSchema);
-        }
-        catch (e) {
-            throw new Error(`Error create w3c credential ${e.message}`);
-        }
-        const issuerAuthBJJCredential = await this._credentialWallet.getAuthBJJCredential(issuerDID);
-        const coreClaimOpts = {
-            revNonce: req.revocationOpts.nonce,
-            subjectPosition: req.subjectPosition,
-            merklizedRootPosition: req.merklizedRootPosition ?? MerklizedRootPosition.None,
-            updatable: false,
-            version: 0,
-            merklizeOpts: { ...opts, documentLoader: loader }
-        };
-        const coreClaim = await Parser.parseClaim(credential, coreClaimOpts);
-        const { hi, hv } = coreClaim.hiHv();
-        const coreClaimHash = poseidon.hash([hi, hv]);
-        const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
-        if (!issuerAuthBJJCredential.proof) {
-            throw new Error('issuer auth credential must have proof');
-        }
-        const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
-        if (!mtpAuthBJJProof) {
-            throw new Error('mtp is required for auth bjj key to issue new credentials');
-        }
-        const sigProof = new BJJSignatureProof2021({
-            issuerData: {
-                id: issuerDID,
-                state: mtpAuthBJJProof.issuerData.state,
-                authCoreClaim: mtpAuthBJJProof.coreClaim,
-                mtp: mtpAuthBJJProof.mtp,
-                credentialStatus: issuerAuthBJJCredential.credentialStatus
-            },
-            coreClaim,
-            signature
-        });
-        credential.proof = [sigProof];
-        return credential;
-    }
-    /** {@inheritDoc IIdentityWallet.revokeCredential} */
-    async revokeCredential(issuerDID, credential) {
-        const issuerTree = await this.getDIDTreeModel(issuerDID);
-        const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
-        if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in the signature proof');
-        }
-        const nonce = coreClaim.getRevocationNonce();
-        await issuerTree.revocationTree.add(nonce, BigInt(0));
-        return Number(BigInt.asUintN(64, nonce));
-    }
-    /** {@inheritDoc IIdentityWallet.addCredentialsToMerkleTree} */
-    async addCredentialsToMerkleTree(credentials, issuerDID) {
-        const oldIssuerTree = await this.getDIDTreeModel(issuerDID);
-        let claimsRoot = await oldIssuerTree.claimsTree.root();
-        let rootOfRoots = await oldIssuerTree.rootsTree.root();
-        let revocationRoot = await oldIssuerTree.revocationTree.root();
-        const oldTreeState = {
-            state: oldIssuerTree.state,
-            claimsRoot,
-            revocationRoot,
-            rootOfRoots
-        };
-        for (let index = 0; index < credentials.length; index++) {
-            const credential = credentials[index];
-            // credential must have a bjj signature proof
-            const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
-            if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
-            }
-            await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
-        }
-        const newIssuerTreeState = await this.getDIDTreeModel(issuerDID);
-        const claimTreeRoot = await newIssuerTreeState.claimsTree.root();
-        await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Roots, claimTreeRoot.bigInt(), BigInt(0));
-        const newIssuerTreeStateWithROR = await this.getDIDTreeModel(issuerDID);
-        claimsRoot = await newIssuerTreeStateWithROR.claimsTree.root();
-        rootOfRoots = await newIssuerTreeStateWithROR.rootsTree.root();
-        revocationRoot = await newIssuerTreeStateWithROR.revocationTree.root();
-        return {
-            credentials,
-            newTreeState: {
-                state: newIssuerTreeStateWithROR.state,
-                claimsRoot,
-                rootOfRoots,
-                revocationRoot
-            },
-            oldTreeState: oldTreeState
-        };
-    }
-    /** {@inheritDoc IIdentityWallet.generateIden3SparseMerkleTreeProof} */
-    // treeState -  optional, if it is not passed proof of claim inclusion will be generated on the latest state in the tree.
-    async generateIden3SparseMerkleTreeProof(issuerDID, credentials, txId, blockNumber, blockTimestamp, treeState) {
-        for (let index = 0; index < credentials.length; index++) {
-            const credential = credentials[index];
-            const mtpWithProof = await this.generateCredentialMtp(issuerDID, credential, treeState);
-            // TODO: return coreClaim from generateCredentialMtp and use it below
-            // credential must have a bjj signature proof
-            const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
-            if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
-            }
-            const mtpProof = new Iden3SparseMerkleTreeProof({
-                mtp: mtpWithProof.proof,
-                issuerData: {
-                    id: issuerDID,
-                    state: {
-                        claimsTreeRoot: mtpWithProof.treeState.claimsRoot,
-                        revocationTreeRoot: mtpWithProof.treeState.revocationRoot,
-                        rootOfRoots: mtpWithProof.treeState.rootOfRoots,
-                        value: mtpWithProof.treeState.state,
-                        txId,
-                        blockNumber,
-                        blockTimestamp
-                    }
-                },
-                coreClaim
-            });
-            if (Array.isArray(credentials[index].proof)) {
-                credentials[index].proof.push(mtpProof);
-            }
-            else {
-                credentials[index].proof = [credentials[index].proof, mtpProof];
-            }
-        }
-        return credentials;
-    }
-    /** {@inheritDoc IIdentityWallet.publishSpecificStateToRHS} */
-    async publishSpecificStateToRHS(treeModel, rhsURL, revokedNonces) {
-        await pushHashesToRHS(treeModel.state, treeModel, rhsURL, revokedNonces);
-    }
-    /** {@inheritDoc IIdentityWallet.publishStateToRHS} */
-    async publishStateToRHS(issuerDID, rhsURL, revokedNonces) {
-        const treeState = await this.getDIDTreeModel(issuerDID);
-        await pushHashesToRHS(treeState.state, {
-            revocationTree: treeState.revocationTree,
-            claimsTree: treeState.claimsTree,
-            state: treeState.state,
-            rootsTree: treeState.rootsTree
-        }, rhsURL, revokedNonces);
-    }
-    getKMSIdByAuthCredential(credential) {
-        if (credential.type.indexOf('AuthBJJCredential') === -1) {
-            throw new Error("can't sign with not AuthBJJCredential credential");
-        }
-        const x = credential.credentialSubject['x'];
-        const y = credential.credentialSubject['y'];
-        const pb = new PublicKey([BigInt(x), BigInt(y)]);
-        const kp = keyPath(KmsKeyType.BabyJubJub, pb.hex());
-        return { type: KmsKeyType.BabyJubJub, id: kp };
-    }
-    async getCoreClaimFromCredential(credential) {
-        const coreClaimFromSigProof = credential.getCoreClaimFromProof(ProofType.BJJSignature);
-        const coreClaimFromMtpProof = credential.getCoreClaimFromProof(ProofType.Iden3SparseMerkleTreeProof);
-        if (coreClaimFromMtpProof &&
-            coreClaimFromSigProof &&
-            coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-            throw new Error('core claim representations is set in both proofs but they are not equal');
-        }
-        if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-            throw new Error('core claim is not set in credential proofs');
-        }
-        //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
-        const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
-        return coreClaim;
-    }
-    async findOwnedCredentialsByDID(did, query) {
-        const credentials = await this._credentialWallet.findByQuery(query);
-        if (!credentials.length) {
-            throw new Error(`no credential satisfied query`);
-        }
-        const { genesisDID } = await this.getGenesisDIDMetadata(did);
-        const profiles = await this.getProfilesByDID(genesisDID);
-        return credentials.filter((cred) => {
-            const credentialSubjectId = cred.credentialSubject['id']; // credential subject
-            return (credentialSubjectId == genesisDID.string() ||
-                profiles.some((p) => {
-                    return p.id === credentialSubjectId;
-                }));
-        });
-    }
-    /** {@inheritDoc IIdentityWallet.updateIdentityState} */
-    async updateIdentityState(issuerDID, published, treeState) {
-        const latestTreeState = await this.getDIDTreeModel(issuerDID);
-        await this._storage.identity.saveIdentity({
-            did: issuerDID.string(),
-            state: treeState?.state ?? latestTreeState.state,
-            isStatePublished: published,
-            isStateGenesis: false
-        });
-    }
-}
-
 var abi = [
 	{
 		anonymous: false,
@@ -60397,6 +60153,21 @@ class OnChainZKPVerifier {
     }
 }
 
+/**
+ * Type of MerkleTree
+ *
+ * @enum {number}
+ */
+var MerkleTreeType;
+(function (MerkleTreeType) {
+    // Claims is merkle tree type for claims tree
+    MerkleTreeType[MerkleTreeType["Claims"] = 0] = "Claims";
+    // Revocations is merkle tree type for revocations tree
+    MerkleTreeType[MerkleTreeType["Revocations"] = 1] = "Revocations";
+    // Roots is merkle tree type for roots tree
+    MerkleTreeType[MerkleTreeType["Roots"] = 2] = "Roots";
+})(MerkleTreeType || (MerkleTreeType = {}));
+
 /**
  * search errors
  *
@@ -61286,6 +61057,482 @@ class FSCircuitStorage {
     }
 }
 
+/**
+ * @public
+ * Wallet instance to manage the digital identity based on iden3 protocol
+ * allows to: create identity/profile, sign payloads (bigint / bytes), generate keys,
+ * generate Merkle tree proofs of inclusion / non-inclusion to Merkle trees, issue credentials with a BJJSignature and Iden3SparseMerkleTree Proofs,
+ * revoke credentials, add credentials to Merkle trees, push states to reverse hash service
+ *
+ *
+ * @class IdentityWallet - class
+ * @implements implements IIdentityWallet interface
+ */
+class IdentityWallet {
+    /**
+     * Constructs a new instance of the `IdentityWallet` class
+     *
+     * @param {KMS} _kms - Key Management System that allows signing data with BJJ key
+     * @param {IDataStorage} _storage - data storage to access credential / identity / Merkle tree data
+     * @param {ICredentialWallet} _credentialWallet - credential wallet instance to quickly access credential CRUD functionality
+     * @public
+     */
+    constructor(_kms, _storage, _credentialWallet, _opts) {
+        this._kms = _kms;
+        this._storage = _storage;
+        this._credentialWallet = _credentialWallet;
+        this._opts = _opts;
+        if (!_opts?.credentialStatusPublisherRegistry) {
+            this._credentialStatusPublisherRegistry = new CredentialStatusPublisherRegistry();
+            this._credentialStatusPublisherRegistry.register(CredentialStatusType.Iden3ReverseSparseMerkleTreeProof, new Iden3SmtRhsCredentialStatusPublisher());
+        }
+        else {
+            this._credentialStatusPublisherRegistry = this._opts
+                ?.credentialStatusPublisherRegistry;
+        }
+    }
+    /**
+     * {@inheritDoc IIdentityWallet.createIdentity}
+     */
+    async createIdentity(opts) {
+        const tmpIdentifier = opts.seed ? v5$1(Hex.encode(sha256$3(opts.seed)), nil) : v4();
+        opts.method = opts.method ?? DidMethod.Iden3;
+        opts.blockchain = opts.blockchain ?? Blockchain.Polygon;
+        opts.networkId = opts.networkId ?? NetworkId.Mumbai;
+        await this._storage.mt.createIdentityMerkleTrees(tmpIdentifier);
+        opts.seed = opts.seed ?? getRandomBytes(32);
+        const keyId = await this._kms.createKeyFromSeed(KmsKeyType.BabyJubJub, opts.seed);
+        const pubKeyHex = await this._kms.publicKey(keyId);
+        const pubKey = PublicKey.newFromHex(pubKeyHex);
+        const schemaHash = SchemaHash.authSchemaHash;
+        const authClaim = Claim.newClaim(schemaHash, ClaimOptions.withIndexDataInts(pubKey.p[0], pubKey.p[1]), ClaimOptions.withRevocationNonce(BigInt(0)));
+        const revNonce = opts.revocationOpts.nonce ?? 0;
+        authClaim.setRevocationNonce(BigInt(revNonce));
+        await this._storage.mt.addToMerkleTree(tmpIdentifier, MerkleTreeType.Claims, authClaim.hiHv().hi, authClaim.hiHv().hv);
+        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(tmpIdentifier, MerkleTreeType.Claims);
+        const currentState = hashElems([
+            (await claimsTree.root()).bigInt(),
+            ZERO_HASH.bigInt(),
+            ZERO_HASH.bigInt()
+        ]);
+        const didType = buildDIDType(opts.method, opts.blockchain, opts.networkId);
+        const identifier = Id.idGenesisFromIdenState(didType, currentState.bigInt());
+        const did = DID.parseFromId(identifier);
+        await this._storage.mt.bindMerkleTreeToNewIdentifier(tmpIdentifier, did.string());
+        const schema = JSON.parse(VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON);
+        const authData = authClaim.getExpirationDate();
+        const expiration = authData ? getUnixTimestamp(authData) : 0;
+        const request = {
+            credentialSchema: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON_URL,
+            type: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_TYPE,
+            credentialSubject: {
+                x: pubKey.p[0].toString(),
+                y: pubKey.p[1].toString()
+            },
+            subjectPosition: subjectPositionIndex(authClaim.getIdPosition()),
+            version: 0,
+            expiration,
+            revocationOpts: {
+                nonce: revNonce,
+                id: opts.revocationOpts.id.replace(/\/$/, ''),
+                type: opts.revocationOpts.type,
+                issuerState: currentState.hex()
+            }
+        };
+        let credential = new W3CCredential();
+        try {
+            credential = this._credentialWallet.createCredential(did, request, schema);
+        }
+        catch (e) {
+            throw new Error(`Error create w3c credential ${e.message}`);
+        }
+        const index = authClaim.hIndex();
+        const ctr = await claimsTree.root();
+        const { proof } = await claimsTree.generateProof(index, ctr);
+        const mtpProof = new Iden3SparseMerkleTreeProof({
+            mtp: proof,
+            issuerData: {
+                id: did,
+                state: {
+                    rootOfRoots: ZERO_HASH,
+                    revocationTreeRoot: ZERO_HASH,
+                    claimsTreeRoot: ctr,
+                    value: currentState
+                }
+            },
+            coreClaim: authClaim
+        });
+        credential.proof = [mtpProof];
+        await this.publishRevocationInfoByCredentialStatusType(did, opts.revocationOpts.type, {
+            rhsUrl: opts.revocationOpts.id,
+            onChain: opts.revocationOpts.onChain
+        });
+        await this._storage.identity.saveIdentity({
+            did: did.string(),
+            state: currentState,
+            isStatePublished: false,
+            isStateGenesis: true
+        });
+        await this._credentialWallet.save(credential);
+        return {
+            did,
+            credential
+        };
+    }
+    /** {@inheritDoc IIdentityWallet.getGenesisDIDMetadata} */
+    async getGenesisDIDMetadata(did) {
+        // check if it is a genesis identity
+        const identity = await this._storage.identity.getIdentity(did.string());
+        if (identity) {
+            return { nonce: 0, genesisDID: DID.parse(identity.did) };
+        }
+        const profile = await this._storage.identity.getProfileById(did.string());
+        if (!profile) {
+            throw new Error('profile or identity not found');
+        }
+        return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
+    }
+    /** {@inheritDoc IIdentityWallet.createProfile} */
+    async createProfile(did, nonce, verifier) {
+        const profileDID = generateProfileDID(did, nonce);
+        const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
+        const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
+        if (existingProfile) {
+            throw new Error('profile with given nonce or verifier already exists');
+        }
+        await this._storage.identity.saveProfile({
+            id: profileDID.string(),
+            nonce,
+            genesisIdentifier: did.string(),
+            verifier
+        });
+        return profileDID;
+    }
+    /**
+     *
+     * gets profile identity by genesis identifiers
+     *
+     * @param {string} genesisIdentifier - genesis identifier from which profile has been derived
+     * @returns `{Promise<Profile[]>}`
+     */
+    async getProfilesByDID(did) {
+        return this._storage.identity.getProfilesByGenesisIdentifier(did.string());
+    }
+    /** {@inheritDoc IIdentityWallet.generateKey} */
+    async generateKey(keyType) {
+        const key = await this._kms.createKeyFromSeed(keyType, getRandomBytes(32));
+        return key;
+    }
+    async getProfileByVerifier(verifier) {
+        return this._storage.identity.getProfileByVerifier(verifier);
+    }
+    /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
+    async getDIDTreeModel(did) {
+        const didStr = did.string();
+        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(didStr, MerkleTreeType.Claims);
+        const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(didStr, MerkleTreeType.Revocations);
+        const rootsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(didStr, MerkleTreeType.Roots);
+        const state = hashElems([
+            (await claimsTree.root()).bigInt(),
+            (await revocationTree.root()).bigInt(),
+            (await rootsTree.root()).bigInt()
+        ]);
+        return {
+            state,
+            claimsTree,
+            revocationTree,
+            rootsTree
+        };
+    }
+    /** {@inheritDoc IIdentityWallet.generateClaimMtp} */
+    async generateCredentialMtp(did, credential, treeState) {
+        const coreClaim = await this.getCoreClaimFromCredential(credential);
+        // todo: Parser.parseClaim
+        const treesModel = await this.getDIDTreeModel(did);
+        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Claims);
+        const claimsRoot = await treesModel.claimsTree.root();
+        const rootOfRoots = await treesModel.rootsTree.root();
+        const revocationRoot = await treesModel.revocationTree.root();
+        const { proof } = await claimsTree.generateProof(coreClaim.hIndex(), treeState ? treeState.claimsRoot : claimsRoot);
+        return {
+            proof,
+            treeState: treeState ?? {
+                state: treesModel.state,
+                claimsRoot,
+                rootOfRoots,
+                revocationRoot
+            }
+        };
+    }
+    /** {@inheritDoc IIdentityWallet.generateNonRevocationMtp} */
+    async generateNonRevocationMtp(did, credential, treeState) {
+        const coreClaim = await this.getCoreClaimFromCredential(credential);
+        const revNonce = coreClaim.getRevocationNonce();
+        const treesModel = await this.getDIDTreeModel(did);
+        const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Revocations);
+        const claimsRoot = await treesModel.claimsTree.root();
+        const rootOfRoots = await treesModel.rootsTree.root();
+        const revocationRoot = await treesModel.revocationTree.root();
+        const { proof } = await revocationTree.generateProof(revNonce, treeState ? treeState.revocationRoot : revocationRoot);
+        return {
+            proof,
+            treeState: treeState ?? {
+                state: treesModel.state,
+                claimsRoot,
+                rootOfRoots,
+                revocationRoot
+            }
+        };
+    }
+    /** {@inheritDoc IIdentityWallet.sign} */
+    async sign(message, credential) {
+        const keyKMSId = getKMSIdByAuthCredential(credential);
+        const payload = poseidon.hashBytes(message);
+        const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(payload));
+        return Signature$5.newFromCompressed(signature);
+    }
+    /** {@inheritDoc IIdentityWallet.signChallenge} */
+    async signChallenge(challenge, credential) {
+        const keyKMSId = getKMSIdByAuthCredential(credential);
+        const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(challenge));
+        return Signature$5.newFromCompressed(signature);
+    }
+    /** {@inheritDoc IIdentityWallet.issueCredential} */
+    async issueCredential(issuerDID, req, opts) {
+        req.revocationOpts.id = req.revocationOpts.id.replace(/\/$/, '');
+        let schema;
+        const loader = opts?.documentLoader ?? cacheLoader(opts);
+        try {
+            schema = (await loader(req.credentialSchema)).document;
+        }
+        catch (e) {
+            throw new Error(`can't load credential schema ${req.credentialSchema}`);
+        }
+        const jsonSchema = schema;
+        let credential = new W3CCredential();
+        const issuerRoots = await this.getDIDTreeModel(issuerDID);
+        req.revocationOpts.issuerState = issuerRoots.state.hex();
+        req.revocationOpts.nonce =
+            typeof req.revocationOpts.nonce === 'number'
+                ? req.revocationOpts.nonce
+                : Math.round(Math.random() * 10000);
+        req.subjectPosition = req.subjectPosition ?? SubjectPosition.Index;
+        try {
+            credential = this._credentialWallet.createCredential(issuerDID, req, jsonSchema);
+            const encodedCred = byteEncoder.encode(JSON.stringify(credential));
+            const encodedSchema = byteEncoder.encode(JSON.stringify(schema));
+            await new JsonSchemaValidator().validate(encodedCred, encodedSchema);
+        }
+        catch (e) {
+            throw new Error(`Error create w3c credential ${e.message}`);
+        }
+        const issuerAuthBJJCredential = await this._credentialWallet.getAuthBJJCredential(issuerDID);
+        const coreClaimOpts = {
+            revNonce: req.revocationOpts.nonce,
+            subjectPosition: req.subjectPosition,
+            merklizedRootPosition: req.merklizedRootPosition ?? MerklizedRootPosition.None,
+            updatable: false,
+            version: 0,
+            merklizeOpts: { ...opts, documentLoader: loader }
+        };
+        const coreClaim = await Parser.parseClaim(credential, coreClaimOpts);
+        const { hi, hv } = coreClaim.hiHv();
+        const coreClaimHash = poseidon.hash([hi, hv]);
+        const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
+        if (!issuerAuthBJJCredential.proof) {
+            throw new Error('issuer auth credential must have proof');
+        }
+        const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
+        if (!mtpAuthBJJProof) {
+            throw new Error('mtp is required for auth bjj key to issue new credentials');
+        }
+        const sigProof = new BJJSignatureProof2021({
+            issuerData: {
+                id: issuerDID,
+                state: mtpAuthBJJProof.issuerData.state,
+                authCoreClaim: mtpAuthBJJProof.coreClaim,
+                mtp: mtpAuthBJJProof.mtp,
+                credentialStatus: issuerAuthBJJCredential.credentialStatus
+            },
+            coreClaim,
+            signature
+        });
+        credential.proof = [sigProof];
+        return credential;
+    }
+    /** {@inheritDoc IIdentityWallet.revokeCredential} */
+    async revokeCredential(issuerDID, credential) {
+        const issuerTree = await this.getDIDTreeModel(issuerDID);
+        const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
+        if (!coreClaim) {
+            throw new Error('credential must have coreClaim representation in the signature proof');
+        }
+        const nonce = coreClaim.getRevocationNonce();
+        await issuerTree.revocationTree.add(nonce, BigInt(0));
+        return Number(BigInt.asUintN(64, nonce));
+    }
+    /** {@inheritDoc IIdentityWallet.addCredentialsToMerkleTree} */
+    async addCredentialsToMerkleTree(credentials, issuerDID) {
+        const oldIssuerTree = await this.getDIDTreeModel(issuerDID);
+        let claimsRoot = await oldIssuerTree.claimsTree.root();
+        let rootOfRoots = await oldIssuerTree.rootsTree.root();
+        let revocationRoot = await oldIssuerTree.revocationTree.root();
+        const oldTreeState = {
+            state: oldIssuerTree.state,
+            claimsRoot,
+            revocationRoot,
+            rootOfRoots
+        };
+        for (let index = 0; index < credentials.length; index++) {
+            const credential = credentials[index];
+            // credential must have a bjj signature proof
+            const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
+            if (!coreClaim) {
+                throw new Error('credential must have coreClaim representation in the signature proof');
+            }
+            await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
+        }
+        const newIssuerTreeState = await this.getDIDTreeModel(issuerDID);
+        const claimTreeRoot = await newIssuerTreeState.claimsTree.root();
+        await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Roots, claimTreeRoot.bigInt(), BigInt(0));
+        const newIssuerTreeStateWithROR = await this.getDIDTreeModel(issuerDID);
+        claimsRoot = await newIssuerTreeStateWithROR.claimsTree.root();
+        rootOfRoots = await newIssuerTreeStateWithROR.rootsTree.root();
+        revocationRoot = await newIssuerTreeStateWithROR.revocationTree.root();
+        return {
+            credentials,
+            newTreeState: {
+                state: newIssuerTreeStateWithROR.state,
+                claimsRoot,
+                rootOfRoots,
+                revocationRoot
+            },
+            oldTreeState: oldTreeState
+        };
+    }
+    /** {@inheritDoc IIdentityWallet.generateIden3SparseMerkleTreeProof} */
+    // treeState -  optional, if it is not passed proof of claim inclusion will be generated on the latest state in the tree.
+    async generateIden3SparseMerkleTreeProof(issuerDID, credentials, txId, blockNumber, blockTimestamp, treeState) {
+        for (let index = 0; index < credentials.length; index++) {
+            const credential = credentials[index];
+            const mtpWithProof = await this.generateCredentialMtp(issuerDID, credential, treeState);
+            // TODO: return coreClaim from generateCredentialMtp and use it below
+            // credential must have a bjj signature proof
+            const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
+            if (!coreClaim) {
+                throw new Error('credential must have coreClaim representation in the signature proof');
+            }
+            const mtpProof = new Iden3SparseMerkleTreeProof({
+                mtp: mtpWithProof.proof,
+                issuerData: {
+                    id: issuerDID,
+                    state: {
+                        claimsTreeRoot: mtpWithProof.treeState.claimsRoot,
+                        revocationTreeRoot: mtpWithProof.treeState.revocationRoot,
+                        rootOfRoots: mtpWithProof.treeState.rootOfRoots,
+                        value: mtpWithProof.treeState.state,
+                        txId,
+                        blockNumber,
+                        blockTimestamp
+                    }
+                },
+                coreClaim
+            });
+            if (Array.isArray(credentials[index].proof)) {
+                credentials[index].proof.push(mtpProof);
+            }
+            else {
+                credentials[index].proof = [credentials[index].proof, mtpProof];
+            }
+        }
+        return credentials;
+    }
+    /** {@inheritDoc IIdentityWallet.publishSpecificStateToRHS} */
+    async publishSpecificStateToRHS(treeModel, rhsURL, revokedNonces) {
+        await pushHashesToRHS(treeModel.state, treeModel, rhsURL, revokedNonces);
+    }
+    /** {@inheritDoc IIdentityWallet.publishStateToRHS} */
+    async publishStateToRHS(issuerDID, rhsURL, revokedNonces) {
+        const treeState = await this.getDIDTreeModel(issuerDID);
+        await pushHashesToRHS(treeState.state, {
+            revocationTree: treeState.revocationTree,
+            claimsTree: treeState.claimsTree,
+            state: treeState.state,
+            rootsTree: treeState.rootsTree
+        }, rhsURL, revokedNonces);
+    }
+    /** {@inheritDoc IIdentityWallet.publishRevocationInfoByCredentialStatusType} */
+    async publishRevocationInfoByCredentialStatusType(issuerDID, credentialStatusType, opts) {
+        const rhsPublishers = this._credentialStatusPublisherRegistry.get(credentialStatusType);
+        if (!rhsPublishers) {
+            throw new Error(`there is no registered publisher to save  hash is not registered for ${credentialStatusType} is not registered`);
+        }
+        let nodes = [];
+        if (opts?.treeModel) {
+            nodes = await getNodesRepresentation(opts.revokedNonces, {
+                revocationTree: opts.treeModel.revocationTree,
+                claimsTree: opts.treeModel.claimsTree,
+                state: opts.treeModel.state,
+                rootsTree: opts.treeModel.rootsTree
+            }, opts.treeModel.state);
+        }
+        else {
+            const treeState = await this.getDIDTreeModel(issuerDID);
+            nodes = await getNodesRepresentation(opts?.revokedNonces, {
+                revocationTree: treeState.revocationTree,
+                claimsTree: treeState.claimsTree,
+                state: treeState.state,
+                rootsTree: treeState.rootsTree
+            }, treeState.state);
+        }
+        if (!nodes.length) {
+            return;
+        }
+        const rhsPublishersTask = rhsPublishers.map((publisher) => publisher.publish({ nodes, ...opts, credentialStatusType, issuerDID }));
+        await Promise.all(rhsPublishersTask);
+    }
+    async getCoreClaimFromCredential(credential) {
+        const coreClaimFromSigProof = credential.getCoreClaimFromProof(ProofType.BJJSignature);
+        const coreClaimFromMtpProof = credential.getCoreClaimFromProof(ProofType.Iden3SparseMerkleTreeProof);
+        if (coreClaimFromMtpProof &&
+            coreClaimFromSigProof &&
+            coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
+            throw new Error('core claim representations is set in both proofs but they are not equal');
+        }
+        if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
+            throw new Error('core claim is not set in credential proofs');
+        }
+        //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
+        const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
+        return coreClaim;
+    }
+    async findOwnedCredentialsByDID(did, query) {
+        const credentials = await this._credentialWallet.findByQuery(query);
+        if (!credentials.length) {
+            throw new Error(`no credential satisfied query`);
+        }
+        const { genesisDID } = await this.getGenesisDIDMetadata(did);
+        const profiles = await this.getProfilesByDID(genesisDID);
+        return credentials.filter((cred) => {
+            const credentialSubjectId = cred.credentialSubject['id']; // credential subject
+            return (credentialSubjectId == genesisDID.string() ||
+                profiles.some((p) => {
+                    return p.id === credentialSubjectId;
+                }));
+        });
+    }
+    /** {@inheritDoc IIdentityWallet.updateIdentityState} */
+    async updateIdentityState(issuerDID, published, treeState) {
+        const latestTreeState = await this.getDIDTreeModel(issuerDID);
+        await this._storage.identity.saveIdentity({
+            did: issuerDID.string(),
+            state: treeState?.state ?? latestTreeState.state,
+            isStatePublished: published,
+            isStateGenesis: false
+        });
+    }
+}
+
 /**
  * converts verifiable RevocationStatus model to circuits structure
  *
@@ -63302,5 +63549,5 @@ class ContractRequestHandler {
     }
 }
 
-export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LinkedNullifierInputs, LinkedNullifierPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, NativeProver, OnChainResolver, OnChainZKPVerifier, Operators, constants$1 as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, Query, QueryOperators, RHSResolver, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes, base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58, bytesToBase64, bytesToBase64url, bytesToHex$1 as bytesToHex, cacheLoader, checkDataInField, comparatorOptions, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fillSlot, findValue, generateProfileDID, getNodeAuxValue, getProperties, getUserDIDFromCredential, hexToBytes$1 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, prepareCircuitArrayValues, prepareSiblingsStr, pushHashesToRHS, resolveDIDDocumentAuth, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, validateDIDDocumentAuth, validateTreeState };
+export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LinkedNullifierInputs, LinkedNullifierPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants$1 as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, Query, QueryOperators, RHSResolver, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes, base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58, bytesToBase64, bytesToBase64url, bytesToHex$1 as bytesToHex, cacheLoader, checkDataInField, comparatorOptions, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fillSlot, findValue, generateProfileDID, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getProperties, getUserDIDFromCredential, hexToBytes$1 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, prepareCircuitArrayValues, prepareSiblingsStr, pushHashesToRHS, resolveDIDDocumentAuth, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, validateDIDDocumentAuth, validateTreeState };
 //# sourceMappingURL=index.js.map