@docknetwork/wallet-sdk-wasm 1.4.0 → 1.5.6

package/src/services/substrate/api-utils.test.js

@@ -1,7 +1,7 @@
 import {DOCK_TOKEN_UNIT} from '../../core/format-utils';
 import {TestFixtures} from '../../fixtures';
 import {once} from '../../modules/event-manager';
-import {dockService} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 import {mockDockService, setMockTransactionError} from '../test-utils';
 import {signAndSend} from './api-utils';
 import {substrateService} from './service';
@@ -16,8 +16,8 @@ describe('ApiUtils', () => {
   describe('signAndSend', () => {
     it('expect to send tokens', async () => {
       const account = TestFixtures.account1.getKeyring();
-      dockService.dock.setAccount(account);
-      const extrinsic = dockService.dock.api.tx.balances.transfer(
+      blockchainService.dock.setAccount(account);
+      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
         TestFixtures.account2.address,
         1,
       );
@@ -32,8 +32,8 @@ describe('ApiUtils', () => {
 
     it('expect to get error: Inability to pay fees', async () => {
       const account = TestFixtures.noBalanceAccount.getKeyring();
-      dockService.dock.setAccount(account);
-      const extrinsic = dockService.dock.api.tx.balances.transfer(
+      blockchainService.dock.setAccount(account);
+      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
         TestFixtures.account2.address,
         1,
       );
@@ -49,11 +49,11 @@ describe('ApiUtils', () => {
 
     it('expect to get error: Not enough balance', async () => {
       const account = TestFixtures.account1.getKeyring();
-      dockService.dock.setAccount(account);
+      blockchainService.dock.setAccount(account);
       const balance = await substrateService.getAccountBalance({
         address: TestFixtures.account1.address,
       });
-      const extrinsic = dockService.dock.api.tx.balances.transfer(
+      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
         TestFixtures.account2.address,
         balance * 2 * DOCK_TOKEN_UNIT,
       );

package/src/services/substrate/api-utils.ts

@@ -2,10 +2,10 @@
 import assert from 'assert';
 import {EventEmitter} from 'events';
 import {Logger} from '../../core/logger';
-import {dockService} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 
 export const extrisicErrorsFilter = ({event}) => {
-  return dockService.dock.api.events.system.ExtrinsicFailed.is(event);
+  return blockchainService.dock.api.events.system.ExtrinsicFailed.is(event);
 };
 
 export const mapEventToErrorMessage = ({event}) => {
@@ -16,7 +16,7 @@ export const mapEventToErrorMessage = ({event}) => {
 
   if (error.isModule) {
     // for module errors, we have the section indexed, lookup
-    const decoded = dockService.dock.api.registry.findMetaError(error.asModule);
+    const decoded = blockchainService.dock.api.registry.findMetaError(error.asModule);
     const {docs, method, section} = decoded;
 
     return `${section}.${method}: ${docs.join(' ')}`;

package/src/services/substrate/service.ts

@@ -3,7 +3,7 @@ import assert from 'assert';
 import BigNumber from 'bignumber.js';
 import BN from 'bn.js';
 import {DOCK_TOKEN_UNIT, getPlainDockAmount} from '../../core/format-utils';
-import {dockService} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 import {signAndSend} from './api-utils';
 import {
   GetAccountBalanceParams,
@@ -36,13 +36,13 @@ export class SubstrateService {
     validation.getAccountBalance(params);
 
     console.log('ensure dock ready');
-    await dockService.ensureDockReady();
+    await blockchainService.ensureBlockchainReady();
 
     console.log('ensure dock ready done');
 
     const {
       data: {free},
-    } = await dockService.dock.api.query.system.account(params.address);
+    } = await blockchainService.dock.api.query.system.account(params.address);
 
     return free.toNumber() / DOCK_TOKEN_UNIT;
   }
@@ -58,9 +58,9 @@ export class SubstrateService {
       password: '',
     });
 
-    dockService.dock.setAccount(account);
+    blockchainService.dock.setAccount(account);
 
-    const extrinsic = dockService.dock.api.tx.balances.transfer(
+    const extrinsic = blockchainService.dock.api.tx.balances.transfer(
       toAddress,
       amount,
     );
@@ -81,7 +81,7 @@ export class SubstrateService {
       jsonData: keyPair,
       password: '',
     });
-    const {dock} = dockService;
+    const {dock} = blockchainService;
 
     dock.setAccount(account);
 

package/src/services/test-utils.js

@@ -4,11 +4,11 @@ import BigNumber from 'bignumber.js';
 import {DOCK_TOKEN_UNIT} from '../core/format-utils';
 import {TestFixtures} from '../fixtures';
 import {NetworkManager} from '../modules/network-manager';
-import {dockService, getDock, setDock} from './dock/service';
 import {keyringService} from './keyring';
 import {RpcService} from './rpc-service-client';
 import {walletService} from './wallet';
 import Keyring from '@polkadot/keyring';
+import {blockchainService} from './blockchain/service';
 
 export async function initializeWalletService() {
   await cryptoWaitReady();
@@ -50,21 +50,21 @@ export async function mockDockService() {
   let sdkMock;
 
   if (API_MOCK_DISABLED) {
-    return dockService.init({
+    return blockchainService.init({
       address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
     });
   } else {
     sdkMock = mockDockSdkConnection();
-    await dockService.init({
+    await blockchainService.init({
       address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
     });
   }
 
-  const _dockSdk = dockService.dock;
+  const _dockSdk = blockchainService.dock;
 
-  dockService.isDockReady = true;
+  blockchainService.isDockReady = true;
 
-  dockService.dock = {
+  blockchainService.dock = {
     api: {
       events: {
         system: {
@@ -125,11 +125,11 @@ export async function mockDockService() {
   };
 
   return () => {
-    dockService.dock = _dockSdk;
+    blockchainService.dock = _dockSdk;
     if (sdkMock) {
       sdkMock.clear();
     }
-    dockService.disconnect();
+    blockchainService.disconnect();
   };
 }
 
@@ -164,7 +164,7 @@ export async function setupTestWallet() {
 
 export function mockDockSdkConnection(connectionError) {
   const result = 'result';
-  const dock = getDock();
+  const dock = blockchainService.dock;
   const mocks = [
     jest.spyOn(dock, 'init').mockImplementation(() => {
       if (connectionError) {
@@ -178,7 +178,7 @@ export function mockDockSdkConnection(connectionError) {
 
   let currentAccount;
 
-  setDock({
+  blockchainService.dock = {
     ...dock,
     setAccount(account) {
       currentAccount = account;
@@ -229,7 +229,7 @@ export function mockDockSdkConnection(connectionError) {
         return kr.createFromUri('//Alice');
       }),
     },
-  });
+  };
 
   return {
     result,
@@ -255,6 +255,8 @@ export function assertRpcService(
   const rpcService = new ServiceClass();
   const validationTmp = {};
 
+  assert(rpcService.serviceName === service.name, 'service name mismatch');
+
   Object.keys(validation).forEach(key => {
     validationTmp[key] = validation[key];
     validation[key] = () => true;

package/src/services/trust-registry/index.test.js

@@ -1,4 +1,4 @@
-import {dockService} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 
 import {trustRegistryService as service} from './service';
 import {
@@ -23,7 +23,7 @@ describe('TrustRegistryService', () => {
     const result = await service.getTrustRegistries(params);
 
     const queryObject =
-      dockService.dock.trustRegistry.registriesInfo.mock.calls[0][0];
+      blockchainService.dock.trustRegistry.registriesInfo.mock.calls[0][0];
     expect(queryObject.issuers.AnyOf).toHaveLength(1);
     expect(queryObject.verifiers.AnyOf).toHaveLength(1);
     expect(queryObject.schemaIds.AnyOf[0]).toEqual(
@@ -42,10 +42,12 @@ describe('TrustRegistryService', () => {
     };
     const result = await service.getTrustRegistryVerifiers(params);
     const queryObject =
-      dockService.dock.trustRegistry.registrySchemasMetadata.mock.calls[0][0];
+      blockchainService.dock.trustRegistry.registrySchemasMetadata.mock
+        .calls[0][0];
 
     expect(
-      dockService.dock.trustRegistry.registrySchemasMetadata.mock.calls[0][1],
+      blockchainService.dock.trustRegistry.registrySchemasMetadata.mock
+        .calls[0][1],
     ).toEqual(trustRegistryId);
     expect(queryObject.issuers.AnyOf).toHaveLength(1);
     expect(queryObject.schemaIds[0]).toEqual(

package/src/services/trust-registry/service.ts

@@ -1,10 +1,16 @@
 // @ts-nocheck
 import {serviceName} from './configs';
-import {typedHexDID} from '@docknetwork/sdk/utils/did/typed-did/helpers';
 import {createHash} from 'crypto';
-import {dockService} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 import {validation} from './configs';
 
+
+// TODO: Implement this function when the Trust Registry support is added to the SDK
+function typedHexDID(resolver, issuerDID) {
+  return issuerDID;
+}
+
+// Trust Registry Service is not supported in the current version of the SDK
 class TrustRegistryService {
   constructor() {
     this.name = serviceName;
@@ -35,7 +41,7 @@ class TrustRegistryService {
     }
 
     if (issuerDID) {
-      const issuerDIDMethodKey = typedHexDID(dockService.dock.api, issuerDID);
+      const issuerDIDMethodKey = typedHexDID(blockchainService.dock.api, issuerDID);
       queryOptions.issuers = {
         AnyOf: [issuerDIDMethodKey],
       };
@@ -43,7 +49,7 @@ class TrustRegistryService {
 
     if (verifierDID) {
       const verifierDIDMethodKey = typedHexDID(
-        dockService.dock.api,
+        blockchainService.dock.api,
         verifierDID,
       );
       queryOptions.verifiers = {
@@ -51,7 +57,7 @@ class TrustRegistryService {
       };
     }
 
-    const registryInfo = await dockService.dock.trustRegistry?.registriesInfo(
+    const registryInfo = await blockchainService.dock.trustRegistry?.registriesInfo(
       queryOptions,
     );
 
@@ -65,11 +71,11 @@ class TrustRegistryService {
     const schemaIdHex = '0x' + hashedId;
 
     const issuerDIDMethodKey = issuerDID
-      ? typedHexDID(dockService.dock.api, issuerDID)
+      ? typedHexDID(blockchainService.dock.api, issuerDID)
       : null;
 
     const metadata =
-      await dockService.dock.trustRegistry.registrySchemasMetadata(
+      await blockchainService.dock.trustRegistry.registrySchemasMetadata(
         {
           schemaIds: [schemaIdHex],
           ...(issuerDIDMethodKey && {

package/src/services/util-crypto/configs.ts

@@ -17,6 +17,10 @@ export const validation = {
     }
   },
 
+  mnemonicToMiniSecret(phrase: string) {
+    assert(typeof phrase === 'string', 'invalid mnemonic phrase');
+  },
+
   mnemonicValidate(phrase: string) {
     assert(typeof phrase === 'string', 'invalid mnemonic phrase');
   },

package/src/services/util-crypto/service-rpc.js

@@ -12,6 +12,12 @@ export class UtilCryptoServiceRpc extends RpcService {
     return this.call('mnemonicGenerate', numWords);
   }
 
+  mnemonicToMiniSecret(phrase: string): Promise<any> {
+    validation.mnemonicToMiniSecret(phrase);
+
+    return this.call('mnemonicToMiniSecret', phrase);
+  }
+
   mnemonicValidate(phrase: string): Promise<any> {
     validation.mnemonicValidate(phrase);
 

package/src/services/util-crypto/service.ts

@@ -6,6 +6,7 @@ import {
   cryptoWaitReady,
   keyExtractSuri,
   mnemonicGenerate,
+  mnemonicToMiniSecret,
   mnemonicValidate,
 } from '@polkadot/util-crypto';
 import assert from 'assert';
@@ -14,6 +15,7 @@ import {validation} from './configs';
 export class UtilCryptoService {
   rpcMethods = [
     UtilCryptoService.prototype.mnemonicGenerate,
+    UtilCryptoService.prototype.mnemonicToMiniSecret,
     UtilCryptoService.prototype.mnemonicValidate,
     UtilCryptoService.prototype.cryptoWaitReady,
     UtilCryptoService.prototype.cryptoIsReady,
@@ -33,6 +35,12 @@ export class UtilCryptoService {
     return mnemonicGenerate(numWords);
   }
 
+  mnemonicToMiniSecret(phrase) {
+    validation.mnemonicToMiniSecret(phrase);
+
+    return mnemonicToMiniSecret(phrase);
+  }
+
   isBase64(value) {
     if (typeof value !== 'string') {
       return false;

package/src/test/setup-test-state.js

@@ -1,7 +1,7 @@
 import {TestFixtures} from '../fixtures';
 import {NetworkManager} from '../modules/network-manager';
 import {Wallet} from '../modules/wallet';
-import {dockService} from '../services/dock';
+import {blockchainService} from '../services/blockchain';
 import {mockDockService} from '../services/test-utils';
 import promiseMemoize from 'promise-memoize';
 import {setStorage} from '../core/storage';
@@ -29,7 +29,7 @@ export const getTestWallet: Wallet = promiseMemoize(async () => {
     mnemonic: TestFixtures.noBalanceAccount.mnemonic,
   });
 
-  await dockService.init({
+  await blockchainService.init({
     address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
   });
 

package/lib/services/dock/configs.js

@@ -1,18 +0,0 @@
-'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

@@ -1,10 +0,0 @@
-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.js

@@ -1,18 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var services_dock_service = require('./service.js');
-require('@docknetwork/dock-blockchain-api');
-require('@docknetwork/credential-sdk/resolver');
-require('@docknetwork/dock-blockchain-modules');
-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

@@ -1,10 +0,0 @@
-export { dockService } from './service.mjs';
-import '@docknetwork/dock-blockchain-api';
-import '@docknetwork/credential-sdk/resolver';
-import '@docknetwork/dock-blockchain-modules';
-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.js

@@ -1,136 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var dockBlockchainApi = require('@docknetwork/dock-blockchain-api');
-var resolver = require('@docknetwork/credential-sdk/resolver');
-var dockBlockchainModules = require('@docknetwork/dock-blockchain-modules');
-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');
-
-// @ts-nocheck
-let dockInstance;
-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 AnyDIDResolver extends resolver.ResolverRouter {
-    method = resolver.WILDCARD;
-}
-/**
- *
- */
-class DockService {
-    dock;
-    modules;
-    didModule;
-    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 = new dockBlockchainApi.DockAPI();
-        this.didModule = new dockBlockchainModules.DockDIDModule(this.dock);
-        this.modules = new dockBlockchainModules.DockCoreModules(this.dock);
-        dockInstance = this.dock;
-        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 AnyDIDResolver([
-            new resolver.DIDKeyResolver(),
-            new resolver.DIDResolver(this.didModule),
-            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;