@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/wallet/memory-storage-interface.mjs

@@ -0,0 +1,95 @@
+import StorageInterface from '@docknetwork/universal-wallet/storage/storage-interface';
+
+function generateDocumentId() {
+  return `doc${Math.floor(Math.random() * 10000)}`;
+}
+
+/* An example file system storage interface implementation. This is not secure and shouldn't be used in production */
+class MemoryStorageInterface extends StorageInterface {
+  constructor(directory) {
+    super();
+
+    this.directory = directory;
+
+    try {
+      this.documents = JSON.parse(global.localStorage.getItem(directory));
+
+      if (!this.documents) {
+        this.documents = {};
+      }
+    } catch (err) {
+      console.error(err);
+      this.documents = {};
+    }
+  }
+
+  updateLocalStorage() {
+    global.localStorage.setItem(this.directory, JSON.stringify(this.documents));
+  }
+
+  async get({id}) {
+    const content = this.documents[id];
+    return {
+      id,
+      content,
+    };
+  }
+
+  async update(options) {
+    return this.insert(options);
+  }
+
+  async delete({document}) {
+    delete this.documents[document.id];
+    this.updateLocalStorage();
+  }
+
+  async insert({document}) {
+    const docId = document.id || generateDocumentId();
+
+    this.documents[docId] = document.content;
+
+    this.updateLocalStorage();
+
+    return {
+      id: docId,
+      ...document,
+    };
+  }
+
+  async count(query) {
+    const result = await this.find(query);
+    return result.length;
+  }
+
+  async find({has = undefined, equals = undefined} = {}) {
+    const documents = Object.keys(this.documents || {})
+      .map(docId => {
+        const content = this.documents[docId];
+
+        let matchesQuery = false;
+        if (!has && !equals) {
+          // Return all documents
+          matchesQuery = true;
+        } else if (equals && equals['content.id']) {
+          // Basic "query" support for tests
+          matchesQuery = content.id === equals['content.id'];
+        } else if (equals && equals['content.type']) {
+          matchesQuery = content.type === equals['content.type'];
+        }
+
+        if (matchesQuery) {
+          return {
+            id: docId,
+            content,
+          };
+        }
+
+        return null;
+      })
+      .filter(value => !!value);
+    return {documents};
+  }
+}
+
+export { MemoryStorageInterface as default };

package/lib/wallet/memory-storage-wallet.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var StorageWallet = require('@docknetwork/universal-wallet/storage-wallet');
+var wallet_memoryStorageInterface = require('./memory-storage-interface.js');
+require('@docknetwork/universal-wallet/storage/storage-interface');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var StorageWallet__default = /*#__PURE__*/_interopDefaultLegacy(StorageWallet);
+
+class MemoryWallet extends StorageWallet__default["default"] {
+  constructor(id, storageOptions = {}) {
+    // Allow user to pass pre-initialized interface or construct a default one
+    const storageInterface =
+      storageOptions.storageInterface || new wallet_memoryStorageInterface(id);
+    super(id, storageInterface);
+  }
+
+  async import(data, password) {
+    const result = await super.import(data, password);
+
+    this.contents.forEach(content => {
+      this.promises.push(this.insertToStorage(content));
+    });
+
+    return result;
+  }
+}
+
+module.exports = MemoryWallet;

package/lib/wallet/memory-storage-wallet.mjs

@@ -0,0 +1,24 @@
+import StorageWallet from '@docknetwork/universal-wallet/storage-wallet';
+import MemoryStorageInterface from './memory-storage-interface.mjs';
+import '@docknetwork/universal-wallet/storage/storage-interface';
+
+class MemoryWallet extends StorageWallet {
+  constructor(id, storageOptions = {}) {
+    // Allow user to pass pre-initialized interface or construct a default one
+    const storageInterface =
+      storageOptions.storageInterface || new MemoryStorageInterface(id);
+    super(id, storageInterface);
+  }
+
+  async import(data, password) {
+    const result = await super.import(data, password);
+
+    this.contents.forEach(content => {
+      this.promises.push(this.insertToStorage(content));
+    });
+
+    return result;
+  }
+}
+
+export { MemoryWallet as default };

