chore: use Cow in scalars/HexString

Author: grandima

crates/fuel-core/src/schema/blob.rs

@@ -32,7 +32,7 @@ impl Blob {
         let query = ctx.read_view()?;
         query
             .blob_bytecode(self.0)
-            .map(HexString)
+            .map(|bytes| HexString(bytes.into()))
             .map_err(async_graphql::Error::from)
     }
 }

crates/fuel-core/src/schema/contract.rs

@@ -52,7 +52,7 @@ impl Contract {
         let query = ctx.read_view()?;
         query
             .contract_bytecode(self.0)
-            .map(HexString)
+            .map(|bytes|HexString(bytes.into()))
             .map_err(Into::into)
     }
 

crates/fuel-core/src/schema/da_compressed.rs

@@ -25,7 +25,7 @@ impl From<Vec<u8>> for DaCompressedBlock {
 #[Object]
 impl DaCompressedBlock {
     async fn bytes(&self) -> HexString {
-        HexString(self.bytes.clone())
+        HexString(self.bytes.clone().into())
     }
 }
 

crates/fuel-core/src/schema/scalars.rs

@@ -22,6 +22,7 @@ use std::{
     },
     str::FromStr,
 };
+use std::borrow::Cow;
 pub use tx_pointer::TxPointer;
 pub use utxo_id::UtxoId;
 
@@ -161,10 +162,26 @@ impl CursorType for SortedTxCursor {
 }
 
 #[derive(Clone, Debug, derive_more::Into, derive_more::From, PartialEq, Eq)]
-pub struct HexString(pub(crate) Vec<u8>);
+pub struct HexString<'a>(pub(crate) Cow<'a, [u8]>);
+
+impl From<Vec<u8>> for HexString<'_> {
+    fn from(vec: Vec<u8>) -> Self {
+        HexString(Cow::Owned(vec))
+    }
+}
+
+impl <'a>From<&'a [u8]> for HexString<'a> {
+    fn from(value: &'a [u8]) -> Self { HexString(Cow::Borrowed(value)) }
+}
+
+impl From<HexString<'_>> for Vec<u8> {
+    fn from(hex: HexString) -> Self {
+        hex.0.into_owned()
+    }
+}
 
 #[Scalar(name = "HexString")]
-impl ScalarType for HexString {
+impl ScalarType for HexString<'_> {
     fn parse(value: Value) -> InputValueResult<Self> {
         match &value {
             Value::String(value) => {
@@ -179,14 +196,14 @@ impl ScalarType for HexString {
     }
 }
 
-impl Display for HexString {
+impl Display for HexString<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let s = format!("0x{}", hex::encode(&self.0));
+        let s = format!("0x{}", hex::encode(&self.0.as_ref()));
         s.fmt(f)
     }
 }
 
-impl CursorType for HexString {
+impl CursorType for HexString<'_> {
     type Error = String;
 
     fn decode_cursor(s: &str) -> Result<Self, Self::Error> {
@@ -198,28 +215,28 @@ impl CursorType for HexString {
     }
 }
 
-impl FromStr for HexString {
+impl FromStr for HexString<'_> {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let value = s.strip_prefix("0x").unwrap_or(s);
         // decode into bytes
         let bytes = hex::decode(value).map_err(|e| e.to_string())?;
-        Ok(HexString(bytes))
+        Ok(HexString(Cow::Owned(bytes)))
     }
 }
 
-impl From<fuel_types::Nonce> for HexString {
+impl From<fuel_types::Nonce> for HexString<'_> {
     fn from(n: fuel_types::Nonce) -> Self {
-        HexString(n.to_vec())
+        HexString(Cow::Owned(n.to_vec()))
     }
 }
 
-impl TryInto<fuel_types::Nonce> for HexString {
+impl TryInto<fuel_types::Nonce> for HexString<'_> {
     type Error = TryFromSliceError;
 
     fn try_into(self) -> Result<fuel_types::Nonce, Self::Error> {
-        let bytes: [u8; 32] = self.0.as_slice().try_into()?;
+        let bytes: [u8; 32] = self.0.as_ref().try_into()?;
         Ok(fuel_types::Nonce::from(bytes))
     }
 }

crates/fuel-core/src/schema/storage.rs

@@ -161,6 +161,6 @@ impl StorageSlot {
     }
 
     async fn value(&self) -> HexString {
-        HexString(self.value.clone())
+        HexString::from(self.value.as_ref())
     }
 }

crates/fuel-core/src/schema/tx.rs

@@ -122,7 +122,7 @@ impl TxQuery {
     async fn dry_run_inner(
         &self,
         ctx: &Context<'_>,
-        txs: Vec<HexString>,
+        txs: Vec<HexString<'_>>,
         // If set to false, disable input utxo validation, overriding the configuration of the node.
         // This allows for non-existent inputs to be used without signature validation
         // for read-only calls.
@@ -373,7 +373,7 @@ impl TxQuery {
         #[graphql(
             desc = "The original transaction that contains application level logic only"
         )]
-        tx: HexString,
+        tx: HexString<'_>,
         #[graphql(
             desc = "Number of blocks into the future to estimate the gas price for"
         )]
