fixed responses

Author: itsHaseebSaeed

contracts/liquidity_book/lb_pair/lb_pair.md

@@ -30,6 +30,8 @@ pub struct BinResponse {
 }
 ```
 
+`BinResponse` is used multiple times across the responses
+
 After obtaining the database of all the bins, it's necessary to maintain and check the changes made in the reserves. This allows for updating specific bins instead of all 'heights'.
 
 ### Queries for Fetching heights at which Bins updated
@@ -61,15 +63,13 @@ GetUpdatedBinAtMultipleHeights { heights: Vec<u64> },
 to receive:
 
 ```rust
-pub struct UpdatedBinsAtHeightResponse {
-    pub height: u64,
-    pub ids: Vec<u32>,
-}
-pub struct UpdatedBinsAtMultipleHeightResponse(pub Vec<UpdatedBinsAtHeightResponse>);
+pub struct UpdatedBinsAtHeightResponse(pub Vec<BinResponse>);
+
+pub struct UpdatedBinsAtMultipleHeightResponse(pub Vec<BinResponse>);
 
 ```
 
-Update `last_update_height` to the last index of `Vec<UpdatedBinsAtHeightResponse>`.
+Update `last_update_height` to the last index of `Vec<BinResponse>`.
 Then, query heights again, focusing only on `heights` > `last_updated_height`.
 
 
@@ -87,11 +87,10 @@ GetUpdatedBinAfterHeight {
 ```
 to receive:
 ```rust
-pub struct UpdatedBinsAtHeightResponse {
-    pub height: u64,
-    pub ids: Vec<u32>,
+pub struct UpdatedBinsAfterHeightResponse {
+    pub bins: Vec<BinResponse>,
+    pub current_block_height: u64,
 }
-pub struct UpdatedBinsAfterHeightResponse(pub Vec<UpdatedBinsAtHeightResponse>);
 ```
 
 Using the response, the admin updates all the bin reserves and stores the `height` in the vector as `last_updated_height`. Then, send that height to `GetUpdatedBinAfterHeight` to get `GetUpdatedBinAfterHeight`, thus continuing the loop.

contracts/liquidity_book/lb_pair/src/contract.rs

