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

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) => {
-  if (applyTokenDivision) {
+export const toReadable = (value: bigint) => {
   value = value / BigInt(10000);
-  }
   const suffixes = [
     { value: BigInt('1000'), suffix: 'thousand' },
     { value: BigInt('1000000'), suffix: 'million' },
@@ -64,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/providers/PlayerProvider.tsx

@@ -91,7 +91,7 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
     }
   });
 
-  console.log(player)
+  console.log(player, army)
 
   const register = useCallback(() => {
     writeContract({

src/RaidGeldStructs.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-
-
 struct Raider {
     uint16 level;
 }

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");

test/RaidGeldUtils.t.sol

@@ -6,7 +6,7 @@ import {Army, Raider} from "../src/RaidGeld.sol";
 import "../src/RaidGeldUtils.sol";
 
 contract raid_geldTest is Test {
-    function test_0_unit_price() pure 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);
@@ -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}),
-            apprentice: Raider({ level: 0}),
-            anointed: Raider({ level: 0}),
-            champion: Raider({ level: 0}),
+            moloch_denier: Raider({level: 1}),
+            apprentice: Raider({level: 0}),
+            anointed: 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}),
-            apprentice: Raider({ level: _apLvl}),
-            anointed: Raider({ level: _anLvl}),
-            champion: Raider({ level: _cLvl}),
+            moloch_denier: Raider({level: _dLvl}),
+            apprentice: Raider({level: _apLvl}),
+            anointed: Raider({level: _anLvl}),
+            champion: Raider({level: _cLvl}),
             profit_per_second: 0 // irrelevant for this test
         });
         profits_per_second = RaidGeldUtils.calculateProfitsPerSecond(army);
-        uint256 expected = 
-            _dLvl * RaidGeldUtils.PRECISION + 
-            _apLvl * RaidGeldUtils.APPRENTICE_PROFIT + 
-            _anLvl * RaidGeldUtils.ANOINTED_PROFIT +
-            _cLvl * RaidGeldUtils.CHAMPION_PROFIT;
+        uint256 expected = _dLvl * RaidGeldUtils.PRECISION + _apLvl * RaidGeldUtils.APPRENTICE_PROFIT
+            + _anLvl * RaidGeldUtils.ANOINTED_PROFIT + _cLvl * RaidGeldUtils.CHAMPION_PROFIT;
         assertEq(profits_per_second, expected);
     }
 }