Add Graph-specific Connext contracts (#179)

* Add connext contracts to repo
* Add hardcoded indexer addresses to multisigData
* Route indexer multisig commitments to custom CTDT
* Add custom indexerCTDT - hardcodes interpreters
* Indexer single asset interpreter
* Indexer free balance interpreter
* Move constants to multisig mastercopy + constructor
* Send to hardcoded addresses everywhere
* Support indexer-specific withdraw
* Port withdrawWapper changes to normal CTDT
* Use Solidity version ^0.6.4
* Remove DolphinCoin test token

The `DolphinCoin` token causes compiler errors because it needs the
new (v3.0) OpenZeppelin ERC20 contract to inherit from.
Since it is only used for testing, it can safely be removed in this
repo.

* Replace `isIndexer` with `hasStake`

The function `isIndexer` doesn't exist in the `Staking` contract.
I assume `hasStake` was meant instead.

* Make `masterCopy` address in multisig payable

Otherwise the compiler complains when we want to access the "static"
multisig variables via their getters, because the multisig contract
has a `receive` function.

* Get rid of compiler warnings about unused function parameters
* CTDTs don't need to inherit from MultisigTransfer anymore because of change to interpreter-based withdrawals.
* Reorder static multisig variables
* IndexerCTDT needs to inherit from MultisigData
* Add node address to static multisig variables
* Fix CTDT replacement in multisig
* Move `_owners` array from MVM to MultisigData

... because, for the customizations, we'll need to access the owners
outside of the MinimumViableMultisig.

* Introduce IndexerMultisigTransfer contract

... which is similar to MultisigTransfer, but handles transfers out of a
multisig where one party is an indexer (and the other party is the node).
Basically, the transfer is redirected to the staking contract, unless
the recipient is the node's address.

Actual details of the transfer to the staking contract still need to be
filled in.

* Remove existing versions of Indexer* interpreters

We're gonna start with these from scratch...

* Fresh start with Indexer* interpreters

We start with copies from the regular single/multi asset interpreters.

* Reimplement Indexer* interpreters
* Fill in details of interaction with staking contract
* Indexer channels handle only Graph token
* For indexer channels, only allow delegatecalls out of the multisig.
* Add lock mechanism for node-indexer multisigs

The staking contract can lock/unlock multisigs; a locked node-indexer
multisig cannot execute transactions.

* Helpers to deploy channel contracts
* Correctly format commitments
* Switch to using mocked staking contract in test
* Add SettleEvent to parrot information in mock
* Funding and withdrawal tests passing
* Deploy contracts for disputes in channel context
* Add MockDispute test fixture
* Update connext to 6.6.5
* Remove logs, connect signer to provider
* Test app uses single asset interpreter
* Use proxy factory for deployment
* Hack workaround to unblock dispute tests
* Initial app dispute test passing
* Add types package
* Simplify channel contracts deployment
* Remove setup hack, correctly access params from proxy
* Indexer-node multisig integration tests passing
* Add locking fns to mock staking
* Update test utils to allow for non-indexer channels

Co-authored-by: Ariel Barmat <[email protected]>
Co-authored-by: Heiko Fisch <[email protected]>
Co-authored-by: LayneHaber <[email protected]>
Co-authored-by: Rahul Sethuram <[email protected]>

Author: 5 people

.eslintignore

@@ -3,3 +3,4 @@ cache/
 coverage/
 node_modules/
 truffle.js
+cache/

.eslintrc

@@ -12,6 +12,7 @@
     "contract": false,
     "assert": false
   },
