@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/src/services/example/service-rpc.js

@@ -1,11 +0,0 @@
-import {RpcService} from '../rpc-service-client';
-
-export class ExampleServiceRpc extends RpcService {
-  constructor() {
-    super('example');
-  }
-
-  sum(): Promise<any> {
-    return this.call('sum');
-  }
-}

package/src/services/example/service.ts

@@ -1,18 +0,0 @@
-// @ts-nocheck
-import {SumParams, validation} from './configs';
-
-export class ExampleService {
-  rpcMethods = [ExampleService.prototype.sum];
-
-  constructor() {
-    this.name = 'example';
-  }
-
-  sum(params: SumParams) {
-    validation.sum(params);
-
-    return params.number1 + params.number2;
-  }
-}
-
-export const exampleService: ExampleService = new ExampleService();

package/src/services/keyring/configs.ts

@@ -1,110 +0,0 @@
-// @ts-nocheck
-import assert from 'assert';
-import {assertKeyType} from '../../core/validation';
-
-export const validation = {
-  addFromJson({jsonData, password}: AddFromJsonParams) {
-    assert(typeof jsonData === 'object', 'invalid jsonData');
-    assert(typeof password === 'string', 'invalid password');
-  },
-  initialize({ss58Format, type}: InitializeParams) {
-    assert(typeof ss58Format === 'number', 'invalid ss58Format');
-
-    if (type) {
-      assertKeyType(type);
-    }
-  },
-  addFromMnemonic({mnemonic, meta, type}: AddFromMnemonicParams) {
-    assert(typeof mnemonic === 'string', 'invalid mnemonic');
-
-    if (type) {
-      assertKeyType(type);
-    }
-
-    if (meta) {
-      assert(typeof meta === 'object', 'invalid meta');
-    }
-  },
-  getKeyringPair(params: GetKeyringParams) {
-    const {mnemonic, derivePath, meta, type} = params;
-
-    assert(
-      !params.keyPairType,
-      'invalid parameter keyPairType, you should use type instead',
-    );
-
-    assert(typeof mnemonic === 'string', 'invalid mnemonic');
-
-    if (derivePath) {
-      assert(typeof derivePath === 'string', 'invalid derivePath');
-    }
-
-    if (type) {
-      assertKeyType(type);
-    }
-
-    if (meta) {
-      assert(typeof meta === 'object', 'invalid meta');
-    }
-  },
-  createFromPair(params: CreateFromPairParams) {
-    const {pair, meta, type} = params;
-
-    assert(typeof pair === 'object', 'invalid pair');
-    assert(pair.publicKey instanceof Uint8Array, 'invalid publicKey');
-    assert(pair.secretKey instanceof Uint8Array, 'invalid secretKey');
-
-    if (type) {
-      assertKeyType(type);
-    }
-
-    if (meta) {
-      assert(typeof meta === 'object', 'invalid meta');
-    }
-  },
-
-  signData(params: SignDataParams) {
-    assert(!!params.keyPair, 'invalid keypair');
-    assert(!!params.data, 'invalid data');
-  },
-};
-
-validation.addressFromUri = validation.getKeyringPair;
-
-export const serviceName = 'keyring';
-
-export type GetKeyringParams = {
-  mnemonic: string,
-  meta?: any,
-  type?: string,
-  derivePath?: string,
-};
-
-export type CreateFromPairParams = {
-  pair: any,
-  meta?: any,
-  type?: string,
-}
-
-export type AddressFromUriParams = GetKeyringParams;
-
-export type AddFromJsonParams = {
-  jsonData: string,
-  password: string,
-};
-
-export type InitializeParams = {
-  ss58Format: number,
-  type?: string,
-};
-
-export type AddFromMnemonicParams = {
-  mnemonic: string,
-  meta?: any,
-  type: string,
-};
-
-export type SignDataParams = {
-  keyPair: any,
-  data: any,
-};

package/src/services/keyring/index.android.js

@@ -1,3 +0,0 @@
-import {KeyringServiceRpc} from './service-rpc';
-
-export const keyringService = new KeyringServiceRpc();

package/src/services/keyring/index.ios.js

@@ -1,3 +0,0 @@
-import {KeyringServiceRpc} from './service-rpc';
-
-export const keyringService = new KeyringServiceRpc();

package/src/services/keyring/index.js

@@ -1 +0,0 @@
-export {keyringService} from './service';

package/src/services/keyring/index.test.js

