diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6157abcefe..88d9f1b9cd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ env:
   CARGO_TERM_COLOR: always
   DASEL_VERSION: https://github.com/TomWright/dasel/releases/download/v2.3.6/dasel_linux_amd64
   RUSTFLAGS: "-D warnings"
-  FUEL_CORE_VERSION: 0.22.1
+  FUEL_CORE_VERSION: 0.23.0
   FUEL_CORE_PATCH_BRANCH:
   RUST_VERSION: 1.74.0
   FORC_VERSION: 0.51.1
diff --git a/Cargo.toml b/Cargo.toml
index 31302decac..42cda23257 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,25 +68,25 @@ tokio = { version = "1.34.0", default-features = false }
 tracing = "0.1.40"
 trybuild = "1.0.85"
 uint = { version = "0.9.5", default-features = false }
-which = { version = "5.0.0", default-features = false }
+which = { version = "6.0.0", default-features = false }
 zeroize = "1.7.0"
 
 # Dependencies from the `fuel-core` repository:
-fuel-core = { version = "0.22.1", default-features = false }
-fuel-core-chain-config = { version = "0.22.1", default-features = false }
-fuel-core-client = { version = "0.22.1", default-features = false }
-fuel-core-poa = { version = "0.22.1", default-features = false }
-fuel-core-services = { version = "0.22.1", default-features = false }
-fuel-core-types = { version = "0.22.1", default-features = false }
+fuel-core = { version = "0.23.0", default-features = false }
+fuel-core-chain-config = { version = "0.23.0", default-features = false }
+fuel-core-client = { version = "0.23.0", default-features = false }
+fuel-core-poa = { version = "0.23.0", default-features = false }
+fuel-core-services = { version = "0.23.0", default-features = false }
+fuel-core-types = { version = "0.23.0", default-features = false }
 
 # Dependencies from the `fuel-vm` repository:
-fuel-asm = { version = "0.43.2" }
-fuel-crypto = { version = "0.43.2" }
-fuel-merkle = { version = "0.43.2" }
-fuel-storage = { version = "0.43.2" }
-fuel-tx = { version = "0.43.2" }
-fuel-types = { version = "0.43.2" }
-fuel-vm = { version = "0.43.2" }
+fuel-asm = { version = "0.47.1" }
+fuel-crypto = { version = "0.47.1" }
+fuel-merkle = { version = "0.47.1" }
+fuel-storage = { version = "0.47.1" }
+fuel-tx = { version = "0.47.1" }
+fuel-types = { version = "0.47.1" }
+fuel-vm = { version = "0.47.1" }
 
 # Workspace projects
 fuels = { version = "0.55.0", path = "./packages/fuels" }
diff --git a/docs/src/calling-contracts/cost-estimation.md b/docs/src/calling-contracts/cost-estimation.md
index 12b30db1b0..824bbcf8d3 100644
--- a/docs/src/calling-contracts/cost-estimation.md
+++ b/docs/src/calling-contracts/cost-estimation.md
@@ -1,16 +1,9 @@
 # Estimating contract call cost
 
-With the function `estimate_transaction_cost(tolerance: Option<f64>)` provided by `ContractCallHandler` and `ContractMultiCallHandler`, you can get a cost estimation for a specific call. The return type, `TransactionCost`, is a struct that contains relevant information for the estimation:
+With the function `estimate_transaction_cost(tolerance: Option<f64>, block_horizon: Option<u32>)` provided by `ContractCallHandler` and `ContractMultiCallHandler`, you can get a cost estimation for a specific call. The return type, `TransactionCost`, is a struct that contains relevant information for the estimation:
 
 ```rust,ignore
-TransactionCost {
-    min_gas_price: u64,
-    min_byte_price: u64,
-    gas_price: u64,
-    gas_used: u64,
-    metered_bytes_size: u64,
-    total_fee: f64, // where total_fee is the sum of the gas and byte fees
-}
+{{#include ../../../packages/fuels-accounts/src/provider.rs:transaction_cost}}
 ```
 
 Below are examples that show how to get the estimated transaction cost from single and multi call transactions.
