Initialize custom actions on start

Joon-Mo Yang · Joon Mo Yang · commit fd9eebaa37c1 · 2018-07-26T19:53:05.000+09:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,6 +17,7 @@ codechain-merkle = { path = "util/merkle" }
 codechain-network = { path = "network" }
 codechain-reactor = { path = "util/reactor" }
 codechain-rpc = { path = "rpc" }
+codechain-state = { path = "state" }
 codechain-sync = { path = "sync" }
 codechain-types = { path = "types" }
 codechain-vm = { path = "vm" }
diff --git a/codechain/config/chain_type.rs b/codechain/config/chain_type.rs
@@ -15,9 +15,11 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use std::str::FromStr;
+use std::sync::Arc;
 use std::{fmt, fs};
 
 use ccore::Spec;
+use cstate::ActionHandler;
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -66,17 +68,17 @@ impl fmt::Display for ChainType {
 }
 
 impl ChainType {
-    pub fn spec<'a>(&self) -> Result<Spec, String> {
+    pub fn spec<'a>(&self, handlers: Vec<Arc<ActionHandler>>) -> Result<Spec, String> {
         match self {
-            ChainType::Solo => Ok(Spec::new_test_solo()),
-            ChainType::SoloAuthority => Ok(Spec::new_test_solo_authority()),
-            ChainType::Tendermint => Ok(Spec::new_test_tendermint()),
-            ChainType::Cuckoo => Ok(Spec::new_test_cuckoo()),
-            ChainType::BlakePoW => Ok(Spec::new_test_blake_pow()),
+            ChainType::Solo => Ok(Spec::new_test_solo(handlers)),
+            ChainType::SoloAuthority => Ok(Spec::new_test_solo_authority(handlers)),
+            ChainType::Tendermint => Ok(Spec::new_test_tendermint(handlers)),
+            ChainType::Cuckoo => Ok(Spec::new_test_cuckoo(handlers)),
+            ChainType::BlakePoW => Ok(Spec::new_test_blake_pow(handlers)),
             ChainType::Custom(filename) => {
                 let file = fs::File::open(filename)
                     .map_err(|e| format!("Could not load specification file at {}: {}", filename, e))?;
-                Spec::load(file)
+                Spec::load(file, handlers)
             }
         }
     }
diff --git a/codechain/main.rs b/codechain/main.rs
@@ -35,6 +35,7 @@ extern crate codechain_logger as clogger;
 extern crate codechain_network as cnetwork;
 extern crate codechain_reactor as creactor;
 extern crate codechain_rpc as crpc;
+extern crate codechain_state as cstate;
 extern crate codechain_sync as csync;
 extern crate codechain_types as ctypes;
 extern crate ctrlc;
