@0xpolygonid/js-sdk 1.10.4 → 1.11.0

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

@@ -6,6 +6,7 @@ import { byteDecoder, byteEncoder } from '../../utils';
 import { proving } from '@iden3/js-jwz';
 import { DID } from '@iden3/js-iden3-core';
 import * as uuid from 'uuid';
+import { AbstractMessageHandler } from './message-handler';
 /**
  *
  * Allows to handle Credential offer protocol message and return fetched credential
@@ -15,41 +16,43 @@ import * as uuid from 'uuid';
  * @class FetchHandler
  * @implements implements IFetchHandler interface
  */
-export class FetchHandler {
+export class FetchHandler extends AbstractMessageHandler {
     /**
-     * Creates an instance of FetchHandler.
-     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * Constructs a new instance of the FetchHandler class.
+     *
+     * @param _packerMgr The package manager used for packing and unpacking data.
+     * @param opts Optional configuration options for the FetchHandler.
+     * @param opts.credentialWallet The credential wallet used for managing credentials.
      */
     constructor(_packerMgr, opts) {
+        super();
         this._packerMgr = _packerMgr;
         this.opts = opts;
     }
-    /**
-     * Handles only messages with credentials/1.0/offer type
-     *
-     * @param {
-     *     offer: Uint8Array; offer - raw offer message
-     *     opts
-     *   }) options how to fetch credential
-     * @returns `Promise<W3CCredential[]>`
-     */
-    async handleCredentialOffer(offer, opts) {
-        if (!opts) {
-            opts = {
-                mediaType: MediaType.ZKPMessage
-            };
+    async handle(message, ctx) {
+        switch (message.type) {
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE:
+                await this.handleOfferMessage(message, ctx);
+                return null;
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE:
+                return this.handleFetchRequest(message);
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
+                return this.handleIssuanceResponseMsg(message);
+            default:
+                return super.handle(message, ctx);
         }
-        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+    }
+    async handleOfferMessage(offerMessage, ctx) {
+        if (!ctx.mediaType) {
+            ctx.mediaType = MediaType.ZKPMessage;
         }
-        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];
             const guid = uuid.v4();
             const fetchRequest = {
                 id: guid,
-                typ: opts.mediaType,
+                typ: ctx.mediaType,
                 type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE,
                 thid: offerMessage.thid ?? guid,
                 body: {
@@ -59,13 +62,13 @@ export class FetchHandler {
                 to: offerMessage.from
             };
             const msgBytes = byteEncoder.encode(JSON.stringify(fetchRequest));
-            const packerOpts = opts.mediaType === MediaType.SignedMessage
-                ? opts.packerOptions
+            const packerOpts = ctx.mediaType === MediaType.SignedMessage
+                ? ctx.packerOptions
                 : {
                     provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
                 };
             const senderDID = DID.parse(offerMessage.to);
-            const token = byteDecoder.decode(await this._packerMgr.pack(opts.mediaType, msgBytes, {
+            const token = byteDecoder.decode(await this._packerMgr.pack(ctx.mediaType, msgBytes, {
                 senderDID,
                 ...packerOpts
             }));
@@ -78,7 +81,7 @@ export class FetchHandler {
                     method: 'post',
                     headers: {
                         'Content-Type': 'application/x-www-form-urlencoded',
-                        ...(opts.headers ?? {})
+                        ...ctx.headers
                     },
                     body: token
                 });
@@ -95,10 +98,26 @@ export class FetchHandler {
         return credentials;
     }
     /**
-     * @inheritdoc IFetchHandler#handleCredentialFetchRequest
+     * Handles only messages with credentials/1.0/offer type
+     *
+     * @param {
+     *     offer: Uint8Array; offer - raw offer message
+     *     opts
+     *   }) options how to fetch credential
+     * @returns `Promise<W3CCredential[]>`
      */
-    async handleCredentialFetchRequest(envelope) {
-        const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+    async handleCredentialOffer(offer, opts) {
+        if (opts?.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+        }
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
+        return this.handleOfferMessage(offerMessage, {
+            mediaType: opts?.mediaType,
+            headers: opts?.headers,
+            packerOptions: opts?.packerOptions
+        });
+    }
+    async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
             throw new Error("failed request. empty 'to' field");
         }
@@ -122,7 +141,7 @@ export class FetchHandler {
         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({
+        return {
             id: uuid.v4(),
             type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE,
             typ: msgRequest.typ ?? MediaType.PlainMessage,
@@ -130,13 +149,17 @@ export class FetchHandler {
             body: { credential: cred },
             from: msgRequest.to,
             to: msgRequest.from
-        })), {});
+        };
     }
     /**
-     * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
+     * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
-    async handleIssuanceResponseMessage(envelop) {
-        const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+    async handleCredentialFetchRequest(envelope) {
+        const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+        const request = await this.handleFetchRequest(msgRequest);
+        return this._packerMgr.pack(MediaType.PlainMessage, byteEncoder.encode(JSON.stringify(request)), {});
+    }
+    async handleIssuanceResponseMsg(issuanceMsg) {
         if (!this.opts?.credentialWallet) {
             throw new Error('please provide credential wallet in options');
         }
@@ -144,7 +167,15 @@ export class FetchHandler {
             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([]));
+        return null;
+    }
+    /**
+     * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
+     */
+    async handleIssuanceResponseMessage(envelop) {
+        const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+        await this.handleIssuanceResponseMsg(issuanceMsg);
+        return Uint8Array.from([]);
     }
     /**
      * @inheritdoc IFetchHandler#unpackMessage

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

@@ -5,3 +5,4 @@ export * from './refresh';
 export * from './revocation-status';
 export * from './common';
 export * from './credential-proposal';
+export * from './message-handler';

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

@@ -0,0 +1,91 @@
+/**
+ * Base implementation of protocol message handler
+ *
+ * @export
+ * @abstract
+ * @class AbstractMessageHandler
+ * @implements {IProtocolMessageHandler}
+ */
+export 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');
+    }
+}
+/**
+ * Protocol message handler entry point
+ */
+export 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;
+    }
+}

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

@@ -4,6 +4,7 @@ import { DID } from '@iden3/js-iden3-core';
 import * as uuid from 'uuid';
 import { byteEncoder } from '../../utils';
 import { proving } from '@iden3/js-jwz';
+import { AbstractMessageHandler } from './message-handler';
 /**
  *
  * Allows to process RevocationStatusRequest protocol message
@@ -12,7 +13,7 @@ import { proving } from '@iden3/js-jwz';
  * @class RevocationStatusHandler
  * @implements implements IRevocationStatusHandler interface
  */
-export class RevocationStatusHandler {
+export class RevocationStatusHandler extends AbstractMessageHandler {
     /**
      * Creates an instance of RevocationStatusHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -20,33 +21,25 @@ export 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 !== 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: MediaType.PlainMessage
-            };
+        if (!context.mediaType) {
+            throw new Error('mediaType is required');
         }
-        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+        switch (message.type) {
+            case 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`);
         }
@@ -57,7 +50,7 @@ export class RevocationStatusHandler {
             throw new Error(`failed request. empty 'revocation_nonce' field`);
         }
         const issuerDID = 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: {
@@ -68,12 +61,6 @@ export class RevocationStatusHandler {
             },
             mtp: mtpWithTreeState.proof
         };
-        const packerOpts = opts.mediaType === MediaType.SignedMessage
-            ? opts.packerOptions
-            : {
-                provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
-            };
-        const senderDID = DID.parse(rsRequest.to);
         const guid = uuid.v4();
         const response = {
             id: guid,
@@ -81,9 +68,50 @@ export class RevocationStatusHandler {
             type: 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 !== 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: MediaType.PlainMessage
+            };
+        }
+        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${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 === MediaType.SignedMessage
+            ? opts.packerOptions
+            : {
+                provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        if (!rsRequest.to) {
+            throw new Error(`failed request. empty 'to' field`);
+        }
+        const senderDID = DID.parse(rsRequest.to);
         return this._packerMgr.pack(opts.mediaType, byteEncoder.encode(JSON.stringify(response)), {
             senderDID,
             ...packerOpts

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

@@ -29,6 +29,22 @@ export 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 = byteDecoder.decode(envelope);

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

@@ -3,6 +3,7 @@ import { extractPublicKeyBytes, resolveVerificationMethods } from '../utils/did'
 import { keyPath } from '../../kms/';
 import { verifyJWS } from 'did-jwt';
 import { parse } from 'did-resolver';
+import { bytesToBase64url } from '../../utils/encoding';
 import { byteDecoder, byteEncoder, bytesToHex, decodeBase64url, encodeBase64url } from '../../utils';
 /**
  * Packer that can pack message to JWZ token,
@@ -23,6 +24,16 @@ export 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
      *
@@ -31,56 +42,8 @@ export class JWSPacker {
      * @returns `Promise<Uint8Array>`
      */
     async pack(payload, params) {
-        if (!params.alg) {
-            throw new Error('Missing algorithm');
-        }
         const message = JSON.parse(byteDecoder.decode(payload));
-        const from = message.from ?? '';
-        if (!from) {
-            throw new Error('Missing sender DID');
-        }
-        const vmTypes = 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 = 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 } = 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: MediaType.SignedMessage };
-        const header = encodeBase64url(JSON.stringify(headerObj));
-        const msg = encodeBase64url(JSON.stringify(message));
-        const signingInput = `${header}.${msg}`;
-        const signingInputBytes = 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: keyPath(kmsKeyType, bytesToHex(publicKeyBytes)) }, signingInputBytes);
-            signatureBase64 = byteDecoder.decode(signatureBytes);
-        }
-        return byteEncoder.encode(`${signingInput}.${signatureBase64}`);
+        return this.packInternal(message, params);
     }
     /**
      * validate envelope which is jwz token
@@ -134,4 +97,55 @@ export 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 = 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 = 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 } = 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: MediaType.SignedMessage };
+        const header = encodeBase64url(JSON.stringify(headerObj));
+        const msg = encodeBase64url(JSON.stringify(message));
+        const signingInput = `${header}.${msg}`;
+        const signingInputBytes = byteEncoder.encode(signingInput);
+        let signatureBase64;
+        if (params.signer) {
+            const signature = await params.signer(vm, signingInputBytes);
+            signatureBase64 = 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: keyPath(kmsKeyType, bytesToHex(publicKeyBytes)) }, signingInputBytes, { alg: params.alg });
+            signatureBase64 = bytesToBase64url(signatureBytes);
+        }
+        return byteEncoder.encode(`${signingInput}.${signatureBase64}`);
+    }
 }

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

@@ -8,6 +8,18 @@ import { byteDecoder, byteEncoder } from '../../utils';
  * @implements implements IPacker interface
  */
 export 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 = MediaType.PlainMessage;
