diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3dcf78e25b..ea2577c450 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.24.3
+  FUEL_CORE_VERSION: 0.26.0
   FUEL_CORE_PATCH_BRANCH:
   RUST_VERSION: 1.76.0
   FORC_VERSION: 0.56.0
diff --git a/Cargo.toml b/Cargo.toml
index 03797675e5..2bf4de6fe3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -53,7 +53,10 @@ itertools = "0.12.0"
 portpicker = "0.1.1"
 proc-macro2 = "1.0.70"
 quote = "1.0.33"
-rand = { version = "0.8.5", default-features = false, features = ["std_rng", "getrandom"] }
+rand = { version = "0.8.5", default-features = false, features = [
+  "std_rng",
+  "getrandom",
+] }
 regex = "1.10.2"
 semver = "1.0.20"
 serde = { version = "1.0.193", default-features = false }
@@ -72,21 +75,21 @@ which = { version = "6.0.0", default-features = false }
 zeroize = "1.7.0"
 
 # Dependencies from the `fuel-core` repository:
-fuel-core = { version = "0.24.3", default-features = false }
-fuel-core-chain-config = { version = "0.24.3", default-features = false }
-fuel-core-client = { version = "0.24.3", default-features = false }
-fuel-core-poa = { version = "0.24.3", default-features = false }
-fuel-core-services = { version = "0.24.3", default-features = false }
-fuel-core-types = { version = "0.24.3", default-features = false }
+fuel-core = { version = "0.26.0", default-features = false }
+fuel-core-chain-config = { version = "0.26.0", default-features = false }
+fuel-core-client = { version = "0.26.0", default-features = false }
+fuel-core-poa = { version = "0.26.0", default-features = false }
+fuel-core-services = { version = "0.26.0", default-features = false }
+fuel-core-types = { version = "0.26.0", default-features = false }
 
 # Dependencies from the `fuel-vm` repository:
-fuel-asm = { version = "0.48.0" }
-fuel-crypto = { version = "0.48.0" }
-fuel-merkle = { version = "0.48.0" }
-fuel-storage = { version = "0.48.0" }
-fuel-tx = { version = "0.48.0" }
-fuel-types = { version = "0.48.0" }
-fuel-vm = { version = "0.48.0" }
+fuel-asm = { version = "0.49.0" }
+fuel-crypto = { version = "0.49.0" }
+fuel-merkle = { version = "0.49.0" }
+fuel-storage = { version = "0.49.0" }
+fuel-tx = { version = "0.49.0" }
+fuel-types = { version = "0.49.0" }
+fuel-vm = { version = "0.49.0" }
 
 # Workspace projects
 fuels = { version = "0.59.0", path = "./packages/fuels" }
