Add SetWorldOwners transaction

Author: Seulgi Kim

core/src/client/client.rs

@@ -285,6 +285,9 @@ impl AssetClient for Client {
                     Some(Transaction::CreateWorld {
                         ..
                     }) => false,
+                    Some(Transaction::SetWorldOwners {
+                        ..
+                    }) => false,
                     Some(Transaction::AssetMint {
                         shard_id: asset_mint_shard_id,
                         ..

core/src/parcel.rs

@@ -156,6 +156,9 @@ impl UnverifiedParcel {
                         Transaction::CreateWorld {
                             ..
                         } => {}
+                        Transaction::SetWorldOwners {
+                            ..
+                        } => {}
                         Transaction::AssetMint {
                             metadata,
                             ..

state/src/impls/shard_level.rs

@@ -107,8 +107,8 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
         &mut self,
         shard_id: ShardId,
         transaction: &Transaction,
-        _sender: &Address,
-        _shard_owner: &Address,
+        sender: &Address,
+        shard_owner: &Address,
     ) -> StateResult<()> {
         debug_assert_eq!(Ok(()), transaction.verify());
         match transaction {
@@ -117,6 +117,13 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
                 owners,
                 ..
             } => Ok(self.create_world(shard_id, nonce, owners)?),
+            Transaction::SetWorldOwners {
+                shard_id,
+                world_id,
+                nonce,
+                owners,
+                ..
+            } => Ok(self.set_world_owners(*shard_id, *world_id, *nonce, &owners, sender, shard_owner)?),
             Transaction::AssetMint {
                 metadata,
                 registrar,
@@ -159,6 +166,35 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
         Ok(())
     }
 
+    fn set_world_owners(
+        &mut self,
+        shard_id: ShardId,
+        world_id: WorldId,
+        nonce: u64,
+        owners: &[Address],
+        sender: &Address,
+        shard_owner: &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) {
+            return Err(TransactionError::InsufficientPermission.into())
+        }
+
+        let current_nonce = world.nonce();
+        if current_nonce != &nonce {
+            return Err(TransactionError::InvalidWorldNonce(Mismatch {
+                expected: *current_nonce,
+                found: nonce,
+            }).into())
+        }
+
+        let mut world = self.require_world(&WorldAddress::new(shard_id, world_id), || unreachable!())?;
+        world.inc_nonce();
+        world.set_owners(owners.to_vec());
+        Ok(())
+    }
+
     fn mint_asset(
         &mut self,
         transaction_hash: H256,
@@ -906,4 +942,128 @@ mod tests {
         let asset2 = state.asset(&asset2_address);
         assert_eq!(Ok(Some(Asset::new(asset_type, random_lock_script_hash, vec![], 15))), asset2);
     }
+
+    #[test]
+    fn shard_owner_can_set_world_owners() {
+        let network_id = 0xDEADBEEF;
+        let shard_id = 0xCAFE;
+        let mut state = get_temp_shard_state(shard_id);
+
+        let owners = vec![Address::random(), Address::random()];
+        assert_eq!(Ok(()), state.create_world(shard_id, &0, &owners));
+        assert_eq!(Ok(()), state.commit());
+
+        let metadata = state.metadata();
+        assert_eq!(Ok(Some(ShardMetadata::new_with_nonce(1, 1))), metadata);
+
+        let world_id = 0;
+        let world = state.world(world_id);
+        assert_eq!(Ok(Some(World::new(owners))), world);
+
+        let nonce = 0;
+
+        let new_owners = vec![Address::random(), Address::random(), Address::random()];
+        let transaction = Transaction::SetWorldOwners {
+            network_id,
+            shard_id,
+            world_id,
+            nonce,
+            owners: new_owners.clone(),
+        };
+
+        let shard_owner = {
+            loop {
+                let owner = address();
+                if !new_owners.contains(&owner) {
+                    break 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);
+    }
+
+    #[test]
+    fn world_owner_can_set_world_owners() {
+        let network_id = 0xDEADBEEF;
+        let shard_id = 0xCAFE;
+        let mut state = get_temp_shard_state(shard_id);
+
+        let sender = Address::random();
+        let old_owners = vec![sender, Address::random()];
+        assert_eq!(Ok(()), state.create_world(shard_id, &0, &old_owners));
+        assert_eq!(Ok(()), state.commit());
+
+        let metadata = state.metadata();
+        assert_eq!(Ok(Some(ShardMetadata::new_with_nonce(1, 1))), metadata);
+
+        let world_id = 0;
+        let world = state.world(world_id);
+        assert_eq!(Ok(Some(World::new(old_owners.clone()))), world);
+
+        let nonce = 0;
+
+        let owners = vec![Address::random(), Address::random(), Address::random()];
+        let transaction = Transaction::SetWorldOwners {
+            network_id,
+            shard_id,
+            world_id,
+            nonce,
+            owners: owners.clone(),
+        };
+
+        let shard_owner = Address::random();
+        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);
+    }
+
+
+    #[test]
+    fn insufficient_permission_must_fail_to_set_world_owners() {
+        let network_id = 0xDEADBEEF;
+        let shard_id = 0xCAFE;
+        let mut state = get_temp_shard_state(shard_id);
+
+        let owners = vec![Address::random(), Address::random()];
+        assert_eq!(Ok(()), state.create_world(shard_id, &0, &owners));
+        assert_eq!(Ok(()), state.commit());
+
+        let metadata = state.metadata();
+        assert_eq!(Ok(Some(ShardMetadata::new_with_nonce(1, 1))), metadata);
+
+        let world_id = 0;
+        let world = state.world(world_id);
+        assert_eq!(Ok(Some(World::new(owners.clone()))), world);
+
+        let nonce = 0;
+
+        let new_owners = vec![Address::random(), Address::random(), Address::random()];
+        let transaction = Transaction::SetWorldOwners {
+            network_id,
+            shard_id,
+            world_id,
+            nonce,
+            owners: new_owners.clone(),
+        };
+
+        let sender = {
+            loop {
+                let owner = address();
+                if !new_owners.contains(&owner) {
+                    break owner
+                }
+            }
+        };
+        let shard_owner = address();
+        assert_eq!(
+            Ok(TransactionInvoice::Fail(TransactionError::InsufficientPermission)),
+            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);
+    }
 }

state/src/impls/top_level.rs

@@ -2085,4 +2085,144 @@ mod tests_parcel {
         let res = state.apply(&parcel, &sender, &sender_public);
         assert_eq!(Err(StateError::Parcel(ParcelError::InvalidShardId(100))), res);
     }
+
+    #[test]
+    fn create_world_and_set_owners_in_the_same_parcel() {
+        let (sender, sender_public) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&sender));
+        assert_eq!(Ok(()), state.commit());
+
+        let shard_id = 0x00;
+        let network_id = 0xBeef;
+        let world_id = 0;
+
+        let owners = vec![Address::random(), Address::random()];
+
+        let t0 = Transaction::CreateWorld {
+            network_id,
+            shard_id,
+            nonce: 0,
+            owners: vec![Address::random()],
+        };
+        let t1 = Transaction::SetWorldOwners {
+            network_id,
+            shard_id,
+            world_id,
+            nonce: 0,
+            owners: owners.clone(),
+        };
+
+        let transactions = vec![t0, t1];
+        let parcel = Parcel {
+            fee: 20.into(),
+            nonce: 0.into(),
+            network_id,
+            action: Action::ChangeShardState {
+                transactions,
+                changes: vec![ChangeShard {
+                    shard_id,
+                    pre_root: H256::from("0xa8ed01b49cd63c6a547ac3ce357539aa634fb44331a351e3e98b9f1c3a8e3edf"),
+                    post_root: H256::zero(),
+                }],
+                signatures: vec![],
+            },
+        };
+
+        assert_eq!(Ok(()), state.add_balance(&sender, &120.into()));
+        assert_eq!(Ok(120.into()), state.balance(&sender));
+
+        assert_eq!(
+            Ok(ParcelInvoice::Multiple(vec![TransactionInvoice::Success, TransactionInvoice::Success])),
+            state.apply(&parcel, &sender, &sender_public)
+        );
+
+        assert_eq!(Ok(100.into()), state.balance(&sender));
+        assert_eq!(Ok(1.into()), state.nonce(&sender));
+
+        assert_eq!(Ok(Some(World::new_with_nonce(owners, 1))), state.world(shard_id, world_id));
+    }
+
+    #[test]
+    fn create_world_and_set_owners_in_different_parcel() {
+        let (sender, sender_public) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&sender));
+        assert_eq!(Ok(()), state.commit());
+
+        let shard_id = 0x00;
+        let network_id = 0xBeef;
+        let world_id = 0;
+
+        assert_eq!(Ok(()), state.add_balance(&sender, &120.into()));
+        assert_eq!(Ok(120.into()), state.balance(&sender));
+
+        let old_owners = vec![Address::random(), Address::random(), Address::random()];
+        let new_owners = vec![Address::random(), Address::random()];
+
+        let t0 = Transaction::CreateWorld {
+            network_id,
+            shard_id,
+            nonce: 0,
+            owners: old_owners.clone(),
+        };
+
+        let parcel0 = Parcel {
+            fee: 20.into(),
+            nonce: 0.into(),
+            network_id,
+            action: Action::ChangeShardState {
+                transactions: vec![t0],
+                changes: vec![ChangeShard {
+                    shard_id,
+                    pre_root: H256::from("0xa8ed01b49cd63c6a547ac3ce357539aa634fb44331a351e3e98b9f1c3a8e3edf"),
+                    post_root: H256::zero(),
+                }],
+                signatures: vec![],
+            },
+        };
+
+        assert_eq!(
+            Ok(ParcelInvoice::Multiple(vec![TransactionInvoice::Success])),
+            state.apply(&parcel0, &sender, &sender_public)
+        );
+
+        assert_eq!(Ok(100.into()), state.balance(&sender));
+        assert_eq!(Ok(1.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(World::new_with_nonce(old_owners, 0))), state.world(shard_id, world_id));
+
+        let t1 = Transaction::SetWorldOwners {
+            network_id,
+            shard_id,
+            world_id,
+            nonce: 0,
+            owners: new_owners.clone(),
+        };
+
+        let parcel1 = Parcel {
+            fee: 30.into(),
+            nonce: 1.into(),
+            network_id,
+            action: Action::ChangeShardState {
+                transactions: vec![t1],
+                changes: vec![ChangeShard {
+                    shard_id,
+                    pre_root: H256::zero(),
+                    post_root: H256::zero(),
+                }],
+                signatures: vec![],
+            },
+        };
+
+        assert_eq!(
+            Ok(ParcelInvoice::Multiple(vec![TransactionInvoice::Success])),
+            state.apply(&parcel1, &sender, &sender_public)
+        );
+
+        assert_eq!(Ok(70.into()), state.balance(&sender));
+        assert_eq!(Ok(2.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(World::new_with_nonce(new_owners, 1))), state.world(shard_id, world_id));
+    }
 }

state/src/item/world.rs

@@ -49,6 +49,16 @@ impl World {
     pub fn nonce(&self) -> &u64 {
         &self.nonce
     }
+
+    pub fn inc_nonce(&mut self) {
+        debug_assert_ne!(::std::u64::MAX, self.nonce);
+        self.nonce += 1;
+    }
+
+    pub fn set_owners(&mut self, owners: Vec<Address>) {
+        debug_assert_ne!(Vec::<Address>::new(), owners);
+        self.world_owners = owners;
+    }
 }
 
 impl CacheableItem for World {