diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 117082d296..111f0c8410 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,7 +17,7 @@ concurrency:
 env:
   CARGO_TERM_COLOR: always
   RUST_VERSION: 1.73.0
-  NIGHTLY_RUST_VERSION: nightly-2023-08-28
+  NIGHTLY_RUST_VERSION: nightly-2023-10-29
 
 jobs:
   check-changelog:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 14649e9d12..4a85970744 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,40 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+
+#### Breaking
+
+- [#623](https://github.com/FuelLabs/fuel-vm/pull/623):
+  Added support for transaction policies. The `Script` and `Create`
+  transactions received a new field, `policies`. Policies allow the addition
+  of some limits to the transaction to protect the user or specify some details regarding execution.
+  This change makes the `GasPrice` and `Maturity` fields optional, allowing to save space in the future.
+  Also, this will enable us to support multidimensional prices later.
+  `GasLimit` was renamed to `ScriptGasLimit`.
+
+  Along with this change, we introduced two new policies:
+    - `WitnessLimit` - allows the limitation of the maximum size of witnesses in bytes for the contract. Because of the changes in the gas calculation model(the blockchain also charges the user for the witness data), the user should protect himself from the block producer or third parties blowing up witness data and draining the user's funds.
+    - `MaxFee` - allows the upper bound for the maximum fee that users agree to pay for the transaction.
+
+  This change brings the following modification to the gas model:
+    - The `ScriptGasLimit` only limits script execution. Previously, the `ScriptGasLimit` also limited the predicate execution time, instead predicate gas is now directly included into `min_fee`. So, it is not possible to use the `ScriptGasLimit` for transaction cost limitations. A new `MaxFee` policy is a way to do that. The `GasLimit` field was removed from the `Create` transaction because it only relates to the script execution (which the `Create` transaction doesn't have).
+    - The blockchain charges the user for the size of witness data (before it was free). There is no separate price for the storage, so it uses gas to charge the user. This change affects `min_gas` and `min_fee` calculation.
+    - A new policy called `WitnessLimit` also impacts the `max_gas` and `max_fee` calculation in addition to `ScriptGasLimit`(in the case of `Create` transaction only `WitnessLimit` affects the `max_gas` and `max_fee`).
+    - The minimal gas also charges the user for transaction ID calculation.
+
+  The change has the following modification to the transaction layout:
+    - The `Create` transaction doesn't have the `ScriptGasLimit` field anymore. Because the `Create` transaction doesn't have any script to execute
+    - The `Create` and `Script` transactions don't have explicit `maturity` and `gas_price` fields. Instead, these fields can be set via a new `policies` field.
+    - The `Create` and `Script` transactions have a new `policies` field with a unique canonical serialization and deserialization for optimal space consumption.
+
+  Other breaking changes caused by the change:
+    - Each transaction requires setting the `GasPrice` policy.
+    - Previously, `ScriptGasLimit` should be less than the `MAX_GAS_PER_TX` constant. After removing this field from the `Create` transaction, it is impossible to require it. Instead, it requires that `max_gas <= MAX_GAS_PER_TX` for any transaction. Consequently, any `Script` transaction that uses `MAX_GAS_PER_TX` as a `ScriptGasLimit` will always fail because of a new rule. Setting the estimated gas usage instead solves the problem.
+    - If the `max_fee > policies.max_fee`, then transaction will be rejected.
+    - If the `witnessses_size > policies.witness_limit`, then transaction will be rejected.
+    - GTF opcode changed its hardcoded constants for fields. It should be updated according to the values from the specification on the Sway side.
+
 ## [Version 0.41.0]
 
 #### Breaking
diff --git a/Cargo.toml b/Cargo.toml
index d8928202bc..21688a74eb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,5 +29,6 @@ fuel-storage = { version = "0.41.0", path = "fuel-storage", default-features = f
 fuel-tx = { version = "0.41.0", path = "fuel-tx", default-features = false }
 fuel-types = { version = "0.41.0", path = "fuel-types", default-features = false }
 fuel-vm = { version = "0.41.0", path = "fuel-vm", default-features = false }
+bitflags = "2"
 bincode = { version = "1.3", default-features = false }
 criterion = "0.5.0"
diff --git a/fuel-asm/Cargo.toml b/fuel-asm/Cargo.toml
index 099eb20aa8..b4ab088384 100644
--- a/fuel-asm/Cargo.toml
+++ b/fuel-asm/Cargo.toml
@@ -12,7 +12,7 @@ description = "Atomic types of the FuelVM."
 
 [dependencies]
 arbitrary = { version = "1.1", features = ["derive"], optional = true }
-bitflags = "1.3"
+bitflags = { workspace = true }
 fuel-types = { workspace = true }
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 strum = { version = "0.24", default-features = false, features = ["derive"] }
diff --git a/fuel-asm/src/args.rs b/fuel-asm/src/args.rs
index 91eb0ce629..035f6b0a3e 100644
--- a/fuel-asm/src/args.rs
+++ b/fuel-asm/src/args.rs
@@ -50,218 +50,218 @@ crate::enum_try_from! {
         /// Set `$rA` to `tx.type`
         Type = 0x001,
 
-        /// Set `$rA` to `tx.gasPrice`
-        ScriptGasPrice = 0x002,
-
-        /// Set `$rA` to `tx.gasLimit`
-        ScriptGasLimit = 0x003,
-
-        /// Set `$rA` to `tx.maturity`
-        ScriptMaturity = 0x004,
+        /// Set `$rA` to `tx.scriptGasLimit`
+        ScriptGasLimit = 0x002,
 
         /// Set `$rA` to `tx.scriptLength`
-        ScriptLength = 0x005,
+        ScriptLength = 0x003,
 
         /// Set `$rA` to `tx.scriptDataLength`
-        ScriptDataLength = 0x006,
+        ScriptDataLength = 0x004,
 
         /// Set `$rA` to `tx.inputsCount`
-        ScriptInputsCount = 0x007,
+        ScriptInputsCount = 0x005,
 
         /// Set `$rA` to `tx.outputsCount`
-        ScriptOutputsCount = 0x008,
+        ScriptOutputsCount = 0x006,
 
         /// Set `$rA` to `tx.witnessesCount`
-        ScriptWitnessesCound = 0x009,
+        ScriptWitnessesCount = 0x007,
 
         /// Set `$rA` to `Memory address of tx.receiptsRoot`
-        ScriptReceiptsRoot = 0x00A,
+        ScriptReceiptsRoot = 0x008,
 
         /// Set `$rA` to `Memory address of tx.script`
-        Script = 0x00B,
+        Script = 0x009,
 
         /// Set `$rA` to `Memory address of tx.scriptData`
-        ScriptData = 0x00C,
+        ScriptData = 0x00A,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB]`
-        ScriptInputAtIndex = 0x00D,
+        ScriptInputAtIndex = 0x00B,
 
         /// Set `$rA` to `Memory address of t.outputs[$rB]`
-        ScriptOutputAtIndex = 0x00E,
+        ScriptOutputAtIndex = 0x00C,
 
         /// Set `$rA` to `Memory address of tx.witnesses[$rB]`
-        ScriptWitnessAtIndex = 0x00F,
-
-        /// Set `$rA` to `tx.gasPrice`
-        CreateGasPrice = 0x010,
-
-        /// Set `$rA` to `tx.gasLimit`
-        CreateGasLimit = 0x011,
-
-        /// Set `$rA` to `tx.maturity`
-        CreateMaturity = 0x012,
+        ScriptWitnessAtIndex = 0x00D,
 
         /// Set `$rA` to `tx.bytecodeLength`
-        CreateBytecodeLength = 0x013,
+        CreateBytecodeLength = 0x100,
 
         /// Set `$rA` to `tx.bytecodeWitnessIndex`
-        CreateBytecodeWitnessIndex = 0x014,
+        CreateBytecodeWitnessIndex = 0x101,
 
         /// Set `$rA` to `tx.storageSlotsCount`
-        CreateStorageSlotsCount = 0x015,
+        CreateStorageSlotsCount = 0x102,
 
         /// Set `$rA` to `tx.inputsCount`
-        CreateInputsCount = 0x016,
+        CreateInputsCount = 0x103,
 
         /// Set `$rA` to `tx.outputsCount`
-        CreateOutputsCount = 0x017,
+        CreateOutputsCount = 0x104,
 
         /// Set `$rA` to `tx.witnessesCount`
-        CreateWitnessesCount = 0x018,
+        CreateWitnessesCount = 0x105,
 
         /// Set `$rA` to `Memory address of tx.salt`
-        CreateSalt = 0x019,
+        CreateSalt = 0x106,
 
         /// Set `$rA` to `Memory address of tx.storageSlots[$rB]`
-        CreateStorageSlotAtIndex = 0x01A,
+        CreateStorageSlotAtIndex = 0x107,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB]`
-        CreateInputAtIndex = 0x01B,
+        CreateInputAtIndex = 0x108,
 
         /// Set `$rA` to `Memory address of t.outputs[$rB]`
-        CreateOutputAtIndex = 0x01C,
+        CreateOutputAtIndex = 0x109,
 
         /// Set `$rA` to `Memory address of tx.witnesses[$rB]`
-        CreateWitnessAtIndex = 0x01D,
+        CreateWitnessAtIndex = 0x10A,
 
         /// Set `$rA` to `tx.inputs[$rB].type`
-        InputType = 0x101,
+        InputType = 0x200,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].txID`
-        InputCoinTxId = 0x102,
+        InputCoinTxId = 0x201,
 
         /// Set `$rA` to `tx.inputs[$rB].outputIndex`
-        InputCoinOutputIndex = 0x103,
+        InputCoinOutputIndex = 0x202,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].owner`
-        InputCoinOwner = 0x104,
+        InputCoinOwner = 0x203,
 
         /// Set `$rA` to `tx.inputs[$rB].amount`
-        InputCoinAmount = 0x105,
+        InputCoinAmount = 0x204,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].asset_id`
-        InputCoinAssetId = 0x106,
+        InputCoinAssetId = 0x205,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
-        InputCoinTxPointer = 0x107,
+        InputCoinTxPointer = 0x206,
 
         /// Set `$rA` to `tx.inputs[$rB].witnessIndex`
-        InputCoinWitnessIndex = 0x108,
+        InputCoinWitnessIndex = 0x207,
 
         /// Set `$rA` to `tx.inputs[$rB].maturity`
-        InputCoinMaturity = 0x109,
+        InputCoinMaturity = 0x208,
 
         /// Set `$rA` to `tx.inputs[$rB].predicateLength`
-        InputCoinPredicateLength = 0x10A,
+        InputCoinPredicateLength = 0x209,
 
         /// Set `$rA` to `tx.inputs[$rB].predicateDataLength`
-        InputCoinPredicateDataLength = 0x10B,
+        InputCoinPredicateDataLength = 0x20A,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
-        InputCoinPredicate = 0x10C,
+        InputCoinPredicate = 0x20B,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
-        InputCoinPredicateData = 0x10D,
+        InputCoinPredicateData = 0x20C,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
-        InputCoinPredicateGasUsed = 0x10E,
+        InputCoinPredicateGasUsed = 0x20D,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].txID`
-        InputContractTxId = 0x10F,
+        InputContractTxId = 0x220,
 
         /// Set `$rA` to `tx.inputs[$rB].outputIndex`
-        InputContractOutputIndex = 0x110,
+        InputContractOutputIndex = 0x221,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].balanceRoot`
-        InputContractBalanceRoot = 0x111,
+        InputContractBalanceRoot = 0x222,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].stateRoot`
-        InputContractStateRoot = 0x112,
+        InputContractStateRoot = 0x223,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
-        InputContractTxPointer = 0x113,
+        InputContractTxPointer = 0x224,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].contractID`
-        InputContractId = 0x114,
+        InputContractId = 0x225,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].sender`
-        InputMessageSender = 0x115,
+        InputMessageSender = 0x240,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].recipient`
-        InputMessageRecipient = 0x116,
+        InputMessageRecipient = 0x241,
 
         /// Set `$rA` to `tx.inputs[$rB].amount`
-        InputMessageAmount = 0x117,
+        InputMessageAmount = 0x242,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].nonce`
-        InputMessageNonce = 0x118,
+        InputMessageNonce = 0x243,
 
         /// Set `$rA` to `tx.inputs[$rB].witnessIndex`
-        InputMessageWitnessIndex = 0x119,
+        InputMessageWitnessIndex = 0x244,
 
         /// Set `$rA` to `tx.inputs[$rB].dataLength`
-        InputMessageDataLength = 0x11A,
+        InputMessageDataLength = 0x245,
 
         /// Set `$rA` to `tx.inputs[$rB].predicateLength`
-        InputMessagePredicateLength = 0x11B,
+        InputMessagePredicateLength = 0x246,
 
         /// Set `$rA` to `tx.inputs[$rB].predicateDataLength`
-        InputMessagePredicateDataLength = 0x11C,
+        InputMessagePredicateDataLength = 0x247,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].data`
-        InputMessageData = 0x11D,
+        InputMessageData = 0x248,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
-        InputMessagePredicate = 0x11E,
+        InputMessagePredicate = 0x249,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
-        InputMessagePredicateData = 0x11F,
+        InputMessagePredicateData = 0x24A,
 
         /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
-        InputMessagePredicateGasUsed = 0x120,
+        InputMessagePredicateGasUsed = 0x24B,
 
         /// Set `$rA` to `tx.outputs[$rB].type`
-        OutputType = 0x201,
+        OutputType = 0x300,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].to`
-        OutputCoinTo = 0x202,
+        OutputCoinTo = 0x301,
 
         /// Set `$rA` to `tx.outputs[$rB].amount`