diff --git a/packages/fuels-accounts/src/provider.rs b/packages/fuels-accounts/src/provider.rs
index be4915075b..c5bbcac218 100644
--- a/packages/fuels-accounts/src/provider.rs
+++ b/packages/fuels-accounts/src/provider.rs
@@ -291,7 +291,9 @@ impl Provider {
                 TransactionExecutionResult::Success { receipts, .. } => {
                     TxStatus::Success { receipts }
                 }
-                TransactionExecutionResult::Failed { receipts, result } => TxStatus::Revert {
+                TransactionExecutionResult::Failed {
+                    receipts, result, ..
+                } => TxStatus::Revert {
                     reason: TransactionExecutionResult::reason(&receipts, &result),
                     receipts,
                     revert_id: 0,
diff --git a/packages/fuels-accounts/src/provider/supported_versions.rs b/packages/fuels-accounts/src/provider/supported_versions.rs
index 0cc09b892a..d5d55761f7 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.24.2".parse().expect("is valid version")
+    "0.26.0".parse().expect("is valid version")
 }
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/packages/fuels-core/src/codec/abi_encoder/configurables_bounded_encoder.rs b/packages/fuels-core/src/codec/abi_encoder/configurables_bounded_encoder.rs
index 4ef443a5c9..b932dac865 100644
--- a/packages/fuels-core/src/codec/abi_encoder/configurables_bounded_encoder.rs
+++ b/packages/fuels-core/src/codec/abi_encoder/configurables_bounded_encoder.rs
@@ -241,7 +241,7 @@ impl ConfigurablesBoundedEncoder {
     fn encode_raw_slice(mut data: Vec<u8>) -> Result<Vec<Data>> {
         let len = data.len();
 
-        zeropad_to_word_alignment(&mut data);
+        zeropad_to_word_alignment(&mut data)?;
 
         let encoded_data = vec![Data::Inline(data)];
 
@@ -261,15 +261,14 @@ impl ConfigurablesBoundedEncoder {
     }
 
     fn encode_string_array(arg_string: &StaticStringToken) -> Result<Data> {
-        Ok(Data::Inline(crate::types::pad_string(
-            arg_string.get_encodable_str()?,
-        )))
+        let padded = crate::types::pad_string(arg_string.get_encodable_str()?)?;
+        Ok(Data::Inline(padded))
     }
 
     fn encode_bytes(mut data: Vec<u8>) -> Result<Vec<Data>> {
         let len = data.len();
 
-        zeropad_to_word_alignment(&mut data);
+        zeropad_to_word_alignment(&mut data)?;
 
         let cap = data.len() as u64;
         let encoded_data = vec![Data::Inline(data)];
@@ -282,7 +281,11 @@ impl ConfigurablesBoundedEncoder {
     }
 }
 
-fn zeropad_to_word_alignment(data: &mut Vec<u8>) {
-    let padded_length = padded_len_usize(data.len());
+fn zeropad_to_word_alignment(data: &mut Vec<u8>) -> Result<()> {
+    let padded_length = padded_len_usize(data.len())
+        .ok_or_else(|| error!(Codec, "data length exceeds maximum allowed length"))?;
+
     data.resize(padded_length, 0);
+
+    Ok(())
 }
diff --git a/packages/fuels-core/src/types.rs b/packages/fuels-core/src/types.rs
index c79c5b9366..6f6b0e5c67 100644
--- a/packages/fuels-core/src/types.rs
+++ b/packages/fuels-core/src/types.rs
@@ -5,6 +5,7 @@ pub use fuel_types::{
 };
 
 pub use crate::types::{core::*, token::*, wrappers::*};
+use crate::{error, types::errors::Result};
 
 pub mod bech32;
 mod core;
@@ -33,12 +34,14 @@ pub fn pad_u32(value: u32) -> ByteArray {
     padded
 }
 
-pub fn pad_string(s: &str) -> Vec<u8> {
-    let pad = padded_len(s.as_bytes()) - s.len();
+pub fn pad_string(s: &str) -> Result<Vec<u8>> {
+    let padded_len =
+        padded_len(s.as_bytes()).ok_or_else(|| error!(Codec, "string is too long to be padded"))?;
+    let pad = padded_len - s.len();
 
     let mut padded = s.as_bytes().to_owned();
 
     padded.extend_from_slice(&vec![0; pad]);
 
-    padded
+    Ok(padded)
 }
diff --git a/packages/fuels-core/src/types/core/raw_slice.rs b/packages/fuels-core/src/types/core/raw_slice.rs
index 0eb37a8fe7..859081c372 100644
--- a/packages/fuels-core/src/types/core/raw_slice.rs
+++ b/packages/fuels-core/src/types/core/raw_slice.rs
@@ -1,6 +1,4 @@
 #[derive(Debug, PartialEq, Clone, Eq)]
-// `RawSlice` is a mapping of the contract type "untyped raw slice" -- currently the only way of
-// returning dynamically sized data from a script.
 pub struct RawSlice(pub Vec<u8>);
 
 impl From<RawSlice> for Vec<u8> {
diff --git a/packages/fuels-core/src/types/core/u256.rs b/packages/fuels-core/src/types/core/u256.rs
index d2f504918f..d869c6f778 100644
--- a/packages/fuels-core/src/types/core/u256.rs
+++ b/packages/fuels-core/src/types/core/u256.rs
@@ -13,7 +13,6 @@ use crate::{
 };
 
 construct_uint! {
-    /// 256-bit unsigned integer.
     pub struct U256(4);
 }
 
diff --git a/packages/fuels-core/src/types/transaction_builders.rs b/packages/fuels-core/src/types/transaction_builders.rs
index ff70d70db1..96288a0979 100644
--- a/packages/fuels-core/src/types/transaction_builders.rs
+++ b/packages/fuels-core/src/types/transaction_builders.rs
@@ -21,7 +21,7 @@ use itertools::Itertools;
 
 use crate::{
     constants::{SIGNATURE_WITNESS_SIZE, WITNESS_STATIC_SIZE, WORD_SIZE},
-    offsets,
+    error, offsets,
     traits::Signer,
     types::{
         bech32::Bech32Address,
@@ -263,22 +263,19 @@ macro_rules! impl_tx_trait {
                     .collect();
             }
 
-            fn generate_fuel_policies(&self) -> Policies {
-                let mut policies = Policies::default();
+            fn generate_fuel_policies(&self) -> Result<Policies> {
+                let witness_limit = match self.tx_policies.witness_limit() {
+                    Some(limit) => limit,
+                    None => self.calculate_witnesses_size()?,
+                };
+                let mut policies = Policies::default().with_witness_limit(witness_limit);
+
                 // `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
-                    .tx_policies
-                    .witness_limit()
-                    .or_else(|| self.calculate_witnesses_size());
-                policies.set(PolicyType::WitnessLimit, witness_limit);
-
                 policies.set(PolicyType::Tip, self.tx_policies.tip());
 
-                policies
+                Ok(policies)
             }
 
             fn is_using_predicates(&self) -> bool {
@@ -300,12 +297,14 @@ macro_rules! impl_tx_trait {
                 Ok(num_witnesses as u16)
             }
 
-            fn calculate_witnesses_size(&self) -> Option<u64> {
+            fn calculate_witnesses_size(&self) -> Result<u64> {
                 let witnesses_size = calculate_witnesses_size(&self.witnesses);
                 let signature_size = SIGNATURE_WITNESS_SIZE
                     * self.unresolved_witness_indexes.owner_to_idx_offset.len();
 
-                Some(padded_len_usize(witnesses_size + signature_size) as u64)
+                let padded_len = padded_len_usize(witnesses_size + signature_size)
+                    .ok_or_else(|| error!(Other, "witnesses size overflow"))?;
+                Ok(padded_len as u64)
             }
 
             async fn set_max_fee_policy<T: PoliciesField + Chargeable>(
@@ -380,7 +379,7 @@ impl ScriptTransactionBuilder {
     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())
+            self.base_offset(provider.consensus_parameters())?
         } else {
             0
         };
@@ -473,7 +472,7 @@ impl ScriptTransactionBuilder {
 
     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();
+        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);
@@ -523,10 +522,15 @@ impl ScriptTransactionBuilder {
         Ok(tx)
     }
 
-    fn base_offset(&self, consensus_parameters: &ConsensusParameters) -> usize {
-        offsets::base_offset_script(consensus_parameters)
-            + padded_len_usize(self.script_data.len())
-            + padded_len_usize(self.script.len())
+    fn base_offset(&self, consensus_parameters: &ConsensusParameters) -> Result<usize> {
+        let padded_script_data_len = padded_len_usize(self.script_data.len())
+            .ok_or_else(|| error!(Other, "script data len overflow {}", self.script_data.len()))?;
+        let padded_script_len = padded_len_usize(self.script.len())
+            .ok_or_else(|| error!(Other, "script len overflow {}", self.script.len()))?;
+
+        Ok(offsets::base_offset_script(consensus_parameters)
+            + padded_script_data_len
+            + padded_script_len)
     }
 
     pub fn with_script(mut self, script: Vec<u8>) -> Self {
@@ -680,7 +684,7 @@ impl CreateTransactionBuilder {
         provider: impl DryRunner,
     ) -> Result<Create> {
         let num_witnesses = self.num_witnesses()?;
-        let policies = self.generate_fuel_policies();
+        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();
@@ -840,7 +844,7 @@ fn resolve_signed_resource(
                 })
         }
         CoinType::Message(message) => {
-            *data_offset += offsets::message_signed_data_offset(message.data.len());
+            *data_offset += offsets::message_signed_data_offset(message.data.len())?;
             let recipient = &message.recipient;
 
             unresolved_witness_indexes
@@ -865,7 +869,7 @@ fn resolve_predicate_resource(
 ) -> Result<FuelInput> {
     match resource {
         CoinType::Coin(coin) => {
-            *data_offset += offsets::coin_predicate_data_offset(code.len());
+            *data_offset += offsets::coin_predicate_data_offset(code.len())?;
 
             let data = data.resolve(*data_offset as u64);
             *data_offset += data.len();
@@ -874,7 +878,7 @@ fn resolve_predicate_resource(
             Ok(create_coin_predicate(coin, asset_id, code, data))
         }
         CoinType::Message(message) => {
-            *data_offset += offsets::message_predicate_data_offset(message.data.len(), code.len());
+            *data_offset += offsets::message_predicate_data_offset(message.data.len(), code.len())?;
 
             let data = data.resolve(*data_offset as u64);
             *data_offset += data.len();
diff --git a/packages/fuels-core/src/types/wrappers/block.rs b/packages/fuels-core/src/types/wrappers/block.rs
index 1877c8ca1e..f224942924 100644
--- a/packages/fuels-core/src/types/wrappers/block.rs
+++ b/packages/fuels-core/src/types/wrappers/block.rs
@@ -10,8 +10,8 @@ use fuel_core_client::client::types::{
 pub struct Header {
     pub id: Bytes32,
     pub da_height: u64,
-    pub transactions_count: u64,
-    pub message_receipt_count: u64,
+    pub transactions_count: u16,
+    pub message_receipt_count: u32,
     pub transactions_root: Bytes32,
     pub message_outbox_root: Bytes32,
     pub event_inbox_root: Bytes32,
diff --git a/packages/fuels-core/src/types/wrappers/message.rs b/packages/fuels-core/src/types/wrappers/message.rs
index 9db100eef7..a8079ac941 100644
--- a/packages/fuels-core/src/types/wrappers/message.rs
+++ b/packages/fuels-core/src/types/wrappers/message.rs
@@ -2,9 +2,10 @@
 
 use fuel_core_chain_config::MessageConfig;
 use fuel_core_client::client::types::{
-    coins::MessageCoin as ClientMessageCoin, message::Message as ClientMessage, primitives::Nonce,
+    coins::MessageCoin as ClientMessageCoin, message::Message as ClientMessage,
 };
 use fuel_tx::{Input, MessageId};
+use fuel_types::Nonce;
 
 use crate::types::bech32::Bech32Address;
 
diff --git a/packages/fuels-core/src/types/wrappers/transaction.rs b/packages/fuels-core/src/types/wrappers/transaction.rs
index 4c51261723..ddb064d1b4 100644
--- a/packages/fuels-core/src/types/wrappers/transaction.rs
+++ b/packages/fuels-core/src/types/wrappers/transaction.rs
@@ -15,7 +15,7 @@ use fuel_tx::{
     },
     Bytes32, Cacheable, Chargeable, ConsensusParameters, Create, FormatValidityChecks, Input, Mint,
     Output, Salt as FuelSalt, Script, StorageSlot, Transaction as FuelTransaction, TransactionFee,
-    UniqueIdentifier, Witness,
+    UniqueIdentifier, Upgrade, Upload, Witness,
 };
 use fuel_types::{bytes::padded_len_usize, AssetId, ChainId};
 use fuel_vm::checked_transaction::{
@@ -27,7 +27,7 @@ use crate::{
     traits::Signer,
     types::{
         bech32::Bech32Address,
-        errors::{error_transaction, Result},
+        errors::{error, error_transaction, Result},
     },
     utils::{calculate_witnesses_size, sealed},
 };
@@ -102,6 +102,84 @@ impl MintTransaction {
     }
 }
 
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct UploadTransaction {
+    tx: Box<Upload>,
+}
+
+impl From<UploadTransaction> for FuelTransaction {
+    fn from(upload: UploadTransaction) -> Self {
+        (*upload.tx).into()
+    }
+}
+
+impl From<UploadTransaction> for Upload {
+    fn from(tx: UploadTransaction) -> Self {
+        *tx.tx
+    }
+}
+
+impl From<Upload> for UploadTransaction {
+    fn from(tx: Upload) -> Self {
+        Self { tx: Box::new(tx) }
+    }
+}
+
+impl UploadTransaction {
+    pub fn check_without_signatures(
+        &self,
+        block_height: u32,
+        consensus_parameters: &ConsensusParameters,
+    ) -> Result<()> {
+        Ok(self
+            .tx
+            .check_without_signatures(block_height.into(), consensus_parameters)?)
+    }
+    #[must_use]
+    pub fn id(&self, chain_id: ChainId) -> Bytes32 {
+        self.tx.id(&chain_id)
+    }
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct UpgradeTransaction {
+    tx: Upgrade,
+}
+
+impl From<UpgradeTransaction> for FuelTransaction {
+    fn from(upload: UpgradeTransaction) -> Self {
+        upload.tx.into()
+    }
+}
+
+impl From<UpgradeTransaction> for Upgrade {
+    fn from(tx: UpgradeTransaction) -> Self {
+        tx.tx
+    }
+}
+
+impl From<Upgrade> for UpgradeTransaction {
+    fn from(tx: Upgrade) -> Self {
+        Self { tx }
+    }
+}
+
+impl UpgradeTransaction {
+    pub fn check_without_signatures(
+        &self,
+        block_height: u32,
+        consensus_parameters: &ConsensusParameters,
+    ) -> Result<()> {
+        Ok(self
+            .tx
+            .check_without_signatures(block_height.into(), consensus_parameters)?)
+    }
+    #[must_use]
+    pub fn id(&self, chain_id: ChainId) -> Bytes32 {
+        self.tx.id(&chain_id)
+    }
+}
+
 #[derive(Default, Debug, Copy, Clone)]
 //ANCHOR: tx_policies_struct
 pub struct TxPolicies {
@@ -185,6 +263,8 @@ pub enum TransactionType {
     Script(ScriptTransaction),
     Create(CreateTransaction),
     Mint(MintTransaction),
+    Upload(UploadTransaction),
+    Upgrade(UpgradeTransaction),
 }
 
 pub trait EstimablePredicates: sealed::Sealed {
@@ -273,6 +353,8 @@ impl From<TransactionType> for FuelTransaction {
             TransactionType::Script(tx) => tx.into(),
             TransactionType::Create(tx) => tx.into(),
             TransactionType::Mint(tx) => tx.into(),
+            TransactionType::Upload(tx) => tx.into(),
+            TransactionType::Upgrade(tx) => tx.into(),
         }
     }
 }
@@ -426,9 +508,12 @@ macro_rules! impl_tx_wrapper {
             }
 
             fn append_witness(&mut self, witness: Witness) -> Result<usize> {
-                let new_witnesses_size = padded_len_usize(calculate_witnesses_size(
+                let witness_size = calculate_witnesses_size(
                     self.tx.witnesses().iter().chain(std::iter::once(&witness)),
-                )) as u64;
+                );
+                let new_witnesses_size = padded_len_usize(witness_size)
+                    .ok_or_else(|| error!(Other, "witness size overflow: {witness_size}"))?
+                    as u64;
 
                 if new_witnesses_size > self.tx.witness_limit() {
                     Err(error_transaction!(
diff --git a/packages/fuels-core/src/types/wrappers/transaction_response.rs b/packages/fuels-core/src/types/wrappers/transaction_response.rs
index 90bd5413de..5b797057e1 100644
--- a/packages/fuels-core/src/types/wrappers/transaction_response.rs
+++ b/packages/fuels-core/src/types/wrappers/transaction_response.rs
@@ -42,6 +42,8 @@ impl From<ClientTransactionResponse> for TransactionResponse {
             Transaction::Script(tx) => TransactionType::Script(ScriptTransaction::from(tx)),
             Transaction::Create(tx) => TransactionType::Create(CreateTransaction::from(tx)),
             Transaction::Mint(tx) => TransactionType::Mint(tx.into()),
+            Transaction::Upgrade(tx) => TransactionType::Upgrade(tx.into()),
+            Transaction::Upload(tx) => TransactionType::Upload(tx.into()),
         };
 
         Self {
diff --git a/packages/fuels-core/src/utils/offsets.rs b/packages/fuels-core/src/utils/offsets.rs
index 2228a93537..15418eb33e 100644
--- a/packages/fuels-core/src/utils/offsets.rs
+++ b/packages/fuels-core/src/utils/offsets.rs
@@ -1,3 +1,4 @@
+use crate::{error, types::errors::Result};
 use fuel_asm::Instruction;
 use fuel_tx::{
     field::{Script, StorageSlots},
@@ -25,27 +26,45 @@ pub fn base_offset_create(consensus_parameters: &ConsensusParameters) -> usize {
 pub fn call_script_data_offset(
     consensus_parameters: &ConsensusParameters,
     calls_instructions_len: usize,
-) -> usize {
+) -> Result<usize> {
     // Instruction::SIZE is a placeholder for the RET instruction which is added later for returning
     // from the script. This doesn't happen in the predicate.
     let opcode_len = Instruction::SIZE;
 
-    base_offset_script(consensus_parameters) + padded_len_usize(calls_instructions_len + opcode_len)
+    let padded_len = padded_len_usize(calls_instructions_len + opcode_len).ok_or_else(|| {
+        error!(
+            Other,
+            "call script data len overflow: {calls_instructions_len}"
+        )
+    })?;
+    Ok(base_offset_script(consensus_parameters) + padded_len)
 }
 
-pub fn coin_predicate_data_offset(code_len: usize) -> usize {
-    InputRepr::Coin
+pub fn coin_predicate_data_offset(code_len: usize) -> Result<usize> {
+    let code_len_padded = padded_len_usize(code_len)
+        .ok_or_else(|| error!(Other, "coin predicate code len overflow: {code_len}"))?;
+
+    Ok(InputRepr::Coin
         .coin_predicate_offset()
         .expect("should have predicate offset")
-        + padded_len_usize(code_len)
+        + code_len_padded)
 }
 
-pub fn message_predicate_data_offset(message_data_len: usize, code_len: usize) -> usize {
-    InputRepr::Message
+pub fn message_predicate_data_offset(message_data_len: usize, code_len: usize) -> Result<usize> {
+    let data_len_padded = padded_len_usize(message_data_len).ok_or_else(|| {
+        error!(
+            Other,
+            "message predicate data len overflow: {message_data_len}"
+        )
+    })?;
+    let code_len_padded = padded_len_usize(code_len)
+        .ok_or_else(|| error!(Other, "message predicate code len overflow: {code_len}"))?;
+
+    Ok(InputRepr::Message
         .data_offset()
         .expect("should have data offset")
-        + padded_len_usize(message_data_len)
-        + padded_len_usize(code_len)
+        + data_len_padded
+        + code_len_padded)
 }
 
 pub fn coin_signed_data_offset() -> usize {
@@ -54,11 +73,18 @@ pub fn coin_signed_data_offset() -> usize {
         .expect("should have coin offset")
 }
 
-pub fn message_signed_data_offset(message_data_len: usize) -> usize {
-    InputRepr::Message
+pub fn message_signed_data_offset(message_data_len: usize) -> Result<usize> {
+    let padded_len = padded_len_usize(message_data_len).ok_or_else(|| {
+        error!(
+            Other,
+            "signed message data len overflow: {message_data_len}"
+        )
+    })?;
+
+    Ok(InputRepr::Message
         .data_offset()
         .expect("should have data offset")
-        + padded_len_usize(message_data_len)
+        + padded_len)
 }
 
 pub fn contract_input_offset() -> usize {
diff --git a/packages/fuels-programs/src/call_utils.rs b/packages/fuels-programs/src/call_utils.rs
index 9fb31d320f..6d9b749946 100644
--- a/packages/fuels-programs/src/call_utils.rs
+++ b/packages/fuels-programs/src/call_utils.rs
@@ -112,7 +112,7 @@ pub(crate) async fn transaction_builder_from_contract_calls(
     let calls_instructions_len = compute_calls_instructions_len(calls)?;
     let provider = account.try_provider()?;
     let consensus_parameters = provider.consensus_parameters();
-    let data_offset = call_script_data_offset(consensus_parameters, calls_instructions_len);
+    let data_offset = call_script_data_offset(consensus_parameters, calls_instructions_len)?;
 
     let (script_data, call_param_offsets) =
         build_script_data_from_contract_calls(calls, data_offset, *provider.base_asset_id())?;
diff --git a/packages/fuels-programs/src/script_calls.rs b/packages/fuels-programs/src/script_calls.rs
index 6a6bfa64eb..179d766e8c 100644
--- a/packages/fuels-programs/src/script_calls.rs
+++ b/packages/fuels-programs/src/script_calls.rs
@@ -165,8 +165,9 @@ where
     /// Compute the script data by calculating the script offset and resolving the encoded arguments
     async fn compute_script_data(&self) -> Result<Vec<u8>> {
         let consensus_parameters = self.provider.consensus_parameters();
-        let script_offset = base_offset_script(consensus_parameters)
-            + padded_len_usize(self.script_call.script_binary.len());
+        let padded_script_len = padded_len_usize(self.script_call.script_binary.len())
+            .ok_or_else(|| error!(Other, "script is too long"))?;
+        let script_offset = base_offset_script(consensus_parameters) + padded_script_len;
         self.script_call
             .encoded_args
             .as_ref()
diff --git a/packages/fuels-test-helpers/src/fuel_bin_service.rs b/packages/fuels-test-helpers/src/fuel_bin_service.rs
index 486256928d..bfa9c0dd4b 100644
--- a/packages/fuels-test-helpers/src/fuel_bin_service.rs
+++ b/packages/fuels-test-helpers/src/fuel_bin_service.rs
@@ -91,12 +91,9 @@ impl ExtendedConfig {
     }
 
     pub fn write_temp_snapshot_files(self) -> FuelResult<TempDir> {
-        let mut writer = SnapshotWriter::json(self.snapshot_dir.path());
+        let writer = SnapshotWriter::json(self.snapshot_dir.path());
         writer
-            .write_chain_config(&self.chain_config)
-            .map_err(|e| error!(Other, "could not write chain config: {}", e))?;
-        writer
-            .write_state_config(self.state_config)
+            .write_state_config(self.state_config, &self.chain_config)
             .map_err(|e| error!(Other, "could not write state config: {}", e))?;
 
         Ok(self.snapshot_dir)
diff --git a/packages/fuels/tests/providers.rs b/packages/fuels/tests/providers.rs
index 5ca9aaf143..0402e34c8b 100644
--- a/packages/fuels/tests/providers.rs
+++ b/packages/fuels/tests/providers.rs
@@ -447,6 +447,7 @@ async fn test_amount_and_asset_forwarding() -> Result<()> {
         call_response.unwrap().asset_id().unwrap(),
         &AssetId::from(*contract_id.hash())
     );
+
     Ok(())
 }