Contract input set estimation

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ env:
   RUSTFLAGS: "-D warnings"
   FUEL_CORE_VERSION: 0.14.1
   RUST_VERSION: 1.64.0
-  FORC_VERSION: 0.30.0
+  FORC_VERSION: 0.30.1
 
 jobs:
   setup-test-projects:

packages/fuels-contract/src/contract.rs

@@ -6,6 +6,7 @@ use std::marker::PhantomData;
 use std::path::Path;
 use std::str::FromStr;
 
+use fuel_gql_client::prelude::PanicReason;
 use fuel_gql_client::{
     fuel_tx::{Contract as FuelContract, Output, Receipt, StorageSlot, Transaction},
     fuel_types::{Address, AssetId, Salt},
@@ -378,6 +379,10 @@ impl ContractCall {
         }
     }
 
+    pub fn append_external_contracts(&mut self, contract_id: Bech32ContractId) {
+        self.external_contracts.push(contract_id)
+    }
+
     pub fn append_message_outputs(&mut self, num: u64) {
         let new_message_outputs = vec![
             Output::Message {
@@ -438,6 +443,12 @@ impl ContractCall {
         let decoded_value = ABIDecoder::decode_single(&self.output_param, &encoded_value)?;
         Ok(decoded_value)
     }
+
+    fn check_if_contract_not_in_inputs(receipts: &[Receipt]) -> Option<&Receipt> {
+        receipts.iter().find(
+            |r| matches!(r, Receipt::Panic { reason, .. } if *reason.reason() == PanicReason::ContractNotInInputs ),
+        )
+    }
 }
 
 #[derive(Debug)]
@@ -465,6 +476,16 @@ where
         self
     }
 
+    /// Appends additional external contracts as dependencies to this contract's call.
+    /// Effectively, this will be used to create additional Input::Contract/Output::Contract
+    /// pairs and set them into the transaction.
+    /// Note that this is a builder method, i.e. use it as a chain:
+    /// `my_contract_instance.my_method(...).append_contracts(additional_contract_id).call()`.
+    pub fn append_contract(mut self, contract_id: Bech32ContractId) -> Self {
+        self.contract_call.append_external_contracts(contract_id);
+        self
+    }
+
     /// Sets the transaction parameters for a given transaction.
     /// Note that this is a builder method, i.e. use it as a chain:
     /// let params = TxParameters { gas_price: 100, gas_limit: 1000000 };
@@ -541,6 +562,16 @@ where
         Self::call_or_simulate(&self, true).await
     }
 
