@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/dids/service.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var src = require('@docknetwork/wallet-sdk-dids/src');
+var services_dids_config = require('./config.js');
+var services_keyring_service = require('../keyring/service.js');
+var services_utilCrypto_service = require('../util-crypto/service.js');
+var assert = require('assert');
+var did = require('@docknetwork/sdk/utils/did');
+var services_dock_service = require('../dock/service.js');
+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');
+require('@polkadot/keyring');
+require('@polkadot/util-crypto');
+require('../keyring/configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+require('@polkadot/util');
+require('../util-crypto/configs.js');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../modules/event-manager.js');
+require('../dock/configs.js');
+require('@polkadot/keyring/pair/decode');
+require('@docknetwork/sdk/utils/misc');
+require('base58-universal');
+require('@docknetwork/universal-wallet/methods/keypairs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+class DIDService {
+    name;
+    constructor() {
+        this.name = services_dids_config.serviceName;
+    }
+    rpcMethods = [
+        DIDService.prototype.keypairToDIDKeyDocument,
+        DIDService.prototype.getDIDResolution,
+        DIDService.prototype.generateKeyDoc,
+        DIDService.prototype.registerDidDock,
+        DIDService.prototype.getDidDockDocument,
+    ];
+    keypairToDIDKeyDocument(params) {
+        services_dids_config.validation.keypairToDIDKeyDocument(params);
+        const { keypairDoc } = params;
+        return src.DIDKeyManager.keypairToDIDKeyDocument(keypairDoc);
+    }
+    getDIDResolution(params) {
+        services_dids_config.validation.getDIDResolution(params);
+        const { didDocument, didDocumentCustomProp = {} } = params;
+        return src.DIDKeyManager.getDIDResolution(didDocument, didDocumentCustomProp);
+    }
+    async generateKeyDoc(params) {
+        services_dids_config.validation.generateKeyDoc(params);
+        const { derivePath = '', type = 'ed25519', keyPairJSON } = params;
+        let keyring;
+        if (keyPairJSON) {
+            keyring = services_keyring_service.keyringService.keyring.addFromJson(keyPairJSON);
+            keyring.unlock('');
+        }
+        else {
+            const mnemonic = await services_utilCrypto_service.utilCryptoService.mnemonicGenerate(12);
+            keyring = services_keyring_service.keyringService.getKeyringPair({
+                mnemonic,
+                derivePath,
+                type,
+            });
+        }
+        return core_polkadotUtils.polkadotToKeydoc(keyring, params.controller);
+    }
+    async getDidDockDocument(did) {
+        assert__default["default"](!!did, 'DID is required');
+        const dock = services_dock_service.getDock();
+        const result = await dock.did.getDocument(did);
+        return result;
+    }
+    async registerDidDock(keyPairJSON) {
+        assert__default["default"](!!keyPairJSON, 'keyPair is required');
+        const dockDID = did.createNewDockDID();
+        const dock$1 = services_dock_service.getDock();
+        const keyPair = services_keyring_service.keyringService.keyring.addFromJson(keyPairJSON);
+        keyPair.unlock('');
+        dock$1.setAccount(keyPair);
+        const publicKey = dock.PublicKeySr25519.fromKeyringPair(keyPair);
+        const didKey = new publicKeys.DidKey(publicKey, new publicKeys.VerificationRelationship());
+        core_logger.Logger.info(`Submitting new DID: ${dockDID}`);
+        const result = await dock$1.did.new(dockDID, [didKey], [], false);
+        core_logger.Logger.info(`DID created with tx hash ${result.txHash.toString()}`);
+        return {
+            dockDID,
+            keyPairWalletId: keyPairJSON.address,
+        };
+    }
+}
+const didService = new DIDService();
+
+exports.didService = didService;

package/lib/services/dids/service.mjs

@@ -0,0 +1,96 @@
+import { DIDKeyManager } from '@docknetwork/wallet-sdk-dids/src';
+import { serviceName, validation } from './config.mjs';
+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 { 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 '@polkadot/keyring';
+import '@polkadot/util-crypto';
+import '../keyring/configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+import '@polkadot/util';
+import '../util-crypto/configs.mjs';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../../modules/event-manager.mjs';
+import '../dock/configs.mjs';
+import '@polkadot/keyring/pair/decode';
+import '@docknetwork/sdk/utils/misc';
+import 'base58-universal';
+import '@docknetwork/universal-wallet/methods/keypairs';
+
+class DIDService {
+    name;
+    constructor() {
+        this.name = serviceName;
+    }
+    rpcMethods = [
+        DIDService.prototype.keypairToDIDKeyDocument,
+        DIDService.prototype.getDIDResolution,
+        DIDService.prototype.generateKeyDoc,
+        DIDService.prototype.registerDidDock,
+        DIDService.prototype.getDidDockDocument,
+    ];
+    keypairToDIDKeyDocument(params) {
+        validation.keypairToDIDKeyDocument(params);
+        const { keypairDoc } = params;
+        return DIDKeyManager.keypairToDIDKeyDocument(keypairDoc);
+    }
+    getDIDResolution(params) {
+        validation.getDIDResolution(params);
+        const { didDocument, didDocumentCustomProp = {} } = params;
+        return DIDKeyManager.getDIDResolution(didDocument, didDocumentCustomProp);
+    }
+    async generateKeyDoc(params) {
+        validation.generateKeyDoc(params);
+        const { derivePath = '', type = 'ed25519', keyPairJSON } = params;
+        let keyring;
+        if (keyPairJSON) {
+            keyring = keyringService.keyring.addFromJson(keyPairJSON);
+            keyring.unlock('');
+        }
+        else {
+            const mnemonic = await utilCryptoService.mnemonicGenerate(12);
+            keyring = keyringService.getKeyringPair({
+                mnemonic,
+                derivePath,
+                type,
+            });
+        }
+        return polkadotToKeydoc(keyring, params.controller);
+    }
+    async getDidDockDocument(did) {
+        assert(!!did, 'DID is required');
+        const dock = getDock();
+        const result = await dock.did.getDocument(did);
+        return result;
+    }
+    async registerDidDock(keyPairJSON) {
+        assert(!!keyPairJSON, 'keyPair is required');
+        const dockDID = createNewDockDID();
+        const dock = getDock();
+        const keyPair = keyringService.keyring.addFromJson(keyPairJSON);
+        keyPair.unlock('');
+        dock.setAccount(keyPair);
+        const publicKey = PublicKeySr25519.fromKeyringPair(keyPair);
+        const didKey = new DidKey(publicKey, new VerificationRelationship());
+        Logger.info(`Submitting new DID: ${dockDID}`);
+        const result = await dock.did.new(dockDID, [didKey], [], false);
+        Logger.info(`DID created with tx hash ${result.txHash.toString()}`);
+        return {
+            dockDID,
+            keyPairWalletId: keyPairJSON.address,
+        };
+    }
+}
+const didService = new DIDService();
+
+export { didService };

package/lib/services/dock/configs.js

@@ -0,0 +1,18 @@
+'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 = {
+    init(params) {
+        assert__default["default"](!!params.address, `invalid substrate address ${params.address}`);
+    },
+};
+
+exports.validation = validation;

package/lib/services/dock/configs.mjs

@@ -0,0 +1,10 @@
+import assert from 'assert';
+
+// @ts-nocheck
+const validation = {
+    init(params) {
+        assert(!!params.address, `invalid substrate address ${params.address}`);
+    },
+};
+
+export { validation };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dock_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 dockService = new services_dock_serviceRpc.DockServiceRpc();
+
+exports.dockService = dockService;

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

@@ -0,0 +1,15 @@
+import { DockServiceRpc } 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 dockService = new DockServiceRpc();
+
+export { dockService };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dock_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 dockService = new services_dock_serviceRpc.DockServiceRpc();
+
+exports.dockService = dockService;

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

@@ -0,0 +1,15 @@
+import { DockServiceRpc } 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 dockService = new DockServiceRpc();
+
+export { dockService };

package/lib/services/dock/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_dock_service = require('./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('assert');
+require('./configs.js');
+
+
+
+exports.dockService = services_dock_service.dockService;

package/lib/services/dock/index.mjs

@@ -0,0 +1,9 @@
+export { dockService } from './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 'assert';
+import './configs.mjs';

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

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_dock_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 DockServiceRpc extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super('dock');
+  }
+
+  /**
+   *
+   */
+  disconnect()               {
+    return this.call('disconnect');
+  }
+
+  /**
+   *
+   */
+  ensureDockReady()               {
+    return this.call('ensureDockReady');
+  }
+
+  /**
+   *
+   */
+  init(params            )               {
+    services_dock_configs.validation.init(params);
+    return this.call('init', params);
+  }
+
+  /**
+   *
+   */
+  isApiConnected()               {
+    return this.call('isApiConnected');
+  }
+
+  getAddress()                  {
+    return this.call('getAddress');
+  }
+}
+
+exports.DockServiceRpc = DockServiceRpc;

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

