fix: add validation on settle_auction to make sure the previous aucti…

…on has been settled; remove rewards_basket from state as it will always be outdated, pass it on settle auction as input parameter now

contracts/injective-auction-pool/src/contract.rs

@@ -61,7 +61,7 @@ pub fn instantiate(
 
     FUNDS_LOCKED.save(deps.storage, &false)?;
 
-    let (messages, attributes) = new_auction_round(deps, &env, info, None, None)?;
+    let (messages, attributes) = new_auction_round(deps, &env, info, None, None, vec![])?;
 
     Ok(Response::default()
         .add_messages(messages)
@@ -111,7 +111,16 @@ pub fn execute(
             auction_round,
             auction_winner,
             auction_winning_bid,
-        } => settle_auction(deps, env, info, auction_round, auction_winner, auction_winning_bid),
+            basket_rewards,
+        } => settle_auction(
+            deps,
+            env,
+            info,
+            auction_round,
+            auction_winner,
+            auction_winning_bid,
+            basket_rewards,
+        ),
     }
 }
 

contracts/injective-auction-pool/src/error.rs

@@ -84,6 +84,18 @@ pub enum ContractError {
 
     #[error("Semver parsing error: {0}")]
     SemVer(String),
+
+    #[error(
+        "Previous auction round has not been settled. Unsettled auction round: {unsettled_auction_round}.\
+         Current auction round: {current_auction_round}"
+    )]
+    AuctionRoundNotSettled {
+        unsettled_auction_round: u64,
+        current_auction_round: u64,
+    },
+
+    #[error("Basket rewards is empty")]
+    EmptyBasketRewards {},
 }
 
 impl From<semver::Error> for ContractError {

contracts/injective-auction-pool/src/executions.rs

@@ -119,10 +119,21 @@ pub(crate) fn join_pool(
         });
     }
 
-    let mut messages = vec![];
+    let unsettled_auction = UNSETTLED_AUCTION.load(deps.storage)?;
+
+    // if the current auction round is different from the unsettled auction round,
+    // prevent the user from joining the pool
+    if unsettled_auction.auction_round != current_auction_round.u64() {
+        return Err(ContractError::AuctionRoundNotSettled {
+            unsettled_auction_round: unsettled_auction.auction_round,
+            current_auction_round: current_auction_round.u64(),
+        });
+    }
 
     // mint the lp token and send it to the user