@@ -1,48 +0,0 @@
-import {mnemonicGenerate} from '@polkadot/util-crypto';
-import {NetworkManager} from '../../modules/network-manager';
-import {assertRpcService, getPromiseError} from '../test-utils';
-import {validation} from './configs';
-import {keyringService as service} from './service';
-import {KeyringServiceRpc} from './service-rpc';
-
-describe('KeyringService', () => {
-  it('ServiceRpc', () => {
-    assertRpcService(KeyringServiceRpc, service, validation);
-  });
-
-  describe('service', () => {
-    beforeAll(async () => {});
-
-    describe('initialize', () => {
-      it('expect to initialize keyring', async () => {
-        await service.initialize({
-          ss58Format:
-            NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-        });
-
-        expect(service.keyring).toBeDefined();
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() => service.initialize({}));
-        expect(error.message).toBe('invalid ss58Format');
-      });
-    });
-
-    describe('addFromMnemonic', () => {
-      it('expect to add keypair from mnemonic', async () => {
-        await service.addFromMnemonic({
-          mnemonic: mnemonicGenerate(12),
-        });
-
-        expect(service.keyring).toBeDefined();
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() => service.addFromMnemonic({}));
-
-        expect(error.message).toBe('invalid mnemonic');
-      });
-    });
-  });
-});

package/src/services/keyring/service-rpc.js

@@ -1,56 +0,0 @@
-import {RpcService} from '../rpc-service-client';
-import {
-  AddFromJsonParams,
-  AddFromMnemonicParams,
-  AddressFromUriParams,
-  GetKeyringParams,
-  serviceName,
-  validation,
-  SignDataParams,
-} from './configs';
-
-export class KeyringServiceRpc extends RpcService {
-  constructor() {
-    super(serviceName);
-  }
-
-  initialize(params: InitializeParams) {
-    validation.initialize(params);
-    return this.call('initialize', params);
-  }
-
-  addFromMnemonic(params: AddFromMnemonicParams) {
-    validation.addFromMnemonic(params);
-    return this.call('addFromMnemonic', params);
-  }
-
-  addFromJson(params: AddFromJsonParams) {
-    validation.addFromJson(params);
-    return this.call('addFromJson', params);
-  }
-
-  decryptKeyPair(params: AddFromJsonParams) {
-    validation.addFromJson(params);
-    return this.call('decryptKeyPair', params);
-  }
-
-  getKeyringPair(params: GetKeyringParams) {
-    validation.getKeyringPair(params);
-    return this.call('getKeyringPair', params);
-  }
-
-  getKeyringPairJSON(params: GetKeyringParams) {
-    validation.getKeyringPair(params);
-    return this.call('getKeyringPairJSON', params);
-  }
-
-  addressFromUri(params: AddressFromUriParams) {
-    validation.addressFromUri(params);
-    return this.call('addressFromUri', params);
-  }
-
-  signData(params: SignDataParams) {
-    validation.signData(params);
-    return this.call('signData', params);
-  }
-}

package/src/services/keyring/service.ts