@@ -263,7 +264,10 @@ fn run_node(matches: ArgMatches) -> Result<(), String> {
 
     let _event_loop = EventLoop::spawn();
     let config = load_config(&matches)?;
-    let spec = config.operating.chain.spec()?;
+
+    // Add handlers here to accept additional custom actions
+    let custom_action_handlers = vec![];
+    let spec = config.operating.chain.spec(custom_action_handlers)?;
 
     let instance_id = config.operating.instance_id.unwrap_or(
         SystemTime::now()
diff --git a/core/src/block.rs b/core/src/block.rs
@@ -453,7 +453,7 @@ mod tests {
 
     #[test]
     fn open_block() {
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         let genesis_header = spec.genesis_header();
         let db = spec.ensure_genesis_state(get_temp_state_db(), &Default::default()).unwrap();
         let b = OpenBlock::new(&*spec.engine, Default::default(), db, &genesis_header, Address::zero(), vec![], false)
diff --git a/core/src/client/test_client.rs b/core/src/client/test_client.rs
@@ -114,7 +114,7 @@ impl TestBlockChainClient {
 
     /// Creates new test client with specified extra data for each block
     pub fn new_with_extra_data(extra_data: Bytes) -> Self {
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         TestBlockChainClient::new_with_spec_and_extra(spec, extra_data)
     }
 
diff --git a/core/src/consensus/solo/mod.rs b/core/src/consensus/solo/mod.rs
@@ -88,7 +88,7 @@ mod tests {
 
     #[test]
     fn solo_can_seal() {
-        let spec = Spec::new_test_solo();
+        let spec = Spec::new_test_solo(Vec::new());
         let engine = &*spec.engine;
         let db = spec.ensure_genesis_state(get_temp_state_db(), &Default::default()).unwrap();
         let genesis_header = spec.genesis_header();
@@ -104,7 +104,7 @@ mod tests {
 
     #[test]
     fn solo_cant_verify() {
-        let engine = Spec::new_test_solo().engine;
+        let engine = Spec::new_test_solo(Vec::new()).engine;
         let mut header: Header = Header::default();
 
         assert!(engine.verify_block_basic(&header).is_ok());
diff --git a/core/src/consensus/solo_authority/mod.rs b/core/src/consensus/solo_authority/mod.rs
@@ -207,13 +207,13 @@ mod tests {
 
     #[test]
     fn has_valid_metadata() {
-        let engine = Spec::new_test_solo_authority().engine;
+        let engine = Spec::new_test_solo_authority(Vec::new()).engine;
         assert!(!engine.name().is_empty());
     }
 
     #[test]
     fn can_do_signature_verification_fail() {
-        let engine = Spec::new_test_solo_authority().engine;
+        let engine = Spec::new_test_solo_authority(Vec::new()).engine;
         let mut header: Header = Header::default();
         header.set_seal(vec![::rlp::encode(&SignatureData::default()).into_vec()]);
 
@@ -223,7 +223,7 @@ mod tests {
 
     #[test]
     fn can_generate_seal() {
-        let spec = Spec::new_test_solo_authority();
+        let spec = Spec::new_test_solo_authority(Vec::new());
         let engine = &*spec.engine;
         let db = spec.ensure_genesis_state(get_temp_state_db(), &Default::default()).unwrap();
         let genesis_header = spec.genesis_header();
@@ -239,7 +239,7 @@ mod tests {
 
     #[test]
     fn seals_internally() {
-        let engine = Spec::new_test_solo_authority().engine;
+        let engine = Spec::new_test_solo_authority(Vec::new()).engine;
         assert!(!engine.seals_internally().unwrap());
     }
 }
diff --git a/core/src/consensus/tendermint/mod.rs b/core/src/consensus/tendermint/mod.rs
@@ -953,13 +953,13 @@ mod tests {
 
     #[test]
     fn has_valid_metadata() {
-        let engine = Spec::new_test_tendermint().engine;
+        let engine = Spec::new_test_tendermint(Vec::new()).engine;
         assert!(!engine.name().is_empty());
     }
 
     #[test]
     fn verification_fails_on_short_seal() {
-        let engine = Spec::new_test_tendermint().engine;
+        let engine = Spec::new_test_tendermint(Vec::new()).engine;
         let header = Header::default();
 
         let verify_result = engine.verify_block_basic(&header);
diff --git a/core/src/miner/sealing_queue.rs b/core/src/miner/sealing_queue.rs
@@ -82,7 +82,7 @@ mod tests {
     const QUEUE_SIZE: usize = 2;
 
     fn create_closed_block(address: Address) -> ClosedBlock {
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         let genesis_header = spec.genesis_header();
         let db = spec.ensure_genesis_state(get_temp_state_db(), &Default::default()).unwrap();
         let b = OpenBlock::new(&*spec.engine, Default::default(), db, &genesis_header, address, vec![], false).unwrap();
diff --git a/core/src/spec/spec.rs b/core/src/spec/spec.rs
@@ -20,7 +20,9 @@ use std::sync::Arc;
 use ccrypto::{blake256, BLAKE_NULL_RLP};
 use cjson;
 use ckey::Address;
-use cstate::{Backend, Metadata, MetadataAddress, Shard, ShardAddress, ShardMetadataAddress, StateDB, StateResult};
+use cstate::{
+    ActionHandler, Backend, Metadata, MetadataAddress, Shard, ShardAddress, ShardMetadataAddress, StateDB, StateResult,
+};
 use ctypes::ShardId;
 use hashdb::HashDB;
 use parking_lot::RwLock;
@@ -103,6 +105,8 @@ pub struct Spec {
     /// Genesis state as plain old data.
     genesis_accounts: PodAccounts,
     genesis_shards: PodShards,
+
+    custom_handlers: Vec<Arc<ActionHandler>>,
 }
 
 // helper for formatting errors.
@@ -111,8 +115,8 @@ fn fmt_err<F: ::std::fmt::Display>(f: F) -> String {
 }
 
 macro_rules! load_bundled {
-    ($e:expr) => {
-        Spec::load(include_bytes!(concat!("../../res/", $e, ".json")) as &[u8]).expect(concat!(
+    ($e:expr, $h:expr) => {
+        Spec::load(include_bytes!(concat!("../../res/", $e, ".json")) as &[u8], $h).expect(concat!(
             "Chain spec ",
             $e,
             " is invalid."
@@ -147,6 +151,7 @@ impl Spec {
         let root = BLAKE_NULL_RLP;
         let (db, root) = self.initialize_accounts(trie_factory, db, root)?;
         let (db, root) = self.initialize_shards(trie_factory, db, root)?;
+        let (db, root) = self.initialize_custom_actions(trie_factory, db, root)?;
 
         *self.state_root_memo.write() = root;
         Ok(db)
@@ -229,6 +234,24 @@ impl Spec {
         Ok((db, root))
     }
 
+    fn initialize_custom_actions<DB: Backend>(
+        &self,
+        trie_factory: &TrieFactory,
+        mut db: DB,
+        mut root: H256,
+    ) -> StateResult<(DB, H256)> {
+        // basic accounts in spec.
+        {
+            let mut t = trie_factory.from_existing(db.as_hashdb_mut(), &mut root)?;
+
+            for handler in &self.custom_handlers {
+                handler.init(t.as_mut())?;
+            }
+        }
+
+        Ok((db, root))
+    }
+
     pub fn check_genesis_root(&self, db: &HashDB) -> bool {
         if db.keys().is_empty() {
             return true
@@ -273,43 +296,43 @@ impl Spec {
 
     /// Loads spec from json file. Provide factories for executing contracts and ensuring
     /// storage goes to the right place.
-    pub fn load<'a, R>(reader: R) -> Result<Self, String>
+    pub fn load<'a, R>(reader: R, handlers: Vec<Arc<ActionHandler>>) -> Result<Self, String>
     where
         R: Read, {
-        cjson::spec::Spec::load(reader).map_err(fmt_err).and_then(|x| load_from(x).map_err(fmt_err))
+        cjson::spec::Spec::load(reader).map_err(fmt_err).and_then(|x| load_from(x, handlers).map_err(fmt_err))
     }
 
     /// Create a new test Spec.
-    pub fn new_test() -> Self {
-        load_bundled!("null")
+    pub fn new_test(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("null", handlers)
     }
 
     /// Create a new Spec with Solo consensus which does internal sealing (not requiring
     /// work).
-    pub fn new_test_solo() -> Self {
-        load_bundled!("solo")
+    pub fn new_test_solo(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("solo", handlers)
     }
 
     /// Create a new Spec with SoloAuthority consensus which does internal sealing (not requiring
     /// work).
-    pub fn new_test_solo_authority() -> Self {
-        load_bundled!("solo_authority")
+    pub fn new_test_solo_authority(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("solo_authority", handlers)
     }
 
     /// Create a new Spec with Tendermint consensus which does internal sealing (not requiring
     /// work).
-    pub fn new_test_tendermint() -> Self {
-        load_bundled!("tendermint")
+    pub fn new_test_tendermint(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("tendermint", handlers)
     }
 
     /// Create a new Spec with Cuckoo PoW consensus.
-    pub fn new_test_cuckoo() -> Self {
-        load_bundled!("cuckoo")
+    pub fn new_test_cuckoo(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("cuckoo", handlers)
     }
 
     /// Create a new Spec with Blake PoW consensus.
-    pub fn new_test_blake_pow() -> Self {
-        load_bundled!("blake_pow")
+    pub fn new_test_blake_pow(handlers: Vec<Arc<ActionHandler>>) -> Self {
+        load_bundled!("blake_pow", handlers)
     }
 
     /// Get common blockchain parameters.
@@ -350,7 +373,7 @@ impl Spec {
 }
 
 /// Load from JSON object.
-fn load_from(s: cjson::spec::Spec) -> Result<Spec, Error> {
+fn load_from(s: cjson::spec::Spec, handlers: Vec<Arc<ActionHandler>>) -> Result<Spec, Error> {
     let g = Genesis::from(s.genesis);
     let GenericSeal(seal_rlp) = g.seal.into();
     let params = CommonParams::from(s.params);
@@ -371,6 +394,8 @@ fn load_from(s: cjson::spec::Spec) -> Result<Spec, Error> {
         state_root_memo: RwLock::new(Default::default()), // will be overwritten right after.
         genesis_accounts: s.accounts.into(),
         genesis_shards: s.shards.into(),
+
+        custom_handlers: handlers,
     };
 
     // use memoized state root if provided.
@@ -394,7 +419,7 @@ mod tests {
 
     #[test]
     fn extra_data_of_genesis_header_is_hash_of_common_params() {
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         let common_params = spec.params();
         let hash_of_common_params = H256::blake(&common_params.rlp_bytes()).to_vec();
 
diff --git a/core/src/tests/helpers.rs b/core/src/tests/helpers.rs
@@ -48,7 +48,7 @@ pub fn get_good_dummy_block() -> Bytes {
 
 pub fn get_good_dummy_block_hash() -> (H256, Bytes) {
     let mut block_header = Header::new();
-    let test_spec = Spec::new_test();
+    let test_spec = Spec::new_test(Vec::new());
     block_header.set_score(U256::from(0x20000));
     block_header.set_timestamp(40);
     block_header.set_number(1);
diff --git a/core/src/verification/queue/mod.rs b/core/src/verification/queue/mod.rs
@@ -514,7 +514,7 @@ mod tests {
     // create a test block queue.
     // auto_scaling enables verifier adjustment.
     fn get_test_queue() -> BlockQueue {
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         let engine = spec.engine;
 
         let config = Config::default();
@@ -524,7 +524,7 @@ mod tests {
     #[test]
     fn can_be_created() {
         // TODO better test
-        let spec = Spec::new_test();
+        let spec = Spec::new_test(Vec::new());
         let engine = spec.engine;
 
         let config = Config::default();
diff --git a/state/src/lib.rs b/state/src/lib.rs
@@ -51,6 +51,7 @@ mod traits;
 #[cfg(test)]
 pub mod tests;
 
+pub use action_handler::ActionHandler;
 pub use backend::{Backend, ShardBackend, TopBackend};
 pub use checkpoint::{CheckpointId, StateWithCheckpoint};
 pub use db::StateDB;

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ impl TestBlockChainClient {`
`114`	`114`
`115`	`115`	`/// Creates new test client with specified extra data for each block`
`116`	`116`	`pub fn new_with_extra_data(extra_data: Bytes) -> Self {`
`117`		`- let spec = Spec::new_test();`
	`117`	`+ let spec = Spec::new_test(Vec::new());`
`118`	`118`	`TestBlockChainClient::new_with_spec_and_extra(spec, extra_data)`
`119`	`119`	`}`
`120`	`120`