@docknetwork/wallet-sdk-wasm 0.4.19 → 0.4.21

package/lib/services/edv/service.js

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_edv_configs = require('./configs.js');
+var EDVHTTPStorageInterface = require('@docknetwork/universal-wallet/storage/edv-http-storage');
+var services_edv_hmac = require('./hmac.js');
+var ed25519VerificationKey2018 = require('@digitalbazaar/ed25519-verification-key-2018');
+var x25519KeyAgreementKey2020 = require('@digitalbazaar/x25519-key-agreement-key-2020');
+var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
+var logger = require('@docknetwork/wallet-sdk-data-store/src/logger');
+var services_dids_service = require('../dids/service.js');
+var keyring = require('@docknetwork/wallet-sdk-wasm/src/services/keyring');
+require('assert');
+require('base64url-universal');
+require('@docknetwork/universal-wallet/crypto');
+require('@docknetwork/wallet-sdk-dids/src');
+require('../dids/config.js');
+require('../keyring/service.js');
+require('@polkadot/keyring');
+require('@polkadot/util-crypto');
+require('../keyring/configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+require('../util-crypto/service.js');
+require('@polkadot/util');
+require('../util-crypto/configs.js');
+require('@docknetwork/sdk/utils/did');
+require('../dock/service.js');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../core/logger.js');
+require('../../modules/event-manager.js');
+require('../dock/configs.js');
+require('@docknetwork/sdk/public-keys');
+require('../../core/polkadot-utils.js');
+require('@polkadot/keyring/pair/decode');
+require('@docknetwork/sdk/utils/misc');
+require('base58-universal');
+require('base64url');
+require('../credential/utils.js');
+require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
+require('@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020');
+require('@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EDVHTTPStorageInterface__default = /*#__PURE__*/_interopDefaultLegacy(EDVHTTPStorageInterface);
+
+// @ts-nocheck
+/**
+ * EDVService
+ */
+class EDVService {
+    storageInterface;
+    insertQueue = Promise.resolve();
+    rpcMethods = [
+        EDVService.prototype.generateKeys,
+        EDVService.prototype.initialize,
+        EDVService.prototype.find,
+        EDVService.prototype.update,
+        EDVService.prototype.insert,
+        EDVService.prototype.delete,
+    ];
+    constructor() {
+        this.name = services_edv_configs.serviceName;
+    }
+    async initialize({ hmacKey, agreementKey, verificationKey, edvUrl, authKey, }) {
+        const hmac = await services_edv_hmac.create({
+            key: hmacKey,
+        });
+        const keyAgreementKey = await x25519KeyAgreementKey2020.X25519KeyAgreementKey2020.from(agreementKey);
+        const keys = {
+            keyAgreementKey,
+            hmac,
+        };
+        const { controller } = verificationKey;
+        const invocationSigner = keypairs.getKeypairFromDoc(verificationKey);
+        invocationSigner.sign = invocationSigner.signer().sign;
+        this.storageInterface = new EDVHTTPStorageInterface__default["default"]({
+            url: edvUrl,
+            keys,
+            invocationSigner,
+            defaultHeaders: {
+                DockAuth: authKey,
+            },
+        });
+        let edvId;
+        try {
+            console.log('Creating EDV with controller:', controller);
+            edvId = await this.storageInterface.createEdv({
+                sequence: 0,
+                controller,
+            });
+        }
+        catch (e) {
+            const existingConfig = await this.storageInterface.findConfigFor(controller);
+            edvId = existingConfig && existingConfig.id;
+            if (!edvId) {
+                logger.logger.error('Unable to create or find primary EDV:');
+                throw e;
+            }
+        }
+        logger.logger.log(`EDV found/created: ${edvId} - connecting to it`);
+        this.storageInterface.connectTo(edvId);
+        await this.storageInterface.client.ensureIndex({
+            attribute: 'content.id',
+            unique: true,
+        });
+        await this.storageInterface.client.ensureIndex({
+            attribute: 'content.type',
+        });
+    }
+    async generateKeys() {
+        await keyring.keyringService.initialize({
+            ss58Format: 22,
+        });
+        const keyPair = await services_dids_service.didService.generateKeyDoc({});
+        const verificationKey = await ed25519VerificationKey2018.Ed25519VerificationKey2018.generate({
+            controller: keyPair.controller,
+            id: keyPair.id,
+        });
+        const agreementKey = await x25519KeyAgreementKey2020.X25519KeyAgreementKey2020.generate({
+            controller: keyPair.controller,
+        });
+        const hmacKey = await services_edv_hmac.exportKey(await services_edv_hmac.generateKey());
+        return { verificationKey, agreementKey, hmacKey };
+    }
+    find(params) {
+        return this.storageInterface.find(params);
+    }
+    update(params) {
+        return this.storageInterface.update(params);
+    }
+    insert(params) {
+        this.insertQueue = this.insertQueue.then(() => {
+            return this.storageInterface.insert(params).catch(error => {
+                logger.logger.error('Insert failed:', error);
+                throw error;
+            });
+        });
+        return this.insertQueue;
+    }
+    delete(params) {
+        return this.storageInterface.delete(params);
+    }
+}
+const edvService = new EDVService();
+
+exports.EDVService = EDVService;
+exports.edvService = edvService;

package/lib/services/edv/service.mjs

@@ -0,0 +1,145 @@
+import { serviceName } from './configs.mjs';
+import EDVHTTPStorageInterface from '@docknetwork/universal-wallet/storage/edv-http-storage';
+import HMAC from './hmac.mjs';
+import { Ed25519VerificationKey2018 } from '@digitalbazaar/ed25519-verification-key-2018';
+import { X25519KeyAgreementKey2020 } from '@digitalbazaar/x25519-key-agreement-key-2020';
+import { getKeypairFromDoc } from '@docknetwork/universal-wallet/methods/keypairs';
+import { logger } from '@docknetwork/wallet-sdk-data-store/src/logger';
+import { didService } from '../dids/service.mjs';
+import { keyringService } from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
+import 'assert';
+import 'base64url-universal';
+import '@docknetwork/universal-wallet/crypto';
+import '@docknetwork/wallet-sdk-dids/src';
+import '../dids/config.mjs';
+import '../keyring/service.mjs';
+import '@polkadot/keyring';
+import '@polkadot/util-crypto';
+import '../keyring/configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+import '../util-crypto/service.mjs';
+import '@polkadot/util';
+import '../util-crypto/configs.mjs';
+import '@docknetwork/sdk/utils/did';
+import '../dock/service.mjs';
+import '@docknetwork/sdk';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../../core/logger.mjs';
+import '../../modules/event-manager.mjs';
+import '../dock/configs.mjs';
+import '@docknetwork/sdk/public-keys';
+import '../../core/polkadot-utils.mjs';
+import '@polkadot/keyring/pair/decode';
+import '@docknetwork/sdk/utils/misc';
+import 'base58-universal';
+import 'base64url';
+import '../credential/utils.mjs';
+import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+import '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
+
+// @ts-nocheck
+/**
+ * EDVService
+ */
+class EDVService {
+    storageInterface;
+    insertQueue = Promise.resolve();
+    rpcMethods = [
+        EDVService.prototype.generateKeys,
+        EDVService.prototype.initialize,
+        EDVService.prototype.find,
+        EDVService.prototype.update,
+        EDVService.prototype.insert,
+        EDVService.prototype.delete,
+    ];
+    constructor() {
+        this.name = serviceName;
+    }
+    async initialize({ hmacKey, agreementKey, verificationKey, edvUrl, authKey, }) {
+        const hmac = await HMAC.create({
+            key: hmacKey,
+        });
+        const keyAgreementKey = await X25519KeyAgreementKey2020.from(agreementKey);
+        const keys = {
+            keyAgreementKey,
+            hmac,
+        };
+        const { controller } = verificationKey;
+        const invocationSigner = getKeypairFromDoc(verificationKey);
+        invocationSigner.sign = invocationSigner.signer().sign;
+        this.storageInterface = new EDVHTTPStorageInterface({
+            url: edvUrl,
+            keys,
+            invocationSigner,
+            defaultHeaders: {
+                DockAuth: authKey,
+            },
+        });
+        let edvId;
+        try {
+            console.log('Creating EDV with controller:', controller);
+            edvId = await this.storageInterface.createEdv({
+                sequence: 0,
+                controller,
+            });
+        }
+        catch (e) {
+            const existingConfig = await this.storageInterface.findConfigFor(controller);
+            edvId = existingConfig && existingConfig.id;
+            if (!edvId) {
+                logger.error('Unable to create or find primary EDV:');
+                throw e;
+            }
+        }
+        logger.log(`EDV found/created: ${edvId} - connecting to it`);
+        this.storageInterface.connectTo(edvId);
+        await this.storageInterface.client.ensureIndex({
+            attribute: 'content.id',
+            unique: true,
+        });
+        await this.storageInterface.client.ensureIndex({
+            attribute: 'content.type',
+        });
+    }
+    async generateKeys() {
+        await keyringService.initialize({
+            ss58Format: 22,
+        });
+        const keyPair = await didService.generateKeyDoc({});
+        const verificationKey = await Ed25519VerificationKey2018.generate({
+            controller: keyPair.controller,
+            id: keyPair.id,
+        });
+        const agreementKey = await X25519KeyAgreementKey2020.generate({
+            controller: keyPair.controller,
+        });
+        const hmacKey = await HMAC.exportKey(await HMAC.generateKey());
+        return { verificationKey, agreementKey, hmacKey };
+    }
+    find(params) {
+        return this.storageInterface.find(params);
+    }
+    update(params) {
+        return this.storageInterface.update(params);
+    }
+    insert(params) {
+        this.insertQueue = this.insertQueue.then(() => {
+            return this.storageInterface.insert(params).catch(error => {
+                logger.error('Insert failed:', error);
+                throw error;
+            });
+        });
+        return this.insertQueue;
+    }
+    delete(params) {
+        return this.storageInterface.delete(params);
+    }
+}
+const edvService = new EDVService();
+
+export { EDVService, edvService };

package/lib/services/index.js

@@ -12,6 +12,7 @@ var services_credential_service = require('./credential/service.js');
 var services_relayService_service = require('./relay-service/service.js');
 var services_pex_service = require('./pex/service.js');
 var services_trustRegistry_service = require('./trust-registry/service.js');
+var services_edv_service = require('./edv/service.js');
 require('@polkadot/keyring');
 require('@polkadot/util-crypto');
 require('./keyring/configs.js');
@@ -51,19 +52,23 @@ require('@polkadot/keyring/pair/decode');
 require('@docknetwork/sdk/utils/misc');
 require('base58-universal');
 require('@docknetwork/universal-wallet/methods/keypairs');
+require('base64url');
+require('./credential/utils.js');
+require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
+require('@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020');
+require('@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019');
 require('./credential/config.js');
 require('@docknetwork/crypto-wasm-ts');
+require('@sphereon/oid4vci-client');
+require('@sphereon/oid4vci-common');
 require('@docknetwork/sdk/verifiable-credential');
 require('@docknetwork/sdk/utils/vc/helpers');
 require('@docknetwork/sdk/verifiable-presentation');
 require('@docknetwork/sdk/presentation');
 require('@docknetwork/sdk/utils/vc/credentials');
 require('@sphereon/pex');
-require('./credential/utils.js');
-require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
 require('./credential/bound-check.js');
 require('@docknetwork/crypto-wasm-ts/lib/legosnark');
-require('base64url');
 require('./credential/pex-helpers.js');
 require('@astronautlabs/jsonpath');
 require('./credential/bbs-revocation.js');
@@ -73,6 +78,15 @@ require('./pex/config.js');
 require('./trust-registry/configs.js');
 require('@docknetwork/sdk/utils/did/typed-did/helpers');
 require('crypto');
+require('./edv/configs.js');
+require('@docknetwork/universal-wallet/storage/edv-http-storage');
+require('./edv/hmac.js');
+require('base64url-universal');
+require('@docknetwork/universal-wallet/crypto');
+require('@digitalbazaar/ed25519-verification-key-2018');
+require('@digitalbazaar/x25519-key-agreement-key-2020');
+require('@docknetwork/wallet-sdk-data-store/src/logger');
+require('@docknetwork/wallet-sdk-wasm/src/services/keyring');
 
 var services = [
   services_keyring_service.keyringService,
@@ -87,6 +101,7 @@ var services = [
   services_relayService_service.relayService,
   services_pex_service.pexService,
   services_trustRegistry_service.trustRegistryService,
+  services_edv_service.edvService,
 ];
 
 module.exports = services;

package/lib/services/index.mjs

@@ -10,6 +10,7 @@ import { credentialService } from './credential/service.mjs';
 import { relayService } from './relay-service/service.mjs';
 import { pexService } from './pex/service.mjs';
 import { trustRegistryService } from './trust-registry/service.mjs';
+import { edvService } from './edv/service.mjs';
 import '@polkadot/keyring';
 import '@polkadot/util-crypto';
 import './keyring/configs.mjs';
@@ -49,19 +50,23 @@ import '@polkadot/keyring/pair/decode';
 import '@docknetwork/sdk/utils/misc';
 import 'base58-universal';
 import '@docknetwork/universal-wallet/methods/keypairs';
+import 'base64url';
+import './credential/utils.mjs';
+import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+import '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
 import './credential/config.mjs';
 import '@docknetwork/crypto-wasm-ts';
+import '@sphereon/oid4vci-client';
+import '@sphereon/oid4vci-common';
 import '@docknetwork/sdk/verifiable-credential';
 import '@docknetwork/sdk/utils/vc/helpers';
 import '@docknetwork/sdk/verifiable-presentation';
 import '@docknetwork/sdk/presentation';
 import '@docknetwork/sdk/utils/vc/credentials';
 import '@sphereon/pex';
-import './credential/utils.mjs';
-import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
 import './credential/bound-check.mjs';
 import '@docknetwork/crypto-wasm-ts/lib/legosnark';
-import 'base64url';
 import './credential/pex-helpers.mjs';
 import '@astronautlabs/jsonpath';
 import './credential/bbs-revocation.mjs';
@@ -71,6 +76,15 @@ import './pex/config.mjs';
 import './trust-registry/configs.mjs';
 import '@docknetwork/sdk/utils/did/typed-did/helpers';
 import 'crypto';
+import './edv/configs.mjs';
+import '@docknetwork/universal-wallet/storage/edv-http-storage';
+import './edv/hmac.mjs';
+import 'base64url-universal';
+import '@docknetwork/universal-wallet/crypto';
+import '@digitalbazaar/ed25519-verification-key-2018';
+import '@digitalbazaar/x25519-key-agreement-key-2020';
+import '@docknetwork/wallet-sdk-data-store/src/logger';
+import '@docknetwork/wallet-sdk-wasm/src/services/keyring';
 
 var services = [
   keyringService,
@@ -85,6 +99,7 @@ var services = [
   relayService,
   pexService,
   trustRegistryService,
+  edvService,
 ];
 
 export { services as default };

package/lib/services/pex/service-rpc.js

@@ -26,6 +26,10 @@ class PEXServiceRPC extends services_rpcServiceClient.RpcService {
     services_pex_config.validation.evaluatePresentation(params);
     return this.call('evaluatePresentation', params);
   }
+
+  async presentationFrom(params                          ) {
+    return this.call('presentationFrom', params);
+  }
 }
 
 exports.PEXServiceRPC = PEXServiceRPC;

package/lib/services/pex/service-rpc.mjs

@@ -22,6 +22,10 @@ class PEXServiceRPC extends RpcService {
     validation.evaluatePresentation(params);
     return this.call('evaluatePresentation', params);
   }
+
+  async presentationFrom(params                          ) {
+    return this.call('presentationFrom', params);
+  }
 }
 
 export { PEXServiceRPC };

package/lib/services/pex/service.js

@@ -17,11 +17,34 @@ const pex = new pex$1.PEX();
  **/
 function removeOptionalAttribute(presentationDefinition) {
     presentationDefinition.input_descriptors.forEach(inputDescriptor => {
-        if (inputDescriptor.constraints && inputDescriptor.constraints.fields) {
-            inputDescriptor.constraints.fields =
-                inputDescriptor.constraints.fields.filter(field => field.optional === undefined);
+        if (!inputDescriptor.constraints?.fields?.length) {
+            return;
+        }
+        // Filter the optional fields
+        // If we include those fields, it might exclude few credentials from the resulsts
+        // e.g: Expiration date as optional, a credenntial without expiration date should be included
+        inputDescriptor.constraints.fields =
+            inputDescriptor.constraints.fields.filter(field => field.optional !== true);
+        // Removes the optinal attributes from the fields
+        // It applies in case optional: false
+        // The field is required, but pex doesn't support the attribute
+        inputDescriptor.constraints.fields.forEach(field => {
+            if (field.optional !== undefined) {
+                delete field.optional;
+            }
+        });
+        // There is a case where ALL fields are optional
+        // If we remove all fields, it will cause an error with PEX
+        // So, we add a placeholder field to avoid the error
+        if (inputDescriptor.constraints.fields.length === 0) {
+            inputDescriptor.constraints.fields.push({
+                path: ['$.id'],
+            });
         }
     });
+    if (!presentationDefinition.id) {
+        presentationDefinition.id = 'id';
+    }
     return presentationDefinition;
 }
 class PEXService {
@@ -32,6 +55,7 @@ class PEXService {
     rpcMethods = [
         PEXService.prototype.filterCredentials,
         PEXService.prototype.evaluatePresentation,
+        PEXService.prototype.presentationFrom,
     ];
     filterCredentials(params) {
         services_pex_config.validation.filterCredentials(params);
@@ -45,6 +69,11 @@ class PEXService {
         const result = pex.evaluatePresentation(removeOptionalAttribute(presentationDefinition), presentation);
         return result;
     }
+    presentationFrom(params) {
+        const { credentials, presentationDefinition, holderDID } = params;
+        const result = pex.presentationFrom(removeOptionalAttribute(presentationDefinition), credentials, holderDID);
+        return result;
+    }
 }
 const pexService = new PEXService();
 

package/lib/services/pex/service.mjs

@@ -13,11 +13,34 @@ const pex = new PEX();
  **/
 function removeOptionalAttribute(presentationDefinition) {
     presentationDefinition.input_descriptors.forEach(inputDescriptor => {
-        if (inputDescriptor.constraints && inputDescriptor.constraints.fields) {
-            inputDescriptor.constraints.fields =
-                inputDescriptor.constraints.fields.filter(field => field.optional === undefined);
+        if (!inputDescriptor.constraints?.fields?.length) {
+            return;
+        }
+        // Filter the optional fields
+        // If we include those fields, it might exclude few credentials from the resulsts
+        // e.g: Expiration date as optional, a credenntial without expiration date should be included
+        inputDescriptor.constraints.fields =
+            inputDescriptor.constraints.fields.filter(field => field.optional !== true);
+        // Removes the optinal attributes from the fields
+        // It applies in case optional: false
+        // The field is required, but pex doesn't support the attribute
+        inputDescriptor.constraints.fields.forEach(field => {
+            if (field.optional !== undefined) {
+                delete field.optional;
+            }
+        });
+        // There is a case where ALL fields are optional
+        // If we remove all fields, it will cause an error with PEX
+        // So, we add a placeholder field to avoid the error
+        if (inputDescriptor.constraints.fields.length === 0) {
+            inputDescriptor.constraints.fields.push({
+                path: ['$.id'],
+            });
         }
     });
+    if (!presentationDefinition.id) {
+        presentationDefinition.id = 'id';
+    }
     return presentationDefinition;
 }
 class PEXService {
@@ -28,6 +51,7 @@ class PEXService {
     rpcMethods = [
         PEXService.prototype.filterCredentials,
         PEXService.prototype.evaluatePresentation,
+        PEXService.prototype.presentationFrom,
     ];
     filterCredentials(params) {
         validation.filterCredentials(params);
@@ -41,6 +65,11 @@ class PEXService {
         const result = pex.evaluatePresentation(removeOptionalAttribute(presentationDefinition), presentation);
         return result;
     }
+    presentationFrom(params) {
+        const { credentials, presentationDefinition, holderDID } = params;
+        const result = pex.presentationFrom(removeOptionalAttribute(presentationDefinition), credentials, holderDID);
+        return result;
+    }
 }
 const pexService = new PEXService();
 

package/lib/services/relay-service/configs.js

@@ -27,6 +27,10 @@ const validation = {
         assert__default["default"](!!keyPairDocs, 'keyPairDoc is required');
         assert__default["default"](!!message, 'message is required');
     },
+    ackMessages({ did, messageIds }) {
+        assert__default["default"](!!did, 'did is required');
+        assert__default["default"](!!messageIds, 'messageIds is required');
+    },
     registerDIDPushNotification({ keyPairDocs, token, }) {
         assert__default["default"](!!keyPairDocs, 'keyPairDoc is required');
         assert__default["default"](!!token, 'token is required');

package/lib/services/relay-service/configs.mjs

@@ -19,6 +19,10 @@ const validation = {
         assert(!!keyPairDocs, 'keyPairDoc is required');
         assert(!!message, 'message is required');
     },
+    ackMessages({ did, messageIds }) {
+        assert(!!did, 'did is required');
+        assert(!!messageIds, 'messageIds is required');
+    },
     registerDIDPushNotification({ keyPairDocs, token, }) {
         assert(!!keyPairDocs, 'keyPairDoc is required');
         assert(!!token, 'token is required');

package/lib/services/relay-service/service-rpc.js

@@ -40,6 +40,9 @@ class RelayServiceRpc extends services_rpcServiceClient.RpcService {
         services_relayService_configs.validation.signJwt(params);
         return this.call('signJwt', params);
     }
+    ackMessages(params) {
+        return this.call('ackMessages', params);
+    }
 }
 
 exports.RelayServiceRpc = RelayServiceRpc;

package/lib/services/relay-service/service-rpc.mjs

@@ -36,6 +36,9 @@ class RelayServiceRpc extends RpcService {
         validation.signJwt(params);
         return this.call('signJwt', params);
     }
+    ackMessages(params) {
+        return this.call('ackMessages', params);
+    }
 }
 
 export { RelayServiceRpc };

package/lib/services/relay-service/service.js

@@ -15,10 +15,11 @@ require('../../types.js');
 class RelayService {
     name;
     rpcMethods = [
+        RelayService.prototype.ackMessages,
         RelayService.prototype.getMessages,
-        RelayService.prototype.sendMessage,
         RelayService.prototype.registerDIDPushNotification,
         RelayService.prototype.resolveDidcommMessage,
+        RelayService.prototype.sendMessage,
         RelayService.prototype.signJwt,
     ];
     constructor() {
@@ -28,6 +29,9 @@ class RelayService {
         services_relayService_configs.validation.sendMessage(params);
         return src.RelayService.sendMessage(params);
     }
+    ackMessages(params) {
+        return src.RelayService.ackMessages(params);
+    }
     resolveDidcommMessage(params) {
         services_relayService_configs.validation.resolveDidcommMessage(params);
         return src.RelayService.resolveDidcommMessage(params);

package/lib/services/relay-service/service.mjs

@@ -12,10 +12,11 @@ import '../../types.mjs';
 class RelayService {
     name;
     rpcMethods = [
+        RelayService.prototype.ackMessages,
         RelayService.prototype.getMessages,
-        RelayService.prototype.sendMessage,
         RelayService.prototype.registerDIDPushNotification,
         RelayService.prototype.resolveDidcommMessage,
+        RelayService.prototype.sendMessage,
         RelayService.prototype.signJwt,
     ];
     constructor() {
@@ -25,6 +26,9 @@ class RelayService {
         validation.sendMessage(params);
         return RelayService$1.sendMessage(params);
     }
+    ackMessages(params) {
+        return RelayService$1.ackMessages(params);
+    }
     resolveDidcommMessage(params) {
         validation.resolveDidcommMessage(params);
         return RelayService$1.resolveDidcommMessage(params);