Remove all "master" from CodeChain

We use "owner" instead of "master"

Author: majecty

state/src/impls/top_level.rs

@@ -355,7 +355,7 @@ impl TopLevelState {
         fee_payer: &Address,
         fee_payer_public: &Public,
     ) -> StateResult<ParcelInvoice> {
-        // Change the address to a master address if it is a regular key.
+        // Change the address to an owner address if it is a regular key.
         let fee_payer = if self.regular_account_exists_and_not_null(fee_payer)? {
             let regular_account = self.require_regular_account_from_address(fee_payer)?;
             public_to_address(&regular_account.owner_public())
@@ -764,16 +764,16 @@ impl TopState<StateDB> for TopLevelState {
         Ok(())
     }
 
-    fn set_regular_key(&mut self, master_public: &Public, regular_key: &Public) -> StateResult<()> {
-        let master_address = public_to_address(master_public);
+    fn set_regular_key(&mut self, owner_public: &Public, regular_key: &Public) -> StateResult<()> {
+        let owner_address = public_to_address(owner_public);
 
-        let (master_public, master_address) = if self.regular_account_exists_and_not_null(&master_address)? {
-            let regular_account = self.require_regular_account_from_address(&master_address)?;
-            let master_public = regular_account.owner_public().clone();
-            let master_address = public_to_address(&master_public);
-            (master_public, master_address)
+        let (owner_public, owner_address) = if self.regular_account_exists_and_not_null(&owner_address)? {
+            let regular_account = self.require_regular_account_from_address(&owner_address)?;
+            let owner_public = regular_account.owner_public().clone();
+            let owner_address = public_to_address(&owner_public);
+            (owner_public, owner_address)
         } else {
-            (*master_public, public_to_address(&master_public))
+            (*owner_public, public_to_address(&owner_public))
         };
 
         let regular_address = public_to_address(regular_key);
@@ -782,18 +782,18 @@ impl TopState<StateDB> for TopLevelState {
         }
 
         if self.account_exists_and_not_null(&regular_address)? {
-            return Err(ParcelError::RegularKeyAlreadyInUseAsMaster.into())
+            return Err(ParcelError::RegularKeyAlreadyInUseAsPlatformAccount.into())
         }
 
-        let prev_regular_key = self.require_account(&master_address)?.regular_key();
+        let prev_regular_key = self.require_account(&owner_address)?.regular_key();
 
         if let Some(prev_regular_key) = prev_regular_key {
             self.kill_regular_account(&prev_regular_key);
         }
 
-        let mut master_account = self.require_account(&master_address)?;
-        master_account.set_regular_key(regular_key);
-        self.require_regular_account(&regular_key)?.set_owner_public(&master_public);
+        let mut owner_account = self.require_account(&owner_address)?;
+        owner_account.set_regular_key(regular_key);
+        self.require_regular_account(&regular_key)?.set_owner_public(&owner_public);
         Ok(())
     }
 
@@ -1346,7 +1346,7 @@ mod tests_parcel {
     }
 
     #[test]
-    fn use_master_balance_when_signed_with_regular_key() {
+    fn use_owner_balance_when_signed_with_regular_key() {
         let mut state = get_temp_state();
         let regular_keypair = Random.generate().unwrap();
         let key = regular_keypair.public();
@@ -1419,7 +1419,7 @@ mod tests_parcel {
     }
 
     #[test]
-    fn fail_when_regular_key_is_already_registered_as_master_key() {
+    fn fail_when_regular_key_is_already_registered_as_owner_key() {
         let (sender, sender_public) = address();
         let (sender2, sender_public2) = address();
 
@@ -1438,7 +1438,7 @@ mod tests_parcel {
         };
 
         let result = state.apply(&parcel, &sender, &sender_public);
-        assert_eq!(Err(StateError::Parcel(ParcelError::RegularKeyAlreadyInUseAsMaster)), result);
+        assert_eq!(Err(StateError::Parcel(ParcelError::RegularKeyAlreadyInUseAsPlatformAccount)), result);
     }
 
     #[test]
@@ -1558,7 +1558,7 @@ mod tests_parcel {
     }
 
     #[test]
-    fn use_deleted_regular_key_as_master_key() {
+    fn use_deleted_regular_key_as_owner_key() {
         let (sender, sender_public) = address();
         let (regular_address, regular_public) = address();
         let (_, regular_public2) = address();

state/src/item/regular_account.rs

@@ -36,8 +36,8 @@ impl RegularAccount {
         &self.owner_public
     }
 
-    pub fn set_owner_public(&mut self, master_public: &Public) {
-        self.owner_public = *master_public;
+    pub fn set_owner_public(&mut self, owner_public: &Public) {
+        self.owner_public = *owner_public;
     }
 }
 

state/src/traits.rs

@@ -102,8 +102,8 @@ where
     /// Increment the nonce of account `a` by 1.
     fn inc_nonce(&mut self, a: &Address) -> TrieResult<()>;
 
-    /// Set the regular key of account `master_public`
-    fn set_regular_key(&mut self, master_public: &Public, key: &Public) -> StateResult<()>;
+    /// Set the regular key of account `owner_public`
+    fn set_regular_key(&mut self, owner_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<()>;

types/src/parcel/error.rs

@@ -72,7 +72,7 @@ pub enum Error {
     InconsistentShardOutcomes,
     ParcelsTooBig,
     RegularKeyAlreadyInUse,
-    RegularKeyAlreadyInUseAsMaster,
+    RegularKeyAlreadyInUseAsPlatformAccount,
     InvalidTransferDestination,
     /// Transaction error
     InvalidTransaction(TransactionError),
@@ -96,7 +96,7 @@ const ERROR_ID_INVALID_SIGNATURE: u8 = 14u8;
 const ERROR_ID_INCONSISTENT_SHARD_OUTCOMES: u8 = 15u8;
 const ERROR_ID_PARCELS_TOO_BIG: u8 = 16u8;
 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_REGULAR_KEY_ALREADY_IN_USE_AS_PLATFORM: u8 = 18u8;
 const ERROR_ID_INVALID_TRANSFER_DESTINATION: u8 = 19u8;
 const ERROR_ID_INVALID_TRANSACTION: u8 = 20u8;
 const ERROR_ID_INSUFFICIENT_PERMISSION: u8 = 21u8;
@@ -133,8 +133,8 @@ impl Encodable for Error {
             Error::InconsistentShardOutcomes => s.begin_list(1).append(&ERROR_ID_INCONSISTENT_SHARD_OUTCOMES),
             Error::ParcelsTooBig => s.begin_list(1).append(&ERROR_ID_PARCELS_TOO_BIG),
             Error::RegularKeyAlreadyInUse => s.begin_list(1).append(&ERROR_ID_REGULAR_KEY_ALREADY_IN_USE),
-            Error::RegularKeyAlreadyInUseAsMaster => {
-                s.begin_list(1).append(&ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_MASTER)
+            Error::RegularKeyAlreadyInUseAsPlatformAccount => {
+                s.begin_list(1).append(&ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_PLATFORM)
             }
             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),
@@ -174,7 +174,7 @@ impl Decodable for Error {
             ERROR_ID_INCONSISTENT_SHARD_OUTCOMES => Error::InconsistentShardOutcomes,
             ERROR_ID_PARCELS_TOO_BIG => Error::ParcelsTooBig,
             ERROR_ID_REGULAR_KEY_ALREADY_IN_USE => Error::RegularKeyAlreadyInUse,
-            ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_MASTER => Error::RegularKeyAlreadyInUseAsMaster,
+            ERROR_ID_REGULAR_KEY_ALREADY_IN_USE_AS_PLATFORM => Error::RegularKeyAlreadyInUseAsPlatformAccount,
             ERROR_ID_INVALID_TRANSFER_DESTINATION => Error::InvalidTransferDestination,
             ERROR_ID_INVALID_TRANSACTION => Error::InvalidTransaction(rlp.val_at(1)?),
             ERROR_ID_INSUFFICIENT_PERMISSION => Error::InsufficientPermission,
@@ -213,7 +213,9 @@ impl Display for Error {
             Error::InconsistentShardOutcomes => "Shard outcomes are inconsistent".to_string(),
             Error::ParcelsTooBig => "Parcel size exceeded the body size limit".to_string(),
             Error::RegularKeyAlreadyInUse => "The regular key is already registered to another account".to_string(),
-            Error::RegularKeyAlreadyInUseAsMaster => "The regular key is already used as a master account".to_string(),
+            Error::RegularKeyAlreadyInUseAsPlatformAccount => {
+                "The regular key is already used as a platform 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(),