@@ -517,7 +517,7 @@ impl TxQuery {
     async fn estimate_predicates(
         &self,
         ctx: &Context<'_>,
-        tx: HexString,
+        tx: HexString<'_>,
     ) -> async_graphql::Result<Transaction> {
         let query = ctx.read_view()?.into_owned();
 
@@ -548,7 +548,7 @@ impl TxQuery {
     async fn dry_run(
         &self,
         ctx: &Context<'_>,
-        txs: Vec<HexString>,
+        txs: Vec<HexString<'_>>,
         // If set to false, disable input utxo validation, overriding the configuration of the node.
         // This allows for non-existent inputs to be used without signature validation
         // for read-only calls.
@@ -572,7 +572,7 @@ impl TxQuery {
     async fn dry_run_record_storage_reads(
         &self,
         ctx: &Context<'_>,
-        txs: Vec<HexString>,
+        txs: Vec<HexString<'_>>,
         // If set to false, disable input utxo validation, overriding the configuration of the node.
         // This allows for non-existent inputs to be used without signature validation
         // for read-only calls.
@@ -625,7 +625,7 @@ impl TxMutation {
     async fn dry_run(
         &self,
         ctx: &Context<'_>,
-        txs: Vec<HexString>,
+        txs: Vec<HexString<'_>>,
         // If set to false, disable input utxo validation, overriding the configuration of the node.
         // This allows for non-existent inputs to be used without signature validation
         // for read-only calls.
@@ -646,7 +646,7 @@ impl TxMutation {
     async fn submit(
         &self,
         ctx: &Context<'_>,
-        tx: HexString,
+        tx: HexString<'_>,
         estimate_predicates: Option<bool>,
     ) -> async_graphql::Result<Transaction> {
         let txpool = ctx.data_unchecked::<TxPool>();
@@ -677,7 +677,7 @@ impl TxMutation {
 pub struct TxStatusSubscription;
 
 #[Subscription]
-impl TxStatusSubscription {
+impl<'a> TxStatusSubscription {
     /// Returns a stream of status updates for the given transaction id.
     /// If the current status is [`TransactionStatus::Success`], [`TransactionStatus::Failed`],
     /// or [`TransactionStatus::SqueezedOut`] the stream will return that and end immediately.
@@ -691,7 +691,7 @@ impl TxStatusSubscription {
     /// a status. If this occurs the stream can simply be restarted to return
     /// the latest status.
     #[graphql(complexity = "query_costs().status_change + child_complexity")]
-    async fn status_change<'a>(
+    async fn status_change(
         &self,
         ctx: &'a Context<'a>,
         #[graphql(desc = "The ID of the transaction")] id: TransactionId,
@@ -720,10 +720,10 @@ impl TxStatusSubscription {
 
     /// Submits transaction to the `TxPool` and await either success or failure.
     #[graphql(complexity = "query_costs().submit_and_await + child_complexity")]
-    async fn submit_and_await<'a>(
+    async fn submit_and_await(
         &self,
         ctx: &'a Context<'a>,
-        tx: HexString,
+        tx: HexString<'a>,
         estimate_predicates: Option<bool>,
     ) -> async_graphql::Result<
         impl Stream<Item = async_graphql::Result<TransactionStatus>> + 'a + use<'a>,
@@ -742,10 +742,10 @@ impl TxStatusSubscription {
     /// Compared to the `submitAndAwait`, the stream also contains
     /// `SubmittedStatus` and potentially preconfirmation as an intermediate state.
     #[graphql(complexity = "query_costs().submit_and_await + child_complexity")]
-    async fn submit_and_await_status<'a>(
-        &self,
+    async fn submit_and_await_status(
+        &'a self,
         ctx: &'a Context<'a>,
-        tx: HexString,
+        tx: HexString<'a>,
         estimate_predicates: Option<bool>,
         include_preconfirmation: Option<bool>,
     ) -> async_graphql::Result<
@@ -763,7 +763,7 @@ impl TxStatusSubscription {
 
 async fn submit_and_await_status<'a>(
     ctx: &'a Context<'a>,
-    tx: HexString,
+    tx: HexString<'a>,
     estimate_predicates: bool,
     include_preconfirmation: bool,
 ) -> async_graphql::Result<
@@ -859,8 +859,8 @@ pub mod schema_types {
         // signature verification. They provide a mocked version of the predicate that
         // returns `true` even if the signature doesn't match.
         pub predicate_address: Address,
-        pub predicate: HexString,
-        pub predicate_data: HexString,
+        pub predicate: HexString<'static>,
+        pub predicate_data: HexString<'static>,
     }
 
     #[derive(async_graphql::InputObject)]

crates/fuel-core/src/schema/tx/input.rs

@@ -17,26 +17,26 @@ use async_graphql::{
 use fuel_core_types::fuel_tx;
 
 #[derive(Union)]
-pub enum Input {
-    Coin(InputCoin),
+pub enum Input<'a> {
+    Coin(InputCoin<'a>),
     Contract(InputContract),
-    Message(InputMessage),
+    Message(InputMessage<'a>),
 }
 
-pub struct InputCoin {
+pub struct InputCoin<'a> {
     utxo_id: UtxoId,
     owner: Address,
     amount: U64,
     asset_id: AssetId,
     tx_pointer: TxPointer,
     witness_index: u16,
     predicate_gas_used: U64,
-    predicate: HexString,
-    predicate_data: HexString,
+    predicate: HexString<'a>,
+    predicate_data: HexString<'a>,
 }
 
 #[Object]
-impl InputCoin {
+impl InputCoin<'_> {
     async fn utxo_id(&self) -> UtxoId {
         self.utxo_id
     }
@@ -105,20 +105,20 @@ impl InputContract {
     }
 }
 
-pub struct InputMessage {
+pub struct InputMessage<'a> {
     sender: Address,
     recipient: Address,
     amount: U64,
     nonce: Nonce,
     witness_index: u16,
     predicate_gas_used: U64,
-    data: HexString,
-    predicate: HexString,
-    predicate_data: HexString,
+    data: HexString<'a>,
+    predicate: HexString<'a>,
+    predicate_data: HexString<'a>,
 }
 
 #[Object]
-impl InputMessage {
+impl InputMessage<'_> {
     async fn sender(&self) -> Address {
         self.sender
     }
@@ -156,8 +156,8 @@ impl InputMessage {
     }
 }
 
-impl From<&fuel_tx::Input> for Input {
-    fn from(input: &fuel_tx::Input) -> Self {
+impl <'a> From<&'a fuel_tx::Input> for Input<'a> {
+    fn from(input: &'a fuel_tx::Input) -> Self {
         match input {
             fuel_tx::Input::CoinSigned(fuel_tx::input::coin::CoinSigned {
                 utxo_id,
@@ -175,7 +175,7 @@ impl From<&fuel_tx::Input> for Input {
                 tx_pointer: TxPointer(*tx_pointer),
                 witness_index: *witness_index,
                 predicate_gas_used: 0.into(),
-                predicate: HexString(Default::default()),
+                predicate: HexString(vec![].into()),
                 predicate_data: HexString(Default::default()),
             }),
             fuel_tx::Input::CoinPredicate(fuel_tx::input::coin::CoinPredicate {
@@ -196,8 +196,8 @@ impl From<&fuel_tx::Input> for Input {
                 tx_pointer: TxPointer(*tx_pointer),
                 witness_index: Default::default(),
                 predicate_gas_used: (*predicate_gas_used).into(),
-                predicate: HexString(predicate.to_vec()),
-                predicate_data: HexString(predicate_data.clone()),
+                predicate: HexString::from(predicate.as_ref()),
+                predicate_data: HexString::from(predicate_data.as_ref()),
             }),
             fuel_tx::Input::Contract(contract) => Input::Contract(contract.into()),
             fuel_tx::Input::MessageCoinSigned(
@@ -239,8 +239,8 @@ impl From<&fuel_tx::Input> for Input {
                 witness_index: Default::default(),
                 predicate_gas_used: (*predicate_gas_used).into(),
                 data: HexString(Default::default()),
-                predicate: HexString(predicate.to_vec()),
-                predicate_data: HexString(predicate_data.clone()),
+                predicate: HexString::from(predicate.as_ref()),
+                predicate_data: HexString::from(predicate_data.as_ref()),
             }),
             fuel_tx::Input::MessageDataSigned(
                 fuel_tx::input::message::MessageDataSigned {
@@ -259,9 +259,9 @@ impl From<&fuel_tx::Input> for Input {
                 nonce: Nonce(*nonce),
                 witness_index: *witness_index,
                 predicate_gas_used: 0.into(),
-                data: HexString(data.clone()),
-                predicate: HexString(Default::default()),
-                predicate_data: HexString(Default::default()),
+                data: HexString::from(data.as_ref()),
+                predicate: HexString(vec![].into()),
+                predicate_data: HexString(vec![].into()),
             }),
             fuel_tx::Input::MessageDataPredicate(
                 fuel_tx::input::message::MessageDataPredicate {
@@ -282,9 +282,9 @@ impl From<&fuel_tx::Input> for Input {
                 nonce: Nonce(*nonce),
                 witness_index: Default::default(),
                 predicate_gas_used: (*predicate_gas_used).into(),
-                data: HexString(data.clone()),
-                predicate: HexString(predicate.to_vec()),
-                predicate_data: HexString(predicate_data.clone()),
+                data: HexString::from(data.as_ref()),
+                predicate: HexString::from(predicate.as_ref()),
+                predicate_data: HexString::from(predicate_data.as_ref()),
             }),
         }
     }