package/lib/wallet/rpc-storage-interface.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var StorageInterface = require('@docknetwork/universal-wallet/storage/storage-interface');
+var uuid = require('uuid');
+var services_storage_service = require('../services/storage/service.js');
+var core_logger = require('../core/logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var StorageInterface__default = /*#__PURE__*/_interopDefaultLegacy(StorageInterface);
+
+function generateDocumentId() {
+  return `doc:${uuid.v4()}`;
+}
+
+/* An example file system storage interface implementation. This is not secure and shouldn't be used in production */
+class RpcStorageInterface extends StorageInterface__default["default"] {
+  constructor(directory) {
+    super();
+    this.directory = directory;
+    this.loadStorage(directory);
+  }
+
+  async loadStorage(directory) {
+    let data;
+    try {
+      core_logger.Logger.debug(`Wallet: Loading storage from ${directory}`);
+      data = await services_storage_service.storageService.getItem(directory);
+
+      this.documents = typeof data === 'string' ? JSON.parse(data) : data;
+
+      if (!this.documents) {
+        core_logger.Logger.debug('Wallet: no storage found, creating empty wallet');
+        this.documents = {};
+      } else {
+        core_logger.Logger.debug(`Wallet: existing storage found: ${JSON.stringify(data)}`);
+      }
+    } catch (err) {
+      core_logger.Logger.error(
+        `error to retrieve data from rpc storage: ${err.toString()}`,
+      );
+      core_logger.Logger.info(JSON.stringify(data));
+      this.documents = {};
+
+      throw err;
+    }
+  }
+
+  updateLocalStorage() {
+    services_storage_service.storageService.setItem(this.directory, JSON.stringify(this.documents));
+  }
+
+  async get({id}) {
+    const content = this.documents[id];
+    return {
+      id,
+      content,
+    };
+  }
+
+  async update(options) {
+    return this.insert(options);
+  }
+
+  async delete({document}) {
+    delete this.documents[document.id];
+    this.updateLocalStorage();
+  }
+
+  async insert({document}) {
+    const docId = document.id || generateDocumentId();
+
+    this.documents[docId] = document.content;
+
+    this.updateLocalStorage();
+
+    return {
+      id: docId,
+      ...document,
+    };
+  }
+
+  async count(query) {
+    const result = await this.find(query);
+    return result.length;
+  }
+
+  async find({has = undefined, equals = undefined} = {}) {
+    core_logger.Logger.debug('Execute find', {
+      equals,
+      documents: this.documents,
+    });
+
+    const documents = Object.keys(this.documents || {})
+      .map(docId => {
+        const content = this.documents[docId];
+
+        let matchesQuery = false;
+        if (!has && !equals) {
+          // Return all documents
+          matchesQuery = true;
+        } else if (equals && equals['content.id']) {
+          // Basic "query" support for tests
+          matchesQuery = content.id === equals['content.id'];
+        } else if (equals && equals['content.type']) {
+          // Basic "query" support for tests
+          matchesQuery = content.type === equals['content.type'];
+        }
+
+        if (matchesQuery) {
+          return {
+            id: docId,
+            content,
+          };
+        }
+
+        return null;
+      })
+      .filter(value => !!value);
+    return {documents};
+  }
+}
+
+module.exports = RpcStorageInterface;

package/lib/wallet/rpc-storage-interface.mjs

@@ -0,0 +1,118 @@
+import StorageInterface from '@docknetwork/universal-wallet/storage/storage-interface';
+import { v4 } from 'uuid';
+import { storageService } from '../services/storage/service.mjs';
+import { Logger } from '../core/logger.mjs';
+
+function generateDocumentId() {
+  return `doc:${v4()}`;
+}
+
+/* An example file system storage interface implementation. This is not secure and shouldn't be used in production */
+class RpcStorageInterface extends StorageInterface {
+  constructor(directory) {
+    super();
+    this.directory = directory;
+    this.loadStorage(directory);
+  }
+
+  async loadStorage(directory) {
+    let data;
+    try {
+      Logger.debug(`Wallet: Loading storage from ${directory}`);
+      data = await storageService.getItem(directory);
+
+      this.documents = typeof data === 'string' ? JSON.parse(data) : data;
+
+      if (!this.documents) {
+        Logger.debug('Wallet: no storage found, creating empty wallet');
+        this.documents = {};
+      } else {
+        Logger.debug(`Wallet: existing storage found: ${JSON.stringify(data)}`);
+      }
+    } catch (err) {
+      Logger.error(
+        `error to retrieve data from rpc storage: ${err.toString()}`,
+      );
+      Logger.info(JSON.stringify(data));
+      this.documents = {};
+
+      throw err;
+    }
+  }
+
+  updateLocalStorage() {
+    storageService.setItem(this.directory, JSON.stringify(this.documents));
+  }
+
+  async get({id}) {
+    const content = this.documents[id];
+    return {
+      id,
+      content,
+    };
+  }
+
+  async update(options) {
+    return this.insert(options);
+  }
+
+  async delete({document}) {
+    delete this.documents[document.id];
+    this.updateLocalStorage();
+  }
+
+  async insert({document}) {
+    const docId = document.id || generateDocumentId();
+
+    this.documents[docId] = document.content;
+
+    this.updateLocalStorage();
+
+    return {
+      id: docId,
+      ...document,
+    };
+  }
+
+  async count(query) {
+    const result = await this.find(query);
+    return result.length;
+  }
+
+  async find({has = undefined, equals = undefined} = {}) {
+    Logger.debug('Execute find', {
+      equals,
+      documents: this.documents,
+    });
+
+    const documents = Object.keys(this.documents || {})
+      .map(docId => {
+        const content = this.documents[docId];
+
+        let matchesQuery = false;
+        if (!has && !equals) {
+          // Return all documents
+          matchesQuery = true;
+        } else if (equals && equals['content.id']) {
+          // Basic "query" support for tests
+          matchesQuery = content.id === equals['content.id'];
+        } else if (equals && equals['content.type']) {
+          // Basic "query" support for tests
+          matchesQuery = content.type === equals['content.type'];
+        }
+
+        if (matchesQuery) {
+          return {
+            id: docId,
+            content,
+          };
+        }
+
+        return null;
+      })
+      .filter(value => !!value);
+    return {documents};
+  }
+}
+
+export { RpcStorageInterface as default };

package/lib/wallet/rpc-storage-wallet.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var StorageWallet = require('@docknetwork/universal-wallet/storage-wallet');
+var wallet_rpcStorageInterface = require('./rpc-storage-interface.js');
+require('@docknetwork/universal-wallet/storage/storage-interface');
+require('uuid');
+require('../services/storage/service.js');
+require('../core/logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var StorageWallet__default = /*#__PURE__*/_interopDefaultLegacy(StorageWallet);
+
+class RpcWallet extends StorageWallet__default["default"] {
+  constructor(id, storageOptions = {}) {
+    // Allow user to pass pre-initialized interface or construct a default one
+    const storageInterface =
+      storageOptions.storageInterface || new wallet_rpcStorageInterface(id);
+    super(id, storageInterface);
+  }
+
+  async import(data, password) {
+    const result = await super.import(data, password);
+
+    // validate wallet data
+    // migrate wallet data
+
+    this.contents.forEach(content => {
+      this.promises.push(this.insertToStorage(content));
+    });
+
+    return result;
+  }
+}
+
+module.exports = RpcWallet;

package/lib/wallet/rpc-storage-wallet.mjs

@@ -0,0 +1,30 @@
+import StorageWallet from '@docknetwork/universal-wallet/storage-wallet';
+import RpcStorageInterface from './rpc-storage-interface.mjs';
+import '@docknetwork/universal-wallet/storage/storage-interface';
+import 'uuid';
+import '../services/storage/service.mjs';
+import '../core/logger.mjs';
+
+class RpcWallet extends StorageWallet {
+  constructor(id, storageOptions = {}) {
+    // Allow user to pass pre-initialized interface or construct a default one
+    const storageInterface =
+      storageOptions.storageInterface || new RpcStorageInterface(id);
+    super(id, storageInterface);
+  }
+
+  async import(data, password) {
+    const result = await super.import(data, password);
+
+    // validate wallet data
+    // migrate wallet data
+
+    this.contents.forEach(content => {
+      this.promises.push(this.insertToStorage(content));
+    });
+
+    return result;
+  }
+}
+
+export { RpcWallet as default };

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@docknetwork/wallet-sdk-wasm",
+    "version": "0.4.19",
+    "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/docknetwork/react-native-sdk.git",
+        "directory": "packages/wasm"
+    },
+    "scripts": {
+        "prepublishOnly": "npm run build",
+        "build:babel": "rm -rf lib && NODE_ENV=production babel src/ --out-dir lib --copy-files",
+        "build": "rm -rf lib && rollup -c"
+    },
+    "resolutions": {
+        "@polkadot/wasm-crypto": "6.3.1",
+        "@polkadot/rpc-core": "9.7.1",
+        "@docknetwork/sdk": "8.0.0",
+        "@polkadot/api": "9.7.1",
+        "@polkadot/keyring": "10.1.11",
+        "@polkadot/rpc-provider": "9.7.1",
+        "@polkadot/types": "9.7.1",
+        "@polkadot/types-known": "9.7.1",
+        "@polkadot/util": "10.1.11",
+        "@polkadot/util-crypto": "10.1.11"
+    },
+    "dependencies": {
+        "@docknetwork/universal-wallet": "^2.0.1",
+        "@polkadot/api": "9.7.1",
+        "@polkadot/keyring": "10.1.11",
+        "@polkadot/rpc-core": "9.7.1",
+        "@polkadot/rpc-provider": "9.7.1",
+        "@polkadot/types": "9.7.1",
+        "@polkadot/types-known": "9.7.1",
+        "@polkadot/ui-shared": "3.4.1",
+        "@polkadot/util": "10.1.11",
+        "@polkadot/util-crypto": "10.1.11",
+        "@polkadot/wasm-crypto": "6.3.1",
+        "@docknetwork/sdk": "8.0.0",
+        "axios": "^0.25.0",
+        "babel-node": "^0.0.1-security",
+        "bignumber.js": "^9.0.1",
+        "json-rpc-2.0": "^0.2.16",
+        "react-native-keychain": "^8.0.0",
+        "uuid": "^8.3.2",
+        "winston": "^3.3.3",
+        "cwait": "1.1.2",
+        "axios-retry": "^3.2.5",
+        "@sphereon/pex": "^1.1.4"
+    },
+    "devDependencies": {
+        "@babel/node": "^7.16.0",
+        "sinon": "^12.0.1",
+        "jest": "29.6.1",
+        "ts-jest": "29.1.0",
+        "typescript": "^5.0.4"
+    }
+}

