session wallet

src/RaidGeld.sol

@@ -20,11 +20,16 @@ contract RaidGeld is ERC20, Ownable, Constants {
     uint256 public BUY_IN_DAO_TOKEN_AMOUNT;
     uint256 public constant INITIAL_GELD = 50 * MANTISSA;
     uint256 public constant SACRIFICE_SHARE = 1e3; // 10%
+    uint256 public constant SESSION_WALLET_FUNDING_CAP = 0.001 ether;
     mapping(address => Player) private players;
     mapping(address => Army) private armies;
     mapping(address => Boss) private bosses;
     mapping(address => LastBossResult) private lastBossResults;
 
+    mapping(address => address) private playerToSessionWallet;
+    mapping(address => address) private sessionWalletToPlayer;
+    mapping(address => address) private proposedSessionWallets;
+
     // WETH
     IWETH public immutable weth = IWETH(WETH);
     // RGCVII token
@@ -92,7 +97,10 @@ contract RaidGeld is ERC20, Ownable, Constants {
     }
 
     modifier onlyActiveSession() {
-        require(players[msg.sender].has_active_session, "Session is not active, you need to buy into the game first");
+        address delegatedWallet = playerToSessionWallet[msg.sender];
+        require(
+            players[msg.sender].has_active_session ||
+            players[delegatedWallet].has_active_session, "Session is not active, you need to buy into the game first");
         _;
     }
 
@@ -200,7 +208,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
 
     // Manual minting for itchy fingers
     function raid() external onlyActiveSession {
-        performRaid(msg.sender);
+        performRaid(_player());
     }
 
     // Helper so we can use it when buying units too
@@ -240,9 +248,10 @@ contract RaidGeld is ERC20, Ownable, Constants {
 
     // Add a unit to your army
     function addUnit(uint8 unit, uint16 n_units) external onlyActiveSession {
+        address player = _player();
         require(unit <= 3, "Unknown unit");
 
-        Army storage army = armies[msg.sender];
+        Army storage army = armies[player];
         uint16 currentLevel = 0;
         if (unit == 0) {
             // moloch_denier
@@ -261,13 +270,13 @@ contract RaidGeld is ERC20, Ownable, Constants {
         uint256 cost = RaidGeldUtils.calculateUnitPrice(unit, currentLevel, n_units);
 
 
-        performRaid(msg.sender);
+        performRaid(player);
 
         // TODO: Since we are first minting then burning the token, this could be simplified
-        require(balanceOf(msg.sender) >= cost, "Not enough GELD to add this unit");
+        require(balanceOf(player) >= cost, "Not enough GELD to add this unit");
 
         // then burn the cost of the new army
-        _burn(msg.sender, cost);
+        _burn(player, cost);
 
         // Increase level
         if (unit == 0) {
@@ -289,7 +298,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
 
         // Emit event
         emit UnitAdded(
-            msg.sender,
+            player,
             unit,
             n_units,
             cost,
@@ -303,15 +312,16 @@ contract RaidGeld is ERC20, Ownable, Constants {
 
     function battle_with_boss() external onlyActiveSession returns (bool[2] memory hasWonOrAscended) {
         // first perform raid
-        performRaid(msg.sender);
-        Boss memory boss_to_attack = bosses[msg.sender];
+        address player = _player();
+        performRaid(player);
+        Boss memory boss_to_attack = bosses[player];
         // calculate how much the player will put into battle
-        uint256 geld_to_burn = balanceOf(msg.sender) >= RaidGeldUtils.getBossPower(boss_to_attack.level)
+        uint256 geld_to_burn = balanceOf(player) >= RaidGeldUtils.getBossPower(boss_to_attack.level)
             ? RaidGeldUtils.getBossPower(boss_to_attack.level)
-            : balanceOf(msg.sender);
+            : balanceOf(player);
         bool hasWonBattle = RaidGeldUtils.calculateBossFight(boss_to_attack.level, geld_to_burn, block.prevrandao);
-        emit BossBattle(msg.sender, boss_to_attack.level, hasWonBattle); 
-        lastBossResults[msg.sender] = LastBossResult({
+        emit BossBattle(player, boss_to_attack.level, hasWonBattle); 
+        lastBossResults[player] = LastBossResult({
             battled_at: block.timestamp,
             level: boss_to_attack.level,
             variant: boss_to_attack.variants[boss_to_attack.level],
@@ -320,7 +330,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
         });
         if (hasWonBattle) {
             // Burn geld, send some sweet DAO Token and continue
-            _burn(msg.sender, geld_to_burn);
+            _burn(player, geld_to_burn);
             uint256 baseReward = (BUY_IN_DAO_TOKEN_AMOUNT - BUY_IN_DAO_TOKEN_AMOUNT * SACRIFICE_SHARE / MANTISSA);
             uint256 wholeReward = RaidGeldUtils.calculateBossReward(boss_to_attack.level, baseReward);
             uint256 treasuryShare = wholeReward * SACRIFICE_SHARE / MANTISSA; 
@@ -328,29 +338,29 @@ contract RaidGeld is ERC20, Ownable, Constants {
             // send a share to dao treasury
             daoToken.transfer(DAO_TREASURY, treasuryShare);
             
-            players[msg.sender].total_rewards += reward;
+            players[player].total_rewards += reward;
             
             // send user its reward
-            daoToken.transfer(msg.sender, reward);
-            emit BossDefeated(msg.sender, boss_to_attack.level, reward);
+            daoToken.transfer(player, reward);
+            emit BossDefeated(player, boss_to_attack.level, reward);
 
-            lastBossResults[msg.sender].reward = reward;
+            lastBossResults[player].reward = reward;
 
             if (boss_to_attack.level == 6) {
                 // User ascends! Moloch is defeated, user can start a new run
-                players[msg.sender].prestige_level += 1;
-                emit PrestigeGained(msg.sender, players[msg.sender].prestige_level);
-                player_dies(msg.sender);
-                lastBossResults[msg.sender].prestigeGained = true;
+                players[player].prestige_level += 1;
+                emit PrestigeGained(player, players[player].prestige_level);
+                player_dies(player);
+                lastBossResults[player].prestigeGained = true;
                 return [hasWonBattle, true /* New prestige level! */ ];
             } else {
                 // else go to next boss
-                bosses[msg.sender].level += 1;
+                bosses[player].level += 1;
             }
         } else {
             // Whoops u died, boss defeated you
-            lastBossResults[msg.sender].reward = 0;
-            player_dies(msg.sender);
+            lastBossResults[player].reward = 0;
+            player_dies(player);
         }
         return [hasWonBattle, false /* hasnt gotten prestige level */ ];
     }
@@ -428,6 +438,31 @@ contract RaidGeld is ERC20, Ownable, Constants {
         DAO = _dao;
     }
 
+    function proposeSessionWallet(address _wallet) payable external onlyPlayer {
+        require(!isRegistered(_wallet), "Wallet belongs to other player");
+        require(msg.value <= SESSION_WALLET_FUNDING_CAP, "Too high funding amoount");
+        require(sessionWalletToPlayer[_wallet] == address(0), "Wallet already in use");
+        playerToSessionWallet[msg.sender] = _wallet;
+        sessionWalletToPlayer[_wallet] = msg.sender;
+        payable(_wallet).call{value: msg.value}("");
+    }
+    function acceptSessionWallet(address _player) external {
+        require(proposedSessionWallets[_player] == msg.sender, "Not the proposed session wallet");
+        sessionWalletToPlayer[msg.sender] = _player;
+        playerToSessionWallet[_player] = msg.sender;
+        proposedSessionWallets[msg.sender] = address(0);
+    }
+    function fundSessionWallet() payable external {
+        require(sessionWalletToPlayer[msg.sender] != address(0), "No session wallet found");
+        require(msg.value <= SESSION_WALLET_FUNDING_CAP, "Too high funding amoount");
+        payable(sessionWalletToPlayer[msg.sender]).call{value: msg.value}("");
+    }
+
+    function _player() internal view returns (address) {
+        address delegatedWallet = sessionWalletToPlayer[msg.sender];
+        return delegatedWallet == address(0) ? msg.sender : delegatedWallet;
+    }
+
     receive() external payable {
         revert("No plain Ether accepted, use register() function to check in :)");
     }