@docknetwork/wallet-sdk-wasm 0.4.19

package/src/modules/account.test.js

@@ -0,0 +1,56 @@
+import {Account} from './account';
+import {Wallet} from './wallet';
+import {NetworkManager} from './network-manager';
+import {TestFixtures} from '../fixtures';
+import {getTestWallet} from '../test/setup-test-state';
+
+describe('Account', () => {
+  let wallet: Wallet;
+  let account: Account;
+
+  beforeAll(async () => {
+    NetworkManager.getInstance().setNetworkId('testnet');
+    wallet = await getTestWallet();
+    await wallet.ensureNetwork();
+    account = await wallet.accounts.getByAddress(TestFixtures.account1.address);
+    await account.loadDetails();
+  });
+
+  it('expect to get account name', () => {
+    expect(account.getName()).toBe(TestFixtures.account1.name);
+  });
+
+  it('expect to get address', () => {
+    expect(account.getAddress()).toBe(TestFixtures.account1.address);
+  });
+
+  it('expect to get mnemonic phrase', async () => {
+    const phrase = await account.getMnemonic();
+    expect(phrase).toBe(TestFixtures.account1.mnemonic);
+  });
+
+  it('expect to get keyring pair', async () => {
+    const pair = await account.getKeyPair();
+    expect(pair.address).toBe(TestFixtures.account1.address);
+  });
+
+  it('expect to export account', () => {
+    const password = '123';
+    jest.spyOn(account.accounts, 'exportAccount');
+    account.export(password);
+    expect(account.accounts.exportAccount).toBeCalledWith(
+      account.address,
+      password,
+    );
+  });
+
+  it('expect to remove account', () => {
+    jest.spyOn(account.accounts, 'remove');
+    account.remove();
+    expect(account.accounts.remove).toBeCalledWith(account.address);
+  });
+
+  afterAll(() => {
+    return wallet.close();
+  });
+});

package/src/modules/account.ts

@@ -0,0 +1,128 @@
+// @ts-nocheck
+import assert from 'assert';
+import {isAddressValid} from '../core/validation';
+import {Accounts} from './accounts';
+import { KeypairType } from '../types';
+
+export type AccountDetails = {
+  id: string,
+  name: string,
+  type: KeypairType,
+  address: string,
+  correlations: any[],
+  balance?: number,
+  readonly?: boolean,
+  meta?: {
+    keypairNotFoundWarning: boolean,
+    name: string,
+    keypairType: KeypairType,
+    derivationPath: string,
+  }
+};
+
+/**
+ * Account
+ */
+export class Account {
+  details: AccountDetails;
+  address: string;
+  name: string;
+  accounts: Accounts;
+
+  constructor(address: string, accounts: Accounts) {
+    this.accounts = accounts;
+    this.address = address;
+    this.id = address;
+  }
+
+  /**
+   * Get account for a given address
+   * The account needs to exist in the wallet
+   *
+   * @example
+   * const accounts = Account.with('some-address')
+   * @param {string} address
+   * @returns
+   */
+  static with(address, accounts) {
+    assert(isAddressValid(address), 'invalid address');
+
+    const account = new Account(address, accounts || Accounts.getInstance());
+
+    account.loadPromise = account.loadDetails();
+
+    return account;
+  }
+
+  /**
+   *
+   * @param {string} address
+   * @returns
+   */
+  static async withAsync(address, accounts) {
+    const account = Account.with(address, accounts);
+
+    await account.loadPromise;
+
+    return account;
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async loadDetails() {
+    this.details = await this.accounts.wallet.getDocumentById(this.id);
+    this.name = this.details && this.details.name;
+  }
+
+  getAddress() {
+    return this.details.address;
+  }
+
+  getDetails(): AccountDetails {
+    return this.details;
+  }
+
+  async getBalance(skipFetch?) {
+    return this.accounts.getBalance(this.details.address, skipFetch);
+  }
+
+  export(password: string) {
+    return this.accounts.exportAccount(this.address, password);
+  }
+
+  remove() {
+    return this.accounts.remove(this.address);
+  }
+
+  update({name}) {
+    return this.accounts.update({
+      ...this.details,
+      name,
+    });
+  }
+
+  async getMnemonic() {
+    const doc = await this.accounts.findCorrelationByType(
+      this.address,
+      'Mnemonic',
+    );
+    return doc.value;
+  }
+
+  async getKeyPair() {
+    const doc = await this.accounts.findCorrelationByType(
+      this.address,
+      'KeyringPair',
+    );
+    return doc.value;
+  }
+
+  getName(): string {
+    return this.details.name;
+  }
+
+  getIcon(isAlternative?: boolean): Promise<any> {
+    return this.accounts.getAccountIcon(this.details.address, isAlternative);
+  }
+}

package/src/modules/accounts.test.js

@@ -0,0 +1,88 @@
+import {substrateService} from '../services/substrate';
+import {Accounts} from './accounts';
+import {Wallet} from './wallet';
+import {getTestWallet} from '../test/setup-test-state';
+
+describe('Accounts module', () => {
+  let wallet: Wallet;
+  let accounts: Accounts;
+
+  beforeAll(async () => {
+    wallet = await getTestWallet();
+    await wallet.ensureNetwork();
+
+    accounts = wallet.accounts;
+  });
+
+  it('Expect to create account', async () => {
+    const name = 'Test account';
+    const account = await accounts.create({
+      name,
+    });
+    const foundDocument = accounts
+      .getAccounts()
+      .find(item => item.id === account.address);
+
+    expect(account.name).toBe(name);
+    expect(account.address).toBeDefined();
+    expect(foundDocument.id).toBe(account.address);
+  });
+
+  it('Expect to create accounts with existing mnemonic', async () => {
+    const name = 'test';
+    const mnemonic =
+      'young defense crouch puzzle mosquito wire front town trophy assist salt entire';
+    const address = '3APujz7DViXXKyh7oKQRR2771aLxMHhh9ZwVadXQZnHSH2kF';
+
+    const account = await accounts.create({
+      name: name,
+      mnemonic: mnemonic,
+    });
+
+    expect(account.getName()).toBe(name);
+    expect(account.address).toBe(address);
+  });
+
+  it('expect to fetch account balance and update currency document', async () => {
+    const account = await accounts.create({
+      name: 'test',
+    });
+    const balance = 10;
+    jest.spyOn(substrateService, 'getAccountBalance').mockReturnValue(balance);
+
+    let result = await accounts.fetchBalance(account.address);
+
+    expect(substrateService.getAccountBalance).toBeCalled();
+    expect(result).toBe(balance);
+
+    const currency = await accounts.findCorrelationByType(
+      account.address,
+      'Currency',
+    );
+
+    expect(currency.value).toBe(balance);
+
+    result = await accounts.getBalance(account.address);
+
+    expect(result).toBe(balance);
+  });
+
+  it('Expect to export account and import account', async () => {
+    const account = await accounts.create({
+      name: 'test',
+    });
+    const json = await accounts.exportAccount(account.address, 'test');
+
+    expect(json.address).toBe(account.address);
+
+    await accounts.remove(account.address);
+
+    const account2 = await accounts.create({
+      name: 'json account',
+      json,
+      password: 'test',
+    });
+
+    expect(account2.address).toBe(account.address);
+  });
+});

package/src/modules/accounts.ts

@@ -0,0 +1,264 @@
+// @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

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

@@ -0,0 +1,86 @@
+// @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;
+}