@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/src/modules/accounts.ts

@@ -1,264 +0,0 @@
-// @ts-nocheck
-import assert from 'assert';
-import {walletService as _walletService} from '../services/wallet';
-import {utilCryptoService} from '../services/util-crypto';
-import {keyringService} from '../services/keyring';
-import {substrateService} from '../services/substrate';
-import {polkadotService} from '../services/polkadot';
-import {Wallet, WalletEvents} from './wallet';
-import {Errors} from '../errors';
-import {
-  KeypairType,
-  WalletDocument,
-  DocumentType,
-  KeypairTypes,
-} from '../types';
-import {EventManager} from './event-manager';
-import {AccountDetails, Account} from './account';
-import {isAddressValid} from '../core/validation';
-
-export const AccountsEvents = {
-  loaded: 'loaded',
-  accountCreated: 'account-added',
-  accountUpdated: 'account-updated',
-  accountRemoved: 'account-removed',
-};
-
-export type CreateAccountParams = {
-  name: string,
-  type?: KeypairType,
-  derivationPath?: string,
-  mnemonic?: string,
-  json?: string,
-  password?: string,
-  getIfExists?: boolean,
-  hasBackup?: boolean,
-};
-
-export class Accounts {
-  accounts: AccountDetails[];
-  wallet: Wallet;
-  eventManager: EventManager;
-  static DocumentFilters = {
-    mnemonicType: (item: WalletDocument) => item.type === 'Mnemonic',
-    currencyType: (item: WalletDocument) => item.type === 'Currency',
-  };
-
-  constructor({wallet, walletService} = {}) {
-    this.accounts = [];
-    this.wallet = wallet || Wallet.getInstance();
-    this.walletService = walletService || _walletService;
-    this.eventManager = new EventManager();
-  }
-
-  async load() {
-    this.accounts = await this.wallet.query({
-      type: 'Address',
-    });
-    this.eventManager.emit(AccountsEvents.loaded);
-    return this.accounts;
-  }
-
-  async exportAccount(address, password) {
-    return this.walletService.exportAccount({address, password});
-  }
-
-  async importAccount(json, password) {
-    return this.create({
-      json,
-      password,
-    });
-  }
-
-  async fetchBalance(address) {
-    assert(isAddressValid(address), 'invalid address');
-    console.log('fetching balance from substrate');
-    let balance;
-
-    try {
-      balance = await substrateService.getAccountBalance({address});
-
-      console.log('balance found', balance.toString());
-
-      console.log('updating cache');
-      const currency = await this.findCorrelationByType(
-        address,
-        'Currency',
-        true,
-      );
-
-      console.log('currency', currency);
-
-      if (currency.value !== balance) {
-        currency.value = balance;
-
-        await this.wallet.update(currency);
-      }
-    } catch(err) {
-      console.log('Unable to update cache');
-      console.error(err); 
-    }
-
-    return balance;
-  }
-
-  async getBalance(address, skipFetch?) {
-    assert(isAddressValid(address), 'address is required');
-
-    if (!skipFetch) {
-      await this.fetchBalance(address);
-    }
-
-    const currency = await this.findCorrelationByType(
-      address,
-      'Currency',
-      true,
-    );
-
-    return currency.value;
-  }
-
-  getAccounts() {
-    return this.accounts;
-  }
-
-  getAccountIcon(address: string, isAlternative: boolean): Promise<any> {
-    return polkadotService.getPolkadotSvgIcon(address, isAlternative);
-  }
-
-  async getByAddress(address: string): Promise<AccountDetails> {
-    return Account.with(address);
-  }
-
-  async findCorrelationByType(
-    address: string,
-    type: DocumentType,
-    assertResult: boolean,
-  ) {
-    assert(isAddressValid(address), 'invalid address');
-
-    const correlations = await this.wallet.resolveCorrelations(address);
-    const result = correlations.find(c => c.type.includes(type));
-
-    if (assertResult) {
-      assert(!!result, `${type} document not found for the account ${address}`);
-    }
-
-    return result;
-  }
-
-  generateMnemonic(): Promise<string> {
-    return utilCryptoService.mnemonicGenerate(12);
-  }
-
-  async update(account: AccountDetails) {
-    assert(!!account, 'account is required');
-
-    await this.walletService.update(account);
-    this.eventManager.emit(AccountsEvents.accountUpdated);
-    await this.load();
-  }
-
-  async getOrCreate(params: CreateAccountParams) {
-    return this.create({
-      ...params,
-      getIfExists: true,
-    });
-  }
-
-  async create(params: CreateAccountParams): Promise<Account> {
-    let {name, json, password, type = 'sr25519', getIfExists, hasBackup} = params;
-
-    assert(!!name, 'name is required');
-    assert(!!type, 'keypair type is required');
-    assert(
-      KeypairTypes.find(t => t === type),
-      `invalid keypair type ${type}`,
-    );
-
-    if (json) {
-      assert(typeof password === 'string', 'password is required');
-    }
-
-    const mnemonic =
-      params.mnemonic || (!json && (await this.generateMnemonic()));
-    const derivePath = params.derivationPath || '';
-
-    const address = json
-      ? json.address
-      : await keyringService.addressFromUri({
-          mnemonic,
-          type,
-          derivePath,
-        });
-
-    const existingAccountDocs = await this.wallet.query({
-      id: address,
-    });
-
-    const accountExists = existingAccountDocs.length > 0;
-
-    if (getIfExists && accountExists) {
-      return this.getByAddress(address);
-    }
-
-    assert(!accountExists, Errors.accountAlreadyExists);
-
-    if (json) {
-      const pair = await keyringService.decryptKeyPair({
-        jsonData: json,
-        password,
-      });
-
-      assert(pair && pair.address, 'invalid keypair');
-
-      type = pair.type;
-    }
-
-    const account: AccountDetails = {
-      id: address,
-      name,
-      type,
-      address,
-    };
-
-    const documents = await this.walletService.createAccountDocuments({
-      name,
-      type,
-      derivePath,
-      mnemonic,
-      json,
-      password,
-      hasBackup,
-    });
-
-    documents.forEach(doc => {
-      this.wallet.eventManager.emit(WalletEvents.documentAdded, doc);
-    });
-
-    this.eventManager.emit(AccountsEvents.accountCreated, account);
-
-    await this.load();
-
-    return Account.withAsync(account.address, this);
-  }
-
-  async remove(accountId) {
-    await this.wallet.remove(accountId);
-
-    // remove other documents
-    // mnemonic phrase and all the stuff
-
-    this.eventManager.emit(AccountsEvents.accountRemoved, accountId);
-
-    this.load();
-  }
-
-  static getInstance(options): Accounts {
-    if (!Accounts.instance || options) {
-      Accounts.instance = new Accounts(options);
-    }
-
-    return Accounts.instance;
-  }
-}

