@docknetwork/wallet-sdk-wasm 0.4.19

package/src/services/dids/index.test.js

@@ -0,0 +1,163 @@
+import {assertRpcService, getPromiseError} from '../test-utils';
+import {DIDServiceRPC} from './service-rpc';
+import {didService as service} from './service';
+import {validation} from './config';
+import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
+import {TestFixtures} from '../../fixtures';
+import {getTestWallet} from '../../test/setup-test-state';
+import {getDock} from '../dock/service';
+
+describe('DID Service', () => {
+  beforeAll(async () => {
+    await getTestWallet();
+  });
+
+  it('ServiceRpc', () => {
+    assertRpcService(DIDServiceRPC, service, validation);
+  });
+
+  it('expect to generate DID Key Document from keypair', async () => {
+    const keypairDoc = {
+      '@context': ['https://w3id.org/wallet/v1'],
+      id: 'urn:uuid:e8fc7810-9524-11ea-bb37-0242ac130002',
+      name: 'My Test Key 2',
+      image: 'https://via.placeholder.com/150',
+      description: 'For testing only, totally compromised.',
+      tags: ['professional', 'organization', 'compromised'],
+      correlation: ['4058a72a-9523-11ea-bb37-0242ac130002'],
+      controller: 'did:key:z6MkjjCpsoQrwnEmqHzLdxWowXk5gjbwor4urC1RPDmGeV8r',
+      type: 'Ed25519VerificationKey2018',
+      publicKeyMultibase: 'z3urLbVGF6ouYwgotxFy6637VcLqugU2s9i2XVY2yGU4v',
+      privateKeyMultibase:
+        'z3rF4Jhp7vF6tavGZCSgkdMM3ANLB7YpmzfRcB5FTs1Q7EgN6u5cCwzCaHCDYcestRSEHzjF82TvJUaj3mdqcbGnS',
+      privateKeyBase58:
+        '3CQCBKF3Mf1tU5q1FLpHpbxYrNYxLiZk4adDtfyPEfc39Wk6gsTb2qoc1ZtpqzJYdM1rG4gpaD3ZVKdkiDrkLF1p',
+      publicKeyBase58: '6GwnHZARcEkJio9dxPYy6SC5sAL6PxpZAB6VYwoFjGMU',
+    };
+    const spy = jest.spyOn(DIDKeyManager, 'keypairToDIDKeyDocument');
+
+    const res = await service.keypairToDIDKeyDocument({keypairDoc});
+
+    expect(DIDKeyManager.keypairToDIDKeyDocument).toBeCalledWith(keypairDoc);
+    expect(res).toBeDefined();
+    expect(res).toHaveProperty('didDocument');
+    expect(res).toHaveProperty('keyDoc');
+
+    spy.mockReset();
+  });
+
+  it('expect to get DID Resolution from DID document', async () => {
+    const didDocument = {
+      '@context': [
+        'https://www.w3.org/ns/did/v1',
+        'https://ns.did.ai/transmute/v1',
+        {
+          '@base': 'did:key:z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+        },
+      ],
+      id: 'did:key:z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+      verificationMethod: [
+        {
+          id: '#z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+          type: 'JsonWebKey2020',
+          controller:
+            'did:key:z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+          publicKeyJwk: {
+            crv: 'Ed25519',
+            x: 'vGur-MEOrN6GDLf4TBGHDYAERxkmWOjTbztvG3xP0I8',
+            kty: 'OKP',
+          },
+        },
+        {
+          id: '#z6LScrLMVd9jvbphPeQkGffSeB99EWSYqAnMg8rGiHCgz5ha',
+          type: 'JsonWebKey2020',
+          controller:
+            'did:key:z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+          publicKeyJwk: {
+            kty: 'OKP',
+            crv: 'X25519',
+            x: 'EXXinkMxdA4zGmwpOOpbCXt6Ts6CwyXyEKI3jfHkS3k',
+          },
+        },
+      ],
+      authentication: ['#z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg'],
+      assertionMethod: ['#z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg'],
+      capabilityInvocation: [
+        '#z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+      ],
+      capabilityDelegation: [
+        '#z6Mks8mvCnVx4HQcoq7ZwvpTbMnoRGudHSiEpXhMf6VW8XMg',
+      ],
+      keyAgreement: ['#z6LScrLMVd9jvbphPeQkGffSeB99EWSYqAnMg8rGiHCgz5ha'],
+    };
+    const spy = jest.spyOn(DIDKeyManager, 'getDIDResolution');
+    const res = await service.getDIDResolution({didDocument});
+    expect(DIDKeyManager.getDIDResolution).toBeCalledWith(didDocument, {});
+    expect(res).toBeDefined();
+    expect(res).toHaveProperty('id');
+    spy.mockReset();
+  });
+
+  it('expect to register did dock', async () => {
+    const result = await service.registerDidDock(
+      TestFixtures.account1.getKeyring().toJson(''),
+    );
+    expect(result.dockDID).toBeDefined();
+    expect(result.keyPairWalletId).toBeDefined();
+  });
+
+  it('expect to fail to register did dock', async () => {
+    const error = await getPromiseError(() =>
+      service.registerDidDock(
+        TestFixtures.noBalanceAccount.getKeyring().toJson(''),
+      ),
+    );
+    expect(error.message).toBe(
+      '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low',
+    );
+  });
+
+  it('expect to get did document', async () => {
+    const document = 'document';
+    jest.spyOn(getDock().did, 'getDocument').mockResolvedValue(document);
+
+    const result = await service.getDidDockDocument(
+      'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
+    );
+
+    expect(result).toStrictEqual(document);
+  });
+
+  it('expect to generateKeyDoc without keyPair', async () => {
+    const controller =
+      'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQ';
+    const keyDoc = await service.generateKeyDoc({
+      controller,
+    });
+
+    expect(keyDoc.controller).toEqual(controller);
+    expect(keyDoc.privateKeyMultibase).toBeDefined();
+  });
+
+  it('expect to generateKeyDoc with keyPair', async () => {
+    const controller =
+      'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQ';
+    const keyPairJSON = {
+      encoded:
+        'MFMCAQEwBQYDK2VwBCIEIJDIpsaUjZCkVkPmBPqKD0dgu59F8ks4yepJKNFQkz+A/fYvnshD7g1RpaSXuGcLytu6fN/P/PGt2ahhH2Bkh0GhIwMhAP32L57IQ+4NUaWkl7hnC8rbunzfz/zxrdmoYR9gZIdB',
+      encoding: {content: ['pkcs8', 'ed25519'], type: ['none'], version: '3'},
+      address: '3CGqgBTzZEPyhVTjpWdX5z2uDQ6hxEUALcZ6HthscNnVrKy7',
+      meta: {},
+    };
+
+    const keyDoc = await service.generateKeyDoc({
+      controller,
+      keyPairJSON,
+    });
+
+    expect(keyDoc.controller).toEqual(controller);
+    expect(keyDoc.privateKeyMultibase).toEqual(
+      'z3ttk77Si8AUHHGAGLWue3qZacSgZDtRRCbd75Bmujx2qstznWv4ZRWtCjEKcJAUUufQpSsurEAJ47mYYKPwQnA2C',
+    );
+  });
+});

