diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24aa50754b..2fca3e2660 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 #### Breaking
 
 - [#683](https://github.com/FuelLabs/fuel-vm/pull/683): Simplify `InterpreterStorage` by removing dependency on `MerkleRootStorage` and removing `merkle_` prefix from method names.
+- [#678](https://github.com/FuelLabs/fuel-vm/pull/678): Zero malleable fields before execution. Remove some now-obsolete GTF getters. Don't update `tx.receiptsRoot` after pushing receipts, and do it after execution instead.
 - [#672](https://github.com/FuelLabs/fuel-vm/pull/672): Remove `GasPrice` policy
 - [#672](https://github.com/FuelLabs/fuel-vm/pull/672): Add `gas_price` field to transaction execution
 - [#684](https://github.com/FuelLabs/fuel-vm/pull/684): Remove `maturity` field from `Input` coin types. Also remove related `GTF` getter.
diff --git a/fuel-asm/src/args.rs b/fuel-asm/src/args.rs
index f8300f1076..518121846f 100644
--- a/fuel-asm/src/args.rs
+++ b/fuel-asm/src/args.rs
@@ -164,15 +164,6 @@ crate::enum_try_from! {
         /// Set `$rA` to `tx.inputs[$rB].outputIndex`
         InputContractOutputIndex = 0x221,
 
-        /// Set `$rA` to `Memory address of tx.inputs[$rB].balanceRoot`
-        InputContractBalanceRoot = 0x222,
-
-        /// Set `$rA` to `Memory address of tx.inputs[$rB].stateRoot`
-        InputContractStateRoot = 0x223,
-
-        /// Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
-        InputContractTxPointer = 0x224,
-
         /// Set `$rA` to `Memory address of tx.inputs[$rB].contractID`
         InputContractId = 0x225,
 
@@ -227,12 +218,6 @@ crate::enum_try_from! {
         /// Set `$rA` to `tx.outputs[$rB].inputIndex`
         OutputContractInputIndex = 0x304,
 
-        /// Set `$rA` to `Memory address of tx.outputs[$rB].balanceRoot`
-        OutputContractBalanceRoot = 0x305,
-
-        /// Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
-        OutputContractStateRoot = 0x306,
-
         /// Set `$rA` to `Memory address of tx.outputs[$rB].contractID`
         OutputContractCreatedContractId = 0x307,
 
@@ -328,11 +313,6 @@ fn encode_gtf_args() {
         GTFArgs::InputCoinPredicate,
         GTFArgs::InputCoinPredicateData,
         GTFArgs::InputCoinPredicateGasUsed,
-        GTFArgs::InputContractTxId,
-        GTFArgs::InputContractOutputIndex,
-        GTFArgs::InputContractBalanceRoot,
-        GTFArgs::InputContractStateRoot,
-        GTFArgs::InputContractTxPointer,
         GTFArgs::InputContractId,
         GTFArgs::InputMessageSender,
         GTFArgs::InputMessageRecipient,
@@ -351,8 +331,6 @@ fn encode_gtf_args() {
         GTFArgs::OutputCoinAmount,
         GTFArgs::OutputCoinAssetId,
         GTFArgs::OutputContractInputIndex,
-        GTFArgs::OutputContractBalanceRoot,
-        GTFArgs::OutputContractStateRoot,
         GTFArgs::OutputContractCreatedContractId,
         GTFArgs::OutputContractCreatedStateRoot,
         GTFArgs::WitnessDataLength,
diff --git a/fuel-tx/src/builder.rs b/fuel-tx/src/builder.rs
index aa09a4ac0f..1d57ce9a87 100644
--- a/fuel-tx/src/builder.rs
+++ b/fuel-tx/src/builder.rs
@@ -103,8 +103,6 @@ impl<T> Buildable for T where T: BuildableSet {}
 pub struct TransactionBuilder<Tx> {
     tx: Tx,
 
-    should_prepare_script: bool,
-    should_prepare_predicate: bool,
     params: ConsensusParameters,
 
     // We take the key by reference so this lib won't have the responsibility to properly
@@ -126,12 +124,7 @@ impl TransactionBuilder<Script> {
             receipts_root: Default::default(),
             metadata: None,
         };
-
-        let mut slf = Self::with_tx(tx);
-
-        slf.prepare_script(true);
-
-        slf
+        Self::with_tx(tx)
     }
 }
 
@@ -190,14 +183,10 @@ impl TransactionBuilder<Mint> {
 
 impl<Tx> TransactionBuilder<Tx> {
     fn with_tx(tx: Tx) -> Self {
-        let should_prepare_script = false;
-        let should_prepare_predicate = false;
         let sign_keys = BTreeMap::new();
 
         Self {
             tx,
-            should_prepare_script,
-            should_prepare_predicate,
             params: ConsensusParameters::standard(),
             sign_keys,
         }
@@ -279,16 +268,6 @@ impl<Tx> TransactionBuilder<Tx> {
 }
 
 impl<Tx: Buildable> TransactionBuilder<Tx> {
-    pub fn prepare_script(&mut self, should_prepare_script: bool) -> &mut Self {
-        self.should_prepare_script = should_prepare_script;
-        self
-    }
-
-    pub fn prepare_predicate(&mut self, should_prepare_predicate: bool) -> &mut Self {
-        self.should_prepare_predicate = should_prepare_predicate;
-        self
-    }
-
     pub fn sign_keys(&self) -> impl Iterator<Item = &SecretKey> {
         self.sign_keys.keys()
     }
@@ -433,19 +412,7 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         *witness_index
     }
 
-    fn prepare_finalize(&mut self) {
-        if self.should_prepare_predicate {
-            self.tx.prepare_init_predicate();
-        }
-
-        if self.should_prepare_script {
-            self.tx.prepare_init_script();
-        }
-    }
-
     fn finalize_inner(&mut self) -> Tx {
-        self.prepare_finalize();
-
         let mut tx = core::mem::take(&mut self.tx);
 
         self.sign_keys
@@ -459,8 +426,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
     }
 
     pub fn finalize_without_signature_inner(&mut self) -> Tx {
-        self.prepare_finalize();
-
         let mut tx = core::mem::take(&mut self.tx);
 
         tx.precompute(&self.get_chain_id())
diff --git a/fuel-tx/src/tests/mod.rs b/fuel-tx/src/tests/mod.rs
index 683e669fa5..842556ba40 100644
--- a/fuel-tx/src/tests/mod.rs
+++ b/fuel-tx/src/tests/mod.rs
@@ -1,5 +1,4 @@
 mod offset;
-mod prepared_init;
 mod valid_cases;
 
 #[cfg(feature = "serde")]
diff --git a/fuel-tx/src/tests/prepared_init.rs b/fuel-tx/src/tests/prepared_init.rs
deleted file mode 100644
index 34b0289a29..0000000000
--- a/fuel-tx/src/tests/prepared_init.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use fuel_tx::{
-    field::Outputs,
-    Executable,
-    *,
-};
-use rand::{
-    rngs::StdRng,
-    Rng,
-    SeedableRng,
-};
-
-#[test]
-fn output_variable_prepare_init_zeroes_recipient_and_amount() {
-    let rng = &mut StdRng::seed_from_u64(8586);
-
-    let variable = Output::variable(rng.gen(), rng.gen(), rng.gen());
-    let zeroed = Output::variable(Address::zeroed(), 0, AssetId::zeroed());
-
-    let tx = TransactionBuilder::script(vec![], vec![])
-        .prepare_script(false)
-        .add_output(variable)
-        .finalize();
-
-    let output = tx
-        .clone()
-        .prepare_init_predicate()
-        .outputs()
-        .first()
-        .cloned()
-        .expect("failed to fetch output");
-
-    let output_p = tx
-        .outputs()
-        .first()
-        .cloned()
-        .expect("failed to fetch output");
-
-    assert_ne!(zeroed, variable);
-    assert_eq!(zeroed, output);
-    assert_eq!(variable, output_p);
-}
diff --git a/fuel-tx/src/transaction.rs b/fuel-tx/src/transaction.rs
index 01c463385e..554d1e7976 100644
--- a/fuel-tx/src/transaction.rs
+++ b/fuel-tx/src/transaction.rs
@@ -412,31 +412,6 @@ pub trait Executable: field::Inputs + field::Outputs + field::Witnesses {
 
         self.inputs_mut().push(input);
     }
-
-    /// Prepare the transaction for VM initialization for script execution
-    ///
-    /// note: Fields dependent on storage/state such as balance and state roots, or tx
-    /// pointers, should already set by the client beforehand.
-    fn prepare_init_script(&mut self) -> &mut Self {
-        self.outputs_mut()
-            .iter_mut()
-            .for_each(|o| o.prepare_init_script());
-
-        self
-    }
-
-    /// Prepare the transaction for VM initialization for predicate verification
-    fn prepare_init_predicate(&mut self) -> &mut Self {
-        self.inputs_mut()
-            .iter_mut()
-            .for_each(|i| i.prepare_init_predicate());
-
-        self.outputs_mut()
-            .iter_mut()
-            .for_each(|o| o.prepare_init_predicate());
-
-        self
-    }
 }
 
 impl<T: field::Inputs + field::Outputs + field::Witnesses> Executable for T {}
diff --git a/fuel-tx/src/transaction/types/input.rs b/fuel-tx/src/transaction/types/input.rs
index f1113251c0..7702347462 100644
--- a/fuel-tx/src/transaction/types/input.rs
+++ b/fuel-tx/src/transaction/types/input.rs
@@ -753,9 +753,9 @@ impl Input {
         owner == &Self::predicate_owner(predicate)
     }
 
-    /// Prepare the output for VM predicate execution
-    pub fn prepare_init_predicate(&mut self) {
-        self.prepare_sign()
+    /// Prepare the output for script or predicate execution
+    pub fn prepare_init_execute(&mut self) {
+        self.prepare_sign(); // This currently does the same thing
     }
 }
 
diff --git a/fuel-tx/src/transaction/types/output.rs b/fuel-tx/src/transaction/types/output.rs
index 37fb79c340..856d8d0d90 100644
--- a/fuel-tx/src/transaction/types/output.rs
+++ b/fuel-tx/src/transaction/types/output.rs
@@ -217,29 +217,9 @@ impl Output {
     }
 
     /// Prepare the output for VM initialization for script execution
-    pub fn prepare_init_script(&mut self) {
-        match self {
-            Output::Change { amount, .. } => {
-                mem::take(amount);
-            }
-
-            Output::Variable {
-                to,
-                amount,
-                asset_id,
-            } => {
-                mem::take(to);
-                mem::take(amount);
-                mem::take(asset_id);
-            }
-
-            _ => (),
-        }
-    }
-
-    /// Prepare the output for VM initialization for predicate verification
-    pub fn prepare_init_predicate(&mut self) {
-        self.prepare_sign()
+    /// or predicate verification
+    pub fn prepare_init_execute(&mut self) {
+        self.prepare_sign() // Currently does the same thing
     }
 }
 
diff --git a/fuel-tx/src/transaction/types/script.rs b/fuel-tx/src/transaction/types/script.rs
index 7d9a1bc98c..ccd391d82a 100644
--- a/fuel-tx/src/transaction/types/script.rs
+++ b/fuel-tx/src/transaction/types/script.rs
@@ -100,6 +100,19 @@ impl Default for Script {
     }
 }
 
+impl Script {
+    /// Prepare script for execution by clearing malleable fields.
+    pub fn prepare_init_execute(&mut self) {
+        *self.receipts_root_mut() = Default::default();
+        self.inputs_mut()
+            .iter_mut()
+            .for_each(Input::prepare_init_execute);
+        self.outputs_mut()
+            .iter_mut()
+            .for_each(Output::prepare_init_execute);
+    }
+}
+
 impl crate::UniqueIdentifier for Script {
     fn id(&self, chain_id: &ChainId) -> Bytes32 {
         if let Some(id) = self.cached_id() {
diff --git a/fuel-vm/src/checked_transaction.rs b/fuel-vm/src/checked_transaction.rs
index f4cf24c582..428e2b8a39 100644
--- a/fuel-vm/src/checked_transaction.rs
+++ b/fuel-vm/src/checked_transaction.rs
@@ -47,6 +47,7 @@ bitflags::bitflags! {
     pub struct Checks: u32 {
         /// Basic checks defined in the specification for each transaction:
         /// https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md#transaction
+        /// Also ensures that malleable fields are zeroed.
         const Basic         = 0b00000001;
         /// Check that signature in the transactions are valid.
         const Signatures    = 0b00000010;
diff --git a/fuel-vm/src/interpreter.rs b/fuel-vm/src/interpreter.rs
index dfafa22b96..8cc2317dfe 100644
--- a/fuel-vm/src/interpreter.rs
+++ b/fuel-vm/src/interpreter.rs
@@ -20,7 +20,12 @@ use fuel_asm::{
     PanicReason,
 };
 use fuel_tx::{
-    field,
+    field::{
+        self,
+        Inputs,
+        Outputs,
+        ReceiptsRoot,
+    },
     output,
     Chargeable,
     ContractParameters,
@@ -28,6 +33,7 @@ use fuel_tx::{
     Executable,
     FeeParameters,
     GasCosts,
+    Input,
     Output,
     PredicateParameters,
     Receipt,
@@ -40,6 +46,7 @@ use fuel_tx::{
 };
 use fuel_types::{
     AssetId,
+    Bytes32,
     ChainId,
     ContractId,
     Word,
@@ -286,6 +293,11 @@ impl<S, Tx, Ecal> Interpreter<S, Tx, Ecal> {
         self.receipts.as_ref().as_slice()
     }
 
+    /// Compute current receipts root
+    pub fn compute_receipts_root(&self) -> Bytes32 {
+        self.receipts.root()
+    }
+
     /// Mutable access to receipts for testing purposes.
     #[cfg(any(test, feature = "test-helpers"))]
     pub fn receipts_mut(&mut self) -> &mut ReceiptsCtx {
@@ -474,6 +486,9 @@ pub trait ExecutableTransaction:
             }) if *input_index as usize == input)
         })
     }
+
+    /// Prepares the transaction for execution.
+    fn prepare_init_execute(&mut self);
 }
 
 impl ExecutableTransaction for Create {
@@ -496,6 +511,8 @@ impl ExecutableTransaction for Create {
     fn transaction_type() -> Word {
         TransactionRepr::Create as Word
     }
+
+    fn prepare_init_execute(&mut self) {}
 }
 
 impl ExecutableTransaction for Script {
@@ -518,6 +535,16 @@ impl ExecutableTransaction for Script {
     fn transaction_type() -> Word {
         TransactionRepr::Script as Word
     }
+
+    fn prepare_init_execute(&mut self) {
+        *self.receipts_root_mut() = Default::default();
+        self.inputs_mut()
+            .iter_mut()
+            .for_each(Input::prepare_init_execute);
+        self.outputs_mut()
+            .iter_mut()
+            .for_each(Output::prepare_init_execute);
+    }
 }
 
 /// The initial balances of the transaction.
diff --git a/fuel-vm/src/interpreter/blockchain.rs b/fuel-vm/src/interpreter/blockchain.rs
index 461f93d21e..0f81be72c2 100644
--- a/fuel-vm/src/interpreter/blockchain.rs
+++ b/fuel-vm/src/interpreter/blockchain.rs
@@ -25,14 +25,12 @@ use crate::{
             ProfileGas,
         },
         internal::{
-            append_receipt,
             base_asset_balance_sub,
             current_contract,
             inc_pc,
             internal_contract,
             internal_contract_bounds,
             tx_id,
-            AppendReceipt,
         },
         memory::{
             copy_from_slice_zero_fill_noownerchecks,
@@ -150,18 +148,13 @@ where
     }
 
     pub(crate) fn burn(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
-        let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, pc, is, .. }, _) =
             split_registers(&mut self.registers);
         BurnCtx {
             storage: &mut self.storage,
             context: &self.context,
-            append: AppendReceipt {
-                receipts: &mut self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset,
-                memory: &mut self.memory,
-            },
+            memory: &self.memory,
+            receipts: &mut self.receipts,
             fp: fp.as_ref(),
             pc,
             is: is.as_ref(),
@@ -170,7 +163,6 @@ where
     }
 
     pub(crate) fn mint(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
-        let tx_offset = self.tx_offset();
         let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte;
         let (
             SystemRegisters {
@@ -186,12 +178,8 @@ where
         MintCtx {
             storage: &mut self.storage,
             context: &self.context,
-            append: AppendReceipt {
-                receipts: &mut self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset,
-                memory: &mut self.memory,
-            },
+            memory: &self.memory,
+            receipts: &mut self.receipts,
             profiler: &mut self.profiler,
             new_storage_gas_per_byte,
             cgas,
@@ -522,15 +510,12 @@ where
     ) -> IoResult<(), S::DataError> {
         let base_asset_id = self.interpreter_params.base_asset_id;
         let max_message_data_length = self.max_message_data_length();
-        let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, pc, .. }, _) = split_registers(&mut self.registers);
         let input = MessageOutputCtx {
             base_asset_id,
             max_message_data_length,
             memory: &mut self.memory,
-            tx_offset,
             receipts: &mut self.receipts,
-            tx: &mut self.tx,
             balances: &mut self.balances,
             storage: &mut self.storage,
             current_contract: self.frames.last().map(|frame| frame.to()).copied(),
@@ -676,7 +661,8 @@ where
 struct BurnCtx<'vm, S> {
     storage: &'vm mut S,
     context: &'vm Context,
-    append: AppendReceipt<'vm>,
+    memory: &'vm [u8; MEM_SIZE],
+    receipts: &'vm mut ReceiptsCtx,
     fp: Reg<'vm, FP>,
     pc: RegMut<'vm, PC>,
     is: Reg<'vm, IS>,
@@ -689,11 +675,10 @@ where
     pub(crate) fn burn(self, a: Word, b: Word) -> IoResult<(), S::Error> {
         let range = internal_contract_bounds(self.context, self.fp)?;
         let sub_id_range = CheckedMemConstLen::<{ Bytes32::LEN }>::new(b)?;
-        let memory = &*self.append.memory;
 
-        let sub_id = Bytes32::from_bytes_ref(sub_id_range.read(memory));
+        let sub_id = Bytes32::from_bytes_ref(sub_id_range.read(self.memory));
 
-        let contract_id = ContractId::from_bytes_ref(range.read(memory));
+        let contract_id = ContractId::from_bytes_ref(range.read(self.memory));
         let asset_id = contract_id.asset_id(sub_id);
 
         let balance = balance(self.storage, contract_id, &asset_id)?;
@@ -708,7 +693,7 @@ where
 
         let receipt = Receipt::burn(*sub_id, *contract_id, a, *self.pc, *self.is);
 
-        append_receipt(self.append, receipt)?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
@@ -717,9 +702,10 @@ where
 struct MintCtx<'vm, S> {
     storage: &'vm mut S,
     context: &'vm Context,
+    memory: &'vm [u8; MEM_SIZE],
     profiler: &'vm mut Profiler,
+    receipts: &'vm mut ReceiptsCtx,
     new_storage_gas_per_byte: Word,
-    append: AppendReceipt<'vm>,
     cgas: RegMut<'vm, CGAS>,
     ggas: RegMut<'vm, GGAS>,
     fp: Reg<'vm, FP>,
@@ -734,11 +720,10 @@ where
     pub(crate) fn mint(self, a: Word, b: Word) -> Result<(), RuntimeError<S::Error>> {
         let range = internal_contract_bounds(self.context, self.fp)?;
         let sub_id_range = CheckedMemConstLen::<{ Bytes32::LEN }>::new(b)?;
-        let memory = &*self.append.memory;
 
-        let sub_id = Bytes32::from_bytes_ref(sub_id_range.read(memory));
+        let sub_id = Bytes32::from_bytes_ref(sub_id_range.read(self.memory));
 
-        let contract_id = ContractId::from_bytes_ref(range.read(memory));
+        let contract_id = ContractId::from_bytes_ref(range.read(self.memory));
         let asset_id = contract_id.asset_id(sub_id);
 
         let balance = balance(self.storage, contract_id, &asset_id)?;
@@ -767,7 +752,7 @@ where
 
         let receipt = Receipt::mint(*sub_id, *contract_id, a, *self.pc, *self.is);
 
-        append_receipt(self.append, receipt)?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
@@ -1127,16 +1112,14 @@ pub(crate) fn timestamp<S: InterpreterStorage>(
 
     Ok(inc_pc(pc)?)
 }
-struct MessageOutputCtx<'vm, Tx, S>
+struct MessageOutputCtx<'vm, S>
 where
     S: ContractsAssetsStorage + ?Sized,
 {
     base_asset_id: AssetId,
     max_message_data_length: u64,
     memory: &'vm mut [u8; MEM_SIZE],
-    tx_offset: usize,
     receipts: &'vm mut ReceiptsCtx,
-    tx: &'vm mut Tx,
     balances: &'vm mut RuntimeBalances,
     storage: &'vm mut S,
     current_contract: Option<ContractId>,
@@ -1152,14 +1135,11 @@ where
     amount_coins_to_send: Word,
 }
 
-impl<Tx, S> MessageOutputCtx<'_, Tx, S>
+impl<S> MessageOutputCtx<'_, S>
 where
     S: ContractsAssetsStorage + ?Sized,
 {
-    pub(crate) fn message_output(self) -> Result<(), RuntimeError<S::Error>>
-    where
-        Tx: ExecutableTransaction,
-    {
+    pub(crate) fn message_output(self) -> Result<(), RuntimeError<S::Error>> {
         let recipient_address = CheckedMemValue::<Address>::new::<{ Address::LEN }>(
             self.recipient_mem_address,
         )?;
@@ -1204,15 +1184,7 @@ where
             msg_data,
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset: self.tx_offset,
-                memory: self.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
diff --git a/fuel-vm/src/interpreter/blockchain/other_tests.rs b/fuel-vm/src/interpreter/blockchain/other_tests.rs
index 0312579e80..ab43cb16e0 100644
--- a/fuel-vm/src/interpreter/blockchain/other_tests.rs
+++ b/fuel-vm/src/interpreter/blockchain/other_tests.rs
@@ -55,7 +55,6 @@ fn test_burn(
         }
     };
     let mut receipts = Default::default();
-    let mut script = Some(fuel_tx::Script::default());
 
     let is = 0;
     const ORIGINAL_PC: Word = 4;
@@ -63,12 +62,8 @@ fn test_burn(
     BurnCtx {
         storage: &mut storage,
         context: &context,
-        append: AppendReceipt {
-            receipts: &mut receipts,
-            script: script.as_mut(),
-            tx_offset: 0,
-            memory: &mut memory,
-        },
+        receipts: &mut receipts,
+        memory: &mut memory,
         fp: Reg::new(&fp),
         pc: RegMut::new(&mut pc),
         is: Reg::new(&is),
@@ -139,7 +134,6 @@ fn test_mint(
     };
 
     let mut receipts = Default::default();
-    let mut script = Some(fuel_tx::Script::default());
 
     let is = 0;
     const ORIGINAL_PC: Word = 4;
@@ -149,12 +143,8 @@ fn test_mint(
     MintCtx {
         storage: &mut storage,
         context: &context,
-        append: AppendReceipt {
-            receipts: &mut receipts,
-            script: script.as_mut(),
-            tx_offset: 0,
-            memory: &mut memory,
-        },
+        receipts: &mut receipts,
+        memory: &mut memory,
         profiler: &mut Profiler::default(),
         new_storage_gas_per_byte: 1,
         cgas: RegMut::new(&mut cgas),
diff --git a/fuel-vm/src/interpreter/blockchain/smo_tests.rs b/fuel-vm/src/interpreter/blockchain/smo_tests.rs
index 7b072cf8ee..23232611d0 100644
--- a/fuel-vm/src/interpreter/blockchain/smo_tests.rs
+++ b/fuel-vm/src/interpreter/blockchain/smo_tests.rs
@@ -20,7 +20,6 @@ use rand::{
     SeedableRng,
 };
 
-use fuel_tx::Create;
 use test_case::test_case;
 
 struct Input {
@@ -217,7 +216,6 @@ fn test_smo(
         memory[offset..offset + bytes.len()].copy_from_slice(bytes.as_slice());
     }
     let mut receipts = Default::default();
-    let mut tx = Create::default();
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let old_balance = storage
         .contract_asset_id_balance_insert(
@@ -236,9 +234,7 @@ fn test_smo(
         base_asset_id,
         max_message_data_length,
         memory: &mut memory,
-        tx_offset: 0,
         receipts: &mut receipts,
-        tx: &mut tx,
         balances: &mut balances,
         storage: &mut storage,
         current_contract: if internal {
diff --git a/fuel-vm/src/interpreter/contract.rs b/fuel-vm/src/interpreter/contract.rs
index a97bd3457b..d407070a8b 100644
--- a/fuel-vm/src/interpreter/contract.rs
+++ b/fuel-vm/src/interpreter/contract.rs
@@ -6,12 +6,10 @@ use super::{
         ProfileGas,
     },
     internal::{
-        append_receipt,
         external_asset_id_balance_sub,
         inc_pc,
         internal_contract,
         set_variable_output,
-        AppendReceipt,
     },
     memory::read_bytes,
     ExecutableTransaction,
@@ -316,15 +314,7 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             *self.is,
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset: self.tx_offset,
-                memory: self.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
@@ -388,15 +378,7 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             *self.is,
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset: self.tx_offset,
-                memory: self.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
diff --git a/fuel-vm/src/interpreter/executors/main.rs b/fuel-vm/src/interpreter/executors/main.rs
index e0b2fa011e..b02329fdb4 100644
--- a/fuel-vm/src/interpreter/executors/main.rs
+++ b/fuel-vm/src/interpreter/executors/main.rs
@@ -565,7 +565,7 @@ where
 
             let receipt = Receipt::script_result(status, gas_used);
 
-            self.append_receipt(receipt)?;
+            self.receipts.push(receipt)?;
 
             if program.is_debug() {
                 self.debugger_set_last_state(program);
@@ -626,6 +626,13 @@ where
             }
         }
     }
+
+    /// Update tx fields after execution
+    pub(crate) fn post_execute(&mut self) {
+        if let Some(script) = self.tx.as_script_mut() {
+            *script.receipts_root_mut() = self.receipts.root();
+        }
+    }
 }
 
 impl<S, Tx, Ecal> Interpreter<S, Tx, Ecal>
@@ -669,6 +676,7 @@ where
         tx: Checked<Tx>,
     ) -> Result<StateTransitionRef<'_, Tx>, InterpreterError<S::DataError>> {
         let state_result = self.init_script(tx).and_then(|_| self.run());
+        self.post_execute();
 
         #[cfg(feature = "profile-any")]
         {
diff --git a/fuel-vm/src/interpreter/executors/predicate.rs b/fuel-vm/src/interpreter/executors/predicate.rs
index daae911953..20864178f5 100644
--- a/fuel-vm/src/interpreter/executors/predicate.rs
+++ b/fuel-vm/src/interpreter/executors/predicate.rs
@@ -22,6 +22,7 @@ where
     Tx: ExecutableTransaction,
     Ecal: EcalHandler,
 {
+    /// Verify a predicate that has been initialized already
     pub(crate) fn verify_predicate(
         &mut self,
     ) -> Result<ProgramState, PredicateVerificationFailed> {
diff --git a/fuel-vm/src/interpreter/flow.rs b/fuel-vm/src/interpreter/flow.rs
index b7e8d1b2be..31de9d544a 100644
--- a/fuel-vm/src/interpreter/flow.rs
+++ b/fuel-vm/src/interpreter/flow.rs
@@ -26,13 +26,11 @@ use crate::{
             ProfileGas,
         },
         internal::{
-            append_receipt,
             current_contract,
             external_asset_id_balance_sub,
             inc_pc,
             internal_contract_or_default,
             set_frame_pointer,
-            AppendReceipt,
         },
         receipts::ReceiptsCtx,
         ExecutableTransaction,
@@ -69,7 +67,6 @@ use fuel_tx::{
     DependentCost,
     PanicReason,
     Receipt,
-    Script,
 };
 use fuel_types::{
     canonical::Serialize,
@@ -99,16 +96,11 @@ where
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?
                 .copied();
-        let tx_offset = self.tx_offset();
         let input = RetCtx {
-            append: AppendReceipt {
-                receipts: &mut self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset,
-                memory: &mut self.memory,
-            },
+            receipts: &mut self.receipts,
             frames: &mut self.frames,
             registers: &mut self.registers,
+            memory: &self.memory,
             context: &mut self.context,
             current_contract,
         };
@@ -119,16 +111,11 @@ where
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?
                 .copied();
-        let tx_offset = self.tx_offset();
         let input = RetCtx {
-            append: AppendReceipt {
-                receipts: &mut self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset,
-                memory: &mut self.memory,
-            },
             frames: &mut self.frames,
             registers: &mut self.registers,
+            memory: &mut self.memory,
+            receipts: &mut self.receipts,
             context: &mut self.context,
             current_contract,
         };
@@ -139,15 +126,8 @@ where
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())
                 .map_or_else(|_| Some(ContractId::zeroed()), Option::<&_>::copied);
-        let tx_offset = self.tx_offset();
-        let append = AppendReceipt {
-            receipts: &mut self.receipts,
-            script: self.tx.as_script_mut(),
-            tx_offset,
-            memory: &mut self.memory,
-        };
         revert(
-            append,
+            &mut self.receipts,
             current_contract,
             self.registers.pc(),
             self.registers.is(),
@@ -170,7 +150,8 @@ where
         };
         self.panic_context = PanicContext::None;
 
-        self.append_receipt(receipt)
+        self.receipts
+            .push(receipt)
             .expect("Appending a panic receipt cannot fail");
     }
 }
@@ -178,7 +159,8 @@ where
 struct RetCtx<'vm> {
     frames: &'vm mut Vec<CallFrame>,
     registers: &'vm mut [Word; VM_REGISTER_COUNT],
-    append: AppendReceipt<'vm>,
+    memory: &'vm [u8; MEM_SIZE],
+    receipts: &'vm mut ReceiptsCtx,
     context: &'vm mut Context,
     current_contract: Option<ContractId>,
 }
@@ -226,7 +208,7 @@ impl RetCtx<'_> {
             set_frame_pointer(context, registers.fp_mut(), fp);
         }
 
-        append_receipt(self.append, receipt)?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.registers.pc_mut())?)
     }
@@ -239,7 +221,7 @@ impl RetCtx<'_> {
             a,
             self.registers[RegId::PC],
             self.registers[RegId::IS],
-            self.append.memory[range.usizes()].to_vec(),
+            self.memory[range.usizes()].to_vec(),
         );
         let digest = *receipt
             .digest()
@@ -255,7 +237,7 @@ impl RetCtx<'_> {
 }
 
 pub(crate) fn revert(
-    append: AppendReceipt,
+    receipts: &mut ReceiptsCtx,
     current_contract: Option<ContractId>,
     pc: Reg<PC>,
     is: Reg<IS>,
@@ -268,7 +250,7 @@ pub(crate) fn revert(
         *is,
     );
 
-    append_receipt(append, receipt)
+    receipts.push(receipt)
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -411,8 +393,6 @@ where
             ),
             new_storage_gas_per_byte,
             receipts: &mut self.receipts,
-            script: self.tx.as_script_mut(),
-            tx_offset: 0,
             frames: &mut self.frames,
             current_contract,
             profiler: &mut self.profiler,
@@ -484,8 +464,6 @@ struct PrepareCallCtx<'vm, S, I> {
     storage: &'vm mut S,
     input_contracts: InputContracts<'vm, I>,
     receipts: &'vm mut ReceiptsCtx,
-    script: Option<&'vm mut Script>,
-    tx_offset: usize,
     frames: &'vm mut Vec<CallFrame>,
     current_contract: Option<ContractId>,
     profiler: &'vm mut Profiler,
@@ -638,15 +616,7 @@ where
             *self.registers.system_registers.is,
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.script,
-                tx_offset: self.tx_offset,
-                memory: self.memory.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         self.frames.push(frame);
 
diff --git a/fuel-vm/src/interpreter/flow/ret_tests.rs b/fuel-vm/src/interpreter/flow/ret_tests.rs
index 3801093ac4..5631273f65 100644
--- a/fuel-vm/src/interpreter/flow/ret_tests.rs
+++ b/fuel-vm/src/interpreter/flow/ret_tests.rs
@@ -156,12 +156,8 @@ fn input<'a>(
     RetCtx {
         frames,
         registers,
-        append: AppendReceipt {
-            receipts,
-            script: None,
-            tx_offset: 0,
-            memory,
-        },
+        receipts,
+        memory,
         context,
         current_contract: Default::default(),
     }
@@ -170,16 +166,9 @@ fn input<'a>(
 #[test]
 fn test_revert() {
     let mut receipts = Default::default();
-    let mut memory: Memory<MEM_SIZE> = vec![0u8; MEM_SIZE].try_into().unwrap();
-    let append = AppendReceipt {
-        receipts: &mut receipts,
-        script: None,
-        tx_offset: 0,
-        memory: &mut memory,
-    };
     let pc = 10;
     let is = 20;
-    revert(append, None, Reg::new(&pc), Reg::new(&is), 99).expect("should be ok");
+    revert(&mut receipts, None, Reg::new(&pc), Reg::new(&is), 99).expect("should be ok");
     assert_eq!(
         *receipts.as_ref().last().unwrap(),
         Receipt::revert(ContractId::default(), 99, pc, is)
diff --git a/fuel-vm/src/interpreter/flow/tests.rs b/fuel-vm/src/interpreter/flow/tests.rs
index 19a41a1743..2542785433 100644
--- a/fuel-vm/src/interpreter/flow/tests.rs
+++ b/fuel-vm/src/interpreter/flow/tests.rs
@@ -15,7 +15,7 @@ use crate::crypto;
 use fuel_storage::StorageAsMut;
 use fuel_tx::{
     field::ReceiptsRoot,
-    TxParameters,
+    Script,
 };
 use fuel_types::{
     canonical::Serialize,
@@ -336,7 +336,7 @@ fn test_prepare_call(input: Input) -> Result<Output, RuntimeError<Infallible>> {
         memory: mut mem,
         gas_cost,
         storage_contract,
-        mut script,
+        script,
     } = input;
     let mut registers = [0; VM_REGISTER_COUNT];
     let mut registers: PrepareCallRegisters = (&mut registers).into();
@@ -380,8 +380,6 @@ fn test_prepare_call(input: Input) -> Result<Output, RuntimeError<Infallible>> {
         input_contracts: InputContracts::new(input_contracts.iter(), &mut panic_context),
         new_storage_gas_per_byte: 0,
         receipts: &mut receipts,
-        script: script.as_mut(),
-        tx_offset: TxParameters::DEFAULT.tx_offset(),
         frames: &mut frames,
         current_contract,
         profiler: &mut Profiler::default(),
@@ -405,7 +403,6 @@ fn check_output(
             assert_eq!(e.receipts, r.receipts);
             assert_eq!(e.frames, r.frames);
             assert_eq!(e.context, r.context);
-            assert_eq!(e.script, r.script);
             match (e.memory, r.memory) {
                 (CheckMem::Check(e), CheckMem::Mem(r)) => {
                     for (i, bytes) in e {
diff --git a/fuel-vm/src/interpreter/initialization.rs b/fuel-vm/src/interpreter/initialization.rs
index cfdd03dfde..16f78a62b9 100644
--- a/fuel-vm/src/interpreter/initialization.rs
+++ b/fuel-vm/src/interpreter/initialization.rs
@@ -15,7 +15,6 @@ use crate::{
     prelude::RuntimeError,
     storage::InterpreterStorage,
 };
-
 use fuel_asm::RegId;
 use fuel_tx::field::ScriptGasLimit;
 use fuel_types::Word;
@@ -30,11 +29,12 @@ where
     /// Initialize the VM with a given transaction
     fn init_inner(
         &mut self,
-        tx: Tx,
+        mut tx: Tx,
         initial_balances: InitialBalances,
         runtime_balances: RuntimeBalances,
         gas_limit: Word,
     ) -> Result<(), RuntimeError<S::DataError>> {
+        tx.prepare_init_execute();
         self.tx = tx;
 
         self.initial_balances = initial_balances.clone();
@@ -79,12 +79,10 @@ where
     pub fn init_predicate(
         &mut self,
         context: Context,
-        mut tx: Tx,
+        tx: Tx,
         gas_limit: Word,
     ) -> Result<(), InterpreterError<S::DataError>> {
         self.context = context;
-        tx.prepare_init_predicate();
-
         let initial_balances: InitialBalances = Default::default();
         let runtime_balances = initial_balances.clone().try_into()?;
         Ok(self.init_inner(tx, initial_balances, runtime_balances, gas_limit)?)
@@ -110,8 +108,8 @@ where
 
         self.context = Context::Script { block_height };
 
-        let (mut tx, metadata): (Tx, Tx::Metadata) = checked.into();
-        tx.prepare_init_script();
+        let (tx, metadata): (Tx, Tx::Metadata) = checked.into();
+
         let gas_limit = tx
             .as_script()
             .map(|script| *script.script_gas_limit())
diff --git a/fuel-vm/src/interpreter/internal.rs b/fuel-vm/src/interpreter/internal.rs
index ab7ad92322..83b798b226 100644
--- a/fuel-vm/src/interpreter/internal.rs
+++ b/fuel-vm/src/interpreter/internal.rs
@@ -1,5 +1,4 @@
 use super::{
-    receipts::ReceiptsCtx,
     ExecutableTransaction,
     Interpreter,
     MemoryRange,
@@ -22,13 +21,8 @@ use fuel_asm::{
     RegId,
 };
 use fuel_tx::{
-    field::{
-        Outputs,
-        ReceiptsRoot,
-    },
+    field::Outputs,
     Output,
-    Receipt,
-    Script,
 };
 use fuel_types::{
     canonical::Serialize,
@@ -54,19 +48,6 @@ where
         let tx_offset = self.tx_offset();
         update_memory_output(&mut self.tx, &mut self.memory, tx_offset, idx)
     }
-
-    pub(crate) fn append_receipt(&mut self, receipt: Receipt) -> SimpleResult<()> {
-        let tx_offset = self.tx_offset();
-        append_receipt(
-            AppendReceipt {
-                receipts: &mut self.receipts,
-                script: self.tx.as_script_mut(),
-                tx_offset,
-                memory: &mut self.memory,
-            },
-            receipt,
-        )
-    }
 }
 
 /// Increase the variable output with a given asset ID. Modifies both the referenced tx
@@ -121,40 +102,6 @@ pub(crate) fn update_memory_output<Tx: ExecutableTransaction>(
     Ok(())
 }
 
-pub(crate) struct AppendReceipt<'vm> {
-    pub receipts: &'vm mut ReceiptsCtx,
-    pub script: Option<&'vm mut Script>,
-    pub tx_offset: usize,
-    pub memory: &'vm mut [u8; MEM_SIZE],
-}
-
-pub(crate) fn append_receipt(input: AppendReceipt, receipt: Receipt) -> SimpleResult<()> {
-    let AppendReceipt {
-        receipts,
-        script,
-        tx_offset,
-        memory,
-    } = input;
-    receipts.push(receipt)?;
-
-    if let Some(script) = script {
-        let offset = tx_offset + script.receipts_root_offset();
-
-        // TODO this generates logarithmic gas cost to the receipts count. This won't fit
-        // the linear monadic model and should be discussed. Maybe the receipts
-        // tree should have constant capacity so the gas cost is also constant to
-        // the maximum depth?
-        let root = receipts.root();
-        *script.receipts_root_mut() = root;
-
-        // Transaction memory space length is already checked on initialization so its
-        // guaranteed to fit
-        memory[offset..offset + Bytes32::LEN].copy_from_slice(&root[..]);
-    }
-
-    Ok(())
-}
-
 impl<S, Tx, Ecal> Interpreter<S, Tx, Ecal> {
     pub(crate) fn reserve_stack(&mut self, len: Word) -> Result<Word, PanicReason> {
         let (ssp, overflow) = self.registers[RegId::SSP].overflowing_add(len);
diff --git a/fuel-vm/src/interpreter/log.rs b/fuel-vm/src/interpreter/log.rs
index 01907af6b1..8e145f4012 100644
--- a/fuel-vm/src/interpreter/log.rs
+++ b/fuel-vm/src/interpreter/log.rs
@@ -1,9 +1,7 @@
 use super::{
     internal::{
-        append_receipt,
         inc_pc,
         internal_contract_or_default,
-        AppendReceipt,
     },
     receipts::ReceiptsCtx,
     ExecutableTransaction,
@@ -17,10 +15,7 @@ use crate::{
     error::SimpleResult,
 };
 
-use fuel_tx::{
-    Receipt,
-    Script,
-};
+use fuel_tx::Receipt;
 use fuel_types::Word;
 
 #[cfg(test)]
@@ -31,15 +26,12 @@ where
     Tx: ExecutableTransaction,
 {
     pub(crate) fn log(&mut self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
-        let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
         let input = LogInput {
             memory: &mut self.memory,
-            tx_offset,
             context: &self.context,
             receipts: &mut self.receipts,
-            script: self.tx.as_script_mut(),
             fp: fp.as_ref(),
             is: is.as_ref(),
             pc,
@@ -54,15 +46,12 @@ where
         c: Word,
         d: Word,
     ) -> SimpleResult<()> {
-        let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
         let input = LogInput {
             memory: &mut self.memory,
-            tx_offset,
             context: &self.context,
             receipts: &mut self.receipts,
-            script: self.tx.as_script_mut(),
             fp: fp.as_ref(),
             is: is.as_ref(),
             pc,
@@ -73,10 +62,8 @@ where
 
 struct LogInput<'vm> {
     memory: &'vm mut [u8; MEM_SIZE],
-    tx_offset: usize,
     context: &'vm Context,
     receipts: &'vm mut ReceiptsCtx,
-    script: Option<&'vm mut Script>,
     fp: Reg<'vm, FP>,
     is: Reg<'vm, IS>,
     pc: RegMut<'vm, PC>,
@@ -94,15 +81,7 @@ impl LogInput<'_> {
             *self.is,
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.script,
-                tx_offset: self.tx_offset,
-                memory: self.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
@@ -120,15 +99,7 @@ impl LogInput<'_> {
             self.memory[range.usizes()].to_vec(),
         );
 
-        append_receipt(
-            AppendReceipt {
-                receipts: self.receipts,
-                script: self.script,
-                tx_offset: self.tx_offset,
-                memory: self.memory,
-            },
-            receipt,
-        )?;
+        self.receipts.push(receipt)?;
 
         Ok(inc_pc(self.pc)?)
     }
diff --git a/fuel-vm/src/interpreter/log/tests.rs b/fuel-vm/src/interpreter/log/tests.rs
index d6ce9e1531..d066037c10 100644
--- a/fuel-vm/src/interpreter/log/tests.rs
+++ b/fuel-vm/src/interpreter/log/tests.rs
@@ -11,17 +11,14 @@ fn test_log() -> SimpleResult<()> {
         block_height: Default::default(),
     };
     let mut receipts = Default::default();
-    let mut script = Some(Script::default());
 
     let fp = 0;
     let is = 0;
     let mut pc = 4;
     let input = LogInput {
         memory: &mut memory,
-        tx_offset: 0,
         context: &context,
         receipts: &mut receipts,
-        script: script.as_mut(),
         fp: Reg::new(&fp),
         is: Reg::new(&is),
         pc: RegMut::new(&mut pc),
@@ -36,10 +33,8 @@ fn test_log() -> SimpleResult<()> {
 
     let input = LogInput {
         memory: &mut memory,
-        tx_offset: 0,
         context: &context,
         receipts: &mut receipts,
-        script: script.as_mut(),
         fp: Reg::new(&fp),
         is: Reg::new(&is),
         pc: RegMut::new(&mut pc),
diff --git a/fuel-vm/src/interpreter/metadata.rs b/fuel-vm/src/interpreter/metadata.rs
index 56981bc26a..a7ffc93043 100644
--- a/fuel-vm/src/interpreter/metadata.rs
+++ b/fuel-vm/src/interpreter/metadata.rs
@@ -22,7 +22,6 @@ use fuel_tx::{
     field::{
         BytecodeLength,
         BytecodeWitnessIndex,
-        ReceiptsRoot,
         Salt,
         Script as ScriptField,
         ScriptData,
@@ -322,36 +321,6 @@ impl<Tx> GTFInput<'_, Tx> {
                     .map(|(idx, _o)| idx)
                     .ok_or(PanicReason::InputNotFound)? as Word
             }
-            GTFArgs::InputContractBalanceRoot => {
-                (ofs + tx
-                    .inputs()
-                    .get(b)
-                    .filter(|i| i.is_contract())
-                    .map(Input::repr)
-                    .and_then(|r| r.contract_balance_root_offset())
-                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o + ofs))
-                    .ok_or(PanicReason::InputNotFound)?) as Word
-            }
-            GTFArgs::InputContractStateRoot => {
-                (ofs + tx
-                    .inputs()
-                    .get(b)
-                    .filter(|i| i.is_contract())
-                    .map(Input::repr)
-                    .and_then(|r| r.contract_state_root_offset())
-                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o + ofs))
-                    .ok_or(PanicReason::InputNotFound)?) as Word
-            }
-            GTFArgs::InputContractTxPointer => {
-                (ofs + tx
-                    .inputs()
-                    .get(b)
-                    .filter(|i| i.is_contract())
-                    .map(Input::repr)
-                    .and_then(|r| r.tx_pointer_offset())
-                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o + ofs))
-                    .ok_or(PanicReason::InputNotFound)?) as Word
-            }
             GTFArgs::InputContractId => {
                 (ofs + tx
                     .inputs()
@@ -502,26 +471,6 @@ impl<Tx> GTFInput<'_, Tx> {
                     .and_then(Output::input_index)
                     .ok_or(PanicReason::InputNotFound)? as Word
             }
-            GTFArgs::OutputContractBalanceRoot => {
-                (ofs + tx
-                    .outputs()
-                    .get(b)
-                    .filter(|o| o.is_contract())
-                    .map(Output::repr)
-                    .and_then(|r| r.contract_balance_root_offset())
-                    .and_then(|ofs| tx.outputs_offset_at(b).map(|o| o + ofs))
-                    .ok_or(PanicReason::OutputNotFound)?) as Word
-            }
-            GTFArgs::OutputContractStateRoot => {
-                (ofs + tx
-                    .outputs()
-                    .get(b)
-                    .filter(|o| o.is_contract())
-                    .map(Output::repr)
-                    .and_then(|r| r.contract_state_root_offset())
-                    .and_then(|ofs| tx.outputs_offset_at(b).map(|o| o + ofs))
-                    .ok_or(PanicReason::OutputNotFound)?) as Word
-            }
             GTFArgs::OutputContractCreatedContractId => {
                 (ofs + tx
                     .outputs()
@@ -569,9 +518,6 @@ impl<Tx> GTFInput<'_, Tx> {
                     (Some(script), None, GTFArgs::ScriptDataLength) => {
                         script.script_data().len() as Word
                     }
-                    (Some(script), None, GTFArgs::ScriptReceiptsRoot) => {
-                        (ofs + script.receipts_root_offset()) as Word
-                    }
                     (Some(script), None, GTFArgs::Script) => {
                         (ofs + script.script_offset()) as Word
                     }
diff --git a/fuel-vm/src/tests/metadata.rs b/fuel-vm/src/tests/metadata.rs
index 2544db05c5..a070ac9e5d 100644
--- a/fuel-vm/src/tests/metadata.rs
+++ b/fuel-vm/src/tests/metadata.rs
@@ -347,7 +347,6 @@ fn get_transaction_fields() {
     let asset_amt = 27;
 
     let tx = TransactionBuilder::script(vec![], vec![])
-        .prepare_script(true)
         .maturity(maturity)
         .with_gas_costs(gas_costs)
         .script_gas_limit(gas_limit)
@@ -395,10 +394,22 @@ fn get_transaction_fields() {
     let outputs = tx.as_ref().outputs();
     let witnesses = tx.as_ref().witnesses();
 
-    let inputs_bytes: Vec<Vec<u8>> =
-        inputs.iter().map(|i| i.clone().to_bytes()).collect();
-    let outputs_bytes: Vec<Vec<u8>> =
-        outputs.iter().map(|o| o.clone().to_bytes()).collect();
+    let inputs_bytes: Vec<Vec<u8>> = inputs
+        .iter()
+        .map(|v| {
+            let mut v = v.clone();
+            v.prepare_init_execute();
+            v.clone().to_bytes()
+        })
+        .collect();
+    let outputs_bytes: Vec<Vec<u8>> = outputs
+        .iter()
+        .map(|v| {
+            let mut v = *v;
+            v.prepare_init_execute();
+            v.clone().to_bytes()
+        })
+        .collect();
     let witnesses_bytes: Vec<Vec<u8>> =
         witnesses.iter().map(|w| w.clone().to_bytes()).collect();
 
@@ -432,8 +443,6 @@ fn get_transaction_fields() {
         outputs[1].balance_root().unwrap().to_vec(), // 21 - OutputContractBalanceRoot
         outputs[1].state_root().unwrap().to_vec(), // 22 - OutputContractStateRoot
         witnesses[1].as_ref().to_vec(), // 23 - WitnessData
-        inputs[0].tx_pointer().unwrap().clone().to_bytes(), // 24 - InputCoinTxPointer
-        inputs[2].tx_pointer().unwrap().clone().to_bytes(), // 25 - InputContractTxPointer
     ];
 
     // hardcoded metadata of script len so it can be checked at runtime
@@ -557,12 +566,8 @@ fn get_transaction_fields() {
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-        op::movi(0x19, 0x01),
-        op::gtf_args(0x10, 0x19, GTFArgs::ScriptReceiptsRoot),
-        op::movi(0x11, cases[3].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
+        // Skip over ReceiptsRoot which is always zero
+        op::addi(0x30, 0x30, cases[3].len().try_into().unwrap()),
 
         op::movi(0x11, script_offset as Immediate18),
         op::movi(0x19, 0x00),
@@ -582,12 +587,8 @@ fn get_transaction_fields() {
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-        op::movi(0x19, 0x00),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputCoinTxId),
-        op::movi(0x11, cases[4].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
+        // Skip over CoinTxId which is always zero
+        op::addi(0x30, 0x30, cases[4].len().try_into().unwrap()),
 
         op::movi(0x11, inputs[0].utxo_id().unwrap().output_index() as Immediate18),
         op::movi(0x19, 0x00),
@@ -650,39 +651,10 @@ fn get_transaction_fields() {
         op::add(0x30, 0x30, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-        op::movi(0x19, 0x01),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputCoinPredicateGasUsed),
-        op::movi(0x11, 0 as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x19, contract_input_index as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputContractTxId),
-        op::movi(0x11, cases[9].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x11, 0x01),
-        op::movi(0x19, contract_input_index as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputContractOutputIndex),
-        op::eq(0x10, 0x10, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x19, contract_input_index as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputContractBalanceRoot),
-        op::movi(0x11, cases[10].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x19, contract_input_index as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputContractStateRoot),
-        op::movi(0x11, cases[11].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
+        // Skip over always-zero InputContract fields
+        op::addi(0x30, 0x30, cases[9].len().try_into().unwrap()),
+        op::addi(0x30, 0x30, cases[10].len().try_into().unwrap()),
+        op::addi(0x30, 0x30, cases[11].len().try_into().unwrap()),
 
         op::movi(0x19, contract_input_index as Immediate18),
         op::gtf_args(0x10, 0x19, GTFArgs::InputContractId),
@@ -810,19 +782,9 @@ fn get_transaction_fields() {
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-        op::movi(0x19, 0x01),
-        op::gtf_args(0x10, 0x19, GTFArgs::OutputContractBalanceRoot),
-        op::movi(0x11, cases[21].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x19, 0x01),
-        op::gtf_args(0x10, 0x19, GTFArgs::OutputContractStateRoot),
-        op::movi(0x11, cases[22].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
+        // Sjip over always-zero OutputContract fields
+        op::addi(0x30, 0x30, cases[21].len().try_into().unwrap()),
+        op::addi(0x30, 0x30, cases[22].len().try_into().unwrap()),
 
         op::movi(0x11, witnesses[1].as_ref().len() as Immediate18),
         op::movi(0x19, 0x01),
@@ -837,20 +799,6 @@ fn get_transaction_fields() {
         op::add(0x30, 0x30, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-        op::movi(0x19, 0),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputCoinTxPointer),
-        op::movi(0x11, cases[24].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
-        op::movi(0x19, contract_input_index as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::InputContractTxPointer),
-        op::movi(0x11, cases[25].len() as Immediate18),
-        op::meq(0x10, 0x10, 0x30, 0x11),
-        op::add(0x30, 0x30, 0x11),
-        op::and(0x20, 0x20, 0x10),
-
         op::log(0x20, 0x00, 0x00, 0x00),
         op::ret(0x00)
     ].into_iter().collect();
diff --git a/fuel-vm/src/tests/validation.rs b/fuel-vm/src/tests/validation.rs
index ac41e151af..e5998cc167 100644
--- a/fuel-vm/src/tests/validation.rs
+++ b/fuel-vm/src/tests/validation.rs
@@ -1,5 +1,17 @@
-use fuel_asm::op;
-use fuel_tx::TransactionBuilder;
+use core::str::FromStr;
+use fuel_asm::{
+    op,
+    RegId,
+};
+use fuel_tx::{
+    field::{
+        Inputs,
+        ReceiptsRoot,
+    },
+    input::coin::CoinSigned,
+    ConsensusParameters,
+    TransactionBuilder,
+};
 use fuel_types::BlockHeight;
 use fuel_vm::prelude::*;
 use rand::{
@@ -8,6 +20,11 @@ use rand::{
     SeedableRng,
 };
 
+#[cfg(feature = "alloc")]
+use alloc::vec;
+
+use crate::consts::WORD_SIZE;
+
 #[test]
 fn transaction_can_be_executed_after_maturity() {
     const MATURITY: BlockHeight = BlockHeight::new(1);
@@ -36,3 +53,116 @@ fn transaction_can_be_executed_after_maturity() {
         .execute_tx(tx);
     assert!(result.is_ok());
 }
+
+/// Malleable fields should not affect validity of the block
+#[test]
+fn malleable_fields_do_not_affect_validity() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let params = ConsensusParameters::default();
+
+    let tx_size_ptr =
+        32 + (params.tx_params.max_inputs as usize * (AssetId::LEN + WORD_SIZE));
+    let tx_start_ptr = tx_size_ptr + 8;
+
+    let tx = TransactionBuilder::script(
+        vec![
+            // Log tx id (hash)
+            op::movi(0x21, 32),
+            op::logd(0x00, 0x00, 0x00, 0x21),
+            // Load tx size
+            op::movi(0x21, tx_size_ptr as u32),
+            op::lw(0x21, 0x21, 0),
+            // Make heap space for tx bytes, chain_id and computed tx hash
+            op::addi(0x22, 0x21, 8 + 32),
+            op::aloc(0x22),
+            // Construct the chain_id and tx bytes for hashing
+            op::addi(0x22, RegId::HP, 32), // Chain id position
+            op::gtf_args(0x20, 0x00, GTFArgs::ScriptData),
+            op::mcpi(0x22, 0x20, 8), // Copy chain id
+            op::movi(0x20, tx_start_ptr as u32),
+            op::addi(0x23, 0x22, 8),   // Tx bytes position
+            op::mcp(0x23, 0x20, 0x21), // Copy tx bytes
+            // Assert that there is exactly one witness
+            op::gtf_args(0x26, 0x00, GTFArgs::ScriptWitnessesCount),
+            op::eq(0x26, 0x26, RegId::ONE),
+            op::jnzf(0x26, 0x00, 1),
+            op::ret(0),
+            // Zero out the only witness (in the heap)
+            op::gtf_args(0x26, 0x00, GTFArgs::WitnessData),
+            op::gtf_args(0x27, 0x00, GTFArgs::WitnessDataLength),
+            op::sub(0x27, 0x26, 0x20), // Offset in relative to the tx bytes
+            op::add(0x27, 0x27, RegId::HP), // Redirect the pointer to heap
+            op::addi(0x26, 0x27, 32 + 8), // Offset of tx bytes in heap
+            op::gtf_args(0x27, 0x00, GTFArgs::WitnessDataLength),
+            op::mcl(0x26, 0x27),
+            // Zero out witness count
+            op::gtf_args(0x26, 0x00, GTFArgs::Script),
+            op::sub(0x26, 0x26, 32 + 8), // Offset to get the witness count address
+            op::add(0x26, 0x26, RegId::HP), // Redirect the pointer to heap
+            op::sub(0x26, 0x26, 0x20),   // Offset in relative to the tx bytes
+            op::sw(0x26, RegId::ZERO, 0), // Zero out the witness count
+            // Actually hash
+            op::subi(0x24, 0x21, 64 + 8 - 8), // Offset ptr
+            op::s256(RegId::HP, 0x22, 0x24),  // Compute tx id hash
+            op::movi(0x25, 32),               // Hash size
+            op::logd(0x00, 0x00, RegId::HP, 0x25), // Log computed txid
+            op::logd(0, 0, 0x22, 0x24),
+            // Done
+            op::ret(0x00),
+        ]
+        .into_iter()
+        .collect(),
+        params.chain_id.to_be_bytes().to_vec(),
+    )
+    .add_unsigned_coin_input(
+        SecretKey::random(rng),
+        UtxoId::new([3; 32].into(), 0),
+        123456789,
+        AssetId::default(),
+        Default::default(),
+    )
+    .script_gas_limit(1_000_000)
+    .finalize();
+
+    let run_tx = |tx: Script| {
+        let original_id = tx.id(&params.chain_id);
+
+        let vm = Interpreter::<_, Script>::with_memory_storage();
+        let mut client = MemoryClient::from_txtor(vm.into());
+        let receipts =
+            client.transact(tx.into_checked(0u32.into(), &params, 0).expect("valid tx"));
+
+        let start_id = receipts[0].data().unwrap();
+        let computed_id = receipts[1].data().unwrap();
+
+        assert_eq!(*original_id, start_id);
+        assert_eq!(*original_id, computed_id);
+
+        original_id
+    };
+
+    let original = run_tx(tx.clone());
+
+    // Check that modifying the input coin doesn't affect validity
+    {
+        let mut tx = tx.clone();
+
+        match tx.inputs_mut()[0] {
+            Input::CoinSigned(CoinSigned {
+                ref mut tx_pointer, ..
+            }) => *tx_pointer = TxPointer::from_str("123456780001").unwrap(),
+            _ => unreachable!(),
+        };
+        let result = run_tx(tx);
+        assert_eq!(result, original);
+    }
+
+    // Check that modifying the receipts root doesn't affect validity
+    {
+        let mut tx = tx;
+        *tx.receipts_root_mut() = [1u8; 32].into();
+        let result = run_tx(tx);
+        assert_eq!(result, original);
+    }
+}
diff --git a/fuel-vm/src/util.rs b/fuel-vm/src/util.rs
index 78191ee8c9..6824441025 100644
--- a/fuel-vm/src/util.rs
+++ b/fuel-vm/src/util.rs
@@ -121,7 +121,10 @@ pub mod test_helpers {
         RegId,
     };
     use fuel_tx::{
-        field::Outputs,
+        field::{
+            Outputs,
+            ReceiptsRoot,
+        },
         ConsensusParameters,
         Contract,
         ContractParameters,
@@ -476,7 +479,12 @@ pub mod test_helpers {
             let tx_offset = self.get_tx_params().tx_offset();
             let mut tx_mem =
                 &interpreter.memory()[tx_offset..(tx_offset + transaction.size())];
-            let deser_tx = Transaction::decode(&mut tx_mem).unwrap();
+            let mut deser_tx = Transaction::decode(&mut tx_mem).unwrap();
+
+            // Patch the tx with correct receipts root
+            if let Transaction::Script(ref mut s) = deser_tx {
+                *s.receipts_root_mut() = interpreter.compute_receipts_root();
+            }
 
             assert_eq!(deser_tx, transaction);
             if is_reverted {