@@ -1832,7 +1832,7 @@ pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> Result<Binary> {
             height,
             page,
             page_size,
-        } => query_updated_bins_after_height(deps, height, page, page_size),
+        } => query_updated_bins_after_height(deps, env, height, page, page_size),
 
         QueryMsg::GetBinUpdatingHeights { page, page_size } => {
             query_bins_updating_heights(deps, page, page_size)
@@ -2156,7 +2156,7 @@ fn query_all_bins_reserves(
     let response = AllBinsResponse {
         reserves: bin_responses,
         last_id: id,
-        last_block_height: env.block.height,
+        current_block_height: env.block.height,
     };
     to_binary(&response).map_err(Error::CwErr)
 }
@@ -2189,51 +2189,62 @@ fn query_bins_reserves(deps: Deps, ids: Vec<u32>) -> Result<Binary> {
 fn query_updated_bins_at_height(deps: Deps, height: u64) -> Result<Binary> {
     let ids = BIN_RESERVES_UPDATED.load(deps.storage, height)?;
 
-    let response: UpdatedBinsAtHeightResponse = UpdatedBinsAtHeightResponse { height, ids };
+    let mut bin_responses = Vec::new();
+
+    for id in ids {
+        let bin: Bytes32 = BIN_MAP.load(deps.storage, id).unwrap_or([0u8; 32]);
+        let (bin_reserve_x, bin_reserve_y) = bin.decode();
+        bin_responses.push(BinResponse {
+            bin_reserve_x,
+            bin_reserve_y,
+            bin_id: id,
+        });
+    }
+
+    let response: UpdatedBinsAtHeightResponse = UpdatedBinsAtHeightResponse(bin_responses);
 
     to_binary(&response).map_err(Error::CwErr)
 }
 
+use std::collections::HashSet;
+
 fn query_updated_bins_at_multiple_heights(deps: Deps, heights: Vec<u64>) -> Result<Binary> {
-    let mut updates = Vec::new();
+    let mut bin_responses = Vec::new();
+    let mut processed_ids = HashSet::new();
+
     for height in heights {
         let ids = BIN_RESERVES_UPDATED.load(deps.storage, height)?;
-        updates.push(UpdatedBinsAtHeightResponse { height, ids });
+
+        for id in ids {
+            // Check if the id has already been processed
+            if processed_ids.insert(id) {
+                let bin: Bytes32 = BIN_MAP.load(deps.storage, id).unwrap_or([0u8; 32]);
+                let (bin_reserve_x, bin_reserve_y) = bin.decode();
+                bin_responses.push(BinResponse {
+                    bin_reserve_x,
+                    bin_reserve_y,
+                    bin_id: id,
+                });
+            }
+        }
     }
 
     let response: UpdatedBinsAtMultipleHeightResponse =
-        UpdatedBinsAtMultipleHeightResponse(updates);
-
-    to_binary(&response).map_err(Error::CwErr)
-}
-
-fn query_bins_updating_heights(
-    deps: Deps,
-    page: Option<u32>,
-    page_size: Option<u32>,
-) -> Result<Binary> {
-    let page = page.unwrap_or(0);
-    let page_size = page_size.unwrap_or(10);
-    let txs: StdResult<Vec<u64>> = BIN_RESERVES_UPDATED_LOG
-        .iter(deps.storage)?
-        .rev()
-        .skip((page * page_size) as usize)
-        .take(page_size as usize)
-        .collect();
-
-    let response = BinUpdatingHeightsResponse(txs?);
+        UpdatedBinsAtMultipleHeightResponse(bin_responses);
 
     to_binary(&response).map_err(Error::CwErr)
 }
 
 fn query_updated_bins_after_height(
     deps: Deps,
+    env: Env,
     height: u64,
     page: Option<u32>,
     page_size: Option<u32>,
 ) -> Result<Binary> {
     let page = page.unwrap_or(0);
     let page_size = page_size.unwrap_or(10);
+    let mut processed_ids = HashSet::new();
 
     let heights: StdResult<Vec<u64>> = BIN_RESERVES_UPDATED_LOG
         .iter(deps.storage)?
@@ -2252,13 +2263,47 @@ fn query_updated_bins_after_height(
         .take(page_size as usize)
         .collect();
 
-    let mut updates = Vec::new();
+    let mut bin_responses = Vec::new();
+
     for height in heights? {
         let ids = BIN_RESERVES_UPDATED.load(deps.storage, height)?;
-        updates.push(UpdatedBinsAtHeightResponse { height, ids });
+
+        for id in ids {
+            if processed_ids.insert(id) {
+                let bin: Bytes32 = BIN_MAP.load(deps.storage, id).unwrap_or([0u8; 32]);
+                let (bin_reserve_x, bin_reserve_y) = bin.decode();
+                bin_responses.push(BinResponse {
+                    bin_reserve_x,
+                    bin_reserve_y,
+                    bin_id: id,
+                });
+            }
+        }
     }
 
-    let response = UpdatedBinsAfterHeightResponse(updates);
+    let response = UpdatedBinsAfterHeightResponse {
+        bins: bin_responses,
+        current_block_height: env.block.height,
+    };
+
+    to_binary(&response).map_err(Error::CwErr)
+}
+
+fn query_bins_updating_heights(
+    deps: Deps,
+    page: Option<u32>,
+    page_size: Option<u32>,
+) -> Result<Binary> {
+    let page = page.unwrap_or(0);
+    let page_size = page_size.unwrap_or(10);
+    let txs: StdResult<Vec<u64>> = BIN_RESERVES_UPDATED_LOG
+        .iter(deps.storage)?
+        .rev()
+        .skip((page * page_size) as usize)
+        .take(page_size as usize)
+        .collect();
+
+    let response = BinUpdatingHeightsResponse(txs?);
 
     to_binary(&response).map_err(Error::CwErr)
 }

contracts/liquidity_book/tests/src/multitests/lb_pair_queries.rs

@@ -329,8 +329,7 @@ pub fn test_query_bins_reserves() -> Result<(), anyhow::Error> {
 
         assert!(balance > Uint256::MIN, "test_sample_mint::9");
     }
-    println!("ids: {:?}", ids);
-    println!("reserves: {:?}", reserves);
+
     Ok(())
 }
 
@@ -352,14 +351,14 @@ pub fn test_query_all_bins_reserves() -> Result<(), anyhow::Error> {
         ids.push(id);
     }
 
-    let (multiple_reserves, last_id) =
+    let (multiple_reserves, last_id, _) =
         lb_pair::query_all_bins_reserves(&app, &lb_pair.lb_pair.contract, None, None, Some(5))?;
 
     //checking pagination
     assert_eq!(last_id, ids[4]);
     assert_eq!(multiple_reserves.len(), 5);
 
-    let (multiple_reserves, last_id) = lb_pair::query_all_bins_reserves(
+    let (multiple_reserves, last_id, _) = lb_pair::query_all_bins_reserves(
         &app,
         &lb_pair.lb_pair.contract,
         Some(last_id),
@@ -371,7 +370,7 @@ pub fn test_query_all_bins_reserves() -> Result<(), anyhow::Error> {
     assert_eq!(last_id, ids[9]);
     assert_eq!(multiple_reserves.len(), 5);
 
-    let (multiple_reserves, last_id) = lb_pair::query_all_bins_reserves(
+    let (multiple_reserves, last_id, _) = lb_pair::query_all_bins_reserves(
         &app,
         &lb_pair.lb_pair.contract,
         Some(last_id),
@@ -383,7 +382,7 @@ pub fn test_query_all_bins_reserves() -> Result<(), anyhow::Error> {
     assert_eq!(last_id, ids[14]);
     assert_eq!(multiple_reserves.len(), 5);
 
-    let (multiple_reserves, last_id) = lb_pair::query_all_bins_reserves(
+    let (multiple_reserves, last_id, _) = lb_pair::query_all_bins_reserves(
         &app,
         &lb_pair.lb_pair.contract,
         Some(last_id),
@@ -395,7 +394,7 @@ pub fn test_query_all_bins_reserves() -> Result<(), anyhow::Error> {
     assert_eq!(last_id, 0);
     assert_eq!(multiple_reserves.len(), 4);
 
-    let (multiple_reserves, last_id) =
+    let (multiple_reserves, last_id, _) =
         lb_pair::query_all_bins_reserves(&app, &lb_pair.lb_pair.contract, None, None, Some(50))?;
     assert_eq!(last_id, 0);
 
@@ -646,12 +645,15 @@ pub fn test_query_update_at_height() -> Result<(), anyhow::Error> {
 
     let height = heights[0];
 
-    let (query_height, mut query_ids) =
+    let bin_responses =
         lb_pair::query_updated_bins_at_height(&app, &lb_pair.lb_pair.contract, height)?;
+    let mut bin_ids: Vec<u32> = bin_responses
+        .into_iter()
+        .map(|response| response.bin_id)
+        .collect();
+    bin_ids.sort();
 
-    assert_eq!(query_height, height);
-
-    assert_eq!(query_ids.sort(), ids.sort());
+    assert_eq!(bin_ids, ids);
 
     Ok(())
 }
@@ -687,12 +689,13 @@ pub fn test_query_update_at_multiple_heights() -> Result<(), anyhow::Error> {
 
     let height = heights[0];
 
-    let (query_height, mut query_ids) =
-        lb_pair::query_updated_bins_at_height(&app, &lb_pair.lb_pair.contract, height)?;
+    let mut query_ids: Vec<u32> =
+        lb_pair::query_updated_bins_at_height(&app, &lb_pair.lb_pair.contract, height)?
+            .into_iter()
+            .map(|x| x.bin_id)
+            .collect();
 
-    assert_eq!(query_height, height);
-
-    assert_eq!(query_ids.sort(), ids.sort());
+    assert_eq!(query_ids, ids);
 
     roll_blockchain(&mut app, None);
 
@@ -717,16 +720,15 @@ pub fn test_query_update_at_multiple_heights() -> Result<(), anyhow::Error> {
     heights.sort();
     assert_eq!(heights.len(), 50);
     //user have all the heights now
-    let updated_bins = lb_pair::query_updated_bins_at_multiple_heights(
+    let updated_bins: Vec<u32> = lb_pair::query_updated_bins_at_multiple_heights(
         &app,
         &lb_pair.lb_pair.contract,
         heights.clone(),
-    )?;
-
-    for (updated_bin, h) in updated_bins.iter().zip(heights) {
-        assert_eq!(updated_bin.height, h);
-        assert_eq!(updated_bin.ids, ids);
-    }
+    )?
+    .into_iter()
+    .map(|x| x.bin_id)
+    .collect();
+    assert_eq!(updated_bins, ids);
 
     Ok(())
 }
@@ -762,12 +764,13 @@ pub fn test_query_update_after_height() -> Result<(), anyhow::Error> {
 
     let height = heights[0];
 
-    let (query_height, mut query_ids) =
-        lb_pair::query_updated_bins_at_height(&app, &lb_pair.lb_pair.contract, height)?;
-
-    assert_eq!(query_height, height);
+    let query_ids: Vec<u32> =
+        lb_pair::query_updated_bins_at_height(&app, &lb_pair.lb_pair.contract, height)?
+            .into_iter()
+            .map(|x| x.bin_id)
+            .collect();
 
-    assert_eq!(query_ids.sort(), ids.sort());
+    assert_eq!(query_ids, ids);
 
     for _ in 0..49 {
         roll_blockchain(&mut app, None);
@@ -790,35 +793,35 @@ pub fn test_query_update_after_height() -> Result<(), anyhow::Error> {
     heights.sort();
     assert_eq!(heights.len(), 50);
     //user have all the heights now
-    let updated_bins = lb_pair::query_updated_bins_after_multiple_heights(
+    let (updated_bins, _) = lb_pair::query_updated_bins_after_multiple_heights(
         &app,
         &lb_pair.lb_pair.contract,
         heights[0],
         Some(0),
         Some(10),
     )?;
 
-    assert_eq!(updated_bins.len(), 10);
+    assert_eq!(updated_bins.len(), 19); //All the bins changed
 
-    let updated_bins = lb_pair::query_updated_bins_after_multiple_heights(
+    let (updated_bins, _) = lb_pair::query_updated_bins_after_multiple_heights(
         &app,
         &lb_pair.lb_pair.contract,
         heights[0],
         Some(0),
         Some(20),
     )?;
 
-    assert_eq!(updated_bins.len(), 20);
+    assert_eq!(updated_bins.len(), 19);
 
-    let updated_bins = lb_pair::query_updated_bins_after_multiple_heights(
+    let (updated_bins, _) = lb_pair::query_updated_bins_after_multiple_heights(
         &app,
         &lb_pair.lb_pair.contract,
         heights[0],
         Some(0),
         Some(100),
     )?;
 
-    assert_eq!(updated_bins.len(), 49);
+    assert_eq!(updated_bins.len(), 19);
 
     Ok(())
 }