Execute custom actions

Author: Joon-Mo Yang

core/src/client/client.rs

@@ -99,7 +99,7 @@ impl Client {
         let trie_factory = TrieFactory::new(trie_spec);
 
         let journal_db = journaldb::new(db.clone(), journaldb::Algorithm::Archive, ::db::COL_STATE);
-        let mut state_db = StateDB::new(journal_db, config.state_cache_size);
+        let mut state_db = StateDB::new(journal_db, config.state_cache_size, spec.custom_handlers.clone());
         if !spec.check_genesis_root(state_db.as_hashdb()) {
             return Err(SpecError::InvalidState.into())
         }

core/src/client/test_client.rs

@@ -288,7 +288,7 @@ impl TestBlockChainClient {
 pub fn get_temp_state_db() -> StateDB {
     let db = kvdb_memorydb::create(NUM_COLUMNS.unwrap_or(0));
     let journal_db = journaldb::new(Arc::new(db), journaldb::Algorithm::Archive, COL_STATE);
-    StateDB::new(journal_db, 1024 * 1024)
+    StateDB::new(journal_db, 1024 * 1024, Vec::new())
 }
 
 impl ReopenBlock for TestBlockChainClient {

core/src/spec/spec.rs

@@ -106,7 +106,7 @@ pub struct Spec {
     genesis_accounts: PodAccounts,
     genesis_shards: PodShards,
 
-    custom_handlers: Vec<Arc<ActionHandler>>,
+    pub custom_handlers: Vec<Arc<ActionHandler>>,
 }
 
 // helper for formatting errors.
@@ -402,7 +402,7 @@ fn load_from(s: cjson::spec::Spec, handlers: Vec<Arc<ActionHandler>>) -> Result<
     match g.state_root {
         Some(root) => *s.state_root_memo.get_mut() = root,
         None => {
-            let db = StateDB::new_with_memorydb(0);
+            let db = StateDB::new_with_memorydb(0, s.custom_handlers.clone());
             let trie_factory = TrieFactory::new(Default::default());
             let _ = s.initialize_state(&trie_factory, db)?;
         }

core/src/tests/helpers.rs

@@ -61,5 +61,5 @@ pub fn get_good_dummy_block_hash() -> (H256, Bytes) {
 }
 
 pub fn get_temp_state_db() -> StateDB {
-    StateDB::new_with_memorydb(5 * 1024 * 1024)
+    StateDB::new_with_memorydb(5 * 1024 * 1024, Vec::new())
 }

state/src/action_handler/hit.rs

@@ -44,6 +44,7 @@ impl Decodable for HitAction {
     }
 }
 
+#[derive(Clone)]
 pub struct HitHandler {}
 
 impl HitHandler {
@@ -60,7 +61,7 @@ impl HitHandler {
 
 impl ActionHandler for HitHandler {
     fn init(&self, state: &mut TrieMut) -> StateResult<()> {
-        let r = state.insert(&self.address(), &0u32.rlp_bytes());
+        let r = state.insert(&self.address(), &1u32.rlp_bytes());
         debug_assert_eq!(Ok(None), r);
         r?;
         Ok(())

state/src/backend.rs

@@ -37,12 +37,15 @@
 //! should become general over time to the point where not even a
 //! merkle trie is strictly necessary.
 
+use std::sync::Arc;
+
 use ckey::Address;
 use hashdb::HashDB;
 use primitives::{Bytes, H256};
 
 use super::{
-    Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Metadata, MetadataAddress, Shard, ShardAddress,
+    Account, ActionHandler, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Metadata, MetadataAddress, Shard,
+    ShardAddress,
 };
 
 
@@ -76,6 +79,8 @@ pub trait TopBackend: Send {
     fn get_cached_account_with<F, U>(&self, a: &Address, f: F) -> Option<U>
     where
         F: FnOnce(Option<&mut Account>) -> U;
+
+    fn custom_handlers(&self) -> &[Arc<ActionHandler>];
 }
 
 pub trait ShardBackend: Send {

state/src/db.rs

@@ -31,8 +31,8 @@ use primitives::{Bytes, H256};
 use util_error::UtilError;
 
 use super::{
-    Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Backend, CacheableItem, Metadata, MetadataAddress,
-    Shard, ShardAddress, ShardBackend, TopBackend,
+    Account, ActionHandler, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Backend, CacheableItem, Metadata,
+    MetadataAddress, Shard, ShardAddress, ShardBackend, TopBackend,
 };
 
 const STATE_CACHE_BLOCKS: usize = 12;
@@ -125,14 +125,16 @@ pub struct StateDB {
     commit_hash: Option<H256>,
     /// Number of the committing block or `None` if not committed yet.
     commit_number: Option<BlockNumber>,
+
+    custom_handlers: Vec<Arc<ActionHandler>>,
 }
 
 impl StateDB {
     /// Create a new instance wrapping `JournalDB` and the maximum allowed size
     /// of the LRU cache in bytes. Actual used memory may (read: will) be higher due to bookkeeping.
     // TODO: make the cache size actually accurate by moving the account storage cache
     // into the `AccountCache` structure as its own `LruCache<(Address, H256), H256>`.
-    pub fn new(db: Box<JournalDB>, cache_size: usize) -> StateDB {
+    pub fn new(db: Box<JournalDB>, cache_size: usize, custom_handlers: Vec<Arc<ActionHandler>>) -> StateDB {
         assert_eq!(
             100,
             ACCOUNT_CACHE_RATIO
@@ -197,12 +199,13 @@ impl StateDB {
             parent_hash: None,
             commit_hash: None,
             commit_number: None,
+            custom_handlers,
         }
     }
 
-    pub fn new_with_memorydb(cache_size: usize) -> Self {
+    pub fn new_with_memorydb(cache_size: usize, custom_handlers: Vec<Arc<ActionHandler>>) -> Self {
         let memorydb = Arc::new(kvdb_memorydb::create(0));
-        StateDB::new(journaldb::new(memorydb, Algorithm::Archive, None), cache_size)
+        StateDB::new(journaldb::new(memorydb, Algorithm::Archive, None), cache_size, custom_handlers)
     }
 
     /// Journal all recent operations under the given era and ID.
@@ -427,6 +430,7 @@ impl StateDB {
             parent_hash: Some(parent.clone()),
             commit_hash: None,
             commit_number: None,
+            custom_handlers: self.custom_handlers.clone(),
         }
     }
 
@@ -541,6 +545,8 @@ impl Clone for StateDB {
             parent_hash: None,
             commit_hash: None,
             commit_number: None,
+
+            custom_handlers: self.custom_handlers.clone(),
         }
     }
 }
@@ -609,6 +615,10 @@ impl TopBackend for StateDB {
         F: FnOnce(Option<&mut Account>) -> U, {
         self.get_cached_with(a, f, &self.account_cache)
     }
+
+    fn custom_handlers(&self) -> &[Arc<ActionHandler>] {
+        &self.custom_handlers
+    }
 }
 
 impl ShardBackend for StateDB {

state/src/impls/top_level.rs

@@ -410,6 +410,15 @@ impl TopLevelState {
                     error: None,
                 })
             }
+            Action::Custom(bytes) => {
+                let handlers = self.db.custom_handlers().to_vec();
+                for h in handlers {
+                    if h.is_target(bytes) {
+                        return h.execute(bytes, self)
+                    }
+                }
+                panic!("Unknown custom parcel accepted!")
+            }
         }
     }
 

state/src/tests.rs

@@ -19,7 +19,7 @@ pub mod helpers {
     use super::super::StateDB;
 
     pub fn get_temp_state_db() -> StateDB {
-        StateDB::new_with_memorydb(5 * 1024 * 1024)
+        StateDB::new_with_memorydb(5 * 1024 * 1024, Vec::new())
     }
 
     pub fn get_temp_state() -> TopLevelState {

types/src/parcel/action.rs

@@ -15,7 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use ckey::{Address, Public};
-use primitives::{H256, U256};
+use primitives::{Bytes, H256, U256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
 use super::super::transaction::Transaction;
@@ -25,6 +25,7 @@ const CHANGE_SHARD_STATE: u8 = 1;
 const PAYMENT: u8 = 2;
 const SET_REGULAR_KEY: u8 = 3;
 const CREATE_SHARD: u8 = 4;
+const CUSTOM: u8 = 5;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, RlpDecodable, RlpEncodable)]
 #[serde(rename_all = "camelCase")]
@@ -51,6 +52,7 @@ pub enum Action {
         key: Public,
     },
     CreateShard,
+    Custom(Bytes),
 }
 
 impl Encodable for Action {
@@ -85,6 +87,11 @@ impl Encodable for Action {
                 s.begin_list(1);
                 s.append(&CREATE_SHARD);
             }
+            Action::Custom(bytes) => {
+                s.begin_list(2);
+                s.append(&CUSTOM);
+                s.append(bytes);
+            }
         }
     }
 }
@@ -124,6 +131,12 @@ impl Decodable for Action {
                 }
                 Ok(Action::CreateShard)
             }
+            CUSTOM => {
+                if rlp.item_count()? != 2 {
+                    return Err(DecoderError::RlpIncorrectListLen)
+                }
+                Ok(Action::Custom(rlp.val_at(1)?))
+            }
             _ => Err(DecoderError::Custom("Unexpected action prefix")),
         }
     }