@@ -1,111 +0,0 @@
-// @ts-nocheck
-import Keyring from '@polkadot/keyring';
-import {cryptoWaitReady} from '@polkadot/util-crypto';
-import {
-  AddFromJsonParams,
-  AddFromMnemonicParams,
-  CreateFromUriParams,
-  CreateFromPairParams,
-  InitializeParams,
-  serviceName,
-  validation,
-  SignDataParams,
-} from './configs';
-
-export function getKeyring() {
-  return keyringService.keyring;
-}
-
-export class KeyringService {
-  keyring: Keyring;
-
-  rpcMethods = [
-    KeyringService.prototype.addFromJson,
-    KeyringService.prototype.addFromMnemonic,
-    KeyringService.prototype.addressFromUri,
-    KeyringService.prototype.getKeyringPair,
-    KeyringService.prototype.getKeyringPairJSON,
-    KeyringService.prototype.initialize,
-    KeyringService.prototype.signData,
-    KeyringService.prototype.decryptKeyPair,
-  ];
-
-  constructor() {
-    this.name = serviceName;
-  }
-
-  async initialize(params: InitializeParams) {
-    await cryptoWaitReady();
-
-    validation.initialize(params);
-
-    this.keyring = new Keyring(params);
-
-    return true;
-  }
-
-  addFromMnemonic({mnemonic, meta, type}: AddFromMnemonicParams) {
-    validation.addFromMnemonic({mnemonic, meta, type});
-    return this.keyring.addFromMnemonic(mnemonic, meta, type);
-  }
-
-  decryptKeyPair({jsonData, password}: {keyPair: any, password: string}) {
-    validation.addFromJson({jsonData, password});
-
-    const pair = this.keyring.addFromJson(jsonData);
-
-    pair.unlock(password);
-
-    return pair;
-  }
-
-  addFromJson({jsonData, password}: AddFromJsonParams) {
-    validation.addFromJson({jsonData, password});
-
-    const pair = this.keyring.addFromJson(jsonData);
-
-    pair.unlock(password);
-
-    return pair.toJson();
-  }
-
-  signData(params: SignDataParams): any {
-    validation.signData(params);
-    const account = this.keyring.addFromPair(params.keyPair);
-    return account.sign(params.data);
-  }
-
-  getKeyringPair(params: CreateFromUriParams): KeyringPair {
-    validation.getKeyringPair(params);
-
-    const {mnemonic, meta, type, derivePath = ''} = params;
-
-    return this.keyring.createFromUri(
-      `${mnemonic.trim()}${derivePath}`,
-      meta,
-      type,
-    );
-  }
-
-  createFromPair(params: CreateFromPairParams): KeyringPair {
-    validation.createFromPair(params);
-
-    const {pair, meta, type} = params;
-
-    return this.keyring.createFromPair(
-      pair,
-      meta,
-      type,
-    );
-  }
-
-  getKeyringPairJSON(params: CreateFromUriParams): KeyringPair {
-    return this.getKeyringPair(params).toJson();
-  }
-
-  addressFromUri(params: CreateFromUriParams) {
-    return this.getKeyringPair(params).address;
-  }
-}
-
-export const keyringService: KeyringService = new KeyringService();

package/src/services/polkadot/configs.ts

@@ -1,13 +0,0 @@
-// @ts-nocheck
-import {assertAddress} from '../../core/validation';
-
-export const validation = {
-  getAddressSvg({address, isAlternative}: GetAddressSvgParams) {
-    assertAddress(address);
-  },
-};
-
-export type GetAddressSvgParams = {
-  address: string,
-  isAlternative?: boolean,
-};

package/src/services/polkadot/index.android.js

@@ -1,3 +0,0 @@
-import {PolkadotServiceRpc} from './service-rpc';
-
-export const polkadotService = new PolkadotServiceRpc();

package/src/services/polkadot/index.ios.js

@@ -1,3 +0,0 @@
-import {PolkadotServiceRpc} from './service-rpc';
-
-export const polkadotService = new PolkadotServiceRpc();

package/src/services/polkadot/index.js

@@ -1 +0,0 @@
-export {polkadotService} from './service';

package/src/services/polkadot/index.test.js

@@ -1,52 +0,0 @@
-import {TestFixtures} from '../../fixtures';
-import {assertRpcService, getPromiseError} from '../test-utils';
-import {validation} from './configs';
-import {polkadotService as service} from './service';
-import {PolkadotServiceRpc} from './service-rpc';
-
-describe('PolkadotService', () => {
-  it('ServiceRpc', () => {
-    assertRpcService(PolkadotServiceRpc, service, validation);
-  });
-
-  describe('service', () => {
-    beforeAll(async () => {});
-
-    describe('getAddressSvg', () => {
-      it('expect to getAddressSvg', async () => {
-        const result = await service.getAddressSvg({
-          address: TestFixtures.account1.address,
-        });
-        expect(result).toEqual([
-          {cx: 32, cy: 32, fill: '#eee', r: 32},
-          {cx: 32, cy: 8, fill: 'hsl(118, 63%, 53%)', r: 5},
-          {cx: 32, cy: 20, fill: 'hsl(348, 63%, 35%)', r: 5},
-          {cx: 21.607695154586736, cy: 14, fill: 'hsl(225, 63%, 35%)', r: 5},
-          {cx: 11.215390309173472, cy: 20, fill: 'hsl(11, 63%, 75%)', r: 5},
-          {cx: 21.607695154586736, cy: 26, fill: 'hsl(264, 63%, 15%)', r: 5},
-          {cx: 11.215390309173472, cy: 32, fill: 'hsl(56, 63%, 15%)', r: 5},
-          {cx: 11.215390309173472, cy: 44, fill: 'hsl(95, 63%, 75%)', r: 5},
-          {cx: 21.607695154586736, cy: 38, fill: 'hsl(163, 63%, 75%)', r: 5},
-          {cx: 21.607695154586736, cy: 50, fill: 'hsl(33, 63%, 53%)', r: 5},
-          {cx: 32, cy: 56, fill: 'hsl(213, 63%, 75%)', r: 5},
-          {cx: 32, cy: 44, fill: 'hsl(281, 63%, 15%)', r: 5},
-          {cx: 42.392304845413264, cy: 50, fill: 'hsl(33, 63%, 53%)', r: 5},
-          {cx: 52.78460969082653, cy: 44, fill: 'hsl(95, 63%, 75%)', r: 5},
-          {cx: 42.392304845413264, cy: 38, fill: 'hsl(163, 63%, 75%)', r: 5},
-          {cx: 52.78460969082653, cy: 32, fill: 'hsl(56, 63%, 15%)', r: 5},
-          {cx: 52.78460969082653, cy: 20, fill: 'hsl(11, 63%, 75%)', r: 5},
-          {cx: 42.392304845413264, cy: 26, fill: 'hsl(264, 63%, 15%)', r: 5},
-          {cx: 42.392304845413264, cy: 14, fill: 'hsl(225, 63%, 35%)', r: 5},
-          {cx: 32, cy: 32, fill: 'hsl(39, 63%, 15%)', r: 5},
-        ]);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getAddressSvg({address: undefined}),
-        );
-        expect(error.message).toBe('invalid address: undefined');
-      });
-    });
-  });
-});

