session wallet

add to boss fight
session wallet
2024-11-01 16:45:31 +01:00 · 2024-11-01 16:13:41 +01:00 · 2024-11-01 13:30:56 +01:00
20 changed files with 346 additions and 902 deletions
--- a/app/package-lock.json
+++ b/app/package-lock.json
@ -11,8 +11,6 @@
        "@next/eslint-plugin-next": "^14.2.15",
        "@rainbow-me/rainbowkit": "^2.2.0",
        "@tanstack/react-query": "^5.55.3",
-        "howler": "^2.2.4",
-        "jsfxr": "^1.2.2",
        "next": "^14.2.10",
        "react": "^18.3.1",
        "react-dom": "^18.3.1",
@ -8976,11 +8974,6 @@
        "minimalistic-crypto-utils": "^1.0.1"
      }
    },
-    "node_modules/howler": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/howler/-/howler-2.2.4.tgz",
-      "integrity": "sha512-iARIBPgcQrwtEr+tALF+rapJ8qSc+Set2GJQl7xT1MQzWaVkFebdJhR3alVlSiUf5U7nAANKuj3aWpwerocD5w=="
-    },
    "node_modules/http-errors": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
@ -10124,14 +10117,6 @@
        "node": ">=6"
      }
    },
-    "node_modules/jsfxr": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/jsfxr/-/jsfxr-1.2.2.tgz",
-      "integrity": "sha512-aBtNHZ/eJVZ3Q12HLj6F0eF20bRJTar6fjHf14zZ/Co5GzcVsEBujJO7IKwAhZS3Pe0xIvUOD3O1BoZ6ij0xhA==",
-      "bin": {
-        "sfxr-to-wav": "sfxr-to-wav"
-      }
-    },
    "node_modules/json-buffer": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
--- a/app/package.json
+++ b/app/package.json
@ -12,8 +12,6 @@
    "@next/eslint-plugin-next": "^14.2.15",
    "@rainbow-me/rainbowkit": "^2.2.0",
    "@tanstack/react-query": "^5.55.3",
-    "howler": "^2.2.4",
-    "jsfxr": "^1.2.2",
    "next": "^14.2.10",
    "react": "^18.3.1",
    "react-dom": "^18.3.1",
--- a/app/public/sounds/arcade_win.wav
+++ b/app/public/sounds/arcade_win.wav
--- a/app/public/sounds/lost.wav
+++ b/app/public/sounds/lost.wav
--- a/app/src/components/BossOutcomeModal.tsx
+++ b/app/src/components/BossOutcomeModal.tsx
@ -4,67 +4,30 @@ import styles from "../styles/Modal.module.css";
 import bgStyles from "../styles/Background.module.css";
 import { bossToName, bossToReward } from "./BossInfo";
 import { bossLevelToClass } from "./Boss";
-import { lostSound, wonSound } from "../utils/soundsEffect";
-import { useEffect } from "react";
+

 interface BossOutcomeModalProps {
-  setIsOpen: (val: boolean) => void;
+  setIsOpen: (val: boolean) => void,
 }

 const BossOutcomeModal = ({ setIsOpen }: BossOutcomeModalProps) => {
  const { lastBossResult } = usePlayer();
-  const outcome = lastBossResult?.reward != BigInt(0);
-  const ascended = lastBossResult?.prestigeGained;
-  useEffect(() => {
-    if (lastBossResult != null) {
-      if (outcome) {
-        wonSound();
-      } else {
-        lostSound();
-      }
-    }
-  }, [outcome, lastBossResult])
-
  if (lastBossResult == null) return null;

-  const text = outcome ? (
-    <span>
-      and you <strong className={styles.won}>won!</strong> 🤩
-    </span>
-  ) : (
-    <span>
-      and you <strong className={styles.lost}>lost</strong> 😔
-    </span>
-  );
-  const rewardAmount = parseFloat(
-    parseFloat(
-      formatUnits(bossToReward[lastBossResult.level], 18).toString()
-    ).toFixed(4)
-  );
-  const rewardText = ascended ? (
-    <p>
-      You won <strong>{rewardAmount} RGCVII</strong> and{" "}
-      <strong>ASCENDED!!!</strong>. This means you beat the bosses and gained a{" "}
-      <strong>Prestige level</strong>. Your GELD is now forfeit, but your legend
-      lives on.
-    </p>
-  ) : outcome ? (
-    <p>
-      You won <strong>{rewardAmount} RGCVII</strong>
-    </p>
-  ) : (
-    <p>
-      Your GELD is now forfeit.
-      <br />
-      Try again 💪 we know you can do it!
-    </p>
-  );
+  const outcome = lastBossResult.reward != BigInt(0);
+  const ascended = lastBossResult.prestigeGained;
+
+  const text = outcome ? <span>and you <strong className={styles.won}>won!</strong> 🤩</span> : <span>and you <strong className={styles.lost}>lost</strong> 😔</span>;
+  const rewardAmount = parseFloat(parseFloat(formatUnits(bossToReward[lastBossResult.level], 18).toString()).toFixed(4));
+  const rewardText =
+    ascended ? <p>You won <strong>{rewardAmount} RGCVII</strong> and <strong>ASCENDED!!!</strong>. This means you beat the bosses and gained a <strong>Prestige level</strong>. Your GELD is now forfeit, but your legend lives on.</p>
+      : outcome ? <p>You won <strong>{rewardAmount} RGCVII</strong></p>
+        : <p>Your GELD is now forfeit.<br />Try again 💪 we know you can do it!</p>

  const bossName = bossToName[lastBossResult.variant];
  const bossClass = bossLevelToClass[lastBossResult.variant];

-  return (
-    <div className={`${styles.modal} ${styles.bossModal}`}>
+  return <div className={`${styles.modal} ${styles.bossModal}`}>
    <h2>You battled {bossName} Moloch!</h2>
    <div className={`${bgStyles.boss} ${bossClass} ${styles.image}`} />
    <p className={styles.outcome}>{text}</p>
@ -73,7 +36,6 @@ const BossOutcomeModal = ({ setIsOpen }: BossOutcomeModalProps) => {
      <button onClick={() => setIsOpen(false)}>Onward!</button>
    </div>
  </div>
-  );
-};
+}

