@0xpolygonid/js-sdk 1.7.5 → 1.8.1

package/dist/node/cjs/verifiable/core-utils.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.caclulateCoreSchemaHash = exports.parseCoreClaimSlots = exports.findCredentialType = exports.parseSerializationAttr = exports.getSerializationAttrFromParsedContext = exports.getSerializationAttrFromContext = exports.fillCoreClaimSlot = exports.getFieldSlotIndex = void 0;
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
+const utils_1 = require("../utils");
+const jsonld = __importStar(require("jsonld/lib"));
+const ldcontext = __importStar(require("jsonld/lib/context"));
+const js_crypto_1 = require("@iden3/js-crypto");
+const js_sha3_1 = require("js-sha3");
+const credentialSubjectKey = 'credentialSubject';
+const contextFullKey = '@context';
+const serializationFullKey = 'iden3_serialization';
+const fieldPrefix = 'iden3:v1:';
+const credentialSubjectFullKey = 'https://www.w3.org/2018/credentials#credentialSubject';
+const verifiableCredentialFullKey = 'https://www.w3.org/2018/credentials#VerifiableCredential';
+const typeFullKey = '@type';
+/**
+ * GetFieldSlotIndex return index of slot from 0 to 7 (each claim has by default 8 slots) for non-merklized claims
+ *
+ * @param {string} field - field name
+ * @param {Uint8Array} schemaBytes -json schema bytes
+ * @returns `number`
+ */
+const getFieldSlotIndex = async (field, typeName, schemaBytes) => {
+    let ctxDoc = JSON.parse(utils_1.byteDecoder.decode(schemaBytes));
+    ctxDoc = ctxDoc[contextFullKey];
+    if (ctxDoc === undefined) {
+        throw new Error('document has no @context');
+    }
+    const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), ctxDoc, {});
+    const serAttr = await (0, exports.getSerializationAttrFromParsedContext)(ldCtx, typeName);
+    if (!serAttr) {
+        throw new Error('serialization attribute is not set');
+    }
+    const sPaths = (0, exports.parseSerializationAttr)(serAttr);
+    switch (field) {
+        case sPaths.indexAPath:
+            return 2;
+        case sPaths.indexBPath:
+            return 3;
+        case sPaths.valueAPath:
+            return 6;
+        case sPaths.valueBPath:
+            return 7;
+        default:
+            throw new Error(`field ${field} not specified in serialization info`);
+    }
+};
+exports.getFieldSlotIndex = getFieldSlotIndex;
+/**
+ * checks if data can fill the slot
+ *
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
+ */
+const fillCoreClaimSlot = async (slotData, mz, path) => {
+    if (!path) {
+        return;
+    }
+    path = credentialSubjectKey + '.' + path;
+    try {
+        const p = await mz.resolveDocPath(path, mz.options);
+        const entry = await mz.entry(p);
+        const intVal = await entry.getValueMtEntry();
+        const bytesVal = js_iden3_core_1.BytesHelper.intToBytes(intVal);
+        slotData.set(bytesVal, 0);
+    }
+    catch (err) {
+        if (err.toString().includes('entry not found')) {
+            throw new Error(`field not found in credential ${path}`);
+        }
+        throw err;
+    }
+};
+exports.fillCoreClaimSlot = fillCoreClaimSlot;
+// Get `iden3_serialization` attr definition from context document either using
+// type name like DeliverAddressMultiTestForked or by type id like
+// urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+const getSerializationAttrFromContext = async (context, opts, tp) => {
+    const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), context, opts);
+    return (0, exports.getSerializationAttrFromParsedContext)(ldCtx, tp);
+};
+exports.getSerializationAttrFromContext = getSerializationAttrFromContext;
+const getSerializationAttrFromParsedContext = async (ldCtx, tp) => {
+    const termDef = ldCtx.mappings;
+    if (!termDef) {
+        throw new Error('terms definitions is not of correct type');
+    }
+    const term = termDef.get(tp) ?? [...termDef.values()].find((value) => value['@id'] === tp);
+    if (!term) {
+        return '';
+    }
+    const termCtx = term[contextFullKey];
+    if (!termCtx) {
+        throw new Error('type @context is not of correct type');
+    }
+    const serStr = termCtx[serializationFullKey] ?? '';
+    return serStr;
+};
+exports.getSerializationAttrFromParsedContext = getSerializationAttrFromParsedContext;
+const parseSerializationAttr = (serAttr) => {
+    if (!serAttr.startsWith(fieldPrefix)) {
+        throw new Error('serialization attribute does not have correct prefix');
+    }
+    const parts = serAttr.slice(fieldPrefix.length).split('&');
+    if (parts.length > 4) {
+        throw new Error('serialization attribute has too many parts');
+    }
+    const paths = {};
+    for (const part of parts) {
+        const kv = part.split('=');
+        if (kv.length !== 2) {
+            throw new Error('serialization attribute part does not have correct format');
+        }
+        switch (kv[0]) {
+            case 'slotIndexA':
+                paths.indexAPath = kv[1];
+                break;
+            case 'slotIndexB':
+                paths.indexBPath = kv[1];
+                break;
+            case 'slotValueA':
+                paths.valueAPath = kv[1];
+                break;
+            case 'slotValueB':
+                paths.valueBPath = kv[1];
+                break;
+            default:
+                throw new Error('unknown serialization attribute slot');
+        }
+    }
+    return paths;
+};
+exports.parseSerializationAttr = parseSerializationAttr;
+const findCredentialType = (mz) => {
+    const opts = mz.options;
+    try {
+        // try to look into credentialSubject.@type to get type of credentials
+        const path1 = new js_jsonld_merklization_1.Path([credentialSubjectFullKey, typeFullKey], opts.hasher);
+        const e = mz.rawValue(path1);
+        return e;
+    }
+    catch (err) {
+        // if type of credentials not found in credentialSubject.@type, loop at
+        // top level @types if it contains two elements: type we are looking for
+        // and "VerifiableCredential" type.
+        const path2 = new js_jsonld_merklization_1.Path([typeFullKey], opts.hasher);
+        const topLevelTypes = mz.rawValue(path2);
+        if (!Array.isArray(topLevelTypes)) {
+            throw new Error('top level @type expected to be an array');
+        }
+        if (topLevelTypes.length !== 2) {
+            throw new Error('top level @type expected to be of length 2');
+        }
+        switch (verifiableCredentialFullKey) {
+            case topLevelTypes[0]:
+                return topLevelTypes[1];
+            case topLevelTypes[1]:
+                return topLevelTypes[0];
+            default:
+                throw new Error('@type(s) are expected to contain VerifiableCredential type');
+        }
+    }
+};
+exports.findCredentialType = findCredentialType;
+/**
+ * parseCoreClaimSlots converts payload to claim slots using provided schema
+ *
+ * @param { { mappings: Map<string, Record<string, unknown>> } } ldCtx - ldCtx
+ * @param {Merklizer} mz - Merklizer
+ * @param {string} credentialType - credential type
+ * @returns `Promise<{ slots: ParsedSlots; nonMerklized: boolean }>`
+ */
+const parseCoreClaimSlots = async (ldCtx, mz, credentialType) => {
+    // parseSlots converts payload to claim slots using provided schema
+    const slots = {
+        indexA: new Uint8Array(32),
+        indexB: new Uint8Array(32),
+        valueA: new Uint8Array(32),
+        valueB: new Uint8Array(32)
+    };
+    const serAttr = await (0, exports.getSerializationAttrFromParsedContext)(ldCtx, credentialType);
+    if (!serAttr) {
+        return { slots, nonMerklized: false };
+    }
+    const sPaths = (0, exports.parseSerializationAttr)(serAttr);
+    const isSPathEmpty = !Object.values(sPaths).some(Boolean);
+    if (isSPathEmpty) {
+        return { slots, nonMerklized: true };
+    }
+    await (0, exports.fillCoreClaimSlot)(slots.indexA, mz, sPaths.indexAPath);
+    await (0, exports.fillCoreClaimSlot)(slots.indexB, mz, sPaths.indexBPath);
+    await (0, exports.fillCoreClaimSlot)(slots.valueA, mz, sPaths.valueAPath);
+    await (0, exports.fillCoreClaimSlot)(slots.valueB, mz, sPaths.valueBPath);
+    return { slots, nonMerklized: true };
+};
+exports.parseCoreClaimSlots = parseCoreClaimSlots;
+/**
+ * Calculates core schema hash
+ *
+ * @param {Uint8Array} schemaId
+ * @returns {*}  {SchemaHash}
+ */
+const caclulateCoreSchemaHash = (schemaId) => {
+    const sHash = js_crypto_1.Hex.decodeString((0, js_sha3_1.keccak256)(schemaId));
+    return new js_iden3_core_1.SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
+};
+exports.caclulateCoreSchemaHash = caclulateCoreSchemaHash;

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

