@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/core/crypto.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var crypto = require('crypto');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+
+const DEFAULT_KEY =
+  process.env.ENCRYPTION_KEY || process.env.REACT_APP_ENCRYPTION_KEY;
+const SECURE_JSON_RPC = process.env.ENCRYPTION_ENABLED;
+
+if (SECURE_JSON_RPC) {
+  assert__default["default"](DEFAULT_KEY, 'ENCRYPTION_KEY is required');
+}
+
+let key = SECURE_JSON_RPC && Buffer.from(DEFAULT_KEY, 'hex');
+
+const iv = crypto__default["default"].randomBytes(16);
+
+function encryptData(text) {
+  let cipher = crypto__default["default"].createCipheriv('aes-256-cbc', Buffer.from(key), iv);
+  let encrypted = cipher.update(text);
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  return {iv: iv.toString('hex'), encryptedData: encrypted.toString('hex')};
+}
+
+function decryptData(text) {
+  let dIv = Buffer.from(text.iv, 'hex');
+  let encryptedText = Buffer.from(text.encryptedData, 'hex');
+  let decipher = crypto__default["default"].createDecipheriv('aes-256-cbc', Buffer.from(key), dIv);
+  let decrypted = decipher.update(encryptedText);
+
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString();
+}
+
+exports.DEFAULT_KEY = DEFAULT_KEY;
+exports.SECURE_JSON_RPC = SECURE_JSON_RPC;
+exports.decryptData = decryptData;
+exports.encryptData = encryptData;

package/lib/core/crypto.mjs

@@ -0,0 +1,33 @@
+import assert from 'assert';
+import crypto from 'crypto';
+
+const DEFAULT_KEY =
+  process.env.ENCRYPTION_KEY || process.env.REACT_APP_ENCRYPTION_KEY;
+const SECURE_JSON_RPC = process.env.ENCRYPTION_ENABLED;
+
+if (SECURE_JSON_RPC) {
+  assert(DEFAULT_KEY, 'ENCRYPTION_KEY is required');
+}
+
+let key = SECURE_JSON_RPC && Buffer.from(DEFAULT_KEY, 'hex');
+
+const iv = crypto.randomBytes(16);
+
+function encryptData(text) {
+  let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key), iv);
+  let encrypted = cipher.update(text);
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  return {iv: iv.toString('hex'), encryptedData: encrypted.toString('hex')};
+}
+
+function decryptData(text) {
+  let dIv = Buffer.from(text.iv, 'hex');
+  let encryptedText = Buffer.from(text.encryptedData, 'hex');
+  let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key), dIv);
+  let decrypted = decipher.update(encryptedText);
+
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString();
+}
+
+export { DEFAULT_KEY, SECURE_JSON_RPC, decryptData, encryptData };

package/lib/core/format-utils.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var BigNumber = require('bignumber.js');
+var core_validation = require('./validation.js');
+require('../types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
+
+// @ts-nocheck
+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
+ */
+function formatCurrency(value, currency = 'USD', locale = 'en-US') {
+    assert__default["default"](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);
+}
+function formatAddress(address, size = 19) {
+    assert__default["default"](!!address, 'address is required');
+    assert__default["default"](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)}`;
+}
+function formatDockAmount(value) {
+    assert__default["default"](!!value, 'value is required');
+    assert__default["default"](core_validation.isNumberValid(value), 'value is not valid');
+    return BigNumber__default["default"](value).dividedBy(DOCK_TOKEN_UNIT).toNumber();
+}
+function getPlainDockAmount(value) {
+    assert__default["default"](!!value, 'value is required');
+    assert__default["default"](core_validation.isNumberValid(value), 'value is not valid');
+    return BigNumber__default["default"](value).times(DOCK_TOKEN_UNIT);
+}
+/**
+ *
+ * @param date
+ * @param locale
+ * @returns {string}
+ */
+function formatDate(date, locale = 'en-US') {
+    assert__default["default"](!!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);
+}
+
+exports.DOCK_TOKEN_UNIT = DOCK_TOKEN_UNIT;
+exports.formatAddress = formatAddress;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatDockAmount = formatDockAmount;
+exports.getPlainDockAmount = getPlainDockAmount;

package/lib/core/format-utils.mjs

@@ -0,0 +1,65 @@
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { isNumberValid } from './validation.mjs';
+import '../types.mjs';
+
+// @ts-nocheck
+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
+ */
+function formatCurrency(value, currency = 'USD', locale = 'en-US') {
+    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);
+}
+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)}`;
+}
+function formatDockAmount(value) {
+    assert(!!value, 'value is required');
+    assert(isNumberValid(value), 'value is not valid');
+    return BigNumber(value).dividedBy(DOCK_TOKEN_UNIT).toNumber();
+}
+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}
+ */
+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);
+}
+
+export { DOCK_TOKEN_UNIT, formatAddress, formatCurrency, formatDate, formatDockAmount, getPlainDockAmount };

package/lib/core/keychain.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RNKeychain = require('react-native-keychain');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var RNKeychain__namespace = /*#__PURE__*/_interopNamespace(RNKeychain);
+
+const Keychain = {
+  ...RNKeychain__namespace,
+  setItem(id, data = {}, options = {}) {
+    const jsonData = JSON.stringify(data);
+
+    options.service = id;
+
+    return RNKeychain__namespace.setGenericPassword(
+      jsonData,
+      data.password || '',
+      options,
+    );
+  },
+  removeItem(id) {
+    return RNKeychain__namespace.resetGenericPassword({
+      service: id,
+    });
+  },
+  async getItem(id, options = {}) {
+    const result = await RNKeychain__namespace.getGenericPassword({
+      service: id,
+      ...options,
+    });
+
+    if (!result) {
+      return;
+    }
+
+    const data = JSON.parse(result.username);
+
+    return data;
+  },
+};
+
+exports.Keychain = Keychain;