-export default BossOutcomeModal;
+export default BossOutcomeModal 
--- a/app/src/components/Dashboard.tsx
+++ b/app/src/components/Dashboard.tsx
@ -1,85 +0,0 @@
-import { useEffect, useState } from 'react';
-import styles from '../styles/Dashboard.module.css';
-
-interface MetricsData {
-  totalPlayers: number;
-  totalRuns: number;
-  activePlayers24h: number;
-  totalBossesDefeated: number;
-  totalPrestigeLevels: number;
-}
-
-const SUBGRAPH_URL = "https://api.studio.thegraph.com/query/75782/slay-the-moloch-base-mainnet/version/latest";
-
-const Dashboard = () => {
-  const [metrics, setMetrics] = useState<MetricsData>();
-
-  useEffect(() => {
-    const fetchMetrics = async () => {
-      try {
-        const response = await fetch(SUBGRAPH_URL, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            query: `{
-              # Get global stats
-              globalStat(id: "1") {
-                totalPlayers
-                totalBossesDefeated
-                totalPrestigeLevels
-                totalRuns
-              }
-              # Get active players in last 24h
-              players(where: { lastRaidedAt_gt: "${Math.floor(Date.now() / 1000) - 86400}" }) {
-                id
-              }
-            }`
-          })
-        });
-
-        const data = await response.json();
-
-        setMetrics({
-          totalPlayers: parseInt(data.data.globalStat.totalPlayers),
-          totalRuns: parseInt(data.data.globalStat.totalRuns),
-          activePlayers24h: data.data.players.length,
-          totalBossesDefeated: parseInt(data.data.globalStat.totalBossesDefeated),
-          totalPrestigeLevels: parseInt(data.data.globalStat.totalPrestigeLevels)
-        });
-      } catch (error) {
-        console.error("Error fetching metrics:", error);
-      }
-    };
-
-    fetchMetrics();
-    const interval = setInterval(fetchMetrics, 30000); // Refresh every 30 seconds
-    return () => clearInterval(interval);
-  }, []);
-
-  return (
-    <div className={styles.dashboard}>
-      <div className={styles.metric}>
-        <h3>Total Players</h3>
-        <p>{metrics?.totalPlayers || 0}</p>
-      </div>
-      <div className={styles.metric}>
-        <h3>Total Game Runs</h3>
-        <p>{metrics?.totalRuns || 0}</p>
-      </div>
-      <div className={styles.metric}>
-        <h3>Active Players (24h)</h3>
-        <p>{metrics?.activePlayers24h || 0}</p>
-      </div>
-      <div className={styles.metric}>
-        <h3>Total Bosses Defeated</h3>
-        <p>{metrics?.totalBossesDefeated || 0}</p>
-      </div>
-      <div className={styles.metric}>
-        <h3>Total Prestige Levels</h3>
-        <p>{metrics?.totalPrestigeLevels || 0}</p>
-      </div>
-    </div>
-  );
-};
-
-export default Dashboard;
--- a/app/src/components/Leaderboard.tsx
+++ b/app/src/components/Leaderboard.tsx
@ -1,31 +1,22 @@
-import { useEffect, useState } from "react";
-import styles from "../styles/Leaderboard.module.css";
-import {
-    TopEarnersResponse,
-    TopRaidersResponse,
-    PlayerResponse,
-} from "../types/leaderboard";
-import { formatUnits } from "viem";
+import { useEffect, useState } from 'react'
+import styles from '../styles/Leaderboard.module.css'
+import { TopEarnersResponse, TopRaidersResponse } from '../types/leaderboard'
+import { formatUnits } from 'viem'