package/readme.md

@@ -0,0 +1,61 @@
+# Dock Wallet SDK
+
+The Dock Wallet SDK provides all the required functions to build a PolkaDot Wallet on top of a [Universal Wallet 2020](https://w3c-ccg.github.io/universal-wallet-interop-spec/) document storage. It supports both Node.js and React Native.
+
+For React Native usage please check [@docknetwork/wallet-sdk-react-native](https://www.npmjs.com/package/@docknetwork/wallet-sdk-react-native)
+
+This is the core package and includes basic functionalities such as:
+- Document storage following [Universal Wallet 2020 spec](https://w3c-ccg.github.io/universal-wallet-interop-spec/)
+- Manage a wallet (CRUD)
+- Manage accounts (CRUD)
+- Fetch account balances
+- Wallet/Account backup
+- Import wallet/accounts
+
+You might require to install extra packages depending on your needs, please refer to:
+- [@docknetwork/wallet-sdk-react-native](https://www.npmjs.com/package/@docknetwork/wallet-sdk-react-native)
+- [@docknetwork/wallet-sdk-dids](https://www.npmjs.com/package/@docknetwork/wallet-sdk-dids)
+- [@docknetwork/wallet-sdk-transactions](https://www.npmjs.com/package/@docknetwork/wallet-sdk-transactions)
+- [@docknetwork/wallet-sdk-credentials](https://www.npmjs.com/package/@docknetwork/wallet-sdk-credentials)
+
+## Installation
+```js
+yarn add @docknetwork/wallet-sdk-core
+
+```
+
+
+## React Native Example
+
+```js
+import {Wallet} from '@docknetwork/wallet-sdk-core/lib/modules/wallet';
+
+const wallet = await Wallet.create();
+
+const account1 = await wallet.accounts.create({
+  name: 'test',
+});
+
+console.log(`Account1 address ${account1.address}`);
+// result: Account1 address 3D1M9UnR684eBfVujjQr6ucPqvXERSxYxcVBFGAhRohhRXxq
+
+// Create account using an existing mnemonic
+const mnemonic =
+  'indicate mention thing discover clarify grief inherit vivid dish health market spoil';
+const account2 = await wallet.accounts.create({
+  name: 'Test',
+  mnemonic,
+});
+
+console.log(`Account2 address ${account2.address}`);
+
+// result: Account2 address 3FENesfZgFmBruv2H9Hc17GmobeTfxFAp8gHKXFmUtA38hcW
+
+// Fetch accounts balance
+const balance = await account1.getBalance();
+
+console.log('Account1 balance', balance);
+
+// result: Account1 balance 0
+
+```

package/rollup.config.mjs

@@ -0,0 +1,35 @@
+import json from '@rollup/plugin-json';
+import multiInput from 'rollup-plugin-multi-input';
+import commonjs from '@rollup/plugin-commonjs';
+import flow from 'rollup-plugin-flow';
+import typescript from '@rollup/plugin-typescript';
+
+export default async function () {
+  return [
+    {
+      plugins: [
+        multiInput.default(),
+        json(),
+        flow({
+          all: true,
+          include: 'src/**/*.js',
+        }),
+        commonjs(),
+        typescript(),
+      ],
+      input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js'],
+      output: [
+        {
+          dir: 'lib',
+          format: 'cjs',
+          entryFileNames: '[name].js'
+        },
+        {
+          dir: 'lib',
+          format: 'esm',
+          entryFileNames: '[name].mjs'
+        },
+      ],
+    },
+  ];
+}

package/src/core/crypto.js

@@ -0,0 +1,31 @@
+import assert from 'assert';
+import crypto from 'crypto';
+
+export const DEFAULT_KEY =
+  process.env.ENCRYPTION_KEY || process.env.REACT_APP_ENCRYPTION_KEY;
+export 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);
+
+export 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')};
+}
+
+export 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();
+}

package/src/core/format-utils.test.js

@@ -0,0 +1,44 @@
+import {
+  formatAddress,
+  formatCurrency,
+  formatDate,
+  getPlainDockAmount,
+} from './format-utils';
+
+const sr25519Address = '395pw1L5R4XiScC2BGRrSSSH6fadFuGSTfUcqA5cHPyA21eQ';
+const ed25519Address = '38yWnWt8k3j5BuxssLAH43t5cNevxyShkCAMEx8su3nSsayh';
+
+describe('Format util', () => {
+  it('expect to format sr25519 address', () => {
+    expect(formatAddress(sr25519Address)).toBe('395pw1L5R...5cHPyA21eQ');
+  });
+
+  it('expect to format ed25519Address address', () => {
+    expect(formatAddress(ed25519Address)).toBe('38yWnWt8k...8su3nSsayh');
+  });
+
+  it('expect to validate address length', () => {
+    expect(formatAddress(sr25519Address, sr25519Address.length + 10)).toBe(
+      sr25519Address,
+    );
+  });
+
+  it('getPlainDockAmount', () => {
+    const amount = getPlainDockAmount(10);
+    expect(amount.toNumber()).toBe(10000000);
+  });
+
+  it('formatCurrency', () => {
+    const result = formatCurrency(12.55);
+    expect(result).toBe('$12.55');
+
+    const result1 = formatCurrency(0);
+    expect(result1).toBe('$0.00');
+  });
+
+  it('format Date', () => {
+    const date = new Date(1996, 11, 17);
+    const result = formatDate(date);
+    expect(result).toBe('December 17, 1996');
+  });
+});