Added events

src/RaidGeld.sol

@@ -15,6 +15,25 @@ contract RaidGeld is ERC20, Ownable {
     mapping(address => Player) private players;
     mapping(address => Army) private armies;
 
+    // Events
+    event PlayerRegistered(address indexed player, uint256 initialGeld);
+    event RaidPerformed(
+        address indexed player,
+        uint256 totalMinted,
+        uint256 geldBalance
+    );
+    event UnitAdded(
+        address indexed player,
+        uint8 unitType,
+        uint16 nUnits,
+        uint256 cost,
+        uint256 geldBalance,
+        uint16 molochDenierLevel,
+        uint16 apprenticeLevel,
+        uint16 anointedLevel,
+        uint16 championLevel
+    );
+
     // Modifier for functions that should only be available to registered players
     modifier onlyPlayer() {
         require(players[msg.sender].created_at != 0, "Not an initiated player");
@@ -25,15 +44,21 @@ contract RaidGeld is ERC20, Ownable {
 
     // This effectively registers the user
     function register() external payable {
-        require(players[msg.sender].created_at == 0, "Whoops, player already exists :)");
+        require(
+            players[msg.sender].created_at == 0,
+            "Whoops, player already exists :)"
+        );
         require(msg.value == BUY_IN_AMOUNT, "Incorrect buy in amount");
 
         // Mint some starting tokens to the player
         _mint(msg.sender, INITIAL_GELD);
 
         // Set initial states
-        players[msg.sender] =
+        players[msg.sender] = Player({
-            Player({total_minted: INITIAL_GELD, created_at: block.timestamp, last_raided_at: block.timestamp});
+            total_minted: INITIAL_GELD,
+            created_at: block.timestamp,
+            last_raided_at: block.timestamp
+        });
         armies[msg.sender] = Army({
             moloch_denier: Raider({level: 0}),
             apprentice: Raider({level: 0}),
@@ -41,6 +66,9 @@ contract RaidGeld is ERC20, Ownable {
             champion: Raider({level: 0}),
             profit_per_second: 0
         });
+
+        // Emit event
+        emit PlayerRegistered(msg.sender, INITIAL_GELD);
     }
 
     // Override for default number of decimals
@@ -55,11 +83,14 @@ contract RaidGeld is ERC20, Ownable {
 
     // Manual minting for itchy fingers
     function raid() external onlyPlayer {
-        performRaid(msg.sender);
+        uint256 totalMinted = performRaid(msg.sender);
+
+        // Emit event
+        emit RaidPerformed(msg.sender, totalMinted, balanceOf(msg.sender));
     }
 
     // Helper so we can use it when buying units too
-    function performRaid(address player) private {
+    function performRaid(address player) private returns (uint256) {
         uint256 time_past = block.timestamp - players[player].last_raided_at;
         uint256 new_geld = armies[player].profit_per_second * time_past;
 
@@ -68,6 +99,8 @@ contract RaidGeld is ERC20, Ownable {
         _mint(player, new_geld);
         players[player].last_raided_at = block.timestamp;
         players[player].total_minted += new_geld;
+
+        return players[player].total_minted;
     }
 
     // Function to get Player struct
@@ -105,13 +138,24 @@ contract RaidGeld is ERC20, Ownable {
             currentLevel = army.champion.level;
         }
 
-        uint256 cost = RaidGeldUtils.calculateUnitPrice(unit, currentLevel, n_units);
+        uint256 cost = RaidGeldUtils.calculateUnitPrice(
+            unit,
+            currentLevel,
+            n_units
+        );
         // First trigger a raid so player receives what he is due at to this moment
 
-        uint256 time_past = block.timestamp - players[msg.sender].last_raided_at;
+        uint256 time_past = block.timestamp -
+            players[msg.sender].last_raided_at;
         uint256 new_geld = armies[msg.sender].profit_per_second * time_past;
-        require(balanceOf(msg.sender) + new_geld > cost, "Not enough GELD to add this unit");
+        require(
-        performRaid(msg.sender);
+            balanceOf(msg.sender) + new_geld >= cost,
+            "Not enough GELD to add this unit"
+        );
+        uint256 totalMinted = performRaid(msg.sender);
+
+        // Emit event
+        emit RaidPerformed(msg.sender, totalMinted, balanceOf(msg.sender));
 
         // TODO: Since we are first minting then burning the token, this could be simplified
         // by first calculating the difference and then minting / burning in just one operation
@@ -136,10 +180,25 @@ contract RaidGeld is ERC20, Ownable {
 
         // update profite per second
         army.profit_per_second = RaidGeldUtils.calculateProfitsPerSecond(army);
+
+        // Emit event
+        emit UnitAdded(
+            msg.sender,
+            unit,
+            n_units,
+            cost,
+            balanceOf(msg.sender),
+            army.moloch_denier.level,
+            army.apprentice.level,
+            army.anointed.level,
+            army.champion.level
+        );
     }
 
     receive() external payable {
-        revert("No plain Ether accepted, use register() function to check in :)");
+        revert(
+            "No plain Ether accepted, use register() function to check in :)"
+        );
     }
 
     // Revert any non-function-call Ether transfers or calls to non-existent functions