Merge pull request #441 from xch-dev/single-sided-fix

Fix single sided offer NFTs and DIDs

Author: Rigidity

crates/sage-wallet/src/database.rs

@@ -121,7 +121,9 @@ pub async fn insert_puzzle(
             });
 
             if coin_state.spent_height.is_some()
-                && (row.created_height.is_none() || row.created_height > coin_state.created_height)
+                && (row.created_height.is_none()
+                    || row.created_height > coin_state.created_height
+                    || row.is_owned)
             {
                 return Ok(());
             }
@@ -174,7 +176,9 @@ pub async fn insert_puzzle(
             });
 
             if coin_state.spent_height.is_some()
-                && (row.created_height.is_none() || row.created_height > coin_state.created_height)
+                && (row.created_height.is_none()
+                    || row.created_height > coin_state.created_height
+                    || row.is_owned)
             {
                 return Ok(());
             }

crates/sage-wallet/src/queues/puzzle_queue.rs

@@ -19,6 +19,7 @@ use crate::{
 pub struct PuzzleQueue {
     db: Database,
     genesis_challenge: Bytes32,
+    batch_size_per_peer: usize,
     state: Arc<Mutex<PeerState>>,
     sync_sender: mpsc::Sender<SyncEvent>,
     command_sender: mpsc::Sender<SyncCommand>,
@@ -28,13 +29,15 @@ impl PuzzleQueue {
     pub fn new(
         db: Database,
         genesis_challenge: Bytes32,
+        batch_size_per_peer: usize,
         state: Arc<Mutex<PeerState>>,
         sync_sender: mpsc::Sender<SyncEvent>,
         command_sender: mpsc::Sender<SyncCommand>,
     ) -> Self {
         Self {
             db,
             genesis_challenge,
+            batch_size_per_peer,
             state,
             sync_sender,
             command_sender,
@@ -55,7 +58,10 @@ impl PuzzleQueue {
             return Ok(());
         }
 
-        let coin_states = self.db.unsynced_coin_states(peers.len() * 5).await?;
+        let coin_states = self
+            .db
+            .unsynced_coin_states(peers.len() * self.batch_size_per_peer)
+            .await?;
 
         if coin_states.is_empty() {
             return Ok(());
@@ -68,7 +74,7 @@ impl PuzzleQueue {
         let mut coin_states_iter = coin_states.into_iter();
 
         for peer in peers {
-            for _ in 0..5 {
+            for _ in 0..self.batch_size_per_peer {
                 let Some(coin_state) = coin_states_iter.next() else {
                     break;
                 };

crates/sage-wallet/src/sync_manager.rs

@@ -407,6 +407,7 @@ impl SyncManager {
                     PuzzleQueue::new(
                         wallet.db.clone(),
                         wallet.genesis_challenge,
+                        self.options.puzzle_batch_size_per_peer,
                         self.state.clone(),
                         self.event_sender.clone(),
                         self.command_sender.clone(),

crates/sage-wallet/src/sync_manager/options.rs

@@ -7,6 +7,7 @@ pub struct SyncOptions {
     pub dns_batch_size: usize,
     pub connection_batch_size: usize,
     pub max_peer_age_seconds: u64,
+    pub puzzle_batch_size_per_peer: usize,
     pub timeouts: Timeouts,
     pub testing: bool,
 }

crates/sage-wallet/src/sync_manager/peer_discovery.rs

@@ -1,5 +1,6 @@
 use std::{
     cmp::Reverse,
+    collections::HashMap,
     net::{IpAddr, SocketAddr},
     str::FromStr,
     time::{Duration, SystemTime, UNIX_EPOCH},
@@ -409,9 +410,19 @@ impl SyncManager {
             let mut rng = rand::thread_rng();
 
             // Sort so user managed are deprioritized, then by height, then randomly
+            let mut peer_rng = HashMap::new();
+
+            for (peer, _) in &peers {
+                peer_rng.insert(peer.socket_addr(), rng.gen_range(0..100));
+            }
+
             peers.sort_by_key(|(peer, height)| {
                 let peer_info = state.peer(peer.socket_addr().ip()).expect("peer not found");
-                (peer_info.user_managed, *height, rng.gen_range(0..100))
+                (
+                    peer_info.user_managed,
+                    *height,
+                    peer_rng[&peer.socket_addr()],
+                )
             });
 
             let count = state.peer_count() - self.options.target_peers + 1;

crates/sage-wallet/src/test.rs

@@ -46,22 +46,37 @@ pub struct TestWallet {
     pub events: Receiver<SyncEvent>,
     pub index: u32,
     pub state: Arc<Mutex<PeerState>>,
+    pub options: SyncOptions,
 }
 
 impl TestWallet {
     pub async fn new(balance: u64) -> anyhow::Result<Self> {
-        let sim = PeerSimulator::new().await?;
-        Self::with_sim(Arc::new(sim), balance, 0).await
+        Self::new_with_options(balance, default_test_options()).await
     }
 
     pub async fn next(&self, balance: u64) -> anyhow::Result<Self> {
-        Self::with_sim(self.sim.clone(), balance, self.index + 1).await
+        self.next_with_options(balance, default_test_options())
+            .await
+    }
+
+    pub async fn new_with_options(balance: u64, options: SyncOptions) -> anyhow::Result<Self> {
+        let sim = PeerSimulator::new().await?;
+        Self::with_sim(Arc::new(sim), balance, 0, options).await
+    }
+
+    pub async fn next_with_options(
+        &self,
+        balance: u64,
+        options: SyncOptions,
+    ) -> anyhow::Result<Self> {
+        Self::with_sim(self.sim.clone(), balance, self.index + 1, options).await
     }
 
     async fn with_sim(
         sim: Arc<PeerSimulator>,
         balance: u64,
         key_index: u32,
+        options: SyncOptions,
     ) -> anyhow::Result<Self> {
         let db_index = {
             let mut lock = INDEX.lock().await;
@@ -119,23 +134,7 @@ impl TestWallet {
         ));
 
         let (mut sync_manager, sender, events) = SyncManager::new(
-            SyncOptions {
-                target_peers: 0,
-                discover_peers: false,
-                dns_batch_size: 0,
-                connection_batch_size: 0,
-                max_peer_age_seconds: 0,
-                timeouts: Timeouts {
-                    sync_delay: Duration::from_millis(100),
-                    nft_uri_delay: Duration::from_millis(100),
-                    cat_delay: Duration::from_millis(100),
-                    puzzle_delay: Duration::from_millis(100),
-                    transaction_delay: Duration::from_millis(100),
-                    offer_delay: Duration::from_millis(100),
-                    ..Default::default()
-                },
-                testing: true,
-            },
+            options,
             state.clone(),
             Some(wallet.clone()),
             TESTNET11.clone(),
@@ -164,6 +163,7 @@ impl TestWallet {
             events,
             index: key_index,
             state,
+            options,
         };
 
         test.consume_until(|event| matches!(event, SyncEvent::Subscribed))
@@ -173,6 +173,11 @@ impl TestWallet {
         Ok(test)
     }
 
+    pub async fn resync(&mut self) -> anyhow::Result<()> {
+        *self = Self::with_sim(self.sim.clone(), 0, self.index, self.options).await?;
+        Ok(())
+    }
+
     pub async fn transact(&self, coin_spends: Vec<CoinSpend>) -> anyhow::Result<()> {
         let spend_bundle = self
             .wallet
@@ -231,3 +236,24 @@ impl TestWallet {
             .await;
     }
 }
+
+pub fn default_test_options() -> SyncOptions {
+    SyncOptions {
+        target_peers: 0,
+        discover_peers: false,
+        dns_batch_size: 0,
+        connection_batch_size: 0,
+        max_peer_age_seconds: 0,
+        puzzle_batch_size_per_peer: 5,
+        timeouts: Timeouts {
+            sync_delay: Duration::from_millis(100),
+            nft_uri_delay: Duration::from_millis(100),
+            cat_delay: Duration::from_millis(100),
+            puzzle_delay: Duration::from_millis(100),
+            transaction_delay: Duration::from_millis(100),
+            offer_delay: Duration::from_millis(100),
+            ..Default::default()
+        },
+        testing: true,
+    }
+}

crates/sage-wallet/src/wallet/offer.rs

@@ -21,6 +21,8 @@ pub use unlock_assets::*;
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use chia::{
         clvm_traits::{FromClvm, ToClvm},
         protocol::{Bytes32, Program},
@@ -30,7 +32,10 @@ mod tests {
     use indexmap::indexmap;
     use test_log::test;
 
-    use crate::{MakerSide, RequestedNft, TakerSide, TestWallet, WalletNftMint};
+    use crate::{
+        default_test_options, MakerSide, RequestedNft, SyncOptions, TakerSide, TestWallet,
+        Timeouts, WalletNftMint,
+    };
 
     use super::aggregate_offers;
 
@@ -738,8 +743,22 @@ mod tests {
 
     #[test(tokio::test)]
     async fn test_offer_nft_single_sided() -> anyhow::Result<()> {
+        let options = default_test_options();
+
         let mut alice = TestWallet::new(2).await?;
-        let mut bob = alice.next(0).await?;
+        let mut bob = alice
+            .next_with_options(
+                0,
+                SyncOptions {
+                    puzzle_batch_size_per_peer: 1,
+                    timeouts: Timeouts {
+                        puzzle_delay: Duration::from_secs(1),
+                        ..options.timeouts
+                    },
+                    ..options
+                },
+            )
+            .await?;
 
         let (coin_spends, did) = alice.wallet.create_did(0, false, true).await?;
         alice.transact(coin_spends).await?;
@@ -790,16 +809,43 @@ mod tests {
             .wallet
             .sign_take_offer(offer, &bob.agg_sig, bob.master_sk.clone())
             .await?;
+        assert_eq!(spend_bundle.coin_spends.len(), 3);
         bob.push_bundle(spend_bundle).await?;
 
         // We need to wait for both wallets to sync in this case
         bob.wait_for_coins().await;
 
+        // Resync to make sure the NFT is spendable even if it wasn't pending previously
+        bob.resync().await?;
+        bob.wait_for_puzzles().await;
+        bob.wait_for_puzzles().await;
+
         // Check balances
-        assert_ne!(
-            bob.wallet.db.spendable_nft(nft.info.launcher_id).await?,
-            None
-        );
+        let nft = bob
+            .wallet
+            .db
+            .spendable_nft(nft.info.launcher_id)
+            .await?
+            .expect("NFT should be spendable");
+
+        let coin_id = bob
+            .wallet
+            .db
+            .nft_row(nft.info.launcher_id)
+            .await?
+            .expect("NFT should exist")
+            .coin_id;
+
+        let is_spent = bob
+            .wallet
+            .db
+            .coin_state(coin_id)
+            .await?
+            .expect("coin should exist")
+            .spent_height
+            .is_some();
+
+        assert!(!is_spent);
 
         Ok(())
     }

crates/sage/src/sage.rs

@@ -220,6 +220,7 @@ impl Sage {
                 max_peer_age_seconds: 3600 * 8,
                 dns_batch_size: 10,
                 connection_batch_size: 30,
+                puzzle_batch_size_per_peer: 5,
                 timeouts: Timeouts::default(),
                 testing: false,
             },