Implement revoke

Author: foriequal0

core/src/consensus/stake/actions.rs

@@ -20,6 +20,7 @@ use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
 const ACTION_TAG_TRANSFER_CCS: u8 = 1;
 const ACTION_TAG_DELEGATE_CCS: u8 = 2;
+const ACTION_TAG_REVOKE: u8 = 3;
 const ACTION_TAG_CHANGE_PARAMS: u8 = 0xFF;
 
 #[derive(Debug, PartialEq)]
@@ -32,6 +33,10 @@ pub enum Action {
         address: Address,
         quantity: u64,
     },
+    Revoke {
+        address: Address,
+        quantity: u64,
+    },
     ChangeParams {
         metadata_seq: u64,
         params: Box<CommonParams>,
@@ -54,6 +59,12 @@ impl Encodable for Action {
             } => {
                 s.begin_list(3).append(&ACTION_TAG_DELEGATE_CCS).append(address).append(quantity);
             }
+            Action::Revoke {
+                address,
+                quantity,
+            } => {
+                s.begin_list(3).append(&ACTION_TAG_REVOKE).append(address).append(quantity);
+            }
             Action::ChangeParams {
                 metadata_seq,
                 params,
@@ -101,6 +112,19 @@ impl Decodable for Action {
                     quantity: rlp.val_at(2)?,
                 })
             }
+            ACTION_TAG_REVOKE => {
+                let item_count = rlp.item_count()?;
+                if item_count != 3 {
+                    return Err(DecoderError::RlpInvalidLength {
+                        expected: 3,
+                        got: item_count,
+                    })
+                }
+                Ok(Action::Revoke {
+                    address: rlp.val_at(1)?,
+                    quantity: rlp.val_at(2)?,
+                })
+            }
             ACTION_TAG_CHANGE_PARAMS => {
                 let item_count = rlp.item_count()?;
                 if item_count < 4 {

core/src/consensus/stake/mod.rs

@@ -115,6 +115,16 @@ impl ActionHandler for Stake {
                     Err(RuntimeError::FailedToHandleCustomAction("DelegateCCS is disabled".to_string()).into())
                 }
             }
+            Action::Revoke {
+                address,
+                quantity,
+            } => {
+                if self.enable_delegations {
+                    revoke(state, sender, &address, quantity)
+                } else {
+                    Err(RuntimeError::FailedToHandleCustomAction("DelegateCCS is disabled".to_string()).into())
+                }
+            }
             Action::ChangeParams {
                 metadata_seq,
                 params,
@@ -133,6 +143,9 @@ impl ActionHandler for Stake {
             Action::DelegateCCS {
                 ..
             } => Ok(()),
+            Action::Revoke {
+                ..
+            } => Ok(()),
             Action::ChangeParams {
                 metadata_seq,
                 params,
@@ -208,6 +221,19 @@ fn delegate_ccs(
     Ok(())
 }
 
+fn revoke(state: &mut TopLevelState, sender: &Address, delegatee: &Address, quantity: u64) -> StateResult<()> {
+    let mut delegator = StakeAccount::load_from_state(state, sender)?;
+    let mut delegation = Delegation::load_from_state(state, &sender)?;
+
+    delegator.add_balance(quantity)?;
+    delegation.subtract_quantity(*delegatee, quantity)?;
+    // delegation does not touch stakeholders
+
+    delegation.save_to_state(state)?;
+    delegator.save_to_state(state)?;
+    Ok(())
+}
+
 pub fn get_stakes(state: &TopLevelState) -> StateResult<HashMap<Address, u64>> {
     let stakeholders = Stakeholders::load_from_state(state)?;
     let mut result = HashMap::new();
@@ -279,6 +305,7 @@ mod tests {
     use super::*;
 
     use ckey::{public_to_address, Public};
+    use consensus::stake::action_data::get_delegation_key;
     use consensus::validator_set::new_validator_set;
     use cstate::tests::helpers;
     use cstate::TopStateView;
@@ -552,4 +579,110 @@ mod tests {
         let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn can_revoke_delegated_tokens() {
+        let delegatee_public = Public::random();
+        let delegatee = public_to_address(&delegatee_public);
+        let delegator = Address::random();
+
+        let mut state = helpers::get_temp_state();
+        let stake = {
+            let mut genesis_stakes = HashMap::new();
+            genesis_stakes.insert(delegatee, 100);
+            genesis_stakes.insert(delegator, 100);
+            Stake::new(genesis_stakes, new_validator_set(vec![delegatee_public]))
+        };
+        stake.init(&mut state).unwrap();
+
+        let action = Action::DelegateCCS {
+            address: delegatee,
+            quantity: 50,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert!(result.is_ok());
+
+        let action = Action::Revoke {
+            address: delegatee,
+            quantity: 20,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert_eq!(Ok(()), result);
+
+        let delegator_account = StakeAccount::load_from_state(&state, &delegator).unwrap();
+        let delegation = Delegation::load_from_state(&state, &delegator).unwrap();
+        assert_eq!(delegator_account.balance, 100 - 50 + 20);
+        assert_eq!(delegation.iter().count(), 1);
+        assert_eq!(delegation.get_quantity(&delegatee), 50 - 20);
+    }
+
+    #[test]
+    fn cannot_revoke_more_than_delegated_tokens() {
+        let delegatee_public = Public::random();
+        let delegatee = public_to_address(&delegatee_public);
+        let delegator = Address::random();
+
+        let mut state = helpers::get_temp_state();
+        let stake = {
+            let mut genesis_stakes = HashMap::new();
+            genesis_stakes.insert(delegatee, 100);
+            genesis_stakes.insert(delegator, 100);
+            Stake::new(genesis_stakes, new_validator_set(vec![delegatee_public]))
+        };
+        stake.init(&mut state).unwrap();
+
+        let action = Action::DelegateCCS {
+            address: delegatee,
+            quantity: 50,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert!(result.is_ok());
+
+        let action = Action::Revoke {
+            address: delegatee,
+            quantity: 70,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert!(result.is_err());
+
+        let delegator_account = StakeAccount::load_from_state(&state, &delegator).unwrap();
+        let delegation = Delegation::load_from_state(&state, &delegator).unwrap();
+        assert_eq!(delegator_account.balance, 100 - 50);
+        assert_eq!(delegation.iter().count(), 1);
+        assert_eq!(delegation.get_quantity(&delegatee), 50);
+    }
+
+    #[test]
+    fn revoke_all_should_clear_state() {
+        let delegatee_public = Public::random();
+        let delegatee = public_to_address(&delegatee_public);
+        let delegator = Address::random();
+
+        let mut state = helpers::get_temp_state();
+        let stake = {
+            let mut genesis_stakes = HashMap::new();
+            genesis_stakes.insert(delegatee, 100);
+            genesis_stakes.insert(delegator, 100);
+            Stake::new(genesis_stakes, new_validator_set(vec![delegatee_public]))
+        };
+        stake.init(&mut state).unwrap();
+
+        let action = Action::DelegateCCS {
+            address: delegatee,
+            quantity: 50,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert!(result.is_ok());
+
+        let action = Action::Revoke {
+            address: delegatee,
+            quantity: 50,
+        };
+        let result = stake.execute(&action.rlp_bytes(), &mut state, &delegator);
+        assert_eq!(Ok(()), result);
+
+        let delegator_account = StakeAccount::load_from_state(&state, &delegator).unwrap();
+        assert_eq!(delegator_account.balance, 100);
+        assert_eq!(state.action_data(&get_delegation_key(&delegator)).unwrap(), None);
+    }
 }