Merge pull request #1161 from fluidvanadium/grace_note-1

Send Grace Dust

Author: zancas

integration-tests/tests/chain_generic_tests.rs

@@ -5,6 +5,7 @@ use zcash_client_backend::ShieldedProtocol::Sapling;
 
 use zingo_testutils::chain_generic_tests::fixtures::ignore_dust_inputs;
 use zingo_testutils::chain_generic_tests::fixtures::propose_and_broadcast_value_to_pool;
+use zingo_testutils::chain_generic_tests::fixtures::send_grace_dust;
 use zingo_testutils::chain_generic_tests::fixtures::send_required_dust;
 use zingo_testutils::chain_generic_tests::fixtures::send_shield_cycle;
 use zingo_testutils::chain_generic_tests::fixtures::send_value_to_pool;
@@ -45,6 +46,10 @@ async fn libtonode_send_required_dust() {
     send_required_dust::<LibtonodeEnvironment>().await;
 }
 #[tokio::test]
+async fn libtonode_send_grace_dust() {
+    send_grace_dust::<LibtonodeEnvironment>().await;
+}
+#[tokio::test]
 async fn libtonode_ignore_dust_inputs() {
     ignore_dust_inputs::<LibtonodeEnvironment>().await;
 }

zingo-testutils/src/chain_generic_tests.rs

@@ -200,6 +200,47 @@ pub mod fixtures {
         );
     }
 
+    /// uses a dust input to pad another input to finish a transaction
+    pub async fn send_grace_dust<CC>()
+    where
+        CC: ConductChain,
+    {
+        let mut environment = CC::setup().await;
+        let primary = environment.fund_client_orchard(120_000).await;
+        let secondary = environment.create_client().await;
+
+        assert_eq!(
+            with_assertions::propose_send_bump_sync_recipient(
+                &mut environment,
+                &primary,
+                &secondary,
+                vec![(Shielded(Orchard), 1), (Shielded(Orchard), 99_999)]
+            )
+            .await,
+            3 * MARGINAL_FEE.into_u64()
+        );
+
+        assert_eq!(
+            with_assertions::propose_send_bump_sync_recipient(
+                &mut environment,
+                &secondary,
+                &primary,
+                vec![(Shielded(Orchard), 30_000)]
+            )
+            .await,
+            2 * MARGINAL_FEE.into_u64()
+        );
+
+        // since we used our dust as a freebie in the last send, we should only have 2
+        assert_eq!(
+            secondary
+                .query_for_ids(OutputQuery::only_unspent())
+                .await
+                .len(),
+            1
+        );
+    }
+
     /// overlooks a bunch of dust inputs to find a pair of inputs marginally big enough to send
     pub async fn ignore_dust_inputs<CC>()
     where

zingolib/src/lightclient/describe.rs

@@ -41,6 +41,20 @@ impl LightClient {
             .query_sum_value(include_notes)
     }
 
+    /// Uses a query to select all notes with specific properties and return a vector of their identifiers
+    pub async fn query_for_ids(
+        &self,
+        include_notes: OutputQuery,
+    ) -> Vec<crate::wallet::notes::OutputId> {
+        self.wallet
+            .transaction_context
+            .transaction_metadata_set
+            .read()
+            .await
+            .transaction_records_by_id
+            .query_for_ids(include_notes)
+    }
+
     /// TODO: Add Doc Comment Here!
     pub async fn do_addresses(&self) -> JsonValue {
         let mut objectified_addresses = Vec::new();

zingolib/src/wallet/notes/query.rs

@@ -96,6 +96,18 @@ impl OutputQuery {
             pools: OutputPoolQuery::any(),
         }
     }
+    /// a query that accepts all notes.
+    pub fn only_unspent() -> Self {
+        Self {
+            spend_status: OutputSpendStatusQuery {
+                unspent: true,
+                pending_spent: false,
+                spent: false,
+            },
+            pools: OutputPoolQuery::any(),
+        }
+    }
+
     /// build a query, specifying each stipulation
     pub fn stipulations(
         unspent: bool,

zingolib/src/wallet/transaction_records_by_id.rs

@@ -63,6 +63,14 @@ impl TransactionRecordsById {
         })
     }
 
