@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

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();
-  }
-}