package/src/services/dids/service-rpc.ts

@@ -0,0 +1,27 @@
+import {RpcService} from '../rpc-service-client';
+import {
+  serviceName,
+  KeypairToDIDKeyDocumentParams,
+  GetDIDResolutionParams,
+} from './config';
+
+export class DIDServiceRPC extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+  keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
+    return this.call('keypairToDIDKeyDocument', params);
+  }
+  getDIDResolution(params: GetDIDResolutionParams) {
+    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);
+  }
+}

package/src/services/dids/service.ts

@@ -0,0 +1,97 @@
+import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
+import {
+  serviceName,
+  validation,
+  KeypairToDIDKeyDocumentParams,
+  GetDIDResolutionParams,
+} from './config';
+import {keyringService} from '../keyring/service';
+import {utilCryptoService} from '../util-crypto/service';
+import assert from 'assert';
+import {createNewDockDID} from '@docknetwork/sdk/utils/did';
+import {getDock} from '../dock/service';
+import {PublicKeySr25519} from '@docknetwork/sdk';
+import {DidKey, VerificationRelationship} from '@docknetwork/sdk/public-keys';
+import {Logger} from '../../core/logger';
+import {polkadotToKeydoc} from '../../core/polkadot-utils';
+
+class DIDService {
+  name: string;
+
+  constructor() {
+    this.name = serviceName;
+  }
+  rpcMethods = [
+    DIDService.prototype.keypairToDIDKeyDocument,
+    DIDService.prototype.getDIDResolution,
+    DIDService.prototype.generateKeyDoc,
+    DIDService.prototype.registerDidDock,
+    DIDService.prototype.getDidDockDocument,
+  ];
+  keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
+    validation.keypairToDIDKeyDocument(params);
+
+    const {keypairDoc} = params;
+    return DIDKeyManager.keypairToDIDKeyDocument(keypairDoc);
+  }
+  getDIDResolution(params: GetDIDResolutionParams) {
+    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,
+    };
+  }
+}
+
+export const didService = new DIDService();

