@0xpolygonid/js-sdk 1.6.1 → 1.7.1

package/dist/node/cjs/storage/blockchain/onchain-revocation.js

@@ -22,9 +22,16 @@ class OnChainRevocationStorage {
      * @param {string} - onhcain contract address
      * @param {string} - rpc url to connect to the blockchain
      */
-    constructor(config, contractAddress) {
-        this.provider = new ethers_1.JsonRpcProvider(config.url);
-        this.onchainContract = new ethers_1.Contract(contractAddress, CredentialStatusResolver_json_1.default, this.provider);
+    constructor(_config, contractAddress, _signer) {
+        this._config = _config;
+        this._signer = _signer;
+        this._provider = new ethers_1.JsonRpcProvider(_config.url);
+        let contract = new ethers_1.Contract(contractAddress, CredentialStatusResolver_json_1.default, 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.
@@ -32,7 +39,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 {
@@ -46,7 +53,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 {
@@ -54,6 +61,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) => js_merkletree_1.Hash.fromBigInt(i).hex());
         return {

package/dist/node/cjs/verifiable/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
+exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
 /** Verifiable constants */
 exports.VerifiableConstants = Object.freeze({
     ERRORS: {
@@ -103,3 +103,12 @@ var SubjectPosition;
     // Value save subject in value part of claim.
     SubjectPosition["Value"] = "value";
 })(SubjectPosition = exports.SubjectPosition || (exports.SubjectPosition = {}));
+/**
+ * RefreshServiceType type for refreshService
+ *
+ * @enum {string}
+ */
+var RefreshServiceType;
+(function (RefreshServiceType) {
+    RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
+})(RefreshServiceType = exports.RefreshServiceType || (exports.RefreshServiceType = {}));

package/dist/node/esm/circuits/comparer.js

@@ -50,12 +50,30 @@ export const QueryOperators = {
 };
 const allOperations = Object.values(QueryOperators);
 export 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]
 ]);
 /**

package/dist/node/esm/circuits/linked-multi-query.js

@@ -25,7 +25,7 @@ export class LinkedMultiQueryInputs extends BaseConfig {
             if (!this.query[i]) {
                 enabled.push(0);
                 claimPathNotExists.push(0);
-                claimPathMtp.push([]);
+                claimPathMtp.push(new Array(this.getMTLevelsClaim()).fill('0'));
                 claimPathMtpNoAux.push('0');
                 claimPathMtpAuxHi.push('0');
                 claimPathMtpAuxHv.push('0');

package/dist/node/esm/credentials/credential-wallet.js

@@ -1,4 +1,4 @@
-import { DID } from '@iden3/js-iden3-core';
+import { DID, getChainId } from '@iden3/js-iden3-core';
 import { W3CCredential, VerifiableConstants, CredentialStatusType } from './../verifiable';
 import * as uuid from 'uuid';
 import { CredentialStatusResolverRegistry } from './status/resolver';
@@ -50,6 +50,7 @@ export class CredentialWallet {
             cr['@context'] = context;
             cr.type = credentialType;
             cr.expirationDate = expirationDate ? new Date(expirationDate * 1000).toISOString() : undefined;
+            cr.refreshService = request.refreshService;
             cr.issuanceDate = new Date().toISOString();
             cr.credentialSubject = credentialSubject;
             cr.issuer = issuer.string();
@@ -57,7 +58,7 @@ export 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
@@ -123,7 +124,7 @@ export class CredentialWallet {
      * @param {CredentialRequest} request
      * @returns `CredentialStatus`
      */
-    buildCredentialStatus(request) {
+    buildCredentialStatus(request, issuer) {
         const credentialStatus = {
             id: request.revocationOpts.id,
             type: request.revocationOpts.type,
@@ -142,6 +143,23 @@ export 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;
         }

package/dist/node/esm/credentials/index.js

@@ -3,6 +3,7 @@ export * from './status/reverse-sparse-merkle-tree';
 export * from './status/sparse-merkle-tree';
 export * from './status/resolver';
 export * from './status/agent-revocation';
+export * from './status/credential-status-publisher';
 export * from './status/utils';
 export * from './credential-wallet';
 export * from './rhs';

package/dist/node/esm/credentials/rhs.js

@@ -1,13 +1,16 @@
-import { newHashFromBigInt, testBit, NodeLeaf } from '@iden3/js-merkletree';
+import { Hash, testBit, NodeLeaf } from '@iden3/js-merkletree';
 import { NODE_TYPE_LEAF } from '@iden3/js-merkletree';
 import { hashElems } from '@iden3/js-merkletree';
 import { ProofNode } from './status/reverse-sparse-merkle-tree';
+import { Iden3SmtRhsCredentialStatusPublisher } from './status/credential-status-publisher';
+import { CredentialStatusType } from '../verifiable';
 /**
  * Pushes identity state information to a reverse hash service.
  *
  * 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
@@ -15,6 +18,23 @@ import { ProofNode } from './status/reverse-sparse-merkle-tree';
  * @returns void
  */
 export 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.
+ */
+export async function getNodesRepresentation(revokedNonces, trees, state) {
     const nb = new NodesBuilder();
     if (revokedNonces) {
         await addRevocationNode(nb, trees, revokedNonces);
@@ -28,15 +48,7 @@ export 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;
@@ -62,8 +74,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.fromBigInt(nodeKey);
+        const nodeValueHash = Hash.fromBigInt(nodeValue);
         const node = new NodeLeaf(nodeKeyHash, nodeValueHash);
         const newNodes = await buildNodesUp(siblings, node);
         for (const n of newNodes) {
@@ -93,7 +105,7 @@ async function buildNodesUp(siblings, node) {
         nodes[index] = new ProofNode();
     }
     nodes[sl].hash = prevHash;
-    const hashOfOne = newHashFromBigInt(BigInt(1));
+    const hashOfOne = Hash.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--) {
@@ -107,7 +119,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;

package/dist/node/esm/credentials/status/credential-status-publisher.js

@@ -0,0 +1,78 @@
+import { CredentialStatusType } from '../../verifiable';
+/**
+ * Registry for managing credential status publishers.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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}`);
+        }
+    }
+}

package/dist/node/esm/credentials/utils.js

@@ -1,4 +1,6 @@
 import { DID } from '@iden3/js-iden3-core';
+import { PublicKey } from '@iden3/js-crypto';
+import { KmsKeyType, keyPath } from '../kms';
 /**
  * Retrieves the user DID from a given credential.
  * If the credential does not have a credentialSubject.id property, the issuer DID is returned.
@@ -17,3 +19,13 @@ export const getUserDIDFromCredential = (issuerDID, credential) => {
     }
     return DID.parse(credential.credentialSubject.id);
 };
+export 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 };
+};

package/dist/node/esm/iden3comm/constants.js

@@ -15,6 +15,8 @@ export const PROTOCOL_MESSAGE_TYPE = Object.freeze({
     CREDENTIAL_OFFER_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/offer',
     // CredentialIssuanceResponseMessageType is type for message with a credential issuance
     CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/issuance-response',
+    // CredentialRefreshMessageType is type for message with a credential issuance
+    CREDENTIAL_REFRESH_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/refresh',
     // DeviceRegistrationRequestMessageType defines device registration request type of the communication protocol
     DEVICE_REGISTRATION_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'devices/1.0/registration',
     // MessageFetMessageFetchRequestMessageType defines message fetch request type of the communication protocol.

package/dist/node/esm/iden3comm/handlers/fetch.js

@@ -16,7 +16,7 @@ import { DID } from '@iden3/js-iden3-core';
  */
 export class FetchHandler {
     /**
-     * Creates an instance of AuthHandler.
+     * Creates an instance of FetchHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
      */
     constructor(_packerMgr) {
@@ -29,7 +29,7 @@ export class FetchHandler {
      *     offer: Uint8Array; offer - raw offer message
      *     opts
      *   }) options how to fetch credential
-     * @returns `Promise<W3CCredential>`
+     * @returns `Promise<W3CCredential[]>`
      */
     async handleCredentialOffer(offer, opts) {
         if (!opts) {

package/dist/node/esm/iden3comm/handlers/index.js

@@ -1,3 +1,4 @@
 export * from './auth';
 export * from './fetch';
 export * from './contract-request';
+export * from './refresh';

package/dist/node/esm/iden3comm/handlers/refresh.js

@@ -0,0 +1,72 @@
+import { MediaType } from '../constants';
+import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { RefreshServiceType, W3CCredential } from '../../verifiable';
+import { byteEncoder } from '../../utils';
+import { proving, ProvingMethodAlg } from '@iden3/js-jwz';
+import { DID } from '@iden3/js-iden3-core';
+import { CircuitId } from '../../circuits';
+import { randomUUID } from 'crypto';
+/**
+ *
+ * Allows to refresh credential from refresh service and return refreshed credential
+ *
+ * @public
+
+ * @class RefreshHandler
+ * @implements implements RefreshHandler interface
+ */
+export class RefreshHandler {
+    /**
+     * Creates an instance of RefreshHandler.
+     * @param {RefreshHandlerOptions} _options - refresh handler options
+     */
+    constructor(_options) {
+        this._options = _options;
+    }
+    async refreshCredential(credential, opts) {
+        if (!credential.refreshService) {
+            throw new Error('refreshService not specified for W3CCredential');
+        }
+        if (credential.refreshService.type !== RefreshServiceType.Iden3RefreshService2023) {
+            throw new Error(`refresh service type ${credential.refreshService.type} is not supported`);
+        }
+        const otherIdentifier = credential.credentialSubject.id;
+        if (!otherIdentifier) {
+            throw new Error('self credentials do not support refresh');
+        }
+        const senderDID = DID.parse(otherIdentifier);
+        const zkpParams = {
+            senderDID,
+            provingMethodAlg: new ProvingMethodAlg(proving.provingMethodGroth16AuthV2Instance.methodAlg.alg, CircuitId.AuthV2)
+        };
+        const refreshMsg = {
+            id: randomUUID(),
+            typ: MediaType.ZKPMessage,
+            type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_REFRESH_MESSAGE_TYPE,
+            thid: randomUUID(),
+            body: {
+                id: otherIdentifier,
+                reason: opts?.reason ?? 'credential is expired'
+            },
+            from: otherIdentifier,
+            to: credential.issuer
+        };
+        const msgBytes = byteEncoder.encode(JSON.stringify(refreshMsg));
+        const jwzToken = await this._options.packageManager.pack(MediaType.ZKPMessage, msgBytes, zkpParams);
+        const resp = await fetch(credential.refreshService.id, {
+            method: 'post',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: jwzToken
+        });
+        if (resp.status !== 200) {
+            throw new Error(`could not refresh W3C credential, return status ${resp.status}`);
+        }
+        const respBody = await resp.json();
+        if (!respBody.body?.credential) {
+            throw new Error('no credential in CredentialIssuanceMessage response');
+        }
+        return W3CCredential.fromJSON(respBody.body.credential);
+    }
+}

package/dist/node/esm/identity/identity-wallet.js

@@ -5,11 +5,11 @@ import { hashElems, ZERO_HASH } from '@iden3/js-merkletree';
 import { generateProfileDID, subjectPositionIndex } from './common';
 import * as uuid from 'uuid';
 import { Parser, JsonSchemaValidator, cacheLoader } from '../schema-processor';
-import { MerkleTreeType } from '../storage/entities/mt';
-import { keyPath } from '../kms/provider-helpers';
+import { MerkleTreeType } from '../storage';
 import { VerifiableConstants, BJJSignatureProof2021, MerklizedRootPosition, SubjectPosition, W3CCredential, Iden3SparseMerkleTreeProof, ProofType, CredentialStatusType } from '../verifiable';
-import { pushHashesToRHS } from '../credentials';
+import { getKMSIdByAuthCredential, getNodesRepresentation, pushHashesToRHS } from '../credentials';
 import { byteEncoder } from '../utils';
+import { CredentialStatusPublisherRegistry, Iden3SmtRhsCredentialStatusPublisher } from '../credentials/status/credential-status-publisher';
 /**
  * @public
  * Wallet instance to manage the digital identity based on iden3 protocol
@@ -30,10 +30,19 @@ export class IdentityWallet {
      * @param {ICredentialWallet} _credentialWallet - credential wallet instance to quickly access credential CRUD functionality
      * @public
      */
-    constructor(_kms, _storage, _credentialWallet) {
+    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}
@@ -107,9 +116,10 @@ export class IdentityWallet {
             coreClaim: authClaim
         });
         credential.proof = [mtpProof];
-        if (opts.revocationOpts.type === CredentialStatusType.Iden3ReverseSparseMerkleTreeProof) {
-            await this.publishStateToRHS(did, opts.revocationOpts.id);
-        }
+        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,
@@ -171,10 +181,11 @@ export class IdentityWallet {
     }
     /** {@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([
+        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()
@@ -228,14 +239,14 @@ export class IdentityWallet {
     }
     /** {@inheritDoc IIdentityWallet.sign} */
     async sign(message, credential) {
-        const keyKMSId = this.getKMSIdByAuthCredential(credential);
+        const keyKMSId = getKMSIdByAuthCredential(credential);
         const payload = poseidon.hashBytes(message);
         const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(payload));
         return Signature.newFromCompressed(signature);
     }
     /** {@inheritDoc IIdentityWallet.signChallenge} */
     async signChallenge(challenge, credential) {
-        const keyKMSId = this.getKMSIdByAuthCredential(credential);
+        const keyKMSId = getKMSIdByAuthCredential(credential);
         const signature = await this._kms.sign(keyKMSId, BytesHelper.intToBytes(challenge));
         return Signature.newFromCompressed(signature);
     }
@@ -403,15 +414,35 @@ export class IdentityWallet {
             rootsTree: treeState.rootsTree
         }, rhsURL, revokedNonces);
     }
-    getKMSIdByAuthCredential(credential) {
-        if (credential.type.indexOf('AuthBJJCredential') === -1) {
-            throw new Error("can't sign with not AuthBJJCredential credential");
+    /** {@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 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 };
+        const rhsPublishersTask = rhsPublishers.map((publisher) => publisher.publish({ nodes, ...opts, credentialStatusType, issuerDID }));
+        await Promise.all(rhsPublishersTask);
     }
     async getCoreClaimFromCredential(credential) {
         const coreClaimFromSigProof = credential.getCoreClaimFromProof(ProofType.BJJSignature);

package/dist/node/esm/storage/blockchain/abi/CredentialStatusResolver.json

@@ -1 +1 @@
-[{ "inputs": [{ "internalType": "uint256", "name": "id", "type": "uint256" }, { "internalType": "uint64", "name": "nonce", "type": "uint64" }], "name": "getRevocationStatus", "outputs": [{ "components": [{ "components": [{ "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint256", "name": "claimsTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "revocationTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "rootOfRoots", "type": "uint256" }], "internalType": "structIOnchainCredentialStatusResolver.IdentityStateRoots", "name": "issuer", "type": "tuple" }, { "components": [{ "internalType": "uint256", "name": "root", "type": "uint256" }, { "internalType": "bool", "name": "existence", "type": "bool" }, { "internalType": "uint256[]", "name": "siblings", "type": "uint256[]" }, { "internalType": "uint256", "name": "index", "type": "uint256" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bool", "name": "auxExistence", "type": "bool" }, { "internalType": "uint256", "name": "auxIndex", "type": "uint256" }, { "internalType": "uint256", "name": "auxValue", "type": "uint256" }], "internalType": "structIOnchainCredentialStatusResolver.Proof", "name": "mtp", "type": "tuple" }], "internalType": "structIOnchainCredentialStatusResolver.CredentialStatus", "name": "", "type": "tuple" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "id", "type": "uint256" }, { "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint64", "name": "nonce", "type": "uint64" }], "name": "getRevocationStatusByIdAndState", "outputs": [{ "components": [{ "components": [{ "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint256", "name": "claimsTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "revocationTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "rootOfRoots", "type": "uint256" }], "internalType": "structIOnchainCredentialStatusResolver.IdentityStateRoots", "name": "issuer", "type": "tuple" }, { "components": [{ "internalType": "uint256", "name": "root", "type": "uint256" }, { "internalType": "bool", "name": "existence", "type": "bool" }, { "internalType": "uint256[]", "name": "siblings", "type": "uint256[]" }, { "internalType": "uint256", "name": "index", "type": "uint256" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bool", "name": "auxExistence", "type": "bool" }, { "internalType": "uint256", "name": "auxIndex", "type": "uint256" }, { "internalType": "uint256", "name": "auxValue", "type": "uint256" }], "internalType": "structIOnchainCredentialStatusResolver.Proof", "name": "mtp", "type": "tuple" }], "internalType": "structIOnchainCredentialStatusResolver.CredentialStatus", "name": "", "type": "tuple" }], "stateMutability": "view", "type": "function" }]
+[{ "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": [{ "internalType": "uint256", "name": "id", "type": "uint256" }, { "internalType": "uint64", "name": "nonce", "type": "uint64" }], "name": "getRevocationStatus", "outputs": [{ "components": [{ "components": [{ "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint256", "name": "claimsTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "revocationTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "rootOfRoots", "type": "uint256" }], "internalType": "struct IOnchainCredentialStatusResolver.IdentityStateRoots", "name": "issuer", "type": "tuple" }, { "components": [{ "internalType": "uint256", "name": "root", "type": "uint256" }, { "internalType": "bool", "name": "existence", "type": "bool" }, { "internalType": "uint256[]", "name": "siblings", "type": "uint256[]" }, { "internalType": "uint256", "name": "index", "type": "uint256" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bool", "name": "auxExistence", "type": "bool" }, { "internalType": "uint256", "name": "auxIndex", "type": "uint256" }, { "internalType": "uint256", "name": "auxValue", "type": "uint256" }], "internalType": "struct IOnchainCredentialStatusResolver.Proof", "name": "mtp", "type": "tuple" }], "internalType": "struct IOnchainCredentialStatusResolver.CredentialStatus", "name": "", "type": "tuple" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "id", "type": "uint256" }, { "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint64", "name": "nonce", "type": "uint64" }], "name": "getRevocationStatusByIdAndState", "outputs": [{ "components": [{ "components": [{ "internalType": "uint256", "name": "state", "type": "uint256" }, { "internalType": "uint256", "name": "claimsTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "revocationTreeRoot", "type": "uint256" }, { "internalType": "uint256", "name": "rootOfRoots", "type": "uint256" }], "internalType": "struct IOnchainCredentialStatusResolver.IdentityStateRoots", "name": "issuer", "type": "tuple" }, { "components": [{ "internalType": "uint256", "name": "root", "type": "uint256" }, { "internalType": "bool", "name": "existence", "type": "bool" }, { "internalType": "uint256[]", "name": "siblings", "type": "uint256[]" }, { "internalType": "uint256", "name": "index", "type": "uint256" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bool", "name": "auxExistence", "type": "bool" }, { "internalType": "uint256", "name": "auxIndex", "type": "uint256" }, { "internalType": "uint256", "name": "auxValue", "type": "uint256" }], "internalType": "struct IOnchainCredentialStatusResolver.Proof", "name": "mtp", "type": "tuple" }], "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" }]