test: move stateful notification tests to dispute resolution. Test ev…

…ent listener in its own test

src/contracts/AbstractContract.js

@@ -9,23 +9,23 @@ class AbstractContract {
    * services such as an off chain store, as well as the functionality of the underlying
    * implementation.
    * @param {object} implementationInstance - Contract Implementation object to extend
-   * @param {object} storeProviderWrapperInstance - StoreProvider wrapper object.
+   * @param {object} storeProviderInstance - StoreProvider wrapper object.
    */
   constructor(
     implementationInstance = isRequired('implementationInstance'),
-    storeProviderWrapperInstance = isRequired('storeProviderWrapperInstance')
+    storeProviderInstance = isRequired('storeProviderInstance')
   ) {
-    this._StoreProvider = storeProviderWrapperInstance
+    this._StoreProvider = storeProviderInstance
     this._contractImplementation = implementationInstance
     delegateCalls(this, implementationInstance)
   }
 
   /**
-   * Set the store wrapper
-   * @param {object} storeProviderWrapperInstance wrapper for store
+   * Set store provider instance.
+   * @param {object} storeProviderInstance - instance of store provider wrapper.
    */
-  setStoreProvider = storeProviderWrapperInstance => {
-    this._StoreProvider = storeProviderWrapperInstance
+  setStoreProviderInstance = storeProviderInstance => {
+    this._StoreProvider = storeProviderInstance
   }
 }
 

src/contracts/abstractions/index.js

@@ -1,4 +1,4 @@
 import Arbitrator from './Arbitrator'
-import ArbitrableContracts from './Arbitrable'
+import Arbitrable from './Arbitrable'
 
-export { Arbitrator, ArbitrableContracts }
+export { Arbitrator, Arbitrable }

src/kleros.js

@@ -10,6 +10,8 @@ class Kleros {
 
   storeWrapper = {}
 
+  eventListener = null
+
   /**
    * Instantiates a new Kelros instance that provides the public interface
    * to Kleros contracts and library. All params are required. To use an individual
@@ -57,23 +59,16 @@ class Kleros {
       _arbitrableTransaction,
       this.storeWrapper
     )
-    // EVENT LISTENER
-    this.eventListener = new EventListener([
-      this.arbitrator._contractImplementation.contractInstance,
-      this.arbitrable._contractImplementation.contractInstance
-    ])
     // DISPUTES
     this.disputes = new resources.Disputes(
       this.arbitrator,
       this.arbitrableContracts,
-      this.eventListener,
       this.storeWrapper
     )
     // NOTIFICATIONS
     this.notifications = new resources.Notifications(
       this.arbitrator,
       this.arbitrableContracts,
-      this.eventListener,
       this.storeWrapper
     )
   }
@@ -90,16 +85,26 @@ class Kleros {
     account,
     callback // for notification callback
   ) => {
-    this.eventListener.clearArbitratorHandlers()
-    await this.disputes.addNewDisputeEventListener()
-    await this.disputes.addTokenShiftToJurorProfileEventListener(
+    // stop current event listeners
+    if (this.eventListener) {
+      this.eventListener.stopWatchingForEvents()
+    }
+    // reinitialize with current arbitrator contract instance
+    this.eventListener = new EventListener([
+      this.arbitrator.getContractInstance()
+    ])
+    // add handlers for notifications
+    this.notifications.registerArbitratorNotifications(
       account,
+      this.eventListener,
       callback
     )
-    await this.disputes.addDisputeDeadlineHandler(account)
-    await this.disputes.addDisputeRulingHandler(account, callback)
-    await this.notifications.registerNotificationListeners(account, callback)
-    await this.eventListener.watchForArbitratorEvents(account)
+    // add handlers for event driven store updates
+    this.disputes.registerStoreUpdateEventListeners(account, this.eventListener)
+    // fetch last block for user
+    const fromBlock = await this.storeWrapper.getLastBlock(account)
+    // start event listener
+    this.eventListener.watchForEvents(fromBlock)
   }
 
   /**
@@ -109,11 +114,10 @@ class Kleros {
   setStoreProvider = storeUri => {
     this.storeWrapper = new StoreProviderWrapper(storeUri)
 
-    this.eventListener.setStoreProvider(this.storeWrapper)
-    this.disputes.setStoreProvider(this.storeWrapper)
-    this.arbitrableContract.setStoreProvider(this.storeWrapper)
-    this.arbitrator.setStoreProvider(this.storeWrapper)
-    this.notifications.setStoreProvider(this.storeWrapper)
+    this.disputes.setStoreProviderInstance(this.storeWrapper)
+    this.arbitrableContract.setStoreProviderInstance(this.storeWrapper)
+    this.arbitrator.setStoreProviderInstance(this.storeWrapper)
+    this.notifications.setStoreProviderInstance(this.storeWrapper)
   }
 }
 

src/resources/Disputes.js

@@ -18,6 +18,27 @@ class Disputes {
     this._ArbitrableInstance = arbitrableInstance
     this._StoreProviderInstance = storeProviderInstance
   }
+  /**
+   * Set arbitrator instance.
+   * @param {object} arbitratorInstance - instance of an arbitrator contract.
+   */
+  setArbitratorInstance = arbitratorInstance => {
+    this._ArbitratorInstance = arbitratorInstance
+  }
+  /**
+   * Set arbitrable instance.
+   * @param {object} arbitrableInstance - instance of an arbitrable contract.
+   */
+  setArbitrableInstance = arbitrableInstance => {
+    this._ArbitrableInstance = arbitrableInstance
+  }
+  /**
+   * Set store provider instance.
+   * @param {object} storeProviderInstance - instance of store provider wrapper.
+   */
+  setStoreProviderInstance = storeProviderInstance => {
+    this._StoreProviderInstance = storeProviderInstance
+  }
 
   // **************************** //
   // *         Events           * //

src/resources/Notifications.js

@@ -51,7 +51,7 @@ class Notifications {
    * @param {object} eventListener - Event Listener that will fetch logs and call callbacks
    * @param {function} callback - If we want notifications to be "pushed" provide a callback function to call when a new notification is created.
    */
-  registerArbitratorNotifications = async (
+  registerArbitratorNotifications = (
     account = isRequired('account'),
     eventListener = isRequired('eventListener'),
     callback

src/utils/EventListener.js

@@ -7,13 +7,20 @@ import * as errorConstants from '../constants/error'
 class EventListener {
   /**
    * Listen for events in contract and handles callbacks with registered event handlers.
-   * @param {object[]} contractInstances - truffle-contract instances to fetch event logs for.
+   * @param {object[]} _contractInstances - truffle-contract instances to fetch event logs for.
    */
-  constructor(contractInstances = []) {
-    this.contractInstances = contractInstances
+  constructor(_contractInstances = []) {
+    this.contractInstances = []
+    // map address -> { event: [handlers], ... }
     this.contractEventHandlerMap = {}
+    // map address -> watcher instance
+    this.watcherInstances = {}
     // event handler queue
     this.eventHandlerQueue = new PromiseQueue()
+    // initialize class variables for new contract instances
+    _contractInstances.forEach(instance => {
+      this.addContractInstance(instance)
+    })
   }
 
   /**
@@ -86,13 +93,15 @@ class EventListener {
     // remove instance from this.contractInstances
     const removedInstance = _.remove(
       this.contractInstances,
-      instance => instance.contractAddress === contractAddress
+      instance => instance.address === contractAddress
     )
     // if we didn't remove anything throw error
     if (removedInstance.length === 0)
       throw new Error(errorConstants.MISSING_CONTRACT_INSTANCE(contractAddress))
     // stop watching on these instances
-    removedInstance.forEach(instance => instance.stopWatching())
+    removedInstance.forEach(instance =>
+      this.stopWatchingForEvents(instance.address)
+    )
     // remove handlers for contract instance
     delete this.contractEventHandlerMap[contractAddress]
   }
@@ -118,34 +127,43 @@ class EventListener {
    * @param {number} fromBlock - A block number can be passed to catch up on missed logs
    */
   watchForEvents = (fromBlock = 'latest') => {
-    Promise.all(
-      this.contractInstances.forEach(instance => {
-        instance
-          .allEvents({
-            fromBlock: fromBlock,
-            lastBlock: 'latest'
-          })
-          .watch((error, result) => {
-            if (!error) {
-              const handlers = this.contractEventHandlerMap[instance.address][
-                result.event
-              ]
-              if (handlers) {
-                handlers.forEach(handler => {
-                  this._queueEvent(handler, result)
-                })
-              }
-            }
-          })
+    this.contractInstances.forEach(instance => {
+      const newWatcherInstance = instance.allEvents({
+        fromBlock: fromBlock,
+        lastBlock: 'latest'
       })
-    )
+
+      // NOTE: should we allow more than one listener per contract instance?
+      if (this.watcherInstances[instance.address])
+        this.watcherInstances[instance.address].stopWatching()
+
+      this.watcherInstances[instance.address] = newWatcherInstance
+
+      newWatcherInstance.watch((error, result) => {
+        if (!error) {
+          const handlers = this.contractEventHandlerMap[instance.address][
+            result.event
+          ]
+          if (handlers) {
+            handlers.forEach(handler => {
+              this._queueEvent(handler, result)
+            })
+          }
+        }
+      })
+    })
   }
 
   /**
-   * Stop listening on contract.
+   * Stop listening on contract. If no contractAddress supplied it stops all listeners
+   * @param {string} contractAddress - Address of the contract to stop watching
    */
-  stopWatchingForEvents = () => {
-    this.contractInstances.forEach(instance => instance.stopWatching())
+  stopWatchingForEvents = contractAddress => {
+    if (contractAddress) this.watcherInstances[contractAddress].stopWatching()
+    else
+      this.contractInstances.forEach(instance => {
+        this.watcherInstances[instance.address].stopWatching()
+      })
   }
 
   /**