@docknetwork/wallet-sdk-wasm 0.4.19

package/src/core/format-utils.ts

@@ -0,0 +1,91 @@
+// @ts-nocheck
+/**
+ * Format utils module
+ *
+ * @module core/format-utils
+ */
+
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import {isNumberValid} from './validation';
+
+export const DOCK_TOKEN_UNIT = 1000000;
+
+/**
+ * Format number as currency
+ * @alias core/format-utils#formatCurrency
+ * @example
+ * const value = formatCurrency(10.5);
+ * // value = $10.50
+ *
+ * @param {number} value
+ * @param {string} currency
+ * * @param {string} locale
+ * @returns string
+ */
+export function formatCurrency(
+  value,
+  currency = 'USD',
+  locale = 'en-US',
+): string {
+  assert(
+    typeof value === 'number' || typeof value === 'bigint',
+    'value must be a number or bigint',
+  );
+
+  const formatter = new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency: currency,
+
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 4,
+  });
+
+  return formatter.format(value);
+}
+
+export function formatAddress(address, size = 19) {
+  assert(!!address, 'address is required');
+  assert(typeof address === 'string', 'address must be a string');
+
+  if (!address || size > address.length) {
+    return address;
+  }
+
+  const offset = size / 2;
+
+  return `${address.substring(0, offset)}...${address.substring(
+    address.length - offset,
+  )}`;
+}
+
+export function formatDockAmount(value) {
+  assert(!!value, 'value is required');
+  assert(isNumberValid(value), 'value is not valid');
+
+  return BigNumber(value).dividedBy(DOCK_TOKEN_UNIT).toNumber();
+}
+
+export function getPlainDockAmount(value) {
+  assert(!!value, 'value is required');
+  assert(isNumberValid(value), 'value is not valid');
+
+  return BigNumber(value).times(DOCK_TOKEN_UNIT);
+}
+
+/**
+ *
+ * @param date
+ * @param locale
+ * @returns {string}
+ */
+export function formatDate(date, locale = 'en-US') {
+  assert(!!date, 'date is required');
+
+  const dateFormat = new Intl.DateTimeFormat(locale, {
+    month: 'long',
+    day: 'numeric',
+    year: 'numeric',
+  });
+  return dateFormat.format(typeof date === 'string' ? new Date(date) : date);
+}

package/src/core/keychain.js

@@ -0,0 +1,35 @@
+import * as RNKeychain from 'react-native-keychain';
+
+export const Keychain = {
+  ...RNKeychain,
+  setItem(id, data = {}, options = {}) {
+    const jsonData = JSON.stringify(data);
+
+    options.service = id;
+
+    return RNKeychain.setGenericPassword(
+      jsonData,
+      data.password || '',
+      options,
+    );
+  },
+  removeItem(id) {
+    return RNKeychain.resetGenericPassword({
+      service: id,
+    });
+  },
+  async getItem(id, options = {}) {
+    const result = await RNKeychain.getGenericPassword({
+      service: id,
+      ...options,
+    });
+
+    if (!result) {
+      return;
+    }
+
+    const data = JSON.parse(result.username);
+
+    return data;
+  },
+};

package/src/core/logger.js

@@ -0,0 +1,7 @@
+const winston = require('winston');
+
+export const Logger = winston.createLogger({
+  format: winston.format.simple(),
+  level: process.env.LOGGER_LEVEL || 'info',
+  transports: [new winston.transports.Console()],
+});

package/src/core/polkadot-utils.js

