Fix underbidding in simulation

Author: azarovh

chainstate/test-framework/src/random_tx_maker.rs

@@ -1007,27 +1007,33 @@ impl<'a> RandomTxMaker<'a> {
                     get_random_order_to_fill(self.orders_store, &orders_cache, &fill_value)
                 {
                     let filled_value =
-                        calculate_filled_order_value(&orders_cache, order_id, amount_to_spend);
+                        calculate_filled_order_value(&orders_cache, order_id, amount_to_spend)
+                            .unwrap();
 
-                    if !is_frozen_token(&filled_value, tokens_cache) {
-                        let input = TxInput::OrderAccountCommand(OrderAccountCommand::FillOrder(
-                            order_id,
-                            amount_to_spend,
-                            key_manager.new_destination(self.chainstate.get_chain_config(), rng),
-                        ));
+                    if let Some(filled_value) = filled_value {
+                        if !is_frozen_token(&filled_value, tokens_cache) {
+                            let input =
+                                TxInput::OrderAccountCommand(OrderAccountCommand::FillOrder(
+                                    order_id,
+                                    amount_to_spend,
+                                    key_manager
+                                        .new_destination(self.chainstate.get_chain_config(), rng),
+                                ));
 
-                        let output = TxOutput::Transfer(
-                            filled_value,
-                            key_manager.new_destination(self.chainstate.get_chain_config(), rng),
-                        );
+                            let output = TxOutput::Transfer(
+                                filled_value,
+                                key_manager
+                                    .new_destination(self.chainstate.get_chain_config(), rng),
+                            );
 
-                        let _ = orders_cache
-                            .fill_order(order_id, amount_to_spend, OrdersVersion::V1)
-                            .unwrap();
-                        self.account_command_used = true;
+                            let _ = orders_cache
+                                .fill_order(order_id, amount_to_spend, OrdersVersion::V1)
+                                .unwrap();
+                            self.account_command_used = true;
 
-                        result_inputs.push(input);
-                        result_outputs.push(output);
+                            result_inputs.push(input);
+                            result_outputs.push(output);
+                        }
                     }
                 }
             } else if switch == 6 {
@@ -1228,28 +1234,37 @@ impl<'a> RandomTxMaker<'a> {
                             &orders_cache,
                             order_id,
                             Amount::from_atoms(atoms),
-                        );
-
-                        if !is_frozen_token(&filled_value, tokens_cache) {
-                            result_outputs.push(TxOutput::Transfer(
-                                filled_value,
-                                key_manager
-                                    .new_destination(self.chainstate.get_chain_config(), rng),
-                            ));
+                        )
+                        .unwrap();
 
-                            result_inputs.push(TxInput::OrderAccountCommand(
-                                OrderAccountCommand::FillOrder(
-                                    order_id,
-                                    Amount::from_atoms(atoms),
+                        if let Some(filled_value) = filled_value {
+                            if !is_frozen_token(&filled_value, tokens_cache) {
+                                result_outputs.push(TxOutput::Transfer(
+                                    filled_value,
                                     key_manager
                                         .new_destination(self.chainstate.get_chain_config(), rng),
-                                ),
-                            ));
-
-                            let _ = orders_cache
-                                .fill_order(order_id, Amount::from_atoms(atoms), OrdersVersion::V1)
-                                .unwrap();
-                            self.account_command_used = true;
+                                ));
+
+                                result_inputs.push(TxInput::OrderAccountCommand(
+                                    OrderAccountCommand::FillOrder(
+                                        order_id,
+                                        Amount::from_atoms(atoms),
+                                        key_manager.new_destination(
+                                            self.chainstate.get_chain_config(),
+                                            rng,
+                                        ),
+                                    ),
+                                ));
+
+                                let _ = orders_cache
+                                    .fill_order(
+                                        order_id,
+                                        Amount::from_atoms(atoms),
+                                        OrdersVersion::V1,
+                                    )
+                                    .unwrap();
+                                self.account_command_used = true;
+                            }
                         }
                     }
                 }
@@ -1470,11 +1485,17 @@ fn calculate_filled_order_value(
     view: &impl OrdersAccountingView,
     order_id: OrderId,
     fill: Amount,
-) -> OutputValue {
+) -> Result<Option<OutputValue>, orders_accounting::Error> {
     let order_data = view.get_order_data(&order_id).unwrap().unwrap();
 
-    let filled_amount =
-        orders_accounting::calculate_fill_order(view, order_id, fill, OrdersVersion::V1).unwrap();
+    let result = orders_accounting::calculate_fill_order(view, order_id, fill, OrdersVersion::V1);
 
-    output_value_with_amount(order_data.give(), filled_amount)
+    match result {
+        Ok(filled_amount) => Ok(Some(output_value_with_amount(
+            order_data.give(),
+            filled_amount,
+        ))),
+        Err(orders_accounting::Error::OrderUnderbid(..)) => Ok(None),
+        Err(e) => Err(e),
+    }
 }