@docknetwork/wallet-sdk-wasm 1.5.9 → 1.5.10

package/src/services/wallet/configs.ts

@@ -1,59 +1,8 @@
 // @ts-nocheck
 import assert from 'assert';
-import {
-  assertAddress,
-  assertKeyType,
-  assertPassword,
-} from '../../core/validation';
-import {KeypairType} from '../../types';
-
-function assertContent(content: WalletContent) {
-  assert(typeof content === 'object', 'invalid wallet content');
-  assert(typeof content.id === 'string', `invalid content id ${content.id}`);
-  assert(
-    typeof content.type === 'string',
-    `invalid content type ${content.type}`,
-  );
-}
+import {assertPassword} from '../../core/validation';
 
 export const validation = {
-  getDocumentById(id: string) {
-    assert(typeof id === 'string', 'invalid documentId');
-    assert(!!id, 'documentId is required');
-  },
-  resolveCorrelations(address) {
-    assert(typeof address === 'string', 'invalid documentId');
-    assert(!!address, 'documentId is required');
-  },
-  exportAccount({address, password}: ExportAccountParams) {
-    assertAddress(address);
-    assertPassword(password);
-  },
-  create({walletId}: CreateParams): Promise<any> {
-    assert(typeof walletId === 'string', `invalid walletId ${walletId}`);
-  },
-  lock(password: string) {
-    assertPassword(password);
-  },
-  unlock(password: string) {
-    assertPassword(password);
-  },
-  add(params: AddParams) {
-    assertContent(params);
-  },
-  remove(id: string) {
-    assert(typeof id === 'string', 'invalid documentId');
-    assert(!!id, 'documentId is required');
-  },
-  update(params: UpdateParams) {
-    assertContent(params);
-  },
-  query(params: QueryParams) {
-    assert(typeof params === 'object', 'invalid query');
-  },
-  exportWallet(password: string) {
-    assertPassword(password);
-  },
   getDocumentsFromEncryptedWallet({
     encryptedJSONWallet,
     password,
@@ -64,10 +13,6 @@ export const validation = {
     );
     assertPassword(password);
   },
-  importWallet({json, password}: ImportWalletParams) {
-    assert(typeof json === 'object', `invalid json data: ${json}`);
-    assertPassword(password);
-  },
   exportDocuments({documents, password}: ExportDocuments) {
     assert(Array.isArray(documents), 'Invalid Documents');
     assert(documents.length > 0, 'Cannot export empty documents');
@@ -81,50 +26,10 @@ export const validation = {
 
     assertPassword(password);
   },
-  createAccountDocuments(params: CreateAccountDocumentsParams) {
-    const {name, json, password, mnemonic, type} = params;
-
-    // Property derivationPath was replaced by derivePath
-    assert(
-      !params.derivationPath,
-      'invalid parameter derivationPath, it should be derivePath instead',
-    );
-
-    assert(typeof name === 'string', `invalid account name: ${name}`);
-
-    if (json) {
-      assert(typeof json === 'object', `invalid json: ${password}`);
-      assert(typeof password === 'string', `invalid password: ${password}`);
-    } else {
-      assert(typeof mnemonic === 'string', `invalid mnemonic: ${mnemonic}`);
-    }
-
-    if (type) {
-      assertKeyType(type);
-    }
-  },
 };
 
 export const serviceName = 'wallet';
 
-export type WalletContent = {
-  '@context'?: string[],
-  name?: any,
-  id: any,
-  type: DocumentType,
-  value?: any,
-  correlation?: any[],
-};
-
-export type CreateAccountDocumentsParams = {
-  name: string,
-  json?: string,
-  password?: string,
-  mnemonic?: string,
-  type?: KeypairType,
-  derivePath?: string,
-};
-
 export type GetDocumentsFromEncryptedWallet = {
   encryptedJSONWallet: any,
   password: string,
@@ -133,20 +38,3 @@ export type GetDocumentsFromEncryptedWallet = {
 export type ExportDocuments = {
   documents: Array<any>,
 };
-
-export type QueryParams = any;
-export type AddParams = WalletContenxt;
-export type UpdateParams = WalletContent;
-export type RemoveParams = string;
-export type ImportWalletParams = {
-  json: string,
-  password: string,
-};
-export type ExportAccountParams = {
-  address: string,
-  password: string,
-};
-export type CreateParams = {
-  walletId: string,
-  type: string,
-};

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

@@ -1,6 +1,3 @@
-import {mnemonicGenerate} from '@polkadot/util-crypto';
-import {NetworkManager} from '../../modules/network-manager';
-import {keyringService} from '../keyring/service';
 import {assertRpcService, getPromiseError} from '../test-utils';
 import {validation} from './configs';
 import {walletService as service, walletService} from './service';
@@ -11,163 +8,7 @@ describe('WalletService', () => {
     assertRpcService(WalletServiceRpc, service, validation);
   });
 
-  let accountDocuments;
-  let testAccount;
-
   describe('service', () => {
-    beforeAll(async () => {
-      await keyringService.initialize({
-        ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-      });
-      await service.create({
-        walletId: 'test',
-        type: 'memory',
-      });
-      await service.load();
-      await service.sync();
-      accountDocuments = await service.createAccountDocuments({
-        mnemonic: mnemonicGenerate(12),
-        name: 'test',
-        type: 'sr25519',
-      });
-
-      testAccount = accountDocuments[0];
-    });
-
-    describe('getDocumentById', () => {
-      it('expect to sum numbers', async () => {
-        const result = await service.getDocumentById(testAccount.id);
-        expect(result.id).toBe(testAccount.id);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getDocumentById(null),
-        );
-
-        expect(error.message).toBe('invalid documentId');
-      });
-    });
-
-    describe('getAccountKeypair', () => {
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getDocumentById(null),
-        );
-
-        expect(error.message).toBe('invalid documentId');
-      });
-    });
-
-    describe('createAccountDocuments', () => {
-      const params = {
-        derivationPath: '',
-        mnemonic: mnemonicGenerate(12),
-        type: 'sr25519',
-        name: 'Test account',
-      };
-      let documents;
-      let correlation;
-
-      beforeAll(async () => {
-        documents = await service.createAccountDocuments(params);
-        correlation = await service.resolveCorrelations(documents[0].id);
-      });
-
-      it('expect to create 4 documents', () => {
-        expect(documents.length).toBe(4);
-      });
-
-      it('expect to create address document ', () => {
-        const document = correlation.find(doc => doc.type === 'Address');
-        expect(document.value).toBe(documents[0].id);
-      });
-
-      it('expect to create mnemonic document', () => {
-        const document = correlation.find(doc => doc.type === 'Mnemonic');
-        expect(document.value).toBe(params.mnemonic);
-      });
-
-      it('expect to create keyringPair document', () => {
-        const document = correlation.find(doc => doc.type === 'KeyringPair');
-        const keyringPairJson = document.value;
-        const keyringPair = keyringService.decryptKeyPair({
-          jsonData: keyringPairJson,
-          password: '',
-        });
-
-        expect(keyringPair.address).toBe(documents[0].value);
-        expect(keyringPair.type).toBe(params.type);
-      });
-
-      it('expect to create DOCK currency document', () => {
-        const document = correlation.find(doc => doc.type === 'Currency');
-        expect(document.value).toBe(0);
-        expect(document.symbol).toBe('DOCK');
-      });
-    });
-
-    describe('exportAccount', () => {
-      it('expect to export account', async () => {
-        const result = await service.exportAccount({
-          address: testAccount.id,
-          password: '123',
-        });
-        expect(result.address).toBe(testAccount.id);
-        const pair = keyringService.addFromJson({
-          jsonData: result,
-          password: '123',
-        });
-        expect(pair.address).toBe(testAccount.id);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.exportAccount({
-            address: undefined,
-            password: null,
-          }),
-        );
-        expect(error.message).toBe('invalid address: undefined');
-      });
-    });
-
-    describe('exportWallet', () => {
-      it('expect to export account', async () => {
-        const result = await service.exportWallet('123');
-        expect(result.id).toBeDefined();
-        expect(result['@context']).toBeDefined();
-        expect(result.type).toBeDefined();
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.exportWallet(undefined),
-        );
-        expect(error.message).toBe('invalid password: undefined');
-      });
-    });
-
-    describe('importWallet', () => {
-      it('expect to export account', async () => {
-        const json = await service.exportWallet('123');
-        await walletService.removeAll();
-        await service.importWallet({json, password: '123'});
-        for (let doc of accountDocuments) {
-          const walletDoc = await walletService.getDocumentById(doc.id);
-          delete walletDoc.hasBackup;
-          delete doc.hasBackup;
-          expect(walletDoc).toStrictEqual(doc);
-        }
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.importWallet({json: undefined}),
-        );
-        expect(error.message).toBe('invalid json data: undefined');
-      });
-    });
     describe('getDocumentsFromEncryptedWallet', () => {
       it('expect to validate params', async () => {
         const error = await getPromiseError(() =>

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

@@ -1,98 +1,11 @@
 import {RpcService} from '../rpc-service-client';
-import {
-  AddParams,
-  CreateAccountDocumentsParams,
-  ExportAccountParams,
-  ImportWalletParams,
-  QueryParams,
-  serviceName,
-  UpdateParams,
-  GetDocumentsFromEncryptedWallet,
-  ExportDocuments,
-  validation,
-} from './configs';
+import {serviceName, ExportDocuments, validation} from './configs';
 
 export class WalletServiceRpc extends RpcService {
   constructor() {
     super(serviceName);
   }
 
-  getDocumentById(id: string): Promise<any> {
-    validation.getDocumentById(id);
-    return this.call('getDocumentById', id);
-  }
-
-  create(params: CreateParams): Promise<any> {
-    validation.create(params);
-    return this.call('create', params);
-  }
-  load() {
-    return this.call('load');
-  }
-  sync() {
-    return this.call('sync');
-  }
-  lock(password) {
-    return this.call('lock');
-  }
-  healthCheck(timestamp) {
-    return this.call('healthCheck', timestamp);
-  }
-  unlock(password) {
-    return this.call('unlock');
-  }
-  status() {
-    return this.call('status');
-  }
-  toJSON() {
-    return this.call('toJSON');
-  }
-
-  add(params: AddParams) {
-    validation.add(params);
-    return this.call('add', params);
-  }
-
-  remove(id: string) {
-    validation.remove(id);
-    return this.call('remove', id);
-  }
-
-  update(params: UpdateParams) {
-    validation.update(params);
-    return this.call('update', params);
-  }
-
-  query(params: QueryParams) {
-    validation.query(params);
-    return this.call('query', params);
-  }
-
-  exportWallet(password: string) {
-    validation.exportWallet(password);
-    return this.call('exportWallet', password);
-  }
-
-  importWallet(params: ImportWalletParams) {
-    validation.importWallet(params);
-    return this.call('importWallet', params);
-  }
-
-  exportAccount(params: ExportAccountParams) {
-    validation.exportAccount(params);
-    return this.call('exportAccount', params);
-  }
-
-  createAccountDocuments(params: CreateAccountDocumentsParams) {
-    validation.createAccountDocuments(params);
-    return this.call('createAccountDocuments', params);
-  }
-
-  resolveCorrelations(address: string) {
-    validation.resolveCorrelations(address);
-    return this.call('resolveCorrelations', address);
-  }
-
   getDocumentsFromEncryptedWallet(params: GetDocumentsFromEncryptedWallet) {
     validation.getDocumentsFromEncryptedWallet(params);
     return this.call('getDocumentsFromEncryptedWallet', params);

package/src/services/wallet/service.ts

@@ -5,7 +5,6 @@ import {v4 as uuid} from 'uuid';
 import {WalletDocument} from '../../types';
 import MemoryWallet from '../../wallet/memory-storage-wallet';
 import RpcWallet from '../../wallet/rpc-storage-wallet';
-import {keyringService} from '../keyring/service';
 import {
   CreateAccountDocumentsParams,
   CreateParams,
@@ -23,24 +22,6 @@ export class WalletService {
   wallet: StorageWallet;
 
   rpcMethods = [
-    WalletService.prototype.create,
-    WalletService.prototype.add,
-    WalletService.prototype.exportWallet,
-    WalletService.prototype.importWallet,
-    WalletService.prototype.resolveCorrelations,
-    WalletService.prototype.createAccountDocuments,
-    WalletService.prototype.exportAccount,
-    WalletService.prototype.getDocumentById,
-    WalletService.prototype.load,
-    WalletService.prototype.lock,
-    WalletService.prototype.query,
-    WalletService.prototype.remove,
-    WalletService.prototype.status,
-    WalletService.prototype.toJSON,
-    WalletService.prototype.sync,
-    WalletService.prototype.unlock,
-    WalletService.prototype.update,
-    WalletService.prototype.healthCheck,
     WalletService.prototype.getDocumentsFromEncryptedWallet,
     WalletService.prototype.exportDocuments,
   ];
@@ -49,245 +30,6 @@ export class WalletService {
     this.name = serviceName;
   }
 
-  create(params: CreateParams) {
-    const {walletId, type} = params;
-    Logger.debug('Creating wallet', params);
-    if (type === 'memory') {
-      this.wallet = new MemoryWallet(walletId);
-    } else {
-      this.wallet = new RpcWallet(walletId);
-    }
-  }
-
-  healthCheck(timestamp) {
-    return `${this.name}: ${timestamp}`;
-  }
-
-  load() {
-    this._assertWallet();
-
-    return this.wallet.load();
-  }
-  sync() {
-    this._assertWallet();
-
-    return this.wallet.sync();
-  }
-  lock(password) {
-    this._assertWallet();
-
-    return this.wallet.lock(password);
-  }
-  unlock(password) {
-    this._assertWallet();
-
-    return this.wallet.unlock(password);
-  }
-  status() {
-    this._assertWallet();
-
-    return this.wallet.status;
-  }
-  toJSON() {
-    this._assertWallet();
-
-    return this.wallet.toJSON();
-  }
-
-  add(content) {
-    this._assertWallet();
-    validation.add(content);
-    return this.wallet.add(content);
-  }
-
-  remove(id: string) {
-    this._assertWallet();
-    validation.remove(id);
-    return this.wallet.remove(id);
-  }
-
-  update(content) {
-    this._assertWallet();
-    validation.update(content);
-    return this.wallet.update(content);
-  }
-
-  query(search) {
-    this._assertWallet();
-    validation.query(search);
-    return this.wallet.query(search);
-  }
-
-  /**
-   *
-   * @param {*} password
-   * @returns
-   */
-  exportWallet(password) {
-    this._assertWallet();
-    validation.exportWallet(password);
-    return this.wallet.export(password);
-  }
-
-  /**
-   *
-   * @param {*} param0
-   * @returns
-   */
-  importWallet(params: ImportWalletParams) {
-    this._assertWallet();
-    validation.importWallet(params);
-
-    const {json, password} = params;
-    return this.wallet.import(json, password);
-  }
-
-  async removeAll() {
-    this._assertWallet();
-    const documents = await this.wallet.query({});
-
-    for (let doc of documents) {
-      await this.wallet.remove(doc.id);
-    }
-
-    await this.wallet.sync();
-  }
-  /**
-   *
-   * @param {*} params
-   * @returns
-   */
-  async exportAccount(params: ExportAccountParams) {
-    validation.exportAccount(params);
-
-    const {address, password, keyPairDocument} = params;
-
-    let pair;
-
-    if (keyPairDocument) {
-      pair = keyringService.decryptKeyPair({
-        jsonData: keyPairDocument,
-        password: '',
-      });
-    } else {
-      pair = await this.getAccountKeypair(address);
-    }
-
-    return pair.toJson(password);
-  }
-  /**
-   *
-   * @param {*} params
-   * @returns
-   */
-  async createAccountDocuments(params: CreateAccountDocumentsParams) {
-    this._assertWallet();
-    validation.createAccountDocuments(params);
-
-    const {
-      name,
-      type = 'sr25519',
-      derivePath,
-      mnemonic,
-      json,
-      password,
-      hasBackup
-    } = params;
-
-    const keyringPair = json
-      ? keyringService.decryptKeyPair({jsonData: json, password})
-      : keyringService.getKeyringPair({mnemonic, derivePath, type});
-    const keyringJson = keyringPair.toJson();
-    const correlationDocs: WalletDocument[] = [];
-
-    correlationDocs.push({
-      '@context': ['https://w3id.org/wallet/v1'],
-      id: uuid(),
-      type: 'KeyringPair',
-      value: keyringJson,
-    });
-
-    correlationDocs.push({
-      '@context': ['https://w3id.org/wallet/v1'],
-      id: uuid(),
-      type: 'Currency',
-      value: 0,
-      symbol: 'DOCK',
-    });
-
-    if (mnemonic) {
-      correlationDocs.push({
-        '@context': ['https://w3id.org/wallet/v1'],
-        id: uuid(),
-        type: 'Mnemonic',
-        value: mnemonic,
-      });
-    }
-
-    Logger.info(`Account created: ${keyringPair.address}`);
-
-    const addressDocument: WalletDocument = {
-      '@context': ['https://w3id.org/wallet/v1'],
-      id: keyringPair.address,
-      type: 'Address',
-      value: keyringPair.address,
-      address: keyringPair.address,
-      name,
-      correlation: correlationDocs.map(doc => doc.id),
-      hasBackup,
-    };
-
-    await this.wallet.add(addressDocument);
-    await Promise.all(correlationDocs.map(doc => this.wallet.add(doc)));
-
-    return [addressDocument, ...correlationDocs];
-  }
-  async resolveCorrelations(documentId) {
-    const document = await this.getDocumentById(documentId);
-
-    assert(!!document, `Document ${documentId} not found`);
-
-    const correlation = await Promise.all(
-      (document.correlation || []).map(docId => this.getDocumentById(docId)),
-    );
-
-    const result = [document, ...correlation];
-
-    return result;
-  }
-
-  _assertWallet() {
-    assert(!!this.wallet, 'wallet is not created');
-  }
-
-  async getAccountKeypair(accountId) {
-    const correlations = await this.resolveCorrelations(accountId);
-    const keyPairDocument = correlations.find(
-      doc => doc.type === 'KeyringPair',
-    );
-
-    assert(
-      !!keyPairDocument,
-      `Keypair document not found for account: ${accountId}`,
-    );
-
-    const pair = keyringService.decryptKeyPair({
-      jsonData: keyPairDocument.value,
-      password: '',
-    });
-
-    pair.unlock();
-
-    return pair;
-  }
-
-  getDocumentById(id: string) {
-    this._assertWallet();
-    validation.getDocumentById(id);
-
-    return this.wallet.getStorageDocument({id}).then(doc => doc.content);
-  }
-
   async getDocumentsFromEncryptedWallet(params) {
     validation.getDocumentsFromEncryptedWallet(params);
     const {encryptedJSONWallet, password} = params;

package/src/test-utils.js

@@ -27,16 +27,3 @@ export function testRpcEndpoint(service, rpcMethod, ...params) {
 }
 
 export const waitFor = timeout => new Promise(res => setTimeout(res, timeout));
-
-let sendTokensSpy;
-let getFeeSpy;
-
-export function resetMockTransaction() {
-  if (sendTokensSpy) {
-    sendTokensSpy.mockRestore();
-  }
-
-  if (getFeeSpy) {
-    getFeeSpy.mockRestore();
-  }
-}