+  "ignorePatterns": ["./cache", "./build"],
   "rules": {
     // Strict mode
     "strict": ["error", "global"],
@@ -25,7 +26,7 @@
     "eol-last": ["error", "always"],
     "eqeqeq": ["error", "smart"],
     "generator-star-spacing": ["error", "before"],
-    "indent": ["error", 2],
+    "indent": ["error", 2, { "SwitchCase": 1 }],
     "linebreak-style": ["error", "unix"],
     "max-len": ["warn", 100, 2],
     "no-debugger": "off",

.gitignore

@@ -5,6 +5,9 @@ node_modules/
 build/
 dist/
 
+# Ignore buidler stuff
+cache/
+
 # Coverage tests
 coverage/
 

.soliumignore

@@ -5,3 +5,8 @@ contracts/openzeppelin
 contracts/Migrations.sol
 contracts/MultiSigWallet.sol
 contracts/Staking.sol
+contracts/connext/IndexerMultiAssetInterpreter.sol
+contracts/connext/IndexerSingleAssetInterpreter.sol
+contracts/connext/IndexerWithdrawInterpreter.sol
+contracts/connext/Proxy.sol
+contracts/connext/MinimumViableMultisig.sol

buidler.config.ts

@@ -2,6 +2,7 @@ import { BuidlerConfig, task, usePlugin } from '@nomiclabs/buidler/config'
 
 usePlugin('@nomiclabs/buidler-waffle')
 usePlugin('solidity-coverage')
+usePlugin('buidler-typechain')
 
 // This is a sample Buidler task. To learn how to create your own go to
 // https://buidler.dev/guides/create-task.html
@@ -44,6 +45,10 @@ const config: BuidlerConfig = {
       url: 'http://localhost:8545',
     },
   },
+  typechain: {
+    outDir: './build/typechain/contracts',
+    target: 'ethers-v4',
+  },
 }
 
 export default config

contracts/Curation.sol

@@ -6,7 +6,6 @@ import "./GraphToken.sol";
 import "./bancor/BancorFormula.sol";
 import "@openzeppelin/contracts/math/SafeMath.sol";
 
-
 /**
  * @title Curation contract
  * @dev Allows curators to signal on subgraph deployments that might be relevant to indexers by

contracts/Staking.sol

@@ -8,7 +8,6 @@ import "./GraphToken.sol";
 import "./libs/Rebates.sol";
 import "./libs/Stakes.sol";
 
-
 /**
  * @title Staking contract
  */

contracts/connext/IndexerCtdt.sol