-const SUBGRAPH_URL =
-    "https://api.studio.thegraph.com/query/75782/slay-the-moloch-base-mainnet/version/latest";
+const SUBGRAPH_URL = 'https://api.studio.thegraph.com/query/75782/slay-the-moloch-base-sepolia/version/latest'

 const Leaderboard = () => {
-    const [topEarners, setTopEarners] = useState<TopEarnersResponse>();
-    const [topRaiders, setTopRaiders] = useState<TopRaidersResponse>();
-    const [activeTab, setActiveTab] = useState<
-        "earners" | "raiders" | "bosses" | "prestige"
-    >("earners");
-    const [bossesDefeated, setBossesDefeated] = useState<PlayerResponse>();
-    const [playerPrestige, setPlayerPrestige] = useState<PlayerResponse>();
+  const [topEarners, setTopEarners] = useState<TopEarnersResponse>()
+  const [topRaiders, setTopRaiders] = useState<TopRaidersResponse>()
+  const [activeTab, setActiveTab] = useState<'earners' | 'raiders'>('earners')

  useEffect(() => {
    const fetchLeaderboards = async () => {
      try {
        // Fetch top earners
        const earnersResponse = await fetch(SUBGRAPH_URL, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            query: `{
              armies(first: 10, orderBy: profitPerSecond, orderDirection: desc) {
@ -41,16 +32,16 @@ const Leaderboard = () => {
                anointedLevel
                championLevel
              }
-            }`,
-                    }),
-                });
-                const earnersData = await earnersResponse.json();
-                setTopEarners({ armies: earnersData.data.armies });
+            }`
+          })
+        })
+        const earnersData = await earnersResponse.json()
+        setTopEarners({ armies: earnersData.data.armies })

        // Fetch top raiders
        const raidersResponse = await fetch(SUBGRAPH_URL, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            query: `{
              players(first: 10, orderBy: numberOfRaids, orderDirection: desc) {
@ -59,52 +50,20 @@ const Leaderboard = () => {
                totalMinted
                currentBalance
              }
-            }`,
-                    }),
-                });
-                const raidersData = await raidersResponse.json();
-                setTopRaiders({ players: raidersData.data.players });
-
-                // Fetch bosses defeated
-                const bossesDefeatedResponse = await fetch(SUBGRAPH_URL, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        query: `{
-                        players(first: 10, orderBy: bossesDefeated, orderDirection: desc) {
-                          id
-                          bossesDefeated
-                        }
-                      }`,
-                    }),
-                });
-                const bossesDefeatedData = await bossesDefeatedResponse.json();
-                setBossesDefeated({ players: bossesDefeatedData.data.players });
-
-                // Fetch player prestige
-                const playerPrestigeResponse = await fetch(SUBGRAPH_URL, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        query: `{
-                        players(first: 10, orderBy: prestigeLevel, orderDirection: desc) {
-                          id
-                          prestigeLevel
-                        }
-                      }`,
-                    }),
-                });
-                const playerPrestigeData = await playerPrestigeResponse.json();
-                setPlayerPrestige({ players: playerPrestigeData.data.players });
+            }`
+          })
+        })
+        const raidersData = await raidersResponse.json()
+        setTopRaiders({ players: raidersData.data.players })
      } catch (error) {
-                console.error("Error fetching leaderboard:", error);
+        console.error('Error fetching leaderboard:', error)
+      }
    }
-        };

