Add ChangeShardOwners parcel

Author: Seulgi Kim

state/src/impls/top_level.rs

@@ -452,6 +452,13 @@ impl TopLevelState {
                 self.create_shard(&shard_creation_cost, fee_payer)?;
                 Ok(ParcelInvoice::SingleSuccess)
             }
+            Action::ChangeShardOwners {
+                shard_id,
+                owners,
+            } => {
+                self.change_shard_owners(*shard_id, owners, fee_payer)?;
+                Ok(ParcelInvoice::SingleSuccess)
+            }
             Action::Custom(bytes) => {
                 let handlers = self.db.custom_handlers().to_vec();
                 for h in handlers {
@@ -790,6 +797,18 @@ impl TopState<StateDB> for TopLevelState {
         Ok(())
     }
 
+    fn change_shard_owners(&mut self, shard_id: ShardId, owners: &[Address], sender: &Address) -> StateResult<()> {
+        let old_owners = self.shard_owners(shard_id)?.ok_or_else(|| ParcelError::InvalidShardId(shard_id))?;
+        if !old_owners.contains(sender) {
+            return Err(ParcelError::InsufficientPermission.into())
+        }
+        if !owners.contains(sender) {
+            return Err(ParcelError::NewOwnersMustContainSender.into())
+        }
+
+        self.set_shard_owners(shard_id, owners.to_vec())
+    }
+
     fn set_shard_root(&mut self, shard_id: ShardId, old_root: &H256, new_root: &H256) -> StateResult<()> {
         let mut shard = self.require_shard(shard_id)?;
         assert_eq!(old_root, shard.root());
@@ -2224,4 +2243,166 @@ mod tests_parcel {
         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));
     }
+
+    #[test]
+    fn change_shard_owners() {
+        let (sender, sender_public) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&sender));
+        assert_eq!(Ok(()), state.add_balance(&sender, &U256::from(69u64)));
+        assert_eq!(Ok(()), state.commit());
+
+        let network_id = 0xCA;
+        let shard_id = 0;
+        let owners = vec![Address::random(), Address::random(), sender];
+
+        let parcel = Parcel {
+            fee: 5.into(),
+            action: Action::ChangeShardOwners {
+                shard_id,
+                owners: owners.clone(),
+            },
+            nonce: 0.into(),
+            network_id,
+        };
+
+        assert_eq!(Ok(Some(vec![sender])), state.shard_owners(shard_id));
+
+        assert_eq!(Ok(ParcelInvoice::SingleSuccess), state.apply(&parcel, &sender, &sender_public));
+
+        assert_eq!(Ok(64.into()), state.balance(&sender));
+        assert_eq!(Ok(1.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(owners)), state.shard_owners(shard_id));
+    }
+
+    #[test]
+    fn new_owners_must_contain_sender() {
+        let (sender, sender_public) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&sender));
+        assert_eq!(Ok(()), state.add_balance(&sender, &U256::from(69u64)));
+        assert_eq!(Ok(()), state.commit());
+
+        let network_id = 0xCA;
+        let shard_id = 0;
+        let owners = {
+            let a1 = loop {
+                let a = Address::random();
+                if a != sender {
+                    break a
+                }
+            };
+            let a2 = loop {
+                let a = Address::random();
+                if a != sender {
+                    break a
+                }
+            };
+            vec![a1, a2]
+        };
+
+        let parcel = Parcel {
+            fee: 5.into(),
+            action: Action::ChangeShardOwners {
+                shard_id,
+                owners,
+            },
+            nonce: 0.into(),
+            network_id,
+        };
+
+        assert_eq!(Ok(Some(vec![sender])), state.shard_owners(shard_id));
+
+        assert_eq!(Err(ParcelError::NewOwnersMustContainSender.into()), state.apply(&parcel, &sender, &sender_public));
+
+        assert_eq!(Ok(69.into()), state.balance(&sender));
+        assert_eq!(Ok(0.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(vec![sender])), state.shard_owners(shard_id));
+    }
+
+    #[test]
+    fn only_owner_can_change_owners() {
+        let (original_owner, _) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&original_owner));
+        let (sender, sender_public) = address();
+        assert_eq!(Ok(()), state.add_balance(&sender, &U256::from(69u64)));
+        assert_eq!(Ok(()), state.commit());
+
+        let network_id = 0xCA;
+        let shard_id = 0;
+
+        let owners = {
+            let a1 = loop {
+                let a = Address::random();
+                if a != original_owner {
+                    break a
+                }
+            };
+            let a2 = loop {
+                let a = Address::random();
+                if a != original_owner {
+                    break a
+                }
+            };
+            vec![a1, a2, sender]
+        };
+
+        let parcel = Parcel {
+            fee: 5.into(),
+            action: Action::ChangeShardOwners {
+                shard_id,
+                owners,
+            },
+            nonce: 0.into(),
+            network_id,
+        };
+
+        assert_eq!(Ok(Some(vec![original_owner])), state.shard_owners(shard_id));
+
+        assert_eq!(Err(ParcelError::InsufficientPermission.into()), state.apply(&parcel, &sender, &sender_public));
+
+        assert_eq!(Ok(69.into()), state.balance(&sender));
+        assert_eq!(Ok(0.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(vec![original_owner])), state.shard_owners(shard_id));
+    }
+
+    #[test]
+    fn change_shard_owners_fail_on_invalid_shard_id() {
+        let (sender, sender_public) = address();
+
+        let mut state = get_temp_state();
+        assert_eq!(Ok(()), state.create_shard_level_state(&sender));
+        assert_eq!(Ok(()), state.add_balance(&sender, &U256::from(69u64)));
+        assert_eq!(Ok(()), state.commit());
+
+        let network_id = 0xCA;
+        let real_shard_id = 0;
+        let shard_id = 0xF;
+
+        let owners = vec![Address::random(), Address::random(), sender];
+
+        let parcel = Parcel {
+            fee: 5.into(),
+            action: Action::ChangeShardOwners {
+                shard_id,
+                owners: owners.clone(),
+            },
+            nonce: 0.into(),
+            network_id,
+        };
+
+        assert_eq!(Ok(Some(vec![sender])), state.shard_owners(real_shard_id));
+        assert_eq!(Ok(None), state.shard_owners(shard_id));
+
+        assert_eq!(Err(ParcelError::InvalidShardId(shard_id).into()), state.apply(&parcel, &sender, &sender_public));
+
+        assert_eq!(Ok(69.into()), state.balance(&sender));
+        assert_eq!(Ok(0.into()), state.nonce(&sender));
+        assert_eq!(Ok(Some(vec![sender])), state.shard_owners(real_shard_id));
+        assert_eq!(Ok(None), state.shard_owners(shard_id));
+    }
 }

