@docknetwork/wallet-sdk-wasm 0.4.19

package/src/wallet/memory-storage-interface.js

@@ -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 default MemoryStorageInterface;

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

@@ -0,0 +1,23 @@
+import StorageWallet from '@docknetwork/universal-wallet/storage-wallet';
+import MemoryStorageInterface from './memory-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 default MemoryWallet;

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

@@ -0,0 +1,118 @@
+import StorageInterface from '@docknetwork/universal-wallet/storage/storage-interface';
+import {v4 as uuid} from 'uuid';
+import {storageService} from '../services/storage';
+import {Logger} from '../core/logger';
+
+function generateDocumentId() {
+  return `doc:${uuid()}`;
+}
+
+/* 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 default RpcStorageInterface;

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

@@ -0,0 +1,26 @@
+import StorageWallet from '@docknetwork/universal-wallet/storage-wallet';
+import RpcStorageInterface from './rpc-storage-interface';
+
+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 default RpcWallet;

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+      "strict": false,
+      "preserveConstEnums": true,
+      "sourceMap": true,
+      "target": "ESNext",
+      "module": "ESNext",
+      "moduleResolution": "Node",
+      "esModuleInterop": true,
+      "downlevelIteration": true,
+      "declarationMap": true,
+      "declaration": true,
+      "composite": true,
+      "emitDecoratorMetadata": true,
+      "useUnknownInCatchVariables": false,
+      "experimentalDecorators": true,
+      "resolveJsonModule": true,
+      "allowJs": true,
+      "allowSyntheticDefaultImports": true,
+      "skipLibCheck": true,
+      "outDir": "./lib",
+      "declarationDir": "./lib"
+    },
+    "ts-node": {
+      "compilerOptions": {
+        "module": "CommonJS"
+      },
+      "esm": true
+    },
+    "include": ["src/**/*"]
+  }