package/src/services/dock/configs.ts

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

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

@@ -0,0 +1,3 @@
+import {DockServiceRpc} from './service-rpc';
+
+export const dockService = new DockServiceRpc();

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

@@ -0,0 +1,3 @@
+import {DockServiceRpc} from './service-rpc';
+
+export const dockService = new DockServiceRpc();

package/src/services/dock/index.js

@@ -0,0 +1 @@
+export {dockService} from './service';

package/src/services/dock/index.test.js

@@ -0,0 +1,48 @@
+import {NetworkManager} from '../../modules/network-manager';
+import {
+  assertRpcService,
+  getPromiseError,
+  mockDockSdkConnection,
+} from '../test-utils';
+import {validation} from './configs';
+import {dockService as service} from './service';
+import {DockServiceRpc} from './service-rpc';
+
+const doConnect = (
+  address = NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+) =>
+  service.init({
+    address,
+  });
+
+describe('DockService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(DockServiceRpc, service, validation);
+  });
+
+  describe('init', () => {
+    afterEach(async () => {
+      await service.disconnect();
+    });
+
+    it('connect and disconnect substrate node', async () => {
+      const mock = mockDockSdkConnection();
+      const result = await doConnect();
+      expect(result).toBe(true);
+      expect(await service.isApiConnected()).toBeTruthy();
+      await service.disconnect();
+      expect(await service.isApiConnected()).toBeFalsy();
+      mock.clear();
+    });
+
+    it('throw error for invalid address', async () => {
+      const mock = mockDockSdkConnection();
+      const error = await getPromiseError(async () => {
+        await doConnect(null);
+      });
+      expect(error.message).toBe('invalid substrate address null');
+      expect(await service.isApiConnected()).toBeFalsy();
+      mock.clear();
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+import {RpcService} from '../rpc-service-client';
+import {InitParams, validation} from './configs';
+
+/**
+ *
+ */
+export class DockServiceRpc extends RpcService {
+  constructor() {
+    super('dock');
+  }
+
+  /**
+   *
+   */
+  disconnect(): Promise<any> {
+    return this.call('disconnect');
+  }
+
+  /**
+   *
+   */
+  ensureDockReady(): Promise<any> {
+    return this.call('ensureDockReady');
+  }
+
+  /**
+   *
+   */
+  init(params: InitParams): Promise<any> {
+    validation.init(params);
+    return this.call('init', params);
+  }
+
+  /**
+   *
+   */
+  isApiConnected(): Promise<any> {
+    return this.call('isApiConnected');
+  }
+
+  getAddress(): Promise<string> {
+    return this.call('getAddress');
+  }
+}

package/src/services/dock/service.ts

@@ -0,0 +1,154 @@
+// @ts-nocheck
+import dock from '@docknetwork/sdk';
+import {
+  DockResolver,
+  DIDKeyResolver,
+  WildcardMultiResolver,
+  UniversalResolver,
+} from '@docknetwork/sdk/resolver';
+import {initializeWasm} from '@docknetwork/crypto-wasm-ts/lib/index';
+import {EventEmitter} from 'events';
+import {Logger} from '../../core/logger';
+import {once} from '../../modules/event-manager';
+import {InitParams, validation} from './configs';
+
+let dockInstance = dock;
+
+export function getDock() {
+  return dockInstance;
+}
+
+export function setDock(instance) {
+  dockInstance = instance;
+}
+
+// Create a resolver in order to lookup DIDs for verifying
+export 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;
+//   }
+// }
+
+/**
+ *
+ */
+export class DockService {
+  dock;
+  isDockReady = false;
+  resolver: any;
+  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;
+    this.emitter = new EventEmitter();
+    this.resolver = this.createDIDResolver();
+  }
+
+  /**
+   *
+   * @returns
+   */
+  async ensureDockReady() {
+    if (this.isDockReady) {
+      return;
+    }
+
+    return once(this.emitter, DockService.Events.DOCK_READY);
+  }
+
+  createDIDResolver() {
+    return new WildcardMultiResolver([
+      new DockResolver(getDock()), // Prebuilt resolver
+      new DIDKeyResolver(), // did:key resolution
+      new UniversalResolver(universalResolverUrl),
+    ]);
+  }
+  /**
+   *
+   * @param {*} params
+   * @returns
+   */
+  async init(params: InitParams) {
+    validation.init(params);
+    
+
+    if (this.dock.isConnected) {
+      await this.dock.disconnect();
+    }
+
+    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 initializeWasm();
+    }
+
+    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);
+    }
+  }
+}
+
+export const dockService: DockService = new DockService();