@@ -0,0 +1,126 @@
+pragma solidity ^0.6.4;
+pragma experimental "ABIEncoderV2";
+
+import "@connext/contracts/src.sol/shared/libs/LibChannelCrypto.sol";
+import "@connext/contracts/src.sol/shared/libs/LibCommitment.sol";
+import "@connext/contracts/src.sol/adjudicator/ChallengeRegistry.sol";
+import "@connext/contracts/src.sol/funding/libs/LibOutcome.sol";
+
+import "./MultisigData.sol";
+import "./MinimumViableMultisig.sol";
+
+
+contract IndexerCtdt is MultisigData {
+    uint256 constant MAX_UINT256 = 2**256 - 1;
+
+    struct FreeBalanceAppState {
+        address[] tokenAddresses;
+        // The inner array contains the list of CoinTransfers for a single asset type
+        // The outer array contains the list of asset balances for respecitve assets
+        // according to the indexing used in the `tokens` array above
+        LibOutcome.CoinTransfer[][] balances;
+        bytes32[] activeApps;
+    }
+
+    struct MultiAssetMultiPartyCoinTransferInterpreterParams {
+        uint256[] limit;
+        address[] tokenAddresses;
+    }
+
+    function executeWithdraw(
+        address, /* interpreterAddress */
+        bytes32, /* nonce */
+        bytes memory encodedOutput,
+        bytes memory encodedParams
+    ) public {
+        address withdrawInterpreter = MinimumViableMultisig(masterCopy)
+            .INDEXER_WITHDRAW_INTERPRETER_ADDRESS();
+        (bool success, ) = withdrawInterpreter.delegatecall(
+            abi.encodeWithSignature(
+                "interpretOutcomeAndExecuteEffect(bytes,bytes)",
+                encodedOutput,
+                encodedParams
+            )
+        );
+
+        require(success, "Execution of executeWithdraw failed");
+    }
+
+    function executeEffectOfFreeBalance(
+        ChallengeRegistry challengeRegistry,
+        bytes32 freeBalanceAppIdentityHash,
+        address /* multiAssetMultiPartyCoinTransferInterpreterAddress */
+    ) public {
+        FreeBalanceAppState memory freeBalanceAppState = abi.decode(
+            challengeRegistry.getOutcome(freeBalanceAppIdentityHash),
+            (FreeBalanceAppState)
+        );
+
+        uint256[] memory limits = new uint256[](freeBalanceAppState.tokenAddresses.length);
+
+        address multiAssetInterpreter = MinimumViableMultisig(masterCopy)
+            .INDEXER_MULTI_ASSET_INTERPRETER_ADDRESS();
+
+        for (uint256 i = 0; i < freeBalanceAppState.tokenAddresses.length; i++) {
+            // The transaction's interpreter parameters are determined at the time
+            // of creation of the free balance; hence we cannot know how much will be
+            // deposited into it all-time. Relying on the app state is unsafe so
+            // we just give it full permissions by setting the limit to the max here.
+            limits[i] = MAX_UINT256;
+        }
+
+        (bool success, ) = multiAssetInterpreter.delegatecall(
+            abi.encodeWithSignature(
+                "interpretOutcomeAndExecuteEffect(bytes,bytes)",
+                abi.encode(freeBalanceAppState.balances),
+                abi.encode(
+                    MultiAssetMultiPartyCoinTransferInterpreterParams(
+                        limits,
+                        freeBalanceAppState.tokenAddresses
+                    )
+                )
+            )
+        );
+
+        require(success, "Execution of executeEffectOfFreeBalance failed");
+    }
+
+    /// @notice Execute a fund transfer for a state channel app in a finalized state
+    /// @param appIdentityHash AppIdentityHash to be resolved
+    function executeEffectOfInterpretedAppOutcome(
+        ChallengeRegistry challengeRegistry,
+        bytes32 freeBalanceAppIdentityHash,
+        bytes32 appIdentityHash,
+        address, /* interpreterAddress */
+        bytes memory interpreterParams
+    ) public {
+        bytes32[] memory activeApps = abi
+            .decode(challengeRegistry.getOutcome(freeBalanceAppIdentityHash), (FreeBalanceAppState))
+            .activeApps;
+
+        bool appIsFunded = false;
+
+        address singleAssetInterpreter = MinimumViableMultisig(masterCopy)
+            .INDEXER_SINGLE_ASSET_INTERPRETER_ADDRESS();
+
+        for (uint256 i = 0; i < activeApps.length; i++) {
+            if (activeApps[i] == appIdentityHash) {
+                appIsFunded = true;
+            }
+        }
+
+        require(appIsFunded, "Referenced AppInstance is not funded");
+
+        bytes memory outcome = challengeRegistry.getOutcome(appIdentityHash);
+
+        (bool success, ) = singleAssetInterpreter.delegatecall(
+            abi.encodeWithSignature(
+                "interpretOutcomeAndExecuteEffect(bytes,bytes)",
+                outcome,
+                interpreterParams
+            )
+        );
+
+        require(success, "Execution of executeEffectOfInterpretedAppOutcome failed");
+    }
+}

contracts/connext/IndexerMultiAssetInterpreter.sol

