Fixed panic during adding change outputs.

Added test to cover it

Author: xgreenx

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

@@ -117,8 +117,9 @@ impl<'a> AssembleArguments<'a> {
             )
             .await?
             .into_iter()
-            .next()
-            .expect("The query returns a single result; qed");
+            .next();
+
+        let result = result.ok_or(anyhow::anyhow!("No result for the coins to spend"))?;
 
         Ok(result)
     }
@@ -525,14 +526,17 @@ where
 
     fn satisfy_change_policy(&mut self, asset_id: AssetId) -> anyhow::Result<()> {
         if self.set_change_outputs.insert(asset_id) {
-            match self
-                .change_output_policies
-                .get(&asset_id)
-                .expect("Policy was inserted in the `new`; qed")
-            {
+            let change_policy =
+                if let Some(policy) = self.change_output_policies.get(&asset_id) {
+                    policy.clone()
+                } else {
+                    ChangePolicy::Change(self.fee_payer_account.owner())
+                };
+
+            match change_policy {
                 ChangePolicy::Change(change_receiver) => {
                     self.tx.outputs_mut().push(Output::change(
-                        *change_receiver,
+                        change_receiver,
                         0,
                         asset_id,
                     ));

tests/test-helpers/src/assemble_tx.rs

@@ -94,16 +94,13 @@ impl AssembleAndRunTx for FuelClient {
         let base_asset_id = *params.base_asset_id();
         let wallet_owner = wallet.owner();
 
-        let mut base_balance_index = required_balances
+        let mut fee_payer_index = required_balances
             .iter()
             .enumerate()
-            .find(|(_, balance)| {
-                balance.asset_id == base_asset_id
-                    && balance.account.owner() == wallet_owner
-            })
+            .find(|(_, balance)| balance.account.owner() == wallet_owner)
             .map(|(i, _)| i);
 
-        if base_balance_index.is_none() {
+        if fee_payer_index.is_none() {
             let required_balance = match &wallet {
                 SigningAccount::Wallet(_) => RequiredBalance {
                     asset_id: base_asset_id,
@@ -126,12 +123,12 @@ impl AssembleAndRunTx for FuelClient {
                 },
             };
 
-            base_balance_index = Some(required_balances.len());
+            fee_payer_index = Some(required_balances.len());
             required_balances.push(required_balance);
         }
 
         let fee_index =
-            u16::try_from(base_balance_index.expect("Fee index set above; qed")).unwrap();
+            u16::try_from(fee_payer_index.expect("Fee index set above; qed")).unwrap();
         let mut tx = self
             .assemble_tx(
                 tx_to_assemble,

tests/tests/assemble_tx.rs

@@ -25,6 +25,7 @@ use fuel_core_types::{
     fuel_crypto::SecretKey,
     fuel_tx::{
         policies::Policies,
+        Address,
         AssetId,
         Input,
         Output,
@@ -227,6 +228,66 @@ async fn assemble_transaction__user_provided_change_output() {
     ));
 }
 
+#[tokio::test]
+async fn assemble_transaction__transfer_non_based_asset() {
+    let mut state_config = StateConfig::local_testnet();
+    let chain_config = ChainConfig::local_testnet();
+
+    let secret: SecretKey = TESTNET_WALLET_SECRETS[1].parse().unwrap();
+    let account = SigningAccount::Wallet(secret);
+    let owner = account.owner();
+    let base_asset_id = *chain_config.consensus_parameters.base_asset_id();
+    let non_base_asset_id = AssetId::from([1; 32]);
+    assert_ne!(base_asset_id, non_base_asset_id);
+
+    // Given
+    state_config.coins[0].owner = owner;
+    state_config.coins[0].asset_id = base_asset_id;
+    state_config.coins[1].owner = owner;
+    state_config.coins[1].asset_id = non_base_asset_id;
+
+    let mut config = Config::local_node_with_configs(chain_config, state_config);
+    config.utxo_validation = true;
+    config.gas_price_config.min_exec_gas_price = 1000;
+
+    let service = FuelService::new_node(config).await.unwrap();
+    let client = FuelClient::from(service.bound_address);
+
+    // Given
+    let recipient = Address::new([123; 32]);
+    let amount = 5_000;
+    let tx = TransactionBuilder::script(vec![op::ret(1)].into_iter().collect(), vec![])
+        .add_output(Output::Coin {
+            to: recipient,
+            asset_id: non_base_asset_id,
+            amount,
+        })
+        .finalize_as_transaction();
+
+    // When
+    let tx = client
+        .assemble_transaction(
+            &tx,
+            default_signing_wallet(),
+            vec![RequiredBalance {
+                asset_id: non_base_asset_id,
+                amount,
+                account: account.clone().into_account(),
+                change_policy: ChangePolicy::Change(owner),
+            }],
+        )
+        .await
+        .unwrap();
+    let status = client.dry_run(&vec![tx.clone()]).await.unwrap();
+
+    // Then
+    let status = status.into_iter().next().unwrap();
+    assert!(matches!(
+        status.result,
+        TransactionExecutionResult::Success { .. }
+    ));
+}
+
 #[tokio::test]
 async fn assemble_transaction__adds_change_output_for_non_required_non_base_balance() {
     let mut state_config = StateConfig::local_testnet();