@docknetwork/wallet-sdk-wasm 0.4.19 → 0.4.22

package/lib/services/credential/service.mjs

@@ -1,10 +1,12 @@
 import { serviceName, validation } from './config.mjs';
 import { Accumulator, WitnessUpdatePublicInfo, MembershipWitness } from '@docknetwork/crypto-wasm-ts';
+import { OpenID4VCIClientV1_0_13 } from '@sphereon/oid4vci-client';
+import { Alg } from '@sphereon/oid4vci-common';
 import VerifiableCredential from '@docknetwork/sdk/verifiable-credential';
 import { getKeypairFromDoc } from '@docknetwork/universal-wallet/methods/keypairs';
 import { getSuiteFromKeyDoc } from '@docknetwork/sdk/utils/vc/helpers';
 import VerifiablePresentation from '@docknetwork/sdk/verifiable-presentation';
-import BbsPlusPresentation from '@docknetwork/sdk/presentation';
+import Presentation from '@docknetwork/sdk/presentation';
 import { verifyCredential } from '@docknetwork/sdk/utils/vc/credentials';
 import { PEX } from '@sphereon/pex';
 import { keyDocToKeypair } from './utils.mjs';
@@ -13,6 +15,7 @@ import { hasProvingKey, fetchProvingKey, applyEnforceBounds } from './bound-chec
 import assert from 'assert';
 import { getIsRevoked, getWitnessDetails } from './bbs-revocation.mjs';
 import { getPexRequiredAttributes } from './pex-helpers.mjs';
+import { didService } from '../dids/service.mjs';
 import 'base58-universal';
 import '@docknetwork/sdk/utils/misc';
 import '@polkadot/util-crypto';
@@ -28,13 +31,37 @@ import '../dock/configs.mjs';
 import '@docknetwork/crypto-wasm-ts/lib/legosnark';
 import 'base64url';
 import '@astronautlabs/jsonpath';
