Feat/update next game (#26)

* half testing

* stable version, not fully tested

* update_next_game

* optimizer v16

* add transfer nft message and reply

* remove migrate

* remove migrate msg fields

* end restart button on homepage

Author: magiodev

.github/workflows/build.yml

@@ -36,5 +36,5 @@ jobs:
             -v "$(pwd)":/code \
             --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \
             --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
-            cosmwasm/workspace-optimizer:0.15.0 \
+            cosmwasm/workspace-optimizer:0.16.0 \
             /code

contracts/prudent-pots/src/contract.rs

@@ -6,7 +6,9 @@ use cosmwasm_std::{
 use cw2::set_contract_version;
 
 use crate::error::ContractError;
-use crate::execute::{allocate_tokens, game_end, reallocate_tokens, update_config};
+use crate::execute::{
+    allocate_tokens, game_end, reallocate_tokens, update_config, update_next_game,
+};
 use crate::helpers::game_end::prepare_next_game;
 use crate::helpers::validate::{validate_funds, validate_pot_initial_amount};
 use crate::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg, ReplyMsg};
@@ -16,8 +18,8 @@ use crate::query::{
     query_raffle, query_raffle_denom_split, query_raffle_winner, query_reallocation_fee_pool,
     query_winning_pots,
 };
-use crate::reply::game_end_reply;
-use crate::state::{GameConfig, GAME_CONFIG, OLD_GAME_CONFIG, REALLOCATION_FEE_POOL};
+use crate::reply::transfer_nft_reply;
+use crate::state::{GAME_CONFIG, REALLOCATION_FEE_POOL};
 
 // version info for migration info
 const CONTRACT_NAME: &str = "crates.io:prudent-pots";
@@ -93,13 +95,25 @@ pub fn execute(
             raffle_cw721_token_addr,
             next_game_start,
         ),
+        ExecuteMsg::UpdateNextGame {
+            raffle_cw721_token_id,
+            raffle_cw721_token_addr,
+            next_game_start,
+        } => update_next_game(
+            deps,
+            env,
+            info,
+            raffle_cw721_token_id,
+            raffle_cw721_token_addr,
+            next_game_start,
+        ),
     }
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn reply(_deps: DepsMut, _env: Env, msg: Reply) -> Result<Response, ContractError> {
     match msg.id.into() {
-        ReplyMsg::GameEnd {} => game_end_reply(msg.result),
+        ReplyMsg::TransferNft {} => transfer_nft_reply(msg.result),
         _ => Err(ContractError::UnknownReply {}),
     }
 }
@@ -128,31 +142,6 @@ pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
-pub fn migrate(deps: DepsMut, _env: Env, msg: MigrateMsg) -> Result<Response, ContractError> {
-    // load the old game config
-    let old_game_config = OLD_GAME_CONFIG.load(deps.storage)?;
-
-    // Save new GameConfig at game_config_v2 storage key
-    GAME_CONFIG.save(
-        deps.storage,
-        &GameConfig {
-            fee: old_game_config.fee,
-            fee_reallocation: old_game_config.fee_reallocation,
-            fee_address: old_game_config.fee_address,
-            game_denom: old_game_config.game_denom,
-            game_cw721_addrs: old_game_config.game_cw721_addrs,
-            game_duration: old_game_config.game_duration,
-            game_duration_epoch: msg.game_duration_epoch, // this is from migrateMsg
-            game_extend: old_game_config.game_extend,
-            game_end_threshold: old_game_config.game_end_threshold,
-            min_pot_initial_allocation: old_game_config.min_pot_initial_allocation,
-            decay_factor: msg.decay_factor, // this is from migrateMsg
-            reallocations_limit: old_game_config.reallocations_limit,
-        },
-    )?;
-
-    // remove the old game config
-    OLD_GAME_CONFIG.remove(deps.storage);
-
+pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
     Ok(Response::new().add_attribute("migrate", "successful"))
 }

