From 5d4f9fe98471b32f20f81450e29a5636aaaae9c5 Mon Sep 17 00:00:00 2001
From: Mitchell Turner <james.mitchell.turner@gmail.com>
Date: Thu, 29 Feb 2024 00:50:26 -0800
Subject: [PATCH] Use max fee policy to charge user (#685)

* refactor hard-to-read function

* WIP

* Remove comments

* Remove fee checks, fmt

* Remove `gas_price` from check

* Get tests compiling but not passing

* Replace limit tests with exists tests

* Break down `create` tests, fix those tests

* Break down `script` tests, fix those tests

* Fix broken tx tests

* Fix warnings

* Fix `run_script` to incude `max_fee`

* WIP

* WIP

* Take ref and clone instead of mut in finalize

* Modify test builder to have default max_fee_limit of 0

* Fix input tests

* WIP fixing tests

* Finish reconciling merge

* Fix `blockchain` tests

* Fix setup function for many tests

* Fix metadata tests

* Fix predicate tests

* Fix interpreter tests

* Fix a bunch of simpler tests

* cargo +nightly fmt

* Add `Immutable` type for txs

* Fix more tests

* Add comments to `Immutable`

* Remove setting of the max limit everywhere and removed unsuded variables

* WIP

* Something else

* Fixed the test `into_checked__tx_fails_when_provided_fees_dont_cover_byte_costs`

* Minimized number of modifications

* Added getter for the `gas_price`

* Fixed several tests

* Fix more tests

* Use `Immutable` in transact

* Fix warnings

* Rename types and functions

* Update CHANGELOG

* Appease Clippy-sama

* Fix bad import

* Revert "Rename types and functions"

This reverts commit 25f44120f0baff4e1dee2ab69fe699e9d3bdb358.

* Rename `Immutable` to `Ready`

* Add test for verifying `Ready` txs

* Update CHANGELOG.md

Co-authored-by: Brandon Kite <brandonkite92@gmail.com>

* Improve tests, change `decompose` method

* Add `deploy` test for checking `Ready`

* Use `CheckError` instead of the `TransactionValidity`

* Updated CHANGELOG.md

---------

Co-authored-by: xgreenx <xgreenx9999@gmail.com>
Co-authored-by: Brandon Kite <brandonkite92@gmail.com>
---
 CHANGELOG.md                                  |   4 +
 fuel-tx/src/builder.rs                        |  32 +-
 fuel-tx/src/tests/valid_cases/input.rs        |  56 +-
 fuel-tx/src/tests/valid_cases/transaction.rs  | 340 ++++++++----
 fuel-tx/src/transaction.rs                    |   6 +
 fuel-tx/src/transaction/policies.rs           |   5 +
 fuel-tx/src/transaction/types/create.rs       |  23 +-
 fuel-tx/src/transaction/types/mint.rs         |  19 +-
 fuel-tx/src/transaction/types/script.rs       |   3 +-
 fuel-tx/src/transaction/validity.rs           |  20 +-
 fuel-tx/src/transaction/validity/error.rs     |   2 +-
 fuel-tx/test-helpers/src/lib.rs               |   2 +-
 fuel-vm/examples/external.rs                  |   9 +-
 fuel-vm/src/checked_transaction.rs            | 517 ++++++++++--------
 fuel-vm/src/checked_transaction/balances.rs   |  59 +-
 fuel-vm/src/checked_transaction/builder.rs    |  20 +-
 fuel-vm/src/checked_transaction/types.rs      |  37 +-
 fuel-vm/src/error.rs                          |  40 +-
 fuel-vm/src/interpreter/debug.rs              |  25 +-
 .../instruction/tests/reserved_registers.rs   |  18 +-
 fuel-vm/src/interpreter/executors/main.rs     |  43 +-
 .../src/interpreter/executors/main/tests.rs   | 101 +++-
 fuel-vm/src/interpreter/initialization.rs     |   5 +-
 fuel-vm/src/interpreter/internal/tests.rs     |  30 +-
 fuel-vm/src/interpreter/memory/tests.rs       |  76 +--
 fuel-vm/src/predicate.rs                      |   9 +-
 fuel-vm/src/tests/blockchain.rs               |  58 +-
 fuel-vm/src/tests/code_coverage.rs            |   3 +-
 fuel-vm/src/tests/contract.rs                 |   7 +-
 fuel-vm/src/tests/crypto.rs                   |  36 +-
 fuel-vm/src/tests/external.rs                 |   8 +-
 fuel-vm/src/tests/gas_factor.rs               |  22 +-
 fuel-vm/src/tests/memory.rs                   |   4 +-
 fuel-vm/src/tests/metadata.rs                 |  31 +-
 fuel-vm/src/tests/outputs.rs                  |   9 +-
 fuel-vm/src/tests/predicate.rs                |  66 +--
 fuel-vm/src/tests/profile_gas.rs              |   7 +-
 fuel-vm/src/tests/test_helpers.rs             |  19 +-
 fuel-vm/src/tests/validation.rs               |   9 +-
 fuel-vm/src/transactor.rs                     |  55 +-
 fuel-vm/src/util.rs                           |  26 +-
 41 files changed, 1139 insertions(+), 722 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5bee6a315b..a0c8423ffc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 #### Breaking
 
+- [#685](https://github.com/FuelLabs/fuel-vm/pull/685):
+  The `MaxFee` is a mandatory policy to set. The `MaxFee` policy is used to check that the transaction is valid. 
+  Added a new stage for the `Checked` transaction - `Ready`. This type can be constructed with the 
+  `gas_price` before being transacted by the `Interpreter`.
 - [#671](https://github.com/FuelLabs/fuel-vm/pull/671): Support dynamically sized values in the ContractsState table by using a vector data type (`Vec<u8>`).
 - [#682](https://github.com/FuelLabs/fuel-vm/pull/682): Include `Tip` policy in fee calculation
 - [#683](https://github.com/FuelLabs/fuel-vm/pull/683): Simplify `InterpreterStorage` by removing dependency on `MerkleRootStorage` and removing `merkle_` prefix from method names.
diff --git a/fuel-tx/src/builder.rs b/fuel-tx/src/builder.rs
index 1d57ce9a87..b5ac614c44 100644
--- a/fuel-tx/src/builder.rs
+++ b/fuel-tx/src/builder.rs
@@ -96,7 +96,9 @@ impl<T> BuildableAloc for T where
 }
 
 impl<T> BuildableStd for T where T: Signable + Cacheable {}
+
 impl<T> BuildableSet for T where T: BuildableAloc + BuildableStd {}
+
 impl<T> Buildable for T where T: BuildableSet {}
 
 #[derive(Debug, Clone)]
@@ -117,7 +119,7 @@ impl TransactionBuilder<Script> {
             script_gas_limit: Default::default(),
             script,
             script_data,
-            policies: Policies::new(),
+            policies: Policies::new().with_max_fee(0),
             inputs: Default::default(),
             outputs: Default::default(),
             witnesses: Default::default(),
@@ -141,7 +143,7 @@ impl TransactionBuilder<Create> {
             bytecode_witness_index: Default::default(),
             salt,
             storage_slots,
-            policies: Policies::new(),
+            policies: Policies::new().with_max_fee(0),
             inputs: Default::default(),
             outputs: Default::default(),
             witnesses: Default::default(),
@@ -412,8 +414,8 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         *witness_index
     }
 
-    fn finalize_inner(&mut self) -> Tx {
-        let mut tx = core::mem::take(&mut self.tx);
+    fn finalize_inner(&self) -> Tx {
+        let mut tx = self.tx.clone();
 
         self.sign_keys
             .iter()
@@ -425,8 +427,8 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         tx
     }
 
-    pub fn finalize_without_signature_inner(&mut self) -> Tx {
-        let mut tx = core::mem::take(&mut self.tx);
+    pub fn finalize_without_signature_inner(&self) -> Tx {
+        let mut tx = self.tx.clone();
 
         tx.precompute(&self.get_chain_id())
             .expect("Should be able to calculate cache");
@@ -443,40 +445,40 @@ impl<Tx: field::Outputs> TransactionBuilder<Tx> {
 }
 
 pub trait Finalizable<Tx> {
-    fn finalize(&mut self) -> Tx;
+    fn finalize(&self) -> Tx;
 
-    fn finalize_without_signature(&mut self) -> Tx;
+    fn finalize_without_signature(&self) -> Tx;
 }
 
 impl Finalizable<Mint> for TransactionBuilder<Mint> {
-    fn finalize(&mut self) -> Mint {
-        let mut tx = core::mem::take(&mut self.tx);
+    fn finalize(&self) -> Mint {
+        let mut tx = self.tx.clone();
         tx.precompute(&self.get_chain_id())
             .expect("Should be able to calculate cache");
         tx
     }
 
-    fn finalize_without_signature(&mut self) -> Mint {
+    fn finalize_without_signature(&self) -> Mint {
         self.finalize()
     }
 }
 
 impl Finalizable<Create> for TransactionBuilder<Create> {
-    fn finalize(&mut self) -> Create {
+    fn finalize(&self) -> Create {
         self.finalize_inner()
     }
 
-    fn finalize_without_signature(&mut self) -> Create {
+    fn finalize_without_signature(&self) -> Create {
         self.finalize_without_signature_inner()
     }
 }
 
 impl Finalizable<Script> for TransactionBuilder<Script> {
-    fn finalize(&mut self) -> Script {
+    fn finalize(&self) -> Script {
         self.finalize_inner()
     }
 
-    fn finalize_without_signature(&mut self) -> Script {
+    fn finalize_without_signature(&self) -> Script {
         self.finalize_without_signature_inner()
     }
 }
diff --git a/fuel-tx/src/tests/valid_cases/input.rs b/fuel-tx/src/tests/valid_cases/input.rs
index 7e0e78025f..95941dd416 100644
--- a/fuel-tx/src/tests/valid_cases/input.rs
+++ b/fuel-tx/src/tests/valid_cases/input.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::cast_possible_truncation)]
+
 use super::PREDICATE_PARAMS;
 
 use fuel_crypto::{
@@ -139,9 +140,7 @@ fn input_coin_message_signature() {
 #[test]
 fn coin_signed() {
     let rng = &mut StdRng::seed_from_u64(8586);
-    let arb_gas_price = 1;
-
-    let mut tx = Script::default();
+    let mut tx = TransactionBuilder::script(vec![], vec![]).finalize();
 
     let input =
         Input::coin_signed(rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen(), 0);
@@ -149,11 +148,7 @@ fn coin_signed() {
 
     let block_height = rng.gen();
     let err = tx
-        .check(
-            block_height,
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check(block_height, &ConsensusParameters::standard())
         .expect_err("Expected failure");
 
     assert_eq!(ValidityError::InputWitnessIndexBounds { index: 0 }, err);
@@ -164,7 +159,6 @@ fn duplicate_secrets_reuse_witness() {
     let rng = &mut StdRng::seed_from_u64(10000);
     let key = SecretKey::random(rng);
 
-    // verify witness reuse for script txs
     let script = TransactionBuilder::script(vec![], vec![])
         // coin 1
         .add_unsigned_coin_input(key, rng.gen(), 100, Default::default(), Default::default())
@@ -326,8 +320,6 @@ fn contract() {
 #[test]
 fn message_metadata() {
     let rng = &mut StdRng::seed_from_u64(8586);
-    let arb_gas_price = 1;
-
     let txhash: Bytes32 = rng.gen();
 
     let predicate = generate_nonempty_padded_bytes(rng);
@@ -346,7 +338,7 @@ fn message_metadata() {
     .check(1, &txhash, &[], &[], &Default::default(), &mut None)
     .expect("failed to validate empty message input");
 
-    let mut tx = Script::default();
+    let mut tx = TransactionBuilder::script(vec![], vec![]).finalize();
 
     let input = Input::message_data_signed(
         rng.gen(),
@@ -364,11 +356,7 @@ fn message_metadata() {
 
     let block_height = rng.gen();
     let err = tx
-        .check(
-            block_height,
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check(block_height, &ConsensusParameters::standard())
         .expect_err("Expected failure");
 
     assert_eq!(ValidityError::InputWitnessIndexBounds { index: 0 }, err,);
@@ -468,9 +456,6 @@ fn message_metadata() {
 #[test]
 fn message_message_coin() {
     let rng = &mut StdRng::seed_from_u64(8586);
-
-    let arb_gas_price = 1;
-
     let txhash: Bytes32 = rng.gen();
 
     let predicate = generate_nonempty_padded_bytes(rng);
@@ -488,18 +473,14 @@ fn message_message_coin() {
     .check(1, &txhash, &[], &[], &Default::default(), &mut None)
     .expect("failed to validate empty message input");
 
-    let mut tx = Script::default();
+    let mut tx = TransactionBuilder::script(vec![], vec![]).finalize();
 
     let input = Input::message_coin_signed(rng.gen(), rng.gen(), rng.gen(), rng.gen(), 0);
     tx.add_input(input);
 
     let block_height = rng.gen();
     let err = tx
-        .check(
-            block_height,
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check(block_height, &ConsensusParameters::standard())
         .expect_err("Expected failure");
 
     assert_eq!(ValidityError::InputWitnessIndexBounds { index: 0 }, err,);
@@ -560,7 +541,6 @@ fn message_message_coin() {
 fn transaction_with_duplicate_coin_inputs_is_invalid() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let utxo_id = rng.gen();
-    let arb_gas_price = 1;
 
     let a = Input::coin_signed(utxo_id, rng.gen(), rng.gen(), rng.gen(), rng.gen(), 0);
     let b = Input::coin_signed(utxo_id, rng.gen(), rng.gen(), rng.gen(), rng.gen(), 0);
@@ -570,11 +550,7 @@ fn transaction_with_duplicate_coin_inputs_is_invalid() {
         .add_input(b)
         .add_witness(rng.gen())
         .finalize()
-        .check_without_signatures(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check_without_signatures(Default::default(), &ConsensusParameters::standard())
         .expect_err("Expected checkable failure");
 
     assert_eq!(err, ValidityError::DuplicateInputUtxoId { utxo_id });
@@ -583,7 +559,6 @@ fn transaction_with_duplicate_coin_inputs_is_invalid() {
 #[test]
 fn transaction_with_duplicate_message_inputs_is_invalid() {
     let rng = &mut StdRng::seed_from_u64(8586);
-    let arb_gas_price = 1;
     let message_input = Input::message_data_signed(
         rng.gen(),
         rng.gen(),
@@ -612,7 +587,6 @@ fn transaction_with_duplicate_message_inputs_is_invalid() {
         .check_without_signatures(
             Default::default(),
             &ConsensusParameters::standard(),
-            arb_gas_price,
         )
         .expect_err("Expected checkable failure");
 
@@ -622,7 +596,6 @@ fn transaction_with_duplicate_message_inputs_is_invalid() {
 #[test]
 fn transaction_with_duplicate_contract_inputs_is_invalid() {
     let rng = &mut StdRng::seed_from_u64(8586);
-    let arb_gas_price = 1;
     let contract_id = rng.gen();
     let fee = Input::coin_signed(
         rng.gen(),
@@ -646,11 +619,7 @@ fn transaction_with_duplicate_contract_inputs_is_invalid() {
         .add_output(o)
         .add_output(p)
         .finalize()
-        .check_without_signatures(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check_without_signatures(Default::default(), &ConsensusParameters::standard())
         .expect_err("Expected checkable failure");
 
     assert_eq!(err, ValidityError::DuplicateInputContractId { contract_id });
@@ -660,7 +629,6 @@ fn transaction_with_duplicate_contract_inputs_is_invalid() {
 fn transaction_with_duplicate_contract_utxo_id_is_valid() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let input_utxo_id: UtxoId = rng.gen();
-    let arb_gas_price = 1;
 
     let a = Input::contract(input_utxo_id, rng.gen(), rng.gen(), rng.gen(), rng.gen());
     let b = Input::contract(input_utxo_id, rng.gen(), rng.gen(), rng.gen(), rng.gen());
@@ -678,10 +646,6 @@ fn transaction_with_duplicate_contract_utxo_id_is_valid() {
         .add_output(p)
         .add_witness(rng.gen())
         .finalize()
-        .check_without_signatures(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            arb_gas_price,
-        )
+        .check_without_signatures(Default::default(), &ConsensusParameters::standard())
         .expect("Duplicated UTXO id is valid for contract input");
 }
diff --git a/fuel-tx/src/tests/valid_cases/transaction.rs b/fuel-tx/src/tests/valid_cases/transaction.rs
index 3324c0714d..868cdef02a 100644
--- a/fuel-tx/src/tests/valid_cases/transaction.rs
+++ b/fuel-tx/src/tests/valid_cases/transaction.rs
@@ -1,4 +1,6 @@
 #![allow(clippy::cast_possible_truncation)]
+#![allow(non_snake_case)]
+
 use super::{
     test_params,
     CHAIN_ID,
@@ -7,7 +9,11 @@ use super::{
     TX_PARAMS,
 };
 use crate::{
-    policies::Policies,
+    policies::{
+        Policies,
+        PolicyType,
+    },
+    transaction::field::Policies as PoliciesField,
     *,
 };
 use core::cmp;
@@ -34,32 +40,30 @@ fn gas_limit() {
     let maturity = 100.into();
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
-
     TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate transaction");
 
     TransactionBuilder::create(vec![0xfau8].into(), rng.gen(), vec![])
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate transaction");
 
     let err = Transaction::script(
         TX_PARAMS.max_gas_per_tx + 1,
         generate_bytes(rng),
         generate_bytes(rng),
-        Policies::new(),
+        Policies::new().with_max_fee(0),
         vec![],
         vec![],
         vec![],
     )
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionMaxGasExceeded, err);
@@ -70,63 +74,61 @@ fn maturity() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
     let block_height = 1000.into();
-    let arb_gas_price = 1;
 
     TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .maturity(block_height)
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate script");
 
     TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
         .maturity(block_height)
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate tx create");
 
     let err = Transaction::script(
         Default::default(),
         vec![],
         vec![],
-        Policies::new().with_maturity(1001.into()),
+        Policies::new().with_maturity(1001.into()).with_max_fee(0),
         vec![],
         vec![],
         vec![],
     )
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionMaturity, err);
 
     let err = Transaction::create(
         0,
-        Policies::new().with_maturity(1001.into()),
+        Policies::new().with_maturity(1001.into()).with_max_fee(0),
         rng.gen(),
         vec![],
         vec![],
         vec![],
         vec![rng.gen()],
     )
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionMaturity, err);
 }
 
 #[test]
-fn script_not_set_witness_limit_success() {
+fn script__check__not_set_witness_limit_success() {
     // Given
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
-    let arb_gas_price = 1;
 
     // When
     let result = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
@@ -138,25 +140,23 @@ fn create_not_set_witness_limit_success() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
     let bytecode = vec![];
-    let arb_gas_price = 1;
 
     // When
     let result = TransactionBuilder::create(bytecode.clone().into(), rng.gen(), vec![])
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
 }
 
 #[test]
-fn script_set_witness_limit_for_empty_witness_success() {
+fn script__check__set_witness_limit_for_empty_witness_success() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
     // Given
     let limit = Signature::LEN /* witness from random fee */ + vec![0u8; 0].size_static();
 
@@ -165,7 +165,7 @@ fn script_set_witness_limit_for_empty_witness_success() {
         .add_random_fee_input()
         .witness_limit(limit as u64)
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
@@ -177,7 +177,6 @@ fn script_set_witness_limit_less_than_witness_data_size_fails() {
 
     let block_height = 1000.into();
     let witness_size = Signature::LEN + vec![0u8; 0].size_static();
-    let arb_gas_price = 1;
 
     // Given
     let limit = witness_size - 1;
@@ -187,7 +186,7 @@ fn script_set_witness_limit_less_than_witness_data_size_fails() {
         .add_random_fee_input()
         .witness_limit(limit as u64)
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     // Then
@@ -200,7 +199,6 @@ fn create_set_witness_limit_for_empty_witness_success() {
 
     let block_height = 1000.into();
     let bytecode = vec![];
-    let arb_gas_price = 1;
     // Given
     let limit = Signature::LEN /* witness from random fee */ + bytecode.size_static() + bytecode.size_static();
 
@@ -209,7 +207,7 @@ fn create_set_witness_limit_for_empty_witness_success() {
         .add_random_fee_input()
         .witness_limit(limit as u64)
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
@@ -221,7 +219,6 @@ fn create_set_witness_limit_less_than_witness_data_size_fails() {
 
     let block_height = 1000.into();
     let bytecode = vec![];
-    let arb_gas_price = 1;
     // Given
     let limit = Signature::LEN /* witness from random fee */ + bytecode.size_static() + bytecode.size_static();
 
@@ -230,7 +227,7 @@ fn create_set_witness_limit_less_than_witness_data_size_fails() {
         .add_random_fee_input()
         .witness_limit(limit as u64 - 1)
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     // Then
@@ -242,37 +239,35 @@ fn script_not_set_max_fee_limit_success() {
     // Given
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
-    let arb_gas_price = 1;
 
     // When
     let result = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
 }
 
 #[test]
-fn script_set_max_fee_limit_fails() {
+fn script__check__no_max_fee_fails() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
     // Given
-    let max_fee = 0;
+    let mut tx = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .add_random_fee_input()
+        .finalize();
+    tx.policies_mut().set(PolicyType::MaxFee, None);
 
     // When
-    let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
-        .max_fee_limit(max_fee)
-        .add_random_fee_input()
-        .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+    let err = tx
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     // Then
-    assert_eq!(ValidityError::TransactionMaxFeeLimitExceeded, err);
+    assert_eq!(ValidityError::TransactionMaxFeeNotSet, err);
 }
 
 #[test]
@@ -281,37 +276,34 @@ fn create_not_set_max_fee_limit_success() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
-
     // When
     let result = TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
         .add_random_fee_input()
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price);
+        .check(block_height, &test_params());
 
     // Then
     assert!(result.is_ok());
 }
 
 #[test]
-fn create_set_max_fee_limit_fails() {
+fn create__check__no_max_fee_fails() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
     // Given
-    let max_fee = 0;
+    let mut tx = TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
+        .add_random_fee_input()
+        .finalize();
+    tx.policies_mut().set(PolicyType::MaxFee, None);
 
     // When
-    let err = TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
-        .max_fee_limit(max_fee)
-        .add_random_fee_input()
-        .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+    let err = tx
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     // Then
-    assert_eq!(ValidityError::TransactionMaxFeeLimitExceeded, err);
+    assert_eq!(ValidityError::TransactionMaxFeeNotSet, err);
 }
 
 #[test]
@@ -321,8 +313,6 @@ fn max_iow() {
     let maturity = 100.into();
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
-
     let secret = SecretKey::random(rng);
 
     let mut builder =
@@ -348,7 +338,7 @@ fn max_iow() {
 
     builder
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate transaction");
 
     // Add inputs up to maximum and validate
@@ -378,7 +368,7 @@ fn max_iow() {
 
     builder
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate transaction");
 
     // Overflow maximum inputs and expect error
@@ -406,7 +396,7 @@ fn max_iow() {
 
     let err = builder
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionInputsMax, err);
@@ -436,7 +426,7 @@ fn max_iow() {
 
     let err = builder
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionOutputsMax, err);
@@ -466,7 +456,7 @@ fn max_iow() {
 
     let err = builder
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionWitnessesMax, err);
@@ -476,8 +466,6 @@ fn max_iow() {
 fn output_change_asset_id() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
-    let arb_gas_price = 1;
-
     let maturity = 100.into();
     let block_height = 1000.into();
 
@@ -494,7 +482,7 @@ fn output_change_asset_id() {
         .add_output(Output::change(rng.gen(), rng.next_u64(), a))
         .add_output(Output::change(rng.gen(), rng.next_u64(), b))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate transaction");
 
     let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
@@ -504,7 +492,7 @@ fn output_change_asset_id() {
         .add_output(Output::change(rng.gen(), rng.next_u64(), a))
         .add_output(Output::change(rng.gen(), rng.next_u64(), a))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
@@ -519,7 +507,7 @@ fn output_change_asset_id() {
         .add_output(Output::change(rng.gen(), rng.next_u64(), a))
         .add_output(Output::change(rng.gen(), rng.next_u64(), c))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert!(matches!(
@@ -534,7 +522,7 @@ fn output_change_asset_id() {
         .add_output(Output::coin(rng.gen(), rng.next_u64(), a))
         .add_output(Output::coin(rng.gen(), rng.next_u64(), c))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert!(matches!(
@@ -544,11 +532,9 @@ fn output_change_asset_id() {
 }
 
 #[test]
-fn script() {
+fn script__check__happy_path() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
-    let arb_gas_price = 1;
-
     let maturity = 100.into();
     let block_height = 1000.into();
 
@@ -563,8 +549,19 @@ fn script() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen())
     .add_output(Output::change(rng.gen(), rng.gen(), asset_id))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect("Failed to validate transaction");
+}
+
+#[test]
+fn script__check__cannot_create_contract() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let asset_id: AssetId = rng.gen();
 
     let err = TransactionBuilder::script(
         vec![0xfa; SCRIPT_PARAMS.max_script_length as usize],
@@ -574,13 +571,24 @@ fn script() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen())
     .add_output(Output::contract_created(rng.gen(), rng.gen()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         ValidityError::TransactionScriptOutputContractCreated { index: 0 },
         err
     );
+}
+
+#[test]
+fn script__check__errors_if_script_too_long() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let asset_id: AssetId = rng.gen();
 
     let err = TransactionBuilder::script(
         vec![0xfa; 1 + SCRIPT_PARAMS.max_script_length as usize],
@@ -590,10 +598,21 @@ fn script() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen())
     .add_output(Output::contract_created(rng.gen(), rng.gen()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionScriptLength, err);
+}
+
+#[test]
+fn script__check__errors_if_script_data_too_long() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let asset_id: AssetId = rng.gen();
 
     let err = TransactionBuilder::script(
         vec![0xfa; SCRIPT_PARAMS.max_script_length as usize],
@@ -603,30 +622,37 @@ fn script() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen())
     .add_output(Output::contract_created(rng.gen(), rng.gen()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionScriptDataLength, err);
 }
 
 #[test]
-fn create() {
+fn create__check__happy_path() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
-    let arb_gas_price = 1;
-
     let maturity = 100.into();
     let block_height = 1000.into();
 
     let secret = SecretKey::random(rng);
-    let secret_b = SecretKey::random(rng);
 
     TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), rng.gen(), rng.gen())
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate tx");
+}
+
+#[test]
+fn create__check__cannot_have_contract_input() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
         .maturity(maturity)
@@ -640,13 +666,23 @@ fn create() {
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), rng.gen(), rng.gen())
         .add_output(Output::contract(0, rng.gen(), rng.gen()))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionCreateInputContract { index: 0 }
     );
+}
+
+#[test]
+fn create__check__cannot_have_message_input() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     let not_empty_data = vec![0x1];
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
@@ -660,26 +696,47 @@ fn create() {
         )
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), rng.gen(), rng.gen())
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionCreateMessageData { index: 0 }
     );
+}
+
+#[test]
+fn create__check__cannot_have_variable_output() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), rng.gen(), rng.gen())
         .add_output(Output::variable(rng.gen(), rng.gen(), rng.gen()))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionCreateOutputVariable { index: 0 }
     );
+}
+
+#[test]
+fn create__check__cannot_have_multiple_change_outputs() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let secret_b = SecretKey::random(rng);
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
         .maturity(maturity)
@@ -694,13 +751,24 @@ fn create() {
         .add_output(Output::change(rng.gen(), rng.gen(), AssetId::BASE))
         .add_output(Output::change(rng.gen(), rng.gen(), AssetId::BASE))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionOutputChangeAssetIdDuplicated(AssetId::BASE)
     );
+}
+
+#[test]
+fn create__check__errors_if_change_is_wrong_asset() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let secret_b = SecretKey::random(rng);
 
     let asset_id: AssetId = rng.gen();
 
@@ -717,13 +785,24 @@ fn create() {
         .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
         .add_output(Output::change(rng.gen(), rng.gen(), asset_id))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionCreateOutputChangeNotBaseAsset { index: 1 },
     );
+}
+
+#[test]
+fn create__check__cannot_create_multiple_contract_outputs() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
+    let secret_b = SecretKey::random(rng);
 
     let witness = generate_bytes(rng);
     let contract = Contract::from(witness.as_ref());
@@ -745,13 +824,23 @@ fn create() {
         .add_output(Output::contract_created(contract_id, state_root))
         .add_output(Output::contract_created(contract_id, state_root))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect_err("Expected erroneous transaction");
 
     assert_eq!(
         err,
         ValidityError::TransactionCreateOutputContractCreatedMultiple { index: 1 },
     );
+}
+
+#[test]
+fn create__check__something_else() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     TransactionBuilder::create(
         vec![0xfa; CONTRACT_PARAMS.contract_max_size as usize / 4].into(),
@@ -762,8 +851,18 @@ fn create() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), AssetId::default(), rng.gen())
     .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect("Failed to validate the transaction");
+}
+
+#[test]
+fn create__check__errors_if_witness_bytecode_too_long() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     let err = TransactionBuilder::create(
         vec![0xfa; 1 + CONTRACT_PARAMS.contract_max_size as usize].into(),
@@ -774,14 +873,21 @@ fn create() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), AssetId::default(), rng.gen())
     .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(err, ValidityError::TransactionCreateBytecodeLen);
+}
+
+#[test]
+fn create__check_without_signatures__errors_if_wrong_witness_index() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let block_height = 1000.into();
 
     let err = Transaction::create(
         1,
-        Default::default(),
+        Policies::default().with_max_fee(0),
         rng.gen(),
         vec![],
         vec![Input::coin_signed(
@@ -795,10 +901,20 @@ fn create() {
         vec![],
         vec![Default::default()],
     )
-    .check_without_signatures(block_height, &test_params(), arb_gas_price)
+    .check_without_signatures(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(err, ValidityError::TransactionCreateBytecodeWitnessIndex);
+}
+
+#[test]
+fn create__check__something() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
         .maturity(maturity)
@@ -811,8 +927,18 @@ fn create() {
         )
         .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
         .finalize()
-        .check(block_height, &test_params(), arb_gas_price)
+        .check(block_height, &test_params())
         .expect("Failed to validate the transaction");
+}
+
+#[test]
+fn create__check__can_max_out_storage_slots() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     let storage_slots = (0..CONTRACT_PARAMS.max_storage_slots)
         .map(|i| {
@@ -832,11 +958,27 @@ fn create() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), AssetId::default(), rng.gen())
     .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect("Failed to validate the transaction");
+}
+
+#[test]
+fn create__check__cannot_exceed_max_storage_slot() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let maturity = 100.into();
+    let block_height = 1000.into();
+
+    let secret = SecretKey::random(rng);
 
     // Test max slots can't be exceeded
-    let mut storage_slots_max = storage_slots;
+    let mut storage_slots_max = (0..CONTRACT_PARAMS.max_storage_slots)
+        .map(|i| {
+            let mut slot_data = StorageSlot::default().to_bytes();
+            slot_data[..8].copy_from_slice(&i.to_be_bytes()); // Force ordering
+            StorageSlot::from_bytes(&slot_data).unwrap()
+        })
+        .collect::<Vec<StorageSlot>>();
 
     let s = StorageSlot::new([255u8; 32].into(), Default::default());
     storage_slots_max.push(s);
@@ -850,14 +992,14 @@ fn create() {
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), AssetId::default(), rng.gen())
     .add_output(Output::change(rng.gen(), rng.gen(), AssetId::default()))
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(ValidityError::TransactionCreateStorageSlotMax, err);
 }
 
 #[test]
-fn script_transaction_at_maximum_size_is_valid() {
+fn script__check__transaction_at_maximum_size_is_valid() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let secret = SecretKey::random(rng);
 
@@ -865,7 +1007,6 @@ fn script_transaction_at_maximum_size_is_valid() {
     let mut params = test_params();
     let max_size = 1024usize;
     params.tx_params.max_size = max_size as u64;
-    let arb_gas_price = 1;
 
     let base_size = {
         let tx = TransactionBuilder::script(vec![], vec![])
@@ -885,19 +1026,18 @@ fn script_transaction_at_maximum_size_is_valid() {
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), rng.gen(), rng.gen())
         .finalize();
 
-    tx.check(block_height, &params, arb_gas_price)
+    tx.check(block_height, &params)
         .expect("Expected valid transaction");
 }
 
 #[test]
-fn script_transaction_exceeding_maximum_size_is_invalid() {
+fn script__check__transaction_exceeding_maximum_size_is_invalid() {
     let rng = &mut StdRng::seed_from_u64(8586);
     let secret = SecretKey::random(rng);
 
     let block_height = 100.into();
     let mut params = test_params();
     let max_size = 1024usize;
-    let arb_gas_price = 1;
     params.tx_params.max_size = max_size as u64;
 
     let base_size = {
@@ -921,7 +1061,7 @@ fn script_transaction_exceeding_maximum_size_is_invalid() {
         .finalize();
 
     let err = tx
-        .check(block_height, &params, arb_gas_price)
+        .check(block_height, &params)
         .expect_err("Expected valid transaction");
 
     assert_eq!(err, ValidityError::TransactionSizeLimitExceeded);
@@ -933,8 +1073,6 @@ fn mint() {
 
     let block_height = 1000.into();
 
-    let arb_gas_price = 1;
-
     let err = TransactionBuilder::mint(
         block_height,
         rng.gen(),
@@ -945,7 +1083,7 @@ fn mint() {
         rng.gen(),
     )
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(err, ValidityError::TransactionMintIncorrectOutputIndex);
@@ -964,7 +1102,7 @@ fn mint() {
         rng.gen(),
     )
     .finalize()
-    .check(block_height, &test_params(), arb_gas_price)
+    .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(err, ValidityError::TransactionMintNonBaseAsset);
@@ -983,7 +1121,7 @@ fn mint() {
         rng.gen(),
     )
     .finalize()
-    .check(block_height.succ().unwrap(), &test_params(), arb_gas_price)
+    .check(block_height.succ().unwrap(), &test_params())
     .expect_err("Expected erroneous transaction");
 
     assert_eq!(err, ValidityError::TransactionMintIncorrectBlockHeight);
diff --git a/fuel-tx/src/transaction.rs b/fuel-tx/src/transaction.rs
index 554d1e7976..0de9e07ce4 100644
--- a/fuel-tx/src/transaction.rs
+++ b/fuel-tx/src/transaction.rs
@@ -652,6 +652,12 @@ pub mod field {
         fn mint_asset_id_offset(&self) -> usize;
     }
 
+    pub trait MintGasPrice {
+        fn gas_price(&self) -> &Word;
+        fn gas_price_mut(&mut self) -> &mut Word;
+        fn gas_price_offset(&self) -> usize;
+    }
+
     pub trait ReceiptsRoot {
         fn receipts_root(&self) -> &Bytes32;
         fn receipts_root_mut(&mut self) -> &mut Bytes32;
diff --git a/fuel-tx/src/transaction/policies.rs b/fuel-tx/src/transaction/policies.rs
index e0570734ad..a77d0b85ae 100644
--- a/fuel-tx/src/transaction/policies.rs
+++ b/fuel-tx/src/transaction/policies.rs
@@ -147,6 +147,11 @@ impl Policies {
         }
     }
 
+    /// Returns `true` if the policy is set.
+    pub fn is_set(&self, policy_type: PolicyType) -> bool {
+        self.bits.contains(policy_type.bit())
+    }
+
     /// Returns a policy's type by the `index`.
     pub fn get_type_by_index(&self, index: usize) -> Option<u32> {
         self.bits.iter().nth(index).map(|bit| bit.bits())
diff --git a/fuel-tx/src/transaction/types/create.rs b/fuel-tx/src/transaction/types/create.rs
index 40ae28dbd7..14b510fb95 100644
--- a/fuel-tx/src/transaction/types/create.rs
+++ b/fuel-tx/src/transaction/types/create.rs
@@ -222,7 +222,6 @@ impl FormatValidityChecks for Create {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<(), ValidityError> {
         let ConsensusParameters {
             contract_params,
@@ -231,7 +230,7 @@ impl FormatValidityChecks for Create {
             ..
         } = consensus_params;
 
-        check_common_part(self, block_height, gas_price, consensus_params)?;
+        check_common_part(self, block_height, consensus_params)?;
 
         let bytecode_witness_len = self
             .witnesses
@@ -308,13 +307,13 @@ impl FormatValidityChecks for Create {
                     state_root,
                 } if contract_id != &contract_id_calculated
                     || state_root != &state_root_calculated =>
-                {
-                    Err(
-                        ValidityError::TransactionCreateOutputContractCreatedDoesntMatch {
-                            index,
-                        },
-                    )
-                }
+                    {
+                        Err(
+                            ValidityError::TransactionCreateOutputContractCreatedDoesntMatch {
+                                index,
+                            },
+                        )
+                    }
 
                 // TODO: Output::ContractCreated { contract_id, state_root } if
                 // contract_id == &id && state_root == &storage_root
@@ -638,7 +637,6 @@ mod tests {
     fn storage_slots_sorting() {
         // Test that storage slots must be sorted correctly
         let mut slot_data = [0u8; 64];
-        let arb_gas_price = 1;
 
         let storage_slots = (0..10u64)
             .map(|i| {
@@ -657,7 +655,7 @@ mod tests {
         tx.storage_slots.reverse();
 
         let err = tx
-            .check(0.into(), &ConsensusParameters::standard(), arb_gas_price)
+            .check(0.into(), &ConsensusParameters::standard())
             .expect_err("Expected erroneous transaction");
 
         assert_eq!(ValidityError::TransactionCreateStorageSlotOrder, err);
@@ -669,7 +667,6 @@ mod tests {
             StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
             StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
         ];
-        let arb_gas_price = 1;
 
         let err = crate::TransactionBuilder::create(
             vec![].into(),
@@ -678,7 +675,7 @@ mod tests {
         )
         .add_random_fee_input()
         .finalize()
-        .check(0.into(), &ConsensusParameters::standard(), arb_gas_price)
+        .check(0.into(), &ConsensusParameters::standard())
         .expect_err("Expected erroneous transaction");
 
         assert_eq!(ValidityError::TransactionCreateStorageSlotOrder, err);
diff --git a/fuel-tx/src/transaction/types/mint.rs b/fuel-tx/src/transaction/types/mint.rs
index 7aae8e5ba1..efc7b0e242 100644
--- a/fuel-tx/src/transaction/types/mint.rs
+++ b/fuel-tx/src/transaction/types/mint.rs
@@ -99,7 +99,6 @@ impl FormatValidityChecks for Mint {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        _gas_price: u64,
     ) -> Result<(), ValidityError> {
         check_size(self, consensus_params.tx_params())?;
 
@@ -138,6 +137,7 @@ mod field {
         InputContract,
         MintAmount,
         MintAssetId,
+        MintGasPrice,
         OutputContract,
     };
 
@@ -225,4 +225,21 @@ mod field {
             self.mint_amount_offset() + WORD_SIZE
         }
     }
+
+    impl MintGasPrice for Mint {
+        #[inline(always)]
+        fn gas_price(&self) -> &Word {
+            &self.gas_price
+        }
+
+        #[inline(always)]
+        fn gas_price_mut(&mut self) -> &mut Word {
+            &mut self.gas_price
+        }
+
+        #[inline(always)]
+        fn gas_price_offset(&self) -> usize {
+            self.mint_asset_id_offset() + AssetId::LEN
+        }
+    }
 }
diff --git a/fuel-tx/src/transaction/types/script.rs b/fuel-tx/src/transaction/types/script.rs
index ccd391d82a..f5c79fdfbc 100644
--- a/fuel-tx/src/transaction/types/script.rs
+++ b/fuel-tx/src/transaction/types/script.rs
@@ -188,9 +188,8 @@ impl FormatValidityChecks for Script {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<(), ValidityError> {
-        check_common_part(self, block_height, gas_price, consensus_params)?;
+        check_common_part(self, block_height, consensus_params)?;
         let script_params = consensus_params.script_params();
         if self.script.len() as u64 > script_params.max_script_length {
             Err(ValidityError::TransactionScriptLength)?;
diff --git a/fuel-tx/src/transaction/validity.rs b/fuel-tx/src/transaction/validity.rs
index b9d90a4aae..af2b9949e8 100644
--- a/fuel-tx/src/transaction/validity.rs
+++ b/fuel-tx/src/transaction/validity.rs
@@ -246,9 +246,8 @@ pub trait FormatValidityChecks {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<(), ValidityError> {
-        self.check_without_signatures(block_height, consensus_params, gas_price)?;
+        self.check_without_signatures(block_height, consensus_params)?;
         self.check_signatures(&consensus_params.chain_id())?;
 
         Ok(())
@@ -264,7 +263,6 @@ pub trait FormatValidityChecks {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<(), ValidityError>;
 }
 
@@ -281,17 +279,16 @@ impl FormatValidityChecks for Transaction {
         &self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<(), ValidityError> {
         match self {
             Transaction::Script(script) => {
-                script.check_without_signatures(block_height, consensus_params, gas_price)
+                script.check_without_signatures(block_height, consensus_params)
             }
             Transaction::Create(create) => {
-                create.check_without_signatures(block_height, consensus_params, gas_price)
+                create.check_without_signatures(block_height, consensus_params)
             }
             Transaction::Mint(mint) => {
-                mint.check_without_signatures(block_height, consensus_params, gas_price)
+                mint.check_without_signatures(block_height, consensus_params)
             }
         }
     }
@@ -315,7 +312,6 @@ where
 pub(crate) fn check_common_part<T>(
     tx: &T,
     block_height: BlockHeight,
-    gas_price: u64,
     consensus_params: &ConsensusParameters,
 ) -> Result<(), ValidityError>
 where
@@ -348,11 +344,9 @@ where
         Err(ValidityError::TransactionMaxGasExceeded)?
     }
 
-    if let Some(max_fee_limit) = tx.policies().get(PolicyType::MaxFee) {
-        if tx.max_fee(gas_costs, fee_params, gas_price) > max_fee_limit as u128 {
-            Err(ValidityError::TransactionMaxFeeLimitExceeded)?
-        }
-    }
+    if !tx.policies().is_set(PolicyType::MaxFee) {
+        Err(ValidityError::TransactionMaxFeeNotSet)?
+    };
 
     if tx.maturity() > block_height {
         Err(ValidityError::TransactionMaturity)?;
diff --git a/fuel-tx/src/transaction/validity/error.rs b/fuel-tx/src/transaction/validity/error.rs
index fdf5a8e7f9..4f10721adb 100644
--- a/fuel-tx/src/transaction/validity/error.rs
+++ b/fuel-tx/src/transaction/validity/error.rs
@@ -90,11 +90,11 @@ pub enum ValidityError {
     TransactionSizeLimitExceeded,
     /// Max gas per tx exceeded
     TransactionMaxGasExceeded,
-    TransactionMaxFeeLimitExceeded,
     TransactionWitnessLimitExceeded,
     TransactionPoliciesAreInvalid,
     TransactionNoGasPricePolicy,
     TransactionMaturity,
+    TransactionMaxFeeNotSet,
     TransactionInputsMax,
     TransactionOutputsMax,
     TransactionWitnessesMax,
diff --git a/fuel-tx/test-helpers/src/lib.rs b/fuel-tx/test-helpers/src/lib.rs
index 7cdd6748d6..21ebf29ecc 100644
--- a/fuel-tx/test-helpers/src/lib.rs
+++ b/fuel-tx/test-helpers/src/lib.rs
@@ -370,7 +370,7 @@ mod use_std {
         R: Rng + CryptoRng,
     {
         pub fn transaction(&mut self) -> Mint {
-            let mut builder = TransactionBuilder::<Mint>::mint(
+            let builder = TransactionBuilder::<Mint>::mint(
                 self.rng.gen(),
                 self.rng.gen(),
                 self.rng.gen(),
diff --git a/fuel-vm/examples/external.rs b/fuel-vm/examples/external.rs
index bb96ff8c09..8ba8f18fa9 100644
--- a/fuel-vm/examples/external.rs
+++ b/fuel-vm/examples/external.rs
@@ -83,7 +83,6 @@ impl EcalHandler for FileReadEcal {
 }
 
 fn example_file_read() {
-    let zero_gas_price = 0;
     let vm: Interpreter<MemoryStorage, Script, FileReadEcal> =
         Interpreter::with_memory_storage();
 
@@ -107,7 +106,7 @@ fn example_file_read() {
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     let receipts = client.receipts().expect("Expected receipts");
@@ -142,7 +141,6 @@ impl EcalHandler for CounterEcal {
 }
 
 fn example_counter() {
-    let zero_gas_price = 0;
     let mut vm: Interpreter<MemoryStorage, Script, CounterEcal> =
         Interpreter::with_memory_storage();
 
@@ -167,7 +165,7 @@ fn example_counter() {
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     let receipts = client.receipts().expect("Expected receipts");
@@ -206,7 +204,6 @@ impl EcalHandler for SharedCounterEcal {
 }
 
 fn example_shared_counter() {
-    let zero_gas_price = 0;
     let vm: Interpreter<MemoryStorage, Script, SharedCounterEcal> =
         Interpreter::with_memory_storage_and_ecal(SharedCounterEcal {
             counter: Arc::new(Mutex::new(5)),
@@ -231,7 +228,7 @@ fn example_shared_counter() {
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     let receipts = client.receipts().expect("Expected receipts");
diff --git a/fuel-vm/src/checked_transaction.rs b/fuel-vm/src/checked_transaction.rs
index e0ba2ba884..b13639fabb 100644
--- a/fuel-vm/src/checked_transaction.rs
+++ b/fuel-vm/src/checked_transaction.rs
@@ -25,10 +25,14 @@ use alloc::{
 };
 use core::{
     borrow::Borrow,
+    fmt::Debug,
     future::Future,
 };
 
-use fuel_tx::ConsensusParameters;
+use fuel_tx::{
+    field::MaxFeeLimit,
+    ConsensusParameters,
+};
 
 mod balances;
 pub mod builder;
@@ -121,6 +125,74 @@ impl<Tx: IntoChecked> Checked<Tx> {
     }
 }
 
+/// Transaction that has checks for all dynamic values, e.g. `gas_price`
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Ready<Tx: IntoChecked> {
+    gas_price: Word,
+    transaction: Tx,
+    metadata: Tx::Metadata,
+    checks_bitmask: Checks,
+}
+
+impl<Tx: IntoChecked> Ready<Tx> {
+    /// Consume and decompose components of the `Immutable` transaction.
+    pub fn decompose(self) -> (Word, Checked<Tx>) {
+        let Ready {
+            gas_price,
+            transaction,
+            metadata,
+            checks_bitmask,
+        } = self;
+        let checked = Checked::new(transaction, metadata, checks_bitmask);
+        (gas_price, checked)
+    }
+
+    /// Getter for `gas_price` field
+    pub fn gas_price(&self) -> Word {
+        self.gas_price
+    }
+}
+
+impl<Tx: IntoChecked + Chargeable> Checked<Tx> {
+    /// Run final checks on `Checked` using dynamic values, e.g. `gas_price`
+    pub fn into_ready(
+        self,
+        gas_price: Word,
+        gas_costs: &GasCosts,
+        fee_parameters: &FeeParameters,
+    ) -> Result<Ready<Tx>, CheckError> {
+        let Checked {
+            transaction,
+            metadata,
+            checks_bitmask,
+        } = self;
+        let fee = TransactionFee::checked_from_tx(
+            gas_costs,
+            fee_parameters,
+            &transaction,
+            gas_price,
+        )
+        .ok_or(CheckError::Validity(ValidityError::BalanceOverflow))?;
+
+        let max_fee_from_policies = transaction.max_fee_limit();
+        let max_fee_from_gas_price = fee.max_fee();
+
+        if max_fee_from_gas_price > max_fee_from_policies {
+            Err(CheckError::InsufficientMaxFee {
+                max_fee_from_policies,
+                max_fee_from_gas_price,
+            })
+        } else {
+            Ok(Ready {
+                gas_price,
+                transaction,
+                metadata,
+                checks_bitmask,
+            })
+        }
+    }
+}
+
 impl<Tx: IntoChecked + UniqueIdentifier> Checked<Tx> {
     /// Returns the transaction ID from the computed metadata
     pub fn id(&self) -> TxId {
@@ -136,24 +208,8 @@ where
     Checked<Tx>: CheckPredicates,
 {
     fn default() -> Self {
-        let gas_price = 0;
-        Self::default_with_gas_price(gas_price)
-    }
-}
-
-#[cfg(feature = "test-helpers")]
-impl<Tx: IntoChecked + Default> Checked<Tx>
-where
-    Checked<Tx>: CheckPredicates,
-{
-    /// Creates a default checked transaction with a given gas price.
-    pub fn default_with_gas_price(gas_price: u64) -> Self {
         Tx::default()
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect("default tx should produce a valid fully checked transaction")
     }
 }
@@ -197,6 +253,14 @@ pub enum CheckError {
     Validity(ValidityError),
     /// The predicate verification failed.
     PredicateVerificationFailed(PredicateVerificationFailed),
+    /// The max fee used during checking was lower than calculated during `Immutable`
+    /// conversion
+    InsufficientMaxFee {
+        /// The max fee from the policies defined by the user.
+        max_fee_from_policies: Word,
+        /// The max fee calculated from the gas price and gas used by the transaction.
+        max_fee_from_gas_price: Word,
+    },
 }
 
 /// Performs checks for a transaction
@@ -209,13 +273,12 @@ pub trait IntoChecked: FormatValidityChecks + Sized {
         self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<Checked<Self>, CheckError>
     where
         Checked<Self>: CheckPredicates,
     {
         let check_predicate_params = consensus_params.into();
-        self.into_checked_basic(block_height, consensus_params, gas_price)?
+        self.into_checked_basic(block_height, consensus_params)?
             .check_signatures(&consensus_params.chain_id)?
             .check_predicates(&check_predicate_params)
     }
@@ -225,7 +288,6 @@ pub trait IntoChecked: FormatValidityChecks + Sized {
         self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<Checked<Self>, CheckError>;
 }
 
@@ -608,24 +670,23 @@ impl IntoChecked for Transaction {
         self,
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
-        gas_price: u64,
     ) -> Result<Checked<Self>, CheckError> {
         match self {
             Transaction::Script(script) => {
                 let (transaction, metadata) = script
-                    .into_checked_basic(block_height, consensus_params, gas_price)?
+                    .into_checked_basic(block_height, consensus_params)?
                     .into();
                 Ok((transaction.into(), metadata.into()))
             }
             Transaction::Create(create) => {
                 let (transaction, metadata) = create
-                    .into_checked_basic(block_height, consensus_params, gas_price)?
+                    .into_checked_basic(block_height, consensus_params)?
                     .into();
                 Ok((transaction.into(), metadata.into()))
             }
             Transaction::Mint(mint) => {
                 let (transaction, metadata) = mint
-                    .into_checked_basic(block_height, consensus_params, gas_price)?
+                    .into_checked_basic(block_height, consensus_params)?
                     .into();
                 Ok((transaction.into(), metadata.into()))
             }
@@ -690,22 +751,19 @@ mod tests {
     }
 
     #[test]
-    fn checked_tx_accepts_valid_tx() {
+    fn into_checked__tx_accepts_valid_tx() {
         // simple smoke test that valid txs can be checked
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let gas_price = 10;
         let gas_limit = 1000;
         let input_amount = 1000;
         let output_amount = 10;
-        let tx = valid_coin_tx(rng, gas_limit, input_amount, output_amount);
+        let max_fee_limit = 500;
+        let tx =
+            valid_coin_tx(rng, gas_limit, input_amount, output_amount, max_fee_limit);
 
         let checked = tx
             .clone()
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect("Expected valid transaction");
 
         // verify transaction getter works
@@ -713,79 +771,72 @@ mod tests {
         // verify available balance was decreased by max fee
         assert_eq!(
             checked.metadata().non_retryable_balances[&AssetId::default()],
-            input_amount - checked.metadata().fee.max_fee() - output_amount
+            input_amount - max_fee_limit - output_amount
         );
     }
 
     #[test]
-    fn checked_tx_accepts_valid_signed_message_input_fees() {
+    fn into_checked__tx_accepts_valid_signed_message_coin_for_fees() {
         // simple test to ensure a tx that only has a message input can cover fees
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let input_amount = 100;
-        let gas_price = 100;
+        let input_amount = 1000;
         let gas_limit = 1000;
-        let tx = signed_message_coin_tx(rng, gas_limit, input_amount);
+        let zero_fee_limit = 500;
+        let tx = signed_message_coin_tx(rng, gas_limit, input_amount, zero_fee_limit);
 
         let checked = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect("Expected valid transaction");
 
         // verify available balance was decreased by max fee
         assert_eq!(
             checked.metadata().non_retryable_balances[&AssetId::default()],
-            input_amount - checked.metadata().fee.max_fee()
+            input_amount - checked.transaction.max_fee_limit()
         );
     }
 
     #[test]
-    fn checked_tx_excludes_message_output_amount_from_fee() {
+    fn into_checked__tx_excludes_message_output_amount_from_fee() {
         // ensure message outputs aren't deducted from available balance
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let input_amount = 100;
-        let gas_price = 100;
         let gas_limit = 1000;
-        let tx = signed_message_coin_tx(rng, gas_limit, input_amount);
+        let zero_fee_limit = 50;
+        let tx = signed_message_coin_tx(rng, gas_limit, input_amount, zero_fee_limit);
 
         let checked = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect("Expected valid transaction");
 
         // verify available balance was decreased by max fee
         assert_eq!(
             checked.metadata().non_retryable_balances[&AssetId::default()],
-            input_amount - checked.metadata().fee.max_fee()
+            input_amount - checked.transaction.max_fee_limit()
         );
     }
 
     #[test]
-    fn message_data_signed_message_is_not_used_to_cover_fees() {
-        // simple test to ensure a tx that only has a message input can cover fees
+    fn into_checked__message_data_signed_message_is_not_used_to_cover_fees() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
+
+        // given
         let input_amount = 100;
-        let gas_price = 100;
+
+        // when
+        let max_fee = input_amount;
         let tx = TransactionBuilder::script(vec![], vec![])
+            .max_fee_limit(max_fee)
+            // Add message input with enough to cover max fee
             .add_unsigned_message_input(SecretKey::random(rng), rng.gen(), rng.gen(), input_amount, vec![0xff; 10])
             // Add empty base coin
             .add_unsigned_coin_input(SecretKey::random(rng), rng.gen(), 0, AssetId::BASE, rng.gen())
             .finalize();
 
         let err = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect_err("Expected valid transaction");
 
-        // verify available balance was decreased by max fee
+        // then
         assert!(matches!(
             err,
             CheckError::Validity(ValidityError::InsufficientFeeAmount {
@@ -797,12 +848,17 @@ mod tests {
 
     #[test]
     fn message_data_predicate_message_is_not_used_to_cover_fees() {
-        // simple test to ensure a tx that only has a message input can cover fees
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let input_amount = 100;
-        let gas_price = 100;
         let gas_limit = 1000;
+
+        // given
+        let input_amount = 100;
+
+        // when
+        let max_fee = input_amount;
+
         let tx = TransactionBuilder::script(vec![], vec![])
+            .max_fee_limit(max_fee)
             .script_gas_limit(gas_limit)
             .add_input(Input::message_data_predicate(
                 rng.gen(),
@@ -819,14 +875,10 @@ mod tests {
             .finalize();
 
         let err = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect_err("Expected valid transaction");
 
-        // verify available balance was decreased by max fee
+        // then
         assert!(matches!(
             err,
             CheckError::Validity(ValidityError::InsufficientFeeAmount {
@@ -857,7 +909,6 @@ mod tests {
         let rng = &mut StdRng::seed_from_u64(seed);
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
-        let base_asset_id = rng.gen();
         let predicate_gas_used = rng.gen();
         let tx = predicate_tx(
             rng,
@@ -867,9 +918,7 @@ mod tests {
             predicate_gas_used,
         );
 
-        if let Ok(valid) =
-            is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params, &base_asset_id)
-        {
+        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
             TestResult::from_bool(valid)
         } else {
             TestResult::discard()
@@ -896,7 +945,6 @@ mod tests {
         let rng = &mut StdRng::seed_from_u64(seed);
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
-        let base_asset_id = rng.gen();
         let predicate_gas_used = rng.gen();
         let tx = predicate_tx(
             rng,
@@ -906,9 +954,7 @@ mod tests {
             predicate_gas_used,
         );
 
-        if let Ok(valid) =
-            is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params, &base_asset_id)
-        {
+        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
             TestResult::from_bool(valid)
         } else {
             TestResult::discard()
@@ -934,12 +980,9 @@ mod tests {
         let rng = &mut StdRng::seed_from_u64(seed);
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
-        let base_asset_id = rng.gen();
         let tx = predicate_message_coin_tx(rng, gas_limit, input_amount, tip);
 
-        if let Ok(valid) =
-            is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params, &base_asset_id)
-        {
+        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
             TestResult::from_bool(valid)
         } else {
             TestResult::discard()
@@ -1003,12 +1046,9 @@ mod tests {
         let rng = &mut StdRng::seed_from_u64(seed);
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
-        let base_asset_id = rng.gen();
         let tx = predicate_message_coin_tx(rng, gas_limit, input_amount, tip);
 
-        if let Ok(valid) =
-            is_valid_min_fee(&tx, &gas_costs, &fee_params, &base_asset_id, gas_price)
-        {
+        if let Ok(valid) = is_valid_min_fee(&tx, &gas_costs, &fee_params, gas_price) {
             TestResult::from_bool(valid)
         } else {
             TestResult::discard()
@@ -1355,7 +1395,6 @@ mod tests {
         // simple smoke test that invalid txs cannot be checked
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let asset = rng.gen();
-        let gas_price = 1;
         let gas_limit = 100;
         let input_amount = 1_000;
 
@@ -1383,67 +1422,100 @@ mod tests {
             .add_witness(Default::default())
             .finalize();
 
-        let checked = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+        let err = tx
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect_err("Expected invalid transaction");
 
         // assert that tx without base input assets fails
         assert!(matches!(
-            checked,
-            CheckError::Validity(ValidityError::InsufficientFeeAmount { .. })
+            err,
+            CheckError::Validity(ValidityError::InputInvalidSignature { .. })
         ));
     }
 
     #[test]
-    fn checked_tx_fails_when_provided_fees_dont_cover_byte_costs() {
+    fn into_checked__tx_fails_when_provided_fees_dont_cover_byte_costs() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
 
-        let input_amount = 1;
+        let arb_input_amount = 1;
         let gas_price = 2; // price > amount
         let gas_limit = 0; // don't include any gas execution fees
         let factor = 1;
+        let zero_max_fee = 0;
+        let params = params(factor);
 
-        let transaction = base_asset_tx(rng, input_amount, gas_limit);
+        // setup "valid" transaction
+        let transaction = base_asset_tx(rng, arb_input_amount, gas_limit, zero_max_fee);
+        transaction
+            .clone()
+            .into_checked(Default::default(), &params)
+            .unwrap();
+        let fees = TransactionFee::checked_from_tx(
+            &GasCosts::default(),
+            params.fee_params(),
+            &transaction,
+            gas_price,
+        )
+        .unwrap();
+        let real_max_fee = fees.max_fee();
 
-        let consensus_params = params(factor);
+        let new_input_amount = real_max_fee;
+        let mut new_transaction =
+            base_asset_tx(rng, new_input_amount, gas_limit, real_max_fee);
+        new_transaction
+            .clone()
+            .into_checked(Default::default(), &params)
+            .unwrap()
+            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
+            .expect("`new_transaction` should be fully valid");
 
-        let err = transaction
-            .into_checked(Default::default(), &consensus_params, gas_price)
-            .expect_err("overflow expected");
+        // given
+        // invalidating the transaction by increasing witness size
+        new_transaction.witnesses_mut().push(rng.gen());
+        let bigger_checked = new_transaction
+            .into_checked(Default::default(), &params)
+            .unwrap();
 
-        let provided = match err {
-            CheckError::Validity(ValidityError::InsufficientFeeAmount {
-                provided,
+        // when
+        let err = bigger_checked
+            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
+            .expect_err("Expected invalid transaction");
+
+        let max_fee_from_policies = match err {
+            CheckError::InsufficientMaxFee {
+                max_fee_from_policies,
                 ..
-            }) => provided,
-            _ => panic!("expected insufficient fee amount; found {err:?}"),
+            } => max_fee_from_policies,
+            _ => panic!("expected insufficient max fee; found {err:?}"),
         };
 
-        assert_eq!(provided, input_amount);
+        // then
+        assert_eq!(max_fee_from_policies, real_max_fee);
     }
 
     #[test]
-    fn checked_tx_fails_when_provided_fees_dont_cover_gas_costs() {
+    fn into_checked__tx_fails_when_provided_fees_dont_cover_fee_limit() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
 
         let input_amount = 10;
         let factor = 1;
         // make gas price too high for the input amount
-        let gas_price = 1;
         let gas_limit = input_amount + 1; // make gas cost 1 higher than input amount
 
-        let transaction = base_asset_tx(rng, input_amount, gas_limit);
+        // given
+        let input_amount = 10;
+        let big_fee_limit = input_amount + 1;
+
+        let transaction = base_asset_tx(rng, input_amount, gas_limit, big_fee_limit);
 
         let consensus_params = params(factor);
 
+        // when
         let err = transaction
-            .into_checked(Default::default(), &consensus_params, gas_price)
+            .into_checked(Default::default(), &consensus_params)
             .expect_err("overflow expected");
 
+        // then
         let provided = match err {
             CheckError::Validity(ValidityError::InsufficientFeeAmount {
                 provided,
@@ -1451,111 +1523,136 @@ mod tests {
             }) => provided,
             _ => panic!("expected insufficient fee amount; found {err:?}"),
         };
-
         assert_eq!(provided, input_amount);
     }
 
     #[test]
-    fn bytes_fee_cant_overflow() {
+    fn into_ready__bytes_fee_cant_overflow() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
 
         let input_amount = 1000;
-        let gas_price = Word::MAX;
+        let max_gas_price = Word::MAX;
         let gas_limit = 0; // ensure only bytes are included in fee
-        let transaction = base_asset_tx(rng, input_amount, gas_limit);
+        let zero_fee_limit = 0;
+        let transaction = base_asset_tx(rng, input_amount, gas_limit, zero_fee_limit);
+        let gas_costs = GasCosts::default();
 
         let consensus_params = params(1);
 
+        let fee_params = consensus_params.fee_params();
         let err = transaction
-            .into_checked(Default::default(), &consensus_params, gas_price)
+            .into_checked(Default::default(), &consensus_params)
+            .unwrap()
+            .into_ready(max_gas_price, &gas_costs, fee_params)
             .expect_err("overflow expected");
 
         assert_eq!(err, CheckError::Validity(ValidityError::BalanceOverflow));
     }
 
-    fn arb_tx(rng: &mut StdRng) -> Script {
-        let input_amount = 1000;
-        let gas_limit = 1000;
-        base_asset_tx(rng, input_amount, gas_limit)
-    }
-
     #[test]
-    fn into_checked_basic__min_fee_calc_includes_tip() {
+    fn into_ready__fails_if_fee_limit_too_low() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let gas_price = 1;
-        let mut tx = arb_tx(rng);
 
-        // given
-        let tipless_tx = tx.clone();
+        let input_amount = 1000;
+        let gas_price = 100;
+        let gas_limit = 0; // ensure only bytes are included in fee
+        let gas_costs = GasCosts::default();
 
-        let min_fee_without_tip = tipless_tx
-            .into_checked_basic(1.into(), &ConsensusParameters::standard(), gas_price)
-            .unwrap()
-            .metadata()
-            .fee
-            .min_fee();
+        let consensus_params = params(1);
 
-        let tip = 100;
+        let fee_params = consensus_params.fee_params();
 
-        // when
-        tx.set_tip(tip);
+        // given
+        let zero_fee_limit = 0;
+        let transaction = base_asset_tx(rng, input_amount, gas_limit, zero_fee_limit);
 
-        let min_fee_with_tip = tx
-            .into_checked_basic(1.into(), &ConsensusParameters::standard(), gas_price)
+        // when
+        let err = transaction
+            .into_checked(Default::default(), &consensus_params)
             .unwrap()
-            .metadata()
-            .fee
-            .min_fee();
+            .into_ready(gas_price, &gas_costs, fee_params)
+            .expect_err("overflow expected");
 
         // then
-        assert_eq!(min_fee_without_tip + tip, min_fee_with_tip);
+        assert!(matches!(err, CheckError::InsufficientMaxFee { .. }));
     }
 
     #[test]
-    fn into_checked_basic__max_fee_calc_includes_tip() {
+    fn into_ready__tx_fails_if_tip_not_covered() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let gas_price = 1;
-        let mut tx = arb_tx(rng);
 
-        // given
-        let tipless_tx = tx.clone();
+        // tx without tip and fee limit that is good
+        let input_amount = 1;
+        let gas_limit = 1000;
+        let params = ConsensusParameters::standard();
+        let block_height = 1.into();
+        let gas_costs = GasCosts::default();
+        let max_fee_limit = input_amount;
+        let gas_price = 1;
 
-        let max_fee_without_tip = tipless_tx
-            .into_checked_basic(1.into(), &ConsensusParameters::standard(), gas_price)
+        let tx_without_tip =
+            base_asset_tx_with_tip(rng, input_amount, gas_limit, max_fee_limit, None);
+        tx_without_tip
+            .clone()
+            .into_checked(block_height, &params)
             .unwrap()
-            .metadata()
-            .fee
-            .max_fee();
+            .into_ready(gas_price, &gas_costs, params.fee_params())
+            .expect("Should be valid");
 
+        // given
         let tip = 100;
+        let tx_without_enough_to_pay_for_tip = base_asset_tx_with_tip(
+            rng,
+            input_amount,
+            gas_limit,
+            max_fee_limit,
+            Some(tip),
+        );
+        tx_without_enough_to_pay_for_tip
+            .into_checked(block_height, &params)
+            .unwrap()
+            .into_ready(gas_price, &gas_costs, params.fee_params())
+            .expect_err("Expected invalid transaction");
 
         // when
-        tx.set_tip(tip);
-
-        let max_fee_with_tip = tx
-            .into_checked_basic(1.into(), &ConsensusParameters::standard(), gas_price)
-            .unwrap()
-            .metadata()
-            .fee
-            .max_fee();
+        let new_input_amount = input_amount + tip;
+        let new_gas_limit = new_input_amount;
+        let tx = base_asset_tx_with_tip(
+            rng,
+            new_input_amount,
+            gas_limit,
+            new_gas_limit,
+            Some(tip),
+        );
 
         // then
-        assert_eq!(max_fee_without_tip + tip, max_fee_with_tip);
+        tx.clone()
+            .into_checked(block_height, &params)
+            .unwrap()
+            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
+            .expect("Should be valid");
     }
 
     #[test]
-    fn gas_fee_cant_overflow() {
+    fn into_ready__return_overflow_error_if_gas_price_too_high() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let input_amount = 1000;
         let gas_price = Word::MAX;
         let gas_limit = 2; // 2 * max should cause gas fee overflow
+        let max_fee_limit = 0;
 
-        let transaction = base_asset_tx(rng, input_amount, gas_limit);
+        let transaction = base_asset_tx(rng, input_amount, gas_limit, max_fee_limit);
 
         let consensus_params = params(1);
 
         let err = transaction
-            .into_checked(Default::default(), &consensus_params, gas_price)
+            .into_checked(Default::default(), &consensus_params)
+            .unwrap()
+            .into_ready(
+                gas_price,
+                &GasCosts::default(),
+                consensus_params.fee_params(),
+            )
             .expect_err("overflow expected");
 
         assert_eq!(err, CheckError::Validity(ValidityError::BalanceOverflow));
@@ -1567,7 +1664,6 @@ mod tests {
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let secret = SecretKey::random(rng);
         let any_asset = rng.gen();
-        let arb_gas_price = 1;
         let tx = TransactionBuilder::script(vec![], vec![])
             .script_gas_limit(100)
             // base asset
@@ -1592,11 +1688,7 @@ mod tests {
             .finalize();
 
         let checked = tx
-            .into_checked(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                arb_gas_price,
-            )
+            .into_checked(Default::default(), &ConsensusParameters::standard())
             .expect_err("Expected valid transaction");
 
         assert_eq!(
@@ -1613,16 +1705,11 @@ mod tests {
     #[test]
     fn basic_check_marks_basic_flag() {
         let block_height = 1.into();
-        let zero_gas_price = 0;
 
         let tx = Transaction::default_test_tx();
         // Sets Checks::Basic
         let checked = tx
-            .into_checked_basic(
-                block_height,
-                &ConsensusParameters::standard(),
-                zero_gas_price,
-            )
+            .into_checked_basic(block_height, &ConsensusParameters::standard())
             .unwrap();
         assert!(checked.checks().contains(Checks::Basic));
     }
@@ -1631,16 +1718,15 @@ mod tests {
     fn signatures_check_marks_signatures_flag() {
         let mut rng = StdRng::seed_from_u64(1);
         let block_height = 1.into();
-        let arb_gas_price = 1;
+        let max_fee_limit = 0;
 
-        let tx = valid_coin_tx(&mut rng, 100000, 1000000, 10);
+        let tx = valid_coin_tx(&mut rng, 100000, 1000000, 10, max_fee_limit);
         let chain_id = ChainId::default();
         let checked = tx
             // Sets Checks::Basic
             .into_checked(
                 block_height,
                 &ConsensusParameters::standard_with_id(chain_id),
-                arb_gas_price,
             )
             .unwrap()
             // Sets Checks::Signatures
@@ -1657,7 +1743,6 @@ mod tests {
         let mut rng = StdRng::seed_from_u64(1);
         let block_height = 1.into();
         let gas_costs = GasCosts::default();
-        let arb_gas_price = 1;
 
         let tx = predicate_tx(&mut rng, 1000000, 1000000, 1000000, gas_costs.ret);
 
@@ -1673,7 +1758,6 @@ mod tests {
             .into_checked(
                 block_height,
                 &consensus_params,
-                arb_gas_price,
             )
             .unwrap()
             // Sets Checks::Predicates
@@ -1689,7 +1773,6 @@ mod tests {
         gas_price: u64,
         gas_costs: &GasCosts,
         fee_params: &FeeParameters,
-        base_asset_id: &AssetId,
     ) -> Result<bool, ValidityError> {
         fn gas_to_fee(gas: u64, price: u64, factor: u64) -> u128 {
             let prices_gas = gas as u128 * price as u128;
@@ -1698,13 +1781,6 @@ mod tests {
             fee + fee_remainder
         }
 
-        let available_balances = balances::initial_free_balances(
-            tx,
-            gas_costs,
-            fee_params,
-            base_asset_id,
-            gas_price,
-        )?;
         // cant overflow as metered bytes * gas_per_byte < u64::MAX
         let gas_used_by_bytes = fee_params
             .gas_per_byte
@@ -1728,13 +1804,11 @@ mod tests {
         let max_gas = min_gas
             .saturating_add(*tx.script_gas_limit())
             .saturating_add(witness_limit_allowance);
-        let max_fee: u64 = gas_to_fee(max_gas, gas_price, fee_params.gas_price_factor)
-            .try_into()
-            .map_err(|_| ValidityError::BalanceOverflow)?;
+        let max_fee = gas_to_fee(max_gas, gas_price, fee_params.gas_price_factor);
 
-        let max_fee_with_tip = max_fee + tx.tip();
+        let max_fee_with_tip = max_fee.saturating_add(tx.tip() as u128);
 
-        let result = max_fee_with_tip == available_balances.fee.max_fee();
+        let result = max_fee_with_tip == tx.max_fee(gas_costs, fee_params, gas_price);
         Ok(result)
     }
 
@@ -1742,19 +1816,11 @@ mod tests {
         tx: &Tx,
         gas_costs: &GasCosts,
         fee_params: &FeeParameters,
-        base_asset_id: &AssetId,
         gas_price: u64,
     ) -> Result<bool, ValidityError>
     where
         Tx: Chargeable + field::Inputs + field::Outputs,
     {
-        let available_balances = balances::initial_free_balances(
-            tx,
-            gas_costs,
-            fee_params,
-            base_asset_id,
-            gas_price,
-        )?;
         // cant overflow as (metered bytes + gas_used_by_predicates) * gas_per_byte <
         // u64::MAX
         let gas_used_by_bytes = fee_params
@@ -1775,14 +1841,13 @@ mod tests {
         let fee = total / fee_params.gas_price_factor as u128;
         let fee_remainder =
             (total.rem_euclid(fee_params.gas_price_factor as u128) > 0) as u128;
-        let rounded_fee = fee.saturating_add(fee_remainder);
-        let min_fee: u64 = rounded_fee
-            .try_into()
-            .map_err(|_| ValidityError::BalanceOverflow)?;
-
-        let min_fee_with_tip = min_fee + tx.tip();
+        let rounded_fee = fee
+            .saturating_add(fee_remainder)
+            .saturating_add(tx.tip() as u128);
+        let min_fee = rounded_fee;
+        let calculated_min_fee = tx.min_fee(gas_costs, fee_params, gas_price);
 
-        Ok(min_fee_with_tip == available_balances.fee.min_fee())
+        Ok(min_fee == calculated_min_fee)
     }
 
     fn valid_coin_tx(
@@ -1790,10 +1855,12 @@ mod tests {
         gas_limit: u64,
         input_amount: u64,
         output_amount: u64,
+        max_fee_limit: u64,
     ) -> Script {
         let asset = AssetId::default();
         TransactionBuilder::script(vec![], vec![])
             .script_gas_limit(gas_limit)
+            .max_fee_limit(max_fee_limit)
             .add_unsigned_coin_input(
                 SecretKey::random(rng),
                 rng.gen(),
@@ -1825,7 +1892,9 @@ mod tests {
         let asset = AssetId::default();
         let predicate = vec![op::ret(1)].into_iter().collect::<Vec<u8>>();
         let owner = Input::predicate_owner(&predicate);
+        let zero_fee_limit = 0;
         TransactionBuilder::script(vec![], vec![])
+            .max_fee_limit(zero_fee_limit)
             .script_gas_limit(gas_limit)
             .witness_limit(witness_limit)
             .add_input(Input::coin_predicate(
@@ -1847,8 +1916,10 @@ mod tests {
         rng: &mut StdRng,
         gas_limit: u64,
         input_amount: u64,
+        max_fee: u64,
     ) -> Script {
         TransactionBuilder::script(vec![], vec![])
+            .max_fee_limit(max_fee)
             .script_gas_limit(gas_limit)
             .add_unsigned_message_input(
                 SecretKey::random(rng),
@@ -1881,8 +1952,28 @@ mod tests {
             .finalize()
     }
 
-    fn base_asset_tx(rng: &mut StdRng, input_amount: u64, gas_limit: u64) -> Script {
-        TransactionBuilder::script(vec![], vec![])
+    fn base_asset_tx(
+        rng: &mut StdRng,
+        input_amount: u64,
+        gas_limit: u64,
+        max_fee: u64,
+    ) -> Script {
+        base_asset_tx_with_tip(rng, input_amount, gas_limit, max_fee, None)
+    }
+
+    fn base_asset_tx_with_tip(
+        rng: &mut StdRng,
+        input_amount: u64,
+        gas_limit: u64,
+        max_fee: u64,
+        tip: Option<u64>,
+    ) -> Script {
+        let mut builder = TransactionBuilder::script(vec![], vec![]);
+        if let Some(tip) = tip {
+            builder.tip(tip);
+        }
+        builder
+            .max_fee_limit(max_fee)
             .script_gas_limit(gas_limit)
             .add_unsigned_coin_input(
                 SecretKey::random(rng),
diff --git a/fuel-vm/src/checked_transaction/balances.rs b/fuel-vm/src/checked_transaction/balances.rs
index 443b6433c7..b2dc5b50e8 100644
--- a/fuel-vm/src/checked_transaction/balances.rs
+++ b/fuel-vm/src/checked_transaction/balances.rs
@@ -13,11 +13,8 @@ use fuel_tx::{
         },
     },
     Chargeable,
-    FeeParameters,
-    GasCosts,
     Input,
     Output,
-    TransactionFee,
     ValidityError,
 };
 use fuel_types::{
@@ -26,17 +23,36 @@ use fuel_types::{
 };
 
 use alloc::collections::BTreeMap;
+use fuel_tx::policies::PolicyType;
 
 pub(crate) fn initial_free_balances<T>(
-    transaction: &T,
-    gas_costs: &GasCosts,
-    params: &FeeParameters,
+    tx: &T,
     base_asset_id: &AssetId,
-    gas_price: u64,
 ) -> Result<AvailableBalances, ValidityError>
 where
     T: Chargeable + field::Inputs + field::Outputs,
 {
+    let (mut non_retryable_balances, retryable_balance) =
+        add_up_input_balances(tx, base_asset_id);
+
+    let max_fee = tx
+        .policies()
+        .get(PolicyType::MaxFee)
+        .ok_or(ValidityError::TransactionMaxFeeNotSet)?;
+    deduct_max_fee_from_base_asset(&mut non_retryable_balances, base_asset_id, max_fee)?;
+
+    reduce_free_balances_by_coin_outputs(&mut non_retryable_balances, tx)?;
+
+    Ok(AvailableBalances {
+        non_retryable_balances,
+        retryable_balance,
+    })
+}
+
+fn add_up_input_balances<T: field::Inputs>(
+    transaction: &T,
+    base_asset_id: &AssetId,
+) -> (BTreeMap<AssetId, Word>, Word) {
     let mut non_retryable_balances = BTreeMap::<AssetId, Word>::new();
     // The sum of [`AssetId::Base`] from metadata messages.
     let mut retryable_balance: Word = 0;
@@ -67,19 +83,29 @@ where
         }
     }
 
-    // Deduct fee from base asset
-    let fee = TransactionFee::checked_from_tx(gas_costs, params, transaction, gas_price)
-        .ok_or(ValidityError::BalanceOverflow)?;
+    (non_retryable_balances, retryable_balance)
+}
 
+fn deduct_max_fee_from_base_asset(
+    non_retryable_balances: &mut BTreeMap<AssetId, Word>,
+    base_asset_id: &AssetId,
+    max_fee: Word,
+) -> Result<(), ValidityError> {
     let base_asset_balance = non_retryable_balances.entry(*base_asset_id).or_default();
-
-    *base_asset_balance = fee.checked_deduct_total(*base_asset_balance).ok_or(
+    *base_asset_balance = base_asset_balance.checked_sub(max_fee).ok_or(
         ValidityError::InsufficientFeeAmount {
-            expected: fee.max_fee(),
+            expected: max_fee,
             provided: *base_asset_balance,
         },
     )?;
 
+    Ok(())
+}
+
+fn reduce_free_balances_by_coin_outputs(
+    non_retryable_balances: &mut BTreeMap<AssetId, Word>,
+    transaction: &impl field::Outputs,
+) -> Result<(), ValidityError> {
     // reduce free balances by coin outputs
     for (asset_id, amount) in
         transaction
@@ -104,15 +130,10 @@ where
         )?;
     }
 
-    Ok(AvailableBalances {
-        non_retryable_balances,
-        retryable_balance,
-        fee,
-    })
+    Ok(())
 }
 
 pub(crate) struct AvailableBalances {
     pub(crate) non_retryable_balances: BTreeMap<AssetId, Word>,
     pub(crate) retryable_balance: Word,
-    pub(crate) fee: TransactionFee,
 }
diff --git a/fuel-vm/src/checked_transaction/builder.rs b/fuel-vm/src/checked_transaction/builder.rs
index 9d41446698..cfd9c9cc89 100644
--- a/fuel-vm/src/checked_transaction/builder.rs
+++ b/fuel-vm/src/checked_transaction/builder.rs
@@ -20,15 +20,11 @@ where
     Tx: IntoChecked,
 {
     /// Finalize the builder into a [`Checked<Tx>`] of the correct type
-    fn finalize_checked(&mut self, height: BlockHeight, gas_price: u64) -> Checked<Tx>;
+    fn finalize_checked(&self, height: BlockHeight) -> Checked<Tx>;
 
     /// Finalize the builder into a [`Checked<Tx>`] of the correct type, with basic checks
     /// only
-    fn finalize_checked_basic(
-        &mut self,
-        height: BlockHeight,
-        gas_price: u64,
-    ) -> Checked<Tx>;
+    fn finalize_checked_basic(&self, height: BlockHeight) -> Checked<Tx>;
 }
 
 impl<Tx: ExecutableTransaction> TransactionBuilderExt<Tx> for TransactionBuilder<Tx>
@@ -36,19 +32,15 @@ where
     Self: Finalizable<Tx>,
     Checked<Tx>: CheckPredicates,
 {
-    fn finalize_checked(&mut self, height: BlockHeight, gas_price: u64) -> Checked<Tx> {
+    fn finalize_checked(&self, height: BlockHeight) -> Checked<Tx> {
         self.finalize()
-            .into_checked(height, self.get_params(), gas_price)
+            .into_checked(height, self.get_params())
             .expect("failed to check tx")
     }
 
-    fn finalize_checked_basic(
-        &mut self,
-        height: BlockHeight,
-        gas_price: u64,
-    ) -> Checked<Tx> {
+    fn finalize_checked_basic(&self, height: BlockHeight) -> Checked<Tx> {
         self.finalize()
-            .into_checked_basic(height, self.get_params(), gas_price)
+            .into_checked_basic(height, self.get_params())
             .expect("failed to check tx")
     }
 }
diff --git a/fuel-vm/src/checked_transaction/types.rs b/fuel-vm/src/checked_transaction/types.rs
index c97ea17e6e..a9f7b303e2 100644
--- a/fuel-vm/src/checked_transaction/types.rs
+++ b/fuel-vm/src/checked_transaction/types.rs
@@ -72,7 +72,6 @@ pub mod create {
         ConsensusParameters,
         Create,
         FormatValidityChecks,
-        TransactionFee,
     };
     use fuel_types::BlockHeight;
 
@@ -83,8 +82,6 @@ pub mod create {
         pub free_balances: NonRetryableFreeBalances,
         /// The block height this tx was verified with
         pub block_height: BlockHeight,
-        /// The fees and gas usage
-        pub fee: TransactionFee,
     }
 
     impl IntoChecked for Create {
@@ -94,25 +91,17 @@ pub mod create {
             mut self,
             block_height: BlockHeight,
             consensus_params: &ConsensusParameters,
-            gas_price: u64,
         ) -> Result<Checked<Self>, CheckError> {
             let chain_id = consensus_params.chain_id();
             self.precompute(&chain_id)?;
-            self.check_without_signatures(block_height, consensus_params, gas_price)?;
+            self.check_without_signatures(block_height, consensus_params)?;
 
             // validate fees and compute free balances
             let AvailableBalances {
                 non_retryable_balances,
                 retryable_balance,
-                fee,
-            } = initial_free_balances(
-                &self,
-                consensus_params.gas_costs(),
-                consensus_params.fee_params(),
-                consensus_params.base_asset_id(),
-                gas_price,
-            )?;
-            assert_eq!(
+            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
+            debug_assert_eq!(
                 retryable_balance, 0,
                 "The `check_without_signatures` should return `TransactionCreateMessageData` above"
             );
@@ -120,7 +109,6 @@ pub mod create {
             let metadata = CheckedMetadata {
                 free_balances: NonRetryableFreeBalances(non_retryable_balances),
                 block_height,
-                fee,
             };
 
             Ok(Checked::basic(self, metadata))
@@ -150,11 +138,10 @@ pub mod mint {
             mut self,
             block_height: BlockHeight,
             consensus_params: &ConsensusParameters,
-            gas_price: u64,
         ) -> Result<Checked<Self>, CheckError> {
             let chain_id = consensus_params.chain_id();
             self.precompute(&chain_id)?;
-            self.check_without_signatures(block_height, consensus_params, gas_price)?;
+            self.check_without_signatures(block_height, consensus_params)?;
 
             Ok(Checked::basic(self, ()))
         }
@@ -181,7 +168,6 @@ pub mod script {
         ConsensusParameters,
         FormatValidityChecks,
         Script,
-        TransactionFee,
     };
     use fuel_types::BlockHeight;
 
@@ -194,8 +180,6 @@ pub mod script {
         pub retryable_balance: RetryableAmount,
         /// The block height this tx was verified with
         pub block_height: BlockHeight,
-        /// The fees and gas usage
-        pub fee: TransactionFee,
     }
 
     impl IntoChecked for Script {
@@ -205,24 +189,16 @@ pub mod script {
             mut self,
             block_height: BlockHeight,
             consensus_params: &ConsensusParameters,
-            gas_price: u64,
         ) -> Result<Checked<Self>, CheckError> {
             let chain_id = consensus_params.chain_id();
             self.precompute(&chain_id)?;
-            self.check_without_signatures(block_height, consensus_params, gas_price)?;
+            self.check_without_signatures(block_height, consensus_params)?;
 
             // validate fees and compute free balances
             let AvailableBalances {
                 non_retryable_balances,
                 retryable_balance,
-                fee,
-            } = initial_free_balances(
-                &self,
-                consensus_params.gas_costs(),
-                consensus_params.fee_params(),
-                consensus_params.base_asset_id(),
-                gas_price,
-            )?;
+            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
 
             let metadata = CheckedMetadata {
                 non_retryable_balances: NonRetryableFreeBalances(non_retryable_balances),
@@ -231,7 +207,6 @@ pub mod script {
                     base_asset_id: consensus_params.base_asset_id,
                 },
                 block_height,
-                fee,
             };
 
             Ok(Checked::basic(self, metadata))
diff --git a/fuel-vm/src/error.rs b/fuel-vm/src/error.rs
index 974b0d1a6c..a4ed0ae37c 100644
--- a/fuel-vm/src/error.rs
+++ b/fuel-vm/src/error.rs
@@ -8,6 +8,7 @@ use fuel_asm::{
 };
 use fuel_tx::ValidityError;
 
+use crate::checked_transaction::CheckError;
 use alloc::{
     format,
     string::{
@@ -35,9 +36,9 @@ pub enum InterpreterError<StorageError> {
     /// contract.
     #[display(fmt = "Execution error: {_0:?}")]
     Panic(PanicReason),
-    /// The provided transaction isn't valid.
-    #[display(fmt = "Failed to validate the transaction: {_0}")]
-    TransactionValidity(ValidityError),
+    /// Failed while checking the transaction.
+    #[display(fmt = "Failed to check the transaction: {_0:?}")]
+    CheckError(CheckError),
     /// No transaction was initialized in the interpreter. It cannot provide
     /// state transitions.
     #[display(fmt = "Execution error")]
@@ -51,6 +52,16 @@ pub enum InterpreterError<StorageError> {
     /// Encountered a bug
     #[display(fmt = "Bug: {_0}")]
     Bug(Bug),
+    /// The `Ready` transaction provided to `Interpreter` doesn't have expected gas price
+    #[display(
+        fmt = "The transaction's gas price is wrong: expected {expected}, got {actual}"
+    )]
+    ReadyTransactionWrongGasPrice {
+        /// Expected gas price
+        expected: Word,
+        /// Actual gas price
+        actual: Word,
+    },
 }
 
 impl<StorageError> InterpreterError<StorageError> {
@@ -104,12 +115,16 @@ where
             Self::Storage(e) => InterpreterError::Storage(format!("{e:?}")),
             Self::PanicInstruction(e) => InterpreterError::PanicInstruction(*e),
             Self::Panic(e) => InterpreterError::Panic(*e),
-            Self::TransactionValidity(e) => {
-                InterpreterError::TransactionValidity(e.clone())
-            }
             Self::NoTransactionInitialized => InterpreterError::NoTransactionInitialized,
             Self::DebugStateNotInitialized => InterpreterError::DebugStateNotInitialized,
             Self::Bug(e) => InterpreterError::Bug(e.clone()),
+            Self::CheckError(e) => InterpreterError::CheckError(e.clone()),
+            InterpreterError::ReadyTransactionWrongGasPrice { expected, actual } => {
+                InterpreterError::ReadyTransactionWrongGasPrice {
+                    expected: *expected,
+                    actual: *actual,
+                }
+            }
         }
     }
 }
@@ -124,12 +139,6 @@ impl<StorageError> From<RuntimeError<StorageError>> for InterpreterError<Storage
     }
 }
 
-impl<StorageError> From<ValidityError> for InterpreterError<StorageError> {
-    fn from(error: ValidityError) -> Self {
-        Self::TransactionValidity(error)
-    }
-}
-
 impl<StorageError> PartialEq for InterpreterError<StorageError>
 where
     StorageError: PartialEq,
@@ -138,7 +147,6 @@ where
         match (self, other) {
             (Self::PanicInstruction(s), Self::PanicInstruction(o)) => s == o,
             (Self::Panic(s), Self::Panic(o)) => s == o,
-            (Self::TransactionValidity(s), Self::TransactionValidity(o)) => s == o,
             (Self::NoTransactionInitialized, Self::NoTransactionInitialized) => true,
             (Self::Storage(a), Self::Storage(b)) => a == b,
             (Self::DebugStateNotInitialized, Self::DebugStateNotInitialized) => true,
@@ -160,6 +168,12 @@ impl<StorageError> From<Infallible> for InterpreterError<StorageError> {
     }
 }
 
+impl<StorageError> From<ValidityError> for InterpreterError<StorageError> {
+    fn from(err: ValidityError) -> Self {
+        Self::CheckError(CheckError::Validity(err))
+    }
+}
+
 /// Runtime error description that should either be specified in the protocol or
 /// halt the execution.
 #[derive(Debug)]
diff --git a/fuel-vm/src/interpreter/debug.rs b/fuel-vm/src/interpreter/debug.rs
index f07d87bf72..888ce4ee07 100644
--- a/fuel-vm/src/interpreter/debug.rs
+++ b/fuel-vm/src/interpreter/debug.rs
@@ -71,7 +71,7 @@ fn breakpoint_script() {
     let mut vm = Interpreter::<_, _>::with_memory_storage();
 
     let gas_limit = 1_000_000;
-    let zero_gas_price = 0;
+    let gas_price = 0;
     let height = Default::default();
 
     let script = [
@@ -91,8 +91,14 @@ fn breakpoint_script() {
         .script_gas_limit(gas_limit)
         .add_random_fee_input()
         .finalize()
-        .into_checked(height, &consensus_params, zero_gas_price)
-        .expect("failed to generate checked tx");
+        .into_checked(height, &consensus_params)
+        .expect("failed to generate checked tx")
+        .into_ready(
+            gas_price,
+            &consensus_params.gas_costs,
+            &consensus_params.fee_params,
+        )
+        .unwrap();
 
     let suite = vec![
         (
@@ -144,10 +150,9 @@ fn single_stepping() {
 
     let mut vm = Interpreter::<_, _>::with_memory_storage();
 
-    let zero_gas_price = 0;
-
     let gas_limit = 1_000_000;
     let height = Default::default();
+    let gas_price = 0;
 
     // Repeats the middle two instructions five times
     let script = [
@@ -165,8 +170,14 @@ fn single_stepping() {
         .script_gas_limit(gas_limit)
         .add_random_fee_input()
         .finalize()
-        .into_checked(height, &consensus_params, zero_gas_price)
-        .expect("failed to generate checked tx");
+        .into_checked(height, &consensus_params)
+        .expect("failed to generate checked tx")
+        .into_ready(
+            gas_price,
+            &consensus_params.gas_costs,
+            &consensus_params.fee_params,
+        )
+        .unwrap();
 
     vm.set_single_stepping(true);
 
diff --git a/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs b/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
index 9f4064d4e8..b7b54d406d 100644
--- a/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
+++ b/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
@@ -33,7 +33,7 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
     let opcode = random_instruction.opcode();
 
     if opcode == Opcode::ECAL {
-        return TestResult::passed() // ECAL can do anything with registers, so skip it
+        return TestResult::passed(); // ECAL can do anything with registers, so skip it
     }
 
     // ignore if rA/rB isn't set to writeable register and the opcode should write to that
@@ -41,10 +41,10 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
     let [ra, rb, _, _] = random_instruction.reg_ids();
     match (ra, rb) {
         (Some(r), _) if writes_to_ra(opcode) && r >= RegId::WRITABLE => {
-            return TestResult::discard()
+            return TestResult::discard();
         }
         (_, Some(r)) if writes_to_rb(opcode) && r >= RegId::WRITABLE => {
-            return TestResult::discard()
+            return TestResult::discard();
         }
         _ => (),
     }
@@ -67,8 +67,10 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
         .finalize();
 
     let tx = tx
-        .into_checked(block_height, &consensus_params, zero_gas_price)
-        .expect("failed to check tx");
+        .into_checked(block_height, &consensus_params)
+        .expect("failed to check tx")
+        .into_ready(zero_gas_price, vm.gas_costs(), &fee_params)
+        .expect("failed dynamic checks");
 
     vm.init_script(tx).expect("Failed to init VM");
     let res = vm.instruction(raw_random_instruction);
@@ -91,7 +93,7 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
                 return TestResult::error(format!(
                     "expected ReservedRegisterNotWritable error {:?}",
                     (opcode, &res)
-                ))
+                ));
             }
         }
     } else if matches!(
@@ -113,10 +115,10 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
     // erroneous register access. This is not a comprehensive set of all possible
     // writeable violations but more can be added.
     if vm.registers[RegId::ZERO] != 0 {
-        return TestResult::error("reserved register was modified!")
+        return TestResult::error("reserved register was modified!");
     }
     if vm.registers[RegId::ONE] != 1 {
-        return TestResult::error("reserved register was modified!")
+        return TestResult::error("reserved register was modified!");
     }
 
     TestResult::passed()
diff --git a/fuel-vm/src/interpreter/executors/main.rs b/fuel-vm/src/interpreter/executors/main.rs
index b02329fdb4..9493776504 100644
--- a/fuel-vm/src/interpreter/executors/main.rs
+++ b/fuel-vm/src/interpreter/executors/main.rs
@@ -44,7 +44,10 @@ use crate::{
 };
 
 use crate::{
-    checked_transaction::CheckPredicateParams,
+    checked_transaction::{
+        CheckPredicateParams,
+        Ready,
+    },
     interpreter::InterpreterParams,
 };
 use fuel_asm::{
@@ -647,7 +650,7 @@ where
     /// result of th execution in form of [`StateTransition`]
     pub fn transact_owned(
         storage: S,
-        tx: Checked<Tx>,
+        tx: Ready<Tx>,
         params: InterpreterParams,
     ) -> Result<StateTransition<Tx>, InterpreterError<S::DataError>> {
         let mut interpreter = Self::with_storage(storage, params);
@@ -673,8 +676,10 @@ where
     /// that can be referenced from the interpreter instance itself.
     pub fn transact(
         &mut self,
-        tx: Checked<Tx>,
+        tx: Ready<Tx>,
     ) -> Result<StateTransitionRef<'_, Tx>, InterpreterError<S::DataError>> {
+        self.verify_ready_tx(&tx)?;
+
         let state_result = self.init_script(tx).and_then(|_| self.run());
         self.post_execute();
 
@@ -706,9 +711,13 @@ where
     /// Returns `Create` transaction with all modifications after execution.
     pub fn deploy(
         &mut self,
-        tx: Checked<Create>,
+        tx: Ready<Create>,
     ) -> Result<Create, InterpreterError<S::DataError>> {
-        let (mut create, metadata) = tx.into();
+        self.verify_ready_tx(&tx)?;
+
+        let (_, checked) = tx.decompose();
+        let (mut create, metadata): (Create, <Create as IntoChecked>::Metadata) =
+            checked.into();
         let gas_costs = self.gas_costs().clone();
         let fee_params = *self.fee_params();
         let base_asset_id = *self.base_asset_id();
@@ -725,3 +734,27 @@ where
         Ok(create)
     }
 }
+
+impl<S: InterpreterStorage, Tx, Ecal> Interpreter<S, Tx, Ecal> {
+    fn verify_ready_tx<Tx2: IntoChecked>(
+        &self,
+        tx: &Ready<Tx2>,
+    ) -> Result<(), InterpreterError<S::DataError>> {
+        self.gas_price_matches(tx)?;
+        Ok(())
+    }
+
+    fn gas_price_matches<Tx2: IntoChecked>(
+        &self,
+        tx: &Ready<Tx2>,
+    ) -> Result<(), InterpreterError<S::DataError>> {
+        if tx.gas_price() != self.gas_price() {
+            Err(InterpreterError::ReadyTransactionWrongGasPrice {
+                expected: self.gas_price(),
+                actual: tx.gas_price(),
+            })
+        } else {
+            Ok(())
+        }
+    }
+}
diff --git a/fuel-vm/src/interpreter/executors/main/tests.rs b/fuel-vm/src/interpreter/executors/main/tests.rs
index 6b6b641c04..80aafe4157 100644
--- a/fuel-vm/src/interpreter/executors/main/tests.rs
+++ b/fuel-vm/src/interpreter/executors/main/tests.rs
@@ -1,3 +1,5 @@
+#![allow(non_snake_case)]
+
 use alloc::{
     vec,
     vec::Vec,
@@ -19,6 +21,7 @@ use rand::{
 
 use crate::{
     checked_transaction::CheckPredicates,
+    interpreter::InterpreterParams,
     prelude::*,
 };
 
@@ -27,7 +30,6 @@ fn estimate_gas_gives_proper_gas_used() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
     let params = &ConsensusParameters::standard();
 
-    let gas_price = 1_000;
     let gas_limit = 1_000_000;
     let script = vec![
         op::addi(0x20, 0x20, 1),
@@ -54,7 +56,7 @@ fn estimate_gas_gives_proper_gas_used() {
     );
 
     let transaction_without_predicate = builder
-        .finalize_checked_basic(Default::default(), gas_price)
+        .finalize_checked_basic(Default::default())
         .check_predicates(&params.into())
         .expect("Predicate check failed even if we don't have any predicates");
 
@@ -92,7 +94,7 @@ fn estimate_gas_gives_proper_gas_used() {
     // unestimated transaction should fail as it's predicates are not estimated
     assert!(transaction
         .clone()
-        .into_checked(Default::default(), params, gas_price)
+        .into_checked(Default::default(), params)
         .is_err());
 
     Interpreter::<PredicateStorage, _>::estimate_predicates(
@@ -103,6 +105,97 @@ fn estimate_gas_gives_proper_gas_used() {
 
     // transaction should pass checking after estimation
 
-    let check_res = transaction.into_checked(Default::default(), params, gas_price);
+    let check_res = transaction.into_checked(Default::default(), params);
     assert!(check_res.is_ok());
 }
+
+#[test]
+fn transact__tx_with_wrong_gas_price_causes_error() {
+    let mut rng = &mut StdRng::seed_from_u64(2322u64);
+
+    // given
+    let tx_gas_price = 1;
+    let interpreter_gas_price = 2;
+    let input_amount = 1000;
+    let arb_max_fee = input_amount;
+
+    let interpreter_params = InterpreterParams {
+        gas_price: interpreter_gas_price,
+        ..Default::default()
+    };
+
+    let ready_tx = TransactionBuilder::script(vec![], vec![])
+        .max_fee_limit(arb_max_fee)
+        .add_unsigned_coin_input(
+            SecretKey::random(&mut rng),
+            rng.gen(),
+            input_amount,
+            AssetId::default(),
+            rng.gen(),
+        )
+        .finalize_checked_basic(Default::default())
+        .into_ready(
+            tx_gas_price,
+            &interpreter_params.gas_costs,
+            &interpreter_params.fee_params,
+        )
+        .unwrap();
+
+    // when
+    let mut transactor =
+        Transactor::<_, _>::new(MemoryStorage::default(), interpreter_params);
+    transactor.transact_ready_tx(ready_tx);
+
+    // then
+    let err = transactor.error().expect("Expected error");
+    assert!(matches!(
+        *err,
+        InterpreterError::ReadyTransactionWrongGasPrice { .. }
+    ));
+}
+
+#[test]
+fn deploy__tx_with_wrong_gas_price_causes_error() {
+    let mut rng = &mut StdRng::seed_from_u64(2322u64);
+
+    // given
+    let tx_gas_price = 1;
+    let interpreter_gas_price = 2;
+    let input_amount = 1000;
+    let arb_max_fee = input_amount;
+
+    let interpreter_params = InterpreterParams {
+        gas_price: interpreter_gas_price,
+        ..Default::default()
+    };
+    let witness = Witness::default();
+    let salt = rng.gen();
+
+    let ready_tx = TransactionBuilder::create(witness, salt, vec![])
+        .max_fee_limit(arb_max_fee)
+        .add_unsigned_coin_input(
+            SecretKey::random(&mut rng),
+            rng.gen(),
+            input_amount,
+            AssetId::default(),
+            rng.gen(),
+        )
+        .finalize_checked_basic(Default::default())
+        .into_ready(
+            tx_gas_price,
+            &interpreter_params.gas_costs,
+            &interpreter_params.fee_params,
+        )
+        .unwrap();
+
+    // when
+    let mut transactor =
+        Transactor::<_, Create>::new(MemoryStorage::default(), interpreter_params);
+    let err = transactor.deploy_ready_tx(ready_tx).unwrap_err();
+
+    // then
+    assert!(matches!(
+        err,
+        InterpreterError::ReadyTransactionWrongGasPrice { .. }
+    ));
+}
diff --git a/fuel-vm/src/interpreter/initialization.rs b/fuel-vm/src/interpreter/initialization.rs
index 16f78a62b9..2bb8c693ea 100644
--- a/fuel-vm/src/interpreter/initialization.rs
+++ b/fuel-vm/src/interpreter/initialization.rs
@@ -6,8 +6,8 @@ use super::{
 };
 use crate::{
     checked_transaction::{
-        Checked,
         IntoChecked,
+        Ready,
     },
     consts::*,
     context::Context,
@@ -102,12 +102,13 @@ where
     /// For predicate estimation and verification, check [`Self::init_predicate`]
     pub fn init_script(
         &mut self,
-        checked: Checked<Tx>,
+        ready_tx: Ready<Tx>,
     ) -> Result<(), InterpreterError<S::DataError>> {
         let block_height = self.storage.block_height().map_err(RuntimeError::Storage)?;
 
         self.context = Context::Script { block_height };
 
+        let (_, checked) = ready_tx.decompose();
         let (tx, metadata): (Tx, Tx::Metadata) = checked.into();
 
         let gas_limit = tx
diff --git a/fuel-vm/src/interpreter/internal/tests.rs b/fuel-vm/src/interpreter/internal/tests.rs
index 336115d9e1..e2e9ae5259 100644
--- a/fuel-vm/src/interpreter/internal/tests.rs
+++ b/fuel-vm/src/interpreter/internal/tests.rs
@@ -32,18 +32,20 @@ fn external_balance() {
 
     let mut vm = Interpreter::<_, _>::with_memory_storage();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
+    let gas_price = 0;
+    let gas_costs = GasCosts::default();
+    let fee_params = ConsensusParameters::standard().fee_params;
 
     let script = op::ret(0x01).to_bytes().to_vec();
     let balances = vec![(rng.gen(), 100), (rng.gen(), 500)];
 
-    let mut tx = TransactionBuilder::script(script, Default::default());
+    let mut builder = TransactionBuilder::script(script, Default::default());
 
     balances.iter().copied().for_each(|(asset, amount)| {
-        tx.add_unsigned_coin_input(
+        builder.add_unsigned_coin_input(
             SecretKey::random(&mut rng),
             rng.gen(),
             amount,
@@ -52,11 +54,13 @@ fn external_balance() {
         );
     });
 
-    let tx = tx
+    let tx = builder
         .script_gas_limit(gas_limit)
         .script_gas_limit(100)
         .maturity(maturity)
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height)
+        .into_ready(gas_price, &gas_costs, &fee_params)
+        .unwrap();
 
     vm.init_script(tx).expect("Failed to init VM!");
 
@@ -65,7 +69,7 @@ fn external_balance() {
             &mut vm.balances,
             &mut vm.memory,
             &asset_id,
-            amount + 1
+            amount + 1,
         )
         .is_err());
         external_asset_id_balance_sub(
@@ -79,7 +83,7 @@ fn external_balance() {
             &mut vm.balances,
             &mut vm.memory,
             &asset_id,
-            11
+            11,
         )
         .is_err());
         external_asset_id_balance_sub(&mut vm.balances, &mut vm.memory, &asset_id, 10)
@@ -88,7 +92,7 @@ fn external_balance() {
             &mut vm.balances,
             &mut vm.memory,
             &asset_id,
-            1
+            1,
         )
         .is_err());
     }
@@ -123,8 +127,14 @@ fn variable_output_updates_in_memory() {
         .add_random_fee_input()
         .add_output(variable_output)
         .finalize()
-        .into_checked(height, &consensus_params, zero_gas_price)
-        .expect("failed to check tx");
+        .into_checked(height, &consensus_params)
+        .expect("failed to check tx")
+        .into_ready(
+            zero_gas_price,
+            &GasCosts::default(),
+            &consensus_params.fee_params,
+        )
+        .unwrap();
 
     vm.init_script(tx).expect("Failed to init VM!");
 
diff --git a/fuel-vm/src/interpreter/memory/tests.rs b/fuel-vm/src/interpreter/memory/tests.rs
index 14615c178b..1122417296 100644
--- a/fuel-vm/src/interpreter/memory/tests.rs
+++ b/fuel-vm/src/interpreter/memory/tests.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::cast_possible_truncation)]
+
 use alloc::vec;
 use core::ops::Range;
 
@@ -32,8 +33,14 @@ fn memcopy() {
         .finalize();
 
     let tx = tx
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
-        .expect("default tx should produce a valid checked transaction");
+        .into_checked(Default::default(), &consensus_params)
+        .expect("default tx should produce a valid checked transaction")
+        .into_ready(
+            zero_gas_price,
+            &consensus_params.gas_costs,
+            &consensus_params.fee_params,
+        )
+        .unwrap();
 
     vm.init_script(tx).expect("Failed to init VM");
 
@@ -85,18 +92,20 @@ fn memcopy() {
 
 #[test]
 fn memrange() {
-    let zero_gas_price = 0;
-
+    let gas_price = 0;
+    let consensus_params = ConsensusParameters::standard();
     let tx = TransactionBuilder::script(vec![], vec![])
         .script_gas_limit(1000000)
         .add_random_fee_input()
         .finalize()
-        .into_checked(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            zero_gas_price,
+        .into_checked(Default::default(), &ConsensusParameters::standard())
+        .expect("Empty script should be valid")
+        .into_ready(
+            gas_price,
+            &consensus_params.gas_costs,
+            &consensus_params.fee_params,
         )
-        .expect("Empty script should be valid");
+        .unwrap();
     let mut vm = Interpreter::<_, _>::with_memory_storage();
     vm.init_script(tx).expect("Failed to init VM");
 
@@ -120,18 +129,21 @@ fn memrange() {
 #[test]
 fn stack_alloc_ownership() {
     let mut vm = Interpreter::<_, _>::with_memory_storage();
-    let zero_gas_price = 0;
+    let gas_price = 0;
+    let consensus_params = ConsensusParameters::standard();
 
     let tx = TransactionBuilder::script(vec![], vec![])
         .script_gas_limit(1000000)
         .add_random_fee_input()
         .finalize()
-        .into_checked(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            zero_gas_price,
+        .into_checked(Default::default(), &ConsensusParameters::standard())
+        .expect("Empty script should be valid")
+        .into_ready(
+            gas_price,
+            &consensus_params.gas_costs,
+            &consensus_params.fee_params,
         )
-        .expect("Empty script should be valid");
+        .unwrap();
     vm.init_script(tx).expect("Failed to init VM");
 
     vm.instruction(op::move_(0x10, RegId::SP)).unwrap();
@@ -143,23 +155,23 @@ fn stack_alloc_ownership() {
 
 #[test_case(
     OwnershipRegisters::test(0..0, 0..0, Context::Call{ block_height: Default::default()}), 0..0
-    => true ; "empty mem range"
+    => true; "empty mem range"
 )]
 #[test_case(
     OwnershipRegisters::test(0..0, 0..0, Context::Script{ block_height: Default::default()}), 0..0
-    => true ; "empty mem range (external)"
+    => true; "empty mem range (external)"
 )]
 #[test_case(
     OwnershipRegisters::test(0..0, 0..0, Context::Call{ block_height: Default::default()}), 0..1
-    => false ; "empty stack and heap"
+    => false; "empty stack and heap"
 )]
 #[test_case(
     OwnershipRegisters::test(0..0, VM_MAX_RAM..VM_MAX_RAM, Context::Script{ block_height: Default::default() }), 0..1
-    => false ; "empty stack and heap (external)"
+    => false; "empty stack and heap (external)"
 )]
 #[test_case(
     OwnershipRegisters::test(0..1, 0..0, Context::Call{ block_height: Default::default()}), 0..1
-    => true ; "in range for stack"
+    => true; "in range for stack"
 )]
 #[test_case(
     OwnershipRegisters::test(0..1, 0..0, Context::Call{ block_height: Default::default()}), 0..2
@@ -167,15 +179,15 @@ fn stack_alloc_ownership() {
 )]
 #[test_case(
     OwnershipRegisters::test(0..0, 0..2, Context::Call{ block_height: Default::default()}), 1..2
-    => true ; "in range for heap"
+    => true; "in range for heap"
 )]
 #[test_case(
     OwnershipRegisters::test(0..2, 1..2, Context::Call{ block_height: Default::default()}), 0..2
-    => true ; "crosses stack and heap"
+    => true; "crosses stack and heap"
 )]
 #[test_case(
     OwnershipRegisters::test(0..0, 0..0, Context::Script{ block_height: Default::default()}), 1..2
-    => true ; "in heap range (external)"
+    => true; "in heap range (external)"
 )]
 #[test_case(
     OwnershipRegisters::test(0..19, 31..100, Context::Script{ block_height: Default::default()}), 20..30
@@ -217,47 +229,47 @@ fn set_index(index: usize, val: u8, mut array: [u8; 100]) -> [u8; 100] {
 }
 
 #[test_case(
-    1, &[],
+    1, & [],
     OwnershipRegisters::test(0..1, 100..100, Context::Script{ block_height: Default::default()})
     => (false, [0u8; 100]); "External errors when write is empty"
 )]
 #[test_case(
-    1, &[],
+    1, & [],
     OwnershipRegisters::test(0..1, 100..100, Context::Call{ block_height: Default::default()})
     => (false, [0u8; 100]); "Internal errors when write is empty"
 )]
 #[test_case(
-    1, &[2],
+    1, & [2],
     OwnershipRegisters::test(0..2, 100..100, Context::Script{ block_height: Default::default()})
     => (true, set_index(1, 2, [0u8; 100])); "External writes to stack"
 )]
 #[test_case(
-    98, &[2],
+    98, & [2],
     OwnershipRegisters::test(0..2, 97..100, Context::Script{ block_height: Default::default()})
     => (true, set_index(98, 2, [0u8; 100])); "External writes to heap"
 )]
 #[test_case(
-    1, &[2],
+    1, & [2],
     OwnershipRegisters::test(0..2, 100..100, Context::Call { block_height: Default::default()})
     => (true, set_index(1, 2, [0u8; 100])); "Internal writes to stack"
 )]
 #[test_case(
-    98, &[2],
+    98, & [2],
     OwnershipRegisters::test(0..2, 97..100, Context::Call { block_height: Default::default()})
     => (true, set_index(98, 2, [0u8; 100])); "Internal writes to heap"
 )]
 #[test_case(
-    1, &[2; 50],
+    1, & [2; 50],
     OwnershipRegisters::test(0..40, 100..100, Context::Script{ block_height: Default::default()})
     => (false, [0u8; 100]); "External too large for stack"
 )]
 #[test_case(
-    1, &[2; 50],
+    1, & [2; 50],
     OwnershipRegisters::test(0..40, 100..100, Context::Call{ block_height: Default::default()})
     => (false, [0u8; 100]); "Internal too large for stack"
 )]
 #[test_case(
-    61, &[2; 50],
+    61, & [2; 50],
     OwnershipRegisters::test(0..0, 60..100, Context::Call{ block_height: Default::default()})
     => (false, [0u8; 100]); "Internal too large for heap"
 )]
diff --git a/fuel-vm/src/predicate.rs b/fuel-vm/src/predicate.rs
index 99e95bcffb..76e446bf73 100644
--- a/fuel-vm/src/predicate.rs
+++ b/fuel-vm/src/predicate.rs
@@ -71,8 +71,6 @@ mod tests {
     fn from_tx_works() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
 
-        let zero_gas_price = 0;
-
         let height = 1.into();
 
         #[rustfmt::skip]
@@ -123,7 +121,7 @@ mod tests {
             let tx = TransactionBuilder::script(vec![], vec![])
                 .add_input(i)
                 .add_random_fee_input()
-                .finalize_checked_basic(height, zero_gas_price);
+                .finalize_checked_basic(height);
 
             // assert invalid idx wont panic
             let idx = 1;
@@ -150,7 +148,7 @@ mod tests {
                         program: Default::default()
                     },
                     tx.transaction().clone(),
-                    *tx.transaction().script_gas_limit()
+                    *tx.transaction().script_gas_limit(),
                 )
                 .is_ok());
 
@@ -178,7 +176,6 @@ mod tests {
     #[test]
     fn inputs_are_validated() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
-        let zero_gas_price = 0;
 
         let height = 1.into();
         let predicate_data =
@@ -272,7 +269,7 @@ mod tests {
                 )
                 .add_input(input)
                 .add_random_fee_input()
-                .finalize_checked_basic(height, zero_gas_price);
+                .finalize_checked_basic(height);
 
                 let result = Interpreter::<PredicateStorage, Script>::check_predicates(
                     &tx,
diff --git a/fuel-vm/src/tests/blockchain.rs b/fuel-vm/src/tests/blockchain.rs
index 8f79412cc8..83a22b1ebb 100644
--- a/fuel-vm/src/tests/blockchain.rs
+++ b/fuel-vm/src/tests/blockchain.rs
@@ -63,7 +63,6 @@ fn deploy_contract(
     contract: Witness,
     salt: Salt,
     storage_slots: Vec<StorageSlot>,
-    gas_price: u64,
 ) {
     let code_root = Contract::root_from_code(contract.as_ref());
     let state_root = Contract::initial_state_root(storage_slots.iter());
@@ -76,7 +75,7 @@ fn deploy_contract(
         .with_tx_params(tx_params)
         .add_output(Output::contract_created(contract_id, state_root))
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     client
         .deploy(contract_deployer)
@@ -578,7 +577,6 @@ fn ldc__load_len_of_target_contract<'a>(
     target_contract_witness: Witness,
     include_log_d: bool,
 ) -> &'a [Receipt] {
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -600,7 +598,7 @@ fn ldc__load_len_of_target_contract<'a>(
             .add_random_fee_input()
             .add_output(output0)
             .finalize()
-            .into_checked(height, &consensus_params, gas_price)
+            .into_checked(height, &consensus_params)
             .expect("failed to check tx");
 
     client.deploy(tx_create_target);
@@ -662,7 +660,7 @@ fn ldc__load_len_of_target_contract<'a>(
     .add_random_fee_input()
     .add_output(output1)
     .finalize()
-    .into_checked(height, &consensus_params, gas_price)
+    .into_checked(height, &consensus_params)
     .expect("failed to check tx");
 
     // Patch the code with correct jump address
@@ -679,7 +677,7 @@ fn ldc__load_len_of_target_contract<'a>(
             .add_random_fee_input()
             .add_output(output1)
             .finalize()
-            .into_checked(height, &consensus_params, gas_price)
+            .into_checked(height, &consensus_params)
             .expect("failed to check tx");
 
     client.transact(tx_deploy_loader)
@@ -740,7 +738,7 @@ fn ldc_reason_helper(cmd: Vec<Instruction>, expected_reason: PanicReason) {
         .add_random_fee_input()
         .add_output(output0)
         .finalize()
-        .into_checked(height, &consensus_params, gas_price)
+        .into_checked(height, &consensus_params)
         .expect("failed to check tx");
 
     client.deploy(tx_create_target);
@@ -755,7 +753,7 @@ fn ldc_reason_helper(cmd: Vec<Instruction>, expected_reason: PanicReason) {
     .maturity(maturity)
     .add_random_fee_input()
     .finalize()
-    .into_checked(height, &consensus_params, gas_price)
+    .into_checked(height, &consensus_params)
     .expect("failed to check tx");
 
     let receipts = client.transact(tx_deploy_loader);
@@ -1075,13 +1073,11 @@ fn code_root_a_plus_32_overflow() {
     let code_root = Contract::root_from_code(contract.as_ref());
     let storage_slots = vec![];
 
-    let zero_gas_price = 0;
-
     let state_root = Contract::initial_state_root(storage_slots.iter());
     let contract_id =
         Contract::from(contract.as_ref()).id(&salt, &code_root, &state_root);
 
-    deploy_contract(&mut client, contract, salt, storage_slots, zero_gas_price);
+    deploy_contract(&mut client, contract, salt, storage_slots);
 
     let reg_a = 0x20;
     let reg_contract = 0x21;
@@ -1123,13 +1119,11 @@ fn code_root_a_over_max_ram() {
     let code_root = Contract::root_from_code(contract.as_ref());
     let storage_slots = vec![];
 
-    let zero_gas_price = 0;
-
     let state_root = Contract::initial_state_root(storage_slots.iter());
     let contract_id =
         Contract::from(contract.as_ref()).id(&salt, &code_root, &state_root);
 
-    deploy_contract(&mut client, contract, salt, storage_slots, zero_gas_price);
+    deploy_contract(&mut client, contract, salt, storage_slots);
 
     let reg_a = 0x20;
     let reg_contract = 0x21;
@@ -1197,7 +1191,7 @@ fn code_size_b_over_max_ram() {
 #[test]
 fn sww_sets_status() {
     #[rustfmt::skip]
-        let program = vec![
+    let program = vec![
         op::sww(0x30, SET_STATUS_REG, RegId::ZERO),
         op::srw(0x31, SET_STATUS_REG + 1, RegId::ZERO),
         op::log(SET_STATUS_REG, SET_STATUS_REG + 1, 0x00, 0x00),
@@ -1211,7 +1205,7 @@ fn sww_sets_status() {
 fn scwq_clears_status() {
     #[rustfmt::skip]
     let program = vec![
-        op::sww(0x30,  SET_STATUS_REG, RegId::ZERO),
+        op::sww(0x30, SET_STATUS_REG, RegId::ZERO),
         op::scwq(0x30, SET_STATUS_REG + 1, RegId::ONE),
         op::srw(0x30, SET_STATUS_REG + 2, RegId::ZERO),
         op::log(SET_STATUS_REG, SET_STATUS_REG + 1, SET_STATUS_REG + 2, 0x00),
@@ -1266,7 +1260,7 @@ fn srwq_reads_status() {
     let program = vec![
         op::aloc(0x10),
         op::addi(0x31, RegId::HP, 0x5),
-        op::sww(0x31,  SET_STATUS_REG, RegId::ZERO),
+        op::sww(0x31, SET_STATUS_REG, RegId::ZERO),
         op::srwq(0x31, SET_STATUS_REG + 1, 0x31, RegId::ONE),
         op::srw(0x31, SET_STATUS_REG + 2, 0x31),
         op::log(SET_STATUS_REG, SET_STATUS_REG + 1, SET_STATUS_REG + 2, 0x00),
@@ -1671,8 +1665,8 @@ fn smo_instruction_works() {
             op::movi(0x10, 0),                          // set the txid as recipient
             op::movi(0x12, 2),                          // one byte of data
             op::movi(0x13, message_output_amount as Immediate24),      // expected output amount
-            op::smo(0x10,RegId::HP,0x12,0x13),
-            op::ret(RegId::ONE)
+            op::smo(0x10, RegId::HP, 0x12, 0x13),
+            op::ret(RegId::ONE),
         ];
 
         let script = script.into_iter().collect();
@@ -1691,7 +1685,7 @@ fn smo_instruction_works() {
                 asset_id: Default::default(),
             })
             .add_random_fee_input()
-            .finalize_checked(block_height, gas_price);
+            .finalize_checked(block_height);
 
         let non_retryable_free_balance =
             tx.metadata().non_retryable_balances[&AssetId::BASE];
@@ -1771,7 +1765,7 @@ fn smo_instruction_works() {
         rng,
         vec![(10, vec![0xfa; 15]), (1000, vec![])],
         1011,
-        1
+        1,
     ));
 
     // check that retryable balance is refunded to user
@@ -1779,7 +1773,7 @@ fn smo_instruction_works() {
         rng,
         vec![(10, vec![0xfa; 15]), (1000, vec![])],
         50,
-        1
+        1,
     ));
 }
 
@@ -1787,7 +1781,6 @@ fn smo_instruction_works() {
 fn timestamp_works() {
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let block_height = Default::default();
@@ -1819,7 +1812,7 @@ fn timestamp_works() {
             op::movi(0x11, input),              // set the argument
             op::time(0x10, 0x11),               // perform the instruction
             op::log(0x10, 0x00, 0x00, 0x00),    // log output
-            op::ret(RegId::ONE)
+            op::ret(RegId::ONE),
         ];
 
         let script = script.into_iter().collect();
@@ -1829,7 +1822,7 @@ fn timestamp_works() {
             .script_gas_limit(gas_limit)
             .maturity(maturity)
             .add_random_fee_input()
-            .finalize_checked(block_height, gas_price);
+            .finalize_checked(block_height);
 
         let receipts = client.transact(tx);
         let result = receipts.iter().any(|r| {
@@ -1864,7 +1857,6 @@ fn block_height_works(#[values(0, 1, 2, 10, 100)] current_height: u32) {
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
 
@@ -1874,7 +1866,7 @@ fn block_height_works(#[values(0, 1, 2, 10, 100)] current_height: u32) {
     let script = vec![
         op::bhei(0x20),         // perform the instruction
         op::log(0x20, 0, 0, 0), // log output
-        op::ret(RegId::ONE)
+        op::ret(RegId::ONE),
     ];
 
     let script = script.into_iter().collect();
@@ -1884,7 +1876,7 @@ fn block_height_works(#[values(0, 1, 2, 10, 100)] current_height: u32) {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(current_height, gas_price);
+        .finalize_checked(current_height);
 
     let receipts = client.transact(tx);
     let Some(Receipt::Log { ra, .. }) = receipts.first() else {
@@ -1906,7 +1898,6 @@ fn block_hash_works(
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
 
@@ -1924,7 +1915,7 @@ fn block_hash_works(
         op::movi(0x11, test_height.into()), // set the argument
         op::bhsh(RegId::HP, 0x11),          // perform the instruction
         op::logd(0, 0, RegId::HP, 0x10),    // log output
-        op::ret(RegId::ONE)
+        op::ret(RegId::ONE),
     ];
 
     let script = script.into_iter().collect();
@@ -1934,7 +1925,7 @@ fn block_hash_works(
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(current_height, gas_price);
+        .finalize_checked(current_height);
 
     let receipts = client.transact(tx);
     let Some(Receipt::LogData { data, .. }) = receipts.first() else {
@@ -1948,7 +1939,6 @@ fn block_hash_works(
 fn coinbase_works() {
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
 
@@ -1963,7 +1953,7 @@ fn coinbase_works() {
         op::aloc(0x10),                     // allocate memory
         op::cb(RegId::HP),                  // perform the instruction
         op::logd(0, 0, RegId::HP, 0x10),    // log output
-        op::ret(RegId::ONE)
+        op::ret(RegId::ONE),
     ];
 
     let script = script.into_iter().collect();
@@ -1973,7 +1963,7 @@ fn coinbase_works() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(10.into(), gas_price);
+        .finalize_checked(10.into());
 
     let receipts = client.transact(tx);
     let Some(Receipt::LogData { data, .. }) = receipts.first() else {
diff --git a/fuel-vm/src/tests/code_coverage.rs b/fuel-vm/src/tests/code_coverage.rs
index 98598eda98..26c70f1b08 100644
--- a/fuel-vm/src/tests/code_coverage.rs
+++ b/fuel-vm/src/tests/code_coverage.rs
@@ -30,7 +30,6 @@ const HALF_WORD_SIZE: u64 = (WORD_SIZE as u64) / 2;
 fn code_coverage() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
 
-    let gas_price = 1;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -56,7 +55,7 @@ fn code_coverage() {
         )
         .script_gas_limit(gas_limit)
         .maturity(maturity)
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     #[derive(Clone, Default)]
     struct ProfilingOutput {
diff --git a/fuel-vm/src/tests/contract.rs b/fuel-vm/src/tests/contract.rs
index 27ec3c4dd6..307a4b4f06 100644
--- a/fuel-vm/src/tests/contract.rs
+++ b/fuel-vm/src/tests/contract.rs
@@ -29,7 +29,6 @@ fn prevent_contract_id_redeployment() {
     let mut client = MemoryClient::default();
 
     let input_amount = 1000;
-    let gas_price = 0;
     let spend_amount = 600;
     let asset_id = AssetId::BASE;
 
@@ -48,9 +47,11 @@ fn prevent_contract_id_redeployment() {
 
     let output = Output::contract_created(contract_undefined, state_root);
 
+    let policies = Policies::new().with_max_fee(0);
+
     let mut create = Transaction::create(
         Default::default(),
-        Policies::new(),
+        policies,
         salt,
         vec![],
         vec![],
@@ -73,7 +74,7 @@ fn prevent_contract_id_redeployment() {
     let consensus_params = ConsensusParameters::standard();
 
     let create = create
-        .into_checked_basic(1.into(), &consensus_params, gas_price)
+        .into_checked_basic(1.into(), &consensus_params)
         .expect("failed to generate checked tx");
 
     // deploy contract
diff --git a/fuel-vm/src/tests/crypto.rs b/fuel-vm/src/tests/crypto.rs
index 4957117984..3d80a0ddd0 100644
--- a/fuel-vm/src/tests/crypto.rs
+++ b/fuel-vm/src/tests/crypto.rs
@@ -48,7 +48,6 @@ fn secp256k1_recover() {
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -87,7 +86,7 @@ fn secp256k1_recover() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -103,7 +102,6 @@ fn ecrecover_tx_id() {
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -146,9 +144,7 @@ fn ecrecover_tx_id() {
     tx.sign_inputs(&secret, &chain_id);
 
     let consensus_params = ConsensusParameters::standard_with_id(chain_id);
-    let tx = tx
-        .into_checked(height, &consensus_params, gas_price)
-        .unwrap();
+    let tx = tx.into_checked(height, &consensus_params).unwrap();
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -165,7 +161,6 @@ async fn recover_tx_id_predicate() {
     use rand::Rng;
     let rng = &mut StdRng::seed_from_u64(1234u64);
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
 
@@ -233,7 +228,7 @@ async fn recover_tx_id_predicate() {
             .expect("Should estimate predicate successfully");
 
         tx_for_async
-            .into_checked(maturity, &consensus_params, gas_price)
+            .into_checked(maturity, &consensus_params)
             .expect("Should check predicate successfully");
     }
 
@@ -241,7 +236,7 @@ async fn recover_tx_id_predicate() {
     tx.estimate_predicates(&check_params)
         .expect("Should estimate predicate successfully");
 
-    tx.into_checked(maturity, &consensus_params, gas_price)
+    tx.into_checked(maturity, &consensus_params)
         .expect("Should check predicate successfully");
 }
 
@@ -338,7 +333,6 @@ fn secp256r1_recover() {
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -377,7 +371,7 @@ fn secp256r1_recover() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -386,6 +380,7 @@ fn secp256r1_recover() {
 
     assert!(success);
 }
+
 #[test]
 fn secp256r1_recover_error() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
@@ -477,7 +472,6 @@ fn ed25519_verify() {
 
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -514,7 +508,7 @@ fn ed25519_verify() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -615,7 +609,6 @@ fn ed25519_verify_c_gt_vmaxram_sub_32() {
 fn sha256() {
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -647,7 +640,7 @@ fn sha256() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -663,7 +656,7 @@ fn s256_a_gt_vmaxram_sub_32() {
     let reg_b = 0x21;
 
     #[rustfmt::skip]
-        let script = vec![
+    let script = vec![
         op::xor(reg_b, reg_b, reg_b),
         op::not(reg_a, RegId::ZERO),
         op::s256(reg_a, reg_b, reg_b),
@@ -677,7 +670,7 @@ fn s256_c_gt_mem_max() {
     let reg_a = 0x20;
 
     #[rustfmt::skip]
-        let script = vec![
+    let script = vec![
         op::not(reg_a, RegId::ZERO),
         op::s256(RegId::ZERO, RegId::ZERO, reg_a),
     ];
@@ -691,7 +684,7 @@ fn s256_b_gt_vmaxram_sub_c() {
     let reg_b = 0x21;
 
     #[rustfmt::skip]
-        let script = vec![
+    let script = vec![
         op::xor(reg_b, reg_b, reg_b),
         op::not(reg_a, RegId::ZERO),
         op::s256(reg_b, reg_a, reg_b),
@@ -704,7 +697,6 @@ fn s256_b_gt_vmaxram_sub_c() {
 fn keccak256() {
     let mut client = MemoryClient::default();
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let maturity = Default::default();
     let height = Default::default();
@@ -739,7 +731,7 @@ fn keccak256() {
         .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
-        .finalize_checked(height, gas_price);
+        .finalize_checked(height);
 
     let receipts = client.transact(tx);
     let success = receipts
@@ -755,7 +747,7 @@ fn k256_a_gt_vmaxram_sub_32() {
     let reg_b = 0x21;
 
     #[rustfmt::skip]
-        let script = vec![
+    let script = vec![
         op::xor(reg_b, reg_b, reg_b),
         op::not(reg_a, RegId::ZERO),
         op::k256(reg_a, reg_b, reg_b),
@@ -785,7 +777,7 @@ fn k256_b_gt_vmaxram_sub_c() {
     let reg_b = 0x21;
 
     #[rustfmt::skip]
-        let script = vec![
+    let script = vec![
         op::xor(reg_b, reg_b, reg_b),
         op::not(reg_a, RegId::ZERO),
         op::k256(reg_b, reg_a, reg_b),
diff --git a/fuel-vm/src/tests/external.rs b/fuel-vm/src/tests/external.rs
index 3916035107..d919c29d79 100644
--- a/fuel-vm/src/tests/external.rs
+++ b/fuel-vm/src/tests/external.rs
@@ -23,6 +23,7 @@ use itertools::Itertools;
 /// An ECAL opcode handler function, which charges for `noop` and does nothing.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct NoopEcal;
+
 impl ::fuel_vm::interpreter::EcalHandler for NoopEcal {
     fn ecal<S, Tx>(
         vm: &mut ::fuel_vm::prelude::Interpreter<S, Tx, Self>,
@@ -37,7 +38,6 @@ impl ::fuel_vm::interpreter::EcalHandler for NoopEcal {
 
 #[test]
 fn noop_ecal() {
-    let zero_gas_price = 0;
     let script = vec![
         op::ecal(RegId::ZERO, RegId::ZERO, RegId::ZERO, RegId::ZERO),
         op::ret(RegId::ONE),
@@ -55,7 +55,7 @@ fn noop_ecal() {
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     let receipts = client.receipts().expect("Expected receipts");
@@ -68,6 +68,7 @@ fn noop_ecal() {
 
 #[derive(Debug, Default, Clone, Copy)]
 pub struct SumProdEcal;
+
 impl ::fuel_vm::interpreter::EcalHandler for SumProdEcal {
     /// This ecal fn computes saturating sum and product of inputs (a,b,c,d),
     /// and stores them in a and b respectively. It charges only a single gas.
@@ -100,7 +101,6 @@ impl ::fuel_vm::interpreter::EcalHandler for SumProdEcal {
 #[test]
 fn provide_ecal_fn() {
     let vm: Interpreter<_, Script, SumProdEcal> = Interpreter::with_memory_storage();
-    let zero_gas_price = 0;
 
     let script_data = [
         2u64.to_be_bytes(),
@@ -131,7 +131,7 @@ fn provide_ecal_fn() {
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     let receipts = client.receipts().expect("Expected receipts");
diff --git a/fuel-vm/src/tests/gas_factor.rs b/fuel-vm/src/tests/gas_factor.rs
index 65a7dea171..d783818514 100644
--- a/fuel-vm/src/tests/gas_factor.rs
+++ b/fuel-vm/src/tests/gas_factor.rs
@@ -7,7 +7,10 @@ use crate::{
 use core::iter;
 use fuel_asm::op;
 use fuel_tx::{
-    field::Outputs,
+    field::{
+        MaxFeeLimit,
+        Outputs,
+    },
     ConsensusParameters,
     FeeParameters,
 };
@@ -21,6 +24,8 @@ fn gas_factor_rounds_correctly() {
     let factor = 5479_f64;
     let gas_price = 6197;
 
+    let large_max_fee_limit = input;
+
     let gas_costs = GasCosts::default();
     let fee_params = FeeParameters::default().with_gas_price_factor(factor as Word);
 
@@ -31,21 +36,16 @@ fn gas_factor_rounds_correctly() {
         .collect();
 
     let transaction = TestBuilder::new(2322u64)
+        .max_fee_limit(large_max_fee_limit)
         .gas_price(gas_price)
         .with_fee_params(fee_params)
         .start_script(script, vec![])
         .script_gas_limit(gas_limit)
         .coin_input(AssetId::default(), input)
         .change_output(AssetId::default())
-        .build();
-
-    let fee = TransactionFee::checked_from_tx(
-        &gas_costs,
-        &fee_params,
-        transaction.transaction(),
-        gas_price,
-    )
-    .expect("failed to calculate fee");
+        .build()
+        .into_ready(gas_price, &gas_costs, &fee_params)
+        .unwrap();
 
     let profiler = GasProfiler::default();
 
@@ -74,7 +74,7 @@ fn gas_factor_rounds_correctly() {
         })
         .expect("failed to fetch change");
 
-    let initial_balance = input - fee.max_fee();
+    let initial_balance = input - res.tx().max_fee_limit();
 
     let gas_used = profiler.total_gas();
 
diff --git a/fuel-vm/src/tests/memory.rs b/fuel-vm/src/tests/memory.rs
index 67b844dbe0..63a99f4727 100644
--- a/fuel-vm/src/tests/memory.rs
+++ b/fuel-vm/src/tests/memory.rs
@@ -38,7 +38,7 @@ fn setup(program: Vec<Instruction>) -> Transactor<MemoryStorage, Script> {
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
-        .into_checked(height, &consensus_params, gas_price)
+        .into_checked(height, &consensus_params)
         .expect("failed to check tx");
 
     let interpreter_params = InterpreterParams::new(gas_price, &consensus_params);
@@ -368,7 +368,7 @@ fn test_meq(
     if let Some(Receipt::Log { ra, .. }) = vm.receipts().first() {
         if count == 0 {
             assert_eq!(*ra, 1); // Empty ranges always equal
-            return
+            return;
         }
         match pattern {
             "equal" => {
diff --git a/fuel-vm/src/tests/metadata.rs b/fuel-vm/src/tests/metadata.rs
index 107964d6c8..da30a90cc4 100644
--- a/fuel-vm/src/tests/metadata.rs
+++ b/fuel-vm/src/tests/metadata.rs
@@ -49,6 +49,7 @@ use crate::prelude::{
     GasCosts,
     *,
 };
+
 #[test]
 fn metadata() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
@@ -67,7 +68,7 @@ fn metadata() {
         op::gm_args(0x10, GMArgs::IsCallerExternal),
         op::gm_args(0x11, GMArgs::GetCaller),
         op::log(0x10, 0x00, 0x00, 0x00),
-        op::movi(0x20,  ContractId::LEN as Immediate18),
+        op::movi(0x20, ContractId::LEN as Immediate18),
         op::logd(0x00, 0x00, 0x11, 0x20),
         op::ret(RegId::ONE),
     ];
@@ -89,7 +90,7 @@ fn metadata() {
         .add_random_fee_input()
         .add_output(output)
         .finalize()
-        .into_checked(height, &consensus_params, gas_price)
+        .into_checked(height, &consensus_params)
         .expect("failed to check tx");
 
     let interpreter_params = InterpreterParams::new(gas_price, &consensus_params);
@@ -139,7 +140,7 @@ fn metadata() {
         .add_random_fee_input()
         .add_output(output)
         .finalize()
-        .into_checked(height, &consensus_params, gas_price)
+        .into_checked(height, &consensus_params)
         .expect("failed to check tx");
 
     assert!(
@@ -200,7 +201,7 @@ fn metadata() {
         .add_output(outputs[1])
         .add_random_fee_input()
         .finalize()
-        .into_checked(height, &consensus_params, gas_price)
+        .into_checked(height, &consensus_params)
         .expect("failed to check tx");
 
     let receipts = Transactor::<_, _>::new(&mut storage, interpreter_params)
@@ -230,7 +231,6 @@ fn metadata() {
 fn get_metadata_chain_id() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
     let gas_limit = 1_000_000;
-    let zero_gas_price = 0;
     let height = BlockHeight::default();
 
     let chain_id: ChainId = rng.gen();
@@ -244,7 +244,7 @@ fn get_metadata_chain_id() {
         MemoryClient::<NotSupportedEcal>::new(Default::default(), interpreter_params);
 
     #[rustfmt::skip]
-        let get_chain_id = vec![
+    let get_chain_id = vec![
         op::gm_args(0x10, GMArgs::GetChainId),
         op::ret(0x10),
     ];
@@ -256,7 +256,7 @@ fn get_metadata_chain_id() {
         .with_chain_id(chain_id)
         .add_random_fee_input()
         .finalize()
-        .into_checked(height, &consensus_params, zero_gas_price)
+        .into_checked(height, &consensus_params)
         .unwrap();
 
     let receipts = client.transact(script);
@@ -275,7 +275,6 @@ fn get_transaction_fields() {
 
     let mut client = MemoryClient::default();
 
-    let zero_gas_price = 0;
     let witness_limit = 1234;
     let max_fee_limit = 4321;
     let tip = 4321;
@@ -296,8 +295,14 @@ fn get_transaction_fields() {
 
     let tx = TransactionBuilder::create(contract, salt, storage_slots)
         .add_output(Output::contract_created(contract_id, state_root))
-        .add_random_fee_input()
-        .finalize_checked(height, zero_gas_price);
+        .add_unsigned_coin_input(
+            SecretKey::random(rng),
+            rng.gen(),
+            max_fee_limit,
+            AssetId::zeroed(),
+            rng.gen(),
+        )
+        .finalize_checked(height);
 
     client.deploy(tx);
 
@@ -389,7 +394,7 @@ fn get_transaction_fields() {
         )
         .add_output(Output::coin(rng.gen(), asset_amt, asset))
         .add_output(Output::change(rng.gen(), rng.gen_range(10..1000), asset))
-        .finalize_checked(height, zero_gas_price);
+        .finalize_checked(height);
 
     let inputs = tx.as_ref().inputs();
     let outputs = tx.as_ref().outputs();
@@ -693,8 +698,6 @@ fn get_transaction_fields() {
         op::add(0x30, 0x30, 0x11),
         op::and(0x20, 0x20, 0x10),
 
-
-
         op::movi(0x11, 0x02),
         op::movi(0x19, 0x03),
         op::gtf_args(0x10, 0x19, GTFArgs::InputMessageWitnessIndex),
@@ -846,7 +849,7 @@ fn get_transaction_fields() {
         .script_gas_limit(gas_limit)
         .witness_limit(witness_limit)
         .max_fee_limit(max_fee_limit)
-        .finalize_checked_basic(height, zero_gas_price);
+        .finalize_checked_basic(height);
 
     let receipts = client.transact(tx);
     let success = receipts
diff --git a/fuel-vm/src/tests/outputs.rs b/fuel-vm/src/tests/outputs.rs
index d55fc15deb..9173b78a17 100644
--- a/fuel-vm/src/tests/outputs.rs
+++ b/fuel-vm/src/tests/outputs.rs
@@ -32,7 +32,6 @@ use rand::{
 };
 
 /// Testing of post-execution output handling
-
 #[test]
 fn full_change_with_no_fees() {
     let mut rng = StdRng::seed_from_u64(2322u64);
@@ -57,6 +56,7 @@ fn used_gas_is_deducted_from_base_asset_change() {
     let gas_price = 1;
 
     let change = TestBuilder::new(2322u64)
+        .max_fee_limit(1000)
         .gas_price(gas_price)
         .base_asset_id(base_asset_id)
         .coin_input(base_asset_id, input_amount)
@@ -85,6 +85,7 @@ fn used_gas_is_deducted_from_base_asset_change_on_revert() {
             .collect(),
             vec![],
         )
+        .max_fee_limit(1000)
         .gas_price(gas_price)
         .base_asset_id(base_asset_id)
         .coin_input(base_asset_id, input_amount)
@@ -116,7 +117,6 @@ fn correct_change_is_provided_for_coin_outputs_script() {
 fn correct_change_is_provided_for_coin_outputs_create() {
     let mut rng = StdRng::seed_from_u64(2322u64);
     let input_amount = 1000;
-    let gas_price = 0;
     let spend_amount = 600;
     let base_asset_id: AssetId = rng.gen();
 
@@ -136,9 +136,10 @@ fn correct_change_is_provided_for_coin_outputs_create() {
     let mut context = TestBuilder::new(2322u64);
     let context = context.base_asset_id(base_asset_id);
     let bytecode_witness = 0;
+
     let mut create = Transaction::create(
         bytecode_witness,
-        Policies::new(),
+        Policies::new().with_max_fee(0),
         salt,
         vec![],
         vec![],
@@ -169,7 +170,7 @@ fn correct_change_is_provided_for_coin_outputs_create() {
         *context.get_base_asset_id(),
     );
     let create = create
-        .into_checked_basic(context.get_block_height(), &consensus_params, gas_price)
+        .into_checked_basic(context.get_block_height(), &consensus_params)
         .expect("failed to generate checked tx");
 
     let state = context.deploy(create).expect("Create should be executed");
diff --git a/fuel-vm/src/tests/predicate.rs b/fuel-vm/src/tests/predicate.rs
index 9ed025b410..f8005c2f8b 100644
--- a/fuel-vm/src/tests/predicate.rs
+++ b/fuel-vm/src/tests/predicate.rs
@@ -87,12 +87,13 @@ where
         predicate_data,
     );
 
-    let gas_price = 0;
     let gas_limit = 1_000_000;
     let script = vec![];
     let script_data = vec![];
 
     let mut builder = TransactionBuilder::script(script, script_data);
+    let params = ConsensusParameters::standard();
+    let check_params = params.clone().into();
 
     builder.script_gas_limit(gas_limit).maturity(maturity);
 
@@ -110,25 +111,24 @@ where
 
     let mut transaction = builder.finalize();
     transaction
-        .estimate_predicates(&ConsensusParameters::standard().into())
-        .expect("Should estiamte predicate");
+        .estimate_predicates(&check_params)
+        .expect("Should estimate predicate");
 
     let checked = transaction
-        .into_checked_basic(height, &ConsensusParameters::standard(), gas_price)
+        .into_checked_basic(height, &params)
         .expect("Should successfully convert into Checked");
 
-    let params = CheckPredicateParams::default();
-
     let parallel_execution = {
         Interpreter::<PredicateStorage, _>::check_predicates_async::<TokioWithRayon>(
-            &checked, &params,
+            &checked,
+            &check_params,
         )
         .await
         .map(|checked| checked.gas_used())
     };
 
     let seq_execution =
-        Interpreter::<PredicateStorage, _>::check_predicates(&checked, &params)
+        Interpreter::<PredicateStorage, _>::check_predicates(&checked, &check_params)
             .map(|checked| checked.gas_used());
 
     match (parallel_execution, seq_execution) {
@@ -202,21 +202,27 @@ async fn execute_gas_metered_predicates(
     const GAS_LIMIT: Word = 10000;
     let rng = &mut StdRng::seed_from_u64(2322u64);
 
-    let gas_price = 1_000;
+    let arb_max_fee = 2_000;
     let script = vec![];
     let script_data = vec![];
 
     let mut builder = TransactionBuilder::script(script, script_data);
-    builder.maturity(Default::default());
+    builder
+        .max_fee_limit(arb_max_fee)
+        .maturity(Default::default());
 
     let coin_amount = 10_000_000;
+    let params = CheckPredicateParams {
+        max_gas_per_predicate: GAS_LIMIT,
+        ..Default::default()
+    };
 
     if predicates.is_empty() {
         builder.add_unsigned_coin_input(
             SecretKey::random(rng),
             rng.gen(),
-            coin_amount,
-            AssetId::default(),
+            arb_max_fee,
+            params.base_asset_id,
             rng.gen(),
         );
     }
@@ -259,11 +265,7 @@ async fn execute_gas_metered_predicates(
             .map_err(|_| ())?;
 
         let tx = async_tx
-            .into_checked_basic(
-                Default::default(),
-                &ConsensusParameters::standard(),
-                gas_price,
-            )
+            .into_checked_basic(Default::default(), &ConsensusParameters::standard())
             .expect("Should successfully create checked tranaction with predicate");
 
         Interpreter::<PredicateStorage, _>::check_predicates_async::<TokioWithRayon>(
@@ -278,11 +280,7 @@ async fn execute_gas_metered_predicates(
     transaction.estimate_predicates(&params).map_err(|_| ())?;
 
     let tx = transaction
-        .into_checked_basic(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            gas_price,
-        )
+        .into_checked_basic(Default::default(), &ConsensusParameters::standard())
         .expect("Should successfully create checked tranaction with predicate");
 
     let seq_gas_used = Interpreter::<PredicateStorage, _>::check_predicates(&tx, &params)
@@ -316,7 +314,7 @@ async fn predicate_gas_metering() {
         vec![
             op::movi(0x10, 0x11),
             op::movi(0x10, 0x11),
-            op::ret(RegId::ONE)
+            op::ret(RegId::ONE),
         ],
     ])
     .await
@@ -342,7 +340,6 @@ async fn gas_used_by_predicates_not_causes_out_of_gas_during_script() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
     let params = CheckPredicateParams::default();
 
-    let gas_price = 1_000;
     let gas_limit = 1_000_000;
     let script = vec![
         op::addi(0x20, 0x20, 1),
@@ -372,14 +369,14 @@ async fn gas_used_by_predicates_not_causes_out_of_gas_during_script() {
     {
         let _ = builder
             .clone()
-            .finalize_checked_basic(Default::default(), gas_price)
+            .finalize_checked_basic(Default::default())
             .check_predicates_async::<TokioWithRayon>(&params)
             .await
             .expect("Predicate check failed even if we don't have any predicates");
     }
 
     let tx_without_predicate = builder
-        .finalize_checked_basic(Default::default(), gas_price)
+        .finalize_checked_basic(Default::default())
         .check_predicates(&params)
         .expect("Predicate check failed even if we don't have any predicates");
 
@@ -418,11 +415,7 @@ async fn gas_used_by_predicates_not_causes_out_of_gas_during_script() {
         .expect("Predicate estimation failed");
 
     let checked = transaction
-        .into_checked_basic(
-            Default::default(),
-            &ConsensusParameters::standard(),
-            gas_price,
-        )
+        .into_checked_basic(Default::default(), &ConsensusParameters::standard())
         .expect("Should successfully create checked tranaction with predicate");
 
     // parallel version
@@ -468,8 +461,8 @@ async fn gas_used_by_predicates_more_than_limit() {
 
     let params = CheckPredicateParams::default();
 
-    let gas_price = 1_000;
     let gas_limit = 1_000_000;
+    let arb_max_fee = 1000;
     let script = vec![
         op::addi(0x20, 0x20, 1),
         op::addi(0x20, 0x20, 1),
@@ -481,6 +474,7 @@ async fn gas_used_by_predicates_more_than_limit() {
 
     let mut builder = TransactionBuilder::script(script, script_data);
     builder
+        .max_fee_limit(arb_max_fee)
         .script_gas_limit(gas_limit)
         .maturity(Default::default());
 
@@ -498,14 +492,14 @@ async fn gas_used_by_predicates_more_than_limit() {
     {
         let _ = builder
             .clone()
-            .finalize_checked_basic(Default::default(), gas_price)
+            .finalize_checked_basic(Default::default())
             .check_predicates_async::<TokioWithRayon>(&params)
             .await
             .expect("Predicate check failed even if we don't have any predicates");
     }
 
     let tx_without_predicate = builder
-        .finalize_checked_basic(Default::default(), gas_price)
+        .finalize_checked_basic(Default::default())
         .check_predicates(&params)
         .expect("Predicate check failed even if we don't have any predicates");
 
@@ -548,7 +542,7 @@ async fn gas_used_by_predicates_more_than_limit() {
     {
         let tx_with_predicate = builder
             .clone()
-            .finalize_checked_basic(Default::default(), gas_price)
+            .finalize_checked_basic(Default::default())
             .check_predicates_async::<TokioWithRayon>(&params)
             .await;
 
@@ -559,7 +553,7 @@ async fn gas_used_by_predicates_more_than_limit() {
     }
 
     let tx_with_predicate = builder
-        .finalize_checked_basic(Default::default(), gas_price)
+        .finalize_checked_basic(Default::default())
         .check_predicates(&params);
 
     assert!(matches!(
diff --git a/fuel-vm/src/tests/profile_gas.rs b/fuel-vm/src/tests/profile_gas.rs
index 5cf4546336..8122dc71b6 100644
--- a/fuel-vm/src/tests/profile_gas.rs
+++ b/fuel-vm/src/tests/profile_gas.rs
@@ -16,8 +16,8 @@ use rand::{
 fn profile_gas() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
 
-    let gas_price = 1;
     let gas_limit = 1_000;
+    let arb_fee_limit = 2_000;
     let maturity = Default::default();
     let height = Default::default();
 
@@ -36,16 +36,17 @@ fn profile_gas() {
 
         let tx_deploy =
             TransactionBuilder::script(script_code.into_iter().collect(), vec![])
+                .max_fee_limit(arb_fee_limit)
                 .add_unsigned_coin_input(
                     SecretKey::random(rng),
                     rng.gen(),
-                    2,
+                    arb_fee_limit,
                     Default::default(),
                     rng.gen(),
                 )
                 .script_gas_limit(gas_limit)
                 .maturity(maturity)
-                .finalize_checked(height, gas_price);
+                .finalize_checked(height);
 
         let output = GasProfiler::default();
 
diff --git a/fuel-vm/src/tests/test_helpers.rs b/fuel-vm/src/tests/test_helpers.rs
index 12a054cb69..f3661d8cb9 100644
--- a/fuel-vm/src/tests/test_helpers.rs
+++ b/fuel-vm/src/tests/test_helpers.rs
@@ -7,6 +7,7 @@ use fuel_asm::{
     op,
     Instruction,
 };
+use fuel_crypto::SecretKey;
 use fuel_tx::ConsensusParameters;
 use fuel_vm::prelude::*;
 
@@ -24,18 +25,30 @@ pub fn set_full_word(r: RegisterId, v: Word) -> Vec<Instruction> {
 
 /// Run a instructions-only script with reasonable defaults, and return receipts
 pub fn run_script(script: Vec<Instruction>) -> Vec<Receipt> {
+    use rand::{
+        Rng,
+        SeedableRng,
+    };
     let script = script.into_iter().collect();
     let mut client = MemoryClient::default();
-    let zero_gas_price = 0;
+    let arb_max_fee = 1000;
 
     let consensus_params = ConsensusParameters::standard();
 
+    let mut rng = rand::rngs::StdRng::seed_from_u64(2322u64);
     let tx = TransactionBuilder::script(script, vec![])
+        .max_fee_limit(arb_max_fee)
         .script_gas_limit(1_000_000)
         .maturity(Default::default())
-        .add_random_fee_input()
+        .add_unsigned_coin_input(
+            SecretKey::random(&mut rng),
+            rng.gen(),
+            arb_max_fee,
+            consensus_params.base_asset_id,
+            Default::default(),
+        )
         .finalize()
-        .into_checked(Default::default(), &consensus_params, zero_gas_price)
+        .into_checked(Default::default(), &consensus_params)
         .expect("failed to generate a checked tx");
     client.transact(tx);
     client.receipts().expect("Expected receipts").to_vec()
diff --git a/fuel-vm/src/tests/validation.rs b/fuel-vm/src/tests/validation.rs
index e5998cc167..643f2e76ce 100644
--- a/fuel-vm/src/tests/validation.rs
+++ b/fuel-vm/src/tests/validation.rs
@@ -30,23 +30,24 @@ fn transaction_can_be_executed_after_maturity() {
     const MATURITY: BlockHeight = BlockHeight::new(1);
     const BLOCK_HEIGHT: BlockHeight = BlockHeight::new(2);
 
-    let arb_gas_price = 1;
+    let arb_max_fee = 1;
 
     let rng = &mut StdRng::seed_from_u64(2322u64);
     let tx = TransactionBuilder::script(
         Some(op::ret(1)).into_iter().collect(),
         Default::default(),
     )
+    .max_fee_limit(arb_max_fee)
     .add_unsigned_coin_input(
         SecretKey::random(rng),
         rng.gen(),
-        1,
+        arb_max_fee,
         Default::default(),
         rng.gen(),
     )
     .script_gas_limit(100)
     .maturity(MATURITY)
-    .finalize_checked(BLOCK_HEIGHT, arb_gas_price);
+    .finalize_checked(BLOCK_HEIGHT);
 
     let result = TestBuilder::new(2322u64)
         .block_height(BLOCK_HEIGHT)
@@ -131,7 +132,7 @@ fn malleable_fields_do_not_affect_validity() {
         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"));
+            client.transact(tx.into_checked(0u32.into(), &params).expect("valid tx"));
 
         let start_id = receipts[0].data().unwrap();
         let computed_id = receipts[1].data().unwrap();
diff --git a/fuel-vm/src/transactor.rs b/fuel-vm/src/transactor.rs
index 6dd48c50a4..5ce355e765 100644
--- a/fuel-vm/src/transactor.rs
+++ b/fuel-vm/src/transactor.rs
@@ -21,9 +21,12 @@ use crate::{
     storage::InterpreterStorage,
 };
 
-use crate::interpreter::{
-    InterpreterParams,
-    NotSupportedEcal,
+use crate::{
+    checked_transaction::Ready,
+    interpreter::{
+        InterpreterParams,
+        NotSupportedEcal,
+    },
 };
 use fuel_tx::{
     Create,
@@ -190,7 +193,23 @@ where
         &mut self,
         checked: Checked<Create>,
     ) -> Result<Create, InterpreterError<S::DataError>> {
-        self.interpreter.deploy(checked)
+        let gas_price = self.interpreter.gas_price();
+        let gas_costs = self.interpreter.gas_costs();
+        let fee_params = self.interpreter.fee_params();
+
+        let ready = checked
+            .into_ready(gas_price, gas_costs, fee_params)
+            .map_err(InterpreterError::CheckError)?;
+
+        self.deploy_ready_tx(ready)
+    }
+
+    /// Deployt a `Ready` transaction directly instead of letting `Transactor` construct
+    pub fn deploy_ready_tx(
+        &mut self,
+        ready_tx: Ready<Create>,
+    ) -> Result<Create, InterpreterError<S::DataError>> {
+        self.interpreter.deploy(ready_tx)
     }
 }
 
@@ -203,17 +222,35 @@ where
 {
     /// Execute a transaction, and return the new state of the transactor
     pub fn transact(&mut self, tx: Checked<Tx>) -> &mut Self {
-        match self.interpreter.transact(tx) {
+        let gas_price = self.interpreter.gas_price();
+        let gas_costs = self.interpreter.gas_costs();
+        let fee_params = self.interpreter.fee_params();
+
+        match tx
+            .into_ready(gas_price, gas_costs, fee_params)
+            .map_err(InterpreterError::CheckError)
+        {
+            Ok(ready_tx) => self.transact_ready_tx(ready_tx),
+            Err(e) => self.handle_error(e),
+        }
+    }
+
+    /// Transact a `Ready` transaction directly instead of letting `Transactor` construct
+    pub fn transact_ready_tx(&mut self, ready_tx: Ready<Tx>) -> &mut Self {
+        match self.interpreter.transact(ready_tx) {
             Ok(s) => {
                 self.program_state.replace(s.into());
                 self.error.take();
+                self
             }
 
-            Err(e) => {
-                self.program_state.take();
-                self.error.replace(e);
-            }
+            Err(e) => self.handle_error(e),
         }
+    }
+
+    fn handle_error(&mut self, error: InterpreterError<S::DataError>) -> &mut Self {
+        self.program_state.take();
+        self.error.replace(error);
         self
     }
 }
diff --git a/fuel-vm/src/util.rs b/fuel-vm/src/util.rs
index 6824441025..769446885d 100644
--- a/fuel-vm/src/util.rs
+++ b/fuel-vm/src/util.rs
@@ -174,6 +174,7 @@ pub mod test_helpers {
     pub struct TestBuilder {
         rng: StdRng,
         gas_price: Word,
+        max_fee_limit: Word,
         script_gas_limit: Word,
         builder: TransactionBuilder<Script>,
         storage: MemoryStorage,
@@ -187,6 +188,7 @@ pub mod test_helpers {
             TestBuilder {
                 rng: StdRng::seed_from_u64(seed),
                 gas_price: 0,
+                max_fee_limit: 0,
                 script_gas_limit: 100,
                 builder: TransactionBuilder::script(bytecode, vec![]),
                 storage: MemoryStorage::default(),
@@ -215,6 +217,11 @@ pub mod test_helpers {
             self
         }
 
+        pub fn max_fee_limit(&mut self, max_fee_limit: Word) -> &mut TestBuilder {
+            self.max_fee_limit = max_fee_limit;
+            self
+        }
+
         pub fn script_gas_limit(&mut self, limit: Word) -> &mut TestBuilder {
             self.builder.script_gas_limit(limit);
             self.script_gas_limit = limit;
@@ -317,6 +324,7 @@ pub mod test_helpers {
         }
 
         pub fn build(&mut self) -> Checked<Script> {
+            self.builder.max_fee_limit(self.max_fee_limit);
             self.builder.with_tx_params(*self.get_tx_params());
             self.builder
                 .with_contract_params(*self.get_contract_params());
@@ -325,8 +333,7 @@ pub mod test_helpers {
             self.builder.with_script_params(*self.get_script_params());
             self.builder.with_fee_params(*self.get_fee_params());
             self.builder.with_base_asset_id(*self.get_base_asset_id());
-            self.builder
-                .finalize_checked(self.block_height, self.gas_price)
+            self.builder.finalize_checked(self.block_height)
         }
 
         pub fn get_tx_params(&self) -> &TxParameters {
@@ -423,11 +430,12 @@ pub mod test_helpers {
             let contract_id = contract.id(&salt, &contract_root, &storage_root);
 
             let tx = TransactionBuilder::create(program, salt, storage_slots)
+                .max_fee_limit(self.max_fee_limit)
                 .maturity(Default::default())
                 .add_random_fee_input()
                 .add_output(Output::contract_created(contract_id, storage_root))
                 .finalize()
-                .into_checked(self.block_height, &self.consensus_params, self.gas_price)
+                .into_checked(self.block_height, &self.consensus_params)
                 .expect("failed to check tx");
 
             // setup a contract in current test state
@@ -466,7 +474,7 @@ pub mod test_helpers {
             let storage = transactor.as_mut().clone();
 
             if let Some(e) = transactor.error() {
-                return Err(anyhow!("{:?}", e))
+                return Err(anyhow!("{:?}", e));
             }
             let is_reverted = transactor.is_reverted();
 
@@ -488,7 +496,7 @@ pub mod test_helpers {
 
             assert_eq!(deser_tx, transaction);
             if is_reverted {
-                return Ok(state)
+                return Ok(state);
             }
 
             // save storage between client instances
@@ -594,13 +602,13 @@ pub mod test_helpers {
         instructions: Vec<Instruction>,
         expected_reason: PanicReason,
     ) {
-        let zero_gas_price = 0;
         let tx_params = TxParameters::default().with_max_gas_per_tx(Word::MAX / 2);
         // The gas should be huge enough to cover the execution but still much less than
         // `MAX_GAS_PER_TX`.
         let gas_limit = tx_params.max_gas_per_tx / 2;
         let maturity = Default::default();
         let height = Default::default();
+        let zero_fee_limit = 0;
 
         // setup contract with state tests
         let contract: Witness = instructions.into_iter().collect::<Vec<u8>>().into();
@@ -612,10 +620,11 @@ pub mod test_helpers {
             Contract::from(contract.as_ref()).id(&salt, &code_root, &state_root);
 
         let contract_deployer = TransactionBuilder::create(contract, salt, storage_slots)
+            .max_fee_limit(zero_fee_limit)
             .with_tx_params(tx_params)
             .add_output(Output::contract_created(contract_id, state_root))
             .add_random_fee_input()
-            .finalize_checked(height, zero_gas_price);
+            .finalize_checked(height);
 
         client
             .deploy(contract_deployer)
@@ -638,6 +647,7 @@ pub mod test_helpers {
             .collect();
 
         let tx_deploy_loader = TransactionBuilder::script(script, script_data)
+            .max_fee_limit(zero_fee_limit)
             .script_gas_limit(gas_limit)
             .maturity(maturity)
             .with_tx_params(tx_params)
@@ -650,7 +660,7 @@ pub mod test_helpers {
             ))
             .add_random_fee_input()
             .add_output(Output::contract(0, Default::default(), Default::default()))
-            .finalize_checked(height, zero_gas_price);
+            .finalize_checked(height);
 
         check_reason_for_transaction(client, tx_deploy_loader, expected_reason);
     }