simple admin ui

scripts/default_auth.sh

@@ -18,6 +18,8 @@ export GAME_ADDRESS=$(cat ./target/dev/manifest.json | jq -r '.contracts[] | sel
 
 export PAPER_MOCK_ADDRESS=$(cat ./target/dev/manifest.json | jq -r '.contracts[] | select(.name == "rollyourown::_mocks::paper_mock::paper_mock" ).address')
 
+export TREASURY_ADDRESS=$PAPER_MOCK_ADDRESS;
+
 echo "---------------------------------------------------------------------------"
 echo profile : $PROFILE
 echo "---------------------------------------------------------------------------"
@@ -32,6 +34,7 @@ echo "--------------------------------------------------------------------------
 # enable system -> models authorizations
 sozo -P $PROFILE auth grant --world $WORLD_ADDRESS --wait writer\
  RyoConfig,$RYO_ADDRESS \
+ RyoAddress,$RYO_ADDRESS \
  Leaderboard,$RYO_ADDRESS \
  GameConfig,$CONFIG_ADDRESS \
  DrugConfig,$CONFIG_ADDRESS \
@@ -55,7 +58,7 @@ sozo -P $PROFILE auth grant --world $WORLD_ADDRESS --wait writer\
 echo "Default authorizations have been successfully set."
 
 echo "Initializing..."
-sozo -P $PROFILE execute  --world $WORLD_ADDRESS $RYO_ADDRESS initialize --calldata $PAPER_MOCK_ADDRESS --wait > /dev/null
+sozo -P $PROFILE execute  --world $WORLD_ADDRESS $RYO_ADDRESS initialize --calldata $PAPER_MOCK_ADDRESS,$TREASURY_ADDRESS --wait > /dev/null
 echo "Initialized RYO!"
 sleep $TX_SLEEP
 

src/config/ryo.cairo

@@ -9,12 +9,13 @@ struct RyoConfig {
     key: u8,
     initialized: bool,
     paused: bool,
+    //
     leaderboard_version: u16,
     leaderboard_duration: u32,
-    paper_address: ContractAddress,
+    //
     paper_fee: u16,
-// treasury_address: ContractAddress,
-// treasury_pct: u8,
+    treasury_fee_pct: u8,
+    treasury_balance: u32,
 }
 
 #[derive(Copy, Drop)]
@@ -35,4 +36,5 @@ impl RyoConfigImpl of RyoConfigManagerTrait {
     fn set(self: RyoConfigManager, ryo_config: RyoConfig) {
         set!(self.world, (ryo_config));
     }
+
 }

src/config/ryo_address.cairo

@@ -0,0 +1,43 @@
+use starknet::ContractAddress;
+use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
+
+const RYO_ADDRESS_CONFIG_KEY: u8 = 0;
+
+#[derive(Model, Copy, Drop, Serde)]
+struct RyoAddress {
+    #[key]
+    key: u8,
+    paper: ContractAddress,
+    treasury: ContractAddress,
+}
+
+#[derive(Copy, Drop)]
+struct RyoAddressManager {
+    world: IWorldDispatcher
+}
+
+#[generate_trait]
+impl RyoAddressImpl of RyoAddressManagerTrait {
+    fn new(world: IWorldDispatcher) -> RyoAddressManager {
+        RyoAddressManager { world }
+    }
+
+    fn get(self: RyoAddressManager) -> RyoAddress {
+        get!(self.world, (RYO_ADDRESS_CONFIG_KEY), RyoAddress)
+    }
+
+    fn set(self: RyoAddressManager, ryo_address: RyoAddress) {
+        set!(self.world, (ryo_address));
+    }
+
+    // getters
+
+    fn paper(self: RyoAddressManager) -> ContractAddress {
+        self.get().paper
+    }
+
+    fn treasury(self: RyoAddressManager) -> ContractAddress {
+        self.get().treasury
+    }
+
+}

src/lib.cairo

@@ -5,6 +5,7 @@ mod config {
     mod game;
     mod hustlers;
     mod ryo;
+    mod ryo_address;
 }
 
 mod models {

src/models/leaderboard.cairo

@@ -11,6 +11,6 @@ struct Leaderboard {
     //
     next_version_timestamp: u64,
     //
-    paper_balance: u256, // TODO: use u32 ?
+    paper_balance: u32, 
     claimed: bool,
 }

src/systems/game.cairo

@@ -25,6 +25,7 @@ trait IGameActions<T> {
     fn travel(self: @T, game_id: u32, next_location: Locations, actions: Span<Actions>);
     fn decide(self: @T, game_id: u32, action: EncounterActions);
     fn claim(self: @T, season: u16);
+    fn claim_treasury(self: @T);
 }
 
 
@@ -35,7 +36,8 @@ mod game {
     use rollyourown::{
         config::{
             drugs::{Drugs}, locations::{Locations}, game::{GameConfig, GameConfigImpl},
-            ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait}
+            ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait},
+            ryo_address::{RyoAddress, RyoAddressManager, RyoAddressManagerTrait},
         },
         models::{
             game_store_packed::GameStorePacked, game::{Game, GameImpl}, leaderboard::{Leaderboard}
@@ -50,6 +52,7 @@ mod game {
         },
         utils::{random::{Random, RandomImpl}, bytes16::{Bytes16, Bytes16Impl, Bytes16Trait}},
         interfaces::paper::{IPaperDispatcher, IPaperDispatcherTrait},
+        constants::{ETHER},
     };
 
 
@@ -332,24 +335,56 @@ mod game {
             leaderboard.claimed = true;
             set!(world, (leaderboard));
 
-            // retrieve paper address from ryo_config
-            let ryo_config_manager = RyoConfigManagerTrait::new(world);
-            let ryo_config = ryo_config_manager.get();
+            // retrieve paper address 
+            let paper_address = RyoAddressManagerTrait::new(world).paper();
+            let paper_jackpot_eth: u256 = leaderboard.paper_balance.into() * ETHER;
 
             // transfer reward
-            IPaperDispatcher { contract_address: ryo_config.paper_address }
-                .transfer(get_caller_address(), leaderboard.paper_balance);
+            IPaperDispatcher { contract_address: paper_address }
+                .transfer(get_caller_address(), paper_jackpot_eth);
+        }
+
+         fn claim_treasury(self: @ContractState) {
+            // check if owner ???   TODO: check if ok
+            // self.assert_caller_is_owner();
+
+            let ryo_config_manager = RyoConfigManagerTrait::new(self.world());
+            let mut ryo_config = ryo_config_manager.get();
+
+            assert(ryo_config.treasury_balance > 0, 'nothin to claim');
+
+            // calc claimable amount
+            let claimable_eth: u256  = ryo_config.treasury_balance.into() * ETHER;
+
+            // reset treasury_balance
+            ryo_config.treasury_balance = 0;
+            ryo_config_manager.set(ryo_config);
+
+            let ryo_addresses_manager = RyoAddressManagerTrait::new(self.world());
+
+            // transfer claimable_eth to treasury
+            IPaperDispatcher { contract_address: ryo_addresses_manager.paper() }
+                .transfer(ryo_addresses_manager.treasury(), claimable_eth);
         }
     }
 
     #[generate_trait]
     impl InternalImpl of InternalTrait {
+        #[inline(always)]
         fn assert_not_paused(self: @ContractState) {
             let ryo_config_manager = RyoConfigManagerTrait::new(self.world());
             let ryo_config = ryo_config_manager.get();
             assert(!ryo_config.paused, 'game is paused');
         }
 
+        #[inline(always)]
+        fn assert_caller_is_owner(self: @ContractState) {
+            assert(
+                self.world().is_owner(get_caller_address(), get_contract_address().into()),
+                'not owner'
+            );
+        }
+
         fn execute_actions(
             self: @ContractState, ref game_store: GameStore, ref actions: Span<super::Actions>
         ) {

src/systems/leaderboard.cairo

@@ -2,9 +2,13 @@ use starknet::{get_caller_address, get_contract_address};
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
 
 use rollyourown::{
-    config::{ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait}},
+    config::{
+        ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait}, 
+        ryo_address::{RyoAddress, RyoAddressManager, RyoAddressManagerTrait}
+    },
     models::{leaderboard::{Leaderboard}}, packing::game_store::{GameStore},
-    interfaces::paper::{IPaperDispatcher, IPaperDispatcherTrait}, constants::{ETHER}
+    interfaces::paper::{IPaperDispatcher, IPaperDispatcherTrait}, constants::{ETHER},
+    utils::math::{MathImpl, MathTrait}
 };
 
 
@@ -79,16 +83,28 @@ impl LeaderboardManagerImpl of LeaderboardManagerTrait {
         // get current leaderboard infos
         let mut leaderboard = get!(self.world, (ryo_config.leaderboard_version), Leaderboard);
 
-        // calc paper_fee
-        let paper_fee: u256 = ryo_config.paper_fee.into() * ETHER;
+        // get paper_fee
+        let paper_fee : u32 = ryo_config.paper_fee.into();
+        let paper_fee_eth: u256 = paper_fee.into() * ETHER;
 
-        // add paper_fee to current_leaderboard & save
-        leaderboard.paper_balance += paper_fee;
+        // calc treasury share
+        let treasury_share = paper_fee.pct(ryo_config.treasury_fee_pct.into());
+        let jackpot_share = paper_fee - treasury_share;
+
+        // add jackpot_share to current_leaderboard & save
+        leaderboard.paper_balance += jackpot_share;
         set!(self.world, (leaderboard));
 
-        // transfer paper_fee from user to game ( user approved game contract to spend paper before)
-        IPaperDispatcher { contract_address: ryo_config.paper_address }
-            .transfer_from(get_caller_address(), get_contract_address(), paper_fee);
+        // add treasury_share to treasury_balance & save
+        ryo_config.treasury_balance += treasury_share;
+        ryo_config_manager.set(ryo_config);
+
+        // retrieve paper_address
+        let paper_address = RyoAddressManagerTrait::new(self.world).paper();
+
+        // transfer paper_fee_ether from user to game ( user approved game contract to spend paper before)
+        IPaperDispatcher { contract_address: paper_address }
+            .transfer_from(get_caller_address(), get_contract_address(), paper_fee_eth);
 
         ryo_config.leaderboard_version
     }

src/systems/ryo.cairo

@@ -1,20 +1,23 @@
 use starknet::ContractAddress;
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
 
-
 #[starknet::interface]
-trait IRyo<TContractState> {
+trait IRyo<T> {
     //
-    fn initialize(self: @TContractState, paper_address: ContractAddress);
-    fn set_paused(self: @TContractState, paused: bool);
-    fn set_paper_fee(self: @TContractState, fee: u16);
-    fn set_leaderboard_duration(self: @TContractState, duration_sec: u32);
+    fn initialize(self: @T, paper_address: ContractAddress, treasury_address: ContractAddress);
+    fn set_paused(self: @T, paused: bool);
+    fn set_paper_fee(self: @T, fee: u16);
+    fn set_treasury_fee_pct(self: @T, fee_pct: u8);
+
+    fn set_leaderboard_duration(self: @T, duration_sec: u32);
 
     //
-    fn paused(self: @TContractState) -> bool;
-    fn paper(self: @TContractState) -> ContractAddress;
-    fn paper_fee(self: @TContractState) -> u16;
-    fn leaderboard_duration(self: @TContractState) -> u32;
+    fn paper(self: @T) -> ContractAddress;
+    fn treasury(self: @T) -> ContractAddress;
+
+    fn paused(self: @T) -> bool;
+    fn paper_fee(self: @T) -> u16;
+    fn leaderboard_duration(self: @T) -> u32;
 }
 
 #[dojo::contract]
@@ -26,7 +29,10 @@ mod ryo {
     use starknet::info::get_tx_info;
 
     use rollyourown::{
-        config::{ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait}},
+        config::{
+            ryo::{RyoConfig, RyoConfigManager, RyoConfigManagerTrait},
+            ryo_address::{RyoAddress, RyoAddressManager, RyoAddressManagerTrait},
+        },
         models::{leaderboard::Leaderboard,}, utils::random::{RandomImpl},
         systems::leaderboard::{LeaderboardManager, LeaderboardManagerTrait},
     };
@@ -38,7 +44,7 @@ mod ryo {
 
     #[abi(embed_v0)]
     impl RyoExternalImpl of super::IRyo<ContractState> {
-        fn initialize(self: @ContractState, paper_address: ContractAddress) {
+        fn initialize(self: @ContractState, paper_address: ContractAddress, treasury_address: ContractAddress) {
             self.assert_caller_is_owner();
 
             let ryo_config_manager = RyoConfigManagerTrait::new(self.world());
@@ -52,12 +58,25 @@ mod ryo {
             // RyoConfig
             ryo_config.initialized = true;
             ryo_config.paused = false;
+
             ryo_config.leaderboard_version = 1;
             ryo_config.leaderboard_duration = FEW_MIN; // ONE_WEEK
-
-            ryo_config.paper_address = paper_address;
+
             ryo_config.paper_fee = 1_000; // in ether
+            ryo_config.treasury_fee_pct = 10;
+
+            // save 
             ryo_config_manager.set(ryo_config);
+
+            // RyoAddresses
+            let ryo_addresses_manager = RyoAddressManagerTrait::new(self.world());
+            let mut ryo_addresses = ryo_addresses_manager.get();
+
+            ryo_addresses.paper = paper_address;
+            ryo_addresses.treasury = treasury_address;
+
+            // save 
+            ryo_addresses_manager.set(ryo_addresses);
 
             // Leaderboard
             let leaderboard_manager = LeaderboardManagerTrait::new(self.world());
@@ -88,6 +107,17 @@ mod ryo {
             ryo_config_manager.set(ryo_config);
         }
 
+
+        fn set_treasury_fee_pct(self: @ContractState, fee_pct: u8) {
+            self.assert_caller_is_owner();
+
+            let ryo_config_manager = RyoConfigManagerTrait::new(self.world());
+            let mut ryo_config = ryo_config_manager.get();
+
+            ryo_config.treasury_fee_pct = fee_pct;
+            ryo_config_manager.set(ryo_config);
+        }
+
         fn set_leaderboard_duration(self: @ContractState, duration_sec: u32) {
             self.assert_caller_is_owner();
 
@@ -103,14 +133,18 @@ mod ryo {
         // getters
         //
 
-        fn paused(self: @ContractState) -> bool {
-            let ryo_config = RyoConfigManagerTrait::new(self.world()).get();
-            ryo_config.paused
+        fn paper(self: @ContractState) -> ContractAddress {
+            RyoAddressManagerTrait::new(self.world()).paper()
         }
 
-        fn paper(self: @ContractState) -> ContractAddress {
+        fn treasury(self: @ContractState) -> ContractAddress {
+            RyoAddressManagerTrait::new(self.world()).treasury()
+        }
+
+
+        fn paused(self: @ContractState) -> bool {
             let ryo_config = RyoConfigManagerTrait::new(self.world()).get();
-            ryo_config.paper_address
+            ryo_config.paused
         }
 
         fn paper_fee(self: @ContractState) -> u16 {