@docknetwork/wallet-sdk-wasm 1.5.9 → 1.5.11

package/src/core/realm-schemas.js

@@ -1,42 +0,0 @@
-export const TokenPrice = {
-  name: 'TokenPrice',
-  properties: {
-    symbol: 'string',
-    name: 'string?',
-    price: 'float',
-  },
-  primaryKey: 'symbol',
-};
-
-export const Account = {
-  name: 'Account',
-  properties: {
-    id: 'string',
-    name: 'string',
-    balance: 'string?',
-  },
-  network: {
-    type: 'string',
-    default: 'testnet',
-  },
-  readyOnly: {
-    type: 'bool',
-    default: false,
-  },
-  primaryKey: 'id',
-};
-
-export const RequestLog = {
-  name: 'RequestLog',
-  properties: {
-    id: 'string',
-    url: 'string',
-    status: 'int',
-    method: 'string',
-    headers: 'string',
-    body: 'string',
-    response: 'string',
-    createdAt: 'date',
-  },
-  primaryKey: 'id',
-};

package/src/core/subscan.js

@@ -1,62 +0,0 @@
-import axios from 'axios';
-import axiosRetry from 'axios-retry';
-import assert from 'assert';
-import {Logger} from './logger';
-import {TaskQueue} from 'cwait';
-
-axiosRetry(axios, {
-  retries: 4,
-  retryDelay: retryCount => {
-    return retryCount * 500;
-  },
-  retryCondition: error => {
-    return error.response.status === 503 || error.response.status === 429;
-  },
-});
-
-const SUBSCAN_URL = 'https://dock.api.subscan.io';
-export const SUBSCAN_TRANSFER_URL = `${SUBSCAN_URL}/api/v2/scan/transfers`;
-
-const queue = new TaskQueue(global.Promise, 1);
-
-function doFetchTransactions({address, page = 0, itemsPerPage = 50}) {
-  assert(typeof address === 'string', 'address must be a string');
-  assert(typeof page === 'number', 'page must be a number');
-  assert(typeof itemsPerPage === 'number', 'itemsPerPage must be a number');
-
-  const body = {
-    row: itemsPerPage,
-    page,
-    address: address,
-  };
-
-  Logger.info(
-    `Fetching transactions from subscan ${SUBSCAN_TRANSFER_URL} with body ${JSON.stringify(
-      body,
-    )}`,
-  );
-
-  return axios
-    .post(SUBSCAN_TRANSFER_URL, body, {})
-    .then(res => {
-      const {data, message} = res.data;
-
-      if (message === 'Success') {
-        const {transfers, count} = data;
-        return {
-          items: transfers,
-          count,
-          page,
-          hasNextPage: (page + 1) * itemsPerPage < count,
-        };
-      }
-
-      throw new Error(message);
-    })
-    .catch(err => {
-      console.error(err);
-      throw err;
-    });
-}
-
-export const fetchTransactions = queue.wrap(doFetchTransactions);

package/src/core/subscan.test.js

@@ -1,56 +0,0 @@
-import {fetchTransactions} from './subscan';
-import {mockSubscanParamsFailure, mockSubscanSuccess} from '../test/axiosMocks';
-import {getPromiseError} from '../services/test-utils';
-
-describe('Subscan integration', () => {
-  describe('fetchTransactions', () => {
-    it('expect to return transactions', async () => {
-      mockSubscanSuccess();
-
-      const transactions = await fetchTransactions({address: '123'});
-
-      expect(transactions.items.length).toBe(12);
-      expect(transactions.hasNextPage).toBe(true);
-    });
-
-    it('expect to return transactions (last page)', async () => {
-      mockSubscanSuccess();
-
-      const transactions = await fetchTransactions({address: '123', page: 2});
-
-      expect(transactions.hasNextPage).toBe(false);
-    });
-
-    it('expect to handle api error', async () => {
-      let error;
-      mockSubscanParamsFailure();
-
-      try {
-        await fetchTransactions({address: '123', page: 2});
-      } catch (err) {
-        error = err;
-      }
-
-      expect(error.message).toBe('Params Error');
-    });
-
-    it('validate adddress param', async () => {
-      const error = await getPromiseError(() => fetchTransactions({}));
-      expect(error.message).toBe('address must be a string');
-    });
-
-    it('validate page param', async () => {
-      const error = await getPromiseError(() =>
-        fetchTransactions({address: '123', page: 'test'}),
-      );
-      await expect(error.message).toBe('page must be a number');
-    });
-
-    it('validate itemsPerPage param', async () => {
-      const error = await getPromiseError(() =>
-        fetchTransactions({address: '123', itemsPerPage: 'test'}),
-      );
-      await expect(error.message).toBe('itemsPerPage must be a number');
-    });
-  });
-});

package/src/fixtures.js

@@ -1,43 +0,0 @@
-import {getKeyring} from './services/keyring/service';
-
-export const TestFixtures = {
-  account1: {
-    name: 'Account 1',
-    mnemonic:
-      'twenty fat wood hub lock cattle thought base lazy apology lyrics innocent',
-    address: '393NFT43eUgKnEthAaKXnuCzizuxExMYULWrsjep5c1TmV4X',
-    balance: 100,
-    getKeyring: () =>
-      getKeyring().addFromMnemonic(
-        TestFixtures.account1.mnemonic,
-        null,
-        'sr25519',
-      ),
-  },
-  account2: {
-    name: 'Account 2',
-    mnemonic:
-      'multiply obtain exact matrix write chimney observe blind siege mobile spoon club',
-    address: '38Pg2Kiod34RiWMEKNZHR6oLUahatQxaeMSfVXAGU3MbX83g',
-    balance: 200,
-    getKeyring: () =>
-      getKeyring().addFromMnemonic(
-        TestFixtures.account2.mnemonic,
-        null,
-        'sr25519',
-      ),
-  },
-  noBalanceAccount: {
-    name: 'Account No Balance',
-    mnemonic:
-      'raise genuine melt wagon make sense paddle sea human skirt lucky humor',
-    address: '3AxrRtwmcmezJLv9Nj6uD6MHJY5HN4buFX1r8vyGVpJmeZmE',
-    balance: 0,
-    getKeyring: () =>
-      getKeyring().addFromMnemonic(
-        TestFixtures.noBalanceAccount.mnemonic,
-        null,
-        'sr25519',
-      ),
-  },
-};

package/src/modules/account.test.js

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

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

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

@@ -1,231 +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 {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 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;
-  }
-}