@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

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,88 +0,0 @@
-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);
-  });
-});