Staking

.gitignore

@@ -1,8 +1,13 @@
-.embark
-chains.json
-config/production/password
-config/livenet/password
-coverage
-dist
+# dependencies
 node_modules
-build
+
+# coverage
+coverage
+coverage.json
+
+# lock files
+package-lock.json
+
+# build artifacts
+build
+flattened_contracts

.solcover.js

@@ -0,0 +1,7 @@
+module.exports = {
+    copyPackages: ['@aragon/os'],
+    testCommand: 'truffle test test_truffle/*.js --network coverage',
+    skipFiles: [
+        'test/',
+    ]
+}

.soliumignore

@@ -0,0 +1 @@
+

.soliumrc.json

@@ -0,0 +1,23 @@
+{
+  "extends": "solium:all",
+  "rules": {
+    "imports-on-top": ["error"],
+    "variable-declarations": ["error"],
+    "array-declarations": ["error"],
+    "operator-whitespace": ["error"],
+    "lbrace": ["error"],
+    "mixedcase": 0,
+    "camelcase": ["error"],
+    "uppercase": 0,
+    "no-empty-blocks": ["error"],
+    "no-unused-vars": ["error"],
+    "quotes": ["error"],
+    "indentation": 0,
+    "whitespace": ["error"],
+    "deprecated-suicide": ["error"],
+    "arg-overflow": ["error", 8],
+    "pragma-on-top": ["error"],
+    "security/enforce-explicit-visibility": ["error"],
+    "error-reason": 0
+  }
+}

README.md