package/src/services/polkadot/service-rpc.js

@@ -1,13 +0,0 @@
-import {RpcService} from '../rpc-service-client';
-import {GetAddressSvgParams, validation} from './configs';
-
-export class PolkadotServiceRpc extends RpcService {
-  constructor() {
-    super('polkadot');
-  }
-
-  getAddressSvg(params: GetAddressSvgParams): Promise<any> {
-    validation.getAddressSvg(params);
-    return this.call('getAddressSvg', params);
-  }
-}

package/src/services/polkadot/service.ts

@@ -1,21 +0,0 @@
-// @ts-nocheck
-import {polkadotIcon} from '@polkadot/ui-shared/cjs/icons/index';
-import {GetAddressSvgParams, validation} from './configs';
-
-export class PolkadotService {
-  rpcMethods = [PolkadotService.prototype.getAddressSvg];
-
-  constructor() {
-    this.name = 'polkadot';
-  }
-
-  async getAddressSvg(params: GetAddressSvgParams) {
-    validation.getAddressSvg(params);
-
-    return polkadotIcon(params.address, {
-      isAlternative: params.isAlternative,
-    });
-  }
-}
-
-export const polkadotService: PolkadotService = new PolkadotService();

package/src/services/substrate/api-utils.test.js

@@ -1,73 +0,0 @@
-import {DOCK_TOKEN_UNIT} from '../../core/format-utils';
-import {TestFixtures} from '../../fixtures';
-import {once} from '../../modules/event-manager';
-import {blockchainService} from '../blockchain/service';
-import {mockDockService, setMockTransactionError} from '../test-utils';
-import {signAndSend} from './api-utils';
-import {substrateService} from './service';
-
-describe('ApiUtils', () => {
-  let unmockDockService;
-
-  beforeAll(async () => {
-    unmockDockService = await mockDockService();
-  });
-
-  describe('signAndSend', () => {
-    it('expect to send tokens', async () => {
-      const account = TestFixtures.account1.getKeyring();
-      blockchainService.dock.setAccount(account);
-      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
-        TestFixtures.account2.address,
-        1,
-      );
-      setMockTransactionError(null);
-      const emitter = signAndSend(account, extrinsic);
-      const [result] = await once(emitter, 'done');
-
-      console.log('tx hash', result);
-
-      expect(typeof result).toBe('string');
-    });
-
-    it('expect to get error: Inability to pay fees', async () => {
-      const account = TestFixtures.noBalanceAccount.getKeyring();
-      blockchainService.dock.setAccount(account);
-      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
-        TestFixtures.account2.address,
-        1,
-      );
-      const errorMessage =
-        '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low';
-
-      setMockTransactionError(errorMessage);
-      const emitter = signAndSend(account, extrinsic);
-      const error = await once(emitter, 'error');
-
-      expect(error.message).toBe(errorMessage);
-    });
-
-    it('expect to get error: Not enough balance', async () => {
-      const account = TestFixtures.account1.getKeyring();
-      blockchainService.dock.setAccount(account);
-      const balance = await substrateService.getAccountBalance({
-        address: TestFixtures.account1.address,
-      });
-      const extrinsic = blockchainService.dock.api.tx.balances.transfer(
-        TestFixtures.account2.address,
-        balance * 2 * DOCK_TOKEN_UNIT,
-      );
-
-      const errorMessage =
-        'balances.InsufficientBalance:  Balance too low to send value';
-
-      setMockTransactionError(errorMessage);
-      const emitter = signAndSend(account, extrinsic);
-      const error = await once(emitter, 'error');
-
-      expect(error.message).toBe(errorMessage);
-    });
-  });
-
-  afterAll(() => unmockDockService);
-});

