Master

.gitignore

@@ -1,2 +1,4 @@
 node_modules/
+package-lock.json
 build/
+*.*swp

README.md

@@ -1,15 +1,31 @@
 ### Dev:
-- `$ git clone https://github.com/DOSNetwork/eth-contracts`
+- `$ git clone https://github.com/DOSNetwork/smart-contracts`
 - `$ npm install`
 - `$ npm -g install truffle`
-- `$ npm install -g ganache-cli` or installing its [graphic interface](https://truffleframework.com/ganache)
+- `$ npm -g install ganache-cli` or installing its [graphic interface](https://truffleframework.com/ganache)
 - Required truffle/solcjs version: >= 0.5
 
 ### Compile:
 - `$ truffle compile`
 
-### Deploy:
+### Deploy to local development network:
+- `$ ganache-cli`
 - `$ truffle migrate --reset`
 
+
+### Deploy to rinkeby testnet without dryrun:
+- `$ truffle compile --all`
+- `$ truffle migrate --reset --network rinkeby --skip-dry-run`
+
+
+### Deploy to mainnet without dryrun:
+- `$ truffle compile --all`
+- `$ truffle migrate --reset --network live --skip-dry-run`
+
+
 ### Test:
+- `$ ganache-cli -a 20`; // Config more than 10 test accounts 
 - `$ truffle test`
+
+### Deployed:
+See `deployed.json`.

contracts/CoingeckoParserV2.sol

@@ -0,0 +1,53 @@
+pragma solidity ^0.5.0;
+
+import "./lib/SafeMath.sol";
+import "./lib/StringUtils.sol";
+
+// A simple parser to parse coingecko api data.
+// Coingecko data api: https://www.coingecko.com/en/api.
+// e.g. source:   "https://api.coingecko.com/api/v3/simple/price?vs_currencies=usd&ids=ethereum,bitcoin,polkadot,huobi-token"
+// e.g. selector: "$..usd"
+// e.g. Return:   "[48766,1524.21,13.99,34.64]"
+contract CoingeckoParserV2 {
+    using StringUtils for *;
+    using SafeMath for uint;
+
+    string public constant description = "Coingecko API Data Parser V2";
+    uint private constant ten = 10;
+
+    // e.g.:
+    //   floatStr2Uint("123.4567", 0) => 123
+    //   floatStr2Uint("123.4567", 2) => 12345
+    //   floatStr2Uint("123.4567", 8) => 12345670000
+    function floatStr2Uint(string memory raw, uint decimal) public pure returns(uint) {
+        uint integral = raw.str2Uint();
+        uint fractional = 0;
+        uint dotIdx = raw.indexOf('.');
+        uint fracIdx = dotIdx + 1;
+        if (dotIdx != bytes(raw).length && fracIdx < bytes(raw).length) {
+            string memory fracStr = raw.subStr(fracIdx, decimal);
+            fractional = fracStr.str2Uint();
+            if (decimal > bytes(fracStr).length) {
+                fractional = fractional.mul(ten.pow(decimal - bytes(fracStr).length));
+            }
+        }
+        return integral.mul(ten.pow(decimal)).add(fractional);
+    }
+
+    function floatBytes2UintArray(bytes memory raw, uint decimal) public pure returns (uint[] memory) {
+        uint len = raw.length;
+        string[] memory s_arr = string(raw.subStr(1, len - 2)).split(',');
+        uint[] memory uint_arr = new uint[](s_arr.length);
+        for (uint i = 0; i < s_arr.length; i++) {
+            uint_arr[i] = floatStr2Uint(s_arr[i], decimal);
+        }
+        return uint_arr;
+    }
+
+    // e.g.:
+    // floatStrs2UintArray("[48766,1524.21,13.99,34.64]", 8) => [4876600000000,152421000000,1399000000,3464000000]
+    // floatStrs2UintArray("[12.34]", 8) => [1234000000]
+    function floatStrs2UintArray(string memory raw, uint decimal) public pure returns (uint[] memory) {
+        return floatBytes2UintArray(bytes(raw), decimal);
+    }
+}

contracts/CommitReveal.sol

@@ -0,0 +1,119 @@
+pragma solidity ^0.5.0;
+
+contract DOSAddressBridgeI {
+    function getProxyAddress() public view returns(address);
+}
+
+contract CommitReveal {
+    struct Participant {
+        uint secret;
+        bytes32 commitment;
+        bool revealed;
+    }
+
+    struct Campaign {
+        uint startBlock;
+        uint commitDuration;  // in blocks
+        uint revealDuration;  // in blocks
+        uint revealThreshold;
+        uint commitNum;
+        uint revealNum;
+        uint generatedRandom;
+        mapping(address => Participant) participants;
+        mapping(bytes32 => bool) commitments;
+    }
+
+    Campaign[] public campaigns;
+    DOSAddressBridgeI public addressBridge;
+
+    modifier checkCommit(uint _cid, bytes32 _commitment) {
+        Campaign storage c = campaigns[_cid];
+        require(_cid != 0 &&
+                block.number >= c.startBlock &&
+                block.number < c.startBlock + c.commitDuration,
+                "not-in-commit");
+        require(_commitment != "", "empty-commitment");
+        require(!c.commitments[_commitment], "duplicate-commitment");
+        _;
+    }
+    modifier checkReveal(uint _cid) {
+        Campaign storage c = campaigns[_cid];
+        require(_cid != 0 &&
+                block.number >= c.startBlock + c.commitDuration &&
+                block.number < c.startBlock + c.commitDuration + c.revealDuration,
+                "not-in-reveal");
+        _;
+    }
+    modifier checkFinish(uint _cid) {
+        Campaign storage c = campaigns[_cid];
+        require(_cid != 0 &&
+                block.number >= c.startBlock + c.commitDuration + c.revealDuration,
+                "commit-reveal-not-finished");
+        _;
+    }
+    modifier onlyFromProxy() {
+        require(msg.sender == addressBridge.getProxyAddress(), "not-from-dos-proxy");
+        _;
+    }
+
+    event LogStartCommitReveal(uint cid, uint startBlock, uint commitDuration, uint revealDuration, uint revealThreshold);
+    event LogCommit(uint cid, address from, bytes32 commitment);
+    event LogReveal(uint cid, address from, uint secret);
+    event LogRandom(uint cid, uint random);
+    event LogRandomFailure(uint cid, uint commitNum, uint revealNum, uint revealThreshold);
+
+    constructor(address _bridgeAddr) public {
+        // campaigns[0] is not used.
+        campaigns.length++;
+        addressBridge = DOSAddressBridgeI(_bridgeAddr);
+    }
+
+    // Returns new campaignId.
+    function startCommitReveal(
+        uint _startBlock,
+        uint _commitDuration,
+        uint _revealDuration,
+        uint _revealThreshold
+    )
+        public
+        onlyFromProxy
+        returns(uint)
+    {
+        uint newCid = campaigns.length;
+        campaigns.push(Campaign(_startBlock, _commitDuration, _revealDuration, _revealThreshold, 0, 0, 0));
+        emit LogStartCommitReveal(newCid, _startBlock, _commitDuration, _revealDuration, _revealThreshold);
+        return newCid;
+    }
+
+    function commit(uint _cid, bytes32 _secretHash) public checkCommit(_cid, _secretHash) {
+        Campaign storage c = campaigns[_cid];
+        c.commitments[_secretHash] = true;
+        c.participants[msg.sender] = Participant(0, _secretHash, false);
+        c.commitNum++;
+        emit LogCommit(_cid, msg.sender, _secretHash);
+    }
+
+    function reveal(uint _cid, uint _secret) public checkReveal(_cid) {
+        Campaign storage c = campaigns[_cid];
+        Participant storage p = c.participants[msg.sender];
+        require(!p.revealed && keccak256(abi.encodePacked(_secret)) == p.commitment,
+                "revealed-secret-not-match-commitment");
+        p.secret = _secret;
+        p.revealed = true;
+        c.revealNum++;
+        c.generatedRandom ^= _secret;
+        emit LogReveal(_cid, msg.sender, _secret);
+    }
+
+    // Return value of 0 representing invalid random output.
+    function getRandom(uint _cid) public checkFinish(_cid) returns (uint) {
+        Campaign storage c = campaigns[_cid];
+        if (c.revealNum >= c.revealThreshold) {
+            emit LogRandom(_cid, c.generatedRandom);
+            return c.generatedRandom;
+        } else{
+            emit LogRandomFailure(_cid, c.commitNum, c.revealNum, c.revealThreshold);
+            return 0;
+        }
+    }
+}