state/src/traits.rs

@@ -104,6 +104,7 @@ where
     fn set_regular_key(&mut self, master_public: &Public, key: &Public) -> StateResult<()>;
 
     fn create_shard(&mut self, shard_creation_cost: &U256, fee_payer: &Address) -> StateResult<()>;
+    fn change_shard_owners(&mut self, shard_id: ShardId, owners: &[Address], sender: &Address) -> StateResult<()>;
 
     fn set_shard_root(&mut self, shard_id: ShardId, old_root: &H256, new_root: &H256) -> StateResult<()>;
     fn set_shard_owners(&mut self, shard_id: ShardId, new_owners: Vec<Address>) -> StateResult<()>;

types/src/parcel/action.rs

@@ -26,6 +26,7 @@ const CHANGE_SHARD_STATE: u8 = 1;
 const PAYMENT: u8 = 2;
 const SET_REGULAR_KEY: u8 = 3;
 const CREATE_SHARD: u8 = 4;
+const CHANGE_SHARD_OWNERS: u8 = 5;
 const CUSTOM: u8 = 0xFF;
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, RlpDecodable, RlpEncodable)]
@@ -54,6 +55,10 @@ pub enum Action {
         key: Public,
     },
     CreateShard,
+    ChangeShardOwners {
+        shard_id: ShardId,
+        owners: Vec<Address>,
+    },
     Custom(Bytes),
 }
 
@@ -98,6 +103,15 @@ impl Encodable for Action {
                 s.begin_list(1);
                 s.append(&CREATE_SHARD);
             }
