fix: configurables encoding to have top level u8 and bool single-byte optimizations (#1294)

ConfigurablesEncoder now present enabling top-level byte or bool single-byte optimizations needed for encoding configurables.

Co-authored-by: hal3e <[email protected]>

Author: segfault-magnet

packages/fuels-code-gen/src/program_bindings/abigen/configurables.rs

@@ -51,7 +51,7 @@ fn generate_struct_decl(configurable_struct_name: &Ident) -> TokenStream {
         #[derive(Clone, Debug, Default)]
         pub struct #configurable_struct_name {
             offsets_with_data: ::std::vec::Vec<(u64, ::std::vec::Vec<u8>)>,
-            encoder: ::fuels::core::codec::ABIEncoder,
+            encoder: ::fuels::core::codec::ConfigurablesEncoder,
         }
     }
 }
@@ -66,7 +66,7 @@ fn generate_struct_impl(
         impl #configurable_struct_name {
             pub fn new(encoder_config: ::fuels::core::codec::EncoderConfig) -> Self {
                 Self {
-                    encoder: ::fuels::core::codec::ABIEncoder::new(encoder_config),
+                    encoder: ::fuels::core::codec::ConfigurablesEncoder::new(encoder_config),
                     ..::std::default::Default::default()
                 }
             }

packages/fuels-core/Cargo.toml

@@ -32,7 +32,7 @@ uint = { workspace = true, default-features = false }
 
 [dev-dependencies]
 fuels-macros = { workspace = true }
-tokio = { workspace = true, features = ["test-util"] }
+tokio = { workspace = true, features = ["test-util", "macros"] }
 
 [features]
 default = ["std"]

packages/fuels-core/src/codec/abi_encoder.rs

@@ -44,7 +44,24 @@ impl ABIEncoder {
     /// Encodes `Token`s in `args` following the ABI specs defined
     /// [here](https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/abi.md)
     pub fn encode(&self, args: &[Token]) -> Result<UnresolvedBytes> {
-        BoundedEncoder::new(self.config).encode(args)
+        BoundedEncoder::new(self.config, false).encode(args)
+    }
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct ConfigurablesEncoder {
+    pub config: EncoderConfig,
+}
+
+impl ConfigurablesEncoder {
+    pub fn new(config: EncoderConfig) -> Self {
+        Self { config }
+    }
+
+    /// Encodes `Token`s in `args` following the ABI specs defined
+    /// [here](https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/abi.md)
+    pub fn encode(&self, args: &[Token]) -> Result<UnresolvedBytes> {
+        BoundedEncoder::new(self.config, true).encode(args)
     }
 }
 
@@ -1122,7 +1139,31 @@ mod tests {
             .map(|fun| fun(MAX_DEPTH + 1))
             .for_each(|token| {
                 assert_encoding_failed(config, token, &msg);
-            })
+            });
+    }
+
+    #[test]
+    fn encoder_for_configurables_optimizes_top_level_u8() {
+        // given
+        let encoder = ConfigurablesEncoder::default();
+
+        // when
+        let encoded = encoder.encode(&[Token::U8(255)]).unwrap().resolve(0);
+
+        // then
+        assert_eq!(encoded, vec![255]);
+    }
+
+    #[test]
+    fn encoder_for_configurables_optimizes_top_level_bool() {
+        // given
+        let encoder = ConfigurablesEncoder::default();
+
+        // when
+        let encoded = encoder.encode(&[Token::Bool(true)]).unwrap().resolve(0);
+
+        // then
+        assert_eq!(encoded, vec![1]);
     }
 
     fn assert_encoding_failed(config: EncoderConfig, token: Token, msg: &str) {

packages/fuels-core/src/codec/abi_encoder/bounded_encoder.rs

@@ -16,13 +16,14 @@ use crate::{
 };
 
 pub(crate) struct BoundedEncoder {
+    used_for_configurables: bool,
     depth_tracker: CounterWithLimit,
     token_tracker: CounterWithLimit,
     max_total_enum_width: usize,
 }
 
 impl BoundedEncoder {
-    pub(crate) fn new(config: EncoderConfig) -> Self {
+    pub(crate) fn new(config: EncoderConfig, used_for_configurables: bool) -> Self {
         let depth_tracker =
             CounterWithLimit::new(config.max_depth, "depth", CodecDirection::Encoding);
         let token_tracker =
@@ -31,6 +32,7 @@ impl BoundedEncoder {
             depth_tracker,
             token_tracker,
             max_total_enum_width: config.max_total_enum_width,
+            used_for_configurables,
         }
     }
 
@@ -41,8 +43,16 @@ impl BoundedEncoder {
         // going through the whole array of tokens, which can be pretty inefficient.
         let data = if args.len() == 1 {
             match args[0] {
-                Token::Bool(arg_bool) => vec![Self::encode_bool_as_u64(arg_bool)],
+                Token::U8(arg_u8) if self.used_for_configurables => {
+                    vec![Self::encode_u8_as_byte(arg_u8)]
+                }
                 Token::U8(arg_u8) => vec![Self::encode_u8_as_u64(arg_u8)],
+                Token::Bool(arg_bool) if self.used_for_configurables => {
+                    vec![Self::encode_bool_as_byte(arg_bool)]
+                }
+                Token::Bool(arg_bool) => {
+                    vec![Self::encode_bool_as_u64(arg_bool)]
+                }
                 _ => self.encode_tokens(args, true)?,
             }
         } else {
@@ -56,10 +66,10 @@ impl BoundedEncoder {
         let mut offset_in_bytes = 0;
         let mut data = vec![];
 
-        for token in tokens.iter() {
+        for token in tokens {
             self.token_tracker.increase()?;
             let mut new_data = self.encode_token(token)?;
-            offset_in_bytes += new_data.iter().map(|x| x.size_in_bytes()).sum::<usize>();
+            offset_in_bytes += new_data.iter().map(Data::size_in_bytes).sum::<usize>();
 
             data.append(&mut new_data);
 
@@ -102,7 +112,7 @@ impl BoundedEncoder {
             Token::U256(arg_u256) => vec![Self::encode_u256(*arg_u256)],
             Token::Bool(arg_bool) => vec![Self::encode_bool_as_byte(*arg_bool)],
             Token::B256(arg_bits256) => vec![Self::encode_b256(arg_bits256)],
-            Token::RawSlice(data) => Self::encode_raw_slice(data.to_vec())?,
+            Token::RawSlice(data) => Self::encode_raw_slice(data.clone())?,
             Token::StringSlice(arg_string) => Self::encode_string_slice(arg_string)?,
             Token::StringArray(arg_string) => vec![Self::encode_string_array(arg_string)?],
             Token::Array(arg_array) => {

packages/fuels/tests/configurables.rs

@@ -94,6 +94,7 @@ async fn contract_configurables() -> Result<()> {
     let new_enum = EnumWithGeneric::VariantTwo;
 
     let configurables = MyContractConfigurables::default()
+        .with_U8(7)?
         .with_STR_4(new_str.clone())?
         .with_STRUCT(new_struct.clone())?
         .with_ENUM(new_enum.clone())?;
@@ -115,7 +116,7 @@ async fn contract_configurables() -> Result<()> {
         .await?;
 
     let expected_value = (
-        8u8,
+        7u8,
         true,
         [253u32, 254u32, 255u32],
         new_str,