@@ -0,0 +1,67 @@
+pragma solidity ^0.6.4;
+pragma experimental "ABIEncoderV2";
+
+import "@connext/contracts/src.sol/funding/libs/LibOutcome.sol";
+import "@connext/contracts/src.sol/funding/Interpreter.sol";
+
+import "./IndexerMultisigTransfer.sol";
+
+
+/**
+ * This file is excluded from ethlint/solium because of this issue:
+ * https://github.com/duaraghav8/Ethlint/issues/261
+ */
+contract IndexerMultiAssetInterpreter is IndexerMultisigTransfer, Interpreter {
+    uint256 constant MAX_UINT256 = 2**256 - 1;
+
+    struct MultiAssetMultiPartyCoinTransferInterpreterParams {
+        uint256[] limit;
+        address[] tokenAddresses;
+    }
+
+    // NOTE: This is useful for writing tests, but is bad practice
+    // to have in the contract when deploying it. We do not want people
+    // to send funds to this contract in any scenario.
+    receive() external payable {}
+
+    function interpretOutcomeAndExecuteEffect(
+        bytes calldata encodedOutcome,
+        bytes calldata encodedParams
+    ) external override {
+        MultiAssetMultiPartyCoinTransferInterpreterParams memory params = abi.decode(
+            encodedParams,
+            (MultiAssetMultiPartyCoinTransferInterpreterParams)
+        );
+
+        LibOutcome.CoinTransfer[][] memory coinTransferListOfLists = abi.decode(
+            encodedOutcome,
+            (LibOutcome.CoinTransfer[][])
+        );
+
+        for (uint256 i = 0; i < coinTransferListOfLists.length; i++) {
+            address tokenAddress = params.tokenAddresses[i];
+            uint256 limitRemaining = params.limit[i];
+            LibOutcome.CoinTransfer[] memory coinTransferList = coinTransferListOfLists[i];
+
+            for (uint256 j = 0; j < coinTransferList.length; j++) {
+                LibOutcome.CoinTransfer memory coinTransfer = coinTransferList[j];
+
+                address payable to = address(uint160(coinTransfer.to));
+
+                if (coinTransfer.amount > 0) {
+                    limitRemaining -= coinTransfer.amount;
+                    multisigTransfer(to, tokenAddress, coinTransfer.amount);
+                }
+            }
+
+            // NOTE: If the limit is MAX_UINT256 it can bypass this check.
+            // We do this for the FreeBalanceApp since its values change.
+            if (params.limit[i] != MAX_UINT256) {
+                require(
+                    limitRemaining == 0,
+                    "Sum of total amounts received from outcome did not equate to limits."
+                );
+            }
+        }
+    }
+}

contracts/connext/IndexerMultisigTransfer.sol

@@ -0,0 +1,57 @@
+pragma solidity ^0.6.4;
+pragma experimental ABIEncoderV2;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import "../Staking.sol";
+
+import "./MultisigData.sol";
+import "./MinimumViableMultisig.sol";
+
+
+/// @title IndexerMultisigTransfer - Indexer variant
+/// of the regular MultisigTransfer.
+contract IndexerMultisigTransfer is MultisigData {
+    /// @notice Use this function for transfers of assets out of
+    /// the multisig.
+    /// @param recipient the recipient of the transfer -- unless this is the node's
+    /// address, the funds will be transferred to the staking contract on the indexer's behalf
+    /// @param assetId the asset to be transferred; must be the Graph token
+    /// @param amount the amount to be transferred
+
+    function multisigTransfer(
+        address payable recipient,
+        address assetId,
+        uint256 amount
+    ) public {
+        address staking = MinimumViableMultisig(masterCopy).INDEXER_STAKING_ADDRESS();
+        address token = address(Staking(staking).token());
+        require(staking != address(0), "multisigTransfer");
+
+        if (assetId != token) {
+            return;
+        }
+
+        // // Note, explicitly do NOT use safemath here. See discussion in: TODO
+        totalAmountWithdrawn[assetId] += amount;
+
+        if (recipient == MinimumViableMultisig(masterCopy).NODE_ADDRESS()) {
+            IERC20(token).transfer(MinimumViableMultisig(masterCopy).NODE_ADDRESS(), amount);
+        } else {
+            // transfer to staking contract
+            require(
+                IERC20(token).approve(staking, amount),
+                "IndexerMultisigTransfer: approving tokens to staking contract failed"
+            );
+            Staking(staking).settle(amount);
+        }
+    }
+
+    function getNodeAndIndexer() public view returns (address, address) {
+        if (_owners[0] == MinimumViableMultisig(masterCopy).NODE_ADDRESS()) {
+            return (_owners[0], _owners[1]);
+        } else {
+            return (_owners[1], _owners[0]);
+        }
+    }
+}