@0xpolygonid/js-sdk 1.7.1 → 1.7.3

package/dist/browser/esm/index.js

@@ -33567,6 +33567,9 @@ class W3CCredential {
             throw new Error('signature proof: invalid tree state of the issuer while checking credential status of singing key');
         }
         const revocationNonce = BigInt(proof.issuerData.credentialStatus.revocationNonce || 0);
+        if (revocationNonce !== proof.issuerData.authCoreClaim.getRevocationNonce()) {
+            throw new Error(`revocation nonce mismatch: revocation nonce from core representation of auth credential is not the same as in its credential`);
+        }
         const proofValid = await verifyProof(Hash$1.fromHex(credStatus.issuer.revocationTreeRoot), credStatus.mtp, revocationNonce, BigInt(0));
         if (!proofValid) {
             throw new Error(`proof validation failed. revNonce=${revocationNonce}`);
@@ -63379,6 +63382,7 @@ class AuthHandler {
             }
             const credWithRevStatus = groupedCredentialsCache.get(groupId);
             const zkpRes = await this._proofService.generateProof(proofReq, did, {
+                verifierDid: DID.parse(authRequest.from),
                 skipRevocation: Boolean(query.skipClaimRevocationCheck),
                 credential: credWithRevStatus?.cred,
                 credentialRevocationStatus: credWithRevStatus?.revStatus,
@@ -63414,8 +63418,9 @@ class FetchHandler {
      * Creates an instance of FetchHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
      */
-    constructor(_packerMgr) {
+    constructor(_packerMgr, opts) {
         this._packerMgr = _packerMgr;
+        this.opts = opts;
     }
     /**
      * Handles only messages with credentials/1.0/offer type
@@ -63435,11 +63440,7 @@ class FetchHandler {
         if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
             throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
         }
-        const { unpackedMessage: message } = await this._packerMgr.unpack(offer);
-        const offerMessage = message;
-        if (message.type !== PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE) {
-            throw new Error('Invalid media type');
-        }
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
         const credentials = [];
         for (let index = 0; index < offerMessage.body.credentials.length; index++) {
             const credentialInfo = offerMessage.body.credentials[index];
@@ -63491,6 +63492,69 @@ class FetchHandler {
         }
         return credentials;
     }
+    /**
+     * @inheritdoc IFetchHandler#handleCredentialFetchRequest
+     */
+    async handleCredentialFetchRequest(envelope) {
+        const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+        if (!msgRequest.to) {
+            throw new Error("failed request. empty 'to' field");
+        }
+        if (!msgRequest.from) {
+            throw new Error("failed request. empty 'from' field");
+        }
+        const issuerDID = DID.parse(msgRequest.to);
+        const userDID = DID.parse(msgRequest.from);
+        const credId = msgRequest.body?.id;
+        if (!credId) {
+            throw new Error('nvalid credential id in fetch request body');
+        }
+        if (!this.opts?.credentialWallet) {
+            throw new Error('please, provide credential wallet in options');
+        }
+        const cred = await this.opts.credentialWallet.findById(credId);
+        if (!cred) {
+            throw new Error('credential not found');
+        }
+        const userToVerifyDID = getUserDIDFromCredential(issuerDID, cred);
+        if (userToVerifyDID.string() !== userDID.string()) {
+            throw new Error('credential subject is not a sender DID');
+        }
+        return this._packerMgr.pack(MediaType.PlainMessage, byteEncoder.encode(JSON.stringify({
+            id: v4(),
+            type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE,
+            typ: msgRequest.typ ?? MediaType.PlainMessage,
+            thid: msgRequest.thid ?? v4(),
+            body: { credential: cred },
+            from: msgRequest.to,
+            to: msgRequest.from
+        })), {});
+    }
+    /**
+     * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
+     */
+    async handleIssuanceResponseMessage(envelop) {
+        const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+        if (!this.opts?.credentialWallet) {
+            throw new Error('please provide credential wallet in options');
+        }
+        if (!issuanceMsg.body?.credential) {
+            throw new Error('credential is missing in issuance response message');
+        }
+        await this.opts.credentialWallet.save(W3CCredential.fromJSON(issuanceMsg.body.credential));
+        return Promise.resolve(Uint8Array.from([]));
+    }
+    /**
+     * @inheritdoc IFetchHandler#unpackMessage
+     */
+    static async unpackMessage(packerMgr, envelope, messageType) {
+        const { unpackedMessage: message } = await packerMgr.unpack(envelope);
+        const msgRequest = message;
+        if (message.type !== messageType) {
+            throw new Error('Invalid message type');
+        }
+        return msgRequest;
+    }
 }
 
 /**