-    let lp_subdenom = UNSETTLED_AUCTION.load(deps.storage)?.lp_subdenom;
+    let mut messages = vec![];
+    let lp_subdenom = unsettled_auction.lp_subdenom;
+
     messages.push(config.token_factory_type.mint(
         env.contract.address.clone(),
         format!("factory/{}/auction.{}", env.contract.address.clone(), lp_subdenom).as_str(),
@@ -283,6 +294,7 @@ pub fn settle_auction(
     auction_round: u64,
     auction_winner: String,
     auction_winning_bid: Uint128,
+    basket_reward: Vec<cosmwasm_std::Coin>,
 ) -> Result<Response, ContractError> {
     // only whitelist addresses can settle the auction for now until the
     // contract can query the aunction module for a specific auction round
@@ -311,8 +323,14 @@ pub fn settle_auction(
 
     FUNDS_LOCKED.save(deps.storage, &false)?;
 
-    let (messages, attributes) =
-        new_auction_round(deps, &env, info, Some(auction_winner), Some(auction_winning_bid))?;
+    let (messages, attributes) = new_auction_round(
+        deps,
+        &env,
+        info,
+        Some(auction_winner),
+        Some(auction_winning_bid),
+        basket_reward,
+    )?;
 
     Ok(Response::default()
         .add_attribute("action", "settle_auction")

contracts/injective-auction-pool/src/helpers.rs

@@ -1,5 +1,3 @@
-use std::str::FromStr;
-
 use cosmwasm_std::{
     attr, instantiate2_address, to_json_binary, Addr, Attribute, BankMsg, Binary, CanonicalAddr,
     CodeInfoResponse, Coin, CosmosMsg, CustomQuery, Decimal, Deps, DepsMut, Env, MessageInfo,
@@ -53,29 +51,15 @@ pub(crate) fn new_auction_round(
     _info: MessageInfo,
     auction_winner: Option<String>,
     auction_winning_bid: Option<Uint128>,
+    basket_reward: Vec<Coin>,
 ) -> Result<(Vec<CosmosMsg>, Vec<Attribute>), ContractError> {
     let config = CONFIG.load(deps.storage)?;
 
-    // TODO: check that info.sender is whitelisted & test it
-    // if !WHITELISTED_ADDRESSES.has(deps.storage, &_info.sender) {
-    //     return Err(ContractError::Unauthorized {});
-    // }
-
     // fetch current auction details and save them in the contract state
     let current_auction_round_response = query_current_auction(deps.as_ref())?;
 
     let current_auction_round = current_auction_round_response.auction_round;
 
-    let current_basket = current_auction_round_response
-        .amount
-        .iter()
-        .map(|coin| Coin {
-            amount: Uint128::from_str(&coin.amount.to_string())
-                .expect("Failed to parse coin amount"),
-            denom: coin.denom.clone(),
-        })
-        .collect();
-
     let unsettled_auction = UNSETTLED_AUCTION.may_load(deps.storage)?;
 
     let mut attributes = vec![];
@@ -100,7 +84,6 @@ pub(crate) fn new_auction_round(
                     }),
                 )?;
 
-                let unsettled_basket = unsettled_auction.basket;
                 let mut basket_fees = vec![];
                 let mut basket_to_treasure_chest = vec![];
 
@@ -117,7 +100,11 @@ pub(crate) fn new_auction_round(
                 }
 
                 // split the basket, taking the rewards fees into account
-                for coin in unsettled_basket.iter() {
+                if basket_reward.is_empty() {
+                    return Err(ContractError::EmptyBasketRewards {});
+                }
+
+                for coin in basket_reward.iter() {
                     let fee = coin.amount * config.rewards_fee;
                     basket_fees.push(Coin {
                         denom: coin.denom.clone(),
@@ -189,20 +176,9 @@ pub(crate) fn new_auction_round(
                     format!("auction.{}", new_subdenom).as_str(),
                 ));
 
-                let basket = current_auction_round_response
-                    .amount
-                    .iter()
-                    .map(|coin| Coin {
-                        amount: Uint128::from_str(&coin.amount.to_string())
-                            .expect("Failed to parse coin amount"),
-                        denom: coin.denom.clone(),
-                    })
-                    .collect();
-
                 UNSETTLED_AUCTION.save(
                     deps.storage,
                     &Auction {
-                        basket,
                         auction_round: current_auction_round_response.auction_round.u64(),
                         lp_subdenom: new_subdenom,
                         closing_time: current_auction_round_response.auction_closing_time.i64()
@@ -226,15 +202,6 @@ pub(crate) fn new_auction_round(
                 UNSETTLED_AUCTION.save(
                     deps.storage,
                     &Auction {
-                        basket: current_auction_round_response
-                            .amount
-                            .iter()
-                            .map(|coin| Coin {
-                                amount: Uint128::from_str(&coin.amount.to_string())
-                                    .expect("Failed to parse coin amount"),
-                                denom: coin.denom.clone(),
-                            })
-                            .collect(),
                         auction_round: current_auction_round_response.auction_round.u64(),
                         lp_subdenom: unsettled_auction.lp_subdenom,
                         closing_time: current_auction_round_response.auction_closing_time.i64()
@@ -254,7 +221,6 @@ pub(crate) fn new_auction_round(
             UNSETTLED_AUCTION.save(
                 deps.storage,
                 &Auction {
-                    basket: current_basket,
                     auction_round: current_auction_round_response.auction_round.u64(),
                     lp_subdenom: 0,
                     closing_time: current_auction_round_response.auction_closing_time.i64() as u64,

contracts/injective-auction-pool/src/state.rs

@@ -5,8 +5,6 @@ use injective_auction::auction_pool::Config;
 
 #[cw_serde]
 pub struct Auction {
-    /// The coins in the basket being auctioned
-    pub basket: Vec<Coin>,
     /// The auction round number
     pub auction_round: u64,
     /// A unique number that is used to create new token factory denoms

packages/injective_auction/src/auction_pool.rs

@@ -1,7 +1,8 @@
 use cosmwasm_schema::{cw_serde, QueryResponses};
+use cosmwasm_std::Coin;
 use cosmwasm_std::{Addr, Decimal, Uint128};
 use cw_ownable::{cw_ownable_execute, cw_ownable_query};
-use treasurechest::tf::{injective::denom::Coin, tokenfactory::TokenFactoryType};
+use treasurechest::tf::tokenfactory::TokenFactoryType;
 
 #[cw_serde]
 pub struct InstantiateMsg {
@@ -61,6 +62,9 @@ pub enum ExecuteMsg {
         auction_winner: String,
         /// The amount bid by the winner of the auction
         auction_winning_bid: Uint128,
+        /// The rewards to be sent to the vault. As rewards are being added to the auction module
+        /// on each block, the eaact amount can only be know once the auction is finished
+        basket_rewards: Vec<Coin>,
     },
 }