@0xpolygonid/js-sdk 1.10.4 → 1.11.1

package/dist/node/cjs/iden3comm/handlers/message-handler.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandler = exports.AbstractMessageHandler = void 0;
+/**
+ * Base implementation of protocol message handler
+ *
+ * @export
+ * @abstract
+ * @class AbstractMessageHandler
+ * @implements {IProtocolMessageHandler}
+ */
+class AbstractMessageHandler {
+    setNext(messageHandler) {
+        this.nextMessageHandler = messageHandler;
+        return messageHandler;
+    }
+    async handle(message, context) {
+        if (this.nextMessageHandler)
+            return this.nextMessageHandler.handle(message, context);
+        return Promise.reject('Message handler not provided or message not supported');
+    }
+}
+exports.AbstractMessageHandler = AbstractMessageHandler;
+/**
+ * Protocol message handler entry point
+ */
+class MessageHandler {
+    /**
+     * Creates an instance of MessageHandler.
+     * @param {{
+     *       messageHandlers: AbstractMessageHandler[];
+     *       packageManager: IPackageManager;
+     *     }} _params
+     * @memberof MessageHandler
+     */
+    constructor(_params) {
+        this._params = _params;
+        this.registerHandlers(_params.messageHandlers);
+    }
+    /**
+     * Registers a list of message handlers and sets up the chain of responsibility.
+     *
+     * This method takes an array of `AbstractMessageHandler` instances and sets up a chain of responsibility
+     * where each handler is linked to the next one in the array. The first handler in the array becomes the
+     * main message handler for the `MessageHandler` class.
+     *
+     * @param {AbstractMessageHandler[]} handlersList - An array of `AbstractMessageHandler` instances to be registered.
+     * @returns {void}
+     */
+    registerHandlers(handlersList) {
+        if (!handlersList.length)
+            return;
+        const [firstMessageHandler, ...restHandlersList] = handlersList;
+        const tempHandler = firstMessageHandler;
+        for (const currentHandler of restHandlersList) {
+            let lastHandler = tempHandler;
+            while (lastHandler.nextMessageHandler) {
+                lastHandler = lastHandler.nextMessageHandler;
+            }
+            lastHandler.setNext(currentHandler);
+        }
+        if (!this.messageHandler) {
+            this.messageHandler = firstMessageHandler;
+        }
+        else {
+            this.messageHandler.setNext(firstMessageHandler);
+        }
+    }
+    /**
+     * Handles a message by unpacking it, passing it to the registered message handler, and packing the response.
+     *
+     * This method takes a Uint8Array of message bytes and a context object that contains information specific to the
+     * type of message being handled (e.g. AuthMessageHandlerOptions, ContractMessageHandlerOptions, etc.).
+     *
+     * The method first unpacks the message using the provided package manager, then passes the unpacked message and
+     * context to the registered message handler. If the message handler returns a response, the method packs the
+     * response using the package manager and returns it. If the message handler does not return a response, the
+     * method returns null.
+     *
+     * @param bytes - A Uint8Array of message bytes to be handled.
+     * @param context - An object containing information specific to the type of message being handled.
+     * @returns A Promise that resolves to a Uint8Array of the packed response, or null if no response was generated.
+     */
+    async handleMessage(bytes, context) {
+        const { unpackedMediaType, unpackedMessage: message } = await this._params.packageManager.unpack(bytes);
+        if (!this.messageHandler) {
+            return Promise.reject(new Error('Message handler not provided'));
+        }
+        const response = await this.messageHandler.handle(message, context);
+        if (response) {
+            return this._params.packageManager.packMessage(unpackedMediaType, response, {});
+        }
+        return null;
+    }
+}
+exports.MessageHandler = MessageHandler;

package/dist/node/cjs/iden3comm/handlers/revocation-status.js

@@ -30,6 +30,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const uuid = __importStar(require("uuid"));
 const utils_1 = require("../../utils");
 const js_jwz_1 = require("@iden3/js-jwz");
+const message_handler_1 = require("./message-handler");
 /**
  *
  * Allows to process RevocationStatusRequest protocol message
@@ -38,7 +39,7 @@ const js_jwz_1 = require("@iden3/js-jwz");
  * @class RevocationStatusHandler
  * @implements implements IRevocationStatusHandler interface
  */