@@ -0,0 +1,88 @@
+import {
+  base64Decode,
+  encodeAddress,
+  ed25519PairFromSeed,
+  sr25519PairFromSeed,
+  secp256k1PairFromSeed,
+} from '@polkadot/util-crypto';
+
+import {decodePair} from '@polkadot/keyring/pair/decode';
+import {getKeyPairType} from '@docknetwork/sdk/utils/misc';
+
+import * as bs58 from 'base58-universal';
+
+import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
+
+const polkadotTypesToKeys = {
+  sr25519: 'Sr25519VerificationKey2020',
+  ed25519: 'Ed25519VerificationKey2018',
+  secp256k1: 'EcdsaSecp256k1VerificationKey2019',
+  ecdsa: 'EcdsaSecp256k1VerificationKey2019',
+};
+
+const TYPE_FROM_SEED = {
+  ecdsa: secp256k1PairFromSeed,
+  secp256k1: secp256k1PairFromSeed,
+  ed25519: ed25519PairFromSeed,
+  ethereum: secp256k1PairFromSeed,
+  sr25519: sr25519PairFromSeed,
+};
+
+export function polkadotToKeydoc(
+  polkadotKeys,
+  controller = undefined,
+  keyPassphrase = 'test',
+) {
+  const keyjson = polkadotKeys.toJson(keyPassphrase);
+  const polkadotType = polkadotKeys.type || getKeyPairType(polkadotKeys);
+
+  // NOTE: polkadotKeys.publicKey and publicKey from decodePair result are different for ecdsa type by an extra value on the end
+  const decoded = decodePair(
+    keyPassphrase,
+    base64Decode(keyjson.encoded),
+    keyjson.encoding.type,
+  );
+
+  let publicKey;
+  let secretKey;
+  if (decoded.secretKey.length === 64) {
+    publicKey = decoded.publicKey;
+    secretKey = decoded.secretKey;
+  } else {
+    const typeFunc = TYPE_FROM_SEED[polkadotType];
+    if (!typeFunc) {
+      throw new Error(`Unsupported key type: ${polkadotType}`);
+    }
+    const pair = typeFunc(decoded.secretKey);
+    publicKey = pair.publicKey;
+    secretKey = pair.secretKey;
+  }
+
+  const kpType = polkadotTypesToKeys[polkadotType];
+  if (!kpType) {
+    throw new Error(`Unknown polkadot type: ${polkadotType}`);
+  }
+
+  const publicKeyBase58 = bs58.encode(publicKey);
+  const privateKeyBase58 = bs58.encode(secretKey);
+  const formattedkeyDoc = {
+    id: `${controller}#${encodeAddress(publicKey)}`,
+    controller,
+    type: kpType,
+    publicKeyBase58,
+    privateKeyBase58,
+    publicKeyMultibase: `z${publicKeyBase58}`,
+    privateKeyMultibase: `z${privateKeyBase58}`,
+  };
+
+  // auto create controller
+  if (!controller) {
+    const keypairInstance = getKeypairFromDoc(formattedkeyDoc);
+    const fingerprint = keypairInstance.fingerprint();
+    if (!formattedkeyDoc.controller) {
+      formattedkeyDoc.controller = `did:key:${fingerprint}`;
+      formattedkeyDoc.id = `${formattedkeyDoc.controller}#${fingerprint}`;
+    }
+  }
+  return formattedkeyDoc;
+}

package/src/core/realm-schemas.js

@@ -0,0 +1,42 @@
+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/storage.ts

@@ -0,0 +1,16 @@
+// @ts-nocheck
+export interface StorageInterface {
+  setItem(key: string, item: string): Promise<void>;
+  getItem(): Promise<string>;
+  remoteItem(key: string): Promise<void>;
+}
+
+let storage: StorageInterface;
+
+export function setStorage(item: StorageInterface) {
+  storage = item;
+}
+
+export function getStorage(): StorageInterface {
+  return storage;
+}

package/src/core/subscan.js