+            Action::ChangeShardOwners {
+                shard_id,
+                owners,
+            } => {
+                s.begin_list(3);
+                s.append(&CHANGE_SHARD_OWNERS);
+                s.append(shard_id);
+                s.append_list(owners);
+            }
             Action::Custom(bytes) => {
                 s.begin_list(2);
                 s.append(&CUSTOM);
@@ -143,6 +157,15 @@ impl Decodable for Action {
                 }
                 Ok(Action::CreateShard)
             }
+            CHANGE_SHARD_OWNERS => {
+                if rlp.item_count()? != 3 {
+                    return Err(DecoderError::RlpIncorrectListLen)
+                }
+                Ok(Action::ChangeShardOwners {
+                    shard_id: rlp.val_at(1)?,
+                    owners: rlp.list_at(2)?,
+                })
+            }
             CUSTOM => {
                 if rlp.item_count()? != 2 {
                     return Err(DecoderError::RlpIncorrectListLen)
@@ -153,3 +176,16 @@ impl Decodable for Action {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn encode_and_decode_change_shard_owners() {
+        rlp_encode_and_decode_test!(Action::ChangeShardOwners {
+            shard_id: 1,
+            owners: vec![Address::random(), Address::random()],
+        });
+    }
+}

types/src/parcel/error.rs

@@ -77,6 +77,8 @@ pub enum Error {
     InvalidTransferDestination,
     /// Transaction error
     InvalidTransaction(TransactionError),
+    InsufficientPermission,
+    NewOwnersMustContainSender,
 }
 
 const ERROR_ID_PARCEL_ALREADY_IMPORTED: u8 = 1u8;
@@ -99,6 +101,8 @@ const ERROR_ID_REGULAR_KEY_ALREADY_IN_USE: u8 = 17u8;
 const ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_MASTER: u8 = 18u8;
 const ERROR_ID_INVALID_TRANSFER_DESTINATION: u8 = 19u8;
 const ERROR_ID_INVALID_TRANSACTION: u8 = 20u8;
+const ERROR_ID_INSUFFICIENT_PERMISSION: u8 = 21u8;
+const ERROR_ID_NEW_OWNERS_MUST_CONTAIN_SENDER: u8 = 22u8;
 
 impl Encodable for Error {
     fn rlp_append(&self, s: &mut RlpStream) {
@@ -135,6 +139,8 @@ impl Encodable for Error {
             }
             Error::InvalidTransferDestination => s.begin_list(1).append(&ERROR_ID_INVALID_TRANSFER_DESTINATION),
             Error::InvalidTransaction(err) => s.begin_list(2).append(&ERROR_ID_INVALID_TRANSACTION).append(err),
+            Error::InsufficientPermission => s.begin_list(1).append(&ERROR_ID_INSUFFICIENT_PERMISSION),
+            Error::NewOwnersMustContainSender => s.begin_list(1).append(&ERROR_ID_NEW_OWNERS_MUST_CONTAIN_SENDER),
         };
     }
 }
@@ -173,6 +179,8 @@ impl Decodable for Error {
             ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_MASTER => Error::RegularKeyAlreadyInUseAsMaster,
             ERROR_ID_INVALID_TRANSFER_DESTINATION => Error::InvalidTransferDestination,
             ERROR_ID_INVALID_TRANSACTION => Error::InvalidTransaction(rlp.val_at(1)?),
+            ERROR_ID_INSUFFICIENT_PERMISSION => Error::InsufficientPermission,
+            ERROR_ID_NEW_OWNERS_MUST_CONTAIN_SENDER => Error::NewOwnersMustContainSender,
             _ => return Err(DecoderError::Custom("Invalid parcel error")),
         })
     }
@@ -211,6 +219,8 @@ impl Display for Error {
             Error::RegularKeyAlreadyInUseAsMaster => "The regular key is already used as a master account".to_string(),
             Error::InvalidTransferDestination => "Transfer receiver is not valid account".to_string(),
             Error::InvalidTransaction(err) => format!("Parcel has an invalid transaction: {}", err).to_string(),
+            Error::InsufficientPermission => "Sender doesn't have a permission".to_string(),
+            Error::NewOwnersMustContainSender => "New owners must contain the sender".to_string(),
         };
 
         f.write_fmt(format_args!("Parcel error ({})", msg))