@@ -0,0 +1,54 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { 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 DockServiceRpc extends RpcService {
+  constructor() {
+    super('dock');
+  }
+
+  /**
+   *
+   */
+  disconnect()               {
+    return this.call('disconnect');
+  }
+
+  /**
+   *
+   */
+  ensureDockReady()               {
+    return this.call('ensureDockReady');
+  }
+
+  /**
+   *
+   */
+  init(params            )               {
+    validation.init(params);
+    return this.call('init', params);
+  }
+
+  /**
+   *
+   */
+  isApiConnected()               {
+    return this.call('isApiConnected');
+  }
+
+  getAddress()                  {
+    return this.call('getAddress');
+  }
+}
+
+export { DockServiceRpc };

package/lib/services/dock/service.js

@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dock = require('@docknetwork/sdk');
+var resolver = require('@docknetwork/sdk/resolver');
+var index = require('@docknetwork/crypto-wasm-ts/lib/index');
+var events = require('events');
+var core_logger = require('../../core/logger.js');
+var modules_eventManager = require('../../modules/event-manager.js');
+var services_dock_configs = require('./configs.js');
+require('assert');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dock__default = /*#__PURE__*/_interopDefaultLegacy(dock);
+
+// @ts-nocheck
+let dockInstance = dock__default["default"];
+function getDock() {
+    return dockInstance;
+}
+function setDock(instance) {
+    dockInstance = instance;
+}
+// Create a resolver in order to lookup DIDs for verifying
+const universalResolverUrl = 'https://uniresolver.io';
+// class WalletSDKResolver extends WildcardMultiResolver {
+//   async resolve(did) {
+//     const trimmedDID = did.split('#')[0];
+//     const document = await super.resolve(trimmedDID);
+//     return document;
+//   }
+// }
+/**
+ *
+ */
+class DockService {
+    dock;
+    isDockReady = false;
+    resolver;
+    static Events = {
+        DOCK_READY: 'dock-ready',
+    };
+    rpcMethods = [
+        DockService.prototype.disconnect,
+        DockService.prototype.ensureDockReady,
+        DockService.prototype.init,
+        DockService.prototype.isApiConnected,
+        DockService.prototype.getAddress,
+    ];
+    constructor() {
+        this.name = 'dock';
+        this.dock = dock__default["default"];
+        this.emitter = new events.EventEmitter();
+        this.resolver = this.createDIDResolver();
+    }
+    /**
+     *
+     * @returns
+     */
+    async ensureDockReady() {
+        if (this.isDockReady) {
+            return;
+        }
+        return modules_eventManager.once(this.emitter, DockService.Events.DOCK_READY);
+    }
+    createDIDResolver() {
+        return new resolver.WildcardMultiResolver([
+            new resolver.DockResolver(getDock()),
+            new resolver.DIDKeyResolver(),
+            new resolver.UniversalResolver(universalResolverUrl),
+        ]);
+    }
+    /**
+     *
+     * @param {*} params
+     * @returns
+     */
+    async init(params) {
+        services_dock_configs.validation.init(params);
+        if (this.dock.isConnected) {
+            await this.dock.disconnect();
+        }
+        core_logger.Logger.info(`Attempt to initialized substrate at: ${params.address}`);
+        await getDock().init(params);
+        this.address = params.address;
+        this.resolver = this.createDIDResolver();
+        if (process.env.NODE_ENV !== 'test' || process.env.API_MOCK_DISABLED === 'true') {
+            await index.initializeWasm();
+        }
+        core_logger.Logger.info(`Substrate initialized at: ${params.address}`);
+        this._setDockReady(true);
+        return true;
+    }
+    /**
+     *
+     * @returns
+     */
+    async disconnect() {
+        const result = await this.dock.disconnect();
+        this._setDockReady(false);
+        return result;
+    }
+    async waitDockReady() {
+        return new Promise(resolve => {
+            if (this.isDockReady) {
+                resolve();
+            }
+            else {
+                this.emitter.once(DockService.Events.DOCK_READY, resolve);
+            }
+        });
+    }
+    /**
+     *
+     * @returns
+     */
+    async isApiConnected() {
+        return this.isDockReady;
+    }
+    async getAddress() {
+        return this.dock.address;
+    }
+    _setDockReady(isDockReady) {
+        this.isDockReady = isDockReady;
+        if (isDockReady) {
+            this.emitter.emit(DockService.Events.DOCK_READY);
+        }
+    }
+}
+const dockService = new DockService();
+
+exports.DockService = DockService;
+exports.dockService = dockService;
+exports.getDock = getDock;
+exports.setDock = setDock;
+exports.universalResolverUrl = universalResolverUrl;