staking: advertise the price for serving queries (#204)

* staking: advertise, in the AllocationCreated event, the non-binding price charged for queries related to an allocation
* staking: check caller is the channel proxy when settling (#203)

Author: abarmat

contracts/DisputeManager.sol

@@ -408,7 +408,7 @@ contract DisputeManager is Governed {
 
         // Get the indexer that created the channel and signed the attestation
         (address indexer, bytes32 subgraphID) = staking.channels(channelID);
-        require(indexer != address(0), "Indexer cannot be found with the attestation");
+        require(indexer != address(0), "Indexer cannot be found for the attestation");
         require(subgraphID == attestation.subgraphID, "Channel and attestation subgraph must match");
 
         // Create a disputeID

contracts/Staking.sol

@@ -49,12 +49,14 @@ contract Staking is Governed {
     // Indexer stake tracking : indexer => Stake
     mapping(address => Stakes.Indexer) public stakes;
 
-    // Channels : channelID => Channel
-    mapping(address => Channel) public channels;
-
     // Rebate pools : epoch => Pool
     mapping(uint256 => Rebates.Pool) public rebates;
 
+    // Channels : channelID => Channel
+    mapping(address => Channel) public channels;
+    // Channels Proxy : Channel Multisig Proxy => channelID
+    mapping(address => address) public channelsProxy;
+
     // List of addresses allowed to slash stakes
     mapping(address => bool) public slashers;
 
@@ -96,14 +98,16 @@ contract Staking is Governed {
      * during `epoch`.
      * `channelID` is the address of the indexer in the channel multisig.
      * `channelPubKey` is the public key used for routing payments to the indexer channel.
+     * `price` price the `indexer` will charge for serving queries of the `subgraphID`.
      */
     event AllocationCreated(
         address indexed indexer,
         bytes32 indexed subgraphID,
         uint256 epoch,
         uint256 tokens,
         address channelID,
-        bytes channelPubKey
+        bytes channelPubKey,
+        uint256 price
     );
 
     /**
@@ -374,11 +378,15 @@ contract Staking is Governed {
      * @param _subgraphID ID of the subgraph where tokens will be allocated
      * @param _tokens Amount of tokens to allocate
      * @param _channelPubKey The public key used by the indexer to setup the off-chain channel
+     * @param _channelProxy Address of the multisig proxy used to hold channel funds
+     * @param _price Price the `indexer` will charge for serving queries of the `subgraphID`
      */
     function allocate(
         bytes32 _subgraphID,
         uint256 _tokens,
-        bytes calldata _channelPubKey
+        bytes calldata _channelPubKey,
+        address _channelProxy,
+        uint256 _price
     ) external {
         address indexer = msg.sender;
         Stakes.Indexer storage indexerStake = stakes[indexer];
@@ -406,35 +414,39 @@ contract Staking is Governed {
         alloc.channelID = channelID;
         alloc.createdAtEpoch = epochManager.currentEpoch();
         channels[channelID] = Channel(indexer, _subgraphID);
+        channelsProxy[_channelProxy] = channelID;
 
         emit AllocationCreated(
             indexer,
             _subgraphID,
             alloc.createdAtEpoch,
             alloc.tokens,
             channelID,
-            _channelPubKey
+            _channelPubKey,
+            _price
         );
     }
 
     /**
      * @dev Settle a channel after receiving collected query fees from it
-     * @param _channelID Address of the indexer in the channel
+     * Funds are received from a channel multisig proxy contract
      * @param _tokens Amount of tokens to settle
      */
-    function settle(address _channelID, uint256 _tokens) external {
-        address channelMultisig = msg.sender;
+    function settle(uint256 _tokens) external {
+        // Get the channelID the caller is related
+        address channelID = channelsProxy[msg.sender];
+        delete channelsProxy[msg.sender]; // Remove to avoid re-entrancy
 
         // Receive funds from the channel multisig
         // We use channelID to find the indexer owner of the channel
-        require(isChannel(_channelID), "Channel: does not exist");
+        require(isChannel(channelID), "Channel: does not exist");
 
         // Transfer tokens to settle from multisig to this contract
         require(
-            token.transferFrom(channelMultisig, address(this), _tokens),
+            token.transferFrom(msg.sender, address(this), _tokens),
             "Channel: Cannot transfer tokens to settle"
         );
-        _settle(_channelID, channelMultisig, _tokens);
+        _settle(channelID, msg.sender, _tokens);
     }
 
     /**