Add stake to solo

foriequal0 · mergify[bot] · commit 4c65699f7b8b · 2019-04-22T09:59:17.000Z
diff --git a/core/res/solo.json b/core/res/solo.json
@@ -3,7 +3,12 @@
   "engine": {
     "solo": {
       "params": {
-        "hit": {}
+        "hit": {},
+        "genesisStakes": {
+          "tccq9h7vnl68frvqapzv3tujrxtxtwqdnxw6yamrrgd": 70000,
+          "tccq9qvruafmf9vegjhkl0ruunkwp0d4lc8fgxknzh5": 20000,
+          "tccq8snvxt5vfwthja7z7880dgs63x4njw2n5e5zm4h": 10000
+        }
       }
     }
   },
diff --git a/core/src/codechain_machine.rs b/core/src/codechain_machine.rs
@@ -208,7 +208,7 @@ impl CodeChainMachine {
         Ok(())
     }
 
-    fn min_cost(&self, action: &Action) -> u64 {
+    pub fn min_cost(&self, action: &Action) -> u64 {
         match action {
             Action::MintAsset {
                 ..
diff --git a/core/src/consensus/solo/mod.rs b/core/src/consensus/solo/mod.rs
@@ -22,6 +22,8 @@ use cstate::{ActionHandler, HitHandler};
 use ctypes::machine::WithBalances;
 
 use self::params::SoloParams;
+use super::stake;
+use super::validator_set;
 use super::{ConsensusEngine, Seal};
 use crate::block::{ExecutedBlock, IsBlock};
 use crate::codechain_machine::CodeChainMachine;
@@ -43,6 +45,10 @@ impl<M> Solo<M> {
         if params.enable_hit_handler {
             action_handlers.push(Arc::new(HitHandler::new()));
         }
+        action_handlers.push(Arc::new(stake::Stake::new(
+            params.genesis_stakes.clone(),
+            Arc::new(validator_set::null_validator::NullValidator {}),
+        )));
 
         Solo {
             params,
@@ -79,9 +85,23 @@ impl ConsensusEngine<CodeChainMachine> for Solo<CodeChainMachine> {
 
     fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
         let author = *block.header().author();
-        let total_reward = self.block_reward(block.header().number())
-            + self.block_fee(Box::new(block.transactions().to_owned().into_iter().map(Into::into)));
-        self.machine.add_balance(block, &author, total_reward)
+        let (total_reward, min_fee) = {
+            let transactions = block.transactions();
+            let block_reward = self.block_reward(block.header().number());
+            let total_fee: u64 = transactions.iter().map(|tx| tx.fee).sum();
+            let min_fee: u64 = transactions.iter().map(|tx| self.machine().min_cost(&tx.action)).sum();
+            (block_reward + total_fee, min_fee)
+        };
+
+        assert!(total_reward >= min_fee, "{} >= {}", total_reward, min_fee);
+        let stakes = stake::get_stakes(block.state()).expect("Cannot get Stake status");
+        for (address, share) in stake::fee_distribute(&author, min_fee, &stakes) {
+            self.machine.add_balance(block, &address, share)?
+        }
+        if total_reward != min_fee {
+            self.machine.add_balance(block, &author, total_reward - min_fee)?
+        }
+        Ok(())
     }
 
     fn block_reward(&self, _block_number: u64) -> u64 {
diff --git a/core/src/consensus/solo/params.rs b/core/src/consensus/solo/params.rs
@@ -14,21 +14,32 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::collections::HashMap;
+
 use cjson;
+use ckey::{Address, PlatformAddress};
 
 /// Params for a null engine.
 #[derive(Clone, Default)]
 pub struct SoloParams {
     /// base reward for a block.
     pub block_reward: u64,
     pub enable_hit_handler: bool,
+    pub genesis_stakes: HashMap<Address, u64>,
 }
 
 impl From<cjson::scheme::SoloParams> for SoloParams {
     fn from(p: cjson::scheme::SoloParams) -> Self {
         SoloParams {
             block_reward: p.block_reward.map_or_else(Default::default, Into::into),
             enable_hit_handler: p.action_handlers.hit.is_some(),
+            genesis_stakes: p
+                .action_handlers
+                .genesis_stakes
+                .unwrap_or_default()
+                .into_iter()
+                .map(|(pa, amount)| (PlatformAddress::into_address(pa), amount))
+                .collect(),
         }
     }
 }
diff --git a/core/src/consensus/validator_set/mod.rs b/core/src/consensus/validator_set/mod.rs
@@ -27,6 +27,7 @@ use crate::codechain_machine::CodeChainMachine;
 use crate::error::Error;
 use crate::header::Header;
 
+pub mod null_validator;
 pub mod validator_list;
 
 /// Creates a validator set from validator public keys.
diff --git a/core/src/consensus/validator_set/null_validator.rs b/core/src/consensus/validator_set/null_validator.rs
@@ -0,0 +1,78 @@
+// Copyright 2019. Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+use ckey::{Address, Public};
+use primitives::H256;
+
+use super::super::EpochChange;
+use super::validator_list::ValidatorList;
+use super::ValidatorSet;
+use crate::codechain_machine::CodeChainMachine;
+use crate::error::Error;
+use crate::header::Header;
+
+/// Validator set containing a known set of public keys.
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+pub struct NullValidator {}
+
+impl ValidatorSet for NullValidator {
+    fn contains(&self, _bh: &H256, _public: &Public) -> bool {
+        true
+    }
+
+    fn contains_address(&self, _bh: &H256, _address: &Address) -> bool {
+        true
+    }
+
+    fn get(&self, _parent: &H256, _nonce: usize) -> Public {
+        unimplemented!()
+    }
+
+    fn get_address(&self, _parent: &H256, _nonce: usize) -> Address {
+        unimplemented!()
+    }
+
+    fn get_index(&self, _parent: &H256, _public: &Public) -> Option<usize> {
+        unimplemented!()
+    }
+
+    fn get_index_by_address(&self, _parent: &H256, _address: &Address) -> Option<usize> {
+        unimplemented!()
+    }
+
+    fn count(&self, _parent: &H256) -> usize {
+        unimplemented!()
+    }
+
+    fn is_epoch_end(&self, _first: bool, _chain_head: &Header) -> Option<Vec<u8>> {
+        unimplemented!()
+    }
+
+    fn signals_epoch_end(&self, _first: bool, _header: &Header) -> EpochChange {
+        unimplemented!()
+    }
+
+    fn epoch_set(
+        &self,
+        _first: bool,
+        _machine: &CodeChainMachine,
+        _number: u64,
+        _proof: &[u8],
+    ) -> Result<(ValidatorList, Option<H256>), Error> {
+        unimplemented!()
+    }
+}
diff --git a/json/src/scheme/solo.rs b/json/src/scheme/solo.rs
@@ -16,6 +16,8 @@
 
 use std::collections::HashMap;
 
+use ckey::PlatformAddress;
+
 use crate::uint::Uint;
 
 /// Solo params deserialization.
@@ -32,6 +34,7 @@ pub struct SoloParams {
 #[serde(rename_all = "camelCase")]
 pub struct SoloActionHandlersParams {
     pub hit: Option<HashMap<(), ()>>,
+    pub genesis_stakes: Option<HashMap<PlatformAddress, u64>>,
 }
 
 /// Solo engine deserialization.
@@ -55,12 +58,14 @@ mod tests {
         let s = r#"{
             "params": {
                 "blockReward": "0x0d",
-                "hit": {}
+                "hit": {},
+                "genesisStakes": {}
             }
         }"#;
 
         let deserialized: Solo = serde_json::from_str(s).unwrap();
         assert_eq!(deserialized.params.block_reward, Some(Uint(U256::from(0x0d))));
         assert_eq!(deserialized.params.action_handlers.hit, Some(HashMap::new()));
+        assert_eq!(deserialized.params.action_handlers.genesis_stakes, Some(HashMap::new()));
     }
 }
diff --git a/test/src/e2e/reward.test.ts b/test/src/e2e/reward.test.ts
@@ -15,12 +15,21 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import { expect } from "chai";
-import { U64 } from "codechain-sdk/lib/core/classes";
+import { PlatformAddress, U64 } from "codechain-sdk/lib/core/classes";
 import "mocha";
-import { aliceAddress, aliceSecret, faucetAddress } from "../helper/constants";
+import {
+    aliceAddress,
+    aliceSecret,
+    bobAddress,
+    faucetAddress
+} from "../helper/constants";
 import CodeChain from "../helper/spawn";
 
 describe("Reward = 50, 1 miner", function() {
+    const MIN_FEE_PAY = 10;
+    const BLOCK_REWARD = 50;
+    const FAUCET_INITIAL_CCS = new U64("18000000000000000000");
+
     let node: CodeChain;
 
     beforeEach(async function() {
@@ -33,15 +42,30 @@ describe("Reward = 50, 1 miner", function() {
 
     it("Mining an empty block", async function() {
         await node.sdk.rpc.devel.startSealing();
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(FAUCET_INITIAL_CCS);
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(50)
+            new U64(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(0)
         );
     });
 
     it("Mining a block with 1 transaction", async function() {
         await node.sendPayTx({ fee: 10 });
+
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(
+            FAUCET_INITIAL_CCS.minus(10 /* fee */).plus(7 /* share */)
+        );
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(50 + 10)
+            new U64(2 /* share */).plus(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(1 /* share */)
         );
     });
 
@@ -60,33 +84,81 @@ describe("Reward = 50, 1 miner", function() {
             seq: 2
         });
         await node.sdk.rpc.devel.startSealing();
+
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(
+            FAUCET_INITIAL_CCS.minus(10 + 10 + 15 /* fee */).plus(
+                21 /* share */
+            )
+        );
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(50 + 35)
+            new U64(6 /* share */)
+                .plus(10 + 10 + 15 - 3 * MIN_FEE_PAY /* share remaining */)
+                .plus(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(3 /* share */)
         );
     });
 
     it("Mining a block with a transaction that pays the author", async function() {
         await node.pay(aliceAddress, 100);
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(
+            FAUCET_INITIAL_CCS.minus(100 /* pay */)
+                .minus(10 /* fee */)
+                .plus(7 /* share */)
+        );
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(50 + 10 + 100)
+            new U64(100 /* pay */).plus(2 /* share */).plus(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(1 /* share */)
         );
     });
 
     it("Mining a block with a transaction which author pays someone in", async function() {
-        await node.sendPayTx({ fee: 10 }); // +60
+        await node.sendPayTx({ fee: 10 });
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(
+            FAUCET_INITIAL_CCS.minus(10 /* fee */).plus(7 /* share */)
+        );
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(60)
+            new U64(2 /* share */).plus(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(1 /* share */)
         );
 
         const tx = await node.sdk.core
             .createPayTransaction({
                 recipient: faucetAddress,
-                quantity: 50
+                quantity: 20
             })
-            .sign({ secret: aliceSecret, seq: 0, fee: 10 }); // -60
-        await node.sdk.rpc.chain.sendSignedTransaction(tx); // +60
+            .sign({ secret: aliceSecret, seq: 0, fee: 10 });
+        await node.sdk.rpc.chain.sendSignedTransaction(tx);
+
+        expect(
+            await node.sdk.rpc.chain.getBalance(faucetAddress)
+        ).to.deep.equal(
+            FAUCET_INITIAL_CCS.minus(10)
+                .plus(7)
+                .plus(20 /* pay */)
+                .plus(7 /* share */)
+        );
         expect(await node.sdk.rpc.chain.getBalance(aliceAddress)).to.deep.equal(
-            new U64(60)
+            new U64(2)
+                .plus(BLOCK_REWARD)
+                .minus(20 /* pay */)
+                .minus(10 /* fee */)
+                .plus(2 /* share */)
+                .plus(BLOCK_REWARD)
+        );
+        expect(await node.sdk.rpc.chain.getBalance(bobAddress)).to.deep.equal(
+            new U64(1 /* share*/).plus(1 /* share */)
         );
     });
 
diff --git a/test/src/e2e/staking.test.ts b/test/src/e2e/staking.test.ts
diff --git a/test/src/e2e/unwrap.test.ts b/test/src/e2e/unwrap.test.ts
diff --git a/test/src/scheme/solo-block-reward-50.json b/test/src/scheme/solo-block-reward-50.json

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,12 @@`
`3`	`3`	`"engine": {`
`4`	`4`	`"solo": {`
`5`	`5`	`"params": {`
`6`		`- "hit": {}`
	`6`	`+ "hit": {},`
	`7`	`+ "genesisStakes": {`
	`8`	`+ "tccq9h7vnl68frvqapzv3tujrxtxtwqdnxw6yamrrgd": 70000,`
	`9`	`+ "tccq9qvruafmf9vegjhkl0ruunkwp0d4lc8fgxknzh5": 20000,`
	`10`	`+ "tccq8snvxt5vfwthja7z7880dgs63x4njw2n5e5zm4h": 10000`
	`11`	`+ }`
`7`	`12`	`}`
`8`	`13`	`}`
`9`	`14`	`},`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ impl CodeChainMachine {`
`208`	`208`	`Ok(())`
`209`	`209`	`}`
`210`	`210`
`211`		`- fn min_cost(&self, action: &Action) -> u64 {`
	`211`	`+ pub fn min_cost(&self, action: &Action) -> u64 {`
`212`	`212`	`match action {`
`213`	`213`	`Action::MintAsset {`
`214`	`214`	`..`