-        OutputCoinAmount = 0x203,
+        OutputCoinAmount = 0x302,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].asset_id`
-        OutputCoinAssetId = 0x204,
+        OutputCoinAssetId = 0x303,
 
         /// Set `$rA` to `tx.outputs[$rB].inputIndex`
-        OutputContractInputIndex = 0x205,
+        OutputContractInputIndex = 0x304,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].balanceRoot`
-        OutputContractBalanceRoot = 0x206,
+        OutputContractBalanceRoot = 0x305,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
-        OutputContractStateRoot = 0x207,
+        OutputContractStateRoot = 0x306,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].contractID`
-        OutputContractCreatedContractId = 0x208,
+        OutputContractCreatedContractId = 0x307,
 
         /// Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
-        OutputContractCreatedStateRoot = 0x209,
+        OutputContractCreatedStateRoot = 0x308,
 
         /// Set `$rA` to `tx.witnesses[$rB].dataLength`
-        WitnessDataLength = 0x301,
+        WitnessDataLength = 0x400,
 
         /// Set `$rA` to `Memory address of tx.witnesses[$rB].data`
-        WitnessData = 0x302,
+        WitnessData = 0x401,
+
+        /// Set `$rA` to `tx.policyTypes`
+        PolicyTypes = 0x500,
+
+        /// Set `$rA` to `tx.policies[0x00].gasPrice`
+        PolicyGasPrice = 0x501,
+
+        /// Set `$rA` to `tx.policies[count_ones(0b11 & tx.policyTypes) - 1].witnessLimit`
+        PolicyWitnessLimit = 0x502,
+
+        /// Set `$rA` to `tx.policies[count_ones(0b111 & tx.policyTypes) - 1].maturity`
+        PolicyMaturity = 0x503,
+
+        /// Set `$rA` to `tx.policies[count_ones(0b1111 & tx.policyTypes) - 1].maxFee`
+        PolicyMaxFee = 0x504,
     },
     Immediate12
 }
@@ -295,23 +295,18 @@ fn encode_gm_args() {
 fn encode_gtf_args() {
     let args = vec![
         GTFArgs::Type,
-        GTFArgs::ScriptGasPrice,
         GTFArgs::ScriptGasLimit,
-        GTFArgs::ScriptMaturity,
         GTFArgs::ScriptLength,
         GTFArgs::ScriptDataLength,
         GTFArgs::ScriptInputsCount,
         GTFArgs::ScriptOutputsCount,
-        GTFArgs::ScriptWitnessesCound,
+        GTFArgs::ScriptWitnessesCount,
         GTFArgs::ScriptReceiptsRoot,
         GTFArgs::Script,
         GTFArgs::ScriptData,
         GTFArgs::ScriptInputAtIndex,
         GTFArgs::ScriptOutputAtIndex,
         GTFArgs::ScriptWitnessAtIndex,
-        GTFArgs::CreateGasPrice,
-        GTFArgs::CreateGasLimit,
-        GTFArgs::CreateMaturity,
         GTFArgs::CreateBytecodeLength,
         GTFArgs::CreateBytecodeWitnessIndex,
         GTFArgs::CreateStorageSlotsCount,
@@ -366,6 +361,11 @@ fn encode_gtf_args() {
         GTFArgs::OutputContractCreatedStateRoot,
         GTFArgs::WitnessDataLength,
         GTFArgs::WitnessData,
+        GTFArgs::PolicyTypes,
+        GTFArgs::PolicyGasPrice,
+        GTFArgs::PolicyWitnessLimit,
+        GTFArgs::PolicyMaturity,
+        GTFArgs::PolicyMaxFee,
     ];
 
     args.into_iter().for_each(|a| {
diff --git a/fuel-asm/src/panic_reason.rs b/fuel-asm/src/panic_reason.rs
index 3298424930..13ac220725 100644
--- a/fuel-asm/src/panic_reason.rs
+++ b/fuel-asm/src/panic_reason.rs
@@ -115,6 +115,10 @@ enum_from! {
         InvalidInstruction = 0x26,
         /// Memory outside $is..$ssp range is not executable
         MemoryNotExecutable = 0x27,
+        /// The policy is not set.
+        PolicyIsNotSet = 0x28,
+        /// The policy is not found across policies.
+        PolicyNotFound = 0x29,
     }
 }
 
diff --git a/fuel-tx/Cargo.toml b/fuel-tx/Cargo.toml
index 1ff1183df4..75604fd5d6 100644
--- a/fuel-tx/Cargo.toml
+++ b/fuel-tx/Cargo.toml
@@ -11,6 +11,7 @@ repository = { workspace = true }
 description = "FuelVM transaction."
 
 [dependencies]
+bitflags = { workspace = true }
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"], optional = true }
 derive_more = { version = "0.99", default-features = false, features = ["display"] }
 fuel-asm = { workspace = true, default-features = false }
@@ -19,7 +20,6 @@ fuel-merkle = { workspace = true, default-features = false, optional = true }
 fuel-types = { workspace = true, default-features = false }
 hashbrown = { version = "0.14", optional = true }
 itertools = { version = "0.10", default-features = false, optional = true }
-num-integer = { version = "0.1", default-features = false, optional = true }
 rand = { version = "0.8", default-features = false, features = ["std_rng"], optional = true }
 serde = { version = "1.0", default-features = false, features = ["alloc", "derive"], optional = true }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"], optional = true }
@@ -45,6 +45,6 @@ builder = ["alloc", "internals"]
 internals = []
 random = ["fuel-crypto/random", "fuel-types/random", "rand"]
 std = ["alloc", "fuel-asm/std", "fuel-crypto/std", "fuel-merkle/std", "fuel-types/std", "itertools/default", "rand?/default", "serde?/default", "hex/std"]
-alloc = ["hashbrown", "fuel-types/alloc", "itertools/use_alloc", "derivative", "fuel-merkle", "num-integer", "strum", "strum_macros"]
+alloc = ["hashbrown", "fuel-types/alloc", "itertools/use_alloc", "derivative", "fuel-merkle", "strum", "strum_macros"]
 # serde is requiring alloc because its mandatory for serde_json. to avoid adding a new feature only for serde_json, we just require `alloc` here since as of the moment we don't have a use case of serde without alloc.
-serde = ["alloc", "dep:serde", "fuel-asm/serde", "fuel-crypto/serde", "fuel-types/serde", "fuel-merkle/serde", "serde_json", "hashbrown/serde"]
+serde = ["alloc", "dep:serde", "fuel-asm/serde", "fuel-crypto/serde", "fuel-types/serde", "fuel-merkle/serde", "serde_json", "hashbrown/serde", "bitflags/serde"]
diff --git a/fuel-tx/src/builder.rs b/fuel-tx/src/builder.rs
index 8819fccf94..f583c8019a 100644
--- a/fuel-tx/src/builder.rs
+++ b/fuel-tx/src/builder.rs
@@ -6,6 +6,8 @@ use crate::{
         field::{
             BytecodeLength,
             BytecodeWitnessIndex,
+            GasPrice,
+            Maturity,
             Witnesses,
         },
         Chargeable,
@@ -34,6 +36,17 @@ use crate::{
     Signable,
 };
 
+use crate::{
+    field::{
+        MaxFeeLimit,
+        WitnessLimit,
+    },
+    policies::Policies,
+};
+use alloc::{
+    collections::BTreeMap,
+    vec::Vec,
+};
 use fuel_crypto::SecretKey;
 use fuel_types::{
     AssetId,
@@ -44,21 +57,9 @@ use fuel_types::{
     Word,
 };
 
-use alloc::{
-    collections::BTreeMap,
-    vec::Vec,
-};
-
 pub trait BuildableAloc
 where
-    Self: Default
-        + Clone
-        + Executable
-        + Chargeable
-        + field::GasLimit
-        + field::GasPrice
-        + field::Maturity
-        + Into<Transaction>,
+    Self: Default + Clone + Executable + Chargeable + field::Policies + Into<Transaction>,
 {
 }
 
@@ -80,31 +81,17 @@ where
         self.witnesses_mut().push(witness);
     }
 
-    /// Set the gas price
-    fn set_gas_price(&mut self, price: Word) {
-        *self.gas_price_mut() = price;
-    }
-
-    /// Set the gas limit
-    fn set_gas_limit(&mut self, limit: Word) {
-        *self.gas_limit_mut() = limit;
-    }
-
-    /// Set the maturity
-    fn set_maturity(&mut self, maturity: BlockHeight) {
-        *self.maturity_mut() = maturity;
+    /// Set the `Script`'s gas limit
+    fn set_script_gas_limit(&mut self, limit: Word)
+    where
+        Self: field::ScriptGasLimit,
+    {
+        *self.script_gas_limit_mut() = limit;
     }
 }
 
 impl<T> BuildableAloc for T where
-    Self: Default
-        + Clone
-        + Executable
-        + Chargeable
-        + field::GasLimit
-        + field::GasPrice
-        + field::Maturity
-        + Into<Transaction>
+    Self: Default + Clone + Executable + Chargeable + field::Policies + Into<Transaction>
 {
 }
 
@@ -129,11 +116,10 @@ pub struct TransactionBuilder<Tx> {
 impl TransactionBuilder<Script> {
     pub fn script(script: Vec<u8>, script_data: Vec<u8>) -> Self {
         let tx = Script {
-            gas_price: Default::default(),
-            gas_limit: Default::default(),
-            maturity: Default::default(),
+            script_gas_limit: Default::default(),
             script,
             script_data,
+            policies: Policies::new().with_gas_price(0),
             inputs: Default::default(),
             outputs: Default::default(),
             witnesses: Default::default(),
@@ -158,13 +144,11 @@ impl TransactionBuilder<Create> {
         // sort the storage slots before initializing the builder
         storage_slots.sort();
         let mut tx = Create {
-            gas_price: Default::default(),
-            gas_limit: Default::default(),
-            maturity: Default::default(),
             bytecode_length: Default::default(),
             bytecode_witness_index: Default::default(),
             salt,
             storage_slots,
+            policies: Policies::new().with_gas_price(0),
             inputs: Default::default(),
             outputs: Default::default(),
             witnesses: Default::default(),
@@ -313,8 +297,11 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         self
     }
 
-    pub fn gas_limit(&mut self, gas_limit: Word) -> &mut Self {
-        self.tx.set_gas_limit(gas_limit);
+    pub fn script_gas_limit(&mut self, gas_limit: Word) -> &mut Self
+    where
+        Tx: field::ScriptGasLimit,
+    {
+        self.tx.set_script_gas_limit(gas_limit);
 
         self
     }
@@ -330,6 +317,18 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         self
     }
 
+    pub fn witness_limit(&mut self, witness_limit: Word) -> &mut Self {
+        self.tx.set_witness_limit(witness_limit);
+
+        self
+    }
+
+    pub fn max_fee_limit(&mut self, max_fee: Word) -> &mut Self {
+        self.tx.set_max_fee_limit(max_fee);
+
+        self
+    }
+
     pub fn add_unsigned_coin_input(
         &mut self,
         secret: SecretKey,
diff --git a/fuel-tx/src/lib.rs b/fuel-tx/src/lib.rs
index 5c742d732d..47b3c3a42e 100644
--- a/fuel-tx/src/lib.rs
+++ b/fuel-tx/src/lib.rs
@@ -73,6 +73,7 @@ pub use transaction::{
     output,
     output::Output,
     output::OutputRepr,
+    policies,
     Cacheable,
     Chargeable,
     CheckError,
diff --git a/fuel-tx/src/tests/bytes.rs b/fuel-tx/src/tests/bytes.rs
index 2778178d3e..81c516cdaa 100644
--- a/fuel-tx/src/tests/bytes.rs
+++ b/fuel-tx/src/tests/bytes.rs
@@ -1,9 +1,17 @@
+use crate::{
+    field::{
+        Inputs,
+        Script,
+        ScriptData,
+    },
+    policies::Policies,
+    *,
+};
 use fuel_asm::{
     op,
     PanicInstruction,
     PanicReason,
 };
-use fuel_tx::*;
 use fuel_tx_test_helpers::{
     generate_bytes,
     generate_nonempty_padded_bytes,
@@ -22,13 +30,6 @@ use rand::{
     RngCore,
     SeedableRng,
 };
-
-use crate::TxParameters;
-use fuel_tx::field::{
-    Inputs,
-    Script,
-    ScriptData,
-};
 use std::fmt;
 use strum::IntoEnumIterator;
 
@@ -270,70 +271,63 @@ fn transaction() {
     assert_encoding_correct(&[
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             rng.gen::<Witness>().into_inner(),
             rng.gen::<Witness>().into_inner(),
+            rng.gen(),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             vec![],
             generate_bytes(rng),
+            rng.gen(),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             rng.gen::<Witness>().into_inner(),
             vec![],
+            rng.gen(),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             vec![],
             vec![],
+            rng.gen(),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             vec![],
             vec![],
+            rng.gen(),
             vec![],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             vec![],
             vec![],
+            rng.gen(),
             vec![],
             vec![],
             vec![w.clone()],
         ),
         Transaction::script(
             rng.next_u64(),
-            rng.next_u64(),
-            rng.gen(),
             vec![],
             vec![],
+            rng.gen(),
             vec![],
             vec![],
             vec![],
@@ -341,8 +335,6 @@ fn transaction() {
     ]);
     assert_encoding_correct(&[
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -352,8 +344,6 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -363,8 +353,6 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -374,8 +362,6 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -385,8 +371,6 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -396,8 +380,6 @@ fn transaction() {
             vec![w],
         ),
         Transaction::create(
-            rng.next_u64(),
-            TxParameters::DEFAULT.max_gas_per_tx,
             rng.gen(),
             rng.gen(),
             rng.gen(),
@@ -421,7 +403,6 @@ fn create_input_data_offset() {
     let rng = &mut StdRng::seed_from_u64(8586);
 
     let gas_price = 100;
-    let gas_limit = 1000;
     let maturity = 10.into();
     let bytecode_witness_index = 0x00;
     let salt = rng.gen();
@@ -493,10 +474,10 @@ fn create_input_data_offset() {
                     inputs.push(input_message.clone());
 
                     let tx = Transaction::create(
-                        gas_price,
-                        gas_limit,
-                        maturity,
                         bytecode_witness_index,
+                        Policies::new()
+                            .with_maturity(maturity)
+                            .with_gas_price(gas_price),
                         salt,
                         storage_slot.clone(),
                         inputs,
@@ -613,11 +594,12 @@ fn script_input_coin_data_offset() {
                         inputs.push(input_coin.clone());
 
                         let tx = Transaction::script(
-                            gas_price,
                             gas_limit,
-                            maturity,
                             script.clone(),
                             script_data.clone(),
+                            Policies::new()
+                                .with_maturity(maturity)
+                                .with_gas_price(gas_price),
                             inputs,
                             outputs.clone(),
                             witnesses.clone(),
diff --git a/fuel-tx/src/tests/valid_cases.rs b/fuel-tx/src/tests/valid_cases.rs
index 1f574600ee..2b45a89ee1 100644
--- a/fuel-tx/src/tests/valid_cases.rs
+++ b/fuel-tx/src/tests/valid_cases.rs
@@ -1,4 +1,4 @@
-use fuel_tx::{
+use crate::{
     ConsensusParameters,
     ContractParameters,
     FeeParameters,
diff --git a/fuel-tx/src/tests/valid_cases/transaction.rs b/fuel-tx/src/tests/valid_cases/transaction.rs
index c93066b1a8..322c176dff 100644
--- a/fuel-tx/src/tests/valid_cases/transaction.rs
+++ b/fuel-tx/src/tests/valid_cases/transaction.rs
@@ -6,9 +6,15 @@ use super::{
     SCRIPT_PARAMS,
     TX_PARAMS,
 };
-
-use fuel_crypto::SecretKey;
-use fuel_tx::*;
+use crate::{
+    policies::Policies,
+    *,
+};
+use core::cmp;
+use fuel_crypto::{
+    SecretKey,
+    Signature,
+};
 use fuel_tx_test_helpers::generate_bytes;
 use fuel_types::canonical::{
     Deserialize,
@@ -21,8 +27,6 @@ use rand::{
     SeedableRng,
 };
 
-use core::cmp;
-
 #[test]
 fn gas_limit() {
     let rng = &mut StdRng::seed_from_u64(8586);
@@ -32,7 +36,6 @@ fn gas_limit() {
 
     TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
@@ -41,7 +44,6 @@ fn gas_limit() {
 
     TransactionBuilder::create(vec![0xfau8].into(), rng.gen(), vec![])
         .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
@@ -49,11 +51,10 @@ fn gas_limit() {
         .expect("Failed to validate transaction");
 
     let err = Transaction::script(
-        rng.gen(),
         TX_PARAMS.max_gas_per_tx + 1,
-        maturity,
         generate_bytes(rng),
         generate_bytes(rng),
+        Policies::new().with_gas_price(rng.gen()),
         vec![],
         vec![],
         vec![],
@@ -61,23 +62,7 @@ fn gas_limit() {
     .check(block_height, &test_params())
     .expect_err("Expected erroneous transaction");
 
-    assert_eq!(CheckError::TransactionGasLimit, err);
-
-    let err = Transaction::create(
-        rng.gen(),
-        TX_PARAMS.max_gas_per_tx + 1,
-        maturity,
-        0,
-        rng.gen(),
-        vec![],
-        vec![],
-        vec![],
-        vec![generate_bytes(rng).into()],
-    )
-    .check(block_height, &test_params())
-    .expect_err("Expected erroneous transaction");
-
-    assert_eq!(CheckError::TransactionGasLimit, err);
+    assert_eq!(CheckError::TransactionMaxGasExceeded, err);
 }
 
 #[test]
@@ -88,7 +73,6 @@ fn maturity() {
 
     TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
         .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .maturity(block_height)
         .add_random_fee_input()
         .finalize()
@@ -97,7 +81,6 @@ fn maturity() {
 
     TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
         .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .maturity(block_height)
         .add_random_fee_input()
         .finalize()
@@ -105,11 +88,10 @@ fn maturity() {
         .expect("Failed to validate tx create");
 
     let err = Transaction::script(
-        rng.gen(),
-        TX_PARAMS.max_gas_per_tx,
-        1001.into(),
+        Default::default(),
         vec![],
         vec![],
+        Policies::new().with_maturity(1001.into()).with_gas_price(0),
         vec![],
         vec![],
         vec![],
@@ -120,10 +102,8 @@ fn maturity() {
     assert_eq!(CheckError::TransactionMaturity, err);
 
     let err = Transaction::create(
-        rng.gen(),
-        TX_PARAMS.max_gas_per_tx,
-        1001.into(),
         0,
+        Policies::new().with_maturity(1001.into()).with_gas_price(0),
         rng.gen(),
         vec![],
         vec![],
@@ -136,6 +116,195 @@ fn maturity() {
     assert_eq!(CheckError::TransactionMaturity, err);
 }
 
+#[test]
+fn script_not_set_witness_limit_success() {
+    // Given
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+
+    // When
+    let result = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn create_not_set_witness_limit_success() {
+    // Given
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+    let bytecode = vec![];
+
+    // When
+    let result = TransactionBuilder::create(bytecode.clone().into(), rng.gen(), vec![])
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn script_set_witness_limit_for_empty_witness_success() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let block_height = 1000.into();
+    // Given
+    let limit = Signature::LEN /* witness from random fee */ + vec![0u8; 0].size_static();
+
+    // When
+    let result = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .add_random_fee_input()
+        .witness_limit(limit as u64)
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn script_set_witness_limit_less_than_witness_data_size_fails() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let block_height = 1000.into();
+    let witness_size = Signature::LEN + vec![0u8; 0].size_static();
+
+    // Given
+    let limit = witness_size - 1;
+
+    // When
+    let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .add_random_fee_input()
+        .witness_limit(limit as u64)
+        .finalize()
+        .check(block_height, &test_params())
+        .expect_err("Expected erroneous transaction");
+
+    // Then
+    assert_eq!(CheckError::TransactionWitnessLimitExceeded, err);
+}
+
+#[test]
+fn create_set_witness_limit_for_empty_witness_success() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let block_height = 1000.into();
+    let bytecode = vec![];
+    // Given
+    let limit = Signature::LEN /* witness from random fee */ + bytecode.size_static() + bytecode.size_static();
+
+    // When
+    let result = TransactionBuilder::create(bytecode.clone().into(), rng.gen(), vec![])
+        .add_random_fee_input()
+        .witness_limit(limit as u64)
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn create_set_witness_limit_less_than_witness_data_size_fails() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+
+    let block_height = 1000.into();
+    let bytecode = vec![];
+    // Given
+    let limit = Signature::LEN /* witness from random fee */ + bytecode.size_static() + bytecode.size_static();
+
+    // When
+    let err = TransactionBuilder::create(bytecode.clone().into(), rng.gen(), vec![])
+        .add_random_fee_input()
+        .witness_limit(limit as u64 - 1)
+        .finalize()
+        .check(block_height, &test_params())
+        .expect_err("Expected erroneous transaction");
+
+    // Then
+    assert_eq!(CheckError::TransactionWitnessLimitExceeded, err);
+}
+
+#[test]
+fn script_not_set_max_fee_limit_success() {
+    // Given
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+
+    // When
+    let result = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .gas_price(rng.gen())
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn script_set_max_fee_limit_fails() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+    // Given
+    let max_fee = 0;
+
+    // When
+    let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
+        .gas_price(rng.gen())
+        .max_fee_limit(max_fee)
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params())
+        .expect_err("Expected erroneous transaction");
+
+    // Then
+    assert_eq!(CheckError::TransactionMaxFeeLimitExceeded, err);
+}
+
+#[test]
+fn create_not_set_max_fee_limit_success() {
+    // Given
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+
+    // When
+    let result = TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
+        .gas_price(rng.gen())
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params());
+
+    // Then
+    assert!(result.is_ok());
+}
+
+#[test]
+fn create_set_max_fee_limit_fails() {
+    let rng = &mut StdRng::seed_from_u64(8586);
+    let block_height = 1000.into();
+    // Given
+    let max_fee = 0;
+
+    // When
+    let err = TransactionBuilder::create(rng.gen(), rng.gen(), vec![])
+        .gas_price(rng.gen())
+        .max_fee_limit(max_fee)
+        .add_random_fee_input()
+        .finalize()
+        .check(block_height, &test_params())
+        .expect_err("Expected erroneous transaction");
+
+    // Then
+    assert_eq!(CheckError::TransactionMaxFeeLimitExceeded, err);
+}
+
 #[test]
 fn max_iow() {
     let rng = &mut StdRng::seed_from_u64(8586);
@@ -152,7 +321,6 @@ fn max_iow() {
 
     builder
         .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .maturity(maturity)
         .add_unsigned_coin_input(
             secret,
@@ -180,10 +348,7 @@ fn max_iow() {
     let mut builder =
         TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![]);
 
-    builder
-        .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
-        .maturity(maturity);
+    builder.gas_price(rng.gen()).maturity(maturity);
 
     let secrets =
         cmp::min(TX_PARAMS.max_inputs as u32, TX_PARAMS.max_witnesses - 1) as usize;
@@ -220,10 +385,7 @@ fn max_iow() {
     let mut builder =
         TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![]);
 
-    builder
-        .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
-        .maturity(maturity);
+    builder.gas_price(rng.gen()).maturity(maturity);
 
     let secrets: Vec<SecretKey> = (0..1 + TX_PARAMS.max_inputs as usize
         - builder.inputs().len())
@@ -260,10 +422,7 @@ fn max_iow() {
     let mut builder =
         TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![]);
 
-    builder
-        .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
-        .maturity(maturity);
+    builder.gas_price(rng.gen()).maturity(maturity);
 
     let secrets: Vec<SecretKey> = (0..TX_PARAMS.max_inputs as usize
         - builder.inputs().len())
@@ -300,10 +459,7 @@ fn max_iow() {
     let mut builder =
         TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![]);
 
-    builder
-        .gas_price(rng.gen())
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
-        .maturity(maturity);
+    builder.gas_price(rng.gen()).maturity(maturity);
 
     let secrets: Vec<SecretKey> = (0..TX_PARAMS.max_inputs as usize
         - builder.inputs().len())
@@ -351,7 +507,6 @@ fn output_change_asset_id() {
     let secret = SecretKey::random(rng);
 
     TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), a, rng.gen(), rng.gen())
@@ -363,7 +518,6 @@ fn output_change_asset_id() {
         .expect("Failed to validate transaction");
 
     let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), a, rng.gen(), rng.gen())
@@ -377,7 +531,6 @@ fn output_change_asset_id() {
     assert_eq!(CheckError::TransactionOutputChangeAssetIdDuplicated(a), err);
 
     let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), a, rng.gen(), rng.gen())
@@ -394,7 +547,6 @@ fn output_change_asset_id() {
     ));
 
     let err = TransactionBuilder::script(generate_bytes(rng), generate_bytes(rng))
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), a, rng.gen(), rng.gen())
@@ -425,7 +577,6 @@ fn script() {
         vec![0xfa; SCRIPT_PARAMS.max_script_length as usize],
         vec![0xfb; SCRIPT_PARAMS.max_script_data_length as usize],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen(), rng.gen())
@@ -438,7 +589,6 @@ fn script() {
         vec![0xfa; SCRIPT_PARAMS.max_script_length as usize],
         vec![0xfb; SCRIPT_PARAMS.max_script_data_length as usize],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen(), rng.gen())
@@ -456,7 +606,6 @@ fn script() {
         vec![0xfa; 1 + SCRIPT_PARAMS.max_script_length as usize],
         vec![0xfb; SCRIPT_PARAMS.max_script_data_length as usize],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen(), rng.gen())
@@ -471,7 +620,6 @@ fn script() {
         vec![0xfa; SCRIPT_PARAMS.max_script_length as usize],
         vec![0xfb; 1 + SCRIPT_PARAMS.max_script_data_length as usize],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(secret, rng.gen(), rng.gen(), asset_id, rng.gen(), rng.gen())
@@ -494,7 +642,6 @@ fn create() {
     let secret_b = SecretKey::random(rng);
 
     TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -510,7 +657,6 @@ fn create() {
         .expect("Failed to validate tx");
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_input(Input::contract(
@@ -537,7 +683,6 @@ fn create() {
 
     let not_empty_data = vec![0x1];
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_message_input(
@@ -562,7 +707,6 @@ fn create() {
     assert_eq!(err, CheckError::TransactionCreateMessageData { index: 0 });
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -584,7 +728,6 @@ fn create() {
     );
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -617,7 +760,6 @@ fn create() {
     let asset_id: AssetId = rng.gen();
 
     let err = TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -655,7 +797,6 @@ fn create() {
     let contract_id = contract.id(&salt, &contract.root(), &state_root);
 
     let err = TransactionBuilder::create(witness.into(), salt, storage_slots)
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -690,7 +831,6 @@ fn create() {
         rng.gen(),
         vec![],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(
@@ -711,7 +851,6 @@ fn create() {
         rng.gen(),
         vec![],
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(
@@ -730,11 +869,9 @@ fn create() {
     assert_eq!(err, CheckError::TransactionCreateBytecodeLen);
 
     let err = Transaction::create(
-        rng.gen(),
-        TX_PARAMS.max_gas_per_tx,
-        maturity,
         1,
         rng.gen(),
+        rng.gen(),
         vec![],
         vec![Input::coin_signed(
             rng.gen(),
@@ -754,7 +891,6 @@ fn create() {
     assert_eq!(err, CheckError::TransactionCreateBytecodeWitnessIndex);
 
     TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-        .gas_limit(TX_PARAMS.max_gas_per_tx)
         .gas_price(rng.gen())
         .maturity(maturity)
         .add_unsigned_coin_input(
@@ -784,7 +920,6 @@ fn create() {
         rng.gen(),
         storage_slots.clone(),
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(
@@ -811,7 +946,6 @@ fn create() {
         rng.gen(),
         storage_slots_max,
     )
-    .gas_limit(TX_PARAMS.max_gas_per_tx)
     .gas_price(rng.gen())
     .maturity(maturity)
     .add_unsigned_coin_input(
@@ -999,10 +1133,10 @@ fn tx_id_bytecode_len() {
     let w_c = vec![0xfbu8; 4].into();
 
     let tx_a = Transaction::create(
-        gas_price,
-        TX_PARAMS.max_gas_per_tx,
-        maturity,
         0,
+        Policies::new()
+            .with_maturity(maturity)
+            .with_gas_price(gas_price),
         salt,
         vec![],
         vec![],
@@ -1011,10 +1145,10 @@ fn tx_id_bytecode_len() {
     );
 
     let tx_b = Transaction::create(
-        gas_price,
-        TX_PARAMS.max_gas_per_tx,
-        maturity,
         0,
+        Policies::new()
+            .with_maturity(maturity)
+            .with_gas_price(gas_price),
         salt,
         vec![],
         vec![],
@@ -1023,10 +1157,10 @@ fn tx_id_bytecode_len() {
     );
 
     let tx_c = Transaction::create(
-        gas_price,
-        TX_PARAMS.max_gas_per_tx,
-        maturity,
         0,
+        Policies::new()
+            .with_maturity(maturity)
+            .with_gas_price(gas_price),
         salt,
         vec![],
         vec![],
@@ -1066,7 +1200,6 @@ mod inputs {
 
         let tx =
             TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-                .gas_limit(TX_PARAMS.max_gas_per_tx)
                 .gas_price(rng.gen())
                 .maturity(rng.gen())
                 .add_input(Input::coin_predicate(
@@ -1094,7 +1227,6 @@ mod inputs {
 
         let tx =
             TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-                .gas_limit(TX_PARAMS.max_gas_per_tx)
                 .gas_price(rng.gen())
                 .maturity(rng.gen())
                 .add_input(Input::coin_predicate(
@@ -1124,7 +1256,6 @@ mod inputs {
 
         let tx =
             TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-                .gas_limit(TX_PARAMS.max_gas_per_tx)
                 .gas_price(rng.gen())
                 .maturity(rng.gen())
                 .add_input(Input::message_data_predicate(
@@ -1151,7 +1282,6 @@ mod inputs {
 
         let tx =
             TransactionBuilder::create(generate_bytes(rng).into(), rng.gen(), vec![])
-                .gas_limit(TX_PARAMS.max_gas_per_tx)
                 .gas_price(rng.gen())
                 .maturity(rng.gen())
                 .add_input(Input::message_data_predicate(
diff --git a/fuel-tx/src/transaction.rs b/fuel-tx/src/transaction.rs
index 10a34c87c5..b49a720c79 100644
--- a/fuel-tx/src/transaction.rs
+++ b/fuel-tx/src/transaction.rs
@@ -1,5 +1,25 @@
+use crate::{
+    input::{
+        coin::{
+            CoinPredicate,
+            CoinSigned,
+        },
+        contract::Contract,
+        message::{
+            MessageCoinPredicate,
+            MessageDataPredicate,
+        },
+    },
+    policies::Policies,
+    TxPointer,
+};
 use fuel_crypto::PublicKey;
 use fuel_types::{
+    canonical::{
+        Deserialize,
+        Error,
+        Serialize,
+    },
     Address,
     AssetId,
     BlockHeight,
@@ -8,6 +28,8 @@ use fuel_types::{
     Salt,
     Word,
 };
+use input::*;
+use output::*;
 
 use alloc::vec::{
     IntoIter,
@@ -24,6 +46,7 @@ mod validity;
 mod id;
 
 pub mod consensus_parameters;
+pub mod policies;
 
 pub use consensus_parameters::{
     ConsensusParameters,
@@ -37,16 +60,10 @@ pub use consensus_parameters::{
     ScriptParameters,
     TxParameters,
 };
-
 pub use fee::{
     Chargeable,
     TransactionFee,
 };
-use fuel_types::canonical::{
-    Deserialize,
-    Error,
-    Serialize,
-};
 pub use metadata::Cacheable;
 pub use repr::TransactionRepr;
 pub use types::*;
@@ -55,23 +72,6 @@ pub use validity::{
     FormatValidityChecks,
 };
 
-use crate::{
-    input::{
-        coin::{
-            CoinPredicate,
-            CoinSigned,
-        },
-        contract::Contract,
-        message::{
-            MessageCoinPredicate,
-            MessageDataPredicate,
-        },
-    },
-    TxPointer,
-};
-use input::*;
-use output::*;
-
 #[cfg(feature = "alloc")]
 pub use id::Signable;
 
@@ -83,6 +83,7 @@ pub type TxId = Bytes32;
 /// The fuel transaction entity <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md>.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, strum_macros::EnumCount)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[allow(clippy::large_enum_variant)]
 pub enum Transaction {
     Script(Script),
     Create(Create),
@@ -108,11 +109,10 @@ impl Transaction {
     }
 
     pub const fn script(
-        gas_price: Word,
         gas_limit: Word,
-        maturity: BlockHeight,
         script: Vec<u8>,
         script_data: Vec<u8>,
+        policies: Policies,
         inputs: Vec<Input>,
         outputs: Vec<Output>,
         witnesses: Vec<Witness>,
@@ -120,12 +120,11 @@ impl Transaction {
         let receipts_root = Bytes32::zeroed();
 
         Script {
-            gas_price,
-            gas_limit,
-            maturity,
+            script_gas_limit: gas_limit,
             receipts_root,
             script,
             script_data,
+            policies,
             inputs,
             outputs,
             witnesses,
@@ -134,10 +133,8 @@ impl Transaction {
     }
 
     pub fn create(
-        gas_price: Word,
-        gas_limit: Word,
-        maturity: BlockHeight,
         bytecode_witness_index: u8,
+        policies: Policies,
         salt: Salt,
         mut storage_slots: Vec<StorageSlot>,
         inputs: Vec<Input>,
@@ -156,11 +153,9 @@ impl Transaction {
         storage_slots.sort();
 
         Create {
-            gas_price,
-            gas_limit,
-            maturity,
             bytecode_length,
             bytecode_witness_index,
+            policies,
             salt,
             storage_slots,
             inputs,
@@ -539,6 +534,7 @@ pub mod field {
     use crate::{
         input,
         output,
+        policies,
         Input,
         Output,
         StorageSlot,
@@ -551,6 +547,7 @@ pub mod field {
         Word,
     };
 
+    use crate::policies::PolicyType;
     use alloc::vec::Vec;
     use core::ops::{
         Deref,
@@ -558,33 +555,88 @@ pub mod field {
     };
 
     pub trait GasPrice {
-        fn gas_price(&self) -> &Word;
-        fn gas_price_mut(&mut self) -> &mut Word;
-        fn gas_price_offset(&self) -> usize {
-            Self::gas_price_offset_static()
+        fn gas_price(&self) -> Word;
+        fn set_gas_price(&mut self, value: Word);
+    }
+
+    impl<T: Policies + ?Sized> GasPrice for T {
+        #[inline(always)]
+        fn gas_price(&self) -> Word {
+            self.policies()
+                .get(PolicyType::GasPrice)
+                .unwrap_or_default()
+        }
+
+        #[inline(always)]
+        fn set_gas_price(&mut self, price: Word) {
+            self.policies_mut().set(PolicyType::GasPrice, Some(price))
+        }
+    }
+
+    pub trait WitnessLimit {
+        fn witness_limit(&self) -> Word;
+        fn set_witness_limit(&mut self, value: Word);
+    }
+
+    impl<T: Policies + ?Sized> WitnessLimit for T {
+        #[inline(always)]
+        fn witness_limit(&self) -> Word {
+            self.policies().get(PolicyType::WitnessLimit).unwrap_or(0)
         }
 
-        fn gas_price_offset_static() -> usize;
+        #[inline(always)]
+        fn set_witness_limit(&mut self, value: Word) {
+            self.policies_mut()
+                .set(PolicyType::WitnessLimit, Some(value))
+        }
     }
 
-    pub trait GasLimit {
-        fn gas_limit(&self) -> &Word;
-        fn gas_limit_mut(&mut self) -> &mut Word;
-        fn gas_limit_offset(&self) -> usize {
-            Self::gas_limit_offset_static()
+    pub trait ScriptGasLimit {
+        fn script_gas_limit(&self) -> &Word;
+        fn script_gas_limit_mut(&mut self) -> &mut Word;
+        fn script_gas_limit_offset(&self) -> usize {
+            Self::script_gas_limit_offset_static()
         }
 
-        fn gas_limit_offset_static() -> usize;
+        fn script_gas_limit_offset_static() -> usize;
     }
 
     pub trait Maturity {
-        fn maturity(&self) -> &BlockHeight;
-        fn maturity_mut(&mut self) -> &mut BlockHeight;
-        fn maturity_offset(&self) -> usize {
-            Self::maturity_offset_static()
+        fn maturity(&self) -> BlockHeight;
+        fn set_maturity(&mut self, value: BlockHeight);
+    }
+
+    impl<T: Policies + ?Sized> Maturity for T {
+        #[inline(always)]
+        fn maturity(&self) -> BlockHeight {
+            self.policies()
+                .get(PolicyType::Maturity)
+                .map(|value| u32::try_from(value).unwrap_or(u32::MAX).into())
+                .unwrap_or_default()
+        }
+
+        #[inline(always)]
+        fn set_maturity(&mut self, block_height: BlockHeight) {
+            self.policies_mut()
+                .set(PolicyType::Maturity, Some(block_height.as_usize() as u64))
         }
+    }
 
-        fn maturity_offset_static() -> usize;
+    pub trait MaxFeeLimit {
+        fn max_fee_limit(&self) -> Word;
+        fn set_max_fee_limit(&mut self, value: Word);
+    }
+
+    impl<T: Policies + ?Sized> MaxFeeLimit for T {
+        #[inline(always)]
+        fn max_fee_limit(&self) -> Word {
+            self.policies().get(PolicyType::MaxFee).unwrap_or(0)
+        }
+
+        #[inline(always)]
+        fn set_max_fee_limit(&mut self, value: Word) {
+            self.policies_mut().set(PolicyType::MaxFee, Some(value))
+        }
     }
 
     pub trait TxPointer {
@@ -647,6 +699,12 @@ pub mod field {
         fn script_data_offset(&self) -> usize;
     }
 
+    pub trait Policies {
+        fn policies(&self) -> &policies::Policies;
+        fn policies_mut(&mut self) -> &mut policies::Policies;
+        fn policies_offset(&self) -> usize;
+    }
+
     pub trait BytecodeLength {
         fn bytecode_length(&self) -> &Word;
         fn bytecode_length_mut(&mut self) -> &mut Word;
@@ -680,11 +738,7 @@ pub mod field {
     pub trait StorageSlots {
         fn storage_slots(&self) -> &Vec<StorageSlot>;
         fn storage_slots_mut(&mut self) -> StorageSlotRef;
-        fn storage_slots_offset(&self) -> usize {
-            Self::storage_slots_offset_static()
-        }
-
-        fn storage_slots_offset_static() -> usize;
+        fn storage_slots_offset(&self) -> usize;
 
         /// Returns the offset to the `StorageSlot` at `idx` index, if any.
         fn storage_slots_offset_at(&self, idx: usize) -> Option<usize>;
@@ -759,24 +813,22 @@ mod tests {
     use super::*;
 
     #[test]
-    fn metered_data_excludes_witnesses() {
+    fn metered_data_includes_witnesses() {
         // test script
         let script_with_no_witnesses = Transaction::script(
-            Default::default(),
-            Default::default(),
             Default::default(),
             vec![],
             vec![],
+            Default::default(),
             vec![],
             vec![],
             vec![],
         );
         let script_with_witnesses = Transaction::script(
-            Default::default(),
-            Default::default(),
             Default::default(),
             vec![],
             vec![],
+            Default::default(),
             vec![],
             vec![],
             vec![[0u8; 64].to_vec().into()],
@@ -785,25 +837,22 @@ mod tests {
         assert_eq!(
             script_with_witnesses.metered_bytes_size(),
             script_with_no_witnesses.metered_bytes_size()
+                + script_with_witnesses.witnesses.size_dynamic()
         );
         // test create
         let create_with_no_witnesses = Transaction::create(
-            Default::default(),
-            Default::default(),
-            Default::default(),
             0,
             Default::default(),
+            Default::default(),
             vec![],
             vec![],
             vec![],
             vec![],
         );
         let create_with_witnesses = Transaction::create(
-            Default::default(),
-            Default::default(),
-            Default::default(),
             0,
             Default::default(),
+            Default::default(),
             vec![],
             vec![],
             vec![],
@@ -812,6 +861,7 @@ mod tests {
         assert_eq!(
             create_with_witnesses.metered_bytes_size(),
             create_with_no_witnesses.metered_bytes_size()
+                + create_with_witnesses.witnesses.size_dynamic()
         );
     }
 }
diff --git a/fuel-tx/src/transaction/consensus_parameters/gas.rs b/fuel-tx/src/transaction/consensus_parameters/gas.rs
index 3bcbeb943e..60030500ef 100644
--- a/fuel-tx/src/transaction/consensus_parameters/gas.rs
+++ b/fuel-tx/src/transaction/consensus_parameters/gas.rs
@@ -593,7 +593,7 @@ impl GasCostsValues {
 }
 
 impl DependentCost {
-    /// Create costs that are all set to zero.
+    /// Create costs that make operations free.
     pub fn free() -> Self {
         Self::HeavyOperation {
             base: 0,
@@ -601,7 +601,7 @@ impl DependentCost {
         }
     }
 
-    /// Create costs that are all set to one.
+    /// Create costs that make operations cost `1`.
     pub fn unit() -> Self {
         Self::HeavyOperation {
             base: 1,
diff --git a/fuel-tx/src/transaction/fee.rs b/fuel-tx/src/transaction/fee.rs
index fa8db0fa43..9e0550caf7 100644
--- a/fuel-tx/src/transaction/fee.rs
+++ b/fuel-tx/src/transaction/fee.rs
@@ -1,5 +1,9 @@
 use crate::{
     field,
+    field::{
+        GasPrice,
+        WitnessLimit,
+    },
     input::{
         coin::{
             CoinPredicate,
@@ -17,6 +21,7 @@ use crate::{
     Input,
 };
 use fuel_asm::Word;
+use fuel_types::canonical::Serialize;
 use hashbrown::HashSet;
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -78,60 +83,6 @@ impl TransactionFee {
         balance.checked_sub(fee)
     }
 
-    /// Attempt to create a transaction fee from parameters and value arguments
-    ///
-    /// Will return `None` if arithmetic overflow occurs or `max_fee` less than `min_fee`.
-    pub fn checked_from_values(
-        params: &FeeParameters,
-        metered_bytes: Word,
-        gas_used_by_signature_checks: Word,
-        gas_used_by_metadata: Word,
-        gas_used_by_predicates: Word,
-        gas_limit: Word,
-        gas_price: Word,
-    ) -> Option<Self> {
-        let factor = params.gas_price_factor as u128;
-
-        let bytes_gas = params.gas_per_byte.checked_mul(metered_bytes)?;
-        let min_gas = bytes_gas
-            .checked_add(gas_used_by_signature_checks)?
-            .checked_add(gas_used_by_metadata)?
-            .checked_add(gas_used_by_predicates)?;
-        let max_gas = min_gas.checked_add(gas_limit)?;
-
-        let max_gas_to_pay = max_gas
-            .checked_mul(gas_price)
-            .and_then(|total| (total as u128).div_ceil(factor).try_into().ok());
-
-        let min_gas_to_pay = min_gas
-            .checked_mul(gas_price)
-            .and_then(|bytes| (bytes as u128).div_ceil(factor).try_into().ok());
-
-        min_gas_to_pay
-            .zip(max_gas_to_pay)
-            .map(|(min_gas_to_pay, max_gas_to_pay)| {
-                Self::new(min_gas_to_pay, max_gas_to_pay, min_gas, max_gas)
-            })
-    }
-
-    /// Attempt to calculate a gas as asset value, using the price factor defined in the
-    /// consensus parameters.
-    ///
-    /// Will return `None` if overflow occurs
-    pub fn gas_refund_value(
-        fee_params: &FeeParameters,
-        gas: Word,
-        price: Word,
-    ) -> Option<Word> {
-        let gas = gas as u128;
-        let price = price as u128;
-        let factor = fee_params.gas_price_factor as u128;
-
-        gas.checked_mul(price)
-            .map(|g| num_integer::div_floor(g, factor))
-            .and_then(|g| g.try_into().ok())
-    }
-
     /// Attempt to create a transaction fee from parameters and transaction internals
     ///
     /// Will return `None` if arithmetic overflow occurs.
@@ -141,57 +92,108 @@ impl TransactionFee {
         tx: &T,
     ) -> Option<Self>
     where
-        T: Chargeable + field::Inputs,
+        T: Chargeable,
     {
-        let metered_bytes = tx.metered_bytes_size() as Word;
-        let gas_used_by_metadata = tx.gas_used_by_metadata(gas_costs) as Word;
-        let gas_used_by_signature_checks = tx.gas_used_by_signature_checks(gas_costs);
-        let gas_used_by_predicates = tx.gas_used_by_predicates();
-        let gas_limit = tx.limit();
-        let gas_price = tx.price();
+        let min_gas = tx.min_gas(gas_costs, params);
+        let max_gas = tx.max_gas(gas_costs, params);
+        let min_fee = tx.min_fee(gas_costs, params).try_into().ok()?;
+        let max_fee = tx.max_fee(gas_costs, params).try_into().ok()?;
 
-        Self::checked_from_values(
-            params,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
+        if min_fee > max_fee {
+            return None
+        }
+
+        Some(Self::new(min_fee, max_fee, min_gas, max_gas))
     }
 }
 
+fn gas_to_fee(gas: Word, gas_price: Word, factor: Word) -> u128 {
+    let total_price = (gas as u128)
+        .checked_mul(gas_price as u128)
+        .expect("Impossible to overflow because multiplication of two `u64` <= `u128`");
+    total_price.div_ceil(factor as u128)
+}
+
 /// Means that the blockchain charges fee for the transaction.
-pub trait Chargeable {
+pub trait Chargeable: field::Inputs + field::Witnesses + field::Policies {
     /// Returns the gas price.
-    fn price(&self) -> Word;
+    fn price(&self) -> Word {
+        self.gas_price()
+    }
+
+    /// Returns the minimum gas required to start transaction execution.
+    fn min_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> Word {
+        let bytes_gas = self.metered_bytes_size() as u64 * fee.gas_per_byte;
+        // It's okay to saturate because we have the `max_gas_per_tx` rule for transaction
+        // validity. In the production, the value always will be lower than
+        // `u64::MAX`.
+        self.gas_used_by_inputs(gas_costs)
+            .saturating_add(self.gas_used_by_metadata(gas_costs))
+            .saturating_add(bytes_gas)
+    }
 
-    /// Returns the gas limit.
-    fn limit(&self) -> Word;
+    /// Returns the maximum possible gas after the end of transaction execution.
+    ///
+    /// The function guarantees that the value is not less than [Self::min_gas].
+    fn max_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> Word {
+        let remaining_allowed_witness_gas = self
+            .witness_limit()
+            .saturating_sub(self.witnesses().size_dynamic() as u64)
+            .saturating_mul(fee.gas_per_byte);
+
+        self.min_gas(gas_costs, fee)
+            .saturating_add(remaining_allowed_witness_gas)
+    }
+
+    /// Returns the minimum fee required to start transaction execution.
+    fn min_fee(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> u128 {
+        gas_to_fee(
+            self.min_gas(gas_costs, fee),
+            self.price(),
+            fee.gas_price_factor,
+        )
+    }
 
-    /// Used for accounting purposes when charging byte based fees.
-    fn metered_bytes_size(&self) -> usize;
+    /// Returns the maximum possible fee after the end of transaction execution.
+    ///
+    /// The function guarantees that the value is not less than [Self::min_fee].
+    fn max_fee(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> u128 {
+        gas_to_fee(
+            self.max_gas(gas_costs, fee),
+            self.price(),
+            fee.gas_price_factor,
+        )
+    }
 
-    /// Used for accounting purposes when charging for predicates.
-    fn gas_used_by_predicates(&self) -> Word
-    where
-        Self: field::Inputs,
-    {
-        let mut cumulative_predicate_gas: Word = 0;
-        for input in self.inputs() {
-            if let Some(predicate_gas_used) = input.predicate_gas_used() {
-                cumulative_predicate_gas =
-                    cumulative_predicate_gas.saturating_add(predicate_gas_used);
-            }
-        }
-        cumulative_predicate_gas
+    /// Returns the fee amount that can be refunded back based on the `used_gas` and
+    /// current state of the transaction.
+    ///
+    /// Return `None` if overflow occurs.
+    fn refund_fee(
+        &self,
+        gas_costs: &GasCosts,
+        fee: &FeeParameters,
+        used_gas: Word,
+    ) -> Option<Word> {
+        // We've already charged the user for witnesses as part of the minimal gas and all
+        // execution required to validate transaction validity rules.
+        let min_gas = self.min_gas(gas_costs, fee);
+
+        let total_used_gas = min_gas.saturating_add(used_gas);
+        let used_fee = gas_to_fee(total_used_gas, self.price(), fee.gas_price_factor);
+
+        let refund = self.max_fee(gas_costs, fee).saturating_sub(used_fee);
+        // It is okay to saturate everywhere above because it only can decrease the value
+        // of `refund`. But here, because we need to return the amount we
+        // want to refund, we need to handle the overflow caused by the price.
+        refund.try_into().ok()
     }
 
-    fn gas_used_by_signature_checks(&self, gas_costs: &GasCosts) -> Word
-    where
-        Self: field::Inputs,
-    {
+    /// Used for accounting purposes when charging byte based fees.
+    fn metered_bytes_size(&self) -> usize;
+
+    /// Returns the gas used by the inputs.
+    fn gas_used_by_inputs(&self, gas_costs: &GasCosts) -> Word {
         let mut witness_cache: HashSet<u8> = HashSet::new();
         self.inputs()
             .iter()
@@ -218,13 +220,24 @@ pub trait Chargeable {
                 | Input::MessageCoinSigned(_)
                 | Input::MessageDataSigned(_) => gas_costs.ecr1,
                 // Charge the cost of the contract root for predicate inputs
-                Input::CoinPredicate(CoinPredicate { predicate, .. })
+                Input::CoinPredicate(CoinPredicate {
+                    predicate,
+                    predicate_gas_used,
+                    ..
+                })
                 | Input::MessageCoinPredicate(MessageCoinPredicate {
-                    predicate, ..
+                    predicate,
+                    predicate_gas_used,
+                    ..
                 })
                 | Input::MessageDataPredicate(MessageDataPredicate {
-                    predicate, ..
-                }) => gas_costs.contract_root.resolve(predicate.len() as u64),
+                    predicate,
+                    predicate_gas_used,
+                    ..
+                }) => gas_costs
+                    .contract_root
+                    .resolve(predicate.len() as u64)
+                    .saturating_add(*predicate_gas_used),
                 // Charge nothing for all other inputs
                 _ => 0,
             })
@@ -234,221 +247,3 @@ pub trait Chargeable {
     /// Used for accounting purposes when charging for metadata creation.
     fn gas_used_by_metadata(&self, gas_costs: &GasCosts) -> Word;
 }
-
-#[cfg(test)]
-#[allow(clippy::cast_possible_truncation)]
-mod tests {
-    use crate::{
-        FeeParameters,
-        TransactionFee,
-        Word,
-    };
-
-    const PARAMS: FeeParameters = FeeParameters::DEFAULT
-        .with_gas_per_byte(2)
-        .with_gas_price_factor(3);
-
-    fn gas_to_fee(params: &FeeParameters, gas: u64, gas_price: Word) -> f64 {
-        let fee = gas * gas_price;
-        fee as f64 / params.gas_price_factor as f64
-    }
-
-    #[test]
-    fn base_fee_is_calculated_correctly() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = 7;
-        let gas_price = 11;
-
-        let params = PARAMS;
-        let fee = TransactionFee::checked_from_values(
-            &params,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .expect("failed to calculate fee");
-
-        let expected_max_gas = params.gas_per_byte * metered_bytes
-            + gas_used_by_signature_checks
-            + gas_used_by_metadata
-            + gas_used_by_predicates
-            + gas_limit;
-        let expected_max_fee =
-            gas_to_fee(&params, expected_max_gas, gas_price).ceil() as Word;
-        let expected_min_gas = params.gas_per_byte * metered_bytes
-            + gas_used_by_signature_checks
-            + gas_used_by_metadata
-            + gas_used_by_predicates;
-        let expected_min_fee =
-            gas_to_fee(&params, expected_min_gas, gas_price).ceil() as Word;
-
-        assert_eq!(expected_max_fee, fee.max_fee);
-        assert_eq!(expected_min_fee, fee.min_fee);
-    }
-
-    #[test]
-    fn base_fee_ceils() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = 7;
-        let gas_price = 11;
-        let params = PARAMS.with_gas_price_factor(10);
-        let fee = TransactionFee::checked_from_values(
-            &params,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .expect("failed to calculate fee");
-
-        let expected_max_gas = params.gas_per_byte * metered_bytes
-            + gas_used_by_signature_checks
-            + gas_used_by_metadata
-            + gas_used_by_predicates
-            + gas_limit;
-        let expected_max_fee = gas_to_fee(&params, expected_max_gas, gas_price);
-        let truncated = expected_max_fee as Word;
-        let expected_max_fee = expected_max_fee.ceil() as Word;
-        assert_ne!(truncated, fee.max_fee);
-        assert_eq!(expected_max_fee, fee.max_fee);
-
-        let expected_min_gas = params.gas_per_byte * metered_bytes
-            + gas_used_by_signature_checks
-            + gas_used_by_metadata
-            + gas_used_by_predicates;
-        let expected_min_fee = gas_to_fee(&params, expected_min_gas, gas_price);
-        let truncated = expected_min_fee as Word;
-        let expected_min_fee = expected_min_fee.ceil() as Word;
-        assert_ne!(truncated, fee.min_fee);
-        assert_eq!(expected_min_fee, fee.min_fee);
-    }
-
-    #[test]
-    fn base_fee_zeroes() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = 7;
-        let gas_price = 0;
-
-        let fee = TransactionFee::checked_from_values(
-            &PARAMS,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .expect("failed to calculate fee");
-
-        let expected = 0u64;
-
-        assert_eq!(expected, fee.max_fee);
-        assert_eq!(expected, fee.min_fee);
-    }
-
-    #[test]
-    fn base_fee_wont_overflow_on_bytes() {
-        let metered_bytes = Word::MAX;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = 7;
-        let gas_price = 11;
-
-        let overflow = TransactionFee::checked_from_values(
-            &PARAMS,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .is_none();
-
-        assert!(overflow);
-    }
-
-    #[test]
-    fn base_fee_wont_overflow_on_gas_used_by_predicates() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = Word::MAX;
-        let gas_limit = 7;
-        let gas_price = 11;
-
-        let overflow = TransactionFee::checked_from_values(
-            &PARAMS,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .is_none();
-
-        assert!(overflow);
-    }
-
-    #[test]
-    fn base_fee_wont_overflow_on_limit() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = Word::MAX;
-        let gas_price = 11;
-
-        let overflow = TransactionFee::checked_from_values(
-            &PARAMS,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .is_none();
-
-        assert!(overflow);
-    }
-
-    #[test]
-    fn base_fee_wont_overflow_on_price() {
-        let metered_bytes = 5;
-        let gas_used_by_signature_checks = 12;
-        let gas_used_by_metadata = 10;
-        let gas_used_by_predicates = 7;
-        let gas_limit = 7;
-        let gas_price = Word::MAX;
-
-        let overflow = TransactionFee::checked_from_values(
-            &PARAMS,
-            metered_bytes,
-            gas_used_by_signature_checks,
-            gas_used_by_metadata,
-            gas_used_by_predicates,
-            gas_limit,
-            gas_price,
-        )
-        .is_none();
-
-        assert!(overflow);
-    }
-}
diff --git a/fuel-tx/src/transaction/id.rs b/fuel-tx/src/transaction/id.rs
index 40484866ee..e298cc42da 100644
--- a/fuel-tx/src/transaction/id.rs
+++ b/fuel-tx/src/transaction/id.rs
@@ -109,7 +109,6 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::TxParameters;
     use core::{
         mem,
         ops::Not,
@@ -279,7 +278,6 @@ mod tests {
     fn assert_id_common_attrs<Tx: Buildable>(tx: &Tx) {
         use core::ops::Deref;
         assert_id_ne(tx, |t| t.set_gas_price(t.gas_price().not()));
-        assert_id_ne(tx, |t| t.set_gas_limit(t.gas_limit().not()));
         assert_id_ne(tx, |t| t.set_maturity((t.maturity().deref().not()).into()));
 
         if !tx.inputs().is_empty() {
@@ -716,16 +714,18 @@ mod tests {
                         for script_data in script_data.iter() {
                             let tx = Transaction::script(
                                 rng.next_u64(),
-                                rng.next_u64(),
-                                rng.gen(),
                                 script.clone(),
                                 script_data.clone(),
+                                rng.gen(),
                                 inputs.clone(),
                                 outputs.clone(),
                                 witnesses.clone(),
                             );
 
                             assert_id_common_attrs(&tx);
+                            assert_id_ne(&tx, |t| {
+                                t.set_script_gas_limit(t.script_gas_limit().not())
+                            });
                             assert_id_ne(&tx, |t| inv_v(t.script_mut()));
                             assert_id_ne(&tx, |t| inv_v(t.script_data_mut()));
                         }
@@ -733,11 +733,9 @@ mod tests {
 
                     for storage_slots in storage_slots.iter() {
                         let tx = Transaction::create(
-                            rng.next_u64(),
-                            TxParameters::DEFAULT.max_gas_per_tx,
-                            rng.gen(),
                             rng.next_u32().to_be_bytes()[0],
                             rng.gen(),
+                            rng.gen(),
                             storage_slots.clone(),
                             inputs.clone(),
                             outputs.clone(),
diff --git a/fuel-tx/src/transaction/policies.rs b/fuel-tx/src/transaction/policies.rs
new file mode 100644
index 0000000000..a234382516
--- /dev/null
+++ b/fuel-tx/src/transaction/policies.rs
@@ -0,0 +1,333 @@
+use fuel_types::{
+    canonical::{
+        Deserialize,
+        Error,
+        Input,
+        Output,
+        Serialize,
+    },
+    BlockHeight,
+    Word,
+};
+
+#[cfg(feature = "random")]
+use rand::{
+    distributions::{
+        Distribution,
+        Standard,
+    },
+    Rng,
+};
+
+bitflags::bitflags! {
+    /// See https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/policy.md#policy
+    #[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    pub struct PoliciesBits: u32 {
+        /// If set, the gas price is present in the policies.
+        const GasPrice = 1 << 0;
+        /// If set, the witness limit is present in the policies.
+        const WitnessLimit = 1 << 1;
+        /// If set, the maturity is present in the policies.
+        const Maturity = 1 << 2;
+        /// If set, the max fee is present in the policies.
+        const MaxFee = 1 << 3;
+    }
+}
+
+/// The helper enum to make user-friendly API for [`Policies::set`] and [`Policies::get`]
+/// methods.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    strum_macros::EnumCount,
+    strum_macros::EnumIter,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum PolicyType {
+    GasPrice,
+    WitnessLimit,
+    Maturity,
+    MaxFee,
+}
+
+impl PolicyType {
+    pub const fn index(&self) -> usize {
+        match self {
+            PolicyType::GasPrice => 0,
+            PolicyType::WitnessLimit => 1,
+            PolicyType::Maturity => 2,
+            PolicyType::MaxFee => 3,
+        }
+    }
+
+    pub const fn bit(&self) -> PoliciesBits {
+        match self {
+            PolicyType::GasPrice => PoliciesBits::GasPrice,
+            PolicyType::WitnessLimit => PoliciesBits::WitnessLimit,
+            PolicyType::Maturity => PoliciesBits::Maturity,
+            PolicyType::MaxFee => PoliciesBits::MaxFee,
+        }
+    }
+}
+
+/// The total number of policies.
+pub const POLICIES_NUMBER: usize = PoliciesBits::all().bits().count_ones() as usize;
+
+/// Container for managing policies.
+#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Policies {
+    /// A bitmask that indicates what policies are set.
+    bits: PoliciesBits,
+    /// The array of policy values.
+    values: [Word; POLICIES_NUMBER],
+}
+
+impl Policies {
+    /// Creates an empty `Self`.
+    pub const fn new() -> Self {
+        Self {
+            bits: PoliciesBits::empty(),
+            values: [0; POLICIES_NUMBER],
+        }
+    }
+
+    /// Returns `true` if no policies are set.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the number of set policies.
+    pub fn len(&self) -> usize {
+        self.bits.bits().count_ones() as usize
+    }
+
+    /// Returns the bit mask of the policies.
+    pub fn bits(&self) -> u32 {
+        self.bits.bits()
+    }
+
+    /// Sets the `gas_price` policy.
+    pub fn with_gas_price(mut self, gas_price: Word) -> Self {
+        self.set(PolicyType::GasPrice, Some(gas_price));
+        self
+    }
+
+    /// Sets the `witness_limit` policy.
+    pub fn with_witness_limit(mut self, witness_limit: Word) -> Self {
+        self.set(PolicyType::WitnessLimit, Some(witness_limit));
+        self
+    }
+
+    /// Sets the `maturity` policy.
+    pub fn with_maturity(mut self, maturity: BlockHeight) -> Self {
+        self.set(PolicyType::Maturity, Some(maturity.as_usize() as u64));
+        self
+    }
+
+    /// Sets the `max_fee` policy.
+    pub fn with_max_fee(mut self, max_fee: Word) -> Self {
+        self.set(PolicyType::MaxFee, Some(max_fee));
+        self
+    }
+
+    /// Returns a policy's value if the corresponding bit is set.
+    pub fn get(&self, policy_type: PolicyType) -> Option<Word> {
+        if self.bits.contains(policy_type.bit()) {
+            Some(self.values[policy_type.index()])
+        } else {
+            None
+        }
+    }
+
+    /// 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())
+    }
+
+    /// Sets a policy's value if the `value` is `Some`, otherwise, unset it.
+    pub fn set(&mut self, policy_type: PolicyType, value: Option<Word>) {
+        if let Some(value) = value {
+            self.bits.insert(policy_type.bit());
+            self.values[policy_type.index()] = value;
+        } else {
+            self.bits.remove(policy_type.bit());
+            self.values[policy_type.index()] = 0;
+        }
+    }
+
+    /// Returns `true` if the `Self` follows all rules from the specification.
+    pub fn is_valid(&self) -> bool {
+        let expected_values = Self::values_for_bitmask(self.bits, self.values);
+
+        if self.bits.bits() > PoliciesBits::all().bits() {
+            return false
+        }
+
+        if self.values != expected_values {
+            return false
+        }
+
+        if let Some(maturity) = self.get(PolicyType::Maturity) {
+            if maturity > u32::MAX as u64 {
+                return false
+            }
+        }
+
+        true
+    }
+
+    /// Helper function to generate values arrays based on the `PoliciesBits`.
+    fn values_for_bitmask(
+        bits: PoliciesBits,
+        default_values: [Word; POLICIES_NUMBER],
+    ) -> [Word; POLICIES_NUMBER] {
+        use strum::IntoEnumIterator;
+        let mut values = [0; POLICIES_NUMBER];
+        for policy_type in PolicyType::iter() {
+            if bits.contains(policy_type.bit()) {
+                values[policy_type.index()] = default_values[policy_type.index()];
+            }
+        }
+        values
+    }
+}
+
+impl Serialize for Policies {
+    fn size_static(&self) -> usize {
+        self.bits.bits().size_static()
+    }
+
+    fn size_dynamic(&self) -> usize {
+        self.bits.bits().count_ones() as usize * Word::MIN.size()
+    }
+
+    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
+        self.bits.bits().encode_static(buffer)
+    }
+
+    fn encode_dynamic<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
+        for (value, bit) in self.values.iter().zip(PoliciesBits::all().iter()) {
+            if self.bits.contains(bit) {
+                value.encode(buffer)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Deserialize for Policies {
+    fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
+        let bits = u32::decode(buffer)?;
+        let bits = PoliciesBits::from_bits(bits)
+            .ok_or(Error::Unknown("Invalid policies bits"))?;
+        Ok(Self {
+            bits,
+            values: Default::default(),
+        })
+    }
+
+    fn decode_dynamic<I: Input + ?Sized>(&mut self, buffer: &mut I) -> Result<(), Error> {
+        for (index, bit) in PoliciesBits::all().iter().enumerate() {
+            if self.bits.contains(bit) {
+                self.values[index] = Word::decode(buffer)?;
+            }
+        }
+
+        if let Some(maturity) = self.get(PolicyType::Maturity) {
+            if maturity > u32::MAX as u64 {
+                return Err(Error::Unknown("The maturity in more than `u32::MAX`"))
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "random")]
+impl Distribution<Policies> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Policies {
+        let bits: u32 = rng.gen();
+        let bits = bits & PoliciesBits::all().bits();
+        let bits = PoliciesBits::from_bits(bits).expect("We checked that above");
+        let values = rng.gen();
+        let mut policies = Policies {
+            bits,
+            values: Policies::values_for_bitmask(bits, values),
+        };
+
+        if policies.get(PolicyType::Maturity).is_some() {
+            let maturity: u32 = rng.gen();
+            policies.set(PolicyType::Maturity, Some(maturity as u64));
+        }
+
+        policies
+    }
+}
+
+#[test]
+fn values_for_bitmask_produces_expected_values() {
+    const MAX_BITMASK: u32 = 1 << POLICIES_NUMBER;
+    const VALUES: [Word; POLICIES_NUMBER] = [0x1000001, 0x2000001, 0x3000001, 0x4000001];
+
+    // Given
+    let mut set = hashbrown::HashSet::new();
+
+    // When
+    for bitmask in 0..MAX_BITMASK {
+        let bits =
+            PoliciesBits::from_bits(bitmask).expect("Should construct a valid bits");
+        set.insert(Policies::values_for_bitmask(bits, VALUES));
+    }
+
+    // Then
+    assert_eq!(set.len(), MAX_BITMASK as usize);
+}
+
+#[test]
+fn canonical_serialization_deserialization_for_any_combination_of_values_works() {
+    const MAX_BITMASK: u32 = 1 << POLICIES_NUMBER;
+    const VALUES: [Word; POLICIES_NUMBER] = [0x1000001, 0x2000001, 0x3000001, 0x4000001];
+
+    for bitmask in 0..MAX_BITMASK {
+        let bits =
+            PoliciesBits::from_bits(bitmask).expect("Should construct a valid bits");
+        let policies = Policies {
+            bits,
+            values: Policies::values_for_bitmask(bits, VALUES),
+        };
+
+        let size = policies.size();
+        let mut buffer = vec![0u8; size];
+        policies
+            .encode(&mut buffer.as_mut_slice())
+            .expect("Should encode without error");
+
+        let new_policies = Policies::decode(&mut buffer.as_slice())
+            .expect("Should decode without error");
+
+        assert_eq!(policies, new_policies);
+        assert_eq!(new_policies.bits.bits(), bitmask);
+
+        for (index, bit) in PoliciesBits::all().iter().enumerate() {
+            if policies.bits.contains(bit) {
+                assert_eq!(VALUES[index], new_policies.values[index]);
+            } else {
+                assert_eq!(0, new_policies.values[index]);
+            }
+        }
+
+        assert_eq!(new_policies.size(), size);
+        // `bitmask.count_ones()` - the number of serialized values
+        assert_eq!(
+            size,
+            (policies.bits.bits().size()
+                + bitmask.count_ones() as usize * Word::MIN.size())
+        );
+    }
+}
diff --git a/fuel-tx/src/transaction/types/create.rs b/fuel-tx/src/transaction/types/create.rs
index 663d59fd89..a35c4e3188 100644
--- a/fuel-tx/src/transaction/types/create.rs
+++ b/fuel-tx/src/transaction/types/create.rs
@@ -1,29 +1,26 @@
 use crate::{
-    transaction::validity::{
-        check_common_part,
-        check_size,
-        FormatValidityChecks,
-    },
-    ConsensusParameters,
-    GasCosts,
-};
-
-use crate::{
-    transaction::field::{
-        BytecodeLength,
-        BytecodeWitnessIndex,
-        GasLimit,
-        GasPrice,
-        Inputs,
-        Maturity,
-        Outputs,
-        Salt as SaltField,
-        StorageSlots,
-        Witnesses,
+    policies::Policies,
+    transaction::{
+        field::{
+            BytecodeLength,
+            BytecodeWitnessIndex,
+            Inputs,
+            Outputs,
+            Policies as PoliciesField,
+            Salt as SaltField,
+            StorageSlots,
+            Witnesses,
+        },
+        validity::{
+            check_common_part,
+            FormatValidityChecks,
+        },
     },
     Chargeable,
     CheckError,
+    ConsensusParameters,
     Contract,
+    GasCosts,
     Input,
     Output,
     StorageSlot,
@@ -34,6 +31,7 @@ use derivative::Derivative;
 use fuel_types::{
     bytes,
     bytes::WORD_SIZE,
+    canonical,
     BlockHeight,
     Bytes32,
     Bytes4,
@@ -112,11 +110,9 @@ impl CreateMetadata {
 #[canonical(prefix = TransactionRepr::Create)]
 #[derivative(Eq, PartialEq, Hash)]
 pub struct Create {
-    pub(crate) gas_price: Word,
-    pub(crate) gas_limit: Word,
-    pub(crate) maturity: BlockHeight,
     pub(crate) bytecode_length: Word,
     pub(crate) bytecode_witness_index: u8,
+    pub(crate) policies: Policies,
     pub(crate) storage_slots: Vec<StorageSlot>,
     pub(crate) inputs: Vec<Input>,
     pub(crate) outputs: Vec<Output>,
@@ -159,20 +155,9 @@ impl crate::UniqueIdentifier for Create {
 }
 
 impl Chargeable for Create {
-    fn price(&self) -> Word {
-        *GasPrice::gas_price(self)
-    }
-
-    fn limit(&self) -> Word {
-        *GasLimit::gas_limit(self)
-    }
-
     #[inline(always)]
     fn metered_bytes_size(&self) -> usize {
-        // Just use the default serialized size for now until
-        // the compressed representation for accounting purposes
-        // is defined. Witness data should still be excluded.
-        self.witnesses_offset()
+        canonical::Serialize::size(self)
     }
 
     fn gas_used_by_metadata(&self, gas_costs: &GasCosts) -> Word {
@@ -183,16 +168,12 @@ impl Chargeable for Create {
             ..
         } = self;
 
-        let contract: Option<Contract> = witnesses
+        let contract_len = witnesses
             .get(*bytecode_witness_index as usize)
-            .map(|c| c.as_ref().into());
-
-        let contract_root_gas = contract
-            .map(|contract| {
-                let contract_len = contract.len() as Word;
-                gas_costs.contract_root.resolve(contract_len)
-            })
+            .map(|c| c.as_ref().len())
             .unwrap_or(0);
+
+        let contract_root_gas = gas_costs.contract_root.resolve(contract_len as Word);
         let state_root_length = storage_slots.len() as Word;
         let state_root_gas = gas_costs.state_root.resolve(state_root_length);
 
@@ -202,8 +183,14 @@ impl Chargeable for Create {
             + core::mem::size_of::<Bytes32>()
             + core::mem::size_of::<Bytes32>();
         let contract_id_gas = gas_costs.s256.resolve(contract_id_input_length as Word);
-
-        contract_root_gas + state_root_gas + contract_id_gas
+        let bytes = canonical::Serialize::size(self);
+        // Gas required to calculate the `tx_id`.
+        let tx_id_gas = gas_costs.s256.resolve(bytes as u64);
+
+        contract_root_gas
+            .saturating_add(state_root_gas)
+            .saturating_add(contract_id_gas)
+            .saturating_add(tx_id_gas)
     }
 }
 
@@ -236,23 +223,13 @@ impl FormatValidityChecks for Create {
         consensus_params: &ConsensusParameters,
     ) -> Result<(), CheckError> {
         let ConsensusParameters {
-            tx_params,
-            predicate_params,
             contract_params,
             chain_id,
             base_asset_id,
             ..
         } = consensus_params;
 
-        check_size(self, consensus_params.tx_params())?;
-
-        check_common_part(
-            self,
-            block_height,
-            tx_params,
-            predicate_params,
-            base_asset_id,
-        )?;
+        check_common_part(self, block_height, consensus_params)?;
 
         let bytecode_witness_len = self
             .witnesses
@@ -376,57 +353,6 @@ mod field {
     use crate::field::StorageSlotRef;
     use fuel_types::canonical::Serialize;
 
-    impl GasPrice for Create {
-        #[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_static() -> usize {
-            WORD_SIZE // `Transaction` enum discriminant
-        }
-    }
-
-    impl GasLimit for Create {
-        #[inline(always)]
-        fn gas_limit(&self) -> &Word {
-            &self.gas_limit
-        }
-
-        #[inline(always)]
-        fn gas_limit_mut(&mut self) -> &mut Word {
-            &mut self.gas_limit
-        }
-
-        #[inline(always)]
-        fn gas_limit_offset_static() -> usize {
-            Self::gas_price_offset_static() + WORD_SIZE
-        }
-    }
-
-    impl Maturity for Create {
-        #[inline(always)]
-        fn maturity(&self) -> &BlockHeight {
-            &self.maturity
-        }
-
-        #[inline(always)]
-        fn maturity_mut(&mut self) -> &mut BlockHeight {
-            &mut self.maturity
-        }
-
-        #[inline(always)]
-        fn maturity_offset_static() -> usize {
-            Self::gas_limit_offset_static() + WORD_SIZE
-        }
-    }
-
     impl BytecodeLength for Create {
         #[inline(always)]
         fn bytecode_length(&self) -> &Word {
@@ -440,7 +366,7 @@ mod field {
 
         #[inline(always)]
         fn bytecode_length_offset_static() -> usize {
-            Self::maturity_offset_static() + WORD_SIZE
+            WORD_SIZE // `Transaction` enum discriminant
         }
     }
 
@@ -461,6 +387,20 @@ mod field {
         }
     }
 
+    impl PoliciesField for Create {
+        fn policies(&self) -> &Policies {
+            &self.policies
+        }
+
+        fn policies_mut(&mut self) -> &mut Policies {
+            &mut self.policies
+        }
+
+        fn policies_offset(&self) -> usize {
+            Self::salt_offset_static() + Salt::LEN
+        }
+    }
+
     impl SaltField for Create {
         #[inline(always)]
         fn salt(&self) -> &Salt {
@@ -475,6 +415,7 @@ mod field {
         #[inline(always)]
         fn salt_offset_static() -> usize {
             Self::bytecode_witness_index_offset_static() + WORD_SIZE
+                + WORD_SIZE // Policies size
                 + WORD_SIZE // Storage slots size
                 + WORD_SIZE // Inputs size
                 + WORD_SIZE // Outputs size
@@ -496,13 +437,13 @@ mod field {
         }
 
         #[inline(always)]
-        fn storage_slots_offset_static() -> usize {
-            Self::salt_offset_static() + Salt::LEN
+        fn storage_slots_offset(&self) -> usize {
+            self.policies_offset() + self.policies.size_dynamic()
         }
 
         fn storage_slots_offset_at(&self, idx: usize) -> Option<usize> {
             if idx < self.storage_slots.len() {
-                Some(Self::storage_slots_offset_static() + idx * StorageSlot::SLOT_SIZE)
+                Some(self.storage_slots_offset() + idx * StorageSlot::SLOT_SIZE)
             } else {
                 None
             }
@@ -522,7 +463,7 @@ mod field {
 
         #[inline(always)]
         fn inputs_offset(&self) -> usize {
-            Self::storage_slots_offset_static()
+            self.storage_slots_offset()
                 + self.storage_slots.len() * StorageSlot::SLOT_SIZE
         }
 
diff --git a/fuel-tx/src/transaction/types/input/snapshot_tests.rs b/fuel-tx/src/transaction/types/input/snapshot_tests.rs
index 49ba6ea248..091bef91d1 100644
--- a/fuel-tx/src/transaction/types/input/snapshot_tests.rs
+++ b/fuel-tx/src/transaction/types/input/snapshot_tests.rs
@@ -19,6 +19,10 @@ fn tx_with_signed_coin_snapshot() {
             predicate: Empty::new(),
             predicate_data: Empty::new(),
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
+        .witness_limit(1000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -41,6 +45,9 @@ fn tx_with_predicate_coin_snapshot() {
             predicate: vec![3u8; 10],
             predicate_data: vec![4u8; 12],
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -58,6 +65,9 @@ fn tx_with_contract_snapshot() {
             tx_pointer: TxPointer::new(46.into(), 5),
             contract_id: [5u8; 32].into(),
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -79,6 +89,10 @@ fn tx_with_signed_message_coin() {
             predicate: Empty::new(),
             predicate_data: Empty::new(),
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
+        .witness_limit(1000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -100,6 +114,9 @@ fn tx_with_predicate_message_coin() {
             predicate: vec![7u8; 11],
             predicate_data: vec![8u8; 12],
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -121,6 +138,10 @@ fn tx_with_signed_message_data() {
             predicate: Empty::new(),
             predicate_data: Empty::new(),
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
+        .witness_limit(1000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
@@ -142,6 +163,9 @@ fn tx_with_predicate_message_data() {
             predicate: vec![7u8; 11],
             predicate_data: vec![8u8; 12],
         }))
+        .gas_price(1)
+        .maturity(123.into())
+        .max_fee_limit(1000000)
         .finalize_as_transaction();
 
     let bytes = tx.to_bytes();
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_contract_snapshot.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_contract_snapshot.snap
index e110220d0a..037f1a9aff 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_contract_snapshot.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_contract_snapshot.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010101010101010101010101010101010101010101010101010101010101010101000000000000000202020202020202020202020202020202020202020202020202020202020202020303030303030303030303030303030303030303030303030303030303030303000000000000002e00000000000000050505050505050505050505050505050505050505050505050505050505050505
+0000000000000000000000000000000000000000000000000000000000000000000000000000000d00000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000007b00000000000f424000000000000000010101010101010101010101010101010101010101010101010101010101010101000000000000000202020202020202020202020202020202020202020202020202020202020202020303030303030303030303030303030303030303030303030303030303030303000000000000002e00000000000000050505050505050505050505050505050505050505050505050505050505050505
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_coin_snapshot.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_coin_snapshot.snap
index bbf9e1b15a..446f666e0b 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_coin_snapshot.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_coin_snapshot.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010101010101010101010101010101010101010101010101010101010101010100000000000000020202020202020202020202020202020202020202020202020202020202020202000000000000000b0505050505050505050505050505050505050505050505050505050505050505000000000000002e00000000000000050000000000000000000000000000000200000000000186a0000000000000000a000000000000000c0303030303030303030300000000000004040404040404040404040400000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000d00000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000007b00000000000f42400000000000000000010101010101010101010101010101010101010101010101010101010101010100000000000000020202020202020202020202020202020202020202020202020202020202020202000000000000000b0505050505050505050505050505050505050505050505050505050505050505000000000000002e00000000000000050000000000000000000000000000000200000000000186a0000000000000000a000000000000000c0303030303030303030300000000000004040404040404040404040400000000
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_coin.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_coin.snap
index 29316c649b..48e7029780 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_coin.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_coin.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020202020202020202020202020202020202020202020202020202020202020202030303030303030303030303030303030303030303030303030303030303030300000000000000040505050505050505050505050505050505050505050505050505050505050505000000000000000000000000000186a00000000000000000000000000000000b000000000000000c0707070707070707070707000000000008080808080808080808080800000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000d00000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000007b00000000000f424000000000000000020202020202020202020202020202020202020202020202020202020202020202030303030303030303030303030303030303030303030303030303030303030300000000000000040505050505050505050505050505050505050505050505050505050505050505000000000000000000000000000186a00000000000000000000000000000000b000000000000000c0707070707070707070707000000000008080808080808080808080800000000
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_data.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_data.snap
index 539290522c..6ab3374a9f 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_data.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_predicate_message_data.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020202020202020202020202020202020202020202020202020202020202020202030303030303030303030303030303030303030303030303030303030303030300000000000000040505050505050505050505050505050505050505050505050505050505050505000000000000000000000000000186a0000000000000000a000000000000000b000000000000000c060606060606060606060000000000000707070707070707070707000000000008080808080808080808080800000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000d00000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000007b00000000000f424000000000000000020202020202020202020202020202020202020202020202020202020202020202030303030303030303030303030303030303030303030303030303030303030300000000000000040505050505050505050505050505050505050505050505050505050505050505000000000000000000000000000186a0000000000000000a000000000000000b000000000000000c060606060606060606060000000000000707070707070707070707000000000008080808080808080808080800000000
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_coin_snapshot.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_coin_snapshot.snap
index 1b1114f385..e0542abfd0 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_coin_snapshot.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_coin_snapshot.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010101010101010101010101010101010101010101010101010101010101010100000000000000020202020202020202020202020202020202020202020202020202020202020202000000000000000b0505050505050505050505050505050505050505050505050505050505050505000000000000002e000000000000000500000000000000040000000000000002000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000f0000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e8000000000000007b00000000000f42400000000000000000010101010101010101010101010101010101010101010101010101010101010100000000000000020202020202020202020202020202020202020202020202020202020202020202000000000000000b0505050505050505050505050505050505050505050505050505050505050505000000000000002e000000000000000500000000000000040000000000000002000000000000000000000000000000000000000000000000
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_coin.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_coin.snap
index 69f0751669..e323d2bc5b 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_coin.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_coin.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020202020202020202020202020202020202020202020202020202020202020203030303030303030303030303030303030303030303030303030303030303030000000000000004050505050505050505050505050505050505050505050505050505050505050500000000000000060000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000f0000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e8000000000000007b00000000000f42400000000000000002020202020202020202020202020202020202020202020202020202020202020203030303030303030303030303030303030303030303030303030303030303030000000000000004050505050505050505050505050505050505050505050505050505050505050500000000000000060000000000000000000000000000000000000000000000000000000000000000
diff --git a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_data.snap b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_data.snap
index b28f689c88..3eedcb9eb0 100644
--- a/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_data.snap
+++ b/fuel-tx/src/transaction/types/input/snapshots/fuel_tx__transaction__types__input__snapshot_tests__tx_with_signed_message_data.snap
@@ -2,4 +2,4 @@
 source: fuel-tx/src/transaction/types/input/snapshot_tests.rs
 expression: hex
 ---
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020202020202020202020202020202020202020202020202020202020202020203030303030303030303030303030303030303030303030303030303030303030000000000000004050505050505050505050505050505050505050505050505050505050505050500000000000000060000000000000000000000000000000a0000000000000000000000000000000007070707070707070707000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000000f0000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e8000000000000007b00000000000f42400000000000000002020202020202020202020202020202020202020202020202020202020202020203030303030303030303030303030303030303030303030303030303030303030000000000000004050505050505050505050505050505050505050505050505050505050505050500000000000000060000000000000000000000000000000a0000000000000000000000000000000007070707070707070707000000000000
diff --git a/fuel-tx/src/transaction/types/script.rs b/fuel-tx/src/transaction/types/script.rs
index 7fdbbb72f6..5dc54fdcf6 100644
--- a/fuel-tx/src/transaction/types/script.rs
+++ b/fuel-tx/src/transaction/types/script.rs
@@ -1,27 +1,28 @@
 use crate::{
+    field::WitnessLimit,
+    policies::Policies,
     transaction::{
         consensus_parameters::TxParameters,
         field::{
-            GasLimit,
-            GasPrice,
             Inputs,
-            Maturity,
             Outputs,
+            Policies as PoliciesField,
             ReceiptsRoot,
             Script as ScriptField,
             ScriptData,
+            ScriptGasLimit,
             Witnesses,
         },
         metadata::CommonMetadata,
         validity::{
             check_common_part,
-            check_size,
             FormatValidityChecks,
         },
         Chargeable,
     },
     CheckError,
     ConsensusParameters,
+    FeeParameters,
     GasCosts,
     Input,
     Output,
@@ -56,13 +57,12 @@ pub(crate) struct ScriptMetadata {
 #[canonical(prefix = TransactionRepr::Script)]
 #[derivative(Eq, PartialEq, Hash, Debug)]
 pub struct Script {
-    pub(crate) gas_price: Word,
-    pub(crate) gas_limit: Word,
-    pub(crate) maturity: BlockHeight,
+    pub(crate) script_gas_limit: Word,
     #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
     pub(crate) script: Vec<u8>,
     #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
     pub(crate) script_data: Vec<u8>,
+    pub(crate) policies: Policies,
     pub(crate) inputs: Vec<Input>,
     pub(crate) outputs: Vec<Output>,
     pub(crate) witnesses: Vec<Witness>,
@@ -81,11 +81,16 @@ impl Default for Script {
         let script = fuel_asm::op::ret(0x10).to_bytes().to_vec();
 
         Self {
-            gas_price: Default::default(),
-            gas_limit: TxParameters::DEFAULT.max_gas_per_tx,
-            maturity: Default::default(),
+            // We want to use any values much less than `max_gas_per_tx`
+            // to avoid the `TransactionMaxGasExceeded` error. For example,
+            // `max_gas_per_tx / 4`.
+            script_gas_limit: TxParameters::DEFAULT.max_gas_per_tx / 4,
             script,
             script_data: Default::default(),
+            policies: Policies::new()
+                .with_gas_price(0)
+                .with_maturity(0.into())
+                .with_witness_limit(10000),
             inputs: Default::default(),
             outputs: Default::default(),
             witnesses: Default::default(),
@@ -121,24 +126,29 @@ impl crate::UniqueIdentifier for Script {
 }
 
 impl Chargeable for Script {
-    fn price(&self) -> Word {
-        *GasPrice::gas_price(self)
-    }
-
-    fn limit(&self) -> Word {
-        *GasLimit::gas_limit(self)
+    #[inline(always)]
+    fn max_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> fuel_asm::Word {
+        // The basic implementation of the `max_gas` + `gas_limit`.
+        let remaining_allowed_witness = self
+            .witness_limit()
+            .saturating_sub(self.witnesses().size_dynamic() as u64)
+            .saturating_mul(fee.gas_per_byte);
+
+        self.min_gas(gas_costs, fee)
+            .saturating_add(remaining_allowed_witness)
+            .saturating_add(self.script_gas_limit)
     }
 
     #[inline(always)]
     fn metered_bytes_size(&self) -> usize {
-        // Just use the default serialized size for now until
-        // the compressed representation for accounting purposes
-        // is defined. Witness data should still be excluded.
-        self.witnesses_offset()
+        Serialize::size(self)
     }
 
-    fn gas_used_by_metadata(&self, _gas_costs: &GasCosts) -> Word {
-        0
+    #[inline(always)]
+    fn gas_used_by_metadata(&self, gas_cost: &GasCosts) -> Word {
+        let bytes = Serialize::size(self);
+        // Gas required to calculate the `tx_id`.
+        gas_cost.s256.resolve(bytes as u64)
     }
 }
 
@@ -166,15 +176,7 @@ impl FormatValidityChecks for Script {
         block_height: BlockHeight,
         consensus_params: &ConsensusParameters,
     ) -> Result<(), CheckError> {
-        check_size(self, consensus_params.tx_params())?;
-
-        check_common_part(
-            self,
-            block_height,
-            consensus_params.tx_params(),
-            consensus_params.predicate_params(),
-            consensus_params.base_asset_id(),
-        )?;
+        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(CheckError::TransactionScriptLength)?;
@@ -216,57 +218,23 @@ impl crate::Cacheable for Script {
 mod field {
     use super::*;
 
-    impl GasPrice for Script {
+    impl ScriptGasLimit for Script {
         #[inline(always)]
-        fn gas_price(&self) -> &Word {
-            &self.gas_price
+        fn script_gas_limit(&self) -> &Word {
+            &self.script_gas_limit
         }
 
         #[inline(always)]
-        fn gas_price_mut(&mut self) -> &mut Word {
-            &mut self.gas_price
+        fn script_gas_limit_mut(&mut self) -> &mut Word {
+            &mut self.script_gas_limit
         }
 
         #[inline(always)]
-        fn gas_price_offset_static() -> usize {
+        fn script_gas_limit_offset_static() -> usize {
             WORD_SIZE // `Transaction` enum discriminant
         }
     }
 
-    impl GasLimit for Script {
-        #[inline(always)]
-        fn gas_limit(&self) -> &Word {
-            &self.gas_limit
-        }
-
-        #[inline(always)]
-        fn gas_limit_mut(&mut self) -> &mut Word {
-            &mut self.gas_limit
-        }
-
-        #[inline(always)]
-        fn gas_limit_offset_static() -> usize {
-            Self::gas_price_offset_static() + WORD_SIZE
-        }
-    }
-
-    impl Maturity for Script {
-        #[inline(always)]
-        fn maturity(&self) -> &BlockHeight {
-            &self.maturity
-        }
-
-        #[inline(always)]
-        fn maturity_mut(&mut self) -> &mut BlockHeight {
-            &mut self.maturity
-        }
-
-        #[inline(always)]
-        fn maturity_offset_static() -> usize {
-            Self::gas_limit_offset_static() + WORD_SIZE
-        }
-    }
-
     impl ReceiptsRoot for Script {
         #[inline(always)]
         fn receipts_root(&self) -> &Bytes32 {
@@ -280,9 +248,10 @@ mod field {
 
         #[inline(always)]
         fn receipts_root_offset_static() -> usize {
-            Self::maturity_offset_static() + WORD_SIZE
+            Self::script_gas_limit_offset_static() + WORD_SIZE
                 + WORD_SIZE // Script size
                 + WORD_SIZE // Script data size
+                + WORD_SIZE // Policies size
                 + WORD_SIZE // Inputs size
                 + WORD_SIZE // Outputs size
                 + WORD_SIZE // Witnesses size
@@ -330,6 +299,23 @@ mod field {
         }
     }
 
+    impl PoliciesField for Script {
+        #[inline(always)]
+        fn policies(&self) -> &Policies {
+            &self.policies
+        }
+
+        #[inline(always)]
+        fn policies_mut(&mut self) -> &mut Policies {
+            &mut self.policies
+        }
+
+        #[inline(always)]
+        fn policies_offset(&self) -> usize {
+            self.script_data_offset() + bytes::padded_len(self.script_data.as_slice())
+        }
+    }
+
     impl Inputs for Script {
         #[inline(always)]
         fn inputs(&self) -> &Vec<Input> {
@@ -351,7 +337,7 @@ mod field {
                 return *inputs_offset
             }
 
-            self.script_data_offset() + bytes::padded_len(self.script_data.as_slice())
+            self.policies_offset() + self.policies.size_dynamic()
         }
 
         #[inline(always)]
diff --git a/fuel-tx/src/transaction/validity.rs b/fuel-tx/src/transaction/validity.rs
index bf7d5011f1..8e5eb2e363 100644
--- a/fuel-tx/src/transaction/validity.rs
+++ b/fuel-tx/src/transaction/validity.rs
@@ -1,35 +1,5 @@
 use crate::{
-    output,
-    ConsensusParameters,
-    Input,
-    Output,
-    Witness,
-};
-use core::hash::Hash;
-
-use fuel_types::{
-    canonical,
-    AssetId,
-    BlockHeight,
-};
-
-use crate::Transaction;
-
-use fuel_types::{
-    Address,
-    Bytes32,
-    ChainId,
-};
-
-use hashbrown::HashMap;
-use itertools::Itertools;
-
-mod error;
-
-#[cfg(test)]
-mod tests;
-
-use crate::{
+    field::Maturity,
     input::{
         coin::{
             CoinPredicate,
@@ -42,6 +12,8 @@ use crate::{
             MessageDataSigned,
         },
     },
+    output,
+    policies::PolicyType,
     transaction::{
         consensus_parameters::{
             PredicateParameters,
@@ -50,7 +22,30 @@ use crate::{
         field,
         Executable,
     },
+    Chargeable,
+    ConsensusParameters,
+    Input,
+    Output,
+    Transaction,
+    Witness,
 };
+use core::hash::Hash;
+use fuel_types::{
+    canonical,
+    canonical::Serialize,
+    Address,
+    BlockHeight,
+    Bytes32,
+    ChainId,
+};
+use hashbrown::HashMap;
+use itertools::Itertools;
+
+mod error;
+
+#[cfg(test)]
+mod tests;
+
 pub use error::CheckError;
 
 impl Input {
@@ -317,23 +312,49 @@ where
 pub(crate) fn check_common_part<T>(
     tx: &T,
     block_height: BlockHeight,
-    tx_params: &TxParameters,
-    predicate_params: &PredicateParameters,
-    base_asset_id: &AssetId,
+    consensus_params: &ConsensusParameters,
 ) -> Result<(), CheckError>
 where
-    T: field::GasPrice
-        + field::GasLimit
-        + field::Maturity
-        + field::Inputs
-        + field::Outputs
-        + field::Witnesses,
+    T: canonical::Serialize + Chargeable + field::Outputs,
 {
-    if tx.gas_limit() > &tx_params.max_gas_per_tx {
-        Err(CheckError::TransactionGasLimit)?
+    let ConsensusParameters {
+        tx_params,
+        predicate_params,
+        base_asset_id,
+        gas_costs,
+        fee_params,
+        ..
+    } = consensus_params;
+
+    check_size(tx, tx_params)?;
+
+    if !tx.policies().is_valid() {
+        Err(CheckError::TransactionPoliciesAreInvalid)?
+    }
+
+    if tx.policies().get(PolicyType::GasPrice).is_none() {
+        Err(CheckError::TransactionNoGasPricePolicy)?
+    }
+
+    if let Some(witness_limit) = tx.policies().get(PolicyType::WitnessLimit) {
+        let witness_size = tx.witnesses().size_dynamic();
+        if witness_size as u64 > witness_limit {
+            Err(CheckError::TransactionWitnessLimitExceeded)?
+        }
+    }
+
+    let max_gas = tx.max_gas(gas_costs, fee_params);
+    if max_gas > tx_params.max_gas_per_tx {
+        Err(CheckError::TransactionMaxGasExceeded)?
+    }
+
+    if let Some(max_fee_limit) = tx.policies().get(PolicyType::MaxFee) {
+        if tx.max_fee(gas_costs, fee_params) > max_fee_limit as u128 {
+            Err(CheckError::TransactionMaxFeeLimitExceeded)?
+        }
     }
 
-    if tx.maturity() > &block_height {
+    if tx.maturity() > block_height {
         Err(CheckError::TransactionMaturity)?;
     }
 
diff --git a/fuel-tx/src/transaction/validity/error.rs b/fuel-tx/src/transaction/validity/error.rs
index ee1eeb9366..c97d08466b 100644
--- a/fuel-tx/src/transaction/validity/error.rs
+++ b/fuel-tx/src/transaction/validity/error.rs
@@ -88,7 +88,11 @@ pub enum CheckError {
     /// The transaction exceeded the size limit.
     TransactionSizeLimitExceeded,
     /// Max gas per tx exceeded
-    TransactionGasLimit,
+    TransactionMaxGasExceeded,
+    TransactionMaxFeeLimitExceeded,
+    TransactionWitnessLimitExceeded,
+    TransactionPoliciesAreInvalid,
+    TransactionNoGasPricePolicy,
     TransactionMaturity,
     TransactionInputsMax,
     TransactionOutputsMax,
diff --git a/fuel-vm/Cargo.toml b/fuel-vm/Cargo.toml
index f8f6870ffe..eae7817b51 100644
--- a/fuel-vm/Cargo.toml
+++ b/fuel-vm/Cargo.toml
@@ -14,7 +14,7 @@ description = "FuelVM interpreter."
 anyhow = { version = "1.0", optional = true }
 async-trait = "0.1"
 backtrace = { version = "0.3", optional = true } # requires debug symbols to work
-bitflags = "1"
+bitflags = { workspace = true }
 derivative = "2.2"
 derive_more = { version = "0.99", default-features = false, features = ["display"] }
 dyn-clone = { version = "1.0", optional = true }
diff --git a/fuel-vm/examples/external.rs b/fuel-vm/examples/external.rs
index d42acaa1c9..26a063c860 100644
--- a/fuel-vm/examples/external.rs
+++ b/fuel-vm/examples/external.rs
@@ -99,7 +99,7 @@ fn main() {
     let consensus_params = ConsensusParameters::standard();
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(0)
-        .gas_limit(1_000_000)
+        .script_gas_limit(1_000_000)
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
diff --git a/fuel-vm/src/checked_transaction.rs b/fuel-vm/src/checked_transaction.rs
index 7e69aa5ae6..68d4e46f16 100644
--- a/fuel-vm/src/checked_transaction.rs
+++ b/fuel-vm/src/checked_transaction.rs
@@ -38,12 +38,12 @@ pub use types::*;
 
 use crate::{
     error::PredicateVerificationFailed,
-    interpreter::CheckedMetadata as CheckedMetadataAccessTrait,
     prelude::*,
 };
 
 bitflags::bitflags! {
     /// Possible types of transaction checks.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
     pub struct Checks: u32 {
         /// Basic checks defined in the specification for each transaction:
         /// https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md#transaction
@@ -52,16 +52,12 @@ bitflags::bitflags! {
         const Signatures    = 0b00000010;
         /// Check that predicate in the transactions are valid.
         const Predicates    = 0b00000100;
-        /// All possible checks.
-        const All           = Self::Basic.bits
-                            | Self::Signatures.bits
-                            | Self::Predicates.bits;
     }
 }
 
 impl core::fmt::Display for Checks {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-        write!(f, "{:032b}", self.bits)
+        write!(f, "{:032b}", self.bits())
     }
 }
 
@@ -317,10 +313,8 @@ where
         params: &CheckPredicateParams,
     ) -> Result<Self, CheckError> {
         if !self.checks_bitmask.contains(Checks::Predicates) {
-            let checked =
-                Interpreter::<PredicateStorage, _>::check_predicates(&self, params)?;
+            Interpreter::<PredicateStorage, _>::check_predicates(&self, params)?;
             self.checks_bitmask.insert(Checks::Predicates);
-            self.metadata.set_gas_used_by_predicates(checked.gas_used());
         }
         Ok(self)
     }
@@ -333,15 +327,12 @@ where
         E: ParallelExecutor,
     {
         if !self.checks_bitmask.contains(Checks::Predicates) {
-            let predicates_checked =
-                Interpreter::<PredicateStorage, _>::check_predicates_async::<E>(
-                    &self, params,
-                )
-                .await?;
+            Interpreter::<PredicateStorage, _>::check_predicates_async::<E>(
+                &self, params,
+            )
+            .await?;
 
             self.checks_bitmask.insert(Checks::Predicates);
-            self.metadata
-                .set_gas_used_by_predicates(predicates_checked.gas_used());
 
             Ok(self)
         } else {
@@ -623,10 +614,16 @@ mod tests {
     use fuel_asm::op;
     use fuel_crypto::SecretKey;
     use fuel_tx::{
+        field::{
+            ScriptGasLimit,
+            WitnessLimit,
+            Witnesses,
+        },
         CheckError,
         Script,
         TransactionBuilder,
     };
+    use fuel_types::canonical::Serialize;
     use quickcheck::TestResult;
     use quickcheck_macros::quickcheck;
     use rand::{
@@ -721,7 +718,7 @@ mod tests {
         let gas_limit = 1000;
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .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(), rng.gen())
@@ -750,7 +747,7 @@ mod tests {
         let gas_limit = 1000;
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_input(Input::message_data_predicate(
                 rng.gen(),
                 rng.gen(),
@@ -785,6 +782,7 @@ mod tests {
     fn max_fee_coin_input(
         gas_price: u64,
         gas_limit: u64,
+        witness_limit: u64,
         input_amount: u64,
         gas_price_factor: u64,
         seed: u64,
@@ -801,8 +799,14 @@ mod tests {
         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, gas_price, gas_limit, input_amount, predicate_gas_used);
+        let tx = predicate_tx(
+            rng,
+            gas_price,
+            gas_limit,
+            witness_limit,
+            input_amount,
+            predicate_gas_used,
+        );
 
         if let Ok(valid) = is_valid_max_fee(&tx, &gas_costs, &fee_params, &base_asset_id)
         {
@@ -818,6 +822,7 @@ mod tests {
     fn min_fee_coin_input(
         gas_price: u64,
         gas_limit: u64,
+        witness_limit: u64,
         input_amount: u64,
         gas_price_factor: u64,
         seed: u64,
@@ -833,8 +838,14 @@ mod tests {
         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, gas_price, gas_limit, input_amount, predicate_gas_used);
+        let tx = predicate_tx(
+            rng,
+            gas_price,
+            gas_limit,
+            witness_limit,
+            input_amount,
+            predicate_gas_used,
+        );
 
         if let Ok(valid) = is_valid_max_fee(&tx, &gas_costs, &fee_params, &base_asset_id)
         {
@@ -854,8 +865,6 @@ mod tests {
         gas_price_factor: u64,
         seed: u64,
     ) -> TestResult {
-        // verify max fee a transaction can consume based on gas limit + bytes is correct
-
         // dont divide by zero
         if gas_price_factor == 0 {
             return TestResult::discard()
@@ -875,6 +884,42 @@ mod tests {
         }
     }
 
+    // use quickcheck to fuzz any rounding or precision errors in refund calculation
+    #[quickcheck]
+    fn refund_when_used_gas_is_zero(
+        gas_price: u64,
+        gas_limit: u64,
+        input_amount: u64,
+        gas_price_factor: u64,
+        seed: u64,
+    ) -> TestResult {
+        // dont divide by zero
+        if gas_price_factor == 0 {
+            return TestResult::discard()
+        }
+
+        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 tx = predicate_message_coin_tx(rng, gas_price, gas_limit, input_amount);
+
+        // Given
+        let used_gas = 0;
+
+        // When
+        let refund = tx.refund_fee(&gas_costs, &fee_params, used_gas);
+
+        let min_fee = tx.min_fee(&gas_costs, &fee_params);
+        let max_fee = tx.max_fee(&gas_costs, &fee_params);
+
+        // Then
+        if let Some(refund) = refund {
+            TestResult::from_bool(max_fee - min_fee == refund as u128)
+        } else {
+            TestResult::discard()
+        }
+    }
+
     // use quickcheck to fuzz any rounding or precision errors in the min fee w/ message
     // input
     #[quickcheck]
@@ -914,7 +959,7 @@ mod tests {
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             // Set up 3 signed inputs
             .add_unsigned_message_input(
                 SecretKey::random(rng),
@@ -942,7 +987,8 @@ mod tests {
 
         let min_fee = fee.min_fee();
         let expected_min_fee = (tx.metered_bytes_size() as u64 * fee_params.gas_per_byte
-            + 3 * gas_costs.ecr1)
+            + 3 * gas_costs.ecr1
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
@@ -961,7 +1007,7 @@ mod tests {
         let secret = SecretKey::random(rng);
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             // Set up 3 signed inputs
             .add_unsigned_message_input(
                 secret,
@@ -992,7 +1038,8 @@ mod tests {
         // be recovered once. Therefore, we charge only once for the address
         // recovery of the signed inputs.
         let expected_min_fee = (tx.metered_bytes_size() as u64 * fee_params.gas_per_byte
-            + gas_costs.ecr1)
+            + gas_costs.ecr1
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
@@ -1021,7 +1068,7 @@ mod tests {
         let predicate_3 = random_bytes::<4096, _>(rng);
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             // Set up 3 predicate inputs
             .add_input(Input::message_coin_predicate(
                 rng.gen(),
@@ -1060,7 +1107,8 @@ mod tests {
             + gas_costs.contract_root.resolve(predicate_3.len() as u64)
             + 50
             + 100
-            + 200)
+            + 200
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
@@ -1081,7 +1129,7 @@ mod tests {
         let predicate_3 = random_bytes::<4096, _>(rng);
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             // Set up 3 signed inputs
             .add_unsigned_message_input(
                 SecretKey::random(rng),
@@ -1143,7 +1191,8 @@ mod tests {
             + gas_costs.contract_root.resolve(predicate_3.len() as u64)
             + 50
             + 100
-            + 200)
+            + 200
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
@@ -1156,7 +1205,7 @@ mod tests {
     fn fee_create_tx() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let gas_price = 100;
-        let gas_limit = 1000;
+        let witness_limit = 1000;
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
         let gen_storage_slot = || rng.gen::<StorageSlot>();
@@ -1167,9 +1216,9 @@ mod tests {
         let bytecode = rng.gen::<Witness>();
         let bytecode_len = bytecode.as_ref().len();
         let salt = rng.gen::<Salt>();
-        let tx = TransactionBuilder::create(bytecode, salt, storage_slots)
+        let tx = TransactionBuilder::create(bytecode.clone(), salt, storage_slots)
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .witness_limit(witness_limit)
             .finalize();
         let fee = TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx).unwrap();
 
@@ -1177,12 +1226,16 @@ mod tests {
         let expected_min_fee = (tx.metered_bytes_size() as u64 * fee_params.gas_per_byte
             + gas_costs.state_root.resolve(storage_slots_len as Word)
             + gas_costs.contract_root.resolve(bytecode_len as Word)
-            + gas_costs.s256.resolve(100))
+            + gas_costs.s256.resolve(100)
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
         let max_fee = fee.max_fee();
-        let expected_max_fee = min_fee + gas_limit * gas_price;
+        let expected_max_fee = min_fee
+            + (witness_limit - bytecode.size() as u64)
+                * fee_params.gas_per_byte
+                * gas_price;
         assert_eq!(max_fee, expected_max_fee);
     }
 
@@ -1190,14 +1243,14 @@ mod tests {
     fn fee_create_tx_no_bytecode() {
         let rng = &mut StdRng::seed_from_u64(2322u64);
         let gas_price = 100;
-        let gas_limit = 1000;
+        let witness_limit = 1000;
         let gas_costs = GasCosts::default();
         let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
         let bytecode: Witness = Vec::<u8>::new().into();
         let salt = rng.gen::<Salt>();
-        let tx = TransactionBuilder::create(bytecode, salt, vec![])
+        let tx = TransactionBuilder::create(bytecode.clone(), salt, vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .witness_limit(witness_limit)
             .finalize();
         let fee = TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx).unwrap();
 
@@ -1205,12 +1258,16 @@ mod tests {
         let expected_min_fee = (tx.metered_bytes_size() as u64 * fee_params.gas_per_byte
             + gas_costs.state_root.resolve(0)
             + gas_costs.contract_root.resolve(0)
-            + gas_costs.s256.resolve(100))
+            + gas_costs.s256.resolve(100)
+            + gas_costs.s256.resolve(tx.size() as u64))
             * gas_price;
         assert_eq!(min_fee, expected_min_fee);
 
         let max_fee = fee.max_fee();
-        let expected_max_fee = min_fee + gas_limit * gas_price;
+        let expected_max_fee = min_fee
+            + (witness_limit - bytecode.size_static() as u64)
+                * fee_params.gas_per_byte
+                * gas_price;
         assert_eq!(max_fee, expected_max_fee);
     }
 
@@ -1226,7 +1283,7 @@ mod tests {
         // create a tx with invalid signature
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_input(Input::coin_signed(
                 rng.gen(),
                 rng.gen(),
@@ -1254,13 +1311,7 @@ mod tests {
             .expect_err("Expected invalid transaction");
 
         // assert that tx without base input assets fails
-        assert_eq!(
-            CheckError::InsufficientFeeAmount {
-                expected: 1,
-                provided: 0
-            },
-            checked
-        );
+        assert!(matches!(checked, CheckError::InsufficientFeeAmount { .. }));
     }
 
     #[test]
@@ -1358,7 +1409,7 @@ mod tests {
         let any_asset = rng.gen();
         let tx = TransactionBuilder::script(vec![], vec![])
             .gas_price(1)
-            .gas_limit(100)
+            .script_gas_limit(100)
             // base asset
             .add_unsigned_coin_input(
                 secret,
@@ -1438,7 +1489,7 @@ mod tests {
         let block_height = 1.into();
         let gas_costs = GasCosts::default();
 
-        let tx = predicate_tx(&mut rng, 1, 1000000, 1000000, gas_costs.ret);
+        let tx = predicate_tx(&mut rng, 1, 1000000, 1000000, 1000000, gas_costs.ret);
 
         let consensus_params = ConsensusParameters {
             gas_costs,
@@ -1462,35 +1513,45 @@ mod tests {
             .contains(Checks::Basic | Checks::Predicates));
     }
 
-    fn is_valid_max_fee<Tx>(
-        tx: &Tx,
+    fn is_valid_max_fee(
+        tx: &Script,
         gas_costs: &GasCosts,
         fee_params: &FeeParameters,
         base_asset_id: &AssetId,
-    ) -> Result<bool, CheckError>
-    where
-        Tx: Chargeable + field::Inputs + field::Outputs,
-    {
+    ) -> Result<bool, CheckError> {
+        fn gas_to_fee(gas: u64, price: u64, factor: u64) -> u128 {
+            let prices_gas = gas as u128 * price as u128;
+            let fee = prices_gas / factor as u128;
+            let fee_remainder = (prices_gas.rem_euclid(factor as u128) > 0) as u128;
+            fee + fee_remainder
+        }
+
         let available_balances =
             balances::initial_free_balances(tx, gas_costs, fee_params, base_asset_id)?;
         // cant overflow as metered bytes * gas_per_byte < u64::MAX
-        let gas_used_by_bytes =
-            tx.metered_bytes_size() as u128 * fee_params.gas_per_byte as u128;
-        let gas_used_by_signature_checks =
-            tx.gas_used_by_signature_checks(gas_costs) as u128;
-        let gas_used_by_predicates = tx.gas_used_by_predicates() as u128;
-        let total = (gas_used_by_bytes
-            + gas_used_by_predicates
-            + gas_used_by_signature_checks
-            + tx.limit() as u128)
-            * tx.price() as u128;
+        let gas_used_by_bytes = fee_params
+            .gas_per_byte
+            .saturating_mul(tx.metered_bytes_size() as u64);
+        let gas_used_by_inputs = tx.gas_used_by_inputs(gas_costs);
+        let gas_used_by_metadata = tx.gas_used_by_metadata(gas_costs);
+        let min_gas = gas_used_by_bytes
+            .saturating_add(gas_used_by_inputs)
+            .saturating_add(gas_used_by_metadata);
+
         // use different division mechanism than impl
-        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 + fee_remainder) as u64;
+        let witness_limit_allowance = tx
+            .witness_limit()
+            .saturating_sub(tx.witnesses().size_dynamic() as u64)
+            .saturating_mul(fee_params.gas_per_byte);
+        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, tx.price(), fee_params.gas_price_factor)
+            .try_into()
+            .map_err(|_| CheckError::ArithmeticOverflow)?;
 
-        Ok(rounded_fee == available_balances.fee.max_fee())
+        let result = max_fee == available_balances.fee.max_fee();
+        Ok(result)
     }
 
     fn is_valid_min_fee<Tx>(
@@ -1506,21 +1567,25 @@ mod tests {
             balances::initial_free_balances(tx, gas_costs, fee_params, base_asset_id)?;
         // cant overflow as (metered bytes + gas_used_by_predicates) * gas_per_byte <
         // u64::MAX
-        let gas_used_by_bytes =
-            tx.metered_bytes_size() as u128 * fee_params.gas_per_byte as u128;
-        let gas_used_by_signature_checks =
-            tx.gas_used_by_signature_checks(gas_costs) as u128;
-        let gas_used_by_predicates = tx.gas_used_by_predicates() as u128;
-        let total =
-            (gas_used_by_bytes + gas_used_by_predicates + gas_used_by_signature_checks)
-                * tx.price() as u128;
+        let gas_used_by_bytes = fee_params
+            .gas_per_byte
+            .saturating_mul(tx.metered_bytes_size() as u64);
+        let gas_used_by_inputs = tx.gas_used_by_inputs(gas_costs);
+        let gas_used_by_metadata = tx.gas_used_by_metadata(gas_costs);
+        let gas = gas_used_by_bytes
+            .saturating_add(gas_used_by_inputs)
+            .saturating_add(gas_used_by_metadata);
+        let total = gas as u128 * tx.price() as u128;
         // use different division mechanism than impl
         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 + fee_remainder) as u64;
+        let rounded_fee = fee.saturating_add(fee_remainder);
+        let min_fee: u64 = rounded_fee
+            .try_into()
+            .map_err(|_| CheckError::ArithmeticOverflow)?;
 
-        Ok(rounded_fee == available_balances.fee.min_fee())
+        Ok(min_fee == available_balances.fee.min_fee())
     }
 
     fn valid_coin_tx(
@@ -1533,7 +1598,7 @@ mod tests {
         let asset = AssetId::default();
         TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_unsigned_coin_input(
                 SecretKey::random(rng),
                 rng.gen(),
@@ -1560,6 +1625,7 @@ mod tests {
         rng: &mut StdRng,
         gas_price: u64,
         gas_limit: u64,
+        witness_limit: u64,
         fee_input_amount: u64,
         predicate_gas_used: u64,
     ) -> Script {
@@ -1568,7 +1634,8 @@ mod tests {
         let owner = Input::predicate_owner(&predicate);
         TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
+            .witness_limit(witness_limit)
             .add_input(Input::coin_predicate(
                 rng.gen(),
                 owner,
@@ -1593,7 +1660,7 @@ mod tests {
     ) -> Script {
         TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_unsigned_message_input(
                 SecretKey::random(rng),
                 rng.gen(),
@@ -1612,7 +1679,7 @@ mod tests {
     ) -> Script {
         TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_input(Input::message_coin_predicate(
                 rng.gen(),
                 rng.gen(),
@@ -1633,7 +1700,7 @@ mod tests {
     ) -> Script {
         TransactionBuilder::script(vec![], vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .add_unsigned_coin_input(
                 SecretKey::random(rng),
                 rng.gen(),
diff --git a/fuel-vm/src/checked_transaction/types.rs b/fuel-vm/src/checked_transaction/types.rs
index ddfbaf7993..1c724935ee 100644
--- a/fuel-vm/src/checked_transaction/types.rs
+++ b/fuel-vm/src/checked_transaction/types.rs
@@ -72,10 +72,7 @@ pub mod create {
         FormatValidityChecks,
         TransactionFee,
     };
-    use fuel_types::{
-        BlockHeight,
-        Word,
-    };
+    use fuel_types::BlockHeight;
 
     /// Metdata produced by checking [`fuel_tx::Create`].
     #[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -86,9 +83,6 @@ pub mod create {
         pub block_height: BlockHeight,
         /// The fees and gas usage
         pub fee: TransactionFee,
-        /// If predicates have been checked, this is how much gas checking them used.
-        /// This must be zero if the predicates have not been checked yet.
-        pub gas_used_by_predicates: Word,
     }
 
     impl IntoChecked for Create {
@@ -123,7 +117,6 @@ pub mod create {
                 free_balances: NonRetryableFreeBalances(non_retryable_balances),
                 block_height,
                 fee,
-                gas_used_by_predicates: 0,
             };
 
             Ok(Checked::basic(self, metadata))
@@ -185,10 +178,7 @@ pub mod script {
         Script,
         TransactionFee,
     };
-    use fuel_types::{
-        BlockHeight,
-        Word,
-    };
+    use fuel_types::BlockHeight;
 
     /// Metdata produced by checking [`fuel_tx::Script`].
     #[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -201,9 +191,6 @@ pub mod script {
         pub block_height: BlockHeight,
         /// The fees and gas usage
         pub fee: TransactionFee,
-        /// If predicates have been checked, this is how much gas checking them used.
-        /// This must be zero if the predicates have not been checked yet.
-        pub gas_used_by_predicates: Word,
     }
 
     impl IntoChecked for Script {
@@ -238,7 +225,6 @@ pub mod script {
                 },
                 block_height,
                 fee,
-                gas_used_by_predicates: 0,
             };
 
             Ok(Checked::basic(self, metadata))
diff --git a/fuel-vm/src/error.rs b/fuel-vm/src/error.rs
index f35676c36b..904a1f55ed 100644
--- a/fuel-vm/src/error.rs
+++ b/fuel-vm/src/error.rs
@@ -4,6 +4,7 @@ use fuel_asm::{
     PanicInstruction,
     PanicReason,
     RawInstruction,
+    Word,
 };
 use fuel_tx::CheckError;
 
@@ -244,9 +245,9 @@ pub enum PredicateVerificationFailed {
     /// The predicate gas used was not specified before execution
     #[display(fmt = "Predicate failed to evaluate")]
     GasNotSpecified,
-    /// The transaction doesn't contain enough gas to evaluate all predicates
-    #[display(fmt = "Insufficient gas available for all predicates")]
-    CumulativePredicateGasExceededTxGasLimit,
+    /// The transaction's `max_gas` is greater than the global gas limit.
+    #[display(fmt = "Transaction exceeds total gas allowance {_0:?}")]
+    TransactionExceedsTotalGasAllowance(Word),
     /// The cumulative gas overflowed the u64 accumulator
     #[display(fmt = "Cumulative gas computation overflowed the u64 accumulator")]
     GasOverflow,
diff --git a/fuel-vm/src/interpreter.rs b/fuel-vm/src/interpreter.rs
index ff03e6dc0f..60d088c98f 100644
--- a/fuel-vm/src/interpreter.rs
+++ b/fuel-vm/src/interpreter.rs
@@ -38,7 +38,6 @@ use fuel_tx::{
     Receipt,
     Script,
     Transaction,
-    TransactionFee,
     TransactionRepr,
     TxParameters,
     UniqueIdentifier,
@@ -360,8 +359,6 @@ pub trait ExecutableTransaction:
     + IntoChecked
     + EstimatePredicates
     + UniqueIdentifier
-    + field::Maturity
-    + field::Inputs
     + field::Outputs
     + field::Witnesses
     + Into<Transaction>
@@ -417,21 +414,23 @@ pub trait ExecutableTransaction:
     /// `initial_balances` contains the initial state of the free balances
     ///
     /// `balances` will contain the current state of the free balances
+    #[allow(clippy::too_many_arguments)]
     fn update_outputs<I>(
         &mut self,
         revert: bool,
-        remaining_gas: Word,
+        used_gas: Word,
         initial_balances: &InitialBalances,
         balances: &I,
+        gas_costs: &GasCosts,
         fee_params: &FeeParameters,
         base_asset_id: &AssetId,
     ) -> Result<(), CheckError>
     where
         I: for<'a> Index<&'a AssetId, Output = Word>,
     {
-        let gas_refund =
-            TransactionFee::gas_refund_value(fee_params, remaining_gas, self.price())
-                .ok_or(CheckError::ArithmeticOverflow)?;
+        let gas_refund = self
+            .refund_fee(gas_costs, fee_params, used_gas)
+            .ok_or(CheckError::ArithmeticOverflow)?;
 
         self.outputs_mut().iter_mut().try_for_each(|o| match o {
             // If revert, set base asset to initial balance and refund unused gas
@@ -547,12 +546,6 @@ pub struct InitialBalances {
 pub trait CheckedMetadata {
     /// Returns the initial balances from the checked metadata of the transaction.
     fn balances(&self) -> InitialBalances;
-
-    /// Get gas used by predicates. Returns zero if the predicates haven't been checked.
-    fn gas_used_by_predicates(&self) -> Word;
-
-    /// Set gas used by predicates after checking them.
-    fn set_gas_used_by_predicates(&mut self, gas_used: Word);
 }
 
 impl CheckedMetadata for ScriptCheckedMetadata {
@@ -562,14 +555,6 @@ impl CheckedMetadata for ScriptCheckedMetadata {
             retryable: Some(self.retryable_balance),
         }
     }
-
-    fn gas_used_by_predicates(&self) -> Word {
-        self.gas_used_by_predicates
-    }
-
-    fn set_gas_used_by_predicates(&mut self, gas_used: Word) {
-        self.gas_used_by_predicates = gas_used;
-    }
 }
 
 impl CheckedMetadata for CreateCheckedMetadata {
@@ -579,14 +564,6 @@ impl CheckedMetadata for CreateCheckedMetadata {
             retryable: None,
         }
     }
-
-    fn gas_used_by_predicates(&self) -> Word {
-        self.gas_used_by_predicates
-    }
-
-    fn set_gas_used_by_predicates(&mut self, gas_used: Word) {
-        self.gas_used_by_predicates = gas_used;
-    }
 }
 
 pub(crate) struct InputContracts<'vm, I> {
diff --git a/fuel-vm/src/interpreter/debug.rs b/fuel-vm/src/interpreter/debug.rs
index 390c3f32dd..92a2cecfc9 100644
--- a/fuel-vm/src/interpreter/debug.rs
+++ b/fuel-vm/src/interpreter/debug.rs
@@ -74,7 +74,7 @@ fn breakpoint_script() {
     let consensus_params = ConsensusParameters::standard();
 
     let tx = TransactionBuilder::script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .add_random_fee_input()
         .finalize()
         .into_checked(height, &consensus_params)
@@ -146,7 +146,7 @@ fn single_stepping() {
     let consensus_params = ConsensusParameters::standard();
 
     let tx = TransactionBuilder::script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .add_random_fee_input()
         .finalize()
         .into_checked(height, &consensus_params)
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 defddda38d..0ad4119464 100644
--- a/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
+++ b/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
@@ -61,7 +61,6 @@ fn cant_write_to_reserved_registers(raw_random_instruction: u32) -> TestResult {
     let script = op::ret(0x10).to_bytes().to_vec();
     let block_height = Default::default();
     let tx = TransactionBuilder::script(script, vec![])
-        .gas_limit(consensus_params.tx_params.max_gas_per_tx)
         .add_random_fee_input()
         .finalize();
 
diff --git a/fuel-vm/src/interpreter/executors/main.rs b/fuel-vm/src/interpreter/executors/main.rs
index 46fc5b4318..cc3207c7fd 100644
--- a/fuel-vm/src/interpreter/executors/main.rs
+++ b/fuel-vm/src/interpreter/executors/main.rs
@@ -56,6 +56,7 @@ use fuel_tx::{
         ReceiptsRoot,
         Salt,
         Script as ScriptField,
+        ScriptGasLimit,
         StorageSlots,
     },
     input::{
@@ -65,10 +66,10 @@ use fuel_tx::{
             MessageDataPredicate,
         },
     },
-    Chargeable,
     Contract,
     Create,
     FeeParameters,
+    GasCosts,
     Input,
     Receipt,
     ScriptExecutionResult,
@@ -83,6 +84,7 @@ use fuel_types::{
 pub struct PredicatesChecked {
     gas_used: Word,
 }
+
 impl PredicatesChecked {
     pub fn gas_used(&self) -> Word {
         self.gas_used
@@ -170,9 +172,10 @@ where
     pub fn estimate_predicates(
         transaction: &mut Tx,
         params: &CheckPredicateParams,
-    ) -> Result<(), PredicateVerificationFailed> {
-        Self::run_predicate(PredicateRunKind::Estimating(transaction), params)?;
-        Ok(())
+    ) -> Result<PredicatesChecked, PredicateVerificationFailed> {
+        let predicates_checked =
+            Self::run_predicate(PredicateRunKind::Estimating(transaction), params)?;
+        Ok(predicates_checked)
     }
 
     /// Initialize the VM with the provided transaction, check all predicates defined in
@@ -184,15 +187,18 @@ where
     pub async fn estimate_predicates_async<E>(
         transaction: &mut Tx,
         params: &CheckPredicateParams,
-    ) -> Result<(), PredicateVerificationFailed>
+    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
     where
         Tx: Send + 'static,
         E: ParallelExecutor,
     {
-        Self::run_predicate_async::<E>(PredicateRunKind::Estimating(transaction), params)
-            .await?;
+        let predicates_checked = Self::run_predicate_async::<E>(
+            PredicateRunKind::Estimating(transaction),
+            params,
+        )
+        .await?;
 
-        Ok(())
+        Ok(predicates_checked)
     }
 
     async fn run_predicate_async<E>(
@@ -205,7 +211,6 @@ where
     {
         let mut checks = vec![];
         let predicate_action = PredicateAction::from(&kind);
-        let max_gas_per_tx = params.max_gas_per_tx;
         let tx_offset = params.tx_offset;
 
         for index in 0..kind.tx().inputs().len() {
@@ -231,7 +236,7 @@ where
 
         let checks = E::execute_tasks(checks).await;
 
-        Self::finalize_check_predicate(kind, checks, predicate_action, max_gas_per_tx)
+        Self::finalize_check_predicate(kind, checks, params)
     }
 
     fn run_predicate(
@@ -257,12 +262,7 @@ where
             }
         }
 
-        Self::finalize_check_predicate(
-            kind,
-            checks,
-            predicate_action,
-            params.max_gas_per_tx,
-        )
+        Self::finalize_check_predicate(kind, checks, params)
     }
 
     fn check_predicate(
@@ -347,8 +347,7 @@ where
     fn finalize_check_predicate(
         mut kind: PredicateRunKind<Tx>,
         checks: Vec<Result<(Word, usize), PredicateVerificationFailed>>,
-        predicate_action: PredicateAction,
-        max_gas_per_tx: u64,
+        params: &CheckPredicateParams,
     ) -> Result<PredicatesChecked, PredicateVerificationFailed> {
         if let PredicateRunKind::Estimating(tx) = &mut kind {
             checks.iter().for_each(|result| {
@@ -375,7 +374,14 @@ where
                         }
                     }
                 }
-            })
+            });
+        }
+
+        let max_gas = kind.tx().max_gas(&params.gas_costs, &params.fee_params);
+        if max_gas > params.max_gas_per_tx {
+            return Err(
+                PredicateVerificationFailed::TransactionExceedsTotalGasAllowance(max_gas),
+            );
         }
 
         let cumulative_gas_used = checks.into_iter().try_fold(0u64, |acc, result| {
@@ -383,19 +389,6 @@ where
                 .ok_or(PredicateVerificationFailed::OutOfGas)
         })?;
 
-        match predicate_action {
-            PredicateAction::Verifying => {
-                if cumulative_gas_used > kind.tx().limit() {
-                    return Err(PredicateVerificationFailed::CumulativePredicateGasExceededTxGasLimit);
-                }
-            }
-            PredicateAction::Estimating => {
-                if cumulative_gas_used > max_gas_per_tx {
-                    return Err(PredicateVerificationFailed::CumulativePredicateGasExceededTxGasLimit);
-                }
-            }
-        }
-
         Ok(PredicatesChecked {
             gas_used: cumulative_gas_used,
         })
@@ -410,14 +403,10 @@ where
         create: &mut Create,
         storage: &mut S,
         initial_balances: InitialBalances,
+        gas_costs: &GasCosts,
         fee_params: &FeeParameters,
         base_asset_id: &AssetId,
     ) -> Result<(), InterpreterError<S::DataError>> {
-        let remaining_gas = create
-            .limit()
-            .checked_sub(create.gas_used_by_predicates())
-            .ok_or(InterpreterError::Panic(PanicReason::OutOfGas))?;
-
         let metadata = create.metadata().as_ref();
         debug_assert!(
             metadata.is_some(),
@@ -459,10 +448,11 @@ where
             .map_err(RuntimeError::Storage)?;
         Self::finalize_outputs(
             create,
+            gas_costs,
             fee_params,
             base_asset_id,
             false,
-            remaining_gas,
+            0,
             &initial_balances,
             &RuntimeBalances::try_from(initial_balances.clone())?,
         )?;
@@ -486,6 +476,7 @@ where
 
     pub(crate) fn run(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>> {
         // TODO: Remove `Create` from here
+        let gas_costs = self.gas_costs().clone();
         let fee_params = *self.fee_params();
         let base_asset_id = *self.base_asset_id();
         let state = if let Some(create) = self.tx.as_create_mut() {
@@ -493,6 +484,7 @@ where
                 create,
                 &mut self.storage,
                 self.initial_balances.clone(),
+                &gas_costs,
                 &fee_params,
                 &base_asset_id,
             )?;
@@ -511,24 +503,24 @@ where
                 return Err(InterpreterError::Panic(PanicReason::ContractNotFound))
             }
 
+            let gas_limit;
+            let is_empty_script;
             if let Some(script) = self.transaction().as_script() {
                 let offset = (self.tx_offset() + script.script_offset()) as Word;
+                gas_limit = *script.script_gas_limit();
+                is_empty_script = script.script().is_empty();
 
                 self.registers[RegId::PC] = offset;
                 self.registers[RegId::IS] = offset;
+            } else {
+                unreachable!("Only `Create` and `Script` transactions can be executed inside of the VM")
             }
 
             // TODO set tree balance
 
             // `Interpreter` supports only `Create` and `Script` transactions. It is not
             // `Create` -> it is `Script`.
-            let program = if !self
-                .transaction()
-                .as_script()
-                .expect("It should be `Script` transaction")
-                .script()
-                .is_empty()
-            {
+            let program = if !is_empty_script {
                 self.run_program()
             } else {
                 // Return `1` as successful execution.
@@ -537,9 +529,7 @@ where
                 Ok(ProgramState::Return(return_val))
             };
 
-            let gas_used = self
-                .transaction()
-                .limit()
+            let gas_used = gas_limit
                 .checked_sub(self.remaining_gas())
                 .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
 
@@ -582,14 +572,13 @@ where
             }
 
             let revert = matches!(program, ProgramState::Revert(_));
-            let remaining_gas = self.remaining_gas();
-            let fee_params = *self.fee_params();
             Self::finalize_outputs(
                 &mut self.tx,
+                &gas_costs,
                 &fee_params,
                 &base_asset_id,
                 revert,
-                remaining_gas,
+                gas_used,
                 &self.initial_balances,
                 &self.balances,
             )?;
@@ -697,12 +686,14 @@ where
         tx: Checked<Create>,
     ) -> Result<Create, InterpreterError<S::DataError>> {
         let (mut create, metadata) = tx.into();
+        let gas_costs = self.gas_costs().clone();
         let fee_params = *self.fee_params();
         let base_asset_id = *self.base_asset_id();
         Self::deploy_inner(
             &mut create,
             &mut self.storage,
             metadata.balances(),
+            &gas_costs,
             &fee_params,
             &base_asset_id,
         )?;
diff --git a/fuel-vm/src/interpreter/executors/main/tests.rs b/fuel-vm/src/interpreter/executors/main/tests.rs
index 4b113b728a..3000c20822 100644
--- a/fuel-vm/src/interpreter/executors/main/tests.rs
+++ b/fuel-vm/src/interpreter/executors/main/tests.rs
@@ -41,7 +41,7 @@ fn estimate_gas_gives_proper_gas_used() {
     let mut builder = TransactionBuilder::script(script, script_data);
     builder
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(Default::default());
 
     let coin_amount = 10_000_000;
@@ -69,7 +69,7 @@ fn estimate_gas_gives_proper_gas_used() {
         .gas_used()
         .expect("Should retrieve gas used");
 
-    builder.gas_limit(gas_without_predicate);
+    builder.script_gas_limit(gas_without_predicate);
 
     let predicate: Vec<u8> = vec![op::addi(0x20, 0x20, 1), op::ret(RegId::ONE)]
         .into_iter()
diff --git a/fuel-vm/src/interpreter/initialization.rs b/fuel-vm/src/interpreter/initialization.rs
index de0cdf6af8..cfdd03dfde 100644
--- a/fuel-vm/src/interpreter/initialization.rs
+++ b/fuel-vm/src/interpreter/initialization.rs
@@ -11,21 +11,16 @@ use crate::{
     },
     consts::*,
     context::Context,
-    error::{
-        Bug,
-        InterpreterError,
-    },
+    error::InterpreterError,
     prelude::RuntimeError,
     storage::InterpreterStorage,
 };
 
 use fuel_asm::RegId;
+use fuel_tx::field::ScriptGasLimit;
 use fuel_types::Word;
 
-use crate::{
-    error::BugVariant::GlobalGasUnderflow,
-    interpreter::CheckedMetadata,
-};
+use crate::interpreter::CheckedMetadata;
 
 impl<S, Tx, Ecal> Interpreter<S, Tx, Ecal>
 where
@@ -115,13 +110,12 @@ where
 
         self.context = Context::Script { block_height };
 
-        let gas_used_by_predicates = checked.metadata().gas_used_by_predicates();
         let (mut tx, metadata): (Tx, Tx::Metadata) = checked.into();
         tx.prepare_init_script();
         let gas_limit = tx
-            .limit()
-            .checked_sub(gas_used_by_predicates)
-            .ok_or_else(|| Bug::new(GlobalGasUnderflow))?;
+            .as_script()
+            .map(|script| *script.script_gas_limit())
+            .unwrap_or_default();
 
         let initial_balances = metadata.balances();
         let runtime_balances = initial_balances.try_into()?;
diff --git a/fuel-vm/src/interpreter/internal/message_tests.rs b/fuel-vm/src/interpreter/internal/message_tests.rs
index fb96bb547c..c52de15a24 100644
--- a/fuel-vm/src/interpreter/internal/message_tests.rs
+++ b/fuel-vm/src/interpreter/internal/message_tests.rs
@@ -13,12 +13,12 @@ use fuel_tx::Create;
 use test_case::test_case;
 
 #[test_case(0, 0, 0 => None)]
-#[test_case(0, 0, 1 => Some(112))]
-#[test_case(88, 0, 1 => Some(200))]
-#[test_case(0, 1, 2 => Some(184))]
-#[test_case(0, 2, 3 => Some(256))]
-#[test_case(0, 1, 3 => Some(184))]
-#[test_case(44, 2, 3 => Some(300))]
+#[test_case(0, 0, 1 => Some(96))]
+#[test_case(88, 0, 1 => Some(184))]
+#[test_case(0, 1, 2 => Some(168))]
+#[test_case(0, 2, 3 => Some(240))]
+#[test_case(0, 1, 3 => Some(168))]
+#[test_case(44, 2, 3 => Some(284))]
 #[test_case(88, 1, 1 => None)]
 // #[test_case(usize::MAX, 0, 1 => None ; "tx_offset and num_outputs should be constrained
 // but they aren't")]
@@ -34,11 +34,11 @@ fn test_absolute_output_offset(
 }
 
 #[test_case(
-    0 => with |r: Result<_, _>| check_memory(r.unwrap(), &[(112, Output::default().to_bytes())])
+    0 => with |r: Result<_, _>| check_memory(r.unwrap(), &[(96, Output::default().to_bytes())])
     ; "Output at start of memory"
 )]
 #[test_case(
-    200 => with |r: Result<_, _>| check_memory(r.unwrap(), &[(200 + 112, Output::default().to_bytes())])
+    200 => with |r: Result<_, _>| check_memory(r.unwrap(), &[(200 + 96, Output::default().to_bytes())])
     ; "Output at 200 in memory"
 )]
 #[test_case(
diff --git a/fuel-vm/src/interpreter/internal/tests.rs b/fuel-vm/src/interpreter/internal/tests.rs
index cf454df9ae..6b53ea2eb6 100644
--- a/fuel-vm/src/interpreter/internal/tests.rs
+++ b/fuel-vm/src/interpreter/internal/tests.rs
@@ -55,8 +55,8 @@ fn external_balance() {
 
     let tx = tx
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
-        .gas_limit(100)
+        .script_gas_limit(gas_limit)
+        .script_gas_limit(100)
         .maturity(maturity)
         .finalize_checked(height);
 
@@ -119,7 +119,7 @@ fn variable_output_updates_in_memory() {
     };
 
     let tx = TransactionBuilder::script(vec![], vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .add_random_fee_input()
         .add_output(variable_output)
         .finalize()
diff --git a/fuel-vm/src/interpreter/memory/tests.rs b/fuel-vm/src/interpreter/memory/tests.rs
index 32522af8eb..37de29398e 100644
--- a/fuel-vm/src/interpreter/memory/tests.rs
+++ b/fuel-vm/src/interpreter/memory/tests.rs
@@ -26,7 +26,7 @@ fn memcopy() {
         InterpreterParams::from(&consensus_params),
     );
     let tx = TransactionBuilder::script(op::ret(0x10).to_bytes().to_vec(), vec![])
-        .gas_limit(tx_params.max_gas_per_tx)
+        .script_gas_limit(100_000)
         .add_random_fee_input()
         .finalize();
 
@@ -85,7 +85,7 @@ fn memcopy() {
 #[test]
 fn memrange() {
     let tx = TransactionBuilder::script(vec![], vec![])
-        .gas_limit(1000000)
+        .script_gas_limit(1000000)
         .add_random_fee_input()
         .finalize()
         .into_checked(Default::default(), &ConsensusParameters::standard())
@@ -115,7 +115,7 @@ fn stack_alloc_ownership() {
     let mut vm = Interpreter::<_, _>::with_memory_storage();
 
     let tx = TransactionBuilder::script(vec![], vec![])
-        .gas_limit(1000000)
+        .script_gas_limit(1000000)
         .add_random_fee_input()
         .finalize()
         .into_checked(Default::default(), &ConsensusParameters::standard())
diff --git a/fuel-vm/src/interpreter/metadata.rs b/fuel-vm/src/interpreter/metadata.rs
index a6e0144b23..e167bead72 100644
--- a/fuel-vm/src/interpreter/metadata.rs
+++ b/fuel-vm/src/interpreter/metadata.rs
@@ -25,8 +25,10 @@ use fuel_tx::{
         Salt,
         Script as ScriptField,
         ScriptData,
+        ScriptGasLimit,
         StorageSlots,
     },
+    policies::PolicyType,
     Input,
     InputRepr,
     Output,
@@ -154,16 +156,34 @@ impl<Tx> GTFInput<'_, Tx> {
             GTFArgs::Type => Tx::transaction_type(),
 
             // General
-            GTFArgs::ScriptGasPrice | GTFArgs::CreateGasPrice => tx.price(),
-            GTFArgs::ScriptGasLimit | GTFArgs::CreateGasLimit => tx.limit(),
-            GTFArgs::ScriptMaturity | GTFArgs::CreateMaturity => **tx.maturity() as Word,
+            GTFArgs::ScriptGasLimit => tx
+                .as_script()
+                .map(|script| *script.script_gas_limit())
+                .unwrap_or_default(),
+            GTFArgs::PolicyTypes => tx.policies().bits() as Word,
+            GTFArgs::PolicyGasPrice => tx
+                .policies()
+                .get(PolicyType::GasPrice)
+                .ok_or(PanicReason::PolicyIsNotSet)?,
+            GTFArgs::PolicyWitnessLimit => tx
+                .policies()
+                .get(PolicyType::WitnessLimit)
+                .ok_or(PanicReason::PolicyIsNotSet)?,
+            GTFArgs::PolicyMaturity => tx
+                .policies()
+                .get(PolicyType::Maturity)
+                .ok_or(PanicReason::PolicyIsNotSet)?,
+            GTFArgs::PolicyMaxFee => tx
+                .policies()
+                .get(PolicyType::MaxFee)
+                .ok_or(PanicReason::PolicyIsNotSet)?,
             GTFArgs::ScriptInputsCount | GTFArgs::CreateInputsCount => {
                 tx.inputs().len() as Word
             }
             GTFArgs::ScriptOutputsCount | GTFArgs::CreateOutputsCount => {
                 tx.outputs().len() as Word
             }
-            GTFArgs::ScriptWitnessesCound | GTFArgs::CreateWitnessesCount => {
+            GTFArgs::ScriptWitnessesCount | GTFArgs::CreateWitnessesCount => {
                 tx.witnesses().len() as Word
             }
             GTFArgs::ScriptInputAtIndex | GTFArgs::CreateInputAtIndex => {
diff --git a/fuel-vm/src/interpreter/metadata/tests.rs b/fuel-vm/src/interpreter/metadata/tests.rs
index 6a99203673..4ddf8d5808 100644
--- a/fuel-vm/src/interpreter/metadata/tests.rs
+++ b/fuel-vm/src/interpreter/metadata/tests.rs
@@ -31,17 +31,19 @@ fn test_metadata() {
 #[test]
 fn test_get_transaction_field() {
     let mut pc = 4;
+    let tx = Script::default();
     let input = GTFInput {
-        tx: &Script::default(),
+        tx: &tx,
         tx_offset: 0,
         pc: RegMut::new(&mut pc),
     };
     let mut result = 1;
-    let imm = 2;
     let b = 0;
-    input.get_transaction_field(&mut result, b, imm).unwrap();
+    input
+        .get_transaction_field(&mut result, b, GTFArgs::ScriptGasLimit as Immediate12)
+        .unwrap();
     assert_eq!(pc, 8);
-    assert_eq!(result, 0);
+    assert_eq!(result, *tx.script_gas_limit());
 }
 
 #[test_case(Context::PredicateEstimation { program: Default::default() }, 2 => (); "can fetch inside predicate estimation")]
diff --git a/fuel-vm/src/interpreter/post_execution.rs b/fuel-vm/src/interpreter/post_execution.rs
index 3b133065bb..00a41d03aa 100644
--- a/fuel-vm/src/interpreter/post_execution.rs
+++ b/fuel-vm/src/interpreter/post_execution.rs
@@ -11,7 +11,10 @@ use crate::interpreter::{
     InitialBalances,
     RuntimeBalances,
 };
-use fuel_tx::FeeParameters;
+use fuel_tx::{
+    FeeParameters,
+    GasCosts,
+};
 use fuel_types::{
     AssetId,
     Word,
@@ -33,12 +36,14 @@ where
     /// The transaction validation is expected to halt in such case. Since the VM only
     /// accepts checked transactions - hence, validated - this case should be
     /// unreachable.
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn finalize_outputs<Tx>(
         tx: &mut Tx,
+        gas_costs: &GasCosts,
         fee_params: &FeeParameters,
         base_asset_id: &AssetId,
         revert: bool,
-        remaining_gas: Word,
+        used_gas: Word,
         initial_balances: &InitialBalances,
         balances: &RuntimeBalances,
     ) -> Result<(), RuntimeError<S::DataError>>
@@ -47,9 +52,10 @@ where
     {
         tx.update_outputs(
             revert,
-            remaining_gas,
+            used_gas,
             initial_balances,
             balances,
+            gas_costs,
             fee_params,
             base_asset_id,
         )
diff --git a/fuel-vm/src/predicate.rs b/fuel-vm/src/predicate.rs
index 31cdc5d432..c959bb863d 100644
--- a/fuel-vm/src/predicate.rs
+++ b/fuel-vm/src/predicate.rs
@@ -46,8 +46,12 @@ mod tests {
         vec,
         vec::Vec,
     };
+    use core::iter;
     use fuel_asm::op;
-    use fuel_tx::TransactionBuilder;
+    use fuel_tx::{
+        field::ScriptGasLimit,
+        TransactionBuilder,
+    };
     use fuel_types::bytes;
     use rand::{
         rngs::StdRng,
@@ -55,8 +59,6 @@ mod tests {
         SeedableRng,
     };
 
-    use core::iter;
-
     use crate::{
         checked_transaction::CheckPredicateParams,
         error::PredicateVerificationFailed,
@@ -88,7 +90,7 @@ mod tests {
             rng.gen(),
             rng.gen(),
             rng.gen(),
-            rng.gen(),
+            0,
             predicate.clone(),
             predicate_data.clone(),
         );
@@ -98,7 +100,7 @@ mod tests {
             rng.gen(),
             rng.gen(),
             rng.gen(),
-            rng.gen(),
+            0,
             predicate.clone(),
             predicate_data.clone(),
         );
@@ -108,7 +110,7 @@ mod tests {
             rng.gen(),
             rng.gen(),
             rng.gen(),
-            rng.gen(),
+            0,
             vec![0xff; 10],
             predicate.clone(),
             predicate_data,
@@ -147,7 +149,7 @@ mod tests {
                         program: Default::default()
                     },
                     tx.transaction().clone(),
-                    tx.transaction().limit()
+                    *tx.transaction().script_gas_limit()
                 )
                 .is_ok());
 
@@ -269,7 +271,6 @@ mod tests {
                 )
                 .add_input(input)
                 .gas_price(0)
-                .gas_limit(TxParameters::DEFAULT.max_gas_per_tx)
                 .add_random_fee_input()
                 .finalize_checked_basic(height);
 
diff --git a/fuel-vm/src/tests/alu.rs b/fuel-vm/src/tests/alu.rs
index e038490f22..2e1a9edf03 100644
--- a/fuel-vm/src/tests/alu.rs
+++ b/fuel-vm/src/tests/alu.rs
@@ -28,7 +28,7 @@ fn alu(
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -56,7 +56,7 @@ fn alu_overflow(program: &[Instruction], reg: RegisterId, expected: u128, boolea
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -85,7 +85,7 @@ fn alu_overflow(program: &[Instruction], reg: RegisterId, expected: u128, boolea
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -146,7 +146,7 @@ fn alu_wrapping(
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -181,7 +181,7 @@ fn alu_err(
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -211,7 +211,7 @@ fn alu_err(
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -239,7 +239,7 @@ fn alu_reserved(registers_init: &[(RegisterId, Word)], ins: Instruction) {
 
     let result = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
diff --git a/fuel-vm/src/tests/backtrace.rs b/fuel-vm/src/tests/backtrace.rs
index 6108b80117..53d95619c8 100644
--- a/fuel-vm/src/tests/backtrace.rs
+++ b/fuel-vm/src/tests/backtrace.rs
@@ -64,7 +64,7 @@ fn backtrace() {
 
     let tx = test_context
         .start_script(script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_undefined)
         .contract_input(contract_call)
         .fee_input()
diff --git a/fuel-vm/src/tests/blockchain.rs b/fuel-vm/src/tests/blockchain.rs
index 9225b99598..bc51241633 100644
--- a/fuel-vm/src/tests/blockchain.rs
+++ b/fuel-vm/src/tests/blockchain.rs
@@ -1,17 +1,39 @@
 #![allow(non_snake_case)]
 
+use crate::{
+    consts::*,
+    interpreter::{
+        InterpreterParams,
+        NotSupportedEcal,
+    },
+    prelude::*,
+    script_with_data_offset,
+    util::test_helpers::check_expected_reason_for_instructions,
+};
 use alloc::{
     vec,
     vec::Vec,
 };
-
-use fuel_asm::RegId;
+use fuel_asm::{
+    op,
+    Instruction,
+    PanicReason::{
+        ContractNotInInputs,
+        ExpectedUnallocatedStack,
+        MemoryOverflow,
+    },
+    RegId,
+};
 use fuel_crypto::{
     Hasher,
     SecretKey,
 };
 use fuel_tx::{
-    field::Outputs,
+    field::{
+        Outputs,
+        Script as ScriptField,
+    },
+    ConsensusParameters,
     Finalizable,
     Input,
     Output,
@@ -32,32 +54,6 @@ use rand::{
     SeedableRng,
 };
 
-use crate::{
-    consts::*,
-    prelude::*,
-};
-
-use crate::interpreter::{
-    InterpreterParams,
-    NotSupportedEcal,
-};
-
-use crate::script_with_data_offset;
-use fuel_asm::{
-    op,
-    Instruction,
-    PanicReason::{
-        ContractNotInInputs,
-        ExpectedUnallocatedStack,
-        MemoryOverflow,
-    },
-};
-use fuel_tx::{
-    field::Script as ScriptField,
-    ConsensusParameters,
-};
-use fuel_vm::util::test_helpers::check_expected_reason_for_instructions;
-
 const SET_STATUS_REG: u8 = 0x39;
 // log2(VM_MAX_MEM) - used to set a pointer to the memory boundary via SHL:
 // 1<<log2(VM_MAX_MEM)
@@ -189,7 +185,7 @@ fn state_read_write() {
 
     let result = test_context
         .start_script(script.clone(), script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -229,7 +225,7 @@ fn state_read_write() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -482,7 +478,6 @@ fn ldc__load_len_of_target_contract<'a>(
     let tx_create_target =
         TransactionBuilder::create(target_contract_witness.clone(), salt, vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
             .maturity(maturity)
             .add_random_fee_input()
             .add_output(output0)
@@ -544,7 +539,7 @@ fn ldc__load_len_of_target_contract<'a>(
         vec![],
     )
     .gas_price(gas_price)
-    .gas_limit(gas_limit)
+    .script_gas_limit(gas_limit)
     .maturity(maturity)
     .add_input(input0.clone())
     .add_random_fee_input()
@@ -562,7 +557,7 @@ fn ldc__load_len_of_target_contract<'a>(
     let tx_deploy_loader =
         TransactionBuilder::script(load_contract.into_iter().collect(), vec![])
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .maturity(maturity)
             .add_input(input0)
             .add_random_fee_input()
@@ -626,7 +621,6 @@ fn ldc_reason_helper(cmd: Vec<Instruction>, expected_reason: PanicReason) {
 
     let tx_create_target = TransactionBuilder::create(program, salt, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .add_output(output0)
@@ -643,7 +637,7 @@ fn ldc_reason_helper(cmd: Vec<Instruction>, expected_reason: PanicReason) {
         contract_id.to_vec(),
     )
     .gas_price(gas_price)
-    .gas_limit(gas_limit)
+    .script_gas_limit(gas_limit)
     .maturity(maturity)
     .add_random_fee_input()
     .finalize()
@@ -775,7 +769,7 @@ fn load_contract_code_out_of_contract_offset_over_length() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -834,7 +828,7 @@ fn code_copy_shorter_zero_padding() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -889,7 +883,7 @@ fn code_copy_out_of_contract_offset_over_length() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -1214,7 +1208,7 @@ fn check_receipts_for_program_call(
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -1515,7 +1509,7 @@ fn smo_instruction_works() {
 
         let mut tx = TransactionBuilder::script(script, script_data);
         tx.gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .maturity(maturity);
         // add inputs
         for (amount, data) in inputs {
@@ -1572,8 +1566,10 @@ fn smo_instruction_works() {
             panic!("expected script result")
         };
         // get refunded fee amount
-        let refund_amount =
-            TransactionFee::gas_refund_value(&fee_params, *gas_used, gas_price).unwrap();
+        let refund_amount = state
+            .tx()
+            .refund_fee(client.gas_costs(), &fee_params, *gas_used)
+            .unwrap();
 
         // check that refundable balances aren't converted into change on failed txs
         if !success {
@@ -1662,7 +1658,7 @@ fn timestamp_works() {
 
         let tx = TransactionBuilder::script(script, script_data)
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .maturity(maturity)
             .add_random_fee_input()
             .finalize_checked(block_height);
@@ -1718,7 +1714,7 @@ fn block_height_works(#[values(0, 1, 2, 10, 100)] current_height: u32) {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(current_height);
@@ -1769,7 +1765,7 @@ fn block_hash_works(
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(current_height);
@@ -1809,7 +1805,7 @@ fn coinbase_works() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(10.into());
diff --git a/fuel-vm/src/tests/cgas.rs b/fuel-vm/src/tests/cgas.rs
index 71cdc7837e..04acf35b91 100644
--- a/fuel-vm/src/tests/cgas.rs
+++ b/fuel-vm/src/tests/cgas.rs
@@ -91,7 +91,7 @@ fn cgas_overflow_bug() {
     // initiate the call between contracts
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .contract_input(sender_contract_id)
         .contract_input(dest_contract_id)
@@ -201,7 +201,7 @@ fn cgas_uses_min_available_gas() {
     // initiate the call between contracts
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .contract_input(sender_contract_id)
         .contract_input(dest_contract_id)
diff --git a/fuel-vm/src/tests/code_coverage.rs b/fuel-vm/src/tests/code_coverage.rs
index 776b2ccd59..634d43eb8e 100644
--- a/fuel-vm/src/tests/code_coverage.rs
+++ b/fuel-vm/src/tests/code_coverage.rs
@@ -50,13 +50,13 @@ fn code_coverage() {
         .add_unsigned_coin_input(
             SecretKey::random(rng),
             rng.gen(),
-            1,
+            2,
             Default::default(),
             rng.gen(),
             Default::default(),
         )
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .finalize_checked(height);
 
diff --git a/fuel-vm/src/tests/contract.rs b/fuel-vm/src/tests/contract.rs
index 9b3b382d6a..e903f24a46 100644
--- a/fuel-vm/src/tests/contract.rs
+++ b/fuel-vm/src/tests/contract.rs
@@ -12,6 +12,7 @@ use fuel_asm::{
     RegId,
 };
 use fuel_tx::{
+    policies::Policies,
     ConsensusParameters,
     Witness,
 };
@@ -48,10 +49,8 @@ fn prevent_contract_id_redeployment() {
     let output = Output::contract_created(contract_undefined, state_root);
 
     let mut create = Transaction::create(
-        gas_price,
-        Default::default(),
-        Default::default(),
         Default::default(),
+        Policies::new().with_gas_price(gas_price),
         salt,
         vec![],
         vec![],
@@ -154,7 +153,7 @@ fn mint_burn() {
             script_check_balance.clone(),
             script_data_check_balance.clone(),
         )
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -165,7 +164,7 @@ fn mint_burn() {
 
     test_context
         .start_script(script_call.clone(), script_call_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -176,7 +175,7 @@ fn mint_burn() {
             script_check_balance.clone(),
             script_data_check_balance.clone(),
         )
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -190,7 +189,7 @@ fn mint_burn() {
 
     let result = test_context
         .start_script(script_call.clone(), script_call_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -202,7 +201,7 @@ fn mint_burn() {
             script_check_balance.clone(),
             script_data_check_balance.clone(),
         )
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -217,7 +216,7 @@ fn mint_burn() {
     let script_call_data = Call::new(contract_id, 1, burn).to_bytes();
     test_context
         .start_script(script_call.clone(), script_call_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -229,7 +228,7 @@ fn mint_burn() {
             script_check_balance.clone(),
             script_data_check_balance.clone(),
         )
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -242,7 +241,7 @@ fn mint_burn() {
     let script_call_data = Call::new(contract_id, 1, balance).to_bytes();
     test_context
         .start_script(script_call, script_call_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -250,7 +249,7 @@ fn mint_burn() {
 
     let result = test_context
         .start_script(script_check_balance, script_data_check_balance)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -306,7 +305,7 @@ fn call_increases_contract_asset_balance_and_balance_register() {
     // call contract with some amount of coins to forward
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .coin_input(asset_id, call_amount)
         .contract_input(contract_id)
@@ -395,7 +394,7 @@ fn call_decreases_internal_balance_and_increases_destination_contract_balance()
     // initiate the call between contracts
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .contract_input(sender_contract_id)
         .contract_input(dest_contract_id)
@@ -484,7 +483,7 @@ fn internal_transfer_reduces_source_contract_balance_and_increases_destination_c
     // initiate the transfer between contracts
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .contract_input(sender_contract_id)
         .contract_input(dest_contract_id)
@@ -566,7 +565,7 @@ fn internal_transfer_cant_exceed_more_than_source_contract_balance() {
 
     let transfer_tx = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .gas_price(0)
         .contract_input(sender_contract_id)
         .contract_input(dest_contract_id)
diff --git a/fuel-vm/src/tests/crypto.rs b/fuel-vm/src/tests/crypto.rs
index d5237fbbf6..6182c77d06 100644
--- a/fuel-vm/src/tests/crypto.rs
+++ b/fuel-vm/src/tests/crypto.rs
@@ -85,7 +85,7 @@ fn secp256k1_recover() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(height);
@@ -140,7 +140,7 @@ fn ecrecover_tx_id() {
 
     let mut tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize();
@@ -214,7 +214,7 @@ async fn recover_tx_id_predicate() {
 
     let mut tx = TransactionBuilder::script(vec![], script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_input(input)
         .add_unsigned_coin_input(
@@ -378,7 +378,7 @@ fn secp256r1_recover() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(height);
@@ -516,7 +516,7 @@ fn ed25519_verify() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(height);
@@ -650,7 +650,7 @@ fn sha256() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(height);
@@ -743,7 +743,7 @@ fn keccak256() {
 
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize_checked(height);
diff --git a/fuel-vm/src/tests/encoding.rs b/fuel-vm/src/tests/encoding.rs
index f2ea46087f..bcea5385fb 100644
--- a/fuel-vm/src/tests/encoding.rs
+++ b/fuel-vm/src/tests/encoding.rs
@@ -14,6 +14,7 @@ use rand::{
 };
 
 use core::fmt;
+use fuel_tx::policies::Policies;
 use fuel_types::{
     canonical::{
         Deserialize,
@@ -212,71 +213,112 @@ fn transaction() {
 
     assert_encoding_correct(&[
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![0xfa],
             vec![0xfb, 0xfc],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![],
             vec![0xfb, 0xfc],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![0xfa],
             vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![],
             vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![i.clone()],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![],
             vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![],
             vec![o],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![],
             vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             vec![],
             vec![],
             vec![w.clone()],
         ),
         Transaction::script(
-            Word::MAX >> 1,
             Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             vec![],
             vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
+            vec![],
+            vec![],
+            vec![],
+        ),
+        Transaction::script(
+            Word::MAX >> 2,
+            vec![],
+            vec![],
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_max_fee(Word::MAX >> 5),
+            vec![],
+            vec![],
+            vec![],
+        ),
+        Transaction::script(
+            Word::MAX >> 2,
+            vec![],
+            vec![],
+            Policies::new(),
             vec![],
             vec![],
             vec![],
@@ -284,10 +326,12 @@ fn transaction() {
     ]);
     assert_encoding_correct(&[
         Transaction::create(
-            Word::MAX >> 1,
-            Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             0xba,
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             [0xdd; 32].into(),
             vec![],
             vec![i],
@@ -295,10 +339,12 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            Word::MAX >> 1,
-            Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             0xba,
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             [0xdd; 32].into(),
             vec![],
             vec![],
@@ -306,10 +352,12 @@ fn transaction() {
             vec![w.clone()],
         ),
         Transaction::create(
-            Word::MAX >> 1,
-            Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             0xba,
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
             [0xdd; 32].into(),
             vec![],
             vec![],
@@ -317,10 +365,32 @@ fn transaction() {
             vec![w],
         ),
         Transaction::create(
-            Word::MAX >> 1,
-            Word::MAX >> 2,
-            (u32::MAX >> 3).into(),
             0xba,
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_maturity((u32::MAX >> 3).into())
+                .with_witness_limit(Word::MAX >> 4)
+                .with_max_fee(Word::MAX >> 5),
+            [0xdd; 32].into(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ),
+        Transaction::create(
+            0xba,
+            Policies::new()
+                .with_gas_price(Word::MAX >> 1)
+                .with_max_fee(Word::MAX >> 5),
+            [0xdd; 32].into(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ),
+        Transaction::create(
+            0xba,
+            Policies::new(),
             [0xdd; 32].into(),
             vec![],
             vec![],
diff --git a/fuel-vm/src/tests/external.rs b/fuel-vm/src/tests/external.rs
index b60f24b5ac..a6fadc8bc8 100644
--- a/fuel-vm/src/tests/external.rs
+++ b/fuel-vm/src/tests/external.rs
@@ -51,7 +51,7 @@ fn noop_ecal() {
     let consensus_params = ConsensusParameters::standard();
     let tx = TransactionBuilder::script(script, vec![])
         .gas_price(0)
-        .gas_limit(1_000_000)
+        .script_gas_limit(1_000_000)
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
@@ -127,7 +127,7 @@ fn provide_ecal_fn() {
     let consensus_params = ConsensusParameters::standard();
     let tx = TransactionBuilder::script(script, script_data)
         .gas_price(0)
-        .gas_limit(1_000_000)
+        .script_gas_limit(1_000_000)
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
diff --git a/fuel-vm/src/tests/flow.rs b/fuel-vm/src/tests/flow.rs
index e6e35fd5b7..03c4329def 100644
--- a/fuel-vm/src/tests/flow.rs
+++ b/fuel-vm/src/tests/flow.rs
@@ -29,7 +29,7 @@ fn can_execute_empty_script_transaction() {
 
     let result = test_context
         .start_script(empty_script, vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -88,7 +88,7 @@ fn code_copy() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -133,7 +133,7 @@ fn call() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -190,7 +190,7 @@ fn call_frame_code_offset() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -252,7 +252,7 @@ fn revert_from_call_immediately_ends_execution() {
     // initiate the call to the contract which reverts
     let result = test_context
         .start_script(script_ops, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -297,7 +297,7 @@ fn repeated_nested_calls() {
     // initiate the call to the contract which reverts
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -386,7 +386,7 @@ fn revert() {
     // initiate the call to the contract which reverts
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -424,7 +424,7 @@ fn revert() {
 
     let result = test_context
         .start_script(script, script_data)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .contract_input(contract_id)
         .fee_input()
         .contract_output(&contract_id)
@@ -469,7 +469,7 @@ fn retd_from_top_of_heap() {
     let result = test_context
         .start_script(script, vec![])
         .gas_price(0)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
@@ -500,7 +500,7 @@ fn logd_from_top_of_heap() {
     let result = test_context
         .start_script(script, vec![])
         .gas_price(0)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .execute();
 
diff --git a/fuel-vm/src/tests/gas_factor.rs b/fuel-vm/src/tests/gas_factor.rs
index a80f6b5e9e..c5d3197453 100644
--- a/fuel-vm/src/tests/gas_factor.rs
+++ b/fuel-vm/src/tests/gas_factor.rs
@@ -1,15 +1,16 @@
 #![cfg(feature = "std")]
 
-use fuel_asm::op;
-use fuel_vm::prelude::*;
-
+use crate::{
+    interpreter::InterpreterParams,
+    prelude::*,
+};
 use core::iter;
+use fuel_asm::op;
 use fuel_tx::{
     field::Outputs,
     ConsensusParameters,
     FeeParameters,
 };
-use fuel_vm::interpreter::InterpreterParams;
 
 #[test]
 fn gas_factor_rounds_correctly() {
@@ -33,7 +34,7 @@ fn gas_factor_rounds_correctly() {
         .with_fee_params(fee_params)
         .start_script(script, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(AssetId::default(), input)
         .change_output(AssetId::default())
         .build();
@@ -56,6 +57,7 @@ fn gas_factor_rounds_correctly() {
     let storage = MemoryStorage::default();
 
     let mut interpreter = Interpreter::<_, _>::with_storage(storage, interpreter_params);
+    let gas_costs = interpreter.gas_costs().clone();
     let res = interpreter
         .with_profiler(profiler.clone())
         .transact(transaction)
@@ -74,8 +76,9 @@ fn gas_factor_rounds_correctly() {
 
     let gas_used = profiler.total_gas();
 
-    let gas_remainder = gas_limit - gas_used;
-    let refund = TransactionFee::gas_refund_value(&fee_params, gas_remainder, gas_price)
+    let refund = res
+        .tx()
+        .refund_fee(&gas_costs, &fee_params, gas_used)
         .expect("failed to calculate refund");
 
     assert_eq!(*change, initial_balance + refund);
diff --git a/fuel-vm/src/tests/memory.rs b/fuel-vm/src/tests/memory.rs
index 4d5d53dd09..ca8a04420f 100644
--- a/fuel-vm/src/tests/memory.rs
+++ b/fuel-vm/src/tests/memory.rs
@@ -35,7 +35,7 @@ fn setup(program: Vec<Instruction>) -> Transactor<MemoryStorage, Script> {
 
     let tx = TransactionBuilder::script(script, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .finalize()
diff --git a/fuel-vm/src/tests/metadata.rs b/fuel-vm/src/tests/metadata.rs
index ecf7f3393f..d48dc5bf63 100644
--- a/fuel-vm/src/tests/metadata.rs
+++ b/fuel-vm/src/tests/metadata.rs
@@ -26,6 +26,7 @@ use fuel_tx::{
         Script as ScriptField,
         Witnesses,
     },
+    policies::PoliciesBits,
     ConsensusParameters,
     Finalizable,
     Receipt,
@@ -85,7 +86,6 @@ fn metadata() {
 
     let tx = TransactionBuilder::create(program, salt, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .add_output(output)
@@ -137,7 +137,6 @@ fn metadata() {
 
     let tx = TransactionBuilder::create(program, salt, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
         .maturity(maturity)
         .add_random_fee_input()
         .add_output(output)
@@ -196,7 +195,7 @@ fn metadata() {
 
     let tx = TransactionBuilder::script(script, vec![])
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity)
         .add_input(inputs[0].clone())
         .add_input(inputs[1].clone())
@@ -255,7 +254,7 @@ fn get_metadata_chain_id() {
     let consensus_params = ConsensusParameters::standard_with_id(chain_id);
 
     let script = TransactionBuilder::script(get_chain_id.into_iter().collect(), vec![])
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .with_chain_id(chain_id)
         .add_random_fee_input()
         .finalize()
@@ -279,7 +278,9 @@ fn get_transaction_fields() {
     let mut client = MemoryClient::default();
 
     let gas_price = 1;
-    let gas_limit = 100_000_000;
+    let witness_limit = 1234;
+    let max_fee_limit = 4321;
+    let gas_limit = 10_000_000;
     let maturity = 50.into();
     let height = 122.into();
     let input = 10_000_000;
@@ -352,7 +353,7 @@ fn get_transaction_fields() {
         .maturity(maturity)
         .with_gas_costs(gas_costs)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .add_unsigned_coin_input(
             SecretKey::random(rng),
             rng.gen(),
@@ -473,7 +474,7 @@ fn get_transaction_fields() {
 
         op::movi(0x11, gas_price as Immediate18),
         op::movi(0x19, 0x00),
-        op::gtf_args(0x10, 0x19, GTFArgs::ScriptGasPrice),
+        op::gtf_args(0x10, 0x19, GTFArgs::PolicyGasPrice),
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
@@ -488,7 +489,25 @@ fn get_transaction_fields() {
 
         op::movi(0x19, 0x00),
         op::movi(0x11, *maturity as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::ScriptMaturity),
+        op::gtf_args(0x10, 0x19, GTFArgs::PolicyMaturity),
+        op::eq(0x10, 0x10, 0x11),
+        op::and(0x20, 0x20, 0x10),
+
+        op::movi(0x19, 0x00),
+        op::movi(0x11, max_fee_limit as Immediate18),
+        op::gtf_args(0x10, 0x19, GTFArgs::PolicyMaxFee),
+        op::eq(0x10, 0x10, 0x11),
+        op::and(0x20, 0x20, 0x10),
+
+        op::movi(0x19, 0x00),
+        op::movi(0x11, witness_limit as Immediate18),
+        op::gtf_args(0x10, 0x19, GTFArgs::PolicyWitnessLimit),
+        op::eq(0x10, 0x10, 0x11),
+        op::and(0x20, 0x20, 0x10),
+
+        op::movi(0x19, 0x00),
+        op::movi(0x11, PoliciesBits::all().bits() as Immediate18),
+        op::gtf_args(0x10, 0x19, GTFArgs::PolicyTypes),
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
@@ -506,7 +525,7 @@ fn get_transaction_fields() {
 
         op::movi(0x19, 0x00),
         op::movi(0x11, witnesses.len() as Immediate18),
-        op::gtf_args(0x10, 0x19, GTFArgs::ScriptWitnessesCound),
+        op::gtf_args(0x10, 0x19, GTFArgs::ScriptWitnessesCount),
         op::eq(0x10, 0x10, 0x11),
         op::and(0x20, 0x20, 0x10),
 
@@ -870,7 +889,9 @@ fn get_transaction_fields() {
     let tx = builder
         .maturity(maturity)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
+        .witness_limit(witness_limit)
+        .max_fee_limit(max_fee_limit)
         .finalize_checked_basic(height);
 
     let receipts = client.transact(tx);
diff --git a/fuel-vm/src/tests/outputs.rs b/fuel-vm/src/tests/outputs.rs
index 74a97f609a..f7e075925b 100644
--- a/fuel-vm/src/tests/outputs.rs
+++ b/fuel-vm/src/tests/outputs.rs
@@ -20,6 +20,7 @@ use fuel_asm::{
     RegId,
 };
 use fuel_tx::{
+    policies::Policies,
     ConsensusParameters,
     Witness,
 };
@@ -136,10 +137,8 @@ fn correct_change_is_provided_for_coin_outputs_create() {
     let context = context.base_asset_id(base_asset_id);
     let bytecode_witness = 0;
     let mut create = Transaction::create(
-        gas_price,
-        Default::default(),
-        Default::default(),
         bytecode_witness,
+        Policies::new().with_gas_price(gas_price),
         salt,
         vec![],
         vec![],
@@ -225,7 +224,7 @@ fn change_is_reduced_by_external_transfer() {
     let change = test_context
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, input_amount)
         .contract_input(contract_id)
         .change_output(asset_id)
@@ -282,7 +281,7 @@ fn change_is_not_reduced_by_external_transfer_on_revert() {
     let change = test_context
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, input_amount)
         .contract_input(contract_id)
         .change_output(asset_id)
@@ -333,7 +332,7 @@ fn zero_amount_transfer_reverts() {
     let result = test_context
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, 0)
         .contract_input(contract_id)
         .change_output(asset_id)
@@ -388,7 +387,7 @@ fn zero_amount_transfer_out_reverts() {
     let result = TestBuilder::new(2322u64)
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, external_balance)
         .variable_output(asset_id)
         .change_output(asset_id)
@@ -449,7 +448,7 @@ fn variable_output_set_by_external_transfer_out() {
     let result = TestBuilder::new(2322u64)
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, external_balance)
         .variable_output(asset_id)
         .change_output(asset_id)
@@ -524,7 +523,7 @@ fn variable_output_not_set_by_external_transfer_out_on_revert() {
     let result = TestBuilder::new(2322u64)
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .coin_input(asset_id, external_balance)
         .variable_output(asset_id)
         .change_output(asset_id)
@@ -614,7 +613,7 @@ fn variable_output_set_by_internal_contract_transfer_out() {
     let result = test_context
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .contract_input(contract_id)
         .variable_output(asset_id)
@@ -694,7 +693,7 @@ fn variable_output_not_increased_by_contract_transfer_out_on_revert() {
     let result = test_context
         .start_script(script, script_data)
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .fee_input()
         .contract_input(contract_id)
         .variable_output(asset_id)
diff --git a/fuel-vm/src/tests/predicate.rs b/fuel-vm/src/tests/predicate.rs
index c9e48b92e4..30ef638076 100644
--- a/fuel-vm/src/tests/predicate.rs
+++ b/fuel-vm/src/tests/predicate.rs
@@ -27,7 +27,6 @@ use crate::checked_transaction::{
     ParallelExecutor,
 };
 use core::iter;
-use fuel_asm::PanicReason::OutOfGas;
 use fuel_tx::ConsensusParameters;
 
 pub struct TokioWithRayon;
@@ -97,7 +96,7 @@ where
 
     builder
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(maturity);
 
     (0..dummy_inputs).for_each(|_| {
@@ -113,17 +112,16 @@ where
 
     builder.add_input(input);
 
-    let transaction = builder.finalize();
-    let gas_costs = GasCosts::free();
+    let mut transaction = builder.finalize();
+    transaction
+        .estimate_predicates(&ConsensusParameters::standard().into())
+        .expect("Should estiamte predicate");
 
     let checked = transaction
         .into_checked_basic(height, &ConsensusParameters::standard())
         .expect("Should successfully convert into Checked");
 
-    let params = CheckPredicateParams {
-        gas_costs,
-        ..Default::default()
-    };
+    let params = CheckPredicateParams::default();
 
     let parallel_execution = {
         Interpreter::<PredicateStorage, _>::check_predicates_async::<TokioWithRayon>(
@@ -142,7 +140,10 @@ where
             assert_eq!(p_gas_used, s_gas_used);
             true
         }
-        (Err(_), Err(_)) => false,
+        (Err(p_err), Err(s_err)) => {
+            assert_eq!(p_err, s_err);
+            false
+        }
         _ => panic!("Parallel and sequential execution should return the same result"),
     }
 }
@@ -206,15 +207,11 @@ async fn execute_gas_metered_predicates(
     let rng = &mut StdRng::seed_from_u64(2322u64);
 
     let gas_price = 1_000;
-    let gas_limit = 1_000_000;
     let script = vec![];
     let script_data = vec![];
 
     let mut builder = TransactionBuilder::script(script, script_data);
-    builder
-        .gas_price(gas_price)
-        .gas_limit(gas_limit)
-        .maturity(Default::default());
+    builder.gas_price(gas_price).maturity(Default::default());
 
     let coin_amount = 10_000_000;
 
@@ -339,153 +336,7 @@ async fn predicate_gas_metering() {
 }
 
 #[tokio::test]
-async fn gas_used_by_predicates_is_deducted_from_script_gas() {
-    let rng = &mut StdRng::seed_from_u64(2322u64);
-
-    let gas_price = 1_000;
-    let gas_limit = 1_000_000;
-    let script = vec![op::ret(RegId::ONE)].into_iter().collect::<Vec<u8>>();
-    let script_data = vec![];
-    let params = CheckPredicateParams::default();
-
-    let mut builder = TransactionBuilder::script(script, script_data);
-    builder
-        .gas_price(gas_price)
-        .gas_limit(gas_limit)
-        .maturity(Default::default());
-
-    let coin_amount = 10_000_000;
-
-    builder.add_unsigned_coin_input(
-        SecretKey::random(rng),
-        rng.gen(),
-        coin_amount,
-        AssetId::default(),
-        rng.gen(),
-        Default::default(),
-    );
-
-    // parallel version
-    let p_tx_without_predicate = {
-        builder
-            .clone()
-            .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())
-        .check_predicates(&params)
-        .expect("Predicate check failed even if we don't have any predicates");
-
-    let predicate: Vec<u8> = vec![
-        op::addi(0x20, 0x20, 1),
-        op::addi(0x20, 0x20, 1),
-        op::addi(0x20, 0x20, 1),
-        op::addi(0x20, 0x20, 1),
-        op::addi(0x20, 0x20, 1),
-        op::ret(RegId::ONE),
-    ]
-    .into_iter()
-    .flat_map(|op| u32::from(op).to_be_bytes())
-    .collect();
-    let owner = Input::predicate_owner(&predicate);
-    let input = Input::coin_predicate(
-        rng.gen(),
-        owner,
-        coin_amount,
-        AssetId::default(),
-        rng.gen(),
-        Default::default(),
-        rng.gen(),
-        predicate,
-        vec![],
-    );
-
-    // add non-predicate input before and after predicate input
-    // to check that predicate verification only handles predicate inputs
-    builder.add_unsigned_coin_input(
-        SecretKey::random(rng),
-        rng.gen(),
-        rng.gen(),
-        AssetId::default(),
-        rng.gen(),
-        Default::default(),
-    );
-
-    builder.add_input(input);
-
-    builder.add_unsigned_coin_input(
-        SecretKey::random(rng),
-        rng.gen(),
-        rng.gen(),
-        AssetId::default(),
-        rng.gen(),
-        Default::default(),
-    );
-
-    let mut transaction = builder.finalize();
-    transaction
-        .estimate_predicates(&params)
-        .expect("Predicate estimation failed");
-
-    let checked = transaction
-        .into_checked_basic(Default::default(), &ConsensusParameters::standard())
-        .expect("Should successfully create checked tranaction with predicate");
-
-    // parallel version
-    let (p_with_predicate, p_without_predicate) = {
-        let tx_with_predicate = checked
-            .clone()
-            .check_predicates_async::<TokioWithRayon>(&params)
-            .await
-            .expect("Predicate check failed");
-
-        let mut client = MemoryClient::default();
-        client.transact(tx_with_predicate);
-        let receipts_with_predicate =
-            client.receipts().expect("Expected receipts").to_vec();
-        client.transact(p_tx_without_predicate);
-        let receipts_without_predicate =
-            client.receipts().expect("Expected receipts").to_vec();
-
-        assert!(
-            receipts_with_predicate[1].gas_used()
-                > receipts_without_predicate[1].gas_used()
-        );
-
-        (
-            receipts_with_predicate[1].gas_used(),
-            receipts_without_predicate[1].gas_used(),
-        )
-    };
-
-    let tx_with_predicate = checked
-        .check_predicates(&params)
-        .expect("Predicate check failed");
-
-    let mut client = MemoryClient::default();
-    client.transact(tx_with_predicate);
-    let receipts_with_predicate = client.receipts().expect("Expected receipts").to_vec();
-    client.transact(tx_without_predicate);
-    let receipts_without_predicate =
-        client.receipts().expect("Expected receipts").to_vec();
-
-    assert!(
-        receipts_with_predicate[1].gas_used() > receipts_without_predicate[1].gas_used()
-    );
-
-    assert_eq!(p_with_predicate, receipts_with_predicate[1].gas_used());
-    assert_eq!(
-        p_without_predicate,
-        receipts_without_predicate[1].gas_used()
-    );
-}
-
-#[tokio::test]
-async fn gas_used_by_predicates_causes_out_of_gas_during_script() {
+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();
 
@@ -503,7 +354,7 @@ async fn gas_used_by_predicates_causes_out_of_gas_during_script() {
     let mut builder = TransactionBuilder::script(script, script_data);
     builder
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(Default::default());
 
     let coin_amount = 10_000_000;
@@ -541,7 +392,7 @@ async fn gas_used_by_predicates_causes_out_of_gas_during_script() {
         .gas_used()
         .expect("Should retrieve gas used");
 
-    builder.gas_limit(gas_without_predicate);
+    builder.script_gas_limit(gas_without_predicate);
 
     let predicate: Vec<u8> = vec![op::addi(0x20, 0x20, 1), op::ret(RegId::ONE)]
         .into_iter()
@@ -585,10 +436,10 @@ async fn gas_used_by_predicates_causes_out_of_gas_during_script() {
 
         // No panic for transaction without gas limit
         assert_eq!(receipts_without_predicate[1].reason(), None);
-        // Panic with out of gas for transaction with predicate
+        // Don't panic with out of gas for transaction with predicate
         assert_eq!(
-            receipts_with_predicate[0].reason().unwrap().reason(),
-            &OutOfGas
+            receipts_with_predicate[1].result().unwrap(),
+            &ScriptExecutionResult::Success
         );
     }
 
@@ -601,10 +452,10 @@ async fn gas_used_by_predicates_causes_out_of_gas_during_script() {
 
     // No panic for transaction without gas limit
     assert_eq!(receipts_without_predicate[1].reason(), None);
-    // Panic with out of gas for transaction with predicate
+    // Don't panic with out of gas for transaction with predicate
     assert_eq!(
-        receipts_with_predicate[0].reason().unwrap().reason(),
-        &OutOfGas
+        receipts_with_predicate[1].result().unwrap(),
+        &ScriptExecutionResult::Success
     );
 }
 
@@ -628,7 +479,7 @@ async fn gas_used_by_predicates_more_than_limit() {
     let mut builder = TransactionBuilder::script(script, script_data);
     builder
         .gas_price(gas_price)
-        .gas_limit(gas_limit)
+        .script_gas_limit(gas_limit)
         .maturity(Default::default());
 
     let coin_amount = 10_000_000;
@@ -666,7 +517,7 @@ async fn gas_used_by_predicates_more_than_limit() {
         .gas_used()
         .expect("Should retrieve gas used");
 
-    builder.gas_limit(gas_without_predicate);
+    builder.script_gas_limit(gas_without_predicate);
 
     let predicate: Vec<u8> = vec![
         op::addi(0x20, 0x20, 1),
diff --git a/fuel-vm/src/tests/profile_gas.rs b/fuel-vm/src/tests/profile_gas.rs
index d713a65f7f..0ba55ecd2d 100644
--- a/fuel-vm/src/tests/profile_gas.rs
+++ b/fuel-vm/src/tests/profile_gas.rs
@@ -39,12 +39,12 @@ fn profile_gas() {
                 .add_unsigned_coin_input(
                     SecretKey::random(rng),
                     rng.gen(),
-                    1,
+                    2,
                     Default::default(),
                     rng.gen(),
                     Default::default(),
                 )
-                .gas_limit(gas_limit)
+                .script_gas_limit(gas_limit)
                 .gas_price(gas_price)
                 .maturity(maturity)
                 .finalize_checked(height);
diff --git a/fuel-vm/src/tests/test_helpers.rs b/fuel-vm/src/tests/test_helpers.rs
index a15db28521..678e849e02 100644
--- a/fuel-vm/src/tests/test_helpers.rs
+++ b/fuel-vm/src/tests/test_helpers.rs
@@ -31,7 +31,7 @@ pub fn run_script(script: Vec<Instruction>) -> Vec<Receipt> {
 
     let tx = TransactionBuilder::script(script, vec![])
         .gas_price(0)
-        .gas_limit(1_000_000)
+        .script_gas_limit(1_000_000)
         .maturity(Default::default())
         .add_random_fee_input()
         .finalize()
diff --git a/fuel-vm/src/tests/validation.rs b/fuel-vm/src/tests/validation.rs
index ceabd81cdd..d8bc693ad5 100644
--- a/fuel-vm/src/tests/validation.rs
+++ b/fuel-vm/src/tests/validation.rs
@@ -26,7 +26,7 @@ fn transaction_can_be_executed_after_maturity() {
         rng.gen(),
         Default::default(),
     )
-    .gas_limit(100)
+    .script_gas_limit(100)
     .maturity(MATURITY)
     .finalize_checked(BLOCK_HEIGHT);
 
diff --git a/fuel-vm/src/util.rs b/fuel-vm/src/util.rs
index cd5bfb33f9..6c83fe9463 100644
--- a/fuel-vm/src/util.rs
+++ b/fuel-vm/src/util.rs
@@ -171,7 +171,7 @@ pub mod test_helpers {
     pub struct TestBuilder {
         rng: StdRng,
         gas_price: Word,
-        gas_limit: Word,
+        script_gas_limit: Word,
         builder: TransactionBuilder<Script>,
         storage: MemoryStorage,
         block_height: BlockHeight,
@@ -184,7 +184,7 @@ pub mod test_helpers {
             TestBuilder {
                 rng: StdRng::seed_from_u64(seed),
                 gas_price: 0,
-                gas_limit: 100,
+                script_gas_limit: 100,
                 builder: TransactionBuilder::script(bytecode, vec![]),
                 storage: MemoryStorage::default(),
                 block_height: Default::default(),
@@ -204,7 +204,7 @@ pub mod test_helpers {
             let bytecode = script.into_iter().collect();
             self.builder = TransactionBuilder::script(bytecode, script_data);
             self.builder.gas_price(self.gas_price);
-            self.builder.gas_limit(self.gas_limit);
+            self.builder.script_gas_limit(self.script_gas_limit);
             self
         }
 
@@ -214,9 +214,9 @@ pub mod test_helpers {
             self
         }
 
-        pub fn gas_limit(&mut self, limit: Word) -> &mut TestBuilder {
-            self.builder.gas_limit(limit);
-            self.gas_limit = limit;
+        pub fn script_gas_limit(&mut self, limit: Word) -> &mut TestBuilder {
+            self.builder.script_gas_limit(limit);
+            self.script_gas_limit = limit;
             self
         }
 
@@ -391,7 +391,7 @@ pub mod test_helpers {
             TestBuilder::new(2322u64)
                 .start_script(script, script_data)
                 .gas_price(0)
-                .gas_limit(1_000_000)
+                .script_gas_limit(1_000_000)
                 .contract_input(*contract_id)
                 .fee_input()
                 .contract_output(contract_id)
@@ -423,7 +423,6 @@ pub mod test_helpers {
 
             let tx = TransactionBuilder::create(program, salt, storage_slots)
                 .gas_price(self.gas_price)
-                .gas_limit(self.gas_limit)
                 .maturity(Default::default())
                 .add_random_fee_input()
                 .add_output(Output::contract_created(contract_id, storage_root))
@@ -592,7 +591,9 @@ pub mod test_helpers {
     ) {
         let gas_price = 0;
         let tx_params = TxParameters::default().with_max_gas_per_tx(Word::MAX / 2);
-        let gas_limit = tx_params.max_gas_per_tx;
+        // 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();
 
@@ -633,7 +634,7 @@ pub mod test_helpers {
 
         let tx_deploy_loader = TransactionBuilder::script(script, script_data)
             .gas_price(gas_price)
-            .gas_limit(gas_limit)
+            .script_gas_limit(gas_limit)
             .maturity(maturity)
             .with_tx_params(tx_params)
             .add_input(Input::contract(