@@ -1,15 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTreeState = exports.extractProof = exports.W3CCredential = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const proof_1 = require("./proof");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const constants_1 = require("./constants");
 const js_merkletree_1 = require("@iden3/js-merkletree");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const js_crypto_1 = require("@iden3/js-crypto");
 const utils_1 = require("../credentials/utils");
 const utils_2 = require("../utils");
+const constants_1 = require("./constants");
+const core_utils_1 = require("./core-utils");
+const jsonld = __importStar(require("jsonld/lib"));
+const ldcontext = __importStar(require("jsonld/lib/context"));
 /**
  * W3C Verifiable credential
  *
@@ -89,6 +115,77 @@ class W3CCredential {
         }
         return undefined;
     }
+    /**
+     * gets core claim representation from W3CCredential
+     *
+     * @param {CoreClaimParsingOptions} [opts] - options to create core claim
+     * @returns {*}  {(Promise<Claim>)}
+     */
+    async toCoreClaim(opts) {
+        if (!opts) {
+            opts = {
+                revNonce: 0,
+                version: 0,
+                subjectPosition: constants_1.SubjectPosition.Index,
+                merklizedRootPosition: constants_1.MerklizedRootPosition.None,
+                updatable: false,
+                merklizeOpts: {}
+            };
+        }
+        const mz = await this.merklize(opts.merklizeOpts);
+        const credentialType = (0, core_utils_1.findCredentialType)(mz);
+        const subjectId = this.credentialSubject['id'];
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), this['@context'], mz.options);
+        const { slots, nonMerklized } = await (0, core_utils_1.parseCoreClaimSlots)(ldCtx, mz, credentialType);
+        // if schema is for non merklized credential, root position must be set to none ('')
+        // otherwise default position for merklized position is index.
+        if (nonMerklized && opts.merklizedRootPosition !== constants_1.MerklizedRootPosition.None) {
+            throw new Error('merklized root position is not supported for non-merklized claims');
+        }
+        if (!nonMerklized && opts.merklizedRootPosition === constants_1.MerklizedRootPosition.None) {
+            opts.merklizedRootPosition = constants_1.MerklizedRootPosition.Index;
+        }
+        const schemaHash = (0, core_utils_1.caclulateCoreSchemaHash)(utils_2.byteEncoder.encode(credentialType));
+        const claim = js_iden3_core_1.Claim.newClaim(schemaHash, js_iden3_core_1.ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), js_iden3_core_1.ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), js_iden3_core_1.ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), js_iden3_core_1.ClaimOptions.withVersion(opts.version));
+        if (opts.updatable) {
+            claim.setFlagUpdatable(opts.updatable);
+        }
+        if (this.expirationDate) {
+            claim.setExpirationDate(new Date(this.expirationDate));
+        }
+        if (subjectId) {
+            const did = js_iden3_core_1.DID.parse(subjectId.toString());
+            const id = js_iden3_core_1.DID.idFromDID(did);
+            switch (opts.subjectPosition) {
+                case '':
+                case constants_1.SubjectPosition.Index:
+                    claim.setIndexId(id);
+                    break;
+                case constants_1.SubjectPosition.Value:
+                    claim.setValueId(id);
+                    break;
+                default:
+                    throw new Error('unknown subject position');
+            }
+        }
+        switch (opts.merklizedRootPosition) {
+            case constants_1.MerklizedRootPosition.Index: {
+                const mk = await this.merklize(opts.merklizeOpts);
+                claim.setIndexMerklizedRoot((await mk.root()).bigInt());
+                break;
+            }
+            case constants_1.MerklizedRootPosition.Value: {
+                const mk = await this.merklize(opts.merklizeOpts);
+                claim.setValueMerklizedRoot((await mk.root()).bigInt());
+                break;
+            }
+            case constants_1.MerklizedRootPosition.None:
+                break;
+            default:
+                throw new Error('unknown merklized root position');
+        }
+        return claim;
+    }
     /**
      * checks BJJSignatureProof2021 in W3C VC
      *
@@ -127,6 +224,7 @@ class W3CCredential {
         if (!coreClaim) {
             throw new Error(`can't get core claim`);
         }
+        await this.verifyCoreClaimMatch(coreClaim, opts?.merklizeOptions);
         switch (proofType) {
             case constants_1.ProofType.BJJSignature: {
                 if (!opts?.credStatusResolverRegistry) {
@@ -144,6 +242,46 @@ class W3CCredential {
             }
         }
     }
+    async verifyCoreClaimMatch(coreClaim, merklizeOpts) {
+        let merklizedRootPosition = '';
+        const merklizedPosition = coreClaim.getMerklizedPosition();
+        switch (merklizedPosition) {
+            case js_iden3_core_1.MerklizedRootPosition.None:
+                merklizedRootPosition = constants_1.MerklizedRootPosition.None;
+                break;
+            case js_iden3_core_1.MerklizedRootPosition.Index:
+                merklizedRootPosition = constants_1.MerklizedRootPosition.Index;
+                break;
+            case js_iden3_core_1.MerklizedRootPosition.Value:
+                merklizedRootPosition = constants_1.MerklizedRootPosition.Value;
+                break;
+        }
+        let subjectPosition = '';
+        const idPosition = coreClaim.getIdPosition();
+        switch (idPosition) {
+            case js_iden3_core_1.IdPosition.None:
+                subjectPosition = constants_1.SubjectPosition.None;
+                break;
+            case js_iden3_core_1.IdPosition.Index:
+                subjectPosition = constants_1.SubjectPosition.Index;
+                break;
+            case js_iden3_core_1.IdPosition.Value:
+                subjectPosition = constants_1.SubjectPosition.Value;
+                break;
+        }
+        const coreClaimOpts = {
+            revNonce: Number(coreClaim.getRevocationNonce()),
+            version: coreClaim.getVersion(),
+            merklizedRootPosition,
+            subjectPosition,
+            updatable: coreClaim.getFlagUpdatable(),
+            merklizeOpts: merklizeOpts
+        };
+        const credentialCoreClaim = await this.toCoreClaim(coreClaimOpts);
+        if (coreClaim.hex() != credentialCoreClaim.hex()) {
+            throw new Error('proof generated for another credential');
+        }
+    }
     async verifyBJJSignatureProof(proof, coreClaim, resolverURL, userDID, credStatusResolverRegistry) {
         // issuer auth claim
         const authClaim = proof.issuerData.authCoreClaim;

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

@@ -19,3 +19,4 @@ __exportStar(require("./presentation"), exports);
 __exportStar(require("./proof"), exports);
 __exportStar(require("./schema"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./core-utils"), exports);

package/dist/node/esm/circuits/atomic-query-mtp-v2.js

@@ -1,6 +1,6 @@
-import { newHashFromString } from '@iden3/js-merkletree';
 import { Id, SchemaHash } from '@iden3/js-iden3-core';
 import { ValueProof, CircuitError } from './models';
+import { Hash } from '@iden3/js-merkletree';
 import { BaseConfig, bigIntArrayToStringArray, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues, prepareSiblingsStr } from './common';
 import { byteDecoder, byteEncoder } from '../utils';
 /**
@@ -140,13 +140,13 @@ export class AtomicQueryMTPV2PubSignals extends BaseConfig {
         this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerClaimIdenState
-        this.issuerClaimIdenState = newHashFromString(sVals[fieldIdx]);
+        this.issuerClaimIdenState = Hash.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - isRevocationChecked
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = newHashFromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);

package/dist/node/esm/circuits/atomic-query-sig-v2.js

@@ -1,6 +1,6 @@
-import { newHashFromString } from '@iden3/js-merkletree';
 import { Id, SchemaHash } from '@iden3/js-iden3-core';
 import { ValueProof, CircuitError } from './models';
+import { Hash } from '@iden3/js-merkletree';
 import { BaseConfig, bigIntArrayToStringArray, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues, prepareSiblingsStr } from './common';
 import { QueryOperators } from './comparer';
 import { byteDecoder, byteEncoder } from '../utils';
@@ -172,7 +172,7 @@ export class AtomicQuerySigV2PubSignals extends BaseConfig {
         this.userID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerAuthState
-        this.issuerAuthState = newHashFromString(sVals[fieldIdx]);
+        this.issuerAuthState = Hash.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - requestID
         this.requestID = BigInt(sVals[fieldIdx]);
@@ -184,7 +184,7 @@ export class AtomicQuerySigV2PubSignals extends BaseConfig {
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = newHashFromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);

package/dist/node/esm/circuits/atomic-query-v3-on-chain.js

@@ -116,7 +116,10 @@ export class AtomicQueryV3OnChainInputs extends BaseConfig {
             valueProof.value = 0n;
             valueProof.mtp = new Proof();
         }
-        const treeState = this.claim.nonRevProof.treeState;
+        let treeState = this.claim.nonRevProof.treeState;
+        if (this.proofType === ProofType.BJJSignature && this.skipClaimRevocationCheck) {
+            treeState = this.claim.signatureProof?.issuerAuthNonRevProof.treeState;
+        }
         if (!treeState) {
             throw new Error(CircuitError.EmptyTreeState);
         }
@@ -172,27 +175,32 @@ export class AtomicQueryV3OnChainInputs extends BaseConfig {
             s.isRevocationChecked = 0;
         }
         if (this.proofType === ProofType.BJJSignature) {
+            const sigProof = this.claim.signatureProof;
             s.proofType = '1';
-            s.issuerClaimSignatureR8x = this.claim.signatureProof?.signature.R8[0].toString();
-            s.issuerClaimSignatureR8y = this.claim.signatureProof?.signature.R8[1].toString();
-            s.issuerClaimSignatureS = this.claim.signatureProof?.signature.S.toString();
-            s.issuerAuthClaim = this.claim.signatureProof?.issuerAuthClaim?.marshalJson();
-            s.issuerAuthClaimMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthIncProof.proof, this.getMTLevel());
+            s.issuerClaimSignatureR8x = sigProof.signature.R8[0].toString();
+            s.issuerClaimSignatureR8y = sigProof.signature.R8[1].toString();
+            s.issuerClaimSignatureS = sigProof.signature.S.toString();
+            s.issuerAuthClaim = sigProof.issuerAuthClaim?.marshalJson();
+            s.issuerAuthClaimMtp = prepareSiblingsStr(sigProof.issuerAuthIncProof.proof, this.getMTLevel());
             const issuerAuthTreeState = this.claim.nonRevProof.treeState;
             if (!issuerAuthTreeState) {
                 throw new Error(CircuitError.EmptyTreeState);
             }
-            s.issuerAuthClaimsTreeRoot = issuerAuthTreeState.claimsRoot.bigInt().toString();
-            s.issuerAuthRevTreeRoot = issuerAuthTreeState.revocationRoot.bigInt().toString();
-            s.issuerAuthRootsTreeRoot = issuerAuthTreeState.rootOfRoots.bigInt().toString();
-            s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthNonRevProof.proof, this.getMTLevel());
-            const nodeAuxIssuerAuthNonRev = getNodeAuxValue(this.claim.signatureProof?.issuerAuthNonRevProof.proof);
+            s.issuerAuthClaimsTreeRoot = sigProof.issuerAuthIncProof.treeState?.claimsRoot
+                .bigInt()
+                .toString();
+            s.issuerAuthRevTreeRoot = sigProof.issuerAuthIncProof.treeState?.revocationRoot
+                .bigInt()
+                .toString();
+            s.issuerAuthRootsTreeRoot = sigProof.issuerAuthIncProof.treeState?.rootOfRoots
+                .bigInt()
+                .toString();
+            s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(sigProof.issuerAuthNonRevProof.proof, this.getMTLevel());
+            const nodeAuxIssuerAuthNonRev = getNodeAuxValue(sigProof.issuerAuthNonRevProof.proof);
             s.issuerAuthClaimNonRevMtpAuxHi = nodeAuxIssuerAuthNonRev.key.bigInt().toString();
             s.issuerAuthClaimNonRevMtpAuxHv = nodeAuxIssuerAuthNonRev.value.bigInt().toString();
             s.issuerAuthClaimNonRevMtpNoAux = nodeAuxIssuerAuthNonRev.noAux;
-            s.issuerAuthState = this.claim.signatureProof?.issuerAuthIncProof.treeState?.state
-                .bigInt()
-                .toString();
+            s.issuerAuthState = sigProof.issuerAuthIncProof.treeState?.state.bigInt().toString();
             this.fillMTPProofsWithZero(s);
         }
         else if (this.proofType === ProofType.Iden3SparseMerkleTreeProof) {

package/dist/node/esm/circuits/auth-v2.js

@@ -1,4 +1,4 @@
-import { newHashFromString } from '@iden3/js-merkletree';
+import { Hash } from '@iden3/js-merkletree';
 import { Id } from '@iden3/js-iden3-core';
 import { CircuitError } from './models';
 import { BaseConfig, getNodeAuxValue, prepareSiblingsStr } from './common';
@@ -85,7 +85,7 @@ export class AuthV2PubSignals {
         }
         this.userID = Id.fromBigInt(BigInt(sVals[0]));
         this.challenge = BigInt(sVals[1]);
-        this.GISTRoot = newHashFromString(sVals[2]);
+        this.GISTRoot = Hash.fromString(sVals[2]);
         return this;
     }
 }

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

@@ -5,8 +5,6 @@ import { CredentialStatusResolverRegistry } from './status/resolver';
 import { IssuerResolver } from './status/sparse-merkle-tree';
 import { AgentResolver } from './status/agent-revocation';
 import { getUserDIDFromCredential } from './utils';
-// ErrAllClaimsRevoked all claims are revoked.
-const ErrAllClaimsRevoked = 'all claims are revoked';
 /**
  *
  * Wallet instance is a wrapper of CRUD logic for W3C credentials,
@@ -222,6 +220,6 @@ export class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error(ErrAllClaimsRevoked);
+        throw new Error('all claims are revoked');
     }
 }

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

@@ -7,3 +7,4 @@ export * from './status/credential-status-publisher';
 export * from './credential-wallet';
 export * from './rhs';
 export * from './utils';
+export * from './models';

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,5 @@
 import { CredentialStatusType } from '../../verifiable';
+import { MessageBus, SDK_EVENTS } from '../../utils';
 /**
  * Registry for managing credential status publishers.
  */
