Implement evictions (#196)

* Eviction support in Core
* Update inherents to use evictions
* Complete PoE piece (but not tests yet)

Author: JoshOrndorff

tuxedo-core/aggregator/src/lib.rs

@@ -253,12 +253,13 @@ pub fn tuxedo_constraint_checker(_attrs: TokenStream, body: TokenStream) -> Toke
             fn check (
                 &self,
                 inputs: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
+                evicted_inputs: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
                 peeks: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
                 outputs: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
             ) -> Result<TransactionPriority, Self::Error> {
                 match self {
                     #(
-                        Self::#variants5(inner) => inner.check(inputs, peeks, outputs).map_err(|e| Self::Error::#variants5(e)),
+                        Self::#variants5(inner) => inner.check(inputs, evicted_inputs, peeks, outputs).map_err(|e| Self::Error::#variants5(e)),
                     )*
                 }
             }

tuxedo-core/src/constraint_checker.rs

@@ -48,6 +48,7 @@ pub trait SimpleConstraintChecker: Debug + Encode + Decode + Clone {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         peek_data: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error>;
@@ -76,6 +77,7 @@ pub trait ConstraintChecker: Debug + Encode + Decode + Clone {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         peek_data: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error>;
@@ -116,10 +118,11 @@ impl<T: SimpleConstraintChecker> ConstraintChecker for T {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         peek_data: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error> {
-        SimpleConstraintChecker::check(self, input_data, peek_data, output_data)
+        SimpleConstraintChecker::check(self, input_data, evicted_input_data, peek_data, output_data)
     }
 
     fn is_inherent(&self) -> bool {
@@ -177,6 +180,7 @@ pub mod testing {
         fn check(
             &self,
             _input_data: &[DynamicallyTypedData],
+            _evicted_input_data: &[DynamicallyTypedData],
             _peek_data: &[DynamicallyTypedData],
             _output_data: &[DynamicallyTypedData],
         ) -> Result<TransactionPriority, ()> {
@@ -217,7 +221,7 @@ pub mod testing {
             checks: true,
             inherent: false,
         }
-        .check(&[], &[], &[]);
+        .check(&[], &[], &[], &[]);
         assert_eq!(result, Ok(0));
     }
 
@@ -227,7 +231,7 @@ pub mod testing {
             checks: false,
             inherent: false,
         }
-        .check(&[], &[], &[]);
+        .check(&[], &[], &[], &[]);
         assert_eq!(result, Err(()));
     }
 }

tuxedo-core/src/executive.rs

@@ -11,7 +11,7 @@ use crate::{
     dynamic_typing::DynamicallyTypedData,
     ensure,
     inherents::PARENT_INHERENT_IDENTIFIER,
-    types::{DispatchResult, OutputRef, Transaction, UtxoError},
+    types::{DispatchResult, OutputRef, RedemptionStrategy, Transaction, UtxoError},
     utxo_set::TransparentUtxoSet,
     verifier::Verifier,
     EXTRINSIC_KEY, HEADER_KEY, LOG_TARGET,
@@ -69,26 +69,34 @@ where
         // This will be passed to the verifiers
         let mut stripped = transaction.clone();
         for input in stripped.inputs.iter_mut() {
-            input.redeemer = Vec::new();
+            input.redeemer = Default::default();
         }
         let stripped_encoded = stripped.encode();
 
         // Check that the verifiers of all inputs are satisfied
         // Keep a Vec of the input data for passing to the constraint checker
         // Keep track of any missing inputs for use in the tagged transaction pool
         let mut input_data = Vec::new();
+        let mut evicted_input_data = Vec::new();
         let mut missing_inputs = Vec::new();
         for input in transaction.inputs.iter() {
             if let Some(input_utxo) = TransparentUtxoSet::<V>::peek_utxo(&input.output_ref) {
-                let redeemer = V::Redeemer::decode(&mut &input.redeemer[..])
-                    .map_err(|_| UtxoError::VerifierError)?;
-                ensure!(
-                    input_utxo
-                        .verifier
-                        .verify(&stripped_encoded, Self::block_height(), &redeemer),
-                    UtxoError::VerifierError
-                );
-                input_data.push(input_utxo.payload);
+                match input.redeemer {
+                    RedemptionStrategy::Redemption(ref redeemer) => {
+                        let redeemer = V::Redeemer::decode(&mut &redeemer[..])
+                            .map_err(|_| UtxoError::VerifierError)?;
+                        ensure!(
+                            input_utxo.verifier.verify(
+                                &stripped_encoded,
+                                Self::block_height(),
+                                &redeemer
+                            ),
+                            UtxoError::VerifierError
+                        );
+                        input_data.push(input_utxo.payload);
+                    }
+                    RedemptionStrategy::Eviction => evicted_input_data.push(input_utxo.payload),
+                }
             } else {
                 missing_inputs.push(input.output_ref.clone().encode());
             }
@@ -163,7 +171,7 @@ where
         // Call the constraint checker
         transaction
             .checker
-            .check(&input_data, &peek_data, &output_data)
+            .check(&input_data, &evicted_input_data, &peek_data, &output_data)
             .map_err(UtxoError::ConstraintCheckerError)?;
 
         // Return the valid transaction
@@ -671,7 +679,7 @@ mod tests {
             .execute_with(|| {
                 let input = Input {
                     output_ref,
-                    redeemer: Vec::new(),
+                    redeemer: Default::default(),
                 };
 
                 let tx = TestTransactionBuilder::default()
@@ -737,7 +745,7 @@ mod tests {
             let output_ref = mock_output_ref(0, 0);
             let input = Input {
                 output_ref: output_ref.clone(),
-                redeemer: Vec::new(),
+                redeemer: Default::default(),
             };
 
             let tx = TestTransactionBuilder::default()
@@ -783,7 +791,7 @@ mod tests {
             .execute_with(|| {
                 let input = Input {
                     output_ref,
-                    redeemer: Vec::new(),
+                    redeemer: Default::default(),
                 };
 
                 let tx = TestTransactionBuilder::default()
@@ -831,7 +839,7 @@ mod tests {
             .execute_with(|| {
                 let input = Input {
                     output_ref,
-                    redeemer: Vec::new(),
+                    redeemer: Default::default(),
                 };
 
                 let tx = TestTransactionBuilder::default()
@@ -901,7 +909,7 @@ mod tests {
             let output_ref = mock_output_ref(0, 0);
             let input = Input {
                 output_ref: output_ref.clone(),
-                redeemer: Vec::new(),
+                redeemer: Default::default(),
             };
 
             let tx = TestTransactionBuilder::default()
@@ -939,7 +947,7 @@ mod tests {
             .execute_with(|| {
                 let input = Input {
                     output_ref: output_ref.clone(),
-                    redeemer: Vec::new(),
+                    redeemer: Default::default(),
                 };
 
                 let tx = TestTransactionBuilder::default()

tuxedo-core/src/inherents.rs

@@ -165,10 +165,17 @@ impl<C: SimpleConstraintChecker + InherentHooks + 'static> ConstraintChecker
     fn check(
         &self,
         input_data: &[crate::dynamic_typing::DynamicallyTypedData],
+        evicted_input_data: &[crate::dynamic_typing::DynamicallyTypedData],
         peek_data: &[crate::dynamic_typing::DynamicallyTypedData],
         output_data: &[crate::dynamic_typing::DynamicallyTypedData],
     ) -> Result<sp_runtime::transaction_validity::TransactionPriority, Self::Error> {
-        SimpleConstraintChecker::check(&self.0, input_data, peek_data, output_data)
+        SimpleConstraintChecker::check(
+            &self.0,
+            input_data,
+            evicted_input_data,
+            peek_data,
+            output_data,
+        )
     }
 
     fn is_inherent(&self) -> bool {

tuxedo-core/src/types.rs

@@ -143,8 +143,28 @@ where
 pub struct Input {
     /// a reference to the output being consumed
     pub output_ref: OutputRef,
-    // Eg the signature
-    pub redeemer: Vec<u8>,
+    /// A means of showing that this input data can be used.
+    /// It is most often a proof such as a signature, but could also be a forceful eviction.
+    pub redeemer: RedemptionStrategy,
+}
+
+//TODO Consider making this enum generic over the redeemer type so there is not an additional decoding necessary.
+// This would percolate up though. For example input would also have to be generic over the redeemer type.
+// IDK if it is appropriate to be making so many types non-opaque??
+/// An input can be consumed in two way. It can be redeemed normally (probably with some signature, or proof) or it
+/// can be evicted. This enum is isomorphic to `Option<Vec<u8>>` but has more meaningful names.
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
+pub enum RedemptionStrategy {
+    /// The input is being consumed in the normal way with a signature or other proof provided by the spender.
+    Redemption(Vec<u8>),
+    /// The input is being forcefully evicted without satisfying its Verifier.
+    Eviction,
+}
+
+impl Default for RedemptionStrategy {
+    fn default() -> Self {
+        Self::Redemption(Vec::new())
+    }
 }
 
 #[derive(Debug, PartialEq, Eq)]

tuxedo-template-runtime/src/lib.rs

@@ -242,10 +242,11 @@ impl tuxedo_core::SimpleConstraintChecker for DummyParachainInfo {
     fn check(
         &self,
         _input_data: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
+        _evicted_input_data: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
         _peeks: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
         _output_data: &[tuxedo_core::dynamic_typing::DynamicallyTypedData],
     ) -> Result<TransactionPriority, ()> {
-        Ok(0)
+        panic!("Transactions should not be sent to the dummy parachain info piece.")
     }
 }
 

wallet/src/amoeba.rs

@@ -66,7 +66,7 @@ pub async fn amoeba_demo(client: &HttpClient) -> anyhow::Result<()> {
     let mitosis_tx = Transaction {
         inputs: vec![Input {
             output_ref: eve_ref,
-            redeemer: Vec::new(),
+            redeemer: Default::default(),
         }],
         peeks: Vec::new(),
         outputs: vec![

wallet/src/money.rs

@@ -14,7 +14,7 @@ use sled::Db;
 use sp_core::sr25519::Public;
 use sp_runtime::traits::{BlakeTwo256, Hash};
 use tuxedo_core::{
-    types::{Input, Output, OutputRef},
+    types::{Input, Output, OutputRef, RedemptionStrategy},
     verifier::Sr25519Signature,
 };
 
@@ -120,7 +120,7 @@ pub async fn spend_coins(
         get_coin_from_storage(output_ref, client).await?;
         transaction.inputs.push(Input {
             output_ref: output_ref.clone(),
-            redeemer: vec![], // We will sign the total transaction so this should be empty
+            redeemer: Default::default(), // We will sign the total transaction so this should be empty
         });
     }
 
@@ -143,7 +143,7 @@ pub async fn spend_coins(
         };
 
         // insert the proof
-        input.redeemer = redeemer;
+        input.redeemer = RedemptionStrategy::Redemption(redeemer);
     }
 
     // Send the transaction

wardrobe/amoeba/src/lib.rs

@@ -44,6 +44,8 @@ pub enum ConstraintCheckerError {
     BadlyTypedInput,
     /// An output data has the wrong type.
     BadlyTypedOutput,
+    /// The Amoeba piece does not allow any evictions at all.
+    NoEvictionsAllowed,
 
     /// Amoeba creation requires a new amoeba to be created, but none was provided.
     CreatedNothing,
@@ -87,9 +89,16 @@ impl SimpleConstraintChecker for AmoebaMitosis {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         _peeks: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, ConstraintCheckerError> {
+        // Can't evict anything
+        ensure!(
+            evicted_input_data.is_empty(),
+            ConstraintCheckerError::NoEvictionsAllowed
+        );
+
         // Make sure there is exactly one mother.
         ensure!(
             input_data.len() == 1,
@@ -145,9 +154,16 @@ impl SimpleConstraintChecker for AmoebaDeath {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         _peeks: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error> {
+        // Can't evict anything
+        ensure!(
+            evicted_input_data.is_empty(),
+            ConstraintCheckerError::NoEvictionsAllowed
+        );
+
         // Make sure there is a single victim
         ensure!(!input_data.is_empty(), ConstraintCheckerError::NoVictim);
         ensure!(
@@ -184,9 +200,16 @@ impl SimpleConstraintChecker for AmoebaCreation {
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
+        evicted_input_data: &[DynamicallyTypedData],
         _peeks: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error> {
+        // Can't evict anything
+        ensure!(
+            evicted_input_data.is_empty(),
+            ConstraintCheckerError::NoEvictionsAllowed
+        );
+
         // Make sure there is a single created amoeba
         ensure!(
             !output_data.is_empty(),