plumb consensus params throughout the vm for configurable tx validati…

…on (#130)

src/interpreter.rs

@@ -6,7 +6,7 @@ use crate::context::Context;
 use crate::state::Debugger;
 use std::collections::HashMap;
 
-use fuel_tx::{Receipt, Transaction};
+use fuel_tx::{ConsensusParameters, Receipt, Transaction};
 use fuel_types::{AssetId, Word};
 
 mod alu;
@@ -58,6 +58,7 @@ pub struct Interpreter<S> {
     profiler: Profiler,
     // track the offset for each unused balance in memory
     unused_balance_index: HashMap<AssetId, usize>,
+    consensus_parameters: ConsensusParameters,
 }
 
 impl<S> Interpreter<S> {

src/interpreter/constructors.rs

@@ -1,6 +1,6 @@
 //! Exposed constructors API for the [`Interpreter`]
 
-use fuel_tx::Transaction;
+use fuel_tx::{ConsensusParameters, Transaction};
 
 use super::Interpreter;
 use crate::consts::*;
@@ -17,7 +17,7 @@ impl<S> Interpreter<S> {
     /// If the provided storage implements
     /// [`crate::storage::InterpreterStorage`], the returned interpreter
     /// will provide full functionality.
-    pub fn with_storage(storage: S) -> Self {
+    pub fn with_storage(storage: S, params: ConsensusParameters) -> Self {
         Self {
             registers: [0; VM_REGISTER_COUNT],
             memory: vec![0; VM_MAX_RAM as usize],
@@ -31,6 +31,7 @@ impl<S> Interpreter<S> {
             #[cfg(feature = "profile-any")]
             profiler: Profiler::default(),
             unused_balance_index: Default::default(),
+            consensus_parameters: params,
         }
     }
 
@@ -47,7 +48,7 @@ where
     S: Default,
 {
     fn default() -> Self {
-        Self::with_storage(Default::default())
+        Self::with_storage(Default::default(), Default::default())
     }
 }
 

src/interpreter/executors/main.rs

@@ -7,7 +7,7 @@ use crate::state::{ExecuteState, ProgramState, StateTransitionRef};
 use crate::storage::InterpreterStorage;
 
 use fuel_asm::PanicReason;
-use fuel_tx::{Contract, Input, Output, Receipt, ScriptExecutionResult, Transaction};
+use fuel_tx::{ConsensusParameters, Contract, Input, Output, Receipt, ScriptExecutionResult, Transaction};
 use fuel_types::{bytes::SerializableVec, Word};
 
 impl<S> Interpreter<S>
@@ -25,8 +25,8 @@ where
     ///
     /// This is not a valid entrypoint for debug calls. It will only return a `bool`, and not the
     /// VM state required to trace the execution steps.
-    pub fn check_predicates(tx: Transaction) -> bool {
-        let mut vm = Interpreter::with_storage(S::default());
+    pub fn check_predicates(tx: Transaction, params: ConsensusParameters) -> bool {
+        let mut vm = Interpreter::with_storage(S::default(), params);
 
         if !tx.check_predicate_owners() {
             return false;
@@ -63,7 +63,7 @@ where
     fn init_predicate(&mut self, tx: Transaction) -> bool {
         let block_height = 0;
 
-        self.init(true, block_height, tx).is_ok()
+        self.init(true, block_height, tx, self.consensus_parameters).is_ok()
     }
 
     fn input_to_predicate(tx: &Transaction, idx: usize) -> Option<MemoryRange> {
@@ -132,7 +132,7 @@ where
                 // Verify predicates
                 // https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/tx_validity.md#predicate-verification
                 // TODO implement debug support
-                if !Interpreter::<()>::check_predicates(self.tx.clone()) {
+                if !Interpreter::<()>::check_predicates(self.tx.clone(), self.consensus_parameters) {
                     return Err(InterpreterError::PredicateFailure);
                 }
 
@@ -286,8 +286,12 @@ where
     /// Allocate internally a new instance of [`Interpreter`] with the provided
     /// storage, initialize it with the provided transaction and return the
     /// result of th execution in form of [`StateTransition`]
-    pub fn transact_owned(storage: S, tx: Transaction) -> Result<StateTransition, InterpreterError> {
-        Interpreter::with_storage(storage)
+    pub fn transact_owned(
+        storage: S,
+        tx: Transaction,
+        params: ConsensusParameters,
+    ) -> Result<StateTransition, InterpreterError> {
+        Interpreter::with_storage(storage, params)
             .transact(tx)
             .map(|st| st.into_owned())
     }
@@ -297,7 +301,9 @@ where
     /// of the interpreter and will avoid unnecessary copy with the data
     /// that can be referenced from the interpreter instance itself.
     pub fn transact(&mut self, tx: Transaction) -> Result<StateTransitionRef<'_>, InterpreterError> {
-        let state_result = self.init_with_storage(tx).and_then(|_| self.run());
+        let state_result = self
+            .init_with_storage(tx, self.consensus_parameters)
+            .and_then(|_| self.run());
 
         #[cfg(feature = "profile-any")]
         self.profiler.on_transaction(&state_result);

src/interpreter/initialization.rs

@@ -15,9 +15,13 @@ use std::io;
 
 impl<S> Interpreter<S> {
     /// Initialize the VM with a given transaction
-    pub fn init(&mut self, predicate: bool, block_height: u32, mut tx: Transaction) -> Result<(), InterpreterError> {
-        let params = ConsensusParameters::default();
-
+    pub fn init(
+        &mut self,
+        predicate: bool,
+        block_height: u32,
+        mut tx: Transaction,
+        params: ConsensusParameters,
+    ) -> Result<(), InterpreterError> {
         tx.validate_without_signature(self.block_height() as Word, &params)?;
         tx.precompute_metadata();
 
@@ -162,10 +166,10 @@ where
     /// execution of contract opcodes.
     ///
     /// For predicate verification, check [`Self::init`]
-    pub fn init_with_storage(&mut self, tx: Transaction) -> Result<(), InterpreterError> {
+    pub fn init_with_storage(&mut self, tx: Transaction, params: ConsensusParameters) -> Result<(), InterpreterError> {
         let predicate = false;
         let block_height = self.storage.block_height().map_err(InterpreterError::from_io)?;
 
-        self.init(predicate, block_height, tx)
+        self.init(predicate, block_height, tx, params)
     }
 }

src/interpreter/internal.rs

@@ -250,7 +250,8 @@ mod tests {
             vec![vec![].into()],
         );
 
-        vm.init_with_storage(tx).expect("Failed to init VM!");
+        vm.init_with_storage(tx, Default::default())
+            .expect("Failed to init VM!");
 
         for (asset_id, amount) in balances {
             assert!(vm.external_asset_id_balance_sub(&asset_id, amount + 1).is_err());
@@ -293,7 +294,8 @@ mod tests {
             vec![Witness::default()],
         );
 
-        vm.init_with_storage(tx).expect("Failed to init VM!");
+        vm.init_with_storage(tx, Default::default())
+            .expect("Failed to init VM!");
 
         // increase variable output
         vm.set_variable_output(0, asset_id_to_update, amount_to_set, owner)

src/interpreter/memory.rs

@@ -423,7 +423,8 @@ mod tests {
     fn memcopy() {
         let mut vm = Interpreter::with_memory_storage();
 
-        vm.init_with_storage(Transaction::default()).expect("Failed to init VM");
+        vm.init_with_storage(Transaction::default(), Default::default())
+            .expect("Failed to init VM");
 
         let alloc = 1024;
 
@@ -505,7 +506,8 @@ mod tests {
         assert_eq!(m, m_p);
 
         let mut vm = Interpreter::with_memory_storage();
-        vm.init_with_storage(Transaction::default()).expect("Failed to init VM");
+        vm.init_with_storage(Transaction::default(), Default::default())
+            .expect("Failed to init VM");
 
         let bytes = 1024;
         vm.instruction(
@@ -536,7 +538,8 @@ mod tests {
     fn stack_alloc_ownership() {
         let mut vm = Interpreter::with_memory_storage();
 
-        vm.init_with_storage(Transaction::default()).expect("Failed to init VM");
+        vm.init_with_storage(Transaction::default(), Default::default())
+            .expect("Failed to init VM");
 
         vm.instruction(Interpreter::instruction_script, Opcode::MOVE(0x10, REG_SP).into())
             .unwrap();

src/memory_client.rs

@@ -3,7 +3,7 @@
 use crate::backtrace::Backtrace;
 use crate::transactor::Transactor;
 
-use fuel_tx::{Receipt, Transaction};
+use fuel_tx::{ConsensusParameters, Receipt, Transaction};
 
 mod storage;
 
@@ -29,9 +29,9 @@ impl<'a> AsMut<MemoryStorage> for MemoryClient<'a> {
 
 impl<'a> MemoryClient<'a> {
     /// Create a new instance of the memory client out of a provided storage.
-    pub fn new(storage: MemoryStorage) -> Self {
+    pub fn new(storage: MemoryStorage, params: ConsensusParameters) -> Self {
         Self {
-            transactor: Transactor::new(storage),
+            transactor: Transactor::new(storage, params),
         }
     }
 
@@ -87,7 +87,7 @@ impl<'a> MemoryClient<'a> {
 
 impl<'a> From<MemoryStorage> for MemoryClient<'a> {
     fn from(s: MemoryStorage) -> Self {
-        Self::new(s)
+        Self::new(s, Default::default())
     }
 }
 

src/transactor.rs

@@ -6,7 +6,7 @@ use crate::interpreter::Interpreter;
 use crate::state::StateTransitionRef;
 use crate::storage::InterpreterStorage;
 
-use fuel_tx::{Receipt, Transaction};
+use fuel_tx::{ConsensusParameters, Receipt, Transaction};
 
 use std::{mem, slice};
 
@@ -26,8 +26,8 @@ pub struct Transactor<'a, S> {
 
 impl<'a, S> Transactor<'a, S> {
     /// Transactor constructor
-    pub fn new(storage: S) -> Self {
-        Interpreter::with_storage(storage).into()
+    pub fn new(storage: S, params: ConsensusParameters) -> Self {
+        Interpreter::with_storage(storage, params).into()
     }
 
     /// State transition representation after the execution of a transaction.
@@ -185,6 +185,6 @@ where
     S: Default,
 {
     fn default() -> Self {
-        Self::new(Default::default())
+        Self::new(Default::default(), Default::default())
     }
 }

src/util.rs

@@ -287,7 +287,7 @@ pub mod test_helpers {
         }
 
         fn execute_tx(&mut self, tx: Transaction) -> StateTransition {
-            let mut client = MemoryClient::new(self.storage.clone());
+            let mut client = MemoryClient::new(self.storage.clone(), Default::default());
             client.transact(tx);
             let storage = client.as_ref().clone();
             let txtor: Transactor<_> = client.into();

tests/alu.rs

@@ -27,7 +27,7 @@ fn alu(registers_init: &[(RegisterId, Immediate18)], op: Opcode, reg: RegisterId
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")
@@ -65,7 +65,7 @@ fn alu_overflow(program: &[Opcode], reg: RegisterId, expected: u128, boolean: bo
         vec![],
     );
 
-    let receipts = Transactor::new(storage.clone())
+    let receipts = Transactor::new(storage.clone(), Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")
@@ -101,7 +101,7 @@ fn alu_overflow(program: &[Opcode], reg: RegisterId, expected: u128, boolean: bo
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")
@@ -146,7 +146,7 @@ fn alu_err(registers_init: &[(RegisterId, Immediate18)], op: Opcode, reg: Regist
         vec![],
     );
 
-    let receipts = Transactor::new(storage.clone())
+    let receipts = Transactor::new(storage.clone(), Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")
@@ -182,7 +182,7 @@ fn alu_err(registers_init: &[(RegisterId, Immediate18)], op: Opcode, reg: Regist
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")
@@ -219,7 +219,7 @@ fn alu_reserved(registers_init: &[(RegisterId, Immediate18)], op: Opcode) {
         vec![],
         vec![],
     );
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute ALU script!")

tests/crypto.rs

@@ -88,7 +88,7 @@ fn ecrecover() {
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute script!")
@@ -171,7 +171,7 @@ fn sha256() {
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute script!")
@@ -259,7 +259,7 @@ fn keccak256() {
         vec![],
     );
 
-    let receipts = Transactor::new(storage)
+    let receipts = Transactor::new(storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute script!")

tests/flow.rs

@@ -149,7 +149,9 @@ fn call() {
         vec![program.clone()],
     );
 
-    assert!(Transactor::new(&mut storage).transact(tx).is_success());
+    assert!(Transactor::new(&mut storage, Default::default())
+        .transact(tx)
+        .is_success());
 
     let mut script_ops = vec![
         Opcode::MOVI(0x10, 0x00),
@@ -185,7 +187,7 @@ fn call() {
         _ => unreachable!(),
     }
 
-    let receipts = Transactor::new(&mut storage)
+    let receipts = Transactor::new(&mut storage, Default::default())
         .transact(tx)
         .receipts()
         .expect("Failed to execute script")
@@ -243,7 +245,9 @@ fn call_frame_code_offset() {
         vec![program.clone().into()],
     );
 
-    assert!(Transactor::new(&mut storage).transact(deploy).is_success());
+    assert!(Transactor::new(&mut storage, Default::default())
+        .transact(deploy)
+        .is_success());
 
     let input = Input::contract(rng.gen(), rng.gen(), rng.gen(), id);
     let output = Output::contract(0, rng.gen(), rng.gen());
@@ -282,7 +286,7 @@ fn call_frame_code_offset() {
         vec![],
     );
 
-    let mut vm = Interpreter::with_storage(storage);
+    let mut vm = Interpreter::with_storage(storage, Default::default());
 
     vm.transact(script).expect("Failed to call deployed contract");