contracts/prudent-pots/src/execute.rs

@@ -1,7 +1,8 @@
 use std::str::FromStr;
 
 use cosmwasm_std::{
-    attr, BankMsg, CosmosMsg, Decimal, DepsMut, Env, MessageInfo, Response, Uint128,
+    attr, to_json_binary, BankMsg, CosmosMsg, Decimal, DepsMut, Env, MessageInfo, Response, SubMsg,
+    Uint128, WasmMsg,
 };
 
 use crate::{
@@ -20,8 +21,8 @@ use crate::{
             validate_is_contract_admin_game_end, validate_pot_limit_not_exceeded,
         },
     },
-    msg::UpdateGameConfig,
-    state::{GAME_CONFIG, GAME_STATE, PLAYER_ALLOCATIONS, REALLOCATION_FEE_POOL},
+    msg::{ReplyMsg, UpdateGameConfig},
+    state::{GAME_CONFIG, GAME_STATE, PLAYER_ALLOCATIONS, RAFFLE, REALLOCATION_FEE_POOL},
     ContractError,
 };
 
@@ -311,3 +312,105 @@ pub fn game_end(
         .add_attributes(process_raffle_winner_resp.attributes) // this contains the raffle event attributes including the treasury denom fee split, which is not included above
         .add_attribute("total_outgoing_tokens", total_outgoing_tokens)) // this is the total of distribution + raffle + treasury
 }
+
+pub fn update_next_game(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+    new_raffle_cw721_id: Option<String>,
+    new_raffle_cw721_addr: Option<String>,
+    next_game_start: Option<u64>,
+) -> Result<Response, ContractError> {
+    validate_is_contract_admin(&deps.querier, &env, &info.sender)?;
+
+    let mut submsgs: Vec<SubMsg> = vec![];
+    let mut response_attributes = vec![];
+
+    // Handle start time update
+    if let Some(start_time) = next_game_start {
+        // If next_game_start is passed, it should be in the future
+        if start_time <= env.block.time.seconds() {
+            return Err(ContractError::InvalidNextGameStart {});
+        }
+
+        let game_duration = GAME_CONFIG.load(deps.storage)?.game_duration;
+        GAME_STATE.update(deps.storage, |mut game_state| -> Result<_, ContractError> {
+            game_state.start_time = start_time;
+            game_state.end_time = start_time + game_duration;
+            Ok(game_state)
+        })?;
+
+        response_attributes.push(attr("next_game_start", start_time.to_string()));
+    }
+
+    // Handle raffle NFT update, if a raffle_id is passed we assume we want to set an NFT for the next round's raffle
+    if let Some(raffle_id) = &new_raffle_cw721_id {
+        // Ensure both or neither options are provided or throw an error
+        if new_raffle_cw721_id.is_some() != new_raffle_cw721_addr.is_some() {
+            return Err(ContractError::InvalidRaffleNft {});
+        }
+
+        // Update the raffle CW721 token ID and address, only if there is no one yet
+        RAFFLE.update(deps.storage, |mut raffle| -> Result<_, ContractError> {
+            if raffle.cw721_token_id.is_none() {
+                raffle.cw721_token_id = Some(raffle_id.clone());
+                raffle.cw721_addr = new_raffle_cw721_addr.clone();
+            } else {
+                // Otherwise throw
+                return Err(ContractError::InvalidRaffleNft {});
+            }
+            Ok(raffle)
+        })?;
+
+        // Transfer the NFT
+        let transfer_nft_msg = SubMsg::reply_always(
+            WasmMsg::Execute {
+                contract_addr: new_raffle_cw721_addr.clone().unwrap(),
+                msg: to_json_binary(&cw721::Cw721ExecuteMsg::TransferNft {
+                    recipient: env.contract.address.to_string(),
+                    token_id: raffle_id.to_string(),
+                })?,
+                funds: vec![],
+            },
+            ReplyMsg::TransferNft as u64,
+        );
+        submsgs.push(transfer_nft_msg);
+        response_attributes.extend(vec![
+            attr("raffle_cw721_addr", new_raffle_cw721_addr.unwrap()),
+            attr("raffle_cw721_id", raffle_id),
+        ]);
+    }
+
+    // Handle raffle funds update, validate_funds to obtain current sent funds
+    let game_denom = GAME_CONFIG.load(deps.storage)?.game_denom;
+    let total_amount = validate_funds(&info.funds, &game_denom).unwrap_or_default();
+    if !total_amount.is_zero() {
+        // Update the denom amount for the next raffle incrementing any previous value
+        RAFFLE.update(deps.storage, |mut raffle| -> Result<_, ContractError> {
+            raffle.denom_amount += total_amount;
+            Ok(raffle)
+        })?;
+        response_attributes.push(attr("raffle_denom_amount", total_amount.to_string()));
+        // this is only the new amount sent
+    }
+
+    // Throw an error if we did nothing in the previous workflow, this method is meant to be executed for a reason
+    if response_attributes.is_empty() {
+        return Err(ContractError::InvalidInput {});
+    }
+
+    // Create response with dynamic attributes based on the current execution
+    let mut response = Response::new()
+        .add_attributes(vec![
+            attr("method", "execute"),
+            attr("action", "update_next_game"),
+        ])
+        .add_attributes(response_attributes);
+
+    // If submsgs is not empty, append the message to transfer the NFT
+    if !submsgs.is_empty() {
+        response = response.add_submessages(submsgs);
+    }
+
+    Ok(response)
+}