@@ -24,3 +17,5 @@ Below are examples that show how to get the estimated transaction cost from sing
 ```
 
 The transaction cost estimation can be used to set the gas limit for an actual call, or to show the user the estimated cost.
+
+> **Note** The same estimation interface is available for scripts.
diff --git a/docs/src/calling-contracts/tx-policies.md b/docs/src/calling-contracts/tx-policies.md
index e83b90c2e2..c02d839642 100644
--- a/docs/src/calling-contracts/tx-policies.md
+++ b/docs/src/calling-contracts/tx-policies.md
@@ -10,13 +10,13 @@ Transaction policies are defined as follows:
 
 Where:
 
-1. **Gas Price** - Maximum gas price for transaction.
+1. **Tip** - amount to pay the block producer to prioritize the transaction.
 2. **Witness Limit** - The maximum amount of witness data allowed for the transaction.
 3. **Maturity** - Block until which the transaction cannot be included.
 4. **Max Fee** - The maximum fee payable by this transaction.
 5. **Script Gas Limit** - The maximum amount of gas the transaction may consume for executing its script code.
 
-When the **Script Gas Limit** is not set, the Rust SDK will estimate the consumed gas in the background and set it as the limit. Similarly, if no **Gas Price** is defined, the Rust SDK defaults to the network's minimum gas price.
+When the **Script Gas Limit** is not set, the Rust SDK will estimate the consumed gas in the background and set it as the limit.
 
 If the **Witness Limit** is not set, the SDK will set it to the size of all witnesses and signatures defined in the transaction builder.
 
diff --git a/examples/contracts/src/lib.rs b/examples/contracts/src/lib.rs
index 5b325d16f2..1e1b7d8e23 100644
--- a/examples/contracts/src/lib.rs
+++ b/examples/contracts/src/lib.rs
@@ -98,11 +98,12 @@ mod tests {
         // ANCHOR: contract_call_cost_estimation
         let contract_instance = MyContract::new(contract_id, wallet);
 
-        let tolerance = 0.0;
+        let tolerance = Some(0.0);
+        let block_horizon = Some(1);
         let transaction_cost = contract_instance
             .methods()
             .initialize_counter(42) // Build the ABI call
-            .estimate_transaction_cost(Some(tolerance)) // Get estimated transaction cost
+            .estimate_transaction_cost(tolerance, block_horizon) // Get estimated transaction cost
             .await?;
         // ANCHOR_END: contract_call_cost_estimation
 
@@ -144,7 +145,7 @@ mod tests {
 
         // Optional: Configure deployment parameters
         let tx_policies = TxPolicies::default()
-            .with_gas_price(0)
+            .with_tip(1)
             .with_script_gas_limit(1_000_000)
             .with_maturity(0);
 
@@ -281,7 +282,7 @@ mod tests {
         let contract_methods = MyContract::new(contract_id.clone(), wallet.clone()).methods();
 
         let tx_policies = TxPolicies::default()
-            .with_gas_price(1)
+            .with_tip(1)
             .with_script_gas_limit(1_000_000)
             .with_maturity(0);
 
@@ -594,9 +595,10 @@ mod tests {
             .add_call(call_handler_1)
             .add_call(call_handler_2);
 
-        let tolerance = 0.0;
+        let tolerance = Some(0.0);
+        let block_horizon = Some(1);
         let transaction_cost = multi_call_handler
-            .estimate_transaction_cost(Some(tolerance)) // Get estimated transaction cost
+            .estimate_transaction_cost(tolerance, block_horizon) // Get estimated transaction cost
             .await?;
         // ANCHOR_END: multi_call_cost_estimation
 
diff --git a/examples/cookbook/src/lib.rs b/examples/cookbook/src/lib.rs
index d514132235..94f39707ef 100644
--- a/examples/cookbook/src/lib.rs
+++ b/examples/cookbook/src/lib.rs
@@ -302,7 +302,7 @@ mod tests {
         // ANCHOR_END: custom_tx_adjust
 
         // ANCHOR: custom_tx_policies
-        let tx_policies = TxPolicies::default().with_gas_price(1);
+        let tx_policies = TxPolicies::default().with_tip(1);
         let tb = tb.with_tx_policies(tx_policies);
         // ANCHOR_END: custom_tx_policies
 
diff --git a/packages/fuels-accounts/Cargo.toml b/packages/fuels-accounts/Cargo.toml
index 5cd4bd05f2..3918be22a9 100644
--- a/packages/fuels-accounts/Cargo.toml
+++ b/packages/fuels-accounts/Cargo.toml
@@ -15,6 +15,7 @@ chrono = { workspace = true }
 elliptic-curve = { workspace = true, default-features = false }
 eth-keystore =  { workspace = true, optional = true }
 fuel-core-client = { workspace = true, optional = true }
+fuel-core-types = { workspace = true }
 fuel-crypto = { workspace = true, features = ["random"] }
 fuel-tx = { workspace = true }
 fuel-types = { workspace = true, features = ["random"] }
diff --git a/packages/fuels-accounts/src/account.rs b/packages/fuels-accounts/src/account.rs
index cc8b19486e..ebeb01d80f 100644
--- a/packages/fuels-accounts/src/account.rs
+++ b/packages/fuels-accounts/src/account.rs
@@ -331,10 +331,12 @@ mod tests {
         async fn dry_run_and_get_used_gas(&self, _: FuelTransaction, _: f32) -> Result<u64> {
             Ok(0)
         }
+
         fn consensus_parameters(&self) -> &ConsensusParameters {
             &self.c_param
         }
-        async fn min_gas_price(&self) -> Result<u64> {
+
+        async fn estimate_gas_price(&self, _block_header: u32) -> Result<u64> {
             Ok(0)
         }
     }
@@ -390,7 +392,7 @@ mod tests {
         assert_eq!(signature, tx_signature);
 
         // Check if the signature is what we expect it to be
-        assert_eq!(signature, Signature::from_str("a7446cb9703d3bc9e68677715fc7ef6ed72ff4eeac0c67bdb0d9b9c8ba38048e078e38fdd85bf988cefd3737005f1be97ed8b9662f002b0480d4404ebb397fed")?);
+        assert_eq!(signature, Signature::from_str("37cf6bdefc9e673f99a7fdbbeff454cb5c1bdf632c072f19cf8ac68fa1ede2749c568c56f87d73fc5c97f73b76dfe637422b77c1fdc6010fb4f488444ff5df1a")?);
 
         // Recover the address that signed the transaction
         let recovered_address = signature.recover(&message)?;
diff --git a/packages/fuels-accounts/src/provider.rs b/packages/fuels-accounts/src/provider.rs
index 9cbec2e231..28bcf9da42 100644
--- a/packages/fuels-accounts/src/provider.rs
+++ b/packages/fuels-accounts/src/provider.rs
@@ -10,17 +10,23 @@ use std::sync::Arc;
 use chrono::{DateTime, Utc};
 use fuel_core_client::client::{
     pagination::{PageDirection, PaginatedResult, PaginationRequest},
-    types::{balance::Balance, contract::ContractBalance},
+    types::{
+        balance::Balance,
+        contract::ContractBalance,
+        gas_price::{EstimateGasPrice, LatestGasPrice},
+    },
 };
+use fuel_core_types::services::executor::{TransactionExecutionResult, TransactionExecutionStatus};
 use fuel_tx::{
-    AssetId, ConsensusParameters, Receipt, ScriptExecutionResult, Transaction as FuelTransaction,
-    TxId, UtxoId,
+    AssetId, ConsensusParameters, Receipt, Transaction as FuelTransaction, TxId, UtxoId,
 };
-use fuel_types::{Address, Bytes32, ChainId, Nonce};
+use fuel_types::{Address, BlockHeight, Bytes32, ChainId, Nonce};
 #[cfg(feature = "coin-cache")]
 use fuels_core::types::coin_type_id::CoinTypeId;
 use fuels_core::{
-    constants::{BASE_ASSET_ID, DEFAULT_GAS_ESTIMATION_TOLERANCE},
+    constants::{
+        BASE_ASSET_ID, DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON, DEFAULT_GAS_ESTIMATION_TOLERANCE,
+    },
     types::{
         bech32::{Bech32Address, Bech32ContractId},
         block::Block,
@@ -31,7 +37,7 @@ use fuels_core::{
         message::Message,
         message_proof::MessageProof,
         node_info::NodeInfo,
-        transaction::Transaction,
+        transaction::{Transaction, Transactions},
         transaction_builders::DryRunner,
         transaction_response::TransactionResponse,
         tx_status::TxStatus,
@@ -48,13 +54,14 @@ use crate::coin_cache::CoinsCache;
 use crate::provider::retryable_client::RetryableClient;
 
 #[derive(Debug)]
+// ANCHOR: transaction_cost
 pub struct TransactionCost {
-    pub min_gas_price: u64,
     pub gas_price: u64,
     pub gas_used: u64,
     pub metered_bytes_size: u64,
     pub total_fee: u64,
 }
+// ANCHOR_END: transaction_cost
 
 pub(crate) struct ResourceQueries {
     utxos: Vec<UtxoId>,
@@ -206,6 +213,7 @@ impl Provider {
         }
 
         self.validate_transaction(tx.clone()).await?;
+
         Ok(())
     }
 
@@ -220,15 +228,11 @@ impl Provider {
 
     async fn validate_transaction<T: Transaction>(&self, tx: T) -> Result<()> {
         let tolerance = 0.0;
-        let TransactionCost {
-            gas_used,
-            min_gas_price,
-            ..
-        } = self
-            .estimate_transaction_cost(tx.clone(), Some(tolerance))
+        let TransactionCost { gas_used, .. } = self
+            .estimate_transaction_cost(tx.clone(), Some(tolerance), None)
             .await?;
 
-        tx.validate_gas(min_gas_price, gas_used)?;
+        tx.validate_gas(gas_used)?;
 
         Ok(())
     }
@@ -299,39 +303,84 @@ impl Provider {
         Ok(self.client.node_info().await?.into())
     }
 
-    pub async fn checked_dry_run<T: Transaction>(&self, tx: T) -> Result<TxStatus> {
-        let receipts = self.dry_run(tx).await?;
-        Ok(Self::tx_status_from_receipts(receipts))
+    pub async fn latest_gas_price(&self) -> Result<LatestGasPrice> {
+        Ok(self.client.latest_gas_price().await?)
     }
 
-    fn tx_status_from_receipts(receipts: Vec<Receipt>) -> TxStatus {
-        let revert_reason = receipts.iter().find_map(|receipt| match receipt {
-            Receipt::ScriptResult { result, .. } if *result != ScriptExecutionResult::Success => {
-                Some(format!("{result:?}"))
-            }
-            _ => None,
-        });
-
-        match revert_reason {
-            Some(reason) => TxStatus::Revert {
-                receipts,
-                reason,
-                revert_id: 0,
-            },
-            None => TxStatus::Success { receipts },
-        }
+    pub async fn estimate_gas_price(&self, block_horizon: u32) -> Result<EstimateGasPrice> {
+        Ok(self.client.estimate_gas_price(block_horizon).await?)
+    }
+
+    pub async fn dry_run(&self, tx: impl Transaction) -> Result<TxStatus> {
+        let [(_, tx_status)] = self
+            .client
+            .dry_run(Transactions::new().insert(tx).as_slice())
+            .await?
+            .into_iter()
+            .map(Self::tx_status_from_execution_status)
+            .collect::<Vec<_>>()
+            .try_into()
+            .expect("should have only one element");
+
+        Ok(tx_status)
     }
 
-    pub async fn dry_run<T: Transaction>(&self, tx: T) -> Result<Vec<Receipt>> {
-        let receipts = self.client.dry_run(&tx.into()).await?;
+    pub async fn dry_run_multiple(
+        &self,
+        transactions: Transactions,
+    ) -> Result<Vec<(TxId, TxStatus)>> {
+        Ok(self
+            .client
+            .dry_run(transactions.as_slice())
+            .await?
+            .into_iter()
+            .map(Self::tx_status_from_execution_status)
+            .collect())
+    }
 
-        Ok(receipts)
+    fn tx_status_from_execution_status(
+        tx_execution_status: TransactionExecutionStatus,
+    ) -> (TxId, TxStatus) {
+        (
+            tx_execution_status.id,
+            match tx_execution_status.result {
+                TransactionExecutionResult::Success { receipts, .. } => {
+                    TxStatus::Success { receipts }
+                }
+                TransactionExecutionResult::Failed { receipts, result } => TxStatus::Revert {
+                    reason: TransactionExecutionResult::reason(&receipts, &result),
+                    receipts,
+                    revert_id: 0,
+                },
+            },
+        )
     }
 
-    pub async fn dry_run_no_validation<T: Transaction>(&self, tx: T) -> Result<Vec<Receipt>> {
-        let receipts = self.client.dry_run_opt(&tx.into(), Some(false)).await?;
+    pub async fn dry_run_no_validation(&self, tx: impl Transaction) -> Result<TxStatus> {
+        let [(_, tx_status)] = self
+            .client
+            .dry_run_opt(Transactions::new().insert(tx).as_slice(), Some(false))
+            .await?
+            .into_iter()
+            .map(Self::tx_status_from_execution_status)
+            .collect::<Vec<_>>()
+            .try_into()
+            .expect("should have only one element");
 
-        Ok(receipts)
+        Ok(tx_status)
+    }
+
+    pub async fn dry_run_no_validation_multiple(
+        &self,
+        transactions: Transactions,
+    ) -> Result<Vec<(TxId, TxStatus)>> {
+        Ok(self
+            .client
+            .dry_run_opt(transactions.as_slice(), Some(false))
+            .await?
+            .into_iter()
+            .map(Self::tx_status_from_execution_status)
+            .collect())
     }
 
     /// Gets all unspent coins owned by address `from`, with asset ID `asset_id`.
@@ -579,11 +628,14 @@ impl Provider {
             .into())
     }
 
-    /// Get block by id.
     pub async fn block(&self, block_id: &Bytes32) -> Result<Option<Block>> {
         Ok(self.client.block(block_id).await?.map(Into::into))
     }
 
+    pub async fn block_by_height(&self, height: BlockHeight) -> Result<Option<Block>> {
+        Ok(self.client.block_by_height(height).await?.map(Into::into))
+    }
+
     // - Get block(s)
     pub async fn get_blocks(
         &self,
@@ -603,22 +655,23 @@ impl Provider {
         &self,
         tx: T,
         tolerance: Option<f64>,
+        block_horizon: Option<u32>,
     ) -> Result<TransactionCost> {
-        let NodeInfo { min_gas_price, .. } = self.node_info().await?;
-        let gas_price = std::cmp::max(tx.gas_price(), min_gas_price);
+        let block_horizon = block_horizon.unwrap_or(DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON);
         let tolerance = tolerance.unwrap_or(DEFAULT_GAS_ESTIMATION_TOLERANCE);
 
+        let EstimateGasPrice { gas_price, .. } = self.estimate_gas_price(block_horizon).await?;
+
         let gas_used = self
             .get_gas_used_with_tolerance(tx.clone(), tolerance)
             .await?;
 
         let transaction_fee = tx
             .clone()
-            .fee_checked_from_tx(&self.consensus_parameters)
+            .fee_checked_from_tx(&self.consensus_parameters, gas_price)
             .expect("Error calculating TransactionFee");
 
         Ok(TransactionCost {
-            min_gas_price,
             gas_price,
             gas_used,
             metered_bytes_size: tx.metered_bytes_size() as u64,
@@ -632,7 +685,8 @@ impl Provider {
         tx: T,
         tolerance: f64,
     ) -> Result<u64> {
-        let gas_used = self.get_gas_used(&self.dry_run_no_validation(tx).await?);
+        let receipts = self.dry_run_no_validation(tx).await?.take_receipts();
+        let gas_used = self.get_gas_used(&receipts);
 
         Ok((gas_used as f64 * (1.0 + tolerance)) as u64)
     }
@@ -697,14 +751,20 @@ impl Provider {
 #[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
 impl DryRunner for Provider {
     async fn dry_run_and_get_used_gas(&self, tx: FuelTransaction, tolerance: f32) -> Result<u64> {
-        let receipts = self.client.dry_run_opt(&tx, Some(false)).await?;
-        let gas_used = self.get_gas_used(&receipts);
+        let [tx_execution_status] = self
+            .client
+            .dry_run_opt(&vec![tx], Some(false))
+            .await?
+            .try_into()
+            .expect("should have only one element");
+
+        let gas_used = self.get_gas_used(tx_execution_status.result.receipts());
 
         Ok((gas_used as f64 * (1.0 + tolerance as f64)) as u64)
     }
 
-    async fn min_gas_price(&self) -> Result<u64> {
-        Ok(self.node_info().await.map(|ni| ni.min_gas_price)?)
+    async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64> {
+        Ok(self.estimate_gas_price(block_horizon).await?.gas_price)
     }
 
     fn consensus_parameters(&self) -> &ConsensusParameters {
diff --git a/packages/fuels-accounts/src/provider/retryable_client.rs b/packages/fuels-accounts/src/provider/retryable_client.rs
index f71d36704a..3a1da44fc9 100644
--- a/packages/fuels-accounts/src/provider/retryable_client.rs
+++ b/packages/fuels-accounts/src/provider/retryable_client.rs
@@ -3,13 +3,15 @@ use std::{future::Future, io};
 use fuel_core_client::client::{
     pagination::{PaginatedResult, PaginationRequest},
     types::{
+        gas_price::{EstimateGasPrice, LatestGasPrice},
         primitives::{BlockId, TransactionId},
         Balance, Block, ChainInfo, Coin, CoinType, ContractBalance, Message, MessageProof,
         NodeInfo, TransactionResponse, TransactionStatus,
     },
     FuelClient,
 };
-use fuel_tx::{Receipt, Transaction, TxId, UtxoId};
+use fuel_core_types::services::executor::TransactionExecutionStatus;
+use fuel_tx::{Transaction, TxId, UtxoId};
 use fuel_types::{Address, AssetId, BlockHeight, ContractId, Nonce};
 use fuels_core::types::errors::{error, Error, Result};
 
@@ -101,15 +103,28 @@ impl RetryableClient {
         self.our_retry(|| self.client.node_info()).await
     }
 
-    pub async fn dry_run(&self, tx: &Transaction) -> RequestResult<Vec<Receipt>> {
+    pub async fn latest_gas_price(&self) -> RequestResult<LatestGasPrice> {
+        self.our_retry(|| self.client.latest_gas_price()).await
+    }
+
+    pub async fn estimate_gas_price(&self, block_horizon: u32) -> RequestResult<EstimateGasPrice> {
+        self.our_retry(|| self.client.estimate_gas_price(block_horizon))
+            .await
+            .map(Into::into)
+    }
+
+    pub async fn dry_run(
+        &self,
+        tx: &[Transaction],
+    ) -> RequestResult<Vec<TransactionExecutionStatus>> {
         self.our_retry(|| self.client.dry_run(tx)).await
     }
 
     pub async fn dry_run_opt(
         &self,
-        tx: &Transaction,
+        tx: &[Transaction],
         utxo_validation: Option<bool>,
-    ) -> RequestResult<Vec<Receipt>> {
+    ) -> RequestResult<Vec<TransactionExecutionStatus>> {
         self.our_retry(|| self.client.dry_run_opt(tx, utxo_validation))
             .await
     }
@@ -202,6 +217,10 @@ impl RetryableClient {
         self.our_retry(|| self.client.block(id)).await
     }
 
+    pub async fn block_by_height(&self, height: BlockHeight) -> RequestResult<Option<Block>> {
+        self.our_retry(|| self.client.block_by_height(height)).await
+    }
+
     pub async fn blocks(
         &self,
         request: PaginationRequest<String>,
diff --git a/packages/fuels-accounts/src/provider/supported_versions.rs b/packages/fuels-accounts/src/provider/supported_versions.rs
index 3ef803575b..478b6e894d 100644
--- a/packages/fuels-accounts/src/provider/supported_versions.rs
+++ b/packages/fuels-accounts/src/provider/supported_versions.rs
@@ -1,7 +1,7 @@
 use semver::Version;
 
 fn get_supported_fuel_core_version() -> Version {
-    "0.22.0".parse().expect("is valid version")
+    "0.23.0".parse().expect("is valid version")
 }
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/packages/fuels-core/src/types.rs b/packages/fuels-core/src/types.rs
index 40edd2f0b2..502077f2c0 100644
--- a/packages/fuels-core/src/types.rs
+++ b/packages/fuels-core/src/types.rs
@@ -2,8 +2,8 @@ use std::fmt;
 
 use fuel_types::bytes::padded_len;
 pub use fuel_types::{
-    Address, AssetId, Bytes32, Bytes4, Bytes64, Bytes8, ChainId, ContractId, MessageId, Nonce,
-    Salt, Word,
+    Address, AssetId, BlockHeight, Bytes32, Bytes4, Bytes64, Bytes8, ChainId, ContractId,
+    MessageId, Nonce, Salt, Word,
 };
 
 pub use crate::types::{core::*, wrappers::*};
diff --git a/packages/fuels-core/src/types/transaction_builders.rs b/packages/fuels-core/src/types/transaction_builders.rs
index 0c1f4bf723..ed664d2abd 100644
--- a/packages/fuels-core/src/types/transaction_builders.rs
+++ b/packages/fuels-core/src/types/transaction_builders.rs
@@ -10,7 +10,7 @@ use async_trait::async_trait;
 use fuel_asm::{op, GTFArgs, RegId};
 use fuel_crypto::{Message as CryptoMessage, Signature};
 use fuel_tx::{
-    field::{Inputs, WitnessLimit, Witnesses},
+    field::{Inputs, Policies as PoliciesField, WitnessLimit, Witnesses},
     policies::{Policies, PolicyType},
     Buildable, Chargeable, ConsensusParameters, Create, Input as FuelInput, Output, Script,
     StorageSlot, Transaction as FuelTransaction, TransactionFee, TxPointer, UniqueIdentifier,
@@ -42,7 +42,7 @@ use crate::{
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait DryRunner: Send + Sync {
     async fn dry_run_and_get_used_gas(&self, tx: FuelTransaction, tolerance: f32) -> Result<u64>;
-    async fn min_gas_price(&self) -> Result<u64>;
+    async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64>;
     fn consensus_parameters(&self) -> &ConsensusParameters;
 }
 
@@ -52,8 +52,8 @@ impl<T: DryRunner> DryRunner for &T {
         (*self).dry_run_and_get_used_gas(tx, tolerance).await
     }
 
-    async fn min_gas_price(&self) -> Result<u64> {
-        (*self).min_gas_price().await
+    async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64> {
+        (*self).estimate_gas_price(block_horizon).await
     }
 
     fn consensus_parameters(&self) -> &ConsensusParameters {
@@ -70,12 +70,12 @@ struct UnresolvedWitnessIndexes {
 pub trait BuildableTransaction: sealed::Sealed {
     type TxType: Transaction;
 
-    async fn build(self, provider: &impl DryRunner) -> Result<Self::TxType>;
+    async fn build(self, provider: impl DryRunner) -> Result<Self::TxType>;
 
     /// Building without signatures will set the witness indexes of signed coins in the
     /// order as they appear in the inputs. Multiple coins with the same owner will have
     /// the same witness index. Make sure you sign the built transaction in the expected order.
-    async fn build_without_signatures(self, provider: &impl DryRunner) -> Result<Self::TxType>;
+    async fn build_without_signatures(self, provider: impl DryRunner) -> Result<Self::TxType>;
 }
 
 impl sealed::Sealed for ScriptTransactionBuilder {}
@@ -84,11 +84,11 @@ impl sealed::Sealed for ScriptTransactionBuilder {}
 impl BuildableTransaction for ScriptTransactionBuilder {
     type TxType = ScriptTransaction;
 
-    async fn build(self, provider: &impl DryRunner) -> Result<Self::TxType> {
+    async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
         self.build(provider).await
     }
 
-    async fn build_without_signatures(mut self, provider: &impl DryRunner) -> Result<Self::TxType> {
+    async fn build_without_signatures(mut self, provider: impl DryRunner) -> Result<Self::TxType> {
         self.set_witness_indexes();
         self.unresolved_signers = Default::default();
 
@@ -102,11 +102,11 @@ impl sealed::Sealed for CreateTransactionBuilder {}
 impl BuildableTransaction for CreateTransactionBuilder {
     type TxType = CreateTransaction;
 
-    async fn build(self, provider: &impl DryRunner) -> Result<Self::TxType> {
+    async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
         self.build(provider).await
     }
 
-    async fn build_without_signatures(mut self, provider: &impl DryRunner) -> Result<Self::TxType> {
+    async fn build_without_signatures(mut self, provider: impl DryRunner) -> Result<Self::TxType> {
         self.set_witness_indexes();
         self.unresolved_signers = Default::default();
 
@@ -119,10 +119,8 @@ pub trait TransactionBuilder: BuildableTransaction + Send + sealed::Sealed {
     type TxType: Transaction;
 
     fn add_signer(&mut self, signer: impl Signer + Send + Sync) -> Result<&mut Self>;
-    async fn fee_checked_from_tx(
-        &self,
-        provider: &impl DryRunner,
-    ) -> Result<Option<TransactionFee>>;
+    async fn fee_checked_from_tx(&self, provider: impl DryRunner)
+        -> Result<Option<TransactionFee>>;
     fn with_tx_policies(self, tx_policies: TxPolicies) -> Self;
     fn with_inputs(self, inputs: Vec<Input>) -> Self;
     fn with_outputs(self, outputs: Vec<Output>) -> Self;
@@ -133,6 +131,7 @@ pub trait TransactionBuilder: BuildableTransaction + Send + sealed::Sealed {
     fn outputs_mut(&mut self) -> &mut Vec<Output>;
     fn witnesses(&self) -> &Vec<Witness>;
     fn witnesses_mut(&mut self) -> &mut Vec<Witness>;
+    fn with_estimation_horizon(self, block_horizon: u32) -> Self;
 }
 
 macro_rules! impl_tx_trait {
@@ -165,7 +164,7 @@ macro_rules! impl_tx_trait {
 
             async fn fee_checked_from_tx(
                 &self,
-                provider: &impl DryRunner,
+                provider: impl DryRunner,
             ) -> Result<Option<TransactionFee>> {
                 let mut fee_estimation_tb = self.clone_without_signers();
 
@@ -177,7 +176,7 @@ macro_rules! impl_tx_trait {
                     .extend(repeat(witness).take(self.unresolved_signers.len()));
 
                 let mut tx =
-                    BuildableTransaction::build_without_signatures(fee_estimation_tb, provider)
+                    BuildableTransaction::build_without_signatures(fee_estimation_tb, &provider)
                         .await?;
 
                 let consensus_parameters = provider.consensus_parameters();
@@ -190,6 +189,9 @@ macro_rules! impl_tx_trait {
                     &consensus_parameters.gas_costs,
                     &consensus_parameters.fee_params,
                     &tx.tx,
+                    provider
+                        .estimate_gas_price(self.gas_price_estimation_block_horizon)
+                        .await?,
                 ))
             }
 
@@ -237,6 +239,12 @@ macro_rules! impl_tx_trait {
             fn witnesses_mut(&mut self) -> &mut Vec<Witness> {
                 &mut self.witnesses
             }
+
+            fn with_estimation_horizon(mut self, block_horizon: u32) -> Self {
+                self.gas_price_estimation_block_horizon = block_horizon;
+
+                self
+            }
         }
 
         impl $ty {
@@ -255,9 +263,11 @@ macro_rules! impl_tx_trait {
                     .collect();
             }
 
-            fn generate_fuel_policies(&self, network_min_gas_price: u64) -> Policies {
+            fn generate_fuel_policies(&self) -> Policies {
                 let mut policies = Policies::default();
-                policies.set(PolicyType::MaxFee, self.tx_policies.max_fee());
+                // `MaxFee` set to `tip` or `0` for `dry_run`
+                policies.set(PolicyType::MaxFee, self.tx_policies.tip().or(Some(0)));
+
                 policies.set(PolicyType::Maturity, self.tx_policies.maturity());
 
                 let witness_limit = self
@@ -266,10 +276,7 @@ macro_rules! impl_tx_trait {
                     .or_else(|| self.calculate_witnesses_size());
                 policies.set(PolicyType::WitnessLimit, witness_limit);
 
-                policies.set(
-                    PolicyType::GasPrice,
-                    self.tx_policies.gas_price().or(Some(network_min_gas_price)),
-                );
+                policies.set(PolicyType::Tip, self.tx_policies.tip());
 
                 policies
             }
@@ -300,6 +307,31 @@ macro_rules! impl_tx_trait {
 
                 Some(padded_len_usize(witnesses_size + signature_size) as u64)
             }
+
+            async fn set_max_fee_policy<T: PoliciesField + Chargeable>(
+                tx: &mut T,
+                provider: impl DryRunner,
+                block_horizon: u32,
+            ) -> Result<()> {
+                let gas_price = provider.estimate_gas_price(block_horizon).await?;
+                let consensus_parameters = provider.consensus_parameters();
+
+                let tx_fee = TransactionFee::checked_from_tx(
+                    &consensus_parameters.gas_costs,
+                    consensus_parameters.fee_params(),
+                    tx,
+                    gas_price,
+                )
+                .ok_or(error_transaction!(
+                    Other,
+                    "error calculating `TransactionFee` in `TransactionBuilder`"
+                ))?;
+
+                tx.policies_mut()
+                    .set(PolicyType::MaxFee, Some(tx_fee.max_fee()));
+
+                Ok(())
+            }
         }
     };
 }
@@ -321,6 +353,7 @@ pub struct ScriptTransactionBuilder {
     pub witnesses: Vec<Witness>,
     pub tx_policies: TxPolicies,
     pub gas_estimation_tolerance: f32,
+    pub gas_price_estimation_block_horizon: u32,
     unresolved_witness_indexes: UnresolvedWitnessIndexes,
     unresolved_signers: Vec<Box<dyn Signer + Send + Sync>>,
 }
@@ -335,6 +368,7 @@ pub struct CreateTransactionBuilder {
     pub witnesses: Vec<Witness>,
     pub tx_policies: TxPolicies,
     pub salt: Salt,
+    pub gas_price_estimation_block_horizon: u32,
     unresolved_witness_indexes: UnresolvedWitnessIndexes,
     unresolved_signers: Vec<Box<dyn Signer + Send + Sync>>,
 }
@@ -343,7 +377,7 @@ impl_tx_trait!(ScriptTransactionBuilder, ScriptTransaction);
 impl_tx_trait!(CreateTransactionBuilder, CreateTransaction);
 
 impl ScriptTransactionBuilder {
-    async fn build(self, provider: &impl DryRunner) -> Result<ScriptTransaction> {
+    async fn build(self, provider: impl DryRunner) -> Result<ScriptTransaction> {
         let is_using_predicates = self.is_using_predicates();
         let base_offset = if is_using_predicates {
             self.base_offset(provider.consensus_parameters())
@@ -385,7 +419,7 @@ impl ScriptTransactionBuilder {
 
     async fn set_script_gas_limit_to_gas_used(
         tx: &mut Script,
-        provider: &impl DryRunner,
+        provider: impl DryRunner,
         tolerance: f32,
     ) -> Result<()> {
         let consensus_params = provider.consensus_parameters();
@@ -401,7 +435,6 @@ impl ScriptTransactionBuilder {
                 Default::default(),
                 TxPointer::default(),
                 0,
-                0u32.into(),
             ));
 
             // Add an empty `Witness` for the `coin_signed` we just added
@@ -431,13 +464,9 @@ impl ScriptTransactionBuilder {
         Ok(())
     }
 
-    async fn resolve_fuel_tx(
-        self,
-        base_offset: usize,
-        provider: &impl DryRunner,
-    ) -> Result<Script> {
+    async fn resolve_fuel_tx(self, base_offset: usize, provider: impl DryRunner) -> Result<Script> {
         let num_witnesses = self.num_witnesses()?;
-        let policies = self.generate_fuel_policies(provider.min_gas_price().await?);
+        let policies = self.generate_fuel_policies();
 
         let has_no_code = self.script.is_empty();
         let dry_run_witnesses = self.create_dry_run_witnesses(num_witnesses);
@@ -466,10 +495,17 @@ impl ScriptTransactionBuilder {
         // If the `script_gas_limit` was not set by the user,
         // dry-run the tx to get the `gas_used`
         } else {
-            Self::set_script_gas_limit_to_gas_used(&mut tx, provider, self.gas_estimation_tolerance)
-                .await?
+            Self::set_script_gas_limit_to_gas_used(
+                &mut tx,
+                &provider,
+                self.gas_estimation_tolerance,
+            )
+            .await?
         };
 
+        Self::set_max_fee_policy(&mut tx, &provider, self.gas_price_estimation_block_horizon)
+            .await?;
+
         let missing_witnesses = generate_missing_witnesses(
             tx.id(&provider.consensus_parameters().chain_id),
             &self.unresolved_signers,
@@ -603,12 +639,13 @@ impl ScriptTransactionBuilder {
             gas_estimation_tolerance: self.gas_estimation_tolerance,
             unresolved_witness_indexes: self.unresolved_witness_indexes.clone(),
             unresolved_signers: Default::default(),
+            gas_price_estimation_block_horizon: self.gas_price_estimation_block_horizon,
         }
     }
 }
 
 impl CreateTransactionBuilder {
-    pub async fn build(self, provider: &impl DryRunner) -> Result<CreateTransaction> {
+    pub async fn build(self, provider: impl DryRunner) -> Result<CreateTransaction> {
         let consensus_parameters = provider.consensus_parameters();
 
         let is_using_predicates = self.is_using_predicates();
@@ -619,11 +656,7 @@ impl CreateTransactionBuilder {
         };
 
         let tx = self
-            .resolve_fuel_tx(
-                base_offset,
-                &consensus_parameters.chain_id,
-                provider.min_gas_price().await?,
-            )
+            .resolve_fuel_tx(base_offset, &consensus_parameters.chain_id, &provider)
             .await?;
 
         Ok(CreateTransaction {
@@ -636,10 +669,10 @@ impl CreateTransactionBuilder {
         self,
         mut base_offset: usize,
         chain_id: &ChainId,
-        network_min_gas_price: u64,
+        provider: impl DryRunner,
     ) -> Result<Create> {
         let num_witnesses = self.num_witnesses()?;
-        let policies = self.generate_fuel_policies(network_min_gas_price);
+        let policies = self.generate_fuel_policies();
 
         let storage_slots_offset = self.storage_slots.len() * StorageSlot::SLOT_SIZE;
         base_offset += storage_slots_offset + policies.size_dynamic();
@@ -659,6 +692,9 @@ impl CreateTransactionBuilder {
             self.witnesses,
         );
 
+        Self::set_max_fee_policy(&mut tx, provider, self.gas_price_estimation_block_horizon)
+            .await?;
+
         let missing_witnesses =
             generate_missing_witnesses(tx.id(chain_id), &self.unresolved_signers).await?;
         tx.witnesses_mut().extend(missing_witnesses);
@@ -726,6 +762,7 @@ impl CreateTransactionBuilder {
             salt: self.salt,
             unresolved_witness_indexes: self.unresolved_witness_indexes.clone(),
             unresolved_signers: Default::default(),
+            gas_price_estimation_block_horizon: self.gas_price_estimation_block_horizon,
         }
     }
 }
@@ -847,7 +884,6 @@ pub fn create_coin_input(coin: Coin, witness_index: u8) -> FuelInput {
         coin.asset_id,
         TxPointer::default(),
         witness_index,
-        0u32.into(),
     )
 }
 
@@ -884,7 +920,6 @@ pub fn create_coin_predicate(
         coin.amount,
         asset_id,
         TxPointer::default(),
-        0u32.into(),
         0u64,
         code,
         predicate_data,
@@ -1036,10 +1071,12 @@ mod tests {
         async fn dry_run_and_get_used_gas(&self, _: FuelTransaction, _: f32) -> Result<u64> {
             Ok(0)
         }
+
         fn consensus_parameters(&self) -> &ConsensusParameters {
             &self.c_param
         }
-        async fn min_gas_price(&self) -> Result<u64> {
+
+        async fn estimate_gas_price(&self, _block_horizon: u32) -> Result<u64> {
             Ok(0)
         }
     }
diff --git a/packages/fuels-core/src/types/wrappers.rs b/packages/fuels-core/src/types/wrappers.rs
index b0bc9c18b1..90b98152cb 100644
--- a/packages/fuels-core/src/types/wrappers.rs
+++ b/packages/fuels-core/src/types/wrappers.rs
@@ -12,3 +12,7 @@ pub mod transaction_response;
 pub mod output {
     pub use fuel_tx::Output;
 }
+#[cfg(feature = "std")]
+pub mod gas_price {
+    pub use fuel_core_client::client::types::gas_price::{EstimateGasPrice, LatestGasPrice};
+}
diff --git a/packages/fuels-core/src/types/wrappers/coin.rs b/packages/fuels-core/src/types/wrappers/coin.rs
index 351917cc48..2b8093a9b9 100644
--- a/packages/fuels-core/src/types/wrappers/coin.rs
+++ b/packages/fuels-core/src/types/wrappers/coin.rs
@@ -21,7 +21,6 @@ pub struct Coin {
     pub block_created: u32,
     pub asset_id: AssetId,
     pub utxo_id: UtxoId,
-    pub maturity: u32,
     pub owner: Bech32Address,
     pub status: CoinStatus,
 }
@@ -33,7 +32,6 @@ impl From<ClientCoin> for Coin {
             block_created: coin.block_created,
             asset_id: coin.asset_id,
             utxo_id: coin.utxo_id,
-            maturity: coin.maturity,
             owner: Bech32Address::from(coin.owner),
             status: CoinStatus::Unspent,
         }
@@ -47,7 +45,6 @@ impl From<Coin> for CoinConfig {
             output_index: Some(coin.utxo_id.output_index()),
             tx_pointer_block_height: Some(coin.block_created.into()),
             tx_pointer_tx_idx: None,
-            maturity: Some(coin.maturity.into()),
             owner: coin.owner.into(),
             amount: coin.amount,
             asset_id: coin.asset_id,
diff --git a/packages/fuels-core/src/types/wrappers/transaction.rs b/packages/fuels-core/src/types/wrappers/transaction.rs
index fcf389b13b..5225946c10 100644
--- a/packages/fuels-core/src/types/wrappers/transaction.rs
+++ b/packages/fuels-core/src/types/wrappers/transaction.rs
@@ -4,8 +4,8 @@ use async_trait::async_trait;
 use fuel_crypto::{Message, Signature};
 use fuel_tx::{
     field::{
-        GasPrice, Inputs, Maturity, MintAmount, MintAssetId, Outputs, Script as ScriptField,
-        ScriptData, ScriptGasLimit, WitnessLimit, Witnesses,
+        Inputs, Maturity, MintAmount, MintAssetId, Outputs, Script as ScriptField, ScriptData,
+        ScriptGasLimit, WitnessLimit, Witnesses,
     },
     input::{
         coin::{CoinPredicate, CoinSigned},
@@ -31,6 +31,27 @@ use crate::{
     utils::{calculate_witnesses_size, sealed},
 };
 
+#[derive(Default, Debug, Clone)]
+pub struct Transactions {
+    fuel_transactions: Vec<FuelTransaction>,
+}
+
+impl Transactions {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn insert(mut self, tx: impl Into<FuelTransaction>) -> Self {
+        self.fuel_transactions.push(tx.into());
+
+        self
+    }
+
+    pub fn as_slice(&self) -> &[FuelTransaction] {
+        &self.fuel_transactions
+    }
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct MintTransaction {
     tx: Box<Mint>,
@@ -83,7 +104,7 @@ impl MintTransaction {
 #[derive(Default, Debug, Copy, Clone)]
 //ANCHOR: tx_policies_struct
 pub struct TxPolicies {
-    gas_price: Option<u64>,
+    tip: Option<u64>,
     witness_limit: Option<u64>,
     maturity: Option<u64>,
     max_fee: Option<u64>,
@@ -93,14 +114,14 @@ pub struct TxPolicies {
 
 impl TxPolicies {
     pub fn new(
-        gas_price: Option<u64>,
+        tip: Option<u64>,
         witness_limit: Option<u64>,
         maturity: Option<u64>,
         max_fee: Option<u64>,
         script_gas_limit: Option<u64>,
     ) -> Self {
         Self {
-            gas_price,
+            tip,
             witness_limit,
             maturity,
             max_fee,
@@ -108,13 +129,13 @@ impl TxPolicies {
         }
     }
 
-    pub fn with_gas_price(mut self, gas_price: u64) -> Self {
-        self.gas_price = Some(gas_price);
+    pub fn with_tip(mut self, tip: u64) -> Self {
+        self.tip = Some(tip);
         self
     }
 
-    pub fn gas_price(&self) -> Option<u64> {
-        self.gas_price
+    pub fn tip(&self) -> Option<u64> {
+        self.tip
     }
 
     pub fn with_witness_limit(mut self, witness_limit: u64) -> Self {
@@ -173,7 +194,7 @@ pub trait EstimablePredicates: sealed::Sealed {
 }
 
 pub trait GasValidation: sealed::Sealed {
-    fn validate_gas(&self, min_gas_price: u64, gas_used: u64) -> Result<()>;
+    fn validate_gas(&self, _gas_used: u64) -> Result<()>;
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -184,6 +205,7 @@ pub trait Transaction:
     fn fee_checked_from_tx(
         &self,
         consensus_parameters: &ConsensusParameters,
+        gas_price: u64,
     ) -> Option<TransactionFee>;
 
     fn max_gas(&self, consensus_parameters: &ConsensusParameters) -> u64;
@@ -199,10 +221,6 @@ pub trait Transaction:
 
     fn with_maturity(self, maturity: u32) -> Self;
 
-    fn gas_price(&self) -> u64;
-
-    fn with_gas_price(self, gas_price: u64) -> Self;
-
     fn metered_bytes_size(&self) -> usize;
 
     fn inputs(&self) -> &Vec<Input>;
@@ -316,11 +334,13 @@ macro_rules! impl_tx_wrapper {
             fn fee_checked_from_tx(
                 &self,
                 consensus_parameters: &ConsensusParameters,
+                gas_price: u64,
             ) -> Option<TransactionFee> {
                 TransactionFee::checked_from_tx(
                     &consensus_parameters.gas_costs,
                     consensus_parameters.fee_params(),
                     &self.tx,
+                    gas_price,
                 )
             }
 
@@ -345,15 +365,6 @@ macro_rules! impl_tx_wrapper {
                 self
             }
 
-            fn gas_price(&self) -> u64 {
-                self.tx.gas_price()
-            }
-
-            fn with_gas_price(mut self, gas_price: u64) -> Self {
-                self.tx.set_gas_price(gas_price);
-                self
-            }
-
             fn metered_bytes_size(&self) -> usize {
                 self.tx.metered_bytes_size()
             }
@@ -463,33 +474,22 @@ impl CreateTransaction {
     }
 }
 
-impl GasValidation for CreateTransaction {
-    // We're not using `gas_used` in this implementation
-    // because `CreateTransaction` has no gas_limit`
-    fn validate_gas(&self, min_gas_price: u64, _: u64) -> Result<()> {
-        if min_gas_price > self.tx.gas_price() {
-            return Err(error_transaction!(
-                Validation,
-                "gas_price({}) is lower than the required min_gas_price({})",
-                self.tx.gas_price(),
-                min_gas_price
-            ));
-        }
+impl EstimablePredicates for ScriptTransaction {
+    fn estimate_predicates(&mut self, consensus_parameters: &ConsensusParameters) -> Result<()> {
+        self.tx.estimate_predicates(&consensus_parameters.into())?;
 
         Ok(())
     }
 }
 
-impl EstimablePredicates for ScriptTransaction {
-    fn estimate_predicates(&mut self, consensus_parameters: &ConsensusParameters) -> Result<()> {
-        self.tx.estimate_predicates(&consensus_parameters.into())?;
-
+impl GasValidation for CreateTransaction {
+    fn validate_gas(&self, _gas_used: u64) -> Result<()> {
         Ok(())
     }
 }
 
 impl GasValidation for ScriptTransaction {
-    fn validate_gas(&self, min_gas_price: u64, gas_used: u64) -> Result<()> {
+    fn validate_gas(&self, gas_used: u64) -> Result<()> {
         if gas_used > *self.tx.script_gas_limit() {
             return Err(error_transaction!(
                 Validation,
@@ -497,13 +497,6 @@ impl GasValidation for ScriptTransaction {
                 self.tx.script_gas_limit(),
                 gas_used
             ));
-        } else if min_gas_price > self.tx.gas_price() {
-            return Err(error_transaction!(
-                Validation,
-                "gas_price({}) is lower than the required min_gas_price({})",
-                self.tx.gas_price(),
-                min_gas_price
-            ));
         }
 
         Ok(())
diff --git a/packages/fuels-core/src/types/wrappers/transaction_response.rs b/packages/fuels-core/src/types/wrappers/transaction_response.rs
index 35c9f3230d..90bd5413de 100644
--- a/packages/fuels-core/src/types/wrappers/transaction_response.rs
+++ b/packages/fuels-core/src/types/wrappers/transaction_response.rs
@@ -1,13 +1,11 @@
 #![cfg(feature = "std")]
 
-use std::str::FromStr;
-
 use chrono::{DateTime, Utc};
 use fuel_core_client::client::types::{
     TransactionResponse as ClientTransactionResponse, TransactionStatus as ClientTransactionStatus,
 };
 use fuel_tx::Transaction;
-use fuel_types::Bytes32;
+use fuel_types::BlockHeight;
 
 use crate::types::{
     transaction::{CreateTransaction, ScriptTransaction, TransactionType},
@@ -18,20 +16,18 @@ use crate::types::{
 pub struct TransactionResponse {
     pub transaction: TransactionType,
     pub status: TxStatus,
-    pub block_id: Option<Bytes32>,
+    pub block_height: Option<BlockHeight>,
     pub time: Option<DateTime<Utc>>,
 }
 
 impl From<ClientTransactionResponse> for TransactionResponse {
     fn from(client_response: ClientTransactionResponse) -> Self {
-        let block_id = match &client_response.status {
+        let block_height = match &client_response.status {
             ClientTransactionStatus::Submitted { .. }
             | ClientTransactionStatus::SqueezedOut { .. } => None,
-            ClientTransactionStatus::Success { block_id, .. }
-            | ClientTransactionStatus::Failure { block_id, .. } => Some(block_id),
+            ClientTransactionStatus::Success { block_height, .. }
+            | ClientTransactionStatus::Failure { block_height, .. } => Some(*block_height),
         };
-        let block_id = block_id
-            .map(|id| Bytes32::from_str(id).expect("client returned block id with invalid format"));
 
         let time = match &client_response.status {
             ClientTransactionStatus::Submitted { .. }
@@ -51,7 +47,7 @@ impl From<ClientTransactionResponse> for TransactionResponse {
         Self {
             transaction,
             status: client_response.status.into(),
-            block_id,
+            block_height,
             time,
         }
     }
diff --git a/packages/fuels-core/src/utils/constants.rs b/packages/fuels-core/src/utils/constants.rs
index 8596475903..16dbcbb4bb 100644
--- a/packages/fuels-core/src/utils/constants.rs
+++ b/packages/fuels-core/src/utils/constants.rs
@@ -11,6 +11,7 @@ pub const BASE_ASSET_ID: AssetId = AssetId::BASE;
 // ANCHOR_END: default_call_parameters
 
 pub const DEFAULT_GAS_ESTIMATION_TOLERANCE: f64 = 0.2;
+pub const DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON: u32 = 1;
 
 // The size of a signature inside a transaction `Witness`
 pub const WITNESS_STATIC_SIZE: usize = 8;
diff --git a/packages/fuels-programs/src/call_utils.rs b/packages/fuels-programs/src/call_utils.rs
index a6318e722e..9e311d8793 100644
--- a/packages/fuels-programs/src/call_utils.rs
+++ b/packages/fuels-programs/src/call_utils.rs
@@ -858,7 +858,6 @@ mod test {
                     block_created: 0u32,
                     asset_id,
                     utxo_id: Default::default(),
-                    maturity: 0u32,
                     owner: Default::default(),
                     status: CoinStatus::Unspent,
                 });
diff --git a/packages/fuels-programs/src/contract.rs b/packages/fuels-programs/src/contract.rs
index 883f9f7535..08c90ce8bd 100644
--- a/packages/fuels-programs/src/contract.rs
+++ b/packages/fuels-programs/src/contract.rs
@@ -622,7 +622,7 @@ where
         self.cached_tx_id = Some(tx.id(provider.chain_id()));
 
         let tx_status = if simulate {
-            provider.checked_dry_run(tx).await?
+            provider.dry_run(tx).await?
         } else {
             provider.send_transaction_and_await_commit(tx).await?
         };
@@ -635,12 +635,13 @@ where
     pub async fn estimate_transaction_cost(
         &self,
         tolerance: Option<f64>,
+        block_horizon: Option<u32>,
     ) -> Result<TransactionCost> {
         let script = self.build_tx().await?;
         let provider = self.account.try_provider()?;
 
         let transaction_cost = provider
-            .estimate_transaction_cost(script, tolerance)
+            .estimate_transaction_cost(script, tolerance, block_horizon)
             .await?;
 
         Ok(transaction_cost)
@@ -917,7 +918,7 @@ impl<T: Account> MultiContractCallHandler<T> {
         self.cached_tx_id = Some(tx.id(provider.chain_id()));
 
         let tx_status = if simulate {
-            provider.checked_dry_run(tx).await?
+            provider.dry_run(tx).await?
         } else {
             provider.send_transaction_and_await_commit(tx).await?
         };
@@ -931,7 +932,7 @@ impl<T: Account> MultiContractCallHandler<T> {
         let provider = self.account.try_provider()?;
         let tx = self.build_tx().await?;
 
-        provider.checked_dry_run(tx).await?.check(None)?;
+        provider.dry_run(tx).await?.check(None)?;
 
         Ok(())
     }
@@ -940,13 +941,14 @@ impl<T: Account> MultiContractCallHandler<T> {
     pub async fn estimate_transaction_cost(
         &self,
         tolerance: Option<f64>,
+        block_horizon: Option<u32>,
     ) -> Result<TransactionCost> {
         let script = self.build_tx().await?;
 
         let transaction_cost = self
             .account
             .try_provider()?
-            .estimate_transaction_cost(script, tolerance)
+            .estimate_transaction_cost(script, tolerance, block_horizon)
             .await?;
 
         Ok(transaction_cost)
diff --git a/packages/fuels-programs/src/script_calls.rs b/packages/fuels-programs/src/script_calls.rs
index 6b02511163..ccf9162bd2 100644
--- a/packages/fuels-programs/src/script_calls.rs
+++ b/packages/fuels-programs/src/script_calls.rs
@@ -235,7 +235,7 @@ where
         self.cached_tx_id = Some(tx.id(self.provider.chain_id()));
 
         let tx_status = if simulate {
-            self.provider.checked_dry_run(tx).await?
+            self.provider.dry_run(tx).await?
         } else {
             self.provider.send_transaction_and_await_commit(tx).await?
         };
@@ -270,12 +270,13 @@ where
     pub async fn estimate_transaction_cost(
         &self,
         tolerance: Option<f64>,
+        block_horizon: Option<u32>,
     ) -> Result<TransactionCost> {
         let tx = self.build_tx().await?;
 
         let transaction_cost = self
             .provider
-            .estimate_transaction_cost(tx, tolerance)
+            .estimate_transaction_cost(tx, tolerance, block_horizon)
             .await?;
 
         Ok(transaction_cost)
diff --git a/packages/fuels-test-helpers/src/lib.rs b/packages/fuels-test-helpers/src/lib.rs
index 4bcf30c231..9705093250 100644
--- a/packages/fuels-test-helpers/src/lib.rs
+++ b/packages/fuels-test-helpers/src/lib.rs
@@ -100,7 +100,6 @@ pub fn setup_single_asset_coins(
                 utxo_id,
                 amount: amount_per_coin,
                 asset_id,
-                maturity: Default::default(),
                 status: CoinStatus::Unspent,
                 block_created: Default::default(),
             }
diff --git a/packages/fuels/tests/contracts.rs b/packages/fuels/tests/contracts.rs
index 0bec35fee2..e9f17dfff7 100644
--- a/packages/fuels/tests/contracts.rs
+++ b/packages/fuels/tests/contracts.rs
@@ -270,37 +270,26 @@ async fn test_contract_call_fee_estimation() -> Result<()> {
         ),
     );
 
-    let gas_price = 100_000_000;
     let gas_limit = 800;
-    let tolerance = 0.2;
+    let tolerance = Some(0.2);
+    let block_horizon = Some(1);
 
-    let expected_min_gas_price = 0; // This is the default `min_gas_price` from `ConsensusParameters`
     let expected_gas_used = 949;
-    let expected_metered_bytes_size = 792;
-    let expected_total_fee = 898;
+    let expected_metered_bytes_size = 784;
 
     let estimated_transaction_cost = contract_instance
         .methods()
         .initialize_counter(42)
-        .with_tx_policies(
-            TxPolicies::default()
-                .with_gas_price(gas_price)
-                .with_script_gas_limit(gas_limit),
-        )
-        .estimate_transaction_cost(Some(tolerance))
+        .with_tx_policies(TxPolicies::default().with_script_gas_limit(gas_limit))
+        .estimate_transaction_cost(tolerance, block_horizon)
         .await?;
 
-    assert_eq!(
-        estimated_transaction_cost.min_gas_price,
-        expected_min_gas_price
-    );
-    assert_eq!(estimated_transaction_cost.gas_price, gas_price);
     assert_eq!(estimated_transaction_cost.gas_used, expected_gas_used);
     assert_eq!(
         estimated_transaction_cost.metered_bytes_size,
         expected_metered_bytes_size
     );
-    assert_eq!(estimated_transaction_cost.total_fee, expected_total_fee);
+
     Ok(())
 }
 
@@ -318,12 +307,14 @@ async fn contract_call_has_same_estimated_and_used_gas() -> Result<()> {
             wallet = "wallet"
         ),
     );
-
-    let tolerance = 0.0;
     let contract_methods = contract_instance.methods();
+
+    let tolerance = Some(0.0);
+    let block_horizon = Some(1);
+
     let estimated_gas_used = contract_methods
         .initialize_counter(42)
-        .estimate_transaction_cost(Some(tolerance))
+        .estimate_transaction_cost(tolerance, block_horizon)
         .await?
         .gas_used;
 
@@ -362,9 +353,10 @@ async fn mult_call_has_same_estimated_and_used_gas() -> Result<()> {
         .add_call(call_handler_1)
         .add_call(call_handler_2);
 
-    let tolerance = 0.0;
+    let tolerance = Some(0.0);
+    let block_horizon = Some(1);
     let estimated_gas_used = multi_call_handler
-        .estimate_transaction_cost(Some(tolerance))
+        .estimate_transaction_cost(tolerance, block_horizon)
         .await?
         .gas_used;
 
@@ -621,8 +613,9 @@ async fn test_connect_wallet() -> Result<()> {
 
     // pay for call with wallet
     let tx_policies = TxPolicies::default()
-        .with_gas_price(10)
+        .with_tip(100)
         .with_script_gas_limit(1_000_000);
+
     contract_instance
         .methods()
         .initialize_counter(42)
@@ -648,6 +641,7 @@ async fn test_connect_wallet() -> Result<()> {
     let wallet_2_balance = wallet_2.get_asset_balance(&Default::default()).await?;
     assert_eq!(wallet_balance_second_call, wallet_balance);
     assert!(DEFAULT_COIN_AMOUNT > wallet_2_balance);
+
     Ok(())
 }
 
@@ -1420,7 +1414,6 @@ fn db_rocksdb() {
                 .await?
                 .results;
 
-            assert_eq!(provider.chain_info().await?.name, temp_dir_name);
             assert_eq!(blocks.len(), 3);
             assert_eq!(
                 *wallet.get_balances().await?.iter().next().unwrap().1,
diff --git a/packages/fuels/tests/predicates.rs b/packages/fuels/tests/predicates.rs
index e417ae471c..d9d169a6e9 100644
--- a/packages/fuels/tests/predicates.rs
+++ b/packages/fuels/tests/predicates.rs
@@ -215,7 +215,7 @@ async fn pay_with_predicate() -> Result<()> {
 
     let contract_methods = MyContract::new(contract_id.clone(), predicate.clone()).methods();
     let tx_policies = TxPolicies::default()
-        .with_gas_price(1)
+        .with_tip(1)
         .with_script_gas_limit(1_000_000);
 
     assert_eq!(predicate.get_asset_balance(&BASE_ASSET_ID).await?, 192);
@@ -270,7 +270,7 @@ async fn pay_with_predicate_vector_data() -> Result<()> {
 
     let contract_methods = MyContract::new(contract_id.clone(), predicate.clone()).methods();
     let tx_policies = TxPolicies::default()
-        .with_gas_price(1)
+        .with_tip(1)
         .with_script_gas_limit(1_000_000);
 
     assert_eq!(predicate.get_asset_balance(&BASE_ASSET_ID).await?, 192);
@@ -506,9 +506,10 @@ async fn contract_tx_and_call_params_with_predicate() -> Result<()> {
     .deploy(&predicate, TxPolicies::default())
     .await?;
     println!("Contract deployed @ {contract_id}");
+
     let contract_methods = MyContract::new(contract_id.clone(), predicate.clone()).methods();
 
-    let tx_policies = TxPolicies::default().with_gas_price(1);
+    let tx_policies = TxPolicies::default().with_tip(100);
 
     let call_params_amount = 100;
     let call_params = CallParameters::default()
@@ -525,7 +526,7 @@ async fn contract_tx_and_call_params_with_predicate() -> Result<()> {
 
         assert_eq!(
             predicate.get_asset_balance(&AssetId::default()).await?,
-            1899
+            1800
         );
     }
     {
@@ -686,7 +687,7 @@ async fn predicate_adjust_fee_persists_message_w_data() -> Result<()> {
     let mut tb = ScriptTransactionBuilder::prepare_transfer(
         vec![message_input.clone()],
         vec![],
-        TxPolicies::default().with_gas_price(1),
+        TxPolicies::default().with_tip(1),
     );
     predicate.adjust_for_fee(&mut tb, 1000).await?;
     let tx = tb.build(&provider).await?;
@@ -739,7 +740,7 @@ async fn predicate_transfer_non_base_asset() -> Result<()> {
     let mut tb = ScriptTransactionBuilder::prepare_transfer(
         inputs,
         outputs,
-        TxPolicies::default().with_gas_price(1),
+        TxPolicies::default().with_tip(1),
     );
 
     tb.add_signer(wallet.clone())?;
diff --git a/packages/fuels/tests/providers.rs b/packages/fuels/tests/providers.rs
index 06307452ba..c4632f4a95 100644
--- a/packages/fuels/tests/providers.rs
+++ b/packages/fuels/tests/providers.rs
@@ -476,7 +476,7 @@ async fn test_gas_errors() -> Result<()> {
 
     //  Test that the call will use more gas than the gas limit
     let gas_used = contract_instance_call
-        .estimate_transaction_cost(None)
+        .estimate_transaction_cost(None, None)
         .await?
         .gas_used;
     assert!(gas_used > gas_limit);
@@ -493,7 +493,7 @@ async fn test_gas_errors() -> Result<()> {
     let response = contract_instance
         .methods()
         .initialize_counter(42) // Build the ABI call
-        .with_tx_policies(TxPolicies::default().with_gas_price(100_000_000_000))
+        .with_tx_policies(TxPolicies::default().with_tip(100_000_000_000))
         .call()
         .await
         .expect_err("should error");
@@ -604,9 +604,7 @@ async fn testnet_hello_world() -> Result<()> {
     let salt: [u8; 32] = rng.gen();
     let configuration = LoadConfiguration::default().with_salt(salt);
 
-    let tx_policies = TxPolicies::default()
-        .with_gas_price(1)
-        .with_script_gas_limit(2000);
+    let tx_policies = TxPolicies::default().with_script_gas_limit(2000);
 
     let contract_id = Contract::load_from(
         "tests/contracts/contract_test/out/debug/contract_test.bin",
@@ -641,9 +639,7 @@ async fn test_parse_block_time() -> Result<()> {
     let coins = setup_single_asset_coins(wallet.address(), AssetId::BASE, 1, DEFAULT_COIN_AMOUNT);
     let provider = setup_test_provider(coins.clone(), vec![], None, None).await?;
     wallet.set_provider(provider);
-    let tx_policies = TxPolicies::default()
-        .with_gas_price(1)
-        .with_script_gas_limit(2000);
+    let tx_policies = TxPolicies::default().with_script_gas_limit(2000);
 
     let wallet_2 = WalletUnlocked::new_random(None).lock();
     let (tx_id, _) = wallet
@@ -651,17 +647,15 @@ async fn test_parse_block_time() -> Result<()> {
         .await?;
 
     let tx_response = wallet
-        .try_provider()
-        .unwrap()
+        .try_provider()?
         .get_transaction_by_id(&tx_id)
         .await?
         .unwrap();
     assert!(tx_response.time.is_some());
 
     let block = wallet
-        .try_provider()
-        .unwrap()
-        .block(&tx_response.block_id.unwrap())
+        .try_provider()?
+        .block_by_height(tx_response.block_height.unwrap())
         .await?
         .unwrap();
     assert!(block.header.time.is_some());
diff --git a/packages/fuels/tests/scripts.rs b/packages/fuels/tests/scripts.rs
index d95bf67e88..40e58fcce8 100644
--- a/packages/fuels/tests/scripts.rs
+++ b/packages/fuels/tests/scripts.rs
@@ -45,19 +45,21 @@ async fn script_call_has_same_estimated_and_used_gas() -> Result<()> {
         )
     );
 
-    let tolerance = 0.0;
+    let tolerance = Some(0.0);
+    let block_horizon = Some(1);
 
     let a = 4u64;
     let b = 2u32;
     let estimated_gas_used = script_instance
         .main(a, b)
-        .estimate_transaction_cost(Some(tolerance))
+        .estimate_transaction_cost(tolerance, block_horizon)
         .await?
         .gas_used;
 
     let gas_used = script_instance.main(a, b).call().await?.gas_used;
 
     assert_eq!(estimated_gas_used, gas_used);
+
     Ok(())
 }
 
@@ -82,9 +84,7 @@ async fn test_basic_script_with_tx_policies() -> Result<()> {
     assert_eq!(result.value, "hello");
 
     // ANCHOR: script_with_tx_policies
-    let tx_policies = TxPolicies::default()
-        .with_gas_price(1)
-        .with_script_gas_limit(1_000_000);
+    let tx_policies = TxPolicies::default().with_script_gas_limit(1_000_000);
     let result = script_instance
         .main(a, b)
         .with_tx_policies(tx_policies)
diff --git a/packages/fuels/tests/wallets.rs b/packages/fuels/tests/wallets.rs
index 6ef3906e16..717e213598 100644
--- a/packages/fuels/tests/wallets.rs
+++ b/packages/fuels/tests/wallets.rs
@@ -80,7 +80,6 @@ fn compare_inputs(inputs: &[Input], expected_inputs: &mut Vec<Input>) -> bool {
                 asset_id,
                 tx_pointer,
                 witness_index,
-                maturity,
                 ..
             }) => Input::coin_signed(
                 zero_utxo_id,
@@ -89,7 +88,6 @@ fn compare_inputs(inputs: &[Input], expected_inputs: &mut Vec<Input>) -> bool {
                 *asset_id,
                 *tx_pointer,
                 *witness_index,
-                *maturity,
             ),
             other => other.clone(),
         })
@@ -149,7 +147,6 @@ async fn adjust_fee_empty_transaction() -> Result<()> {
         BASE_ASSET_ID,
         TxPointer::default(),
         0,
-        0u32.into(),
     )];
     let expected_outputs = vec![Output::change(wallet.address().into(), 0, BASE_ASSET_ID)];
 
@@ -189,7 +186,6 @@ async fn adjust_fee_resources_to_transfer_with_base_asset() -> Result<()> {
         BASE_ASSET_ID,
         TxPointer::default(),
         0,
-        0u32.into(),
     ))
     .take(3)
     .collect::<Vec<_>>();
@@ -245,14 +241,14 @@ async fn send_transfer_transactions() -> Result<()> {
     const AMOUNT: u64 = 5;
     let (wallet_1, wallet_2) = setup_transfer_test(AMOUNT).await?;
 
-    // Configure transaction policies.
-    let gas_price = 1;
+    // Configure transaction policies
+    let tip = 2;
     let script_gas_limit = 500_000;
     let expected_script_gas_limit = 0;
     let maturity = 0;
 
     let tx_policies = TxPolicies::default()
-        .with_gas_price(gas_price)
+        .with_tip(tip)
         .with_maturity(maturity)
         .with_script_gas_limit(script_gas_limit);
 
@@ -275,7 +271,6 @@ async fn send_transfer_transactions() -> Result<()> {
     };
     // Transfer scripts have `script_gas_limit` set to `0`
     assert_eq!(script.gas_limit(), expected_script_gas_limit);
-    assert_eq!(script.gas_price(), gas_price);
     assert_eq!(script.maturity(), maturity as u32);
 
     let wallet_1_spendable_resources = wallet_1.get_spendable_resources(BASE_ASSET_ID, 1).await?;