@@ -0,0 +1,63 @@
+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';
+
+const queue = new TaskQueue(global.Promise, 1);
+
+function doFetchTransactions({address, page = 0, itemsPerPage = 50}) {
+  const url = `${SUBSCAN_URL}/api/scan/transfers`;
+
+  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 ${url} with body ${JSON.stringify(
+      body,
+    )}`,
+  );
+
+  return axios
+    .post(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

@@ -0,0 +1,56 @@
+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/core/validation.test.js

@@ -0,0 +1,41 @@
+import BigNumber from 'bignumber.js';
+import {
+  assertAddress,
+  assertTokenAmount,
+  isAddressValid,
+  isNumberValid,
+} from './validation';
+
+describe('core validation', () => {
+  it('isAddressValid', () => {
+    expect(isAddressValid(' ')).toBeFalsy();
+    expect(isAddressValid('   ')).toBeFalsy();
+    expect(isAddressValid('')).toBeFalsy();
+    expect(isAddressValid(null)).toBeFalsy();
+    expect(isAddressValid(undefined)).toBeFalsy();
+    expect(isAddressValid(123)).toBeFalsy();
+    expect(isAddressValid('address')).toBeTruthy();
+  });
+
+  it('isNumberValid', () => {
+    expect(isNumberValid('100000000')).toBeTruthy();
+    expect(isNumberValid('this is not valid')).toBeFalsy();
+    expect(isNumberValid(false)).toBeFalsy();
+    expect(isNumberValid(10)).toBeTruthy();
+    expect(isNumberValid(BigNumber(1))).toBeTruthy();
+  });
+
+  it('assertAddress', () => {
+    expect(() => assertAddress(' ')).toThrow(`invalid address: ${' '}`);
+    expect(() => assertAddress(null)).toThrow('invalid address: null');
+    expect(() => assertAddress('address')).not.toThrow();
+  });
+
+  it('assertTokenAmount', () => {
+    expect(() => assertTokenAmount(' ')).toThrow('invalid token amount');
+    expect(() => assertTokenAmount('abc')).toThrow('invalid token amount');
+    expect(() => assertTokenAmount(null)).toThrow('invalid token amount');
+    expect(() => assertTokenAmount('10')).not.toThrow();
+    expect(() => assertTokenAmount(100)).not.toThrow();
+  });
+});

package/src/core/validation.ts

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import BigNumber from 'bignumber.js';
+import assert from 'assert';
+import {KeypairTypes} from '../types';
+
+export {assert};
+
+export function isNumberValid(v: any) {
+  if (v instanceof BigNumber) {
+    return true;
+  }
+
+  return !isNaN(parseInt(v, 10));
+}
+
+export function assertKeyType(type) {
+  assert(
+    !!KeypairTypes.find(t => t === type),
+    `Invalid keypair type ${type}. Expected one of ${KeypairTypes.join(',')}`,
+  );
+}
+
+export function assertPassword(password) {
+  assert(typeof password === 'string', `invalid password: ${password}`);
+}
+
+export function assertTokenAmount(amount) {
+  assert(isNumberValid(amount), 'invalid token amount');
+}
+
+export function assertAddress(address, name = 'address') {
+  assert(isAddressValid(address), `invalid ${name}: ${address}`);
+}
+
+export function isAddressValid(address) {
+  if (!address || typeof address !== 'string') {
+    return false;
+  }
+
+  if (!address.trim()) {
+    return false;
+  }
+
+  return true;
+}

package/src/core/webview-logger.js

@@ -0,0 +1,39 @@
+import Transport from 'winston-transport';
+
+export class WebviewLoggerTransport extends Transport {
+  postMessage = () => {};
+
+  constructor({postMessage, ...opts}) {
+    super(opts);
+
+    this.postMessage = postMessage;
+  }
+
+  log(...params) {
+    this.postMessage({
+      type: 'log',
+      body: JSON.stringify(params),
+    });
+  }
+
+  debug(...params) {
+    this.postMessage({
+      type: 'log',
+      body: JSON.stringify(params),
+    });
+  }
+
+  info(...params) {
+    this.postMessage({
+      type: 'log',
+      body: JSON.stringify(params),
+    });
+  }
+
+  error(...params) {
+    this.postMessage({
+      type: 'log',
+      body: JSON.stringify(params),
+    });
+  }
+}

package/src/errors.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+export class SdkError extends Error {
+  constructor(message?: string) {
+    super(message);
+    Object.setPrototypeOf(this, SdkError.prototype);
+  }
+}
+
+export const Errors = {
+  accountAlreadyExists: 'account already exists',
+};

package/src/events.js

@@ -0,0 +1,11 @@
+import {EventEmitter} from 'events';
+
+let emitter = new EventEmitter();
+
+export function setRpcEventEmitter(e) {
+  emitter = e;
+}
+
+export function getRpcEventEmitter() {
+  return emitter;
+}

package/src/fixtures.js

@@ -0,0 +1,43 @@
+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/index.js

@@ -0,0 +1,67 @@
+import {getRpcClient, initRpcClient} from './rpc-client';
+import {getLogger, setLogger} from './logger';
+import {Logger} from './core/logger';
+import rpcServer from './rpc-server';
+import {WebviewLoggerTransport} from './core/webview-logger';
+
+initRpcClient(jsonRPCRequest => {
+  postMessage({
+    type: 'json-rpc-request',
+    body: jsonRPCRequest,
+  });
+
+  return Promise.resolve(jsonRPCRequest);
+});
+
+const postMessage = message => {
+  if (window.ReactNativeWebView) {
+    window.ReactNativeWebView.postMessage(JSON.stringify(message));
+  } else {
+    console.log(message);
+  }
+};
+
+const addEventListener = (...args) =>
+  (navigator.appVersion.includes('Android')
+    ? document
+    : window
+  ).addEventListener(...args);
+
+setLogger({
+  log: (...params) => {
+    postMessage({
+      type: 'log',
+      body: JSON.stringify(params),
+    });
+  },
+});
+
+Logger.add(
+  new WebviewLoggerTransport({
+    postMessage,
+  }),
+);
+
+global.handleEvent = event => {
+  const data = event.data;
+
+  if (data && data.type === 'json-rpc-request') {
+    rpcServer.receive(data.body).then(response => {
+      postMessage({
+        type: 'json-rpc-response',
+        body: response,
+      });
+    });
+  }
+
+  if (data && data.type === 'json-rpc-response') {
+    getLogger().log('webview: Received response', data.body);
+    getRpcClient().receive(data.body);
+  }
+};
+
+addEventListener('message', global.handleEvent);
+
+postMessage({
+  type: 'json-rpc-ready',
+});

package/src/logger.js

@@ -0,0 +1,15 @@
+let logger = {
+  log: (...args) => {
+    if (process.env.NODE_ENV !== 'test') {
+      console.log(...args);
+    }
+  },
+};
+
+export function setLogger(l) {
+  logger = l;
+}
+
+export function getLogger() {
+  return logger;
+}