Allow adjustment of league points

closes #9

.cargo/config → .cargo/config.toml

@@ -1,4 +1,4 @@
 [alias]
 wasm = "build --release --lib --target wasm32-unknown-unknown"
 wasm-debug = "build --lib --target wasm32-unknown-unknown"
-unit-test = "test --lib"
+unit-test = "test --lib"

contracts/arena-core/schema/arena-core.json

@@ -1,6 +1,6 @@
 {
   "contract_name": "arena-core",
-  "contract_version": "1.2.0",
+  "contract_version": "1.4.0",
   "idl_version": "1.0.0",
   "instantiate": {
     "$schema": "http://json-schema.org/draft-07/schema#",

contracts/arena-core/src/tests/leagues.rs

@@ -3,11 +3,13 @@ use std::str::FromStr;
 use arena_league_module::{
     msg::{
         CompetitionInstantiateExt, ExecuteExt, ExecuteMsg, InstantiateMsg, LeagueResponse,
-        MatchResult, MemberPoints, QueryExt, QueryMsg,
+        MatchResult, MemberPoints, QueryExt, QueryMsg, RoundResponse,
     },
-    state::{Match, Result, RoundResponse, TournamentExt},
+    state::{Match, PointAdjustment, Result, TournamentExt},
+};
+use cosmwasm_std::{
+    coins, to_json_binary, Addr, Coin, Coins, Decimal, Int128, Uint128, Uint64, WasmMsg,
 };
-use cosmwasm_std::{coins, to_json_binary, Addr, Coin, Coins, Decimal, Uint128, Uint64, WasmMsg};
 use cw4::Member;
 use cw_balance::{BalanceUnchecked, MemberBalanceUnchecked};
 use cw_competition::msg::ModuleInfo;
@@ -144,9 +146,9 @@ fn create_competition(
             rulesets: vec![],
             instantiate_extension: CompetitionInstantiateExt {
                 teams,
-                match_win_points: Uint128::from(3u128),
-                match_draw_points: Uint128::one(),
-                match_lose_points: Uint128::zero(),
+                match_win_points: Uint64::from(3u64),
+                match_draw_points: Uint64::one(),
+                match_lose_points: Uint64::zero(),
                 distribution,
             },
         },
@@ -533,36 +535,86 @@ fn test_leagues() {
         *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
         MemberPoints {
             member: users[1].clone(),
-            points: Uint128::one(),
+            points: Int128::one(),
             matches_played: Uint64::one()
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[0]).unwrap(),
         MemberPoints {
             member: users[0].clone(),
-            points: Uint128::from(3u128),
+            points: Int128::from(3),
             matches_played: Uint64::one()
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[3]).unwrap(),
         MemberPoints {
             member: users[3].clone(),
-            points: Uint128::zero(),
+            points: Int128::zero(),
             matches_played: Uint64::one()
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[4]).unwrap(),
         MemberPoints {
             member: users[4].clone(),
-            points: Uint128::one(),
+            points: Int128::one(),
             matches_played: Uint64::one()
         }
     );
 
     context.app.update_block(|x| x.height += 10);
+
+    // Owners realized that users[1] was cheating and have deducted 5 points
+    let result = context.app.execute_contract(
+        admin.clone(),
+        context.core.sudo_proposal_addr.clone(),
+        &dao_proposal_sudo::msg::ExecuteMsg::Execute {
+            msgs: vec![WasmMsg::Execute {
+                contract_addr: context.league.league_module_addr.to_string(),
+                msg: to_json_binary(&ExecuteMsg::Extension {
+                    msg: ExecuteExt::AddPointAdjustments {
+                        league_id: competition_id,
+                        addr: users[1].to_string(),
+                        point_adjustments: vec![PointAdjustment {
+                            description: "Team was caught cheating".to_string(),
+                            amount: Int128::new(-3),
+                        }],
+                    },
+                })
+                .unwrap(),
+                funds: vec![],
+            }
+            .into()],
+        },
+        &[],
+    );
+    assert!(result.is_ok());
+
+    // Check users[1] new points
+    let leaderboard: Vec<MemberPoints> = context
+        .app
+        .wrap()
+        .query_wasm_smart(
+            context.league.league_module_addr.clone(),
+            &QueryMsg::QueryExtension {
+                msg: QueryExt::Leaderboard {
+                    league_id: competition_id,
+                    round: None,
+                },
+            },
+        )
+        .unwrap();
+    assert_eq!(
+        *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
+        MemberPoints {
+            member: users[1].clone(),
+            points: Int128::from(-2),
+            matches_played: Uint64::one()
+        }
+    );
+
     // Process 2nd round of matches
     let result = context.app.execute_contract(
         admin.clone(),
@@ -613,39 +665,39 @@ fn test_leagues() {
         *leaderboard.iter().find(|x| x.member == users[0]).unwrap(),
         MemberPoints {
             member: users[0].clone(),
-            points: Uint128::from(6u128),
+            points: Int128::from(6),
             matches_played: Uint64::from(2u64)
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
         MemberPoints {
             member: users[1].clone(),
-            points: Uint128::from(4u128),
+            points: Int128::from(1),
             matches_played: Uint64::from(2u64)
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[2]).unwrap(),
         MemberPoints {
             member: users[2].clone(),
-            points: Uint128::zero(),
+            points: Int128::zero(),
             matches_played: Uint64::one()
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[3]).unwrap(),
         MemberPoints {
             member: users[3].clone(),
-            points: Uint128::zero(),
+            points: Int128::zero(),
             matches_played: Uint64::one()
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[4]).unwrap(),
         MemberPoints {
             member: users[4].clone(),
-            points: Uint128::one(),
+            points: Int128::one(),
             matches_played: Uint64::from(2u64)
         }
     );
@@ -701,39 +753,39 @@ fn test_leagues() {
         *leaderboard.iter().find(|x| x.member == users[0]).unwrap(),
         MemberPoints {
             member: users[0].clone(),
-            points: Uint128::from(6u128),
+            points: Int128::from(6),
             matches_played: Uint64::from(2u64)
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
         MemberPoints {
             member: users[1].clone(),
-            points: Uint128::from(4u128),
+            points: Int128::from(1),
             matches_played: Uint64::from(3u64)
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[2]).unwrap(),
         MemberPoints {
             member: users[2].clone(),
-            points: Uint128::zero(),
+            points: Int128::zero(),
             matches_played: Uint64::from(2u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[3]).unwrap(),
         MemberPoints {
             member: users[3].clone(),
-            points: Uint128::from(3u128),
+            points: Int128::from(3),
             matches_played: Uint64::from(2u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[4]).unwrap(),
         MemberPoints {
             member: users[4].clone(),
-            points: Uint128::from(4u128),
+            points: Int128::from(4),
             matches_played: Uint64::from(3u64)
         }
     );
@@ -789,39 +841,39 @@ fn test_leagues() {
         *leaderboard.iter().find(|x| x.member == users[0]).unwrap(),
         MemberPoints {
             member: users[0].clone(),
-            points: Uint128::from(9u128),
+            points: Int128::from(9),
             matches_played: Uint64::from(3u64)
         }
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
         MemberPoints {
             member: users[1].clone(),
-            points: Uint128::from(4u128),
+            points: Int128::from(1),
             matches_played: Uint64::from(3u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[2]).unwrap(),
         MemberPoints {
             member: users[2].clone(),
-            points: Uint128::zero(),
+            points: Int128::zero(),
             matches_played: Uint64::from(3u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[3]).unwrap(),
         MemberPoints {
             member: users[3].clone(),
-            points: Uint128::from(3u128),
+            points: Int128::from(3),
             matches_played: Uint64::from(3u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[4]).unwrap(),
         MemberPoints {
             member: users[4].clone(),
-            points: Uint128::from(7u128),
+            points: Int128::from(7),
             matches_played: Uint64::from(4u64)
         }
     );
@@ -845,7 +897,7 @@ fn test_leagues() {
                             },
                             MatchResult {
                                 match_number: Uint128::from(10u128),
-                                result: Some(Result::Team1),
+                                result: Some(Result::Team2),
                             },
                         ],
                     },
@@ -877,39 +929,39 @@ fn test_leagues() {
         *leaderboard.iter().find(|x| x.member == users[0]).unwrap(),
         MemberPoints {
             member: users[0].clone(),
-            points: Uint128::from(12u128),
+            points: Int128::from(12),
             matches_played: Uint64::from(4u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[1]).unwrap(),
         MemberPoints {
             member: users[1].clone(),
-            points: Uint128::from(4u128),
+            points: Int128::from(1),
             matches_played: Uint64::from(4u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[2]).unwrap(),
         MemberPoints {
             member: users[2].clone(),
-            points: Uint128::from(3u128),
+            points: Int128::from(0),
             matches_played: Uint64::from(4u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[3]).unwrap(),
         MemberPoints {
             member: users[3].clone(),
-            points: Uint128::from(3u128),
+            points: Int128::from(6),
             matches_played: Uint64::from(4u64)
         },
     );
     assert_eq!(
         *leaderboard.iter().find(|x| x.member == users[4]).unwrap(),
         MemberPoints {
             member: users[4].clone(),
-            points: Uint128::from(7u128),
+            points: Int128::from(7),
             matches_played: Uint64::from(4u64)
         }
     );
@@ -931,25 +983,25 @@ fn test_leagues() {
         balances,
         vec![
             MemberBalanceUnchecked {
-                addr: users[0].to_string(), // 2nd
+                addr: users[3].to_string(), // 3rd
                 balance: BalanceUnchecked {
-                    native: coins(11900, "juno"),
+                    native: coins(1700, "juno"),
                     cw20: vec![],
                     cw721: vec![]
                 }
             },
             MemberBalanceUnchecked {
-                addr: users[4].to_string(), // 1st 20000 (prize pool) * .85 (tax) * .7 (1st place earnings) = 11900
+                addr: users[0].to_string(), // 2nd
                 balance: BalanceUnchecked {
-                    native: coins(3400, "juno"),
+                    native: coins(11900, "juno"),
                     cw20: vec![],
                     cw721: vec![]
                 }
             },
             MemberBalanceUnchecked {
-                addr: users[1].to_string(), // 3rd
+                addr: users[4].to_string(), // 1st 20000 (prize pool) * .85 (tax) * .7 (1st place earnings) = 11900
                 balance: BalanceUnchecked {
-                    native: coins(1700, "juno"),
+                    native: coins(3400, "juno"),
                     cw20: vec![],
                     cw721: vec![]
                 }

contracts/arena-escrow/schema/arena-escrow.json

@@ -1,6 +1,6 @@
 {
   "contract_name": "arena-escrow",
-  "contract_version": "1.2.0",
+  "contract_version": "1.4.0",
   "idl_version": "1.0.0",
   "instantiate": {
     "$schema": "http://json-schema.org/draft-07/schema#",

contracts/arena-league-module/Cargo.toml

@@ -27,4 +27,5 @@ thiserror = { workspace = true }
 dao-interface = { workspace = true }
 cw-ownable = { workspace = true }
 itertools = { workspace = true }
-cw-balance = { workspace = true }
+cw-balance = { workspace = true }
+cw-paginate = { workspace = true }