contracts/prudent-pots/src/helpers/game_end.rs

@@ -190,8 +190,8 @@ pub fn process_raffle_winner(
     // TODO_FUTURE: Early return here if there is no raffle
     // if raffle.nft_id && addr is none and denom_prize is_zero() return all default values.
 
-    let mut msgs = Vec::new();
-    let mut submsgs = Vec::new();
+    let mut msgs = vec![];
+    let mut submsgs = vec![];
     let mut raffle_response_attributes = vec![];
 
     // this is common for yes_raffle and no_raffle scenarios
@@ -213,12 +213,11 @@ pub fn process_raffle_winner(
                         })?,
                         funds: vec![],
                     },
-                    ReplyMsg::GameEnd as u64,
+                    ReplyMsg::TransferNft as u64,
                 );
                 submsgs.push(transfer_nft_msg);
                 // Append attributes
                 raffle_response_attributes.extend(vec![
-                    attr("raffle_winner", recipient.to_string()),
                     attr("raffle_outgoing_nft_addr", cw721_addr),
                     attr("raffle_outgoing_nft_id", token_id),
                 ]);
@@ -233,10 +232,10 @@ pub fn process_raffle_winner(
                 msgs.push(send_msg);
             }
             // Append attributes
-            raffle_response_attributes.extend(vec![attr(
-                "raffle_outgoing_tokens_winner",
-                prize_to_distribute,
-            )]);
+            raffle_response_attributes.extend(vec![
+                attr("raffle_winner", recipient.to_string()),
+                attr("raffle_outgoing_tokens_winner", prize_to_distribute),
+            ]);
 
             if !prize_to_treasury.is_zero() {
                 let send_msg = CosmosMsg::Bank(BankMsg::Send {
@@ -289,7 +288,7 @@ pub fn process_raffle_winner(
                 })?,
                 funds: vec![],
             },
-            ReplyMsg::GameEnd as u64,
+            ReplyMsg::TransferNft as u64,
         );
         submsgs.push(transfer_nft_msg);
     }

contracts/prudent-pots/src/msg.rs

@@ -43,14 +43,19 @@ pub enum ExecuteMsg {
         raffle_cw721_token_addr: Option<String>,
         next_game_start: Option<u64>,
     },