+    /// Uses a query to select all notes across all transactions with specific properties and sum them
+    pub fn query_for_ids(&self, include_notes: OutputQuery) -> Vec<crate::wallet::notes::OutputId> {
+        self.0
+            .iter()
+            .flat_map(|transaction_record| transaction_record.1.query_for_ids(include_notes))
+            .collect()
+    }
+
     /// TODO: Add Doc Comment Here!
     pub fn get_received_spendable_note_from_identifier<D: DomainWalletExt>(
         &self,

zingolib/src/wallet/transaction_records_by_id/trait_inputsource.rs

@@ -9,7 +9,10 @@ use zcash_client_backend::{
 };
 use zcash_primitives::{
     legacy::Script,
-    transaction::components::{amount::NonNegativeAmount, TxOut},
+    transaction::{
+        components::{amount::NonNegativeAmount, TxOut},
+        fees::zip317::MARGINAL_FEE,
+    },
 };
 
 use crate::wallet::{
@@ -160,6 +163,25 @@ impl InputSource for TransactionRecordsById {
             }
         }
 
+        if selected.len() < 2 {
+            // since we maxed out the target value with only one note, we have an option to grace a note.
+            // we will rescue the biggest dust note
+            unselected.reverse();
+            if let Some(biggest_dust) = unselected
+                .iter()
+                .find(|(_id, value)| value <= &MARGINAL_FEE.into_u64())
+            {
+                selected.push(*biggest_dust);
+                // we dont bother to pop this last selected note from unselected because we are done with unselected
+            } else {
+                // we have no extra dust, but we can still save a marginal fee by adding the next smallest note to change
+                unselected.reverse();
+                if let Some(id_value) = unselected.pop() {
+                    selected.push(id_value);
+                };
+            }
+        }
+
         let mut selected_sapling = Vec::<ReceivedNote<NoteId, sapling_crypto::Note>>::new();
         let mut selected_orchard = Vec::<ReceivedNote<NoteId, orchard::Note>>::new();
 
@@ -310,11 +332,12 @@ mod tests {
 
     use crate::wallet::{
         notes::{
-            query::OutputSpendStatusQuery, transparent::mocks::TransparentOutputBuilder,
-            OutputInterface,
+            orchard::mocks::OrchardNoteBuilder, query::OutputSpendStatusQuery,
+            transparent::mocks::TransparentOutputBuilder, OutputInterface,
         },
         transaction_record::mocks::{
             nine_note_transaction_record, nine_note_transaction_record_default,
+            TransactionRecordBuilder,
         },
         transaction_records_by_id::TransactionRecordsById,
     };
@@ -388,7 +411,46 @@ mod tests {
                     anchor_height,
                     &[],
                 ).unwrap();
-            let expected_len = if target_value > std::cmp::max(sapling_value, orchard_value) {2} else {1};
+            prop_assert_eq!(spendable_notes.sapling().len(), 1);
+            prop_assert_eq!(spendable_notes.orchard().len(), 1);
+        }
+        #[test]
+        fn select_spendable_notes_2(
+            target_value in 0..4_000_000u32,
+        ) {
+            let mut transaction_records_by_id = TransactionRecordsById::new();
+            transaction_records_by_id.insert_transaction_record(
+
+        TransactionRecordBuilder::default()
+            .orchard_notes(OrchardNoteBuilder::default().value(1_000_000).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(1_000_000).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(1_000_000).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(1_000_000).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(0).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(1).clone())
+            .orchard_notes(OrchardNoteBuilder::default().value(10).clone())
+            .randomize_txid()
+            .set_output_indexes()
+            .build()
+                );
+
+            let target_amount = NonNegativeAmount::const_from_u64(target_value as u64);
+            let anchor_height: BlockHeight = 10.into();
+            let spendable_notes =
+                zcash_client_backend::data_api::InputSource::select_spendable_notes(
+                    &transaction_records_by_id,
+                    AccountId::ZERO,
+                    target_amount,
+                    &[ShieldedProtocol::Sapling, ShieldedProtocol::Orchard],
+                    anchor_height,
+                    &[],
+                ).unwrap();
+            let expected_len = match target_value {
+                target_value if target_value <= 2_000_000 => 2,
+                target_value if target_value <= 3_000_000 => 3,
+                _ => 4
+            };
+
             prop_assert_eq!(spendable_notes.sapling().len() + spendable_notes.orchard().len(), expected_len);
         }
     }