package/src/modules/data-migration.test.js

@@ -1,72 +0,0 @@
-import {Wallet} from './wallet';
-import walletLegacyData from '../test/fixtures/legacy-wallet-schema.json';
-import {mockDockService} from '../services/test-utils';
-
-describe('DataMigration', () => {
-  let unmockDockService;
-
-  beforeAll(async () => {
-    unmockDockService = await mockDockService();
-  });
-
-  describe('migrate wallet from v0.1 to v0.2 (file1)', () => {
-    let wallet: Wallet;
-
-    beforeAll(async () => {
-      global.localStorage.setItem(
-        'import-test',
-        JSON.stringify(walletLegacyData),
-      );
-      wallet = await Wallet.create({walletId: 'import-test'});
-      await wallet.load();
-      await wallet.ensureNetwork();
-    });
-
-    // TODO: Check why test is failing
-    // it('expect to migrate accounts', async () => {
-    //   const accounts = await wallet.accounts.getAccounts();
-    //   expect(accounts.length).toBe(3);
-    //   expect(wallet.migrated).toBeTruthy();
-    // });
-
-    it('expect wallet version to be the latest', async () => {
-      const version = await wallet.getVersion();
-      expect(version).toBe('0.2');
-    });
-  });
-
-  it('expect not to migrate v0.2 wallet', async () => {
-    global.localStorage.setItem('dock-wallet', null);
-    const wallet = await Wallet.create();
-
-    await wallet.load();
-    await wallet.ensureNetwork();
-
-    const accounts = await wallet.accounts.getAccounts();
-
-    expect(accounts.length).toBe(0);
-    expect(wallet.migrated).toBeFalsy();
-  });
-
-  it('expect to recover wallet from missing @context on documents', async () => {
-    global.localStorage.setItem(
-      'bad-documents',
-      JSON.stringify({
-        'doc:d4bd8145-4a56-456e-9b78-71509184f6ed': {
-          // bad context data
-          '@context': null,
-          id: '6ee76a80-bdf2-4cf8-9647-4897ed6feadd',
-          name: 'Account 1',
-          type: 'Address',
-          value: 'some address',
-        },
-      }),
-    );
-    const wallet = await Wallet.create({walletId: 'bad-documents'});
-    await wallet.load();
-  });
-
-  afterAll(() => {
-    return unmockDockService();
-  });
-});

package/src/modules/data-migration.ts