+        return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));
+    }
     /**
      * Pack returns packed message to transport envelope
      *
@@ -15,9 +27,7 @@ export 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(byteDecoder.decode(payload));
         msg.typ = MediaType.PlainMessage;
         return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));

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

@@ -74,6 +74,15 @@ export 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(byteEncoder.encode(JSON.stringify(msg)), param);
+    }
     /**
      * creates JSON Web Zeroknowledge token
      *

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

@@ -1,5 +1,5 @@
 import { SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
-import elliptic from 'elliptic';
+import { secp256k1 as sec } from '@noble/curves/secp256k1';
 import { KmsKeyType } from '../../kms';
 import { base58ToBytes, base64UrlToBytes, bytesToHex, hexToBytes } from '../../utils';
 const DIDAuthenticationSection = 'authentication';
@@ -23,7 +23,6 @@ export const resolveVerificationMethods = (didDocument) => {
     }
     return sortedVerificationMethods;
 };
-const secp256k1 = new elliptic.ec('secp256k1');
 export const extractPublicKeyBytes = (vm) => {
     const isSupportedVmType = Object.keys(SUPPORTED_PUBLIC_KEY_TYPES).some((key) => SUPPORTED_PUBLIC_KEY_TYPES[key].includes(vm.type));
     if (vm.publicKeyBase58 && isSupportedVmType) {
@@ -42,13 +41,17 @@ export const extractPublicKeyBytes = (vm) => {
         vm.publicKeyJwk.crv === 'secp256k1' &&
         vm.publicKeyJwk.x &&
         vm.publicKeyJwk.y) {
+        const [xHex, yHex] = [
+            base64UrlToBytes(vm.publicKeyJwk.x),
+            base64UrlToBytes(vm.publicKeyJwk.y)
+        ].map(bytesToHex);
+        const x = xHex.includes('0x') ? BigInt(xHex) : BigInt(`0x${xHex}`);
+        const y = yHex.includes('0x') ? BigInt(yHex) : BigInt(`0x${yHex}`);
         return {
-            publicKeyBytes: hexToBytes(secp256k1
-                .keyFromPublic({
-                x: bytesToHex(base64UrlToBytes(vm.publicKeyJwk.x)),
-                y: bytesToHex(base64UrlToBytes(vm.publicKeyJwk.y))
-            })
-                .getPublic('hex')),
+            publicKeyBytes: sec.ProjectivePoint.fromAffine({
+                x,
+                y
+            }).toRawBytes(false),
             kmsKeyType: KmsKeyType.Secp256k1
         };
     }