@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/credential/service.mjs

@@ -0,0 +1,259 @@
+import { serviceName, validation } from './config.mjs';
+import { Accumulator, WitnessUpdatePublicInfo, MembershipWitness } from '@docknetwork/crypto-wasm-ts';
+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 { verifyCredential } from '@docknetwork/sdk/utils/vc/credentials';
+import { PEX } from '@sphereon/pex';
+import { keyDocToKeypair } from './utils.mjs';
+import { getDock, dockService } from '../dock/service.mjs';
+import { hasProvingKey, fetchProvingKey, applyEnforceBounds } from './bound-check.mjs';
+import assert from 'assert';
+import { getIsRevoked, getWitnessDetails } from './bbs-revocation.mjs';
+import { getPexRequiredAttributes } from './pex-helpers.mjs';
+import 'base58-universal';
+import '@docknetwork/sdk/utils/misc';
+import '@polkadot/util-crypto';
+import '@polkadot/util';
+import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+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/crypto-wasm-ts/lib/legosnark';
+import 'base64url';
+import '@astronautlabs/jsonpath';
+
+// @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))));
+}
+class CredentialService {
+    constructor() {
+        this.name = serviceName;
+    }
+    rpcMethods = [
+        CredentialService.prototype.generateCredential,
+        CredentialService.prototype.signCredential,
+        CredentialService.prototype.createPresentation,
+        CredentialService.prototype.verifyCredential,
+        CredentialService.prototype.createBBSPresentation,
+        CredentialService.prototype.deriveVCFromBBSPresentation,
+        CredentialService.prototype.isBBSPlusCredential,
+    ];
+    generateCredential(params = {}) {
+        validation.generateCredential(params);
+        const { subject } = params;
+        const vc = new VerifiableCredential();
+        vc.addType('DockAuthCredential');
+        vc.addContext({
+            dk: 'https://ld.dock.io/credentials#',
+            DockAuthCredential: 'dk:DockAuthCredential',
+        });
+        if (subject) {
+            vc.setSubject(subject);
+            vc.addContext({
+                state: 'dk:state',
+            });
+        }
+        return vc;
+    }
+    async signCredential(params) {
+        validation.signCredential(params);
+        const { vcJson, keyDoc } = params;
+        const verifiableCredential = new VerifiableCredential();
+        verifiableCredential.setFromJSON(vcJson);
+        const kp = getKeypairFromDoc(keyDoc);
+        kp.signer = kp.signer();
+        const suite = await getSuiteFromKeyDoc(kp);
+        verifiableCredential.setIssuer(keyDoc.controller);
+        await verifiableCredential.sign(suite);
+        return verifiableCredential;
+    }
+    async createPresentation(params) {
+        validation.createPresentation(params);
+        const { credentials, keyDoc, challenge, id, domain } = params;
+        const vp = new VerifiablePresentation(id);
+        let isBBS;
+        for (const signedVC of credentials) {
+            vp.addCredential(signedVC);
+            isBBS = isBBS || isBBSPlusCredential(signedVC);
+        }
+        if (!isBBS) {
+            vp.setHolder(keyDoc.controller);
+        }
+        keyDoc.keypair = keyDocToKeypair(keyDoc, getDock());
+        if (isBBS) {
+            return vp.toJSON();
+        }
+        return vp.sign(keyDoc, challenge, domain, dockService.resolver);
+    }
+    async verifyCredential(params) {
+        validation.verifyCredential(params);
+        const { credential, membershipWitness } = params;
+        const result = await verifyCredential(credential, {
+            resolver: dockService.resolver,
+            revocationApi: { dock: getDock() },
+        });
+        const { credentialStatus } = credential;
+        if (result.verified && credentialStatus?.id) {
+            try {
+                const isRevoked = await getIsRevoked(credential, membershipWitness);
+                if (isRevoked) {
+                    result.verified = false;
+                    result.error = 'revocation check: the credential is revoked';
+                }
+            }
+            catch (err) {
+                console.log('Unable to get revocation status');
+                console.error(err);
+            }
+        }
+        return result;
+    }
+    filterCredentials(params) {
+        const { credentials, presentationDefinition, holderDid } = params;
+        const result = pex.selectFrom(presentationDefinition, credentials, holderDid);
+        return result;
+    }
+    evaluatePresentation(params) {
+        const { presentation, presentationDefinition } = params;
+        const result = pex.evaluatePresentation(presentationDefinition, presentation);
+        return result;
+    }
+    isBBSPlusCredential(params) {
+        const { credential } = params;
+        return isBBSPlusCredential(credential);
+    }
+    async createBBSPresentation(params) {
+        validation.createBBSPresentation(params);
+        const { credentials } = params;
+        const bbsPlusPresentation = new BbsPlusPresentation();
+        for (const { credential, attributesToReveal } of credentials) {
+            const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
+                resolver: dockService.resolver,
+            });
+            if (Array.isArray(attributesToReveal) && attributesToReveal.length > 0) {
+                await bbsPlusPresentation.addAttributeToReveal(idx, attributesToReveal);
+            }
+        }
+        return bbsPlusPresentation.createPresentation();
+    }
+    getAccumulatorId({ credential }) {
+        assert(!!credential, `credential is required`);
+        if (!credential?.credentialStatus) {
+            return null;
+        }
+        return credential?.credentialStatus.id.replace('dock:accumulator:', '');
+    }
+    async getAccumulatorData({ credential }) {
+        assert(!!credential, `credential is required`);
+        const accumulatorId = await this.getAccumulatorId({ credential });
+        if (!accumulatorId) {
+            return null;
+        }
+        return getDock().accumulatorModule.getAccumulator(accumulatorId, false);
+    }
+    /**
+     * Fetch the latest accumulator witness updates for a given credential and membership witness
+     * The witness is generated by the issuer when the credential is created and is stored in the wallet when the credential is imported
+     *
+     * @param param0
+     */
+    async updateMembershipWitness({ credential, membershipWitnessJSON }) {
+        const revocationId = credential.credentialStatus.revocationId;
+        const member = Accumulator.encodePositiveNumberAsAccumulatorMember(revocationId);
+        let updates = [];
+        try {
+            updates = await dock.accumulatorModule.getUpdatesFromBlock(accumulatorId, accumulator.lastModified);
+        }
+        catch (err) {
+            if (err.code === -32000) {
+                console.error(err);
+                // "-32000: Client error: UnknownBlock: State already discarded for BlockId::Hash(<hash>)"
+                // This means that the node has discarded old blocks to preserve space. This should not happen with a full node
+                updates = [];
+            }
+            else {
+                throw err;
+            }
+        }
+        const additions = [];
+        const removals = [];
+        if (updates.length && updates[0].additions !== null) {
+            for (const a of updates[0].additions) {
+                additions.push(hexToU8a(a));
+            }
+        }
+        if (updates.length && updates[0].removals !== null) {
+            for (const a of updates[0].removals) {
+                removals.push(hexToU8a(a));
+            }
+        }
+        const queriedWitnessInfo = new WitnessUpdatePublicInfo(hexToU8a(updates[0].witnessUpdateInfo));
+        const witness = MembershipWitness.fromJSON(membershipWitnessJSON);
+        witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
+        return witness.toJSON();
+    }
+    async deriveVCFromBBSPresentation(params) {
+        validation.deriveVCFromBBSPresentation(params);
+        const { credentials, options = {}, proofRequest } = params;
+        const bbsPlusPresentation = new BbsPlusPresentation();
+        const selectedCredentials = credentials.map(({ credential }) => credential);
+        let descriptorBounds = [];
+        for (const { credential } of credentials) {
+            await bbsPlusPresentation.addCredentialToPresent(credential, {
+                resolver: dockService.resolver,
+            });
+        }
+        if (proofRequest && hasProvingKey(proofRequest)) {
+            const { provingKey, provingKeyId } = await fetchProvingKey(proofRequest);
+            descriptorBounds = applyEnforceBounds({
+                builder: bbsPlusPresentation.presBuilder,
+                proofRequest,
+                provingKey,
+                provingKeyId,
+                selectedCredentials,
+            });
+        }
+        let pexRequiredAttributes = [];
+        if (proofRequest?.request) {
+            pexRequiredAttributes = getPexRequiredAttributes(proofRequest.request, selectedCredentials);
+        }
+        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 _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
+            _pexRequiredAttributes.forEach((attr) => {
+                if (!filteredAttributes.includes(attr)) {
+                    filteredAttributes.push(attr);
+                }
+            });
+            if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
+                bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+            }
+            if (witness) {
+                const details = await getWitnessDetails(credential, witness);
+                bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+            }
+            idx++;
+        }
+        const credentialsFromPresentation = await bbsPlusPresentation.deriveCredentials(options);
+        return credentialsFromPresentation;
+    }
+    async testRangeProof() {
+        console.log('test');
+    }
+}
+const credentialService = new CredentialService();
+
+export { credentialService, isBBSPlusCredential };