+import '@docknetwork/wallet-sdk-dids/src';
+import '../dids/config.mjs';
+import '../keyring/service.mjs';
+import '@polkadot/keyring';
+import '../keyring/configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+import '../util-crypto/service.mjs';
+import '../util-crypto/configs.mjs';
+import '@docknetwork/sdk/utils/did';
+import '@docknetwork/sdk/public-keys';
+import '../../core/polkadot-utils.mjs';
+import '@polkadot/keyring/pair/decode';
+import '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
 
 // @ts-nocheck
 const pex = new PEX();
 function isBBSPlusCredential(credential) {
     return ((typeof credential?.proof?.type === 'string' &&
-        (credential.proof.type.includes('BBS+SignatureDock')) ||
-        (Array.isArray(credential['@context']) && credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1))));
+        credential.proof.type.includes('BBS+SignatureDock')) ||
+        (Array.isArray(credential['@context']) &&
+            credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1)));
+}
+function isKvacCredential(credential) {
+    return (typeof credential?.proof?.type === 'string' &&
+        credential.proof.type.toLowerCase().includes('bbdt16'));
+}
+function isAnnonymousCredential(credential) {
+    return isBBSPlusCredential(credential) || isKvacCredential(credential);
 }
 class CredentialService {
     constructor() {
@@ -46,8 +73,10 @@ class CredentialService {
         CredentialService.prototype.createPresentation,
         CredentialService.prototype.verifyCredential,
         CredentialService.prototype.createBBSPresentation,
-        CredentialService.prototype.deriveVCFromBBSPresentation,
+        CredentialService.prototype.deriveVCFromPresentation,
         CredentialService.prototype.isBBSPlusCredential,
+        CredentialService.prototype.isKvacCredential,
+        CredentialService.prototype.acquireOIDCredential,
     ];
     generateCredential(params = {}) {
         validation.generateCredential(params);
@@ -82,16 +111,16 @@ class CredentialService {
         validation.createPresentation(params);
         const { credentials, keyDoc, challenge, id, domain } = params;
         const vp = new VerifiablePresentation(id);
-        let isBBS;
+        let shouldSkipSigning = false;
         for (const signedVC of credentials) {
             vp.addCredential(signedVC);
-            isBBS = isBBS || isBBSPlusCredential(signedVC);
+            shouldSkipSigning = shouldSkipSigning || isAnnonymousCredential(signedVC);
         }
-        if (!isBBS) {
+        if (!shouldSkipSigning) {
             vp.setHolder(keyDoc.controller);
         }
         keyDoc.keypair = keyDocToKeypair(keyDoc, getDock());
-        if (isBBS) {
+        if (shouldSkipSigning) {
             return vp.toJSON();
         }
         return vp.sign(keyDoc, challenge, domain, dockService.resolver);
@@ -133,10 +162,75 @@ class CredentialService {
         const { credential } = params;
         return isBBSPlusCredential(credential);
     }
+    isKvacCredential(params) {
+        const { credential } = params;
+        return isKvacCredential(credential);
+    }
+    async acquireOIDCredential({ uri, authorizationCode, holderKeyDocument, }) {
+        const searchParams = new URL(uri).searchParams;
+        const params = new URLSearchParams(searchParams);
+        const credentialOfferEncoded = params.get('credential_offer');
+        const credentialOfferDecoded = decodeURIComponent(credentialOfferEncoded);
+        const credentialOffer = JSON.parse(credentialOfferDecoded);
+        const scope = credentialOffer.credentials[0];
+        const format = 'ldp_vc';
+        const credentialTypes = scope.replace('ldp_vc:', '');
+        const client = await OpenID4VCIClientV1_0_13.fromURI({
+            uri: uri,
+            clientId: 'dock.wallet',
+            authorizationRequest: {
+                redirectUri: 'dock-wallet://credentials/callback',
+                clientId: 'dock.wallet',
+                scope: credentialOffer.credentials[0],
+            },
+        });
+        let code;
+        if (client.credentialOffer?.preAuthorizedCode) {
+            code = client.credentialOffer?.preAuthorizedCode;
+        }
+        else {
+            if (authorizationCode) {
+                code = authorizationCode;
+            }
+            else {
+                return {
+                    authorizationURL: client.authorizationURL,
+                };
+            }
+        }
+        await client.acquireAccessToken({
+            code,
+        });
+        try {
+            const response = await client.acquireCredentials({
+                credentialTypes,
+                proofCallbacks: {
+                    signCallback: async (args) => {
+                        // use service method here
+                        const jwt = await didService.createSignedJWT({
+                            payload: args.payload,
+                            privateKeyDoc: holderKeyDocument,
+                            headerInput: args.header,
+                        });
+                        return jwt;
+                    },
+                },
+                format: format,
+                alg: Alg.EdDSA,
+                kid: holderKeyDocument.id,
+            });
+            return {
+                credential: response.credential,
+            };
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
     async createBBSPresentation(params) {
         validation.createBBSPresentation(params);
         const { credentials } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation();
+        const bbsPlusPresentation = new Presentation();
         for (const { credential, attributesToReveal } of credentials) {
             const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
                 resolver: dockService.resolver,
@@ -203,21 +297,21 @@ class CredentialService {
         witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
         return witness.toJSON();
     }
-    async deriveVCFromBBSPresentation(params) {
-        validation.deriveVCFromBBSPresentation(params);
+    async deriveVCFromPresentation(params) {
+        validation.deriveVCFromPresentation(params);
         const { credentials, options = {}, proofRequest } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation();
+        const presentation = new Presentation();
         const selectedCredentials = credentials.map(({ credential }) => credential);
         let descriptorBounds = [];
         for (const { credential } of credentials) {
-            await bbsPlusPresentation.addCredentialToPresent(credential, {
+            await presentation.addCredentialToPresent(credential, {
                 resolver: dockService.resolver,
             });
         }
         if (proofRequest && hasProvingKey(proofRequest)) {
             const { provingKey, provingKeyId } = await fetchProvingKey(proofRequest);
             descriptorBounds = applyEnforceBounds({
-                builder: bbsPlusPresentation.presBuilder,
+                builder: presentation.presBuilder,
                 proofRequest,
                 provingKey,
                 provingKeyId,
@@ -230,24 +324,26 @@ class CredentialService {
         }
         let idx = 0;
         for (const { attributesToReveal, witness, credential } of credentials) {
-            const attributesToSkip = descriptorBounds[idx] ? descriptorBounds[idx].map((bound) => bound.attributeName) : [];
-            const filteredAttributes = attributesToReveal.filter((attribute) => !attributesToSkip.includes(attribute));
+            const attributesToSkip = descriptorBounds[idx]
+                ? descriptorBounds[idx].map(bound => bound.attributeName)
+                : [];
+            const filteredAttributes = attributesToReveal.filter(attribute => !attributesToSkip.includes(attribute));
             const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
-            _pexRequiredAttributes.forEach((attr) => {
+            _pexRequiredAttributes.forEach(attr => {
                 if (!filteredAttributes.includes(attr)) {
                     filteredAttributes.push(attr);
                 }
             });
             if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
-                bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+                presentation.addAttributeToReveal(idx, filteredAttributes);
             }
             if (witness) {
                 const details = await getWitnessDetails(credential, witness);
-                bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+                presentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
             }
             idx++;
         }
-        const credentialsFromPresentation = await bbsPlusPresentation.deriveCredentials(options);
+        const credentialsFromPresentation = await presentation.deriveCredentials(options);
         return credentialsFromPresentation;
     }
     async testRangeProof() {
@@ -256,4 +352,4 @@ class CredentialService {
 }
 const credentialService = new CredentialService();
 
-export { credentialService, isBBSPlusCredential };
+export { credentialService, isAnnonymousCredential, isBBSPlusCredential, isKvacCredential };

package/lib/services/dids/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var services_dids_service = require('./service.js');
-require('@docknetwork/wallet-sdk-dids/src');
+require('@docknetwork/wallet-sdk-dids/lib');
 require('./config.js');
 require('assert');
 require('../keyring/service.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

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var src = require('@docknetwork/wallet-sdk-dids/src');
+var src = require('@docknetwork/wallet-sdk-dids/lib');
 var services_dids_config = require('./config.js');
 var services_keyring_service = require('../keyring/service.js');
 var services_utilCrypto_service = require('../util-crypto/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;