@@ -0,0 +1,35 @@
+# Staking App
+
+A Staking app with checkpointing (implementing ERC900 interface with history) and locking.
+
+## Testing
+### Truffle
+
+Currently this app is using Truffle. You can run tests with `npm test`.
+
+###  Slither
+[Install slither](https://github.com/trailofbits/slither#how-to-install) and then:
+```
+slither --solc /usr/local/bin/solc .
+```
+
+Some noise can be filtered with:
+```
+slither --solc /usr/local/bin/solc .  2>/tmp/a.txt ; grep -v "is not in mixedCase"  /tmp/a.txt | grep "Contract: Staking"
+```
+
+### Echidna
+Run `./scripts/flatten_echidna.sh` and then:
+```
+docker run -v `pwd`:/src trailofbits/echidna echidna-test /src/flattened_contracts/EchidnaStaking.sol EchidnaStaking --config="/src/echidna/config.yaml"
+```
+
+### Manticore
+```
+docker run --rm -ti -v `pwd`:/src trailofbits/manticore bash
+ulimit -s unlimited
+manticore --detect-all --contract Staking /src/flattened_contracts/Staking.sol
+```
+
+## Coverage
+You can measure coverage using Truffle by running `npm run coverage`.

contracts/Checkpointing.sol

@@ -0,0 +1,119 @@
+pragma solidity ^0.4.24;
+
+
+library Checkpointing {
+    struct Checkpoint {
+        uint64 time;
+        uint192 value;
+    }
+
+    struct History {
+        Checkpoint[] history;
+    }
+
+    uint256 private constant MAX_UINT192 = uint256(uint192(-1));
+    uint256 private constant MAX_UINT64 = uint256(uint64(-1));
+
+    string private constant ERROR_PAST_CHECKPOINT = "CHECKPOINT_PAST_CHECKPOINT";
+    string private constant ERROR_TIME_TOO_BIG = "CHECKPOINT_TIME_TOO_BIG";
+    string private constant ERROR_VALUE_TOO_BIG = "CHECKPOINT_VALUE_TOO_BIG";
+
+    function add(History storage self, uint256 time, uint256 value) internal {
+        require(time <= MAX_UINT64, ERROR_TIME_TOO_BIG);
+        require(value <= MAX_UINT192, ERROR_VALUE_TOO_BIG);
+
+        add192(self, uint64(time), uint192(value));
+    }
+
+    function add64(History storage self, uint64 time, uint256 value) internal {
+        require(value <= MAX_UINT192, ERROR_VALUE_TOO_BIG);
+
+        add192(self, time, uint192(value));
+    }
+
+    function get(History storage self, uint256 time) internal view returns (uint256) {
+        require(time <= MAX_UINT64, ERROR_TIME_TOO_BIG);
+
+        return uint256(get192(self, uint64(time)));
+    }
+
+    function get64(History storage self, uint64 time) internal view returns (uint256) {
+        return uint256(get192(self, time));
+    }
+
+    function lastUpdated(History storage self) internal view returns (uint256) {
+        uint256 length = self.history.length;
+
+        if (length > 0) {
+            return uint256(self.history[length - 1].time);
+        }
+
+        return 0;
+    }
+
+    function getLatestValue(History storage self) internal view returns (uint256) {
+        uint256 length = self.history.length;
+        if (length > 0) {
+            return uint256(self.history[length - 1].value);
+        }
+
+        return 0;
+    }
+
+    function add192(History storage self, uint64 time, uint192 value) internal {
+        uint256 length = self.history.length;
+
+        if (length == 0) {
+            self.history.push(Checkpoint(time, value));
+        } else {
+            Checkpoint storage currentCheckpoint = self.history[length - 1];
+            uint64 currentCheckpointTime = currentCheckpoint.time;
+            if (time > currentCheckpointTime) {
+                self.history.push(Checkpoint(time, value));
+            } else if (time == currentCheckpointTime) {
+                currentCheckpoint.value = value;
+            } else { // ensure list ordering
+                revert(ERROR_PAST_CHECKPOINT);
+            }
+        }
+    }
+
+    function get192(History storage self, uint64 time) internal view returns (uint192) {
+        uint256 length = self.history.length;
+
+        if (length == 0) {
+            return 0;
+        }
+
+        uint256 lastIndex = length - 1;
+
+        // short-circuit
+        Checkpoint storage lastCheckpoint = self.history[lastIndex];
+        if (time >= lastCheckpoint.time) {
+            return lastCheckpoint.value;
+        }
+
+        if (time < self.history[0].time) {
+            return 0;
+        }
+
+        uint256 low = 0;
+        uint256 high = lastIndex;
+
+        while (high > low) {
+            uint256 mid = (high + low + 1) / 2; // average, ceil round
+            Checkpoint storage checkpoint = self.history[mid];
+            uint64 midTime = checkpoint.time;
+
+            if (time > midTime) {
+                low = mid;
+            } else if (time < midTime) {
+                high = mid - 1;
+            } else { // time == midTime
+                return checkpoint.value;
+            }
+        }
+
+        return self.history[low].value;
+    }
+}

contracts/ERCStaking.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.4.24;
+
+// Interface for ERC900: https://eips.ethereum.org/EIPS/eip-900
+interface ERCStaking {
+    event Staked(address indexed user, uint256 amount, uint256 total, bytes data);
+    event Unstaked(address indexed user, uint256 amount, uint256 total, bytes data);
+
+    function stake(uint256 amount, bytes data) external;
+    function stakeFor(address user, uint256 amount, bytes data) external;
+    function unstake(uint256 amount, bytes data) external;
+
+    function totalStakedFor(address addr) external view returns (uint256);
+    function totalStaked() external view returns (uint256);
+    function token() external view returns (address);
+
+    function supportsHistory() external pure returns (bool);
+}
+
+interface ERCStakingHistory {
+    function lastStakedFor(address addr) external view returns (uint256);
+    function totalStakedForAt(address addr, uint256 blockNumber) external view returns (uint256);
+    function totalStakedAt(uint256 blockNumber) external view returns (uint256);
+}

contracts/ILockManager.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.4.24;
+
+
+interface ILockManager {
+    function canUnlock(address account, uint256 lockId, bytes lockData) external view returns (bool);
+}

contracts/IStakingLocking.sol

@@ -0,0 +1,33 @@
+pragma solidity ^0.4.24;
+
+import "./ILockManager.sol";
+
+
+interface IStakingLocking {
+    event Locked(address indexed account, uint256 indexed lockId, uint256 amount, address manager, bytes data);
+    event Unlocked(address indexed account, uint256 indexed lockId, uint256 amount, address manager, bytes data);
+    event LockAmountChanged(address indexed account, uint256 indexed lockId, uint256 amount);
+    event LockManagerChanged(address indexed account, uint256 indexed lockId, address manager);
+    event LockDataChanged(address indexed account, uint256 indexed lockId, bytes data);
+
+    function lock(uint256 _amount, address _manager, bytes _data) external returns (uint256 _lockId);
+    function unlock(address _account, uint256 _lockId) external;
+    function decreaseLockAmount(address _account, uint256 _lockId, uint256 _newAmount) external;
+    function setLockManager(address _account, uint256 _lockId, ILockManager _newManager) external;
+    function setLockData(address _account, uint256 _lockId, bytes _newData) external;
+    function transfer(address _to, uint256 _toLockId, uint256 _amount) external;
+    function transferFromLock(address _account, uint256 _lockId, address _to, uint256 _toLockId, uint256 _amount) external;
+
+    function locksCount(address _account) external view returns (uint256);
+    function getLock(address _account, uint256 _lockId)
+        external
+        view
+        returns (
+            uint256 _amount,
+            uint64 _unlockedAt,
+            address _manager,
+            bytes _data
+        );
+    function unlockedBalanceOf(address _account) external view returns (uint256);
+    function canUnlock(address _account, uint256 _lockId) external view returns (bool);
+}