-        fetchLeaderboards();
-        const interval = setInterval(fetchLeaderboards, 30000); // Refresh every 30 seconds
-        return () => clearInterval(interval);
-    }, []);
+    fetchLeaderboards()
+    const interval = setInterval(fetchLeaderboards, 30000) // Refresh every 30 seconds
+    return () => clearInterval(interval)
+  }, [])

  return (
    <div className={styles.leaderboard}>
@ -112,106 +71,44 @@ const Leaderboard = () => {
      
      <div className={styles.tabs}>
        <button 
-                    className={`${styles.tab} ${
-                        activeTab === "earners" ? styles.active : ""
-                    }`}
-                    onClick={() => setActiveTab("earners")}
+          className={`${styles.tab} ${activeTab === 'earners' ? styles.active : ''}`}
+          onClick={() => setActiveTab('earners')}
        >
          Top Earners
        </button>
        <button 
-                    className={`${styles.tab} ${
-                        activeTab === "raiders" ? styles.active : ""
-                    }`}
-                    onClick={() => setActiveTab("raiders")}
+          className={`${styles.tab} ${activeTab === 'raiders' ? styles.active : ''}`}
+          onClick={() => setActiveTab('raiders')}
        >
          Top Raiders
        </button>
-                <button
-                    className={`${styles.tab} ${
-                        activeTab === "bosses" ? styles.active : ""
-                    }`}
-                    onClick={() => setActiveTab("bosses")}
-                >
-                    Top Boss Slayers
-                </button>
-                <button
-                    className={`${styles.tab} ${
-                        activeTab === "prestige" ? styles.active : ""
-                    }`}
-                    onClick={() => setActiveTab("prestige")}
-                >
-                    Top Players by Prestige
-                </button>
      </div>

-            {activeTab === "earners" && (
+      {activeTab === 'earners' && (
        <div className={styles.list}>
          {topEarners?.armies.map((army, index) => (
            <div key={army.player.id} className={styles.item}>
              <span className={styles.rank}>#{index + 1}</span>
-                            <span className={styles.address}>
-                                {army.player.id.slice(0, 6)}...
-                                {army.player.id.slice(-4)}
-                            </span>
-                            <span className={styles.stat}>
-                                {formatUnits(BigInt(army.profitPerSecond), 4)}{" "}
-                                GELD/s
-                            </span>
+              <span className={styles.address}>{army.player.id.slice(0, 6)}...{army.player.id.slice(-4)}</span>
+              <span className={styles.stat}>{formatUnits(BigInt(army.profitPerSecond), 4)} GELD/s</span>
            </div>
          ))}
        </div>
      )}

-            {activeTab === "raiders" && (
+      {activeTab === 'raiders' && (
        <div className={styles.list}>
          {topRaiders?.players.map((player, index) => (
            <div key={player.id} className={styles.item}>
              <span className={styles.rank}>#{index + 1}</span>
-                            <span className={styles.address}>
-                                {player.id.slice(0, 6)}...{player.id.slice(-4)}
-                            </span>
-                            <span className={styles.stat}>
-                                {player.numberOfRaids} raids
-                            </span>
-                        </div>
-                    ))}
-                </div>
-            )}
-
-            {activeTab === "bosses" && (
-                <div className={styles.list}>
-                    {bossesDefeated?.players.map((player, index) => (
-                        <div key={player.id} className={styles.item}>
-                            <span className={styles.rank}>#{index + 1}</span>
-                            <span className={styles.address}>
-                                {player.id.slice(0, 6)}...{player.id.slice(-4)}
-                            </span>
-                            <span className={styles.stat}>
-                                {player.bossesDefeated} Bosses Slain
-                            </span>
-                        </div>
-                    ))}
-                </div>
-            )}
-
-            {activeTab === "prestige" && (
-                <div className={styles.list}>
-                    {playerPrestige?.players.map((player, index) => (
-                        <div key={player.id} className={styles.item}>
-                            <span className={styles.rank}>#{index + 1}</span>
-                            <span className={styles.address}>
-                                {player.id.slice(0, 6)}...{player.id.slice(-4)}
-                            </span>
-                            <span className={styles.stat}>
-                                {player.prestigeLevel} Prestige Level
-                            </span>
+              <span className={styles.address}>{player.id.slice(0, 6)}...{player.id.slice(-4)}</span>
+              <span className={styles.stat}>{player.numberOfRaids} raids</span>
            </div>
          ))}
        </div>
      )}
    </div>
-    );
-};
+  )
+}

-export default Leaderboard;
+export default Leaderboard
--- a/app/src/components/Scene.tsx
+++ b/app/src/components/Scene.tsx
@ -8,7 +8,6 @@ import Leaderboard from "./Leaderboard";
 import { usePlayer } from "../providers/PlayerProvider";
 import Boss from "./Boss";
 import BossInfo from "./BossInfo";
-import Link from "next/link";

 const bossToMountainsClass = {
  0: styles.mountains0,
@ -54,7 +53,6 @@ const Scene = () => {
    >
      🏆 <span className={styles.hideMobile}>Top players</span>
    </button>
-    <Link href="/metrics" className={styles.metricsButton}>📈 <span className={styles.hideMobile}>Game metrics</span></Link>
    {isLeaderboardOpen && (
      <div className={styles.leaderboardOverlay}>
        <div className={styles.leaderboardContent}>
--- a/app/src/pages/_app.tsx
+++ b/app/src/pages/_app.tsx
@ -8,10 +8,8 @@ import { RainbowKitProvider, midnightTheme } from "@rainbow-me/rainbowkit";
 import { config } from "../wagmi";
 import { Press_Start_2P, Texturina } from "next/font/google";
 import PlayerProvider from "../providers/PlayerProvider";
-import ModalProvider from "../providers/ModalProvider";
-import Script from "next/script";
-import { useEffect } from "react";
-import { clickSound } from "../utils/soundsEffect";
+import ModalProvider from '../providers/ModalProvider';
+

 const client = new QueryClient();
 const font = Texturina({ weight: ["400"], subsets: ["latin"] });
@ -20,18 +18,6 @@ const font = Texturina({ weight: ["400"], subsets: ["latin"] });
 const fontPixel = Press_Start_2P({ weight: ["400"], subsets: ["latin"] });

 function MyApp({ Component, pageProps }: AppProps) {
-  useEffect(() => {
-    window.addEventListener("click", () => {
-      clickSound();
-    });
-
-    return () => {
-      window.removeEventListener("click", () => {
-        clickSound();
-      });
-    };
-  }, []);
-
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={client}>
@ -60,14 +46,6 @@ function MyApp({ Component, pageProps }: AppProps) {
          `}</style>
          <PlayerProvider>
            <ModalProvider>
-              <Script
-                src="https://sfxr.me/riffwave.js"
-                strategy="beforeInteractive"
-              />
-              <Script
-                src="https://sfxr.me/sfxr.js"
-                strategy="beforeInteractive"
-              />
              <Component {...pageProps} />
            </ModalProvider>
          </PlayerProvider>
--- a/app/src/pages/metrics.tsx
+++ b/app/src/pages/metrics.tsx
@ -1,15 +0,0 @@
-import Dashboard from '../components/Dashboard';
-import styles from '../styles/Metrics.module.css';
-import Link from 'next/link';
-
-const MetricsPage = () => {
-  return (
-    <div className={styles.metricsPage}>
-      <Link href="/" className={styles.backLink}>← Back to game</Link>
-      <h1>Game Metrics</h1>
-      <Dashboard />
-    </div>
-  );
-};
-
-export default MetricsPage;
--- a/app/src/providers/PlayerProvider.tsx
+++ b/app/src/providers/PlayerProvider.tsx
@ -1,55 +1,38 @@
-import React, {
-  createContext,
-  ReactNode,
-  useCallback,
-  useContext,
-  useEffect,
-  useRef,
-  useState,
-} from "react";
-import { useAccount, useReadContract, useWriteContract } from "wagmi";
-import contractAbi from "../../../out/RaidGeld.sol/RaidGeld.json";
-import { Hash, parseEther } from "viem";
-import contracts from "../../contract_address";
-import WaitingForTxModal from "../components/WaitingForTxModal";
-import BossOutcomeModal from "../components/BossOutcomeModal";
-import styles from "../styles/Background.module.css";
-import { coinSound } from "../utils/soundsEffect";
+import React, { createContext, ReactNode, useCallback, useContext, useEffect, useRef, useState } from 'react'
+import { useAccount, useReadContract, useWriteContract } from 'wagmi'
+import contractAbi from "../../../out/RaidGeld.sol/RaidGeld.json"
+import { Hash, parseEther } from 'viem'
+import contracts from '../../contract_address'
+import WaitingForTxModal from '../components/WaitingForTxModal'
+import BossOutcomeModal from '../components/BossOutcomeModal'
+import styles from "../styles/Background.module.css"

-const { contractAddress, daoTokenAddress } = contracts;
-const abi = contractAbi.abi;
+const { contractAddress, daoTokenAddress } = contracts
+const abi = contractAbi.abi

-export type UnitType = 0 | 1 | 2 | 3;
-export type BossLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type UnitType = 0 | 1 | 2 | 3
+export type BossLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6

 export interface Player {
-  created_at: bigint;
-  last_raided_at: bigint;
-  total_minted: bigint;
-  total_rewards: bigint;
-  n_runs: number;
-  prestige_level: number;
-  is_registered: boolean;
-  has_active_session: boolean;
+  created_at: bigint,
+  last_raided_at: bigint,
+  total_minted: bigint
+  total_rewards: bigint,
+  n_runs: number,
+  prestige_level: number,
+  is_registered: boolean,
+  has_active_session: boolean,
 }
 export interface Army {
-  anointed: { level: number };
-  apprentice: { level: number };
-  champion: { level: number };
-  moloch_denier: { level: number };
-  profit_per_second: bigint;
+  anointed: { level: number }
+  apprentice: { level: number }
+  champion: { level: number }
+  moloch_denier: { level: number }
+  profit_per_second: bigint
 }
 export interface Boss {
  level: BossLevel;
-  variants: [
-    BossLevel,
-    BossLevel,
-    BossLevel,
-    BossLevel,
-    BossLevel,
-    BossLevel,
-    BossLevel
-  ];
+  variants: [BossLevel, BossLevel, BossLevel, BossLevel, BossLevel, BossLevel, BossLevel]
 }

 export interface LastBossResult {
@ -61,14 +44,14 @@ export interface LastBossResult {
 }

 export interface PlayerContextType {
-  isRegistered: boolean;
-  player: null | Player;
-  army: null | Army;
-  boss: null | Boss;
-  lastBossResult: null | LastBossResult;
-  balance: bigint;
-  register: (arg: "ETH" | "RGCVII") => void;
-  raid: () => void;
+  isRegistered: boolean,
+  player: null | Player,
+  army: null | Army,
+  boss: null | Boss,
+  lastBossResult: null | LastBossResult,
+  balance: bigint,
+  register: (arg: "ETH" | "RGCVII") => void,
+  raid: () => void,
  battleWithBoss: () => void;
  addUnit: (unit: UnitType, amount?: number) => void;
 }
@ -80,199 +63,169 @@ const PlayerContext = createContext<PlayerContextType>({
  boss: null,
  lastBossResult: null,
  balance: BigInt(0),
-  register: () => {},
-  raid: () => {},
-  battleWithBoss: () => {},
-  addUnit: () => {},
+  register: () => { },
+  raid: () => { },
+  battleWithBoss: () => { },
+  addUnit: () => { }
 });

 const PlayerProvider = ({ children }: { children: ReactNode }) => {
  const { address, isConnected } = useAccount();
  const { writeContract, error } = useWriteContract();
-  const [[txHash, callbackFn], setHashAndCallback] = useState<
-    [Hash | null, () => void]
-  >([null, () => {}]);
+  const [[txHash, callbackFn], setHashAndCallback] = useState<[Hash | null, () => void]>([null, () => { }])
  const [bossBattledModalOpen, setBossBattlesModalOpen] = useState(false);
  const hasFetchedLastBossFirstTime = useRef(false);

  useEffect(() => {
-    console.warn(error);
-  }, [error]);
+    console.warn(error)
+  }, [error])

  const resetHashAndCallback = useCallback(() => {
-    setHashAndCallback([null, () => {}]);
-  }, []);
+    setHashAndCallback([null, () => { }])
+  }, [])

  const { data: isRegistered } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "isRegistered",
+    functionName: 'isRegistered',
    args: [address],
    query: {
      enabled: isConnected,
-      refetchInterval: 10000,
-    },
+      refetchInterval: 15,
+    }
  });

-  const { data: balance } = useReadContract({
+  const { data: balance, } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "balanceOf",
+    functionName: 'balanceOf',
    args: [address],
    query: {
-      refetchInterval: 10000,
-      enabled: isConnected,
-    },
+      refetchInterval: 15,
+      enabled: isConnected
+    }
  });

  const { data: player } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "getPlayer",
+    functionName: 'getPlayer',
    args: [address],
    query: {
      enabled: isConnected,
-      refetchInterval: 10000,
-    },
+      refetchInterval: 15
+    }
  });

  const { data: army } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "getArmy",
+    functionName: 'getArmy',
    args: [address],
    query: {
      enabled: isConnected,
-      refetchInterval: 10000,
-    },
+      refetchInterval: 15
+    }
  });

  const { data: boss } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "getBoss",
+    functionName: 'getBoss',
    args: [address],
    query: {
      enabled: isConnected,
-      refetchInterval: 10000,
-    },
+      refetchInterval: 15
+    }
  });

  const { data: lastBossResult } = useReadContract({
    address: contractAddress,
    abi,
-    functionName: "getLastBossResult",
+    functionName: 'getLastBossResult',
    args: [address],
    query: {
      enabled: isConnected,
-      refetchInterval: 10000,
-    },
+      refetchInterval: 15
+    }
  });

-  const register = useCallback(
-    (arg: "RGCVII" | "ETH") => {
-      if (arg === "ETH") {
-        writeContract(
-          {
+  console.log(balance, player, army, boss)
+
+  const register = useCallback((arg: "RGCVII" | "ETH") => {
+    if (arg === 'ETH') {
+      writeContract({
        abi,
        address: contractAddress,
-            functionName: "register_eth",
+        functionName: 'register_eth',
        value: parseEther("0.00045"),
-          },
-          {
+      }, {
        onSuccess: (hash) => {
-              setHashAndCallback([hash, resetHashAndCallback]);
+          setHashAndCallback([hash, resetHashAndCallback])
        },
-            onError: () => resetHashAndCallback(),
-          }
-        );
+        onError: () => resetHashAndCallback()
+      })
    } else if (arg === "RGCVII") {
-        writeContract(
-          {
+      writeContract({
        abi,
        address: daoTokenAddress,
-            functionName: "approve",
+        functionName: 'approve',
        args: [contractAddress, parseEther("400")],
-          },
-          {
+      }, {
        onSuccess: (hash) => {
          setHashAndCallback([
            hash,
-                () =>
-                  writeContract(
-                    {
+            () => writeContract({
              abi,
              address: contractAddress,
-                      functionName: "register_dao",
-                    },
-                    {
+              functionName: 'register_dao',
+            }, {
              onSuccess: (hash) => {
-                        setHashAndCallback([hash, resetHashAndCallback]);
+                setHashAndCallback([hash, resetHashAndCallback])
              },
-                      onError: () => resetHashAndCallback(),
-                    }
-                  ),
-              ]);
+              onError: () => resetHashAndCallback()
+            })
+          ])
        },
-            onError: () => resetHashAndCallback(),
+        onError: () => resetHashAndCallback()
+      });
    }
-        );
-      }
-    },
-    [writeContract, resetHashAndCallback]
-  );
+  }, [writeContract, resetHashAndCallback])

  const raid = useCallback(() => {
-    writeContract(
-      {
+    writeContract({
      abi,
      address: contractAddress,
-        functionName: "raid",
-      },
-      {
+      functionName: 'raid',
+    }, {
      onSuccess: (hash) => {
-          setHashAndCallback([hash, resetHashAndCallback]);
+        setHashAndCallback([hash, resetHashAndCallback])
      },
-        onError: () => resetHashAndCallback(),
-      }
-    );
-  }, [writeContract, resetHashAndCallback]);
+      onError: () => resetHashAndCallback()
+    })
+  }, [writeContract, resetHashAndCallback])

-  const addUnit = useCallback(
-    (unit: UnitType) => {
-      writeContract(
-        {
+  const addUnit = useCallback((unit: UnitType) => {
+    writeContract({
      abi,
      address: contractAddress,
-          functionName: "addUnit",
-          args: [unit, 1],
-        },
-        {
-          onSuccess: () => {
-            coinSound();
-          },
-          onError: () => resetHashAndCallback(),
-        }
-      );
-    },
-    [writeContract, resetHashAndCallback]
-  );
+      functionName: 'addUnit',
+      args: [unit, 1]
+    })
+  }, [writeContract])

  const battleWithBoss = useCallback(() => {
-    writeContract(
-      {
+    writeContract({
      abi,
      address: contractAddress,
-        functionName: "battle_with_boss",
-      },
-      {
+      functionName: 'battle_with_boss',
+    }, {
      onSuccess: (hash) => {
-          setHashAndCallback([hash, () => resetHashAndCallback()]);
+        setHashAndCallback([hash, () => resetHashAndCallback()])
      },
-        onError: () => resetHashAndCallback(),
-      }
-    );
-  }, [writeContract, resetHashAndCallback]);
+      onError: () => resetHashAndCallback()
+    })
+  }, [writeContract, resetHashAndCallback])

  useEffect(() => {
    if (lastBossResult != null) {
@ -282,11 +235,10 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
        hasFetchedLastBossFirstTime.current = true;
      }
    }
-  }, [lastBossResult]);
+  }, [lastBossResult])

  return (
-    <PlayerContext.Provider
-      value={{
+    <PlayerContext.Provider value={{
      isRegistered: isRegistered as boolean,
      player: player as Player,
      army: army as Army,
@ -296,26 +248,20 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
      register,
      raid,
      addUnit,
-        battleWithBoss,
-      }}
-    >
+      battleWithBoss
+    }}>
      {children}
-      <div
-        className={`${
-          txHash || bossBattledModalOpen ? styles.leaderboardOverlay : ""
-        }`}
-      >
+      <div className={`${(txHash || bossBattledModalOpen) ? styles.leaderboardOverlay : ""}`}>
        {txHash && <WaitingForTxModal hash={txHash} callbackFn={callbackFn} />}
-        {bossBattledModalOpen && (
-          <BossOutcomeModal setIsOpen={setBossBattlesModalOpen} />
-        )}
+        {bossBattledModalOpen && <BossOutcomeModal setIsOpen={setBossBattlesModalOpen} />}
      </div>
    </PlayerContext.Provider>
  );
-};
+}

 export const usePlayer = () => {
  return useContext(PlayerContext);
-};
+}
+
+export default PlayerProvider

-export default PlayerProvider;
--- a/app/src/styles/Background.module.css
+++ b/app/src/styles/Background.module.css
@ -402,8 +402,7 @@
  }
 }

-.leaderboardButton,
-.metricsButton {
+.leaderboardButton {
  position: absolute;
  top: 30px;
  left: 80px;
@ -426,12 +425,6 @@
    }
  }
 }
-.metricsButton {
-  left: auto;
-  top: auto;
-  right: 32px;
-  bottom: 32px;
-}

 .leaderboardButton:hover {
  transform: scale(1.1);
--- a/app/src/styles/Dashboard.module.css
+++ b/app/src/styles/Dashboard.module.css
@ -1,29 +0,0 @@
-.dashboard {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-    gap: 2rem;
-    padding: 2rem;
-    max-width: 1200px;
-    margin: 0 auto;
-  }
-  
-  .metric {
-    background: rgba(0, 0, 0, 0.8);
-    border-radius: 8px;
-    padding: 1.5rem;
-    text-align: center;
-    border: 1px solid rgba(255, 255, 255, 0.1);
-  }
-  
-  .metric h3 {
-    color: #888;
-    margin: 0 0 1rem 0;
-    font-size: 1.1rem;
-  }
-  
-  .metric p {
-    color: #fff;
-    font-size: 2rem;
-    margin: 0;
-    font-weight: bold;
-  }
--- a/app/src/styles/Metrics.module.css
+++ b/app/src/styles/Metrics.module.css
@ -1,23 +0,0 @@
-.metricsPage {
-    min-height: 100vh;
-    padding: 2rem;
-    background: #1a1a1a;
-    color: white;
-  }
-  
-  .metricsPage h1 {
-    text-align: center;
-    margin-bottom: 3rem;
-  }
-  
-  .backLink {
-    display: inline-block;
-    color: #888;
-    text-decoration: none;
-    margin-bottom: 2rem;
-    transition: color 0.2s;
-  }
-  
-  .backLink:hover {
-    color: white;
-  }
--- a/app/src/types/leaderboard.ts
+++ b/app/src/types/leaderboard.ts
@ -1,31 +1,25 @@
 export interface Player {
-    id: string;
-    totalMinted: string;
-    currentBalance: string;
-    numberOfRaids: string;
-    army?: Army;
-    bossesDefeated?: string;
-    prestigeLevel: string;
-}
+    id: string
+    totalMinted: string
+    currentBalance: string
+    numberOfRaids: string
+    army?: Army
+  }
  
-export interface Army {
-    player: Player;
-    profitPerSecond: string;
-    projectedDailyEarnings: string;
-    molochDenierLevel: string;
-    apprenticeLevel: string;
-    anointedLevel: string;
-    championLevel: string;
-}
+  export interface Army {
+    player: Player
+    profitPerSecond: string
+    projectedDailyEarnings: string
+    molochDenierLevel: string
+    apprenticeLevel: string
+    anointedLevel: string
+    championLevel: string
+  }
  
-export interface TopEarnersResponse {
-    armies: Army[];
-}
+  export interface TopEarnersResponse {
+    armies: Army[]
+  }
  
-export interface TopRaidersResponse {
-    players: Player[];
-}
-
-export interface PlayerResponse {
-    players: Player[];
-}
+  export interface TopRaidersResponse {
+    players: Player[]
+  }
--- a/app/src/utils/soundsEffect.js
+++ b/app/src/utils/soundsEffect.js
@ -1,44 +0,0 @@
-// https://sfxr.me/
-// https://github.com/chr15m/jsfxr?tab=readme-ov-file#library
-// https://github.com/goldfire/howler.js
-
-import { sfxr } from "jsfxr";
-import { Howl } from "howler";
-
-export const coinSound = () => {
-  const coin = sfxr.toAudio(
-    "34T6PkpUzHPSs4CvSaNXpQ6fftpW1yrCDSda6oECJ5CH6BEaokmoZC7aAra2xef61iP6srxUaRZUk8Z2DRJHNMEvtWCLjgKkUCFtpxPe9o8AvYBCJZG1YNNPR"
-  );
-  coin.play();
-};
-
-export const errorSound = () => {
-  const fail = sfxr.toAudio(
-    "3mLuemG9nym33ak7ot6gTcNTFBBnNkcF4rmQFkh1zRhrvJ6totmE1EX61m9LTW9KWGuQpQEMqnVopubShwmxqQK7vAZYMXKbJCxYE9bcTh2qMm9JbMRJAKD5a"
-  );
-  fail.play();
-};
-
-export const clickSound = () => {
-  const click = sfxr.toAudio(
-    "7BMHBGPkXasqBZ54qHeMQTKSwDs2Y176H4hQVNkvQPg5eZyckEhyzKTnAZfqnp9ayL5iPVRNXFNjXAXBbUKhT7U6c1hKZBgWzaWkWTQvmcrCwikKi3RoF7wbd"
-  );
-  click.play();
-};
-
-export const lostSound = () => {
-  const fail = new Howl({
-    src: ["/sounds/lost.wav"],
-    volume: 0.7
-  });
-
-  fail.play();
-};
-
-export const wonSound = () => {
-  const won = new Howl({
-    src: ["/sounds/arcade_win.wav"],
-  });
-
-  won.play();
-};
--- a/app/src/wagmi.ts
+++ b/app/src/wagmi.ts
@ -9,9 +9,9 @@ export const config = getDefaultConfig({
  appName: 'RainbowKit App',
  projectId: 'YOUR_PROJECT_ID',
  chains: [
-    base,
-    foundry,
    baseSepolia,
+    foundry,
+    base,
  ],
  ssr: true,
 });
--- a/broadcast/RaidGeld.s.sol/8453/run-1730464724.json
+++ b/broadcast/RaidGeld.s.sol/8453/run-1730464724.json
--- a/broadcast/RaidGeld.s.sol/8453/run-latest.json
+++ b/broadcast/RaidGeld.s.sol/8453/run-latest.json
--- a/src/RaidGeld.sol
+++ b/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 :)");
    }
Author	SHA1	Message	Date
yellow	0e691e46af	session wallet Some checks failed CI / Foundry project (push) Has been cancelled Details	2024-11-01 16:45:31 +01:00
yellow	4c8f2250b7	add to boss fight	2024-11-01 16:13:41 +01:00
yellow	ef1c242471	session wallet Some checks are pending CI / Foundry project (push) Waiting to run Details	2024-11-01 13:30:56 +01:00