Ran forge fmt + solved client bug with amounts being much too high due to change in contract calculations

.gitignore

@@ -1,3 +1,6 @@
+# Address
+/app/contract_address.ts
+
 # Compiler files
 cache/
 out/

README.md

@@ -20,6 +20,8 @@ This is so time gets set on the local chain, otherwise you will start at 0 time
 
 #### 3. 2. Point Metamask to Anvil network for local dev
 
+#### 3. 3. Change `app/contract_address.ts` to match your program address if needed
+
 ### 4. Local development requires mining blocks by hand
 
 Call `cast rpc anvil_mine` to mine next block, otherwise it wont ever progress and time "stands still" as far as the game is concerned

app/.gitignore

@@ -1,4 +1,7 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files
+
+# address
+contract_address.ts
 
 # dependencies
 /node_modules

app/contract_address.ts

@@ -0,0 +1,4 @@
+const contractAddress = "0xbd06B0878888bf4c6895704fa603a5ADf7e65c66";
+
+
+export default contractAddress

app/src/components/Counter.tsx

@@ -8,14 +8,12 @@ const calculateBalance = (balance: bigint, perSecond: bigint, lastRaidedAt: bigi
     (new Date()).getTime() - parseInt(lastRaidedAt.toString()) * 1000;
   return (
     balance +
-    (BigInt(millisecondsSinceLastRaid) * (perSecond * BigInt(10000) /* decimals */)
+    (BigInt(millisecondsSinceLastRaid) * perSecond
       / BigInt(1000) /* deduct milliseconds*/))
 }
 
-export const toReadable = (value: bigint, applyTokenDivision?: boolean) => {
+export const toReadable = (value: bigint) => {
-  if (applyTokenDivision) {
+  value = value / BigInt(10000);
-    value = value / BigInt(10000);
-  }
   const suffixes = [
     { value: BigInt('1000'), suffix: 'thousand' },
     { value: BigInt('1000000'), suffix: 'million' },
@@ -37,8 +35,6 @@ export const toReadable = (value: bigint, applyTokenDivision?: boolean) => {
     { value: BigInt('1000000000000000000000000000000000000000000000000000000'), suffix: 'septendecillion' },
   ];
 
-  console.log(value)
-
   for (let i = 0; i < suffixes.length; i++) {
     if (value < suffixes[i].value) {
       if (i == 0) {
@@ -66,8 +62,8 @@ const Counter = () => {
         balance,
         army?.profit_per_second ?? BigInt(0),
         player?.last_raided_at ?? BigInt(0)
-      ), true);
+      ));
-      availableBalance.current = toReadable(balance, true);
+      availableBalance.current = toReadable(balance);
       render();
     }, 100);
     return () => clearInterval(tickInterval)

app/src/components/Header.tsx

@@ -25,7 +25,6 @@ const Header = () => {
 
   const perSecondParagraph = useMemo(() => {
     const perSecond = toReadable(army?.profit_per_second ?? BigInt(0))
-    console.log(perSecond, army?.profit_per_second)
     return (isRegistered) ?
       <p className={styles.counter_per_seconds}>per second: {perSecond}</p>
       : null

app/src/pages/index.tsx

@@ -26,7 +26,7 @@ const Home: NextPage = () => {
       </main>
 
       <footer className={styles.footer}>
-        Made with ❤️ by your fren mic0
+        Made with ❤️ by your frens at 😈 Slay the Moloch team for Cohort VII of <a href="https://www.raidguild.org/" target="blank">RaidGuild</a>
       </footer>
     </div>
   );

app/src/providers/PlayerProvider.tsx

@@ -2,8 +2,8 @@ import React, { createContext, ReactNode, useCallback, useContext, useEffect } f
 import { useAccount, useReadContract, useWriteContract } from 'wagmi'
 import contractAbi from "../../../out/RaidGeld.sol/RaidGeld.json"
 import { parseEther } from 'viem'
+import contractAddress from '../../contract_address'
 
-const contractAddress = "0xbd06B0878888bf4c6895704fa603a5ADf7e65c66"
 const abi = contractAbi.abi
 
 export interface Player {
@@ -91,7 +91,7 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
     }
   });
 
-  console.log(player)
+  console.log(player, army)
 
   const register = useCallback(() => {
     writeContract({

app/src/styles/Home.module.css

@@ -21,19 +21,10 @@
 }
 
 .footer {
-  display: flex;
+  margin-top: 2rem;
-  flex: 1;
   padding: 2rem 0;
   border-top: 1px solid #eaeaea;
-  justify-content: center;
+  text-align: center;
-  align-items: center;
-}
-
-.footer a {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  flex-grow: 1;
 }
 
 .title a {

src/RaidGeld.sol

@@ -63,7 +63,7 @@ contract RaidGeld is ERC20, Ownable {
     // Helper so we can use it when buying units too
     function performRaid(address player) private {
         uint256 time_past = block.timestamp - players[player].last_raided_at;
-    
+
         uint256 new_geld = armies[player].profit_per_second * time_past;
 
         // TODO: Pink noise, make it so sometimes its better than expected
@@ -109,14 +109,14 @@ contract RaidGeld is ERC20, Ownable {
         }
 
         uint256 cost = RaidGeldUtils.calculateUnitPrice(unit, currentLevel, n_units);
-                // First trigger a raid so player receives what he is due at to this moment
+        // First trigger a raid so player receives what he is due at to this moment
         performRaid(msg.sender);
         require(balanceOf(msg.sender) > cost, "Not enough GELD to add this much");
-        
+
         // 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
 
-        // then burn the cost of the new army 
+        // then burn the cost of the new army
         _burn(msg.sender, cost);
 
         // Increase level

src/RaidGeldStructs.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-
-
 struct Raider {
     uint16 level;
 }
@@ -19,4 +17,4 @@ struct Player {
     uint256 total_minted;
     uint256 created_at;
     uint256 last_raided_at;
-}
+}

src/RaidGeldUtils.sol

@@ -4,15 +4,12 @@ pragma solidity ^0.8.13;
 import {Army} from "../src/RaidGeldStructs.sol";
 
 library RaidGeldUtils {
-
     uint256 public constant PRECISION = 10000;
-
     uint256 constant BASE_PRICE = 380000;
     uint256 constant PRICE_FACTOR = 11500;
     uint256 constant APPRENTICE_PROFIT = 61000;
     uint256 constant ANOINTED_PROFIT = 6 * 64000;
-    uint256 constant CHAMPION_PROFIT = 67000 * 61000 * 64000/ PRECISION / PRECISION; 
+    uint256 constant CHAMPION_PROFIT = 67000 * 61000 * 64000 / PRECISION / PRECISION;
-
 
     function calculateUnitPrice(uint8 unit, uint16 currentLevel, uint16 units) internal pure returns (uint256) {
         require(unit <= 3, "No matching unit found");
@@ -37,7 +34,7 @@ library RaidGeldUtils {
 
         uint256 apprentice_profit = army.apprentice.level * APPRENTICE_PROFIT;
 
-        uint256 anointed_profit = army.anointed.level *  ANOINTED_PROFIT;
+        uint256 anointed_profit = army.anointed.level * ANOINTED_PROFIT;
 
         uint256 champion_profit = army.champion.level * CHAMPION_PROFIT;
 

test/RaidGeld.t.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.13;
 
 import {Test, console} from "forge-std/Test.sol";
 import {RaidGeld, Army, Player} from "../src/RaidGeld.sol";
-import  "../src/RaidGeldUtils.sol";
+import "../src/RaidGeldUtils.sol";
 
 contract raid_geldTest is Test {
     RaidGeld public raid_geld;
@@ -124,7 +124,7 @@ contract raid_geldTest is Test {
 
         // Check that those tokens were burnt
         // WARN: In addUnit will mint additional tokens but they are not calculated
-        // into this because the test doesnt move the blockchain so no extra tokens 
+        // into this because the test doesnt move the blockchain so no extra tokens
         // are minted to the user
         uint256 newBalance = raid_geld.balanceOf(player1);
         assertEq(newBalance, balance - unitPrice);

test/RaidGeldUtils.t.sol

@@ -3,14 +3,14 @@ pragma solidity ^0.8.13;
 
 import {Test, console} from "forge-std/Test.sol";
 import {Army, Raider} from "../src/RaidGeld.sol";
-import  "../src/RaidGeldUtils.sol";
+import "../src/RaidGeldUtils.sol";
 
 contract raid_geldTest is Test {
-    function test_0_unit_price() public {
+    function test_0_unit_price() public pure {
         // buying 1 unit of moloch_denier
         uint256 basePriceMolochDenier = RaidGeldUtils.calculateUnitPrice(0, 0, 1);
         assertEq(basePriceMolochDenier, RaidGeldUtils.BASE_PRICE);
-   
+
         // buying 3 units
         // has to be a bit more than 3 * 38 = 114
         uint256 price = RaidGeldUtils.calculateUnitPrice(0, 0, 3);
@@ -30,28 +30,25 @@ contract raid_geldTest is Test {
 
     function test_1_profits_per_second(uint16 _dLvl, uint16 _apLvl, uint16 _anLvl, uint16 _cLvl) public {
         Army memory army = Army({
-            moloch_denier: Raider({ level: 1}),
+            moloch_denier: Raider({level: 1}),
-            apprentice: Raider({ level: 0}),
+            apprentice: Raider({level: 0}),
-            anointed: Raider({ level: 0}),
+            anointed: Raider({level: 0}),
-            champion: Raider({ level: 0}),
+            champion: Raider({level: 0}),
             profit_per_second: 0 // irrelevant for this test
         });
         uint256 profits_per_second = RaidGeldUtils.calculateProfitsPerSecond(army);
         assertEq(profits_per_second, RaidGeldUtils.PRECISION);
 
         army = Army({
-            moloch_denier: Raider({ level: _dLvl}),
+            moloch_denier: Raider({level: _dLvl}),
-            apprentice: Raider({ level: _apLvl}),
+            apprentice: Raider({level: _apLvl}),
-            anointed: Raider({ level: _anLvl}),
+            anointed: Raider({level: _anLvl}),
-            champion: Raider({ level: _cLvl}),
+            champion: Raider({level: _cLvl}),
             profit_per_second: 0 // irrelevant for this test
         });
         profits_per_second = RaidGeldUtils.calculateProfitsPerSecond(army);
-        uint256 expected = 
+        uint256 expected = _dLvl * RaidGeldUtils.PRECISION + _apLvl * RaidGeldUtils.APPRENTICE_PROFIT
-            _dLvl * RaidGeldUtils.PRECISION + 
+            + _anLvl * RaidGeldUtils.ANOINTED_PROFIT + _cLvl * RaidGeldUtils.CHAMPION_PROFIT;
-            _apLvl * RaidGeldUtils.APPRENTICE_PROFIT + 
-            _anLvl * RaidGeldUtils.ANOINTED_PROFIT +
-            _cLvl * RaidGeldUtils.CHAMPION_PROFIT;
         assertEq(profits_per_second, expected);
     }
 }