package/lib/core/keychain.mjs

@@ -0,0 +1,37 @@
+import * as RNKeychain from 'react-native-keychain';
+
+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;
+  },
+};
+
+export { Keychain };

package/lib/core/logger.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const winston = require('winston');
+
+const Logger = winston.createLogger({
+  format: winston.format.simple(),
+  level: process.env.LOGGER_LEVEL || 'info',
+  transports: [new winston.transports.Console()],
+});
+
+exports.Logger = Logger;

package/lib/core/logger.mjs

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

package/lib/core/polkadot-utils.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utilCrypto = require('@polkadot/util-crypto');
+var decode = require('@polkadot/keyring/pair/decode');
+var misc = require('@docknetwork/sdk/utils/misc');
+var bs58 = require('base58-universal');
+var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var bs58__namespace = /*#__PURE__*/_interopNamespace(bs58);
+
+const polkadotTypesToKeys = {
+  sr25519: 'Sr25519VerificationKey2020',
+  ed25519: 'Ed25519VerificationKey2018',
+  secp256k1: 'EcdsaSecp256k1VerificationKey2019',
+  ecdsa: 'EcdsaSecp256k1VerificationKey2019',
+};
+
+const TYPE_FROM_SEED = {
+  ecdsa: utilCrypto.secp256k1PairFromSeed,
+  secp256k1: utilCrypto.secp256k1PairFromSeed,
+  ed25519: utilCrypto.ed25519PairFromSeed,
+  ethereum: utilCrypto.secp256k1PairFromSeed,
+  sr25519: utilCrypto.sr25519PairFromSeed,
+};
+
+function polkadotToKeydoc(
+  polkadotKeys,
+  controller = undefined,
+  keyPassphrase = 'test',
+) {
+  const keyjson = polkadotKeys.toJson(keyPassphrase);
+  const polkadotType = polkadotKeys.type || misc.getKeyPairType(polkadotKeys);
+
+  // NOTE: polkadotKeys.publicKey and publicKey from decodePair result are different for ecdsa type by an extra value on the end
+  const decoded = decode.decodePair(
+    keyPassphrase,
+    utilCrypto.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__namespace.encode(publicKey);
+  const privateKeyBase58 = bs58__namespace.encode(secretKey);
+  const formattedkeyDoc = {
+    id: `${controller}#${utilCrypto.encodeAddress(publicKey)}`,
+    controller,
+    type: kpType,
+    publicKeyBase58,
+    privateKeyBase58,
+    publicKeyMultibase: `z${publicKeyBase58}`,
+    privateKeyMultibase: `z${privateKeyBase58}`,
+  };
+
+  // auto create controller
+  if (!controller) {
+    const keypairInstance = keypairs.getKeypairFromDoc(formattedkeyDoc);
+    const fingerprint = keypairInstance.fingerprint();
+    if (!formattedkeyDoc.controller) {
+      formattedkeyDoc.controller = `did:key:${fingerprint}`;
+      formattedkeyDoc.id = `${formattedkeyDoc.controller}#${fingerprint}`;
+    }
+  }
+  return formattedkeyDoc;
+}
+
+exports.polkadotToKeydoc = polkadotToKeydoc;

package/lib/core/polkadot-utils.mjs

@@ -0,0 +1,81 @@
+import { base64Decode, encodeAddress, secp256k1PairFromSeed, ed25519PairFromSeed, sr25519PairFromSeed } 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,
+};
+
+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;
+}
+
+export { polkadotToKeydoc };

package/lib/core/realm-schemas.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const TokenPrice = {
+  name: 'TokenPrice',
+  properties: {
+    symbol: 'string',
+    name: 'string?',
+    price: 'float',
+  },
+  primaryKey: 'symbol',
+};
+
+const Account = {
+  name: 'Account',
+  properties: {
+    id: 'string',
+    name: 'string',
+    balance: 'string?',
+  },
+  network: {
+    type: 'string',
+    default: 'testnet',
+  },
+  readyOnly: {
+    type: 'bool',
+    default: false,
+  },
+  primaryKey: 'id',
+};
+
+const RequestLog = {
+  name: 'RequestLog',
+  properties: {
+    id: 'string',
+    url: 'string',
+    status: 'int',
+    method: 'string',
+    headers: 'string',
+    body: 'string',
+    response: 'string',
+    createdAt: 'date',
+  },
+  primaryKey: 'id',
+};
+
+exports.Account = Account;
+exports.RequestLog = RequestLog;
+exports.TokenPrice = TokenPrice;

package/lib/core/realm-schemas.mjs

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

package/lib/core/storage.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let storage;
+function setStorage(item) {
+    storage = item;
+}
+function getStorage() {
+    return storage;
+}
+
+exports.getStorage = getStorage;
+exports.setStorage = setStorage;

package/lib/core/storage.mjs

@@ -0,0 +1,9 @@
+let storage;
+function setStorage(item) {
+    storage = item;
+}
+function getStorage() {
+    return storage;
+}
+
+export { getStorage, setStorage };