@@ -42,12 +43,30 @@ export class Iden3OnchainSmtCredentialStatusPublisher {
         }
         const nodesBigInts = params.nodes.map((n) => n.children.map((c) => c.bigInt()));
         const txPromise = this._storage.saveNodes(nodesBigInts);
+        let publishMode = params.onChain?.publishMode ?? 'sync';
         if (params.onChain?.txCallback) {
-            const cb = params.onChain?.txCallback;
-            txPromise.then((receipt) => cb(receipt));
-            return;
+            publishMode = 'callback';
+        }
+        switch (publishMode) {
+            case 'sync':
+                await txPromise;
+                break;
+            case 'callback': {
+                if (!params.onChain?.txCallback) {
+                    throw new Error('txCallback is required for publishMode "callback"');
+                }
+                const cb = params.onChain?.txCallback;
+                txPromise.then((receipt) => cb(receipt));
+                break;
+            }
+            case 'async': {
+                const mb = MessageBus.getInstance();
+                txPromise.then((receipt) => mb.publish(SDK_EVENTS.TX_RECEIPT_ACCEPTED, receipt));
+                break;
+            }
+            default:
+                throw new Error(`Invalid publishMode: ${publishMode}`);
         }
-        await txPromise;
     }
 }
 /**

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

@@ -30,7 +30,9 @@ export const PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // RevocationStatusResponseMessageType is type for response with a revocation status
     REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: IDEN3_PROTOCOL + 'revocation/1.0/status',
     // ContractInvokeRequestMessageType is type for request of contract invoke request
-    CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'proofs/1.0/contract-invoke-request'
+    CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'proofs/1.0/contract-invoke-request',
+    // CredentialOnchainOfferMessageType is type of message with credential onchain offering
+    CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/onchain-offer'
 });
 /**
  * Media types for iden3 comm communication protocol