+    /// Simulates a call without needing to resolve the generic for the return type
+    async fn simulate_without_decode(&self) -> Result<(), Error> {
+        let script = self.get_call_execution_script().await?;
+        let provider = self.wallet.get_provider()?;
+
+        script.simulate(provider).await?;
+
+        Ok(())
+    }
+
     /// Simulates the call and attempts to resolve missing tx dependencies.
     /// Forwards the received error if it cannot be fixed.
     pub async fn estimate_tx_dependencies(
@@ -550,14 +581,23 @@ where
         let attempts = max_attempts.unwrap_or(DEFAULT_TX_DEP_ESTIMATION_ATTEMPTS);
 
         for _ in 0..attempts {
-            let result = self.call_or_simulate(true).await;
+            let result = self.simulate_without_decode().await;
 
             match result {
                 Err(Error::RevertTransactionError(_, receipts))
                     if ContractCall::is_missing_output_variables(&receipts) =>
                 {
                     self = self.append_variable_outputs(1);
                 }
+
+                Err(Error::RevertTransactionError(_, receipts)) => {
+                    if let Some(receipt) = ContractCall::check_if_contract_not_in_inputs(&receipts)
+                    {
+                        let contract_id = Bech32ContractId::from(*receipt.contract_id().unwrap());
+                        self = self.append_contract(contract_id);
+                    }
+                }
+
                 Err(e) => return Err(e),
                 _ => return Ok(self),
             }
@@ -694,6 +734,17 @@ impl MultiContractCallHandler {
                         .take(1)
                         .for_each(|call| call.append_variable_outputs(1));
                 }
+
+                Err(Error::RevertTransactionError(_, receipts)) => {
+                    if let Some(receipt) = ContractCall::check_if_contract_not_in_inputs(&receipts)
+                    {
+                        let contract_id = Bech32ContractId::from(*receipt.contract_id().unwrap());
+                        self.contract_calls
+                            .iter_mut()
+                            .take(1)
+                            .for_each(|call| call.append_external_contracts(contract_id.clone()));
+                    }
+                }
                 Err(e) => return Err(e),
                 _ => return Ok(self),
             }

packages/fuels-contract/src/script.rs

@@ -1,9 +1,10 @@
 use anyhow::Result;
 use fuel_gql_client::client::schema::resource::Resource;
 use fuel_gql_client::fuel_tx::{
-    field::Script as ScriptField, ConsensusParameters, Input, Output, Receipt, Transaction,
-    TxPointer, UtxoId,
+    field::Script as ScriptField, ConsensusParameters, Input, Output, PanicReason, Receipt,
+    Transaction, TxPointer, UtxoId,
 };
+
 use fuel_gql_client::fuel_types::{
     bytes::padded_len_usize, AssetId, Bytes32, ContractId, Immediate18, Word,
 };
@@ -409,8 +410,9 @@ impl Script {
         if receipts
             .iter()
             .any(|r|
-                matches!(r, Receipt::ScriptResult { result, .. } if *result != ScriptExecutionResult::Success)
-        ) {
+                matches!(r, Receipt::ScriptResult { result, .. } if *result != ScriptExecutionResult::Success) |
+                    matches!(r, Receipt::Panic { reason, .. } if *reason.reason() == PanicReason::ContractNotInInputs )
+            ) {
             return Err(Error::RevertTransactionError(Default::default(), receipts));
         }
 

packages/fuels/tests/contracts.rs

@@ -645,3 +645,76 @@ async fn contract_call_futures_implement_send() -> Result<(), Error> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_contract_set_estimation() -> Result<(), Error> {
+    setup_contract_test!(
+        foo_contract_instance,
+        wallet,
+        "packages/fuels/tests/contracts/foo_contract"
+    );
+    let foo_contract_id = foo_contract_instance.get_contract_id();
+
+    let res = foo_contract_instance.methods().foo(true).call().await?;
+    assert!(!res.value);
+
+    setup_contract_test!(
+        foo_caller_contract_instance,
+        None,
+        "packages/fuels/tests/contracts/foo_caller_contract"
+    );
+
+    let bits = *foo_contract_id.hash();
+    let res = foo_caller_contract_instance
+        .methods()
+        .call_foo_contract(Bits256(bits), true)
+        .estimate_tx_dependencies(None)
+        .await?
+        .call()
+        .await?;
+
+    assert!(res.value);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_output_variable_contract_id_estimation_multicall() -> Result<(), Error> {
+    setup_contract_test!(
+        foo_contract_instance,
+        wallet,
+        "packages/fuels/tests/contracts/foo_contract"
+    );
+
+    let foo_contract_id = foo_contract_instance.get_contract_id();
+
+    setup_contract_test!(
+        foo_caller_contract_instance,
+        None,
+        "packages/fuels/tests/contracts/foo_caller_contract"
+    );
+
+    let bits = *foo_contract_id.hash();
+    let contract_methods = foo_caller_contract_instance.methods();
+
+    let mut multi_call_handler = MultiContractCallHandler::new(wallet.clone());
+    multi_call_handler.tx_params(Default::default());
+
+    (0..3).for_each(|_| {
+        let call_handler = contract_methods.call_foo_contract(Bits256(bits), true);
+        multi_call_handler.add_call(call_handler);
+    });
+
+    // add call that does not need ContractId
+    let call_handler = contract_methods.return_bool(false);
+    multi_call_handler.add_call(call_handler);
+
+    let call_response = multi_call_handler
+        .estimate_tx_dependencies(None)
+        .await?
+        .call::<(bool, bool, bool, bool)>()
+        .await?;
+
+    assert_eq!(call_response.value, (true, true, true, false));
+
+    Ok(())
+}

packages/fuels/tests/contracts/foo_caller_contract/src/main.sw

@@ -5,6 +5,7 @@ use std::constants::ZERO_B256;
 
 abi FooCaller {
     fn call_foo_contract(target: b256, value: bool) -> bool;
+    fn return_bool(value: bool) -> bool;
 }
 
 impl FooCaller for Contract {
@@ -18,4 +19,8 @@ impl FooCaller for Contract {
 
         !response
     }
+
+    fn return_bool(value: bool) -> bool {
+        value
+    }
 }