+    UpdateNextGame {
+        raffle_cw721_token_id: Option<String>,
+        raffle_cw721_token_addr: Option<String>,
+        next_game_start: Option<u64>,
+    },
 }
 
 /// Reply
 
 #[derive(FromPrimitive, IntoPrimitive)]
 #[repr(u64)]
 pub enum ReplyMsg {
-    GameEnd = 1,
+    TransferNft = 1,
     #[default]
     Unknown,
 }
@@ -154,7 +159,4 @@ pub struct RaffleDenomSplitResponse {
 }
 
 #[cw_serde]
-pub struct MigrateMsg {
-    pub game_duration_epoch: u64,
-    pub decay_factor: Decimal,
-}
+pub struct MigrateMsg {}

contracts/prudent-pots/src/reply.rs

@@ -3,11 +3,11 @@ use cosmwasm_std::{attr, Response, SubMsgResult};
 use crate::ContractError;
 
 // This reply function is called by reply_always. This should only do nothing, or throw an error, foreach NFT send during game_end workflow to the raflle winner.
-pub fn game_end_reply(msg: SubMsgResult) -> Result<Response, ContractError> {
+pub fn transfer_nft_reply(msg: SubMsgResult) -> Result<Response, ContractError> {
     match msg.into() {
         Ok(_data) => Ok(Response::new().add_attributes(vec![
             attr("method", "reply"),
-            attr("action", "game_end_reply"),
+            attr("action", "transfer_nft_reply"),
         ])),
         _ => Err(ContractError::Cw721TokenNotReceived {}),
     }

contracts/prudent-pots/src/state.rs

@@ -66,7 +66,6 @@ pub struct FirstBidder {
     pub time: u64,
 }
 
-pub const OLD_GAME_CONFIG: Item<OldGameConfig> = Item::new("game_config");
 pub const GAME_CONFIG: Item<GameConfig> = Item::new("game_config_v2");
 pub const GAME_STATE: Item<GameState> = Item::new("game_state");
 pub const POT_STATES: Map<u8, TokenAllocation> = Map::new("pot_states");

contracts/prudent-pots/src/tests/integration/fixtures.rs

@@ -142,15 +142,16 @@ pub fn default_with_balances(
             mint_nfts(&mut app, &cw721_addr, 1, 10, Addr::unchecked(ADMIN_ADDRESS));
 
             // ApproveAll as admin to operator pp
-            let _ = app.execute_contract(
+            app.execute_contract(
                 Addr::unchecked(ADMIN_ADDRESS),
                 cw721_addr.clone(),
                 &cw721::Cw721ExecuteMsg::ApproveAll {
                     operator: pp_addr.to_string(),
                     expires: None,
                 },
                 &vec![],
-            );
+            )
+            .unwrap();
 
             // Update config to extend game duration
             update_config(

contracts/prudent-pots/src/tests/integration/helpers.rs

@@ -72,6 +72,26 @@ pub fn game_end(
     )
 }
 
+pub fn update_next_game(
+    app: &mut App,
+    pp_addr: &Addr,
+    info: &MessageInfo,
+    raffle_cw721_token_id: Option<String>,
+    raffle_cw721_token_addr: Option<String>,
+    next_game_start: Option<u64>,
+) -> Result<AppResponse, AnyError> {
+    app.execute_contract(
+        info.sender.clone(),
+        pp_addr.clone(),
+        &ExecuteMsg::UpdateNextGame {
+            raffle_cw721_token_id,
+            raffle_cw721_token_addr,
+            next_game_start,
+        },
+        &info.funds,
+    )
+}
+
 // CW721
 
 pub fn mint_nfts(app: &mut App, cw721_addr: &Addr, start_id: u64, count: u64, to_addr: Addr) {

contracts/prudent-pots/src/tests/integration/mod.rs

@@ -5,3 +5,4 @@ mod helpers;
 mod instantiate;
 mod reallocate_tokens;
 mod update_config;
+mod update_next_game;