Update registry middleware (#5585)

js/src/redux/middleware.js

@@ -38,7 +38,7 @@ export default function (api, browserHistory, forEmbed = false) {
 
   if (!forEmbed) {
     const certifications = new CertificationsMiddleware().toMiddleware();
-    const registry = new RegistryMiddleware(api);
+    const registry = new RegistryMiddleware(api).toMiddleware();
 
     middleware.push(certifications, registry);
   }

js/src/redux/providers/registry/middleware.js

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 import { debounce } from 'lodash';
-import store from 'store';
+import lsstore from 'store';
 import Contracts from '~/contracts';
 import subscribeToEvents from '~/util/subscribe-to-events';
 
@@ -25,126 +25,140 @@ import { setReverse, startCachingReverses } from './actions';
 
 const STORE_KEY = '_parity::reverses';
 
-const read = (chain) => {
+export default class RegistryMiddleware {
-  const reverses = store.get(`${STORE_KEY}::${chain}::data`);
+  contract;
-  const lastBlock = store.get(`${STORE_KEY}::${chain}::lastBlock`);
+  interval;
+  store;
+  subscription;
+  timeout;
 
-  if (!reverses || !lastBlock) {
+  addressesToCheck = {};
-    return null;
+
+  constructor (api) {
+    this._api = api;
   }
-  return { reverses, lastBlock };
-};
 
-const write = debounce((getChain, getReverses, getLastBlock) => {
+  toMiddleware () {
-  const chain = getChain();
+    return (store) => {
-  const reverses = getReverses();
+      this.store = store;
-  const lastBlock = getLastBlock();
 
-  store.set(`${STORE_KEY}::${chain}::data`, reverses);
+      return (next) => (action) => {
-  store.set(`${STORE_KEY}::${chain}::lastBlock`, lastBlock);
+        switch (action.type) {
-}, 20000);
+          case 'initAll':
+            next(action);
+            store.dispatch(startCachingReverses());
+            break;
 
-export default (api) => (store) => {
+          case 'startCachingReverses':
-  let contract;
+            this.cacheReverses();
-  let subscription;
+            break;
-  let timeout;
-  let interval;
 
-  let addressesToCheck = {};
+          case 'stopCachingReverses':
+            if (this.subscription) {
+              this.subscription.unsubscribe();
+            }
+            if (this.interval) {
+              clearInterval(this.interval);
+            }
+            if (this.timeout) {
+              clearTimeout(this.timeout);
+            }
 
-  const onLog = (log) => {
+            this.write.flush();
-    switch (log.event) {
+            break;
-      case 'ReverseConfirmed':
-        addressesToCheck[log.params.reverse.value] = true;
 
-        break;
+          case 'setReverse':
-      case 'ReverseRemoved':
+            this.write(
-        delete addressesToCheck[log.params.reverse.value];
+              () => store.getState().nodeStatus.netChain,
+              () => store.getState().registry.reverse,
+              () => +store.getState().nodeStatus.blockNumber
+            );
+            next(action);
+            break;
 
-        break;
+          default:
+            next(action);
+        }
+      };
+    };
+  }
+
+  cacheReverses () {
+    const { registry } = Contracts.get();
+    const cached = this.read(this.store.getState().nodeStatus.netChain);
+
+    if (cached) {
+      Object
+        .entries(cached.reverses)
+        .forEach(([ address, reverse ]) => this.store.dispatch(setReverse(address, reverse)));
     }
-  };
 
-  const checkReverses = () => {
+    registry.getInstance()
+      .then((instance) => this._api.newContract(registryABI, instance.address))
+      .then((_contract) => {
+        this.contract = _contract;
+
+        this.subscription = subscribeToEvents(this.contract, [
+          'ReverseConfirmed', 'ReverseRemoved'
+        ], {
+          from: cached ? cached.lastBlock : 0
+        });
+        this.subscription.on('log', this.onLog);
+
+        this.timeout = setTimeout(this.checkReverses, 10000);
+        this.interval = setInterval(this.checkReverses, 20000);
+      })
+      .catch((err) => {
+        console.error('Failed to start caching reverses:', err);
+        throw err;
+      });
+  }
+
+  checkReverses = () => {
     Object
-      .keys(addressesToCheck)
+      .keys(this.addressesToCheck)
       .forEach((address) => {
-        contract
+        this.contract
           .instance
           .reverse
           .call({}, [ address ])
           .then((reverse) => {
-            store.dispatch(setReverse(address, reverse));
+            this.store.dispatch(setReverse(address, reverse));
           });
       });
 
-    addressesToCheck = {};
+    this.addressesToCheck = {};
   };
 
-  return (next) => (action) => {
+  onLog = (log) => {
-    switch (action.type) {
+    switch (log.event) {
-      case 'initAll':
+      case 'ReverseConfirmed':
-        next(action);
+        this.addressesToCheck[log.params.reverse.value] = true;
-        store.dispatch(startCachingReverses());
 
         break;
-
+      case 'ReverseRemoved':
-      case 'startCachingReverses':
+        delete this.addressesToCheck[log.params.reverse.value];
-        const { registry } = Contracts.get();
-        const cached = read(store.getState().nodeStatus.netChain);
-
-        if (cached) {
-          Object
-            .entries(cached.reverses)
-            .forEach(([ address, reverse ]) => store.dispatch(setReverse(address, reverse)));
-        }
-
-        registry.getInstance()
-          .then((instance) => api.newContract(registryABI, instance.address))
-          .then((_contract) => {
-            contract = _contract;
-
-            subscription = subscribeToEvents(_contract, [
-              'ReverseConfirmed', 'ReverseRemoved'
-            ], {
-              from: cached ? cached.lastBlock : 0
-            });
-            subscription.on('log', onLog);
-
-            timeout = setTimeout(checkReverses, 10000);
-            interval = setInterval(checkReverses, 20000);
-          })
-          .catch((err) => {
-            console.error('Failed to start caching reverses:', err);
-            throw err;
-          });
 
         break;
-      case 'stopCachingReverses':
-        if (subscription) {
-          subscription.unsubscribe();
-        }
-        if (interval) {
-          clearInterval(interval);
-        }
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-
-        write.flush();
-        break;
-
-      case 'setReverse':
-        write(
-          () => store.getState().nodeStatus.netChain,
-          () => store.getState().registry.reverse,
-          () => +store.getState().nodeStatus.blockNumber
-        );
-        next(action);
-        break;
-
-      default:
-        next(action);
     }
   };
-};
+
+  read = (chain) => {
+    const reverses = lsstore.get(`${STORE_KEY}::${chain}::data`);
+    const lastBlock = lsstore.get(`${STORE_KEY}::${chain}::lastBlock`);
+
+    if (!reverses || !lastBlock) {
+      return null;
+    }
+    return { reverses, lastBlock };
+  };
+
+  write = debounce((getChain, getReverses, getLastBlock) => {
+    const chain = getChain();
+    const reverses = getReverses();
+    const lastBlock = getLastBlock();
+
+    lsstore.set(`${STORE_KEY}::${chain}::data`, reverses);
+    lsstore.set(`${STORE_KEY}::${chain}::lastBlock`, lastBlock);
+  }, 20000);
+}