seperate pick

artifacts/checksums.txt

@@ -1 +1 @@
-12bf66626d6c7972664a19b0c6394cf65de38a831d84c2340a096656316a5859  raffle_drop.wasm
+0e07d227b8272b94da7f5e020d401639fe23fd5ffaa1bcb62e365fb61712b8d8  raffle_drop.wasm

artifacts/checksums_intermediate.txt

@@ -1 +1 @@
-45da052c35dc16f3d2080236dbf00daac2d7c2e8850c897871c3b7d614b52152  /target/wasm32-unknown-unknown/release/raffle_drop.wasm
+2809aafd2d63401e1756729b144609a3692fda5be4ed3e020c7f1ae48d638152  /target/wasm32-unknown-unknown/release/raffle_drop.wasm

src/contract.rs

@@ -1,6 +1,8 @@
 use crate::error::ContractError;
 use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
-use crate::state::{ADMIN, NOIS_PROXY, PARTICIPANT_COUNT, TEST_WINNERS, WINNERS};
+use crate::state::{
+    ADMIN, FINAL_RANDOMNESS, NOIS_PROXY, PARTICIPANT_COUNT, TEST_RANDOMNESS, TEST_WINNERS, WINNERS,
+};
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
@@ -49,7 +51,9 @@ pub fn execute(
         ExecuteMsg::RequestRandomness { job_id } => {
             execute_request_randomness(deps, env, info, job_id)
         }
-        ExecuteMsg::NoisReceive { callback } => execute_pick_winners(deps, env, info, callback),
+        ExecuteMsg::NoisReceive { callback } => execute_set_randomness(deps, env, info, callback),
+        ExecuteMsg::PickTestWinners {} => pick_test_winners(deps, env, info),
+        ExecuteMsg::PickWinners {} => pick_winners(deps, env, info),
     }
 }
 
@@ -73,7 +77,7 @@ pub fn execute_request_randomness(
     Ok(res)
 }
 
-pub fn execute_pick_winners(
+pub fn execute_set_randomness(
     deps: DepsMut,
     _env: Env,
     info: MessageInfo,
@@ -86,34 +90,80 @@ pub fn execute_pick_winners(
         job_id, randomness, ..
     } = callback;
 
-    let randomness: [u8; 32] = randomness
-        .to_array()
-        .map_err(|_| ContractError::InvalidRandomness {})?;
+    if job_id.contains("test") {
+        TEST_RANDOMNESS.save(deps.storage, &randomness)?;
+    } else {
+        if FINAL_RANDOMNESS.may_load(deps.storage)?.is_some() {
+            return Err(ContractError::FinalRandomnessAlreadySet {});
+        }
+        FINAL_RANDOMNESS.save(deps.storage, &randomness)?;
+    }
 
+    let res = Response::new();
+    Ok(res)
+}
+
+pub fn pick_test_winners(
+    deps: DepsMut,
+    _env: Env,
+    _info: MessageInfo,
+) -> Result<Response, ContractError> {
     let participant_count = PARTICIPANT_COUNT.load(deps.storage)?;
-    let participant_arr = (1..=participant_count).collect::<Vec<u32>>();
+    let participants = (1..=participant_count).collect::<Vec<u32>>();
+    let test_randomness = TEST_RANDOMNESS.load(deps.storage)?;
+    let test_randomness_vec: [u8; 32] = test_randomness[..].try_into().unwrap();
 
-    let winners = pick(randomness, 100, participant_arr);
-    let winners_string = winners
+    if test_randomness.is_empty() {
+        return Err(ContractError::TestRandomnessNotSet {});
+    }
+
+    let winners = pick(test_randomness_vec, 100, participants);
+    let winners_str = winners
         .iter()
-        .map(|&x| x.to_string())
+        .map(|x| x.to_string())
         .collect::<Vec<String>>()
-        .join(", ");
+        .join(",");
+    TEST_WINNERS.save(deps.storage, &winners)?;
 
-    match job_id.as_str() {
-        "test" => {
-            TEST_WINNERS.save(deps.storage, &winners)?;
-        }
-        _ => {
-            let old_winners = WINNERS.may_load(deps.storage)?;
-            if old_winners.is_some() {
-                return Err(ContractError::WinnersAlreadyPicked {});
-            }
-            WINNERS.save(deps.storage, &winners)?;
-        }
+    let res = Response::new()
+        .add_attribute("action", "pick_test_winners")
+        .add_attribute("test winners", winners_str);
+    Ok(res)
+}
+
+pub fn pick_winners(
+    deps: DepsMut,
+    _env: Env,
+    info: MessageInfo,
+) -> Result<Response, ContractError> {
+    if info.sender != ADMIN.load(deps.storage)? {
+        return Err(ContractError::Unauthorized {});
     }
+    if WINNERS.may_load(deps.storage)?.is_some() {
+        return Err(ContractError::WinnersAlreadyPicked {});
+    }
+
+    let participant_count = PARTICIPANT_COUNT.load(deps.storage)?;
+    let participants = (1..=participant_count).collect::<Vec<u32>>();
+
+    let final_randomness = FINAL_RANDOMNESS
+        .load(deps.storage)
+        .map_err(|_| ContractError::FinalRandomnessNotSet {})?;
+    let final_randomness_vec: [u8; 32] = final_randomness[..].try_into().unwrap();
+
+    let winners = pick(final_randomness_vec, 100, participants);
+    let winners_str = winners
+        .iter()
+        .map(|x| x.to_string())
+        .collect::<Vec<String>>()
+        .join(",");
+
+    WINNERS.save(deps.storage, &winners)?;
+
+    let res = Response::new()
+        .add_attribute("action", "pick_winners")
+        .add_attribute("winners", winners_str);
 
-    let res = Response::new().add_attribute("winners", winners_string);
     Ok(res)
 }
 

src/error.rs

@@ -20,4 +20,13 @@ pub enum ContractError {
 
     #[error("Winners already picked")]
     WinnersAlreadyPicked {},
+
+    #[error("Test randomness not set")]
+    TestRandomnessNotSet {},
+
+    #[error("Final randomness not set")]
+    FinalRandomnessNotSet {},
+
+    #[error("Final randomness already set")]
+    FinalRandomnessAlreadySet {},
 }

src/msg.rs

@@ -11,6 +11,8 @@ pub struct InstantiateMsg {
 pub enum ExecuteMsg {
     RequestRandomness { job_id: String },
     NoisReceive { callback: NoisCallback },
+    PickTestWinners {},
+    PickWinners {},
 }
 
 #[cw_serde]

src/state.rs

@@ -1,8 +1,10 @@
-use cosmwasm_std::Addr;
+use cosmwasm_std::{Addr, HexBinary};
 use cw_storage_plus::Item;
 
 pub const PARTICIPANT_COUNT: Item<u32> = Item::new("participant_count");
 pub const NOIS_PROXY: Item<Addr> = Item::new("nois_proxy");
 pub const ADMIN: Item<Addr> = Item::new("admin");
 pub const WINNERS: Item<Vec<u32>> = Item::new("winners");
 pub const TEST_WINNERS: Item<Vec<u32>> = Item::new("test_winners");
+pub const TEST_RANDOMNESS: Item<HexBinary> = Item::new("test_randomness");
+pub const FINAL_RANDOMNESS: Item<HexBinary> = Item::new("final_randomness");