@@ -1,86 +0,0 @@
-// @ts-nocheck
-import {Logger} from '../core/logger';
-import {getStorage} from '../core/storage';
-import {Wallet} from './wallet';
-
-type MigrateParams = {
-  wallet: Wallet,
-};
-
-const currentWalletVersion = '0.2';
-
-export async function migrate({wallet}: MigrateParams) {
-  Logger.debug('Starting wallet migration');
-
-  const docs = await wallet.query({});
-
-  if (!docs.length) {
-    Logger.debug(
-      `Empty wallet, adding version ${currentWalletVersion} document`,
-    );
-    await wallet.add({
-      type: 'Metadata',
-      walletVersion: currentWalletVersion,
-    });
-  }
-
-  const version = await wallet.getVersion();
-  let migrated = false;
-
-  Logger.debug(`Wallet version ${version}`);
-
-  if (version !== currentWalletVersion) {
-    const snapshot = await getStorage().getItem(wallet.walletId);
-    await getStorage().setItem(`${wallet.walletId}-snapshot`, snapshot);
-  }
-
-  if (version === '0.1') {
-    const targetVersion = '0.2';
-    Logger.debug(`Migrating wallet ${version} to ${targetVersion}`);
-    const legacyAccounts = docs.filter((doc: any) => doc.type === 'Account');
-    await Promise.all(
-      legacyAccounts.map(async (account: any) => {
-        const relatedDocs = docs.filter(doc =>
-          account.correlation.find(id => id === doc.id),
-        );
-        const mnemonicDoc = relatedDocs.find(doc => doc.type === 'Mnemonic');
-        const keyPairDoc = relatedDocs.find(doc => doc.type === 'KeyPair');
-
-        try {
-          if (mnemonicDoc) {
-            await wallet.remove(mnemonicDoc.id);
-            await wallet.remove(account.id);
-            await wallet.accounts.create({
-              mnemonic: mnemonicDoc.value,
-              name: account.meta.name,
-              type: account.meta.keypairType,
-              derivationPath: account.meta.derivationPath,
-            });
-          } else if (keyPairDoc) {
-            console.log(keyPairDoc);
-            await wallet.remove(keyPairDoc.id);
-            await wallet.remove(account.id);
-            await wallet.accounts.create({
-              name: account.meta.name,
-              json: keyPairDoc.value,
-              password: '',
-            });
-          }
-        } catch (err) {
-          Logger.error(`failed to migrate account ${account.id}`);
-          Logger.error(err);
-          throw err;
-        }
-      }),
-    );
-
-    await wallet.add({
-      type: 'Metadata',
-      walletVersion: `${targetVersion}`,
-    });
-
-    migrated = true;
-  }
-
-  return migrated;
-}

package/src/modules/wallet-backup.test.js

@@ -1,24 +0,0 @@
-import {getPromiseError} from '../services/test-utils';
-import {walletService} from '../services/wallet/service';
-import emptyBackup from '../test/fixtures/backup-files/empty-wallet-backup.json';
-import {WalletBackup} from './wallet-backup';
-
-describe('WalletBackup', () => {
-  describe('validate', () => {
-    beforeEach(async () => {
-      await walletService.create({
-        walletId: 'wallet',
-        type: 'memory',
-      });
-
-      await walletService.removeAll();
-    });
-
-    it('expect to handle empty file', async () => {
-      const result = await getPromiseError(() =>
-        WalletBackup.getInstance().validate(emptyBackup, 'test'),
-      );
-      expect(result.message).toBeDefined();
-    });
-  });
-});

package/src/modules/wallet-backup.ts

@@ -1,68 +0,0 @@
-// @ts-nocheck
-import assert from 'assert';
-import {walletService} from '../services/wallet/service';
-
-export const invalidFileMessage = 'Invalid backup file';
-export const noDocumentsFound = 'No documents found';
-export const noAccountsFound = 'No accounts found';
-
-export class WalletBackup {
-  async validate(data, password) {
-    assert(!!data.credentialSubject, invalidFileMessage);
-
-    await walletService.importWallet({json: data, password});
-
-    const docs = await walletService.query({});
-
-    console.log(docs);
-
-    if (docs.length === 0) {
-      throw new Error(noDocumentsFound);
-    }
-
-    const accounts = docs.filter(doc => doc.type === 'Account');
-
-    if (accounts.length === 0) {
-      console.log('no accounts found');
-      console.log(docs);
-      throw new Error(noAccountsFound);
-    }
-
-    const warnings = [];
-
-    for (let account of accounts) {
-      const correlationDocs = account.correlation.map(docId =>
-        docs.find(doc => doc.id === docId),
-      );
-      const hasMnemonic = correlationDocs.find(doc => doc.type === 'Mnemonic');
-      const hasKeyPair = correlationDocs.find(doc => doc.type === 'KeyPair');
-
-      if (!hasMnemonic && !hasKeyPair) {
-        warnings.push(`keypair not found for account ${account.id}`);
-
-        await walletService.update({
-          ...account,
-          meta: {
-            ...account.meta,
-            readOnly: true,
-            keypairNotFoundWarning: true,
-          },
-        });
-      }
-    }
-
-    return {
-      accounts,
-      warnings,
-      docs,
-    };
-  }
-
-  static getInstance(): WalletBackup {
-    if (!WalletBackup.instance) {
-      WalletBackup.instance = new WalletBackup();
-    }
-
-    return WalletBackup.instance;
-  }
-}