Make multiple users can share a shard

Author: Seulgi Kim

core/res/blake_pow.json

@@ -42,7 +42,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/res/cuckoo.json

@@ -45,7 +45,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/res/null.json

@@ -39,7 +39,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/res/solo.json

@@ -40,7 +40,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/res/solo_authority.json

@@ -44,7 +44,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/res/tendermint.json

@@ -56,7 +56,7 @@
   "shards": {
     "0": {
       "nonce": 0,
-      "owner": "0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6",
+      "owners": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"],
       "worlds": [{
         "nonce": 0,
         "owners": [

core/src/spec/pod_shard_metadata.rs

@@ -25,7 +25,7 @@ use super::pod_world::PodWorld;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PodShardMetadata {
-    pub owner: Address,
+    pub owners: Vec<Address>,
     pub nonce: u64,
     pub worlds: Vec<PodWorld>,
 }
@@ -48,14 +48,14 @@ impl From<cjson::spec::Shard> for PodShardMetadata {
     fn from(s: cjson::spec::Shard) -> Self {
         Self {
             nonce: s.nonce.map(Into::into).unwrap_or(0),
-            owner: s.owner.into(),
+            owners: s.owners.into_iter().map(Into::into).collect(),
             worlds: s.worlds.unwrap_or_else(Vec::new).into_iter().map(Into::into).collect(),
         }
     }
 }
 
 impl fmt::Display for PodShardMetadata {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(#nonce={}; owner={}; worlds={:#?})", self.nonce, self.owner, self.worlds)
+        write!(f, "(#nonce={}; owners={:#?}; worlds={:#?})", self.nonce, self.owners, self.worlds)
     }
 }

core/src/spec/spec.rs

@@ -25,6 +25,7 @@ use cstate::{
     ActionHandler, Backend, Metadata, MetadataAddress, Shard, ShardAddress, ShardMetadataAddress, StateDB, StateResult,
     WorldAddress,
 };
+use ctypes::transaction::Error as TransactionError;
 use ctypes::ShardId;
 use hashdb::HashDB;
 use parking_lot::RwLock;
@@ -177,7 +178,7 @@ impl Spec {
     }
 
     fn initialize_shards<DB: Backend>(&self, mut db: DB, mut root: H256) -> StateResult<(DB, H256)> {
-        let mut shard_roots = Vec::<(ShardId, H256, Address)>::with_capacity(self.genesis_shards.len());
+        let mut shard_roots = Vec::<(ShardId, H256, Vec<Address>)>::with_capacity(self.genesis_shards.len());
 
         // Initialize shard-level tries
         for (shard_id, shard) in &*self.genesis_shards {
@@ -200,8 +201,11 @@ impl Spec {
                     r?;
                 }
             }
-            let owner = shard.owner;
-            shard_roots.push((*shard_id, shard_root, owner));
+            let owners = shard.owners.clone();
+            if owners.is_empty() {
+                return Err(TransactionError::EmptyShardOwners(*shard_id).into())
+            }
+            shard_roots.push((*shard_id, shard_root, owners));
         }
 
         debug_assert_eq!(::std::mem::size_of::<u16>(), ::std::mem::size_of::<ShardId>());
@@ -214,12 +218,12 @@ impl Spec {
         let global_metadata = Metadata::new(shard_roots.len() as ShardId);
 
         // Initialize shards
-        for (shard_id, shard_root, owner) in shard_roots.into_iter() {
+        for (shard_id, shard_root, owners) in shard_roots.into_iter() {
             {
                 let mut t = TrieFactory::from_existing(db.as_hashdb_mut(), &mut root)?;
                 let address = ShardAddress::new(shard_id);
 
-                let shard = Shard::new(shard_root, owner);
+                let shard = Shard::new(shard_root, owners);
                 let r = t.insert(&*address, &shard.rlp_bytes());
                 debug_assert_eq!(Ok(None), r);
                 r?;

json/src/spec/shard.rs

@@ -21,7 +21,7 @@ use super::World;
 #[derive(Debug, PartialEq, Deserialize)]
 pub struct Shard {
     pub nonce: Option<Uint>,
-    pub owner: Address,
+    pub owners: Vec<Address>,
     pub worlds: Option<Vec<World>>,
 }
 
@@ -37,7 +37,7 @@ mod tests {
     fn shard_deserialization() {
         let s = r#"{
             "nonce": 0,
-            "owner": "0x01234567890abcdef0123456789abcdef0123456",
+            "owners": ["0x01234567890abcdef0123456789abcdef0123456"],
             "worlds": [{
                 "nonce": 3,
                 "owners": ["0x01234567890abcdef0123456789abcdef0123457"]
@@ -47,7 +47,7 @@ mod tests {
         assert_eq!(
             Shard {
                 nonce: Some(Uint(U256::from(0))),
-                owner: Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456")),
+                owners: vec![Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456"))],
                 worlds: Some(vec![World {
                     nonce: Some(Uint(U256::from(3))),
                     owners: Some(vec![Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123457"))]),
@@ -61,13 +61,13 @@ mod tests {
     fn shard_with_non_zero_nonce_deserialization() {
         let s = r#"{
             "nonce": 100,
-            "owner": "0x01234567890abcdef0123456789abcdef0123456"
+            "owners": ["0x01234567890abcdef0123456789abcdef0123456"]
         }"#;
         let shard: Shard = serde_json::from_str(s).unwrap();
         assert_eq!(
             Shard {
                 nonce: Some(Uint(U256::from(100))),
-                owner: Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456")),
+                owners: vec![Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456"))],
                 worlds: None,
             },
             shard
@@ -86,13 +86,13 @@ mod tests {
     #[test]
     fn shard_without_nonce_deserialization() {
         let s = r#"{
-            "owner": "0x01234567890abcdef0123456789abcdef0123456"
+            "owners": ["0x01234567890abcdef0123456789abcdef0123456"]
         }"#;
         let shard: Shard = serde_json::from_str(s).unwrap();
         assert_eq!(
             Shard {
                 nonce: None,
-                owner: Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456")),
+                owners: vec![Address(CoreAddress::from("01234567890abcdef0123456789abcdef0123456"))],
                 worlds: None,
             },
             shard

state/src/impls/shard_level.rs

@@ -108,7 +108,7 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
         shard_id: ShardId,
         transaction: &Transaction,
         sender: &Address,
-        shard_owner: &Address,
+        shard_owners: &[Address],
     ) -> StateResult<()> {
         debug_assert_eq!(Ok(()), transaction.verify());
         match transaction {
@@ -123,7 +123,7 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
                 nonce,
                 owners,
                 ..
-            } => Ok(self.set_world_owners(*shard_id, *world_id, *nonce, &owners, sender, shard_owner)?),
+            } => Ok(self.set_world_owners(*shard_id, *world_id, *nonce, &owners, sender, shard_owners)?),
             Transaction::AssetMint {
                 metadata,
                 registrar,
@@ -173,11 +173,11 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
         nonce: u64,
         owners: &[Address],
         sender: &Address,
-        shard_owner: &Address,
+        shard_owners: &[Address],
     ) -> StateResult<()> {
         let world: World = self.world(world_id)?.ok_or_else(|| TransactionError::InvalidWorldId(world_id))?;
 
-        if shard_owner != sender && !world.world_owners().contains(sender) {
+        if !shard_owners.contains(sender) && !world.world_owners().contains(sender) {
             return Err(TransactionError::InsufficientPermission.into())
         }
 
@@ -510,12 +510,12 @@ impl<B: Backend + ShardBackend> ShardState<B> for ShardLevelState<B> {
         shard_id: ShardId,
         transaction: &Transaction,
         sender: &Address,
-        shard_owner: &Address,
+        shard_owners: &[Address],
     ) -> StateResult<TransactionInvoice> {
         ctrace!(TX, "Execute {:?}(TxHash:{:?})", transaction, transaction.hash());
 
         self.create_checkpoint(TRANSACTION_CHECKPOINT);
-        let result = self.apply_internal(shard_id, transaction, sender, shard_owner);
+        let result = self.apply_internal(shard_id, transaction, sender, shard_owners);
         match result {
             Ok(_) => {
                 cinfo!(TX, "Tx({}) is applied", transaction.hash());
@@ -573,7 +573,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        let result = state.apply(shard_id, &transaction, &sender, &shard_owner);
+        let result = state.apply(shard_id, &transaction, &sender, &[shard_owner]);
         assert_eq!(Ok(TransactionInvoice::Success), result);
 
         let metadata = state.metadata();
@@ -602,7 +602,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        let result = state.apply(shard_id, &transaction, &sender, &shard_owner);
+        let result = state.apply(shard_id, &transaction, &sender, &[shard_owner]);
         assert_eq!(Ok(TransactionInvoice::Success), result);
 
         let metadata = state.metadata();
@@ -636,7 +636,7 @@ mod tests {
                 expected: 0,
                 found: 1
             }))),
-            state.apply(shard_id, &transaction, &sender, &shard_owner)
+            state.apply(shard_id, &transaction, &sender, &[shard_owner])
         );
 
         let metadata = state.metadata();
@@ -672,7 +672,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        let result = state.apply(shard_id, &transaction, &sender, &shard_owner);
+        let result = state.apply(shard_id, &transaction, &sender, &[shard_owner]);
         assert_eq!(Ok(TransactionInvoice::Success), result);
 
         let transaction_hash = transaction.hash();
@@ -709,7 +709,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        let result = state.apply(shard_id, &transaction, &sender, &shard_owner);
+        let result = state.apply(shard_id, &transaction, &sender, &[shard_owner]);
         assert_eq!(Ok(TransactionInvoice::Success), result);
 
         let transaction_hash = transaction.hash();
@@ -752,7 +752,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &mint, &sender, &shard_owner));
+        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &mint, &sender, &[shard_owner]));
 
         let asset_scheme_address = AssetSchemeAddress::new(mint_hash, shard_id);
         let asset_scheme = state.asset_scheme(&asset_scheme_address);
@@ -802,7 +802,7 @@ mod tests {
         };
         let transfer_hash = transfer.hash();
 
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transfer, &sender, &shard_owner));
+        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transfer, &sender, &[shard_owner]));
 
         let asset0_address = AssetAddress::new(transfer_hash, 0, shard_id);
         let asset0 = state.asset(&asset0_address);
@@ -844,7 +844,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &mint, &sender, &shard_owner));
+        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &mint, &sender, &[shard_owner]));
 
         let asset_scheme_address = AssetSchemeAddress::new(mint_hash, shard_id);
         let asset_scheme = state.asset_scheme(&asset_scheme_address);
@@ -881,7 +881,7 @@ mod tests {
 
         let sender = address();
         let shard_owner = address();
-        let failed_invoice = state.apply(shard_id, &failed_transfer, &sender, &shard_owner).unwrap();
+        let failed_invoice = state.apply(shard_id, &failed_transfer, &sender, &[shard_owner]).unwrap();
         assert_eq!(
             TransactionInvoice::Fail(TransactionError::ScriptHashMismatch(Mismatch {
                 expected: lock_script_hash,
@@ -928,7 +928,10 @@ mod tests {
         };
         let successful_transfer_hash = successful_transfer.hash();
 
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &successful_transfer, &sender, &shard_owner));
+        assert_eq!(
+            Ok(TransactionInvoice::Success),
+            state.apply(shard_id, &successful_transfer, &sender, &[shard_owner])
+        );
 
         let asset0_address = AssetAddress::new(successful_transfer_hash, 0, shard_id);
         let asset0 = state.asset(&asset0_address);
@@ -979,7 +982,7 @@ mod tests {
                 }
             }
         };
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transaction, &shard_owner, &shard_owner));
+        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transaction, &shard_owner, &[shard_owner]));
 
         let world = state.world(world_id);
         assert_eq!(Ok(Some(World::new_with_nonce(new_owners, 1))), world);
@@ -1015,7 +1018,7 @@ mod tests {
         };
 
         let shard_owner = Address::random();
-        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transaction, &sender, &shard_owner));
+        assert_eq!(Ok(TransactionInvoice::Success), state.apply(shard_id, &transaction, &sender, &[shard_owner]));
 
         let world = state.world(world_id);
         assert_eq!(Ok(Some(World::new_with_nonce(owners, 1))), world);
@@ -1061,7 +1064,7 @@ mod tests {
         let shard_owner = address();
         assert_eq!(
             Ok(TransactionInvoice::Fail(TransactionError::InsufficientPermission)),
-            state.apply(shard_id, &transaction, &sender, &shard_owner)
+            state.apply(shard_id, &transaction, &sender, &[shard_owner])
         );
         let world = state.world(world_id);
         assert_eq!(Ok(Some(World::new_with_nonce(owners, 0))), world);