package/src/services/substrate/api-utils.ts

@@ -1,66 +0,0 @@
-// @ts-nocheck
-import assert from 'assert';
-import {EventEmitter} from 'events';
-import {Logger} from '../../core/logger';
-import {blockchainService} from '../blockchain/service';
-
-export const extrisicErrorsFilter = ({event}) => {
-  return blockchainService.dock.api.events.system.ExtrinsicFailed.is(event);
-};
-
-export const mapEventToErrorMessage = ({event}) => {
-  assert(!!event, 'event is required');
-
-  const [error] = event.data;
-  assert(!!error, 'error is required');
-
-  if (error.isModule) {
-    // for module errors, we have the section indexed, lookup
-    const decoded = blockchainService.dock.api.registry.findMetaError(error.asModule);
-    const {docs, method, section} = decoded;
-
-    return `${section}.${method}: ${docs.join(' ')}`;
-  }
-
-  return error.toString();
-};
-
-export const getExtrinsicErrors = ({status, events}) =>
-  events.filter(extrisicErrorsFilter).map(mapEventToErrorMessage);
-
-export function signAndSend(account, extrinsic: any): EventEmitter {
-  const emitter = new EventEmitter();
-
-  function execute() {
-    extrinsic
-      .signAndSend(account, result => {
-        const {status} = result;
-
-        Logger.debug(`extrinsic update ${JSON.stringify(result)}`);
-
-        if (status.isInBlock || status.isFinalized) {
-          const errors = getExtrinsicErrors(result);
-
-          if (!errors.length) {
-            return emitter.emit('done', status.toHex());
-          }
-
-          emitter.emit('error', new Error(errors[0]));
-          emitter.emit('errors', errors);
-        } else if (status.isInvalid) {
-          emitter.emit('error', new Error('Transaction status is invalid'));
-        } else if (status.isDropped) {
-          emitter.emit('error', new Error('Transaction status dropped'));
-        } else if (status.isRetracted) {
-          emitter.emit('error', new Error('Transaction status is retracted'));
-        }
-      })
-      .catch(err => {
-        emitter.emit('error', err);
-      });
-  }
-
-  setTimeout(execute, 1);
-
-  return emitter;
-}

package/src/services/substrate/configs.ts

@@ -1,34 +0,0 @@
-// @ts-nocheck
-import assert from 'assert';
-import {isAddressValid, isNumberValid} from '../../core/validation';
-
-const assertTransaction = ({
-  toAddress,
-  fromAddress,
-  amount,
-}: TransactionParams) => {
-  assert(isAddressValid(toAddress), 'invalid toAddress');
-  assert(isAddressValid(fromAddress), 'invalid fromAddress');
-  assert(isNumberValid(amount), 'invalid amount');
-};
-
-export const validation = {
-  getAccountBalance({address}: GetAccountBalanceParams) {
-    assert(isAddressValid(address), `invalid address ${address}`);
-  },
-  getFeeAmount: assertTransaction,
-  sendTokens: assertTransaction,
-};
-
-export const serviceName = 'substrate';
-
-export type GetAccountBalanceParams = {
-  address: string,
-};
-
-export type TransactionParams = {
-  toAddress: string,
-  fromAddress: string,
-  amount: number | string,
-  transferAll?: boolean,
-};

package/src/services/substrate/index.android.js

@@ -1,3 +0,0 @@
-import {SubstrateServiceRpc} from './service-rpc';
-
-export const substrateService = new SubstrateServiceRpc();

package/src/services/substrate/index.ios.js

@@ -1,3 +0,0 @@
-import {SubstrateServiceRpc} from './service-rpc';
-
-export const substrateService = new SubstrateServiceRpc();

package/src/services/substrate/index.js

@@ -1 +0,0 @@
-export {substrateService} from './service';