package/lib/services/credential/utils.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bs58 = require('base58-universal');
+var misc = require('@docknetwork/sdk/utils/misc');
+var utilCrypto = require('@polkadot/util-crypto');
+var util = require('@polkadot/util');
+var Bls12381G2KeyPairDock2022 = require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
+
+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 bs58__namespace = /*#__PURE__*/_interopNamespace(bs58);
+var Bls12381G2KeyPairDock2022__default = /*#__PURE__*/_interopDefaultLegacy(Bls12381G2KeyPairDock2022);
+
+function createSecp256k1Keypair(privateKeyHex) {
+  const pk = privateKeyHex || utilCrypto.randomAsHex(32);
+  const kp = misc.generateEcdsaSecp256k1Keypair(pk);
+  kp.pk = pk;
+  return kp;
+}
+const docToKeyMap = {
+  Sr25519VerificationKey2020: 'sr25519',
+  Ed25519VerificationKey2018: 'ed25519',
+};
+function keyDocToKeypair(keyDoc, dock) {
+  // For now we expect multibase to just be b58, this needs fixing later if/when we support more keys
+  const {
+    type,
+    privateKeyBase58,
+    publicKeyBase58,
+    privateKeyMultibase,
+    publicKeyMultibase,
+  } = keyDoc;
+  const privateKeyEncoded = privateKeyBase58 || privateKeyMultibase.substr(1);
+  const privateKeyBytes = bs58__namespace.decode(privateKeyEncoded);
+
+  if (type === 'EcdsaSecp256k1VerificationKey2019') {
+    return createSecp256k1Keypair(util.u8aToHex(privateKeyBytes));
+  } else if (type === 'Bls12381G2VerificationKeyDock2022') {
+    return new Bls12381G2KeyPairDock2022__default["default"](keyDoc);
+  } else {
+    const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
+    const keyType = docToKeyMap[type];
+    if (!keyType) {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+
+    return dock.keyring.createFromPair(
+      {
+        publicKey: bs58__namespace.decode(publicKeyEncoded),
+        secretKey: privateKeyBytes,
+      },
+      {},
+      keyType,
+    );
+  }
+}
+
+exports.keyDocToKeypair = keyDocToKeypair;

package/lib/services/credential/utils.mjs

@@ -0,0 +1,51 @@
+import * as bs58 from 'base58-universal';
+import { generateEcdsaSecp256k1Keypair } from '@docknetwork/sdk/utils/misc';
+import { randomAsHex } from '@polkadot/util-crypto';
+import { u8aToHex } from '@polkadot/util';
+import Bls12381G2KeyPairDock2022 from '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+
+function createSecp256k1Keypair(privateKeyHex) {
+  const pk = privateKeyHex || randomAsHex(32);
+  const kp = generateEcdsaSecp256k1Keypair(pk);
+  kp.pk = pk;
+  return kp;
+}
+const docToKeyMap = {
+  Sr25519VerificationKey2020: 'sr25519',
+  Ed25519VerificationKey2018: 'ed25519',
+};
+function keyDocToKeypair(keyDoc, dock) {
+  // For now we expect multibase to just be b58, this needs fixing later if/when we support more keys
+  const {
+    type,
+    privateKeyBase58,
+    publicKeyBase58,
+    privateKeyMultibase,
+    publicKeyMultibase,
+  } = keyDoc;
+  const privateKeyEncoded = privateKeyBase58 || privateKeyMultibase.substr(1);
+  const privateKeyBytes = bs58.decode(privateKeyEncoded);
+
+  if (type === 'EcdsaSecp256k1VerificationKey2019') {
+    return createSecp256k1Keypair(u8aToHex(privateKeyBytes));
+  } else if (type === 'Bls12381G2VerificationKeyDock2022') {
+    return new Bls12381G2KeyPairDock2022(keyDoc);
+  } else {
+    const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
+    const keyType = docToKeyMap[type];
+    if (!keyType) {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+
+    return dock.keyring.createFromPair(
+      {
+        publicKey: bs58.decode(publicKeyEncoded),
+        secretKey: privateKeyBytes,
+      },
+      {},
+      keyType,
+    );
+  }
+}
+
+export { keyDocToKeypair };

package/lib/services/dids/config.js

@@ -0,0 +1,32 @@
+'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);
+
+const serviceName = 'didManager';
+const validation = {
+    keypairToDIDKeyDocument: ({ keypairDoc }) => {
+        assert__default["default"](typeof keypairDoc === 'object', 'invalid keypairDoc');
+        assert__default["default"](keypairDoc.type === 'Ed25519VerificationKey2018', 'invalid type');
+        assert__default["default"](typeof keypairDoc.publicKeyBase58 === 'string', 'publicKeyBase58 is not present');
+    },
+    getDIDResolution: ({ didDocument }) => {
+        assert__default["default"](typeof didDocument.id === 'string', 'invalid didDocument');
+    },
+    generateKeyDoc: ({ derivePath, type }) => {
+        if (derivePath) {
+            assert__default["default"](typeof derivePath === 'string', 'invalid derivePath');
+        }
+        if (type) {
+            assert__default["default"](typeof type === 'string', 'invalid type');
+        }
+    },
+};
+
+exports.serviceName = serviceName;
+exports.validation = validation;

package/lib/services/dids/config.mjs

@@ -0,0 +1,23 @@
+import assert from 'assert';
+
+const serviceName = 'didManager';
+const validation = {
+    keypairToDIDKeyDocument: ({ keypairDoc }) => {
+        assert(typeof keypairDoc === 'object', 'invalid keypairDoc');
+        assert(keypairDoc.type === 'Ed25519VerificationKey2018', 'invalid type');
+        assert(typeof keypairDoc.publicKeyBase58 === 'string', 'publicKeyBase58 is not present');
+    },
+    getDIDResolution: ({ didDocument }) => {
+        assert(typeof didDocument.id === 'string', 'invalid didDocument');
+    },
+    generateKeyDoc: ({ derivePath, type }) => {
+        if (derivePath) {
+            assert(typeof derivePath === 'string', 'invalid derivePath');
+        }
+        if (type) {
+            assert(typeof type === 'string', 'invalid type');
+        }
+    },
+};
+
+export { serviceName, validation };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dids_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('./config.js');
+
+const didServiceRPC = new services_dids_serviceRpc.DIDServiceRPC();
+
+exports.didServiceRPC = didServiceRPC;

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

@@ -0,0 +1,15 @@
+import { DIDServiceRPC } 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 './config.mjs';
+
+const didServiceRPC = new DIDServiceRPC();
+
+export { didServiceRPC };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dids_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('./config.js');
+
+const didServiceRPC = new services_dids_serviceRpc.DIDServiceRPC();
+
+exports.didServiceRPC = didServiceRPC;

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

@@ -0,0 +1,15 @@
+import { DIDServiceRPC } 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 './config.mjs';
+
+const didServiceRPC = new DIDServiceRPC();
+
+export { didServiceRPC };

package/lib/services/dids/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dids_service = require('./service.js');
+require('@docknetwork/wallet-sdk-dids/src');
+require('./config.js');
+require('assert');
+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('@docknetwork/universal-wallet/methods/keypairs');
+
+const didServiceRPC = services_dids_service.didService;
+
+exports.didServiceRPC = didServiceRPC;

package/lib/services/dids/index.mjs

@@ -0,0 +1,33 @@
+import { didService } from './service.mjs';
+import '@docknetwork/wallet-sdk-dids/src';
+import './config.mjs';
+import 'assert';
+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 '@docknetwork/universal-wallet/methods/keypairs';
+
+const didServiceRPC = didService;
+
+export { didServiceRPC };

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

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_dids_config = require('./config.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 DIDServiceRPC extends services_rpcServiceClient.RpcService {
+    constructor() {
+        super(services_dids_config.serviceName);
+    }
+    keypairToDIDKeyDocument(params) {
+        return this.call('keypairToDIDKeyDocument', params);
+    }
+    getDIDResolution(params) {
+        return this.call('getDIDResolution', params);
+    }
+    generateKeyDoc(params) {
+        return this.call('generateKeyDoc', params);
+    }
+    registerDidDock(keyPair) {
+        return this.call('registerDidDock', keyPair);
+    }
+    getDidDockDocument(did) {
+        return this.call('getDidDockDocument', did);
+    }
+}
+
+exports.DIDServiceRPC = DIDServiceRPC;

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

@@ -0,0 +1,33 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { serviceName } from './config.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 DIDServiceRPC extends RpcService {
+    constructor() {
+        super(serviceName);
+    }
+    keypairToDIDKeyDocument(params) {
+        return this.call('keypairToDIDKeyDocument', params);
+    }
+    getDIDResolution(params) {
+        return this.call('getDIDResolution', params);
+    }
+    generateKeyDoc(params) {
+        return this.call('generateKeyDoc', params);
+    }
+    registerDidDock(keyPair) {
+        return this.call('registerDidDock', keyPair);
+    }
+    getDidDockDocument(did) {
+        return this.call('getDidDockDocument', did);
+    }
+}
+
+export { DIDServiceRPC };