-class RevocationStatusHandler {
+class RevocationStatusHandler extends message_handler_1.AbstractMessageHandler {
     /**
      * Creates an instance of RevocationStatusHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -46,33 +47,25 @@ class RevocationStatusHandler {
      *
      */
     constructor(_packerMgr, _identityWallet) {
+        super();
         this._packerMgr = _packerMgr;
         this._identityWallet = _identityWallet;
     }
-    /**
-     * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
-     */
-    async parseRevocationStatusRequest(request) {
-        const { unpackedMessage: message } = await this._packerMgr.unpack(request);
-        const ciRequest = message;
-        if (message.type !== constants_1.PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE) {
-            throw new Error('Invalid media type');
+    handle(message, context) {
+        if (!context.did) {
+            throw new Error('DID is required');
         }
-        return ciRequest;
-    }
-    /**
-     * @inheritdoc IRevocationStatusHandler#handleRevocationStatusRequest
-     */
-    async handleRevocationStatusRequest(did, request, opts) {
-        if (!opts) {
-            opts = {
-                mediaType: constants_2.MediaType.PlainMessage
-            };
+        if (!context.mediaType) {
+            throw new Error('mediaType is required');
         }
-        if (opts.mediaType === constants_2.MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${constants_2.MediaType.SignedMessage}`);
+        switch (message.type) {
+            case constants_1.PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE:
+                return this.handleRevocationStatusRequestMessage(message, context);
+            default:
+                return super.handle(message, context);
         }
-        const rsRequest = await this.parseRevocationStatusRequest(request);
+    }
+    async handleRevocationStatusRequestMessage(rsRequest, context) {
         if (!rsRequest.to) {
             throw new Error(`failed request. empty 'to' field`);
         }
@@ -83,7 +76,7 @@ class RevocationStatusHandler {
             throw new Error(`failed request. empty 'revocation_nonce' field`);
         }
         const issuerDID = js_iden3_core_1.DID.parse(rsRequest.to);
-        const mtpWithTreeState = await this._identityWallet.generateNonRevocationMtpWithNonce(issuerDID, BigInt(rsRequest.body.revocation_nonce), opts?.treeState);
+        const mtpWithTreeState = await this._identityWallet.generateNonRevocationMtpWithNonce(issuerDID, BigInt(rsRequest.body.revocation_nonce), context.treeState);
         const treeState = mtpWithTreeState.treeState;
         const revStatus = {
             issuer: {
@@ -94,12 +87,6 @@ class RevocationStatusHandler {
             },
             mtp: mtpWithTreeState.proof
         };
-        const packerOpts = opts.mediaType === constants_2.MediaType.SignedMessage
-            ? opts.packerOptions
-            : {
-                provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
-            };
-        const senderDID = js_iden3_core_1.DID.parse(rsRequest.to);
         const guid = uuid.v4();
         const response = {
             id: guid,
@@ -107,9 +94,50 @@ class RevocationStatusHandler {
             type: constants_1.PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE,
             thid: rsRequest.thid ?? guid,
             body: revStatus,
-            from: did.string(),
+            from: context.did.string(),
             to: rsRequest.from
         };
+        return response;
+    }
+    /**
+     * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
+     */
+    async parseRevocationStatusRequest(request) {
+        const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+        const ciRequest = message;
+        if (message.type !== constants_1.PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid media type');
+        }
+        return ciRequest;
+    }
+    /**
+     * @inheritdoc IRevocationStatusHandler#handleRevocationStatusRequest
+     */
+    async handleRevocationStatusRequest(did, request, opts) {
+        if (!opts) {
+            opts = {
+                mediaType: constants_2.MediaType.PlainMessage
+            };
+        }
+        if (opts.mediaType === constants_2.MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_2.MediaType.SignedMessage}`);
+        }
+        const rsRequest = await this.parseRevocationStatusRequest(request);
+        const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
+            did,
+            mediaType: opts.mediaType,
+            packerOptions: opts.packerOptions,
+            treeState: opts.treeState
+        });
+        const packerOpts = opts.mediaType === constants_2.MediaType.SignedMessage
+            ? opts.packerOptions
+            : {
+                provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        if (!rsRequest.to) {
+            throw new Error(`failed request. empty 'to' field`);
+        }
+        const senderDID = js_iden3_core_1.DID.parse(rsRequest.to);
         return this._packerMgr.pack(opts.mediaType, utils_1.byteEncoder.encode(JSON.stringify(response)), {
             senderDID,
             ...packerOpts

package/dist/node/cjs/iden3comm/packageManager.js

@@ -32,6 +32,22 @@ class PackageManager {
         }
         return await p.pack(payload, params);
     }
+    /**
+     * Packs a protocol message using the specified media type and packer parameters.
+     *
+     * @param mediaType - The media type to use for packing the message.
+     * @param protocolMessage - The protocol message to pack.
+     * @param params - The packer parameters.
+     * @returns A promise that resolves to the packed message as a Uint8Array.
+     * @throws An error if the packer for the specified media type is not found.
+     */
+    packMessage(mediaType, protocolMessage, params) {
+        const p = this.packers.get(mediaType);
+        if (!p) {
+            throw new Error(`packer for media type ${mediaType} not found`);
+        }
+        return p.packMessage(protocolMessage, params);
+    }
     /** {@inheritDoc IPackageManager.unpack} */
     async unpack(envelope) {
         const decodedStr = utils_1.byteDecoder.decode(envelope);

package/dist/node/cjs/iden3comm/packers/jws.js

@@ -6,6 +6,7 @@ const did_1 = require("../utils/did");
 const kms_1 = require("../../kms/");
 const did_jwt_1 = require("did-jwt");
 const did_resolver_1 = require("did-resolver");
+const encoding_1 = require("../../utils/encoding");
 const utils_1 = require("../../utils");
 /**
  * Packer that can pack message to JWZ token,
@@ -26,6 +27,16 @@ class JWSPacker {
         this._kms = _kms;
         this._documentResolver = _documentResolver;
     }
+    /**
+     * Packs the given payload and returns a promise that resolves to the packed data.
+     *
+     * @param {Uint8Array} payload - The payload to be packed.
+     * @param {PackerParams} param - The packing parameters.
+     * @returns `Promise<Uint8Array>`
+     */
+    packMessage(msg, param) {
+        return this.packInternal(msg, param);
+    }
     /**
      * creates JSON Web Signature token
      *
@@ -34,56 +45,8 @@ class JWSPacker {
      * @returns `Promise<Uint8Array>`
      */
     async pack(payload, params) {
-        if (!params.alg) {
-            throw new Error('Missing algorithm');
-        }
         const message = JSON.parse(utils_1.byteDecoder.decode(payload));
-        const from = message.from ?? '';
-        if (!from) {
-            throw new Error('Missing sender DID');
-        }
-        const vmTypes = constants_1.SUPPORTED_PUBLIC_KEY_TYPES[params.alg];
-        if (!vmTypes?.length) {
-            throw new Error(`No supported verification methods for algorithm ${params.alg}`);
-        }
-        const didDocument = params.didDocument ?? (await this.resolveDidDoc(from));
-        const vms = (0, did_1.resolveVerificationMethods)(didDocument);
-        if (!vms.length) {
-            throw new Error(`No verification methods defined in the DID document of ${didDocument.id}`);
-        }
-        // try to find a managed signing key that matches keyRef
-        const vm = params.kid ? vms.find((vm) => vm.id === params.kid) : vms[0];
-        if (!vm) {
-            throw new Error(`No key found with id ${params.kid} in DID document of ${didDocument.id}`);
-        }
-        const { publicKeyBytes, kmsKeyType } = (0, did_1.extractPublicKeyBytes)(vm);
-        if (!publicKeyBytes && !kmsKeyType) {
-            if ((vm.blockchainAccountId || vm.ethereumAddress) && !params.signer) {
-                throw new Error(`No signer provided for ${vm.blockchainAccountId || vm.ethereumAddress}`);
-            }
-        }
-        const kid = vm.id;
-        const headerObj = { alg: params.alg, kid, typ: constants_1.MediaType.SignedMessage };
-        const header = (0, utils_1.encodeBase64url)(JSON.stringify(headerObj));
-        const msg = (0, utils_1.encodeBase64url)(JSON.stringify(message));
-        const signingInput = `${header}.${msg}`;
-        const signingInputBytes = utils_1.byteEncoder.encode(signingInput);
-        let signatureBase64;
-        if (params.signer) {
-            const signerFn = params.signer(vm, signingInputBytes);
-            signatureBase64 = (await signerFn(signingInput)).toString();
-        }
-        else {
-            if (!publicKeyBytes) {
-                throw new Error('No public key found');
-            }
-            if (!kmsKeyType) {
-                throw new Error('No KMS key type found');
-            }
-            const signatureBytes = await this._kms.sign({ type: kmsKeyType, id: (0, kms_1.keyPath)(kmsKeyType, (0, utils_1.bytesToHex)(publicKeyBytes)) }, signingInputBytes);
-            signatureBase64 = utils_1.byteDecoder.decode(signatureBytes);
-        }
-        return utils_1.byteEncoder.encode(`${signingInput}.${signatureBase64}`);
+        return this.packInternal(message, params);
     }
     /**
      * validate envelope which is jwz token
@@ -137,5 +100,56 @@ class JWSPacker {
         }
         return didDocument;
     }
+    async packInternal(message, params) {
+        if (!params.alg) {
+            throw new Error('Missing algorithm');
+        }
+        const from = message.from ?? '';
+        if (!from) {
+            throw new Error('Missing sender DID');
+        }
+        const vmTypes = constants_1.SUPPORTED_PUBLIC_KEY_TYPES[params.alg];
+        if (!vmTypes?.length) {
+            throw new Error(`No supported verification methods for algorithm ${params.alg}`);
+        }
+        const didDocument = params.didDocument ?? (await this.resolveDidDoc(from));
+        const vms = (0, did_1.resolveVerificationMethods)(didDocument);
+        if (!vms.length) {
+            throw new Error(`No verification methods defined in the DID document of ${didDocument.id}`);
+        }
+        // try to find a managed signing key that matches keyRef
+        const vm = params.kid ? vms.find((vm) => vm.id === params.kid) : vms[0];
+        if (!vm) {
+            throw new Error(`No key found with id ${params.kid} in DID document of ${didDocument.id}`);
+        }
+        const { publicKeyBytes, kmsKeyType } = (0, did_1.extractPublicKeyBytes)(vm);
+        if (!publicKeyBytes && !kmsKeyType) {
+            if ((vm.blockchainAccountId || vm.ethereumAddress) && !params.signer) {
+                throw new Error(`No signer provided for ${vm.blockchainAccountId || vm.ethereumAddress}`);
+            }
+        }
+        const kid = vm.id;
+        const headerObj = { alg: params.alg, kid, typ: constants_1.MediaType.SignedMessage };
+        const header = (0, utils_1.encodeBase64url)(JSON.stringify(headerObj));
+        const msg = (0, utils_1.encodeBase64url)(JSON.stringify(message));
+        const signingInput = `${header}.${msg}`;
+        const signingInputBytes = utils_1.byteEncoder.encode(signingInput);
+        let signatureBase64;
+        if (params.signer) {
+            const signature = await params.signer(vm, signingInputBytes);
+            signatureBase64 = (0, encoding_1.bytesToBase64url)(signature);
+        }
+        else {
+            if (!publicKeyBytes) {
+                throw new Error('No public key found');
+            }
+            if (!kmsKeyType) {
+                throw new Error('No KMS key type found');
+            }
+            const signatureBytes = await this._kms.sign({ type: kmsKeyType, id: (0, kms_1.keyPath)(kmsKeyType, (0, utils_1.bytesToHex)(publicKeyBytes)) }, signingInputBytes, { alg: params.alg });
+            signatureBase64 = (0, encoding_1.bytesToBase64url)(signatureBytes);
+        }
+        return utils_1.byteEncoder.encode(`${signingInput}.${signatureBase64}`);
+    }
 }
 exports.JWSPacker = JWSPacker;

package/dist/node/cjs/iden3comm/packers/plain.js

@@ -11,6 +11,18 @@ const utils_1 = require("../../utils");
  * @implements implements IPacker interface
  */
 class PlainPacker {
+    /**
+     * Packs a basic message using the specified parameters.
+     *
+     * @param msg - The basic message to pack.
+     * @param param - The packer parameters.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     * @throws An error if the method is not implemented.
+     */
+    packMessage(msg) {
+        msg.typ = constants_1.MediaType.PlainMessage;
+        return Promise.resolve(utils_1.byteEncoder.encode(JSON.stringify(msg)));
+    }
     /**
      * Pack returns packed message to transport envelope
      *
@@ -18,9 +30,7 @@ class PlainPacker {
      * @param {PlainPackerParams} _params - not used here
      * @returns `Promise<Uint8Array>`
      */
-    //
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async pack(payload, _params) {
+    async pack(payload) {
         const msg = JSON.parse(utils_1.byteDecoder.decode(payload));
         msg.typ = constants_1.MediaType.PlainMessage;
         return Promise.resolve(utils_1.byteEncoder.encode(JSON.stringify(msg)));

package/dist/node/cjs/iden3comm/packers/zkp.js

@@ -79,6 +79,15 @@ class ZKPPacker {
         this.provingParamsMap = provingParamsMap;
         this.verificationParamsMap = verificationParamsMap;
     }
+    /**
+     * Packs a basic message using the specified parameters.
+     * @param msg - The basic message to pack.
+     * @param param - The parameters for the ZKPPacker.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     */
+    packMessage(msg, param) {
+        return this.pack(utils_1.byteEncoder.encode(JSON.stringify(msg)), param);
+    }
     /**
      * creates JSON Web Zeroknowledge token
      *

package/dist/node/cjs/iden3comm/utils/did.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractPublicKeyBytes = exports.resolveVerificationMethods = void 0;
 const constants_1 = require("../constants");
-const elliptic_1 = __importDefault(require("elliptic"));
+const secp256k1_1 = require("@noble/curves/secp256k1");
 const kms_1 = require("../../kms");
 const utils_1 = require("../../utils");
 const DIDAuthenticationSection = 'authentication';
@@ -30,7 +27,6 @@ const resolveVerificationMethods = (didDocument) => {
     return sortedVerificationMethods;
 };
 exports.resolveVerificationMethods = resolveVerificationMethods;
-const secp256k1 = new elliptic_1.default.ec('secp256k1');
 const extractPublicKeyBytes = (vm) => {
     const isSupportedVmType = Object.keys(constants_1.SUPPORTED_PUBLIC_KEY_TYPES).some((key) => constants_1.SUPPORTED_PUBLIC_KEY_TYPES[key].includes(vm.type));
     if (vm.publicKeyBase58 && isSupportedVmType) {
@@ -49,13 +45,17 @@ const extractPublicKeyBytes = (vm) => {
         vm.publicKeyJwk.crv === 'secp256k1' &&
         vm.publicKeyJwk.x &&
         vm.publicKeyJwk.y) {
+        const [xHex, yHex] = [
+            (0, utils_1.base64UrlToBytes)(vm.publicKeyJwk.x),
+            (0, utils_1.base64UrlToBytes)(vm.publicKeyJwk.y)
+        ].map(utils_1.bytesToHex);
+        const x = xHex.includes('0x') ? BigInt(xHex) : BigInt(`0x${xHex}`);
+        const y = yHex.includes('0x') ? BigInt(yHex) : BigInt(`0x${yHex}`);
         return {
-            publicKeyBytes: (0, utils_1.hexToBytes)(secp256k1
-                .keyFromPublic({
-                x: (0, utils_1.bytesToHex)((0, utils_1.base64UrlToBytes)(vm.publicKeyJwk.x)),
-                y: (0, utils_1.bytesToHex)((0, utils_1.base64UrlToBytes)(vm.publicKeyJwk.y))
-            })
-                .getPublic('hex')),
+            publicKeyBytes: secp256k1_1.secp256k1.ProjectivePoint.fromAffine({
+                x,
+                y
+            }).toRawBytes(false),
             kmsKeyType: kms_1.KmsKeyType.Secp256k1
         };
     }