package/src/services/example/configs.js

@@ -0,0 +1,14 @@
+import assert from 'assert';
+import {isNumberValid} from '../../core/validation';
+
+export const validation = {
+  sum(params: SumParams) {
+    assert(isNumberValid(params.number1), 'invalid number1');
+    assert(isNumberValid(params.number2), 'invalid number2');
+  },
+};
+
+export type SumParams = {
+  number1: number,
+  number2: number,
+};

package/src/services/example/index.js

@@ -0,0 +1,3 @@
+import {ExampleServiceRpc} from './service-rpc';
+
+export const exampleService = new ExampleServiceRpc();

package/src/services/example/index.test.js

@@ -0,0 +1,28 @@
+import {assertRpcService, getPromiseError} from '../test-utils';
+import {validation} from './configs';
+import {exampleService as service} from './service';
+import {ExampleServiceRpc} from './service-rpc';
+
+describe('ExampleService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(ExampleServiceRpc, service, validation);
+  });
+
+  describe('service', () => {
+    beforeAll(async () => {});
+
+    describe('sum', () => {
+      it('expect to sum numbers', async () => {
+        const result = await service.sum({number1: 1, number2: 1});
+        expect(result).toBe(2);
+      });
+
+      it('expect to validate params', async () => {
+        const error = await getPromiseError(() =>
+          service.sum({number1: null, number2: 1}),
+        );
+        expect(error.message).toBe('invalid number1');
+      });
+    });
+  });
+});

package/src/services/example/service-rpc.js

@@ -0,0 +1,11 @@
+import {RpcService} from '../rpc-service-client';
+
+export class ExampleServiceRpc extends RpcService {
+  constructor() {
+    super('example');
+  }
+
+  sum(): Promise<any> {
+    return this.call('sum');
+  }
+}

package/src/services/example/service.ts

@@ -0,0 +1,16 @@
+// @ts-nocheck
+import {SumParams, validation} from './configs';
+
+export class ExampleService {
+  rpcMethods = [ExampleService.prototype.sum];
+
+  constructor() {}
+
+  sum(params: SumParams) {
+    validation.sum(params);
+
+    return params.number1 + params.number2;
+  }
+}
+
+export const exampleService: ExampleService = new ExampleService();

package/src/services/index.js

@@ -0,0 +1,26 @@
+import {keyringService} from './keyring/service';
+import {dockService} from './dock/service';
+import {substrateService} from './substrate/service';
+import {walletService} from './wallet/service';
+import {polkadotService} from './polkadot/service';
+import {utilCryptoService} from './util-crypto/service';
+import {storageService} from './storage/service';
+import {didService} from './dids/service';
+import {credentialService} from './credential/service';
+import {relayService} from './relay-service/service';
+import {pexService} from './pex/service';
+import {trustRegistryService} from './trust-registry/service';
+export default [
+  keyringService,
+  dockService,
+  substrateService,
+  walletService,
+  polkadotService,
+  utilCryptoService,
+  storageService,
+  didService,
+  credentialService,
+  relayService,
+  pexService,
+  trustRegistryService,
+];