@docknetwork/wallet-sdk-wasm 0.4.19 → 0.4.21

package/lib/services/dids/index.js

@@ -31,6 +31,11 @@ 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');
 
 const didServiceRPC = services_dids_service.didService;
 

package/lib/services/dids/index.mjs

@@ -27,6 +27,11 @@ 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';
 
 const didServiceRPC = didService;
 

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

@@ -32,6 +32,9 @@ class DIDServiceRPC extends services_rpcServiceClient.RpcService {
     getDidDockDocument(did) {
         return this.call('getDidDockDocument', did);
     }
+    createSignedJWT(params) {
+        return this.call('createSignedJWT', params);
+    }
 }
 
 exports.DIDServiceRPC = DIDServiceRPC;

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

@@ -28,6 +28,9 @@ class DIDServiceRPC extends RpcService {
     getDidDockDocument(did) {
         return this.call('getDidDockDocument', did);
     }
+    createSignedJWT(params) {
+        return this.call('createSignedJWT', params);
+    }
 }
 
 export { DIDServiceRPC };

package/lib/services/dids/service.js

@@ -13,6 +13,10 @@ var dock = require('@docknetwork/sdk');
 var publicKeys = require('@docknetwork/sdk/public-keys');
 var core_logger = require('../../core/logger.js');
 var core_polkadotUtils = require('../../core/polkadot-utils.js');
+var base64url = require('base64url');
+var services_credential_utils = require('../credential/utils.js');
+var Ed25519Signature2020 = require('@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020');
+var EcdsaSecp256k1Signature2019 = require('@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019');
 require('@polkadot/keyring');
 require('@polkadot/util-crypto');
 require('../keyring/configs.js');
@@ -30,11 +34,37 @@ require('@polkadot/keyring/pair/decode');
 require('@docknetwork/sdk/utils/misc');
 require('base58-universal');
 require('@docknetwork/universal-wallet/methods/keypairs');
+require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var base64url__default = /*#__PURE__*/_interopDefaultLegacy(base64url);
+var Ed25519Signature2020__default = /*#__PURE__*/_interopDefaultLegacy(Ed25519Signature2020);
+var EcdsaSecp256k1Signature2019__default = /*#__PURE__*/_interopDefaultLegacy(EcdsaSecp256k1Signature2019);
 
+async function getSignerKeypair(privateKeyDoc) {
+    const privateKey = privateKeyDoc.keypair || services_credential_utils.keyDocToKeypair(privateKeyDoc, services_dock_service.dockService.dock);
+    if (!privateKey.signer && privateKey.sign) {
+        privateKey.signer = () => ({ sign: ({ data }) => privateKey.sign(data) });
+    }
+    // ed25519 should use latest
+    if (privateKeyDoc.type.startsWith('Ed25519')) {
+        return new Ed25519Signature2020__default["default"]({
+            keypair: privateKey,
+            ...privateKeyDoc,
+        });
+    }
+    // HACK: for secp256k1 keyDocToKeypair returns an unusable class, wrap it in EcdsaSecp256k1Signature2019
+    // TODO: refactor so that keyDocToKeypair returns EcdsaSecp256k1Signature2019
+    if (privateKey.type === 'secp256k1') {
+        return new EcdsaSecp256k1Signature2019__default["default"]({
+            keypair: privateKey,
+            ...privateKeyDoc,
+        });
+    }
+    return privateKey;
+}
 class DIDService {
     name;
     constructor() {
@@ -46,6 +76,7 @@ class DIDService {
         DIDService.prototype.generateKeyDoc,
         DIDService.prototype.registerDidDock,
         DIDService.prototype.getDidDockDocument,
+        DIDService.prototype.createSignedJWT,
     ];
     keypairToDIDKeyDocument(params) {
         services_dids_config.validation.keypairToDIDKeyDocument(params);
@@ -75,6 +106,23 @@ class DIDService {
         }
         return core_polkadotUtils.polkadotToKeydoc(keyring, params.controller);
     }
+    async createSignedJWT({ payload, privateKeyDoc, headerInput }) {
+        const privateKey = await getSignerKeypair(privateKeyDoc);
+        const { sign } = typeof privateKey.signer === 'function'
+            ? privateKey.signer()
+            : privateKey.signer;
+        const header = {
+            alg: privateKey.alg || 'EdDSA',
+            kid: privateKeyDoc.id,
+            ...headerInput,
+        };
+        const headerBase64URL = base64url__default["default"](JSON.stringify(header));
+        const payloadBase64URL = base64url__default["default"](JSON.stringify(payload));
+        const headerAndPayloadBase64URL = `${headerBase64URL}.${payloadBase64URL}`;
+        const signPayload = Buffer.from(headerAndPayloadBase64URL);
+        const signature = await sign({ data: signPayload });
+        return `${headerAndPayloadBase64URL}.${base64url__default["default"].encode(signature)}`;
+    }
     async getDidDockDocument(did) {
         assert__default["default"](!!did, 'DID is required');
         const dock = services_dock_service.getDock();

package/lib/services/dids/service.mjs

@@ -4,11 +4,15 @@ import { keyringService } from '../keyring/service.mjs';
 import { utilCryptoService } from '../util-crypto/service.mjs';
 import assert from 'assert';
 import { createNewDockDID } from '@docknetwork/sdk/utils/did';
-import { getDock } from '../dock/service.mjs';
+import { dockService, getDock } from '../dock/service.mjs';
 import { PublicKeySr25519 } from '@docknetwork/sdk';
 import { DidKey, VerificationRelationship } from '@docknetwork/sdk/public-keys';
 import { Logger } from '../../core/logger.mjs';
 import { polkadotToKeydoc } from '../../core/polkadot-utils.mjs';
+import base64url from 'base64url';
+import { keyDocToKeypair } from '../credential/utils.mjs';
+import Ed25519Signature2020 from '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import EcdsaSecp256k1Signature2019 from '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
 import '@polkadot/keyring';
 import '@polkadot/util-crypto';
 import '../keyring/configs.mjs';
@@ -26,7 +30,30 @@ import '@polkadot/keyring/pair/decode';
 import '@docknetwork/sdk/utils/misc';
 import 'base58-universal';
 import '@docknetwork/universal-wallet/methods/keypairs';
+import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
 
+async function getSignerKeypair(privateKeyDoc) {
+    const privateKey = privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, dockService.dock);
+    if (!privateKey.signer && privateKey.sign) {
+        privateKey.signer = () => ({ sign: ({ data }) => privateKey.sign(data) });
+    }
+    // ed25519 should use latest
+    if (privateKeyDoc.type.startsWith('Ed25519')) {
+        return new Ed25519Signature2020({
+            keypair: privateKey,
+            ...privateKeyDoc,
+        });
+    }
+    // HACK: for secp256k1 keyDocToKeypair returns an unusable class, wrap it in EcdsaSecp256k1Signature2019
+    // TODO: refactor so that keyDocToKeypair returns EcdsaSecp256k1Signature2019
+    if (privateKey.type === 'secp256k1') {
+        return new EcdsaSecp256k1Signature2019({
+            keypair: privateKey,
+            ...privateKeyDoc,
+        });
+    }
+    return privateKey;
+}
 class DIDService {
     name;
     constructor() {
@@ -38,6 +65,7 @@ class DIDService {
         DIDService.prototype.generateKeyDoc,
         DIDService.prototype.registerDidDock,
         DIDService.prototype.getDidDockDocument,
+        DIDService.prototype.createSignedJWT,
     ];
     keypairToDIDKeyDocument(params) {
         validation.keypairToDIDKeyDocument(params);
@@ -67,6 +95,23 @@ class DIDService {
         }
         return polkadotToKeydoc(keyring, params.controller);
     }
+    async createSignedJWT({ payload, privateKeyDoc, headerInput }) {
+        const privateKey = await getSignerKeypair(privateKeyDoc);
+        const { sign } = typeof privateKey.signer === 'function'
+            ? privateKey.signer()
+            : privateKey.signer;
+        const header = {
+            alg: privateKey.alg || 'EdDSA',
+            kid: privateKeyDoc.id,
+            ...headerInput,
+        };
+        const headerBase64URL = base64url(JSON.stringify(header));
+        const payloadBase64URL = base64url(JSON.stringify(payload));
+        const headerAndPayloadBase64URL = `${headerBase64URL}.${payloadBase64URL}`;
+        const signPayload = Buffer.from(headerAndPayloadBase64URL);
+        const signature = await sign({ data: signPayload });
+        return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
+    }
     async getDidDockDocument(did) {
         assert(!!did, 'DID is required');
         const dock = getDock();

package/lib/services/edv/configs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+// @ts-nocheck
+const validation = {
+    initialize(params) {
+        assert__default["default"](!!params, 'params required');
+        assert__default["default"](!!params.agreementKey, 'agreementKey required');
+        assert__default["default"](!!params.hmacKey, 'hmac required');
+        assert__default["default"](!!params.verificationKey, 'verificationKey required');
+        assert__default["default"](!!params.envUrl, 'envUrl required');
+        assert__default["default"](!!params.authKey, 'authKey required');
+    },
+};
+const serviceName = 'edv';
+
+exports.serviceName = serviceName;
+exports.validation = validation;

package/lib/services/edv/configs.mjs

@@ -0,0 +1,16 @@
+import assert from 'assert';
+
+// @ts-nocheck
+const validation = {
+    initialize(params) {
+        assert(!!params, 'params required');
+        assert(!!params.agreementKey, 'agreementKey required');
+        assert(!!params.hmacKey, 'hmac required');
+        assert(!!params.verificationKey, 'verificationKey required');
+        assert(!!params.envUrl, 'envUrl required');
+        assert(!!params.authKey, 'authKey required');
+    },
+};
+const serviceName = 'edv';
+
+export { serviceName, validation };

package/lib/services/edv/hmac.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var base64url = require('base64url-universal');
+var crypto = require('@docknetwork/universal-wallet/crypto');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var base64url__namespace = /*#__PURE__*/_interopNamespace(base64url);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+
+class HMAC {
+    key;
+    id;
+    type;
+    algorithm;
+    constructor({ id, type, algorithm, key, }) {
+        this.id = id;
+        this.type = type;
+        this.algorithm = algorithm;
+        this.key = key;
+    }
+    static async generateKey() {
+        const key = await crypto__default["default"].subtle.generateKey({
+            name: 'HMAC',
+            hash: { name: 'SHA-256' },
+        }, true, ['sign', 'verify']);
+        return key;
+    }
+    static async exportKey(key) {
+        const rawKey = await crypto__default["default"].subtle.exportKey('raw', key);
+        return base64url__namespace.encode(Buffer.from(rawKey));
+    }
+    static async importKey(encodedKey) {
+        const rawKey = base64url__namespace.decode(encodedKey);
+        const key = await crypto__default["default"].subtle.importKey('raw', rawKey, { name: 'HMAC', hash: { name: 'SHA-256' } }, true, ['sign', 'verify']);
+        return key;
+    }
+    m;
+    static async create({ id = 'urn:hmac:cloud-wallet', key, }) {
+        let cryptoKey;
+        if (typeof key === 'string') {
+            cryptoKey = await HMAC.importKey(key);
+        }
+        else {
+            cryptoKey = key;
+        }
+        const type = 'Sha256HmacKey2019';
+        const algorithm = 'HS256';
+        return new HMAC({
+            id,
+            type,
+            algorithm,
+            key: cryptoKey,
+        });
+    }
+    async sign({ data }) {
+        const signature = await crypto__default["default"].subtle.sign('HMAC', this.key, data);
+        return base64url__namespace.encode(Buffer.from(signature));
+    }
+    async verify({ data, signature, }) {
+        const decodedSignature = base64url__namespace.decode(signature);
+        return crypto__default["default"].subtle.verify('HMAC', this.key, decodedSignature, data);
+    }
+}
+
+module.exports = HMAC;

package/lib/services/edv/hmac.mjs

@@ -0,0 +1,59 @@
+import * as base64url from 'base64url-universal';
+import crypto from '@docknetwork/universal-wallet/crypto';
+
+class HMAC {
+    key;
+    id;
+    type;
+    algorithm;
+    constructor({ id, type, algorithm, key, }) {
+        this.id = id;
+        this.type = type;
+        this.algorithm = algorithm;
+        this.key = key;
+    }
+    static async generateKey() {
+        const key = await crypto.subtle.generateKey({
+            name: 'HMAC',
+            hash: { name: 'SHA-256' },
+        }, true, ['sign', 'verify']);
+        return key;
+    }
+    static async exportKey(key) {
+        const rawKey = await crypto.subtle.exportKey('raw', key);
+        return base64url.encode(Buffer.from(rawKey));
+    }
+    static async importKey(encodedKey) {
+        const rawKey = base64url.decode(encodedKey);
+        const key = await crypto.subtle.importKey('raw', rawKey, { name: 'HMAC', hash: { name: 'SHA-256' } }, true, ['sign', 'verify']);
+        return key;
+    }
+    m;
+    static async create({ id = 'urn:hmac:cloud-wallet', key, }) {
+        let cryptoKey;
+        if (typeof key === 'string') {
+            cryptoKey = await HMAC.importKey(key);
+        }
+        else {
+            cryptoKey = key;
+        }
+        const type = 'Sha256HmacKey2019';
+        const algorithm = 'HS256';
+        return new HMAC({
+            id,
+            type,
+            algorithm,
+            key: cryptoKey,
+        });
+    }
+    async sign({ data }) {
+        const signature = await crypto.subtle.sign('HMAC', this.key, data);
+        return base64url.encode(Buffer.from(signature));
+    }
+    async verify({ data, signature, }) {
+        const decodedSignature = base64url.decode(signature);
+        return crypto.subtle.verify('HMAC', this.key, decodedSignature, data);
+    }
+}
+
+export { HMAC as default };

package/lib/services/edv/index.android.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_edv_serviceRpc = require('./service-rpc.js');
+require('../rpc-service-client.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+require('./configs.js');
+
+const edvService = new services_edv_serviceRpc.EDVServiceRpc();
+
+exports.edvService = edvService;

package/lib/services/edv/index.android.mjs

@@ -0,0 +1,15 @@
+import { EDVServiceRpc } from './service-rpc.mjs';
+import '../rpc-service-client.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+import './configs.mjs';
+
+const edvService = new EDVServiceRpc();
+
+export { edvService };

package/lib/services/edv/index.ios.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_edv_serviceRpc = require('./service-rpc.js');
+require('../rpc-service-client.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+require('./configs.js');
+
+const edvService = new services_edv_serviceRpc.EDVServiceRpc();
+
+exports.edvService = edvService;

package/lib/services/edv/index.ios.mjs

@@ -0,0 +1,15 @@
+import { EDVServiceRpc } from './service-rpc.mjs';
+import '../rpc-service-client.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+import './configs.mjs';
+
+const edvService = new EDVServiceRpc();
+
+export { edvService };

package/lib/services/edv/index.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_edv_service = require('./service.js');
+require('./configs.js');
+require('assert');
+require('@docknetwork/universal-wallet/storage/edv-http-storage');
+require('./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/universal-wallet/methods/keypairs');
+require('@docknetwork/wallet-sdk-data-store/src/logger');
+require('../dids/service.js');
+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');
+require('@docknetwork/wallet-sdk-wasm/src/services/keyring');
+
+
+
+exports.edvService = services_edv_service.edvService;

package/lib/services/edv/index.mjs

@@ -0,0 +1,44 @@
+export { edvService } from './service.mjs';
+import './configs.mjs';
+import 'assert';
+import '@docknetwork/universal-wallet/storage/edv-http-storage';
+import './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/universal-wallet/methods/keypairs';
+import '@docknetwork/wallet-sdk-data-store/src/logger';
+import '../dids/service.mjs';
+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';
+import '@docknetwork/wallet-sdk-wasm/src/services/keyring';

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

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_edv_configs = require('./configs.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+
+class EDVServiceRpc extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super(services_edv_configs.serviceName);
+  }
+
+  initialize(params                     ) {
+    services_edv_configs.validation.initialize(params);
+    return this.call('initialize', params);
+  }
+
+  generateKeys() {
+    return this.call('generateKeys');
+  }
+
+  find(params     ) {
+    return this.call('find', params);
+  }
+
+  update(params     ) {
+    return this.call('update', params);
+  }
+
+  insert(params     ) {
+    return this.call('insert', params);
+  }
+
+  delete(params     ) {
+    return this.call('delete', params);
+  }
+}
+
+exports.EDVServiceRpc = EDVServiceRpc;

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

@@ -0,0 +1,43 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { serviceName, validation } from './configs.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+
+class EDVServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  initialize(params                     ) {
+    validation.initialize(params);
+    return this.call('initialize', params);
+  }
+
+  generateKeys() {
+    return this.call('generateKeys');
+  }
+
+  find(params     ) {
+    return this.call('find', params);
+  }
+
+  update(params     ) {
+    return this.call('update', params);
+  }
+
+  insert(params     ) {
+    return this.call('insert', params);
+  }
+
+  delete(params     ) {
+    return this.call('delete', params);
+  }
+}
+
+export { EDVServiceRpc };