From c404c1c9845e227f73737cf5c5a99af9039cea02 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Tue, 26 Aug 2025 15:28:41 -0400
Subject: [PATCH 01/34] initial commit

---
 README.md    | 134 +++++++++++++++++++++++++++++++++++++++++++++++++--
 funding.json |   5 ++
 2 files changed, 135 insertions(+), 4 deletions(-)
 create mode 100644 funding.json

diff --git a/README.md b/README.md
index d8a2c9f8..560a520a 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,132 @@
-# Base Challenge Extension Template
-> ⚠️ This is not meant to be used as an extension by itself. Follow instructions [here](https://github.com/scaffold-eth/se-2-challenges/blob/main/README.md#-contributing-guide-and-hints-to-create-new-challenges) to see how to use this set of files.
+# 🏗 Scaffold-ETH 2 Challenges
 
-You can use these files to help set up a new extension that matches the style and feel of [SpeedRunEthereum](https://speedrunethereum.com/).
+**Learn how to use 🏗 Scaffold-ETH 2 to create decentralized applications on Ethereum. 🚀**
 
-There are `// CHALLENGE-TODO:` comments placed throughout that provide instructions on key changes to adapt this template for use with a new challenge.
+---
+
+## 🚩 Challenge 0: 🎟 Simple NFT Example
+
+🎫 Create a simple NFT to learn the basics of 🏗 scaffold-eth. You'll use 👷‍♀️ HardHat to compile and deploy smart contracts. Then, you'll use a template React app full of important Ethereum components and hooks. Finally, you'll deploy an NFT to a public network to share with friends! 🚀
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-0-simple-nft
+
+---
+
+## 🚩 Challenge 1: 🔏 Decentralized Staking App
+
+🦸 A superpower of Ethereum is allowing you, the builder, to create a simple set of rules that an adversarial group of players can use to work together. In this challenge, you create a decentralized application where users can coordinate a group funding effort. If the users cooperate, the money is collected in a second smart contract. If they defect, the worst that can happen is everyone gets their money back. The users only have to trust the code.
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-1-decentralized-staking
+
+---
+
+## 🚩 Challenge 2: 🏵 Token Vendor
+
+🤖 Smart contracts are kind of like "always on" vending machines that anyone can access. Let's make a decentralized, digital currency. Then, let's build an unstoppable vending machine that will buy and sell the currency. We'll learn about the "approve" pattern for ERC20s and how contract to contract interactions work.
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-2-token-vendor
+
+---
+
+## 🚩 Challenge 3: 🎲 Dice Game
+
+🎰 Randomness is tricky on a public deterministic blockchain. In this challenge you will explore creating random numbers using block hash and how that may be exploitable. Attack the dice game with your own contract by predicting the randomness ahead of time to always roll a winner!
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-3-dice-game
+
+---
+
+## 🚩 Challenge 4: ⚖️ Build a DEX Challenge
+
+💵 Build an exchange that swaps ETH to tokens and tokens to ETH. 💰 This is possible because the smart contract holds reserves of both assets and has a price function based on the ratio of the reserves. Liquidity providers are issued a token that represents their share of the reserves and fees...
+
+DEX Telegram Channel: https://t.me/+_NeUIJ664Tc1MzIx
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-4-dex
+
+---
+
+## 🎉 Checkpoint: Eligible to join 🏰️ BuidlGuidl
+
+The BuidlGuidl is a curated group of Ethereum builders creating products, prototypes, and tutorials to enrich the web3 ecosystem. A place to show off your builds and meet other builders. Start crafting your Web3 portfolio by submitting your DEX, Multisig or SVG NFT build.
+
+https://buidlguidl.com/
+
+---
+
+## 🚩 Challenge 5: 📺 State Channel Application Challenge
+
+🛣️ The Ethereum blockchain has great decentralization & security properties but these properties come at a price: transaction throughput is low, and transactions can be expensive. This makes many traditional web applications infeasible on a blockchain... or does it? State channels look to solve these problems by allowing participants to securely transact off-chain while keeping interaction with Ethereum Mainnet at a minimum.
+
+State Channels Telegram Channel: https://t.me/+k0eUYngV2H0zYWUx
+
+https://github.com/scaffold-eth/se-2-challenges/tree/challenge-5-state-channels
+
+---
+
+## 💡 Contributing: Guide and Hints to create New Challenges
+
+### 1. Learn about SE-2 Extensions
+
+Go to [SE-2 Extensions Documentation](https://docs.scaffoldeth.io/extensions/createExtensions) and familiarize yourself with the way extensions work by watching the video and reading the overview.
+
+### 2. Follow the steps to create an extension
+1. Clone the [create-eth repo](https://github.com/scaffold-eth/create-eth) and cd into it.
+```bash
+    git clone https://github.com/scaffold-eth/create-eth
+    cd create-eth
+```
+
+#### Setting up things in externalExtensions:
+2. cd into `externalExtensions` (if it's not present `mkdir externalExtensions && cd externalExtensions`)
+
+3. Clone the base-challenge-template with name of your extension inside `externalExtensions`:
+
+```bash
+    git clone -b base-challenge-template https://github.com/scaffold-eth/se-2-challenges.git <my-challenge-name>
+```
+
+4. cd into `<my-challenge-name>` dir and create a branch with your challenge name.
+```bash
+    cd <my-challenge-name> && git switch -c <my-challenge-name>
+```
+
+5. Find all the file comments marked `// CHALLENGE-TODO:` and follow the instructions to prepare your challenge.
+
+6. Commit those changes as an initial commit: `git add . && git commit -m "fill template"`
+
+#### Commands to be run in create-eth repo:
+
+1. Build the create-eth cli
+
+```bash
+    yarn build:dev
+```
+
+2. Create an instance with same name as the challenge name directory which was created inside `externalExtensions`:
+
+```bash
+    yarn cli ../<my-challenge-name> -e <my-challenge-name> --dev
+```
+
+3. This will create the full instance outside of create-eth repo with <my-challenge-name>
+
+4. Tinker in that instance, adding any new files your challenge will use and then committing those changes
+
+5. Run this in create-eth to copy all the changes to you extension:
+
+```bash
+    yarn create-extension ../<my-challenge-name>
+```
+
+### 3. Testing your extension
+
+Now that you ran the `create-extension` command you should see in the terminal all files that were created and any missing template files. Add any missing template files and continue to follow the instructions in the [local testing](https://docs.scaffoldeth.io/extensions/createExtensions#local-testing) section!
+
+Don't forget to add a README.md to the top level of your extension. It should match what you put in the `extraContents` variable in `extension/README.md.args.mjs`.
+
+Iterate as necessary, repeating the steps, to get it just right.
+
+### 4. Submit a PR
+
+Once you have iterated your challenge to perfection, you can ask a maintainer to add a branch for your challenge and then submit a pull request to that branch. Expect to make a few passes of revisions as we test these challenges extensively.
diff --git a/funding.json b/funding.json
new file mode 100644
index 00000000..1493388d
--- /dev/null
+++ b/funding.json
@@ -0,0 +1,5 @@
+{
+  "opRetro": {
+    "projectId": "0x154a42e5ca88d7c2732fda74d6eb611057fc88dbe6f0ff3aae7b89c2cd1666ab"
+  }
+}

From 5eeca9fe87351a259020dca46943209c8b6e3dee Mon Sep 17 00:00:00 2001
From: Rinat <rinat@hey.com>
Date: Fri, 1 Nov 2024 15:30:00 +0300
Subject: [PATCH 02/34] Initial commit of base challenge template for
 extensions

---
 README.md                                     | 134 +-----------------
 .../packages/nextjs/app/page.tsx.args.mjs     |   1 -
 .../ScaffoldEthAppWithProviders.tsx.args.mjs  |   1 +
 .../packages/nextjs/next.config.js.args.mjs   |   1 +
 .../nextjs/tailwind.config.js.args.mjs        |  68 +++++++++
 5 files changed, 74 insertions(+), 131 deletions(-)
 create mode 100644 extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
 create mode 100644 extension/packages/nextjs/next.config.js.args.mjs
 create mode 100644 extension/packages/nextjs/tailwind.config.js.args.mjs

diff --git a/README.md b/README.md
index 560a520a..d8a2c9f8 100644
--- a/README.md
+++ b/README.md
@@ -1,132 +1,6 @@
-# 🏗 Scaffold-ETH 2 Challenges
+# Base Challenge Extension Template
+> ⚠️ This is not meant to be used as an extension by itself. Follow instructions [here](https://github.com/scaffold-eth/se-2-challenges/blob/main/README.md#-contributing-guide-and-hints-to-create-new-challenges) to see how to use this set of files.
 
-**Learn how to use 🏗 Scaffold-ETH 2 to create decentralized applications on Ethereum. 🚀**
+You can use these files to help set up a new extension that matches the style and feel of [SpeedRunEthereum](https://speedrunethereum.com/).
 
----
-
-## 🚩 Challenge 0: 🎟 Simple NFT Example
-
-🎫 Create a simple NFT to learn the basics of 🏗 scaffold-eth. You'll use 👷‍♀️ HardHat to compile and deploy smart contracts. Then, you'll use a template React app full of important Ethereum components and hooks. Finally, you'll deploy an NFT to a public network to share with friends! 🚀
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-0-simple-nft
-
----
-
-## 🚩 Challenge 1: 🔏 Decentralized Staking App
-
-🦸 A superpower of Ethereum is allowing you, the builder, to create a simple set of rules that an adversarial group of players can use to work together. In this challenge, you create a decentralized application where users can coordinate a group funding effort. If the users cooperate, the money is collected in a second smart contract. If they defect, the worst that can happen is everyone gets their money back. The users only have to trust the code.
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-1-decentralized-staking
-
----
-
-## 🚩 Challenge 2: 🏵 Token Vendor
-
-🤖 Smart contracts are kind of like "always on" vending machines that anyone can access. Let's make a decentralized, digital currency. Then, let's build an unstoppable vending machine that will buy and sell the currency. We'll learn about the "approve" pattern for ERC20s and how contract to contract interactions work.
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-2-token-vendor
-
----
-
-## 🚩 Challenge 3: 🎲 Dice Game
-
-🎰 Randomness is tricky on a public deterministic blockchain. In this challenge you will explore creating random numbers using block hash and how that may be exploitable. Attack the dice game with your own contract by predicting the randomness ahead of time to always roll a winner!
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-3-dice-game
-
----
-
-## 🚩 Challenge 4: ⚖️ Build a DEX Challenge
-
-💵 Build an exchange that swaps ETH to tokens and tokens to ETH. 💰 This is possible because the smart contract holds reserves of both assets and has a price function based on the ratio of the reserves. Liquidity providers are issued a token that represents their share of the reserves and fees...
-
-DEX Telegram Channel: https://t.me/+_NeUIJ664Tc1MzIx
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-4-dex
-
----
-
-## 🎉 Checkpoint: Eligible to join 🏰️ BuidlGuidl
-
-The BuidlGuidl is a curated group of Ethereum builders creating products, prototypes, and tutorials to enrich the web3 ecosystem. A place to show off your builds and meet other builders. Start crafting your Web3 portfolio by submitting your DEX, Multisig or SVG NFT build.
-
-https://buidlguidl.com/
-
----
-
-## 🚩 Challenge 5: 📺 State Channel Application Challenge
-
-🛣️ The Ethereum blockchain has great decentralization & security properties but these properties come at a price: transaction throughput is low, and transactions can be expensive. This makes many traditional web applications infeasible on a blockchain... or does it? State channels look to solve these problems by allowing participants to securely transact off-chain while keeping interaction with Ethereum Mainnet at a minimum.
-
-State Channels Telegram Channel: https://t.me/+k0eUYngV2H0zYWUx
-
-https://github.com/scaffold-eth/se-2-challenges/tree/challenge-5-state-channels
-
----
-
-## 💡 Contributing: Guide and Hints to create New Challenges
-
-### 1. Learn about SE-2 Extensions
-
-Go to [SE-2 Extensions Documentation](https://docs.scaffoldeth.io/extensions/createExtensions) and familiarize yourself with the way extensions work by watching the video and reading the overview.
-
-### 2. Follow the steps to create an extension
-1. Clone the [create-eth repo](https://github.com/scaffold-eth/create-eth) and cd into it.
-```bash
-    git clone https://github.com/scaffold-eth/create-eth
-    cd create-eth
-```
-
-#### Setting up things in externalExtensions:
-2. cd into `externalExtensions` (if it's not present `mkdir externalExtensions && cd externalExtensions`)
-
-3. Clone the base-challenge-template with name of your extension inside `externalExtensions`:
-
-```bash
-    git clone -b base-challenge-template https://github.com/scaffold-eth/se-2-challenges.git <my-challenge-name>
-```
-
-4. cd into `<my-challenge-name>` dir and create a branch with your challenge name.
-```bash
-    cd <my-challenge-name> && git switch -c <my-challenge-name>
-```
-
-5. Find all the file comments marked `// CHALLENGE-TODO:` and follow the instructions to prepare your challenge.
-
-6. Commit those changes as an initial commit: `git add . && git commit -m "fill template"`
-
-#### Commands to be run in create-eth repo:
-
-1. Build the create-eth cli
-
-```bash
-    yarn build:dev
-```
-
-2. Create an instance with same name as the challenge name directory which was created inside `externalExtensions`:
-
-```bash
-    yarn cli ../<my-challenge-name> -e <my-challenge-name> --dev
-```
-
-3. This will create the full instance outside of create-eth repo with <my-challenge-name>
-
-4. Tinker in that instance, adding any new files your challenge will use and then committing those changes
-
-5. Run this in create-eth to copy all the changes to you extension:
-
-```bash
-    yarn create-extension ../<my-challenge-name>
-```
-
-### 3. Testing your extension
-
-Now that you ran the `create-extension` command you should see in the terminal all files that were created and any missing template files. Add any missing template files and continue to follow the instructions in the [local testing](https://docs.scaffoldeth.io/extensions/createExtensions#local-testing) section!
-
-Don't forget to add a README.md to the top level of your extension. It should match what you put in the `extraContents` variable in `extension/README.md.args.mjs`.
-
-Iterate as necessary, repeating the steps, to get it just right.
-
-### 4. Submit a PR
-
-Once you have iterated your challenge to perfection, you can ask a maintainer to add a branch for your challenge and then submit a pull request to that branch. Expect to make a few passes of revisions as we test these challenges extensively.
+There are `// CHALLENGE-TODO:` comments placed throughout that provide instructions on key changes to adapt this template for use with a new challenge.
diff --git a/extension/packages/nextjs/app/page.tsx.args.mjs b/extension/packages/nextjs/app/page.tsx.args.mjs
index 2389922f..1d4ed8fc 100644
--- a/extension/packages/nextjs/app/page.tsx.args.mjs
+++ b/extension/packages/nextjs/app/page.tsx.args.mjs
@@ -26,6 +26,5 @@ export const description = `
     </div>
   </div>
 `;
-
 // CHALLENGE-TODO: Update the externalExtensionName to reflect your challenge
 export const externalExtensionName = "SpeedRunEthereum CHALLENGE TITLE";
diff --git a/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
new file mode 100644
index 00000000..fca30389
--- /dev/null
+++ b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
@@ -0,0 +1 @@
+export const globalClassNames = "font-space-grotesk";
diff --git a/extension/packages/nextjs/next.config.js.args.mjs b/extension/packages/nextjs/next.config.js.args.mjs
new file mode 100644
index 00000000..13898486
--- /dev/null
+++ b/extension/packages/nextjs/next.config.js.args.mjs
@@ -0,0 +1 @@
+export const ignoreTsAndLintBuildErrors = 'true';
diff --git a/extension/packages/nextjs/tailwind.config.js.args.mjs b/extension/packages/nextjs/tailwind.config.js.args.mjs
new file mode 100644
index 00000000..1ffa57b1
--- /dev/null
+++ b/extension/packages/nextjs/tailwind.config.js.args.mjs
@@ -0,0 +1,68 @@
+export const lightTheme = {
+    primary: "#C8F5FF",
+    "primary-content": "#026262",
+    secondary: "#89d7e9",
+    "secondary-content": "#088484",
+    accent: "#026262",
+    "accent-content": "#E9FBFF",
+    neutral: "#088484",
+    "neutral-content": "#F0FCFF",
+    "base-100": "#F0FCFF",
+    "base-200": "#E1FAFF",
+    "base-300": "#C8F5FF",
+    "base-content": "#088484",
+    info: "#026262",
+    success: "#34EEB6",
+    warning: "#FFCF72",
+    error: "#FF8863",
+  
+    "--rounded-btn": "9999rem",
+  
+    ".tooltip": {
+      "--tooltip-tail": "6px"
+    },
+    ".link": {
+      textUnderlineOffset: "2px"
+    },
+    ".link:hover": {
+      opacity: "80%"
+    }
+  };
+  
+  export const darkTheme = {
+    primary: "#026262",
+    "primary-content": "#C8F5FF",
+    secondary: "#107575",
+    "secondary-content": "#E9FBFF",
+    accent: "#C8F5FF",
+    "accent-content": "#088484",
+    neutral: "#E9FBFF",
+    "neutral-content": "#11ACAC",
+    "base-100": "#11ACAC",
+    "base-200": "#088484",
+    "base-300": "#026262",
+    "base-content": "#E9FBFF",
+    info: "#C8F5FF",
+    success: "#34EEB6",
+    warning: "#FFCF72",
+    error: "#FF8863",
+  
+    "--rounded-btn": "9999rem",
+  
+    ".tooltip": {
+      "--tooltip-tail": "6px",
+      "--tooltip-color": "oklch(var(--p))"
+    },
+    ".link": {
+      textUnderlineOffset: "2px"
+    },
+    ".link:hover": {
+      opacity: "80%"
+    }
+  };
+  
+  export const extendTheme = {
+    fontFamily: {
+      "space-grotesk": ["Space Grotesk", "sans-serif"]
+    }
+  };

From fb628b195bf9331973f620be98b5c42d4854c571 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Thu, 21 Aug 2025 15:44:26 -0400
Subject: [PATCH 03/34] fill template

---
 README.md                                     | 1120 ++++++++++++++++-
 extension/README.md.args.mjs                  | 1076 +++++++++++++++-
 .../packages/nextjs/app/layout.tsx.args.mjs   |    3 +-
 .../packages/nextjs/app/page.tsx.args.mjs     |   29 +-
 .../nextjs/components/Header.tsx.args.mjs     |   21 +-
 5 files changed, 2199 insertions(+), 50 deletions(-)

diff --git a/README.md b/README.md
index d8a2c9f8..e80de368 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,1118 @@
-# Base Challenge Extension Template
-> ⚠️ This is not meant to be used as an extension by itself. Follow instructions [here](https://github.com/scaffold-eth/se-2-challenges/blob/main/README.md#-contributing-guide-and-hints-to-create-new-challenges) to see how to use this set of files.
+# 🔮 Oracle Challenge
 
-You can use these files to help set up a new extension that matches the style and feel of [SpeedRunEthereum](https://speedrunethereum.com/).
+![readme-oracle](https://raw.githubusercontent.com/scaffold-eth/se-2-challenges/challenge-oracles/extension/packages/nextjs/public/hero.png)
 
-There are `// CHALLENGE-TODO:` comments placed throughout that provide instructions on key changes to adapt this template for use with a new challenge.
+🔗 Build your own decentralized oracle systems! In this challenge, you'll explore three fundamental oracle architectures that power the decentralized web: **Whitelist Oracle**, **Staking Oracle**, and **Optimistic Oracle**.
+
+🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: how do we trust data that comes from outside the blockchain?
+
+<details markdown='1'><summary>❓ Wondering what an oracle is? Read the overview here.</summary>
+
+Oracles are bridges between blockchains and the external world. They solve a fundamental problem: smart contracts can only access data that exists on the blockchain, but most real-world data (prices, weather, sports scores, etc.) exists off-chain.
+
+🤔 Why are oracles important?
+
+- **DeFi Protocols**: Need accurate price feeds for lending, trading, and liquidation
+- **Insurance**: Require real-world event verification (weather, flight delays)
+- **Gaming**: Need random numbers and external event outcomes
+- **Supply Chain**: Track real-world goods and events
+
+🔒 Why are oracles difficult?
+
+- **Trust**: How do we know the oracle is telling the truth?
+- **Centralization**: Single points of failure can compromise entire protocols
+- **Incentives**: How do we align oracle behavior with protocol needs?
+- **Latency**: Real-time data needs to be fresh and accurate
+
+👍 Now that you understand the basics, let's look at three different oracle systems!
+
+</details>
+
+---
+
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration and hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+
+🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
+
+- **Whitelist Oracle**: Simple and fast, but requires trust in a centralized authority
+- **Staking Oracle**: Decentralized with economic incentives, but more complex
+- **Optimistic Oracle**: Dispute-based with strong security guarantees, but higher latency
+
+📚 This challenge is inspired by real-world oracle systems like [Chainlink](https://chain.link/), [Pyth Network](https://www.pyth.network/), and [UMA Protocol](https://uma.xyz/).
+
+💬 Meet other builders working on this challenge and get help in the [Oracle Challenge Telegram](https://t.me/+AkmcMB3jC3A0NDcx)
+
+---
+
+## Checkpoint 0: 📦 Environment 📚
+
+🛠️ Before you begin, make sure you have the following tools installed:
+
+- [Node (>=20.18.3)](https://nodejs.org/en/download/)
+- Yarn ([v1](https://classic.yarnpkg.com/en/docs/install/) or [v2+](https://yarnpkg.com/getting-started/install))
+- [Git](https://git-scm.com/downloads)
+
+📥 Then download the challenge to your computer and install dependencies by running:
+
+```sh
+
+npx create-eth@1.0.2 -e scaffold-eth/se-2-challenges:challenge-oracles challenge-oracles
+
+cd challenge-oracles
+
+```
+
+> 💻 In the same terminal, start your local network (a blockchain emulator in your computer):
+
+```sh
+
+yarn chain
+
+```
+
+> 🛰️ In a second terminal window, deploy your contract (locally):
+
+```sh
+
+cd challenge-oracles
+
+yarn deploy
+
+```
+
+> 📱 In a third terminal window, start your frontend:
+
+```sh
+
+cd challenge-oracles
+
+yarn start
+
+```
+
+📱 Open http://localhost:3000 to see the app.
+
+> 👩‍💻 Rerun `yarn deploy` whenever you want to deploy new contracts to the frontend. If you haven't made any contract changes, you can run `yarn deploy --reset` for a completely fresh deploy.
+
+---
+
+## Checkpoint 1: 🏛️ Whitelist Oracle Overview
+
+🔍 Let's start with the simplest of the three oracle designs we'll cover: the Whitelist Oracle. This design uses a centralized authority to control which data sources can provide information, making it simple and fast but requiring trust.
+
+💰 The implementation we'll be looking at is a **price** oracle. Price oracles are one of the most common and critical types of oracles in DeFi, as they enable smart contracts to make decisions based on real-world asset prices. Our whitelist price oracle collects price reports from multiple trusted sources (instances of `SimpleOracle`) and returns their median value.
+
+🧭 Let's understand how this oracle system works. We'll examine both the basic building block (SimpleOracle) and how multiple simple oracles can be combined into a more robust system (WhitelistOracle).
+
+### 🔗 Simple Oracle - The Building Block
+
+🔍 Open the `packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol` file to examine the basic oracle functionality.
+
+#### 📖 Understanding the Code:
+
+🧩 The `SimpleOracle` contract is the fundamental building block of this oracle system:
+
+1. **`setPrice(uint256 _newPrice)`** - This function allows the contract owner to update the current price
+
+   * 🔄 Updates the `price` state variable with the new value
+
+   * ⏱️ Updates the `timestamp` to the current block timestamp
+
+   * 📣 Emits the `PriceUpdated` event with the new price
+
+2. **`getPrice()`** - This function returns both the current price and timestamp
+
+   * ↩️ Returns them as a tuple: `(price, timestamp)`
+
+#### 🤔 Key Insights:
+
+- **Single Source**: Each SimpleOracle represents one data source
+- **Trust Model**: Requires complete trust in whoever updates the price
+- **Limitations**: No consensus mechanism, no economic incentives
+
+### 🏛️ Whitelist Oracle - Aggregating Multiple Sources
+
+🔍 Open the `packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol` file to examine how multiple SimpleOracle contracts are aggregated.
+
+#### 📖 Understanding the Relationship:
+
+The `WhitelistOracle` contract **aggregates data from multiple SimpleOracle contracts**:
+
+```solidity
+
+SimpleOracle[] public oracles;  // Array of SimpleOracle contract instances
+
+```
+
+🏗️ This creates a **hierarchical oracle system**:
+
+- **Individual Level**: Each SimpleOracle contract is managed by a trusted (theoretically) data provider
+- **Aggregation Level**: The WhitelistOracle collects and processes data from all whitelisted SimpleOracle contracts
+
+#### 📖 Understanding the Code:
+
+1. **`addOracle(address oracle)`** - Adds a SimpleOracle contract to the whitelist
+
+   * ✔️ Validates the oracle address is not zero
+
+   * 🧪 Checks for duplicates in the existing list
+
+   * ➕ Adds the SimpleOracle to the `oracles` array
+
+   * 📣 Emits the `OracleAdded` event
+
+2. **`removeOracle(uint256 index)`** - Removes a SimpleOracle from the whitelist
+
+   * ✔️ Validates the index is within bounds
+
+   * ➖ Efficiently removes the oracle (swaps with last element)
+
+   * 📣 Emits the `OracleRemoved` event
+
+3. **`getPrice()`** - Aggregates prices from all whitelisted SimpleOracle contracts
+
+   * 🔁 Loops through each SimpleOracle in the whitelist
+
+   * 📡 Calls `getPrice()` on each SimpleOracle to get `(price, timestamp)`
+
+   * 🧹 Filters out stale prices (older than 10 seconds)
+
+   * ⛔️ Reverts if all prices are stale
+
+   * 🧮 Calculates the median of valid prices
+
+#### 🤔 Key Insights:
+
+- **Composition Pattern**: WhitelistOracle is composed of multiple SimpleOracle contracts
+- **Centralized Authority**: Only the owner can add/remove SimpleOracle contracts
+- **Consensus Mechanism**: Uses median calculation to resist outliers from individual SimpleOracle contracts
+- **Freshness Check**: Filters out stale data from any SimpleOracle
+- **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
+- **Use Cases**: Good for controlled environments where you trust the authority and data providers
+
+### 🔄 How They Work Together:
+
+1. **Data Flow**:
+
+```
+
+SimpleOracle A → setPrice(100) → getPrice() → (100, timestamp)
+
+SimpleOracle B → setPrice(102) → getPrice() → (102, timestamp)
+
+SimpleOracle C → setPrice(98)  → getPrice() → (98, timestamp)
+
+```
+
+2. **Aggregation**:
+
+```
+
+WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
+
+```
+
+3. **Benefits**:
+
+- **Redundancy**: If one SimpleOracle fails, others continue providing data
+
+- **Outlier Resistance**: Median calculation ignores extreme values
+
+- **Freshness**: Stale data from any SimpleOracle is filtered out
+
+### 🤔 Critical Thinking: Security Vulnerabilities
+
+- **Question**: How could this whitelist oracle design be exploited or taken advantage of? What are the main attack vectors?
+
+<details markdown='1'>
+
+<summary>💡 Click to see potential vulnerabilities</summary>
+
+1. 🔓 **Whitelist Authority Compromise**: If the owner's private key is compromised, an attacker could:
+
+   - Remove all legitimate oracles and add malicious ones
+
+   - Manipulate which data sources are trusted
+
+   - Add multiple oracles they control to skew the median
+
+2. 👥 **Collusion Among Whitelisted Providers**: If enough whitelisted oracle providers collude, they could:
+
+   - Report coordinated false prices to manipulate the median
+
+   - Extract value from protocols relying on the oracle
+
+3. 🔓 **Data Provider Compromise**: Individual SimpleOracle operators could:
+
+   - Be hacked or coerced to report false prices
+
+   - Sell their influence to manipulators
+
+💡 *Real-World Impact*: These vulnerabilities explain why protocols like [MakerDAO/Sky](https://github.com/sky-ecosystem/medianizer) eventually moved to more decentralized oracle systems as the stakes grew higher!
+
+</details>
+
+👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+
+1. **Change Prices**: Use the frontend to modify individual oracle prices
+
+2. **Add New Nodes**: Deploy and add new SimpleOracle contracts to the whitelist
+
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
+
+🧪 **Live Simulation**: Run the `yarn simulate:whitelist` command to see what a live version of this protocol might look like in action:
+
+```sh
+
+yarn simulate:whitelist
+
+```
+
+🤖 This will start automated bots that simulate real oracle behavior, showing you how the system would work in production with multiple active price feeds.
+
+### 🥅 Goals:
+
+- See how WhitelistOracle aggregates multiple nodes
+- Observe how median calculation provides consensus from multiple sources
+- Understand the benefits of aggregating multiple data sources
+- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+---
+
+## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
+
+🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
+
+🔍 Open the `packages/hardhat/contracts/01_Staking/StakingOracle.sol` file to examine the staking oracle implementation.
+
+#### 📖 Understanding the Code:
+
+🧩 The `StakingOracle` contract implements a decentralized economic incentive model:
+
+1. **`registerNode(uint256 initialPrice)`** - Allows users to register as oracle nodes
+
+   * ⚠️ Requires a minimum stake of 1 ETH
+
+   * 🧪 Checks that the node is not already registered
+
+   * 🏗️ Creates a new `OracleNode` struct with the provided data
+
+   * ➕ Adds the node to the `nodeAddresses` array
+
+   * 📣 Emits the `NodeRegistered` and `PriceReported` events
+
+2. **`reportPrice(uint256 price)`** - Allows registered nodes to report new prices
+
+   * 🧪 Checks that the caller is a registered node
+
+   * 🔍 Verifies the node has sufficient stake
+
+   * 🔄 Updates the node's last reported price and timestamp
+
+   * 📣 Emits the `PriceReported` event
+
+3. **`separateStaleNodes(address[] memory nodesToSeparate)`** - Categorizes nodes into fresh and stale based on data recency
+
+   * 📦 Takes an array of node addresses to categorize
+
+   * ⏱️ Checks each node's last reported timestamp against `STALE_DATA_WINDOW` (5 seconds)
+
+   * 📊 Separates nodes into two arrays: fresh (recent data) and stale (old data)
+
+   * 🧹 Returns trimmed arrays containing only the relevant addresses
+
+   * 🔍 Used internally by other functions to filter active vs inactive nodes
+
+4. **`claimReward()`** - Allows registered nodes to claim their ORA token rewards
+
+   * 🧪 Checks that the caller is a registered node
+
+   * 🔍 Calculates reward amount based on time elapsed since last claim
+
+   * 💰 For active nodes (sufficient stake): rewards based on time since last claim
+
+   * ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+
+   * 🎁 Mints ORA tokens as rewards (time-based, scaled by 10^18)
+
+   * 📣 Emits the `NodeRewarded` event
+
+5. **`slashNodes()`** - Allows anyone to slash nodes that haven't reported recently
+
+   * 🔎 Identifies nodes with stale data (older than 5 seconds)
+
+   * ✂️ Slashes each stale node by 1 ETH
+
+   * 🏅 Rewards the slasher with 10% of the slashed amount so we can guarantee bad nodes are always slashed
+
+   * 📣 Emits the `NodeSlashed` event for each slashed node
+
+6. **`getPrice()`** - Aggregates prices from all active nodes
+
+   * 📦 Collects prices from all active nodes
+
+   * 🧹 Filters out nodes with stale data
+
+   * 🧮 Calculates the median of all valid prices
+
+   * ⛔️ Reverts if no valid prices are available
+
+### 🤔 Key Insights:
+
+- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, where in contrast, good behavior rewards the nodes with ORA token
+- **Decentralized**: Anyone can participate by staking, no central authority needed
+- **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
+- **Freshness Enforcement**: Stale data is automatically filtered out
+- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
+
+🔄 Run `yarn deploy --reset` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+
+🧪 **Live Simulation**: Run the `yarn simulate:staking` command to watch a live simulation of staking oracle behavior with multiple nodes:
+
+```sh
+
+yarn simulate:staking
+
+```
+
+🤖 This will start automated bots that simulate honest and malicious node behavior, frequent and stale reports, and demonstrate how slashing and median aggregation impact the reported price. You can update the price variance and skip probability from the front-end as well.
+
+### 🥅 Goals:
+
+- Understand how economic incentives drive honest behavior
+- See how slashing mechanisms enforce data freshness
+- Observe the decentralized nature of the system
+- Recognize the trade-offs and risks associated with this type of oracle
+- Oracles that require staking include [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
+
+---
+
+## Checkpoint 3: 🧠 Optimistic Oracle Architecture
+
+🤿 Now let's dive into the most sophisticated of this challenge's three designs: the **Optimistic Oracle**. Unlike the previous two designs that focus on price data, this one will handle any type of binary (true/false) question about real-world events.
+
+🎯 **What makes it "optimistic"?** The system assumes proposals are correct unless someone disputes them. This creates a game-theoretic mechanism where economic incentives encourage honest behavior while providing strong security guarantees through dispute resolution.
+
+💡 **Key Innovation**: Instead of requiring constant active participation from multiple parties (like staking oracles), optimistic oracles only require intervention when something goes wrong. This makes them highly efficient for events that don't need frequent updates.
+
+🔍 **Real-World Applications**:
+- **Cross-chain bridges**: "Did transaction X happen on chain Y?"
+- **Insurance claims**: "Did flight ABC get delayed by more than 2 hours?"
+- **Prediction markets**: "Did candidate X win the election?"
+- **DeFi protocols**: "Did token X reach price Y on date Z?"
+
+🧭 Before coding, let's understand the flow at a glance.
+
+**Roles**:
+- **asserter**: posts an assertion + reward
+- **proposer**: posts an outcome + bond
+- **disputer**: challenges the proposal + bond
+- **decider**: resolves disputes and sets the winner
+
+**Windows**:
+- Assertion window: when proposals are allowed
+- Dispute window: short period after a proposal when disputes are allowed
+
+**Incentives**:
+- Reward + a bond refund flow to the winner; the loser's bond goes to the decider in disputes
+
+```mermaid
+
+sequenceDiagram
+  participant A as Asserter
+  participant P as Proposer
+  participant D as Disputer
+  participant C as Decider
+  participant O as OptimisticOracle
+  A->>O: assertEvent(description, startTime, endTime) + reward
+  Note over O: Wait until startTime
+  alt No proposal before endTime
+    A->>O: claimRefund(assertionId)
+    O-->>A: refund reward
+  else Proposal received
+    P->>O: proposeOutcome(assertionId, outcome) + bond
+    Note over O: Start dispute window
+    alt No dispute before deadline
+      O-->>P: Claim undisputed rewards -> reward + bond refund
+    else Dispute filed in window
+      D->>O: disputeOutcome(assertionId) + bond
+      C->>O: settleAssertion(assertionId, resolvedOutcome)
+      O-->>Winner: claimDisputedReward() -> reward + bond refund
+    end
+  end
+```
+
+🧩 The way this system works is someone creates an **assertion**;
+- Something that needs a boolean answer (`true` or `false`)
+- After a certain time
+- Before a specific deadline
+- With a reward
+
+🦗 If no one answers before the end of the assertion window, the asserter can claim a refund.
+
+💡 If someone knows the answer within the correct time then they **propose** the answer, posting a bond. This bond is a risk to them because if their answer is thought to be wrong by someone else then they might lose it. This keeps people economically tied to the **proposals** they make.
+
+⏳ Then if no one **disputes** the proposal before the dispute window is over then the proposal is considered to be true, and the proposer may claim the reward and their bond. The dispute window should give anyone ample time to submit a dispute.
+
+⚖️ If someone does **dispute** during the dispute window then they must also post a bond equal to the proposer's bond. This kicks the assertion out of any particular timeline and puts it in a state where it is waiting for a decision from the **decider**. Once the decider contract has **settled** the assertion, the winner can claim the reward and their posted bond. The decider gets the loser's bond.
+
+🧑‍⚖️ Now, as we mentioned earlier, this oracle has a role called the **decider**. For this example it is just a simple contract that anyone can call to settle disputes. One could imagine in a live oracle you would want something more robust such as a group of people who vote to settle disputes.
+
+🔗 Look at how [UMA](https://uma.xyz/) does this with their Optimistic Oracle (OO). **This contract is based UMA's OO design**.
+
+## Checkpoint 4: ⚡ Optimistic Oracle - Dispute Resolution
+
+👩‍💻 Now it's (finally) time to build! Unlike the previous checkpoints where you explored existing implementations, this section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
+
+🎯 **Your Mission**: Complete the missing function implementations in the `OptimisticOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
+
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run `yarn test` after implementing each function to verify your solution works correctly.
+
+🔍 Open the `packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol` file to implement the optimistic oracle functionality.
+
+### ✏️ Tasks:
+
+1. **Implement `assertEvent(string memory description, uint256 startTime, uint256 endTime)`**
+
+* 📣 This function allows users to assert that an event will have a true/false outcome
+
+* 💸 It should require that the reward (`msg.value`) is greater than 0 . If it is not then revert with `NotEnoughValue`
+
+* ⏱️ It should accept 0 for `startTime` and set it to `block.timestamp`
+
+* ⏳ It should accept 0 for `endTime` and default to `startTime + MINIMUM_ASSERTION_WINDOW`
+
+* 🕰️ It should check that the given `startTime` is less than the current time (`block.timestamp`) and revert with `InvalidTime` if it is not
+
+* 🧭 It should validate the time window given is >= `MINIMUM_ASSERTION_WINDOW`, otherwise revert with `InvalidTime`
+
+* 🏗️ It should create a new `EventAssertion` struct with relevant properties set - see if you can figure it out
+
+* 🗂️ That struct should be stored in the `assertions` mapping. You can use `nextAssertionId` but don't forget to increment it!
+
+* 📣 It should emit the `EventAsserted` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Asserting Events</summary>
+
+Here are more granular instructions on setting up the EventAssertion struct:
+- asserter should be `msg.sender`
+- reward should be `msg.value`
+- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
+- startTime = `startTime`
+- endTime = `endTime`
+- description = `description`
+- any remaining properties can be initialized with the default values (`false`, `address(0)`, etc.)
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+    function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
+        uint256 assertionId = nextAssertionId;
+        nextAssertionId++;
+        if (msg.value == 0) revert NotEnoughValue();
+
+        // Set default times if not provided
+        if (startTime == 0) {
+            startTime = block.timestamp;
+        }
+        if (endTime == 0) {
+            endTime = startTime + MINIMUM_ASSERTION_WINDOW;
+        }
+
+        if (startTime < block.timestamp) revert InvalidTime();
+        if (endTime < startTime + MINIMUM_ASSERTION_WINDOW) revert InvalidTime();
+
+        assertions[assertionId] = EventAssertion({
+            asserter: msg.sender,
+            proposer: address(0),
+            disputer: address(0),
+            proposedOutcome: false,
+            resolvedOutcome: false,
+            reward: msg.value,
+            bond: msg.value * 2,
+            startTime: startTime,
+            endTime: endTime,
+            claimed: false,
+            winner: address(0),
+            description: description
+        });
+
+        emit EventAsserted(assertionId, msg.sender, description, msg.value);
+        return assertionId;
+    }
+```
+
+</details>
+</details>
+
+---
+
+2. **Implement `proposeOutcome(uint256 assertionId, bool outcome)`**
+
+* 🗳️ This function allows users to propose the outcome for an asserted event
+
+* 🔍 It should check that the assertion exists and hasn't been proposed yet. Otherwise revert with `AssertionNotFound` or `AssertionProposed`
+
+* ⏱️ It should validate the timing constraints - it has to be after `startTime` but before the `endTime` or else revert with `InvalidTime`
+
+* 💸 It should enforce the correct bond amount is provided or revert with `NotEnoughValue`
+
+* ✍️ It should update the assertion with the proposal
+
+* ⏳ It should set the `endTime` to `block.timestamp + MINIMUM_DISPUTE_WINDOW`
+
+* 📣 It should emit `OutcomeProposed`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Proposing Outcomes</summary>
+
+You want to set these properties on the assertion:
+- proposer should be `msg.sender`
+- proposedOutcome should be `outcome`
+- endTime should be updated to `block.timestamp + MINIMUM_DISPUTE_WINDOW`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+    function proposeOutcome(uint256 assertionId, bool outcome) external payable {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.asserter == address(0)) revert AssertionNotFound();
+        if (assertion.proposer != address(0)) revert AssertionProposed();
+        if (block.timestamp < assertion.startTime) revert InvalidTime();
+        if (block.timestamp > assertion.endTime) revert InvalidTime();
+        if (msg.value != assertion.bond) revert NotEnoughValue();
+
+        assertion.proposer = msg.sender;
+        assertion.proposedOutcome = outcome;
+        assertion.endTime = block.timestamp + MINIMUM_DISPUTE_WINDOW;
+
+        emit OutcomeProposed(assertionId, msg.sender, outcome);
+    }
+```
+
+</details>
+</details>
+
+---
+
+3. **Implement `disputeOutcome(uint256 assertionId)`**
+
+* ⚖️ This function allows users to dispute a proposed outcome
+
+* 🔍 It should check that a proposal exists and hasn't been disputed yet, if not then revert with `NotProposedAssertion` or `ProposalDisputed`
+
+* ⏳ It should validate the timing constraints to make sure the `endTime` has not been passed or else it should revert with `InvalidTime`
+
+* 💸 It should require the correct bond amount (as set on the assertion)
+
+* 📝 It should record the disputer on the assertion struct
+
+<details markdown='1'>
+
+<summary>💡 Hint: Disputing Outcomes</summary>
+
+The bond amount should be the bond set on the assertion. The same amount that the proposer paid.
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+    function disputeOutcome(uint256 assertionId) external payable {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer != address(0)) revert ProposalDisputed();
+        if (block.timestamp > assertion.endTime) revert InvalidTime();
+        if (msg.value != assertion.bond) revert NotEnoughValue();
+
+        assertion.disputer = msg.sender;
+
+        emit OutcomeDisputed(assertionId, msg.sender);
+    }
+```
+
+</details>
+</details>
+
+---
+
+4. **Implement `claimUndisputedReward(uint256 assertionId)`**
+
+We need to allow the proposer to claim the reward when no dispute occurs before the deadline.
+
+* 🧩 A proposal must exist (revert with `NotProposedAssertion`)
+
+* 🚫 No dispute must have been raised (revert with `ProposalDisputed`)
+
+* ⏰ Current time must be after the dispute `endTime` (revert with `InvalidTime`)
+
+* 🔒 Not already claimed (revert with `AlreadyClaimed`)
+
+* 💸 Transfer `reward + proposer bond` to the proposer
+
+* 📣 Emit `RewardClaimed`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Claiming Undisputed Rewards</summary>
+
+- Validate the assertion has a proposer and no disputer
+- Check the deadline has passed
+- Mark as claimed first
+- Set `resolvedOutcome` to the proposed outcome and `winner` to the proposer
+- Compute `totalReward = reward + bond`
+- Use safe ETH send with revert on failure
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+    function claimUndisputedReward(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer != address(0)) revert ProposalDisputed();
+        if (block.timestamp <= assertion.endTime) revert InvalidTime();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+        assertion.resolvedOutcome = assertion.proposedOutcome;
+        assertion.winner = assertion.proposer;
+
+        uint256 totalReward = (assertion.reward + assertion.bond);
+
+        (bool winnerSuccess, ) = payable(assertion.proposer).call{value: totalReward}("");
+        if (!winnerSuccess) revert TransferFailed();
+
+        emit RewardClaimed(assertionId, assertion.proposer, totalReward);
+    }
+```
+
+</details>
+</details>
+
+---
+
+5. **Implement `claimDisputedReward(uint256 assertionId)`**
+
+Very similar to the last function except this one allows the winner of the dispute to claim *only after the Decider has resolved the dispute*.
+
+* 🧩 A proposal must exist (revert with `NotProposedAssertion`)
+
+* ⚖️ A dispute must exist (revert with `NotDisputedAssertion`)
+
+* 🧑‍⚖️ The decider must have set a winner (revert with `AwaitingDecider`)
+
+* 🔒 Not already claimed (revert with `AlreadyClaimed`)
+
+* 📝 Set the `claimed` property on the assertion to `true`
+
+* 💸 Transfer the loser's bond to the decider, then send the reward and bond refund to the winner
+
+* 📣 Emit `RewardClaimed`
+
+<details markdown="1">
+<summary>💡 Hint: Claiming Disputed Rewards</summary>
+
+- Validate assertion state: proposed, disputed, winner set, not yet claimed
+- Mark as claimed *before* paying to avoid re-entrancy
+- Pay the losers bond to the `decider`
+- Winner receives `(reward + bond)`
+- Use safe ETH sending pattern with revert on failure (`TransferFailed`)
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+```solidity
+    function claimDisputedReward(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer == address(0)) revert NotDisputedAssertion();
+        if (assertion.winner == address(0)) revert AwaitingDecider();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+
+        (bool deciderSuccess, ) = payable(decider).call{value: assertion.bond}("");
+        if (!deciderSuccess) revert TransferFailed();
+        
+        uint256 totalReward = assertion.reward + assertion.bond;
+
+        (bool winnerSuccess, ) = payable(assertion.winner).call{value: totalReward}("");
+        if (!winnerSuccess) revert TransferFailed();
+
+        emit RewardClaimed(assertionId, assertion.winner, totalReward);
+    }
+```
+
+</details>
+</details>
+
+---
+
+6. **Implement `claimRefund(uint256 assertionId)`**
+
+This function enables the asserter to get a refund of their posted reward when no proposal arrives by the deadline.
+
+* 🚫 No proposer exists (revert with `AssertionProposed`)
+
+* ⏰ After assertion endTime ( revert with `InvalidTime`)
+
+* 🔒 Not already claimed (revert with `AlreadyClaimed`)
+
+* 🛡️ Mark the assertion as claimed to avoid re-entrancy
+
+* 💸 Refund the reward to the asserter
+
+* ✅ Check for successful transfer (revert with `TransferFailed`)
+
+* 📣 Emit `RefundClaimed`
+
+<details markdown="1">
+<summary>💡 Hint: No Proposal Refund</summary>
+
+- Validate: no proposal, now > endTime, not claimed
+- Mark as claimed then refund
+- Emit refund event
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+```solidity
+    function claimRefund(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer != address(0)) revert AssertionProposed();
+        if (block.timestamp <= assertion.endTime) revert InvalidTime();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+
+        (bool refundSuccess, ) = payable(assertion.asserter).call{value: assertion.reward}("");
+        if (!refundSuccess) revert TransferFailed();
+        emit RefundClaimed(assertionId, assertion.asserter, assertion.reward);
+    }
+```
+
+</details>
+</details>
+
+---
+
+7. **Implement `settleAssertion(uint256 assertionId, bool resolvedOutcome)`**
+
+This is the method that the decider will call to settle whether the proposer or disputer are correct.
+
+It should be:
+
+* 🧑‍⚖️ Only callable by the `decider` contract
+
+* ⚖️ The assertion must be both proposed and disputed (or revert with `NotProposedAssertion` or `NotDisputedAssertion`)
+
+* 🔒 We need to make sure the winner has not already been set (or revert with `AlreadySettled`)
+
+* ✍️ Now we should set the resolvedOutcome property
+
+* 🏁 Winner = proposer if proposedOutcome == resolvedOutcome, else disputer
+
+* 📣 Emit `AssertionSettled`
+
+<details markdown="1">
+<summary>💡 Hint: Decider Sets Winner</summary>
+
+We just need the decider to use the remaining unused properties to establish which party is correct, hence, which party gets to claim the reward.
+
+Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
+
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+```solidity
+    function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer == address(0)) revert NotDisputedAssertion();
+        if (assertion.winner != address(0)) revert AlreadySettled();
+
+        assertion.resolvedOutcome = resolvedOutcome;
+        
+        assertion.winner = (resolvedOutcome == assertion.proposedOutcome)
+            ? assertion.proposer
+            : assertion.disputer;
+
+        emit AssertionSettled(assertionId, resolvedOutcome, assertion.winner);
+    }
+```
+
+</details>
+</details>
+
+8. **Implement `getState(uint256 assertionId)`**
+
+This function returns a simple state machine view for UI/testing.
+
+The states are defined as follows in an enum at the top of the contract.
+**States**: Invalid, Asserted, Proposed, Disputed, Settled, Expired
+
+Think through how you can check which properties have been set to derive the current state of the assertion.
+
+For instance, if the `asserter` property is empty then you would return an `Invalid` state.
+
+Try to deduce the rest without any help.
+
+<details markdown="1">
+<summary>💡 Hint: Derive State</summary>
+
+- `Invalid` if no assertion
+- Winner set => `Settled`
+- Disputer set => `Disputed`
+- No proposer: if past endTime => `Expired`, else `Asserted`
+- Proposer present: if past endTime => `Settled`, else `Proposed`
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+```solidity
+    function getState(uint256 assertionId) external view returns (State) {
+        EventAssertion storage a = assertions[assertionId];
+
+        if (a.asserter == address(0)) return State.Invalid;
+        
+        // If there's a winner, it's settled
+        if (a.winner != address(0)) return State.Settled;
+        
+        // If there's a dispute, it's disputed
+        if (a.disputer != address(0)) return State.Disputed;
+        
+        // If no proposal yet, check if deadline has passed
+        if (a.proposer == address(0)) {
+            if (block.timestamp > a.endTime) return State.Expired;
+            return State.Asserted;
+        }
+        
+        // If no dispute and deadline passed, it's settled (can be claimed)
+        if (block.timestamp > a.endTime) return State.Settled;
+        
+        // Otherwise it's proposed
+        return State.Proposed;
+    }
+```
+
+</details>
+</details>
+
+---
+
+9. **Implement `getResolution(uint256 assertionId)`**
+
+This function will help everyone know the exact outcome of the assertion.
+
+* 🔎 It should revert with `AssertionNotFound` if it doesn't exist
+
+* ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the `proposedOutcome` (if the time isn't over then revert with `InvalidTime`)
+
+* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the `winner` has been set by the decider (or else revert with `AwaitingDecider`)
+
+<details markdown="1">
+<summary>💡 Hint: Read Outcome Carefully</summary>
+
+- Handle undisputed vs disputed paths
+- Enforce timing and readiness conditions with appropriate errors
+
+The important thing here is that it reverts if it is not settled and if it has been then it returns the correct outcome, whether that be a proposal that was undisputed or a disputed proposal that was then settled by the decider.
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+```solidity
+    function getResolution(uint256 assertionId) external view returns (bool) {
+        EventAssertion storage a = assertions[assertionId];
+        if (a.asserter == address(0)) revert AssertionNotFound();
+
+        if (a.disputer == address(0)) {
+            if (block.timestamp <= a.endTime) revert InvalidTime();
+            return a.proposedOutcome;
+        } else {
+            if (a.winner == address(0)) revert AwaitingDecider();
+            return a.resolvedOutcome;
+        }
+    }
+```
+
+</details>
+</details>
+
+---
+
+✅ Make sure you have implemented everything correctly by running tests with `yarn test`. You can dig into any errors by viewing the tests at `packages/hardhat/test/OptimisticOracle.ts`.
+
+🔄 Run `yarn deploy --reset` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+
+🧪 **Live Simulation**: Run the `yarn simulate:optimistic` command to see the full optimistic oracle lifecycle in action:
+
+```sh
+
+yarn simulate:optimistic
+
+```
+
+🤖 This will start automated bots that create assertions, propose outcomes, and dispute proposals, so you can observe rewards, bonds, fees, and timing windows in a realistic flow. It is up to you to settle disputes!
+
+### 🥅 Goals:
+
+- Users can assert events with descriptions and time windows
+- Users can propose outcomes for asserted events
+- Users can dispute proposed outcomes
+- Undisputed assertions can be claimed after the dispute window
+- The system correctly handles timing constraints
+- Bond amounts are properly validated
+---
+
+## Checkpoint 5: 🔍 Oracle Comparison & Trade-offs
+
+🧠 Now let's analyze the strengths and weaknesses of each oracle design.
+
+### 📊 Comparison Table:
+| Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
+|--------|------------------|----------------|-------------------|
+| **Speed** | Fast | Medium | Slow |
+| **Security** | Low (trusted authority) | Medium (economic incentives) | High (dispute resolution) |
+| **Decentralization** | Low | High | Depends on Decider Implementation |
+| **Cost** | Low | Medium | High |
+| **Complexity** | Simple | Medium | Complex |
+
+### 🤔 Key Trade-offs:
+
+1. **Whitelist Oracle:**
+
+- ✅ Simple and fast
+
+- ✅ Low gas costs
+
+- ❌ Requires trust in centralized authority
+
+- ❌ Single point of failure
+
+2. **Staking Oracle:**
+
+- ✅ Decentralized with economic incentives
+
+- ✅ Self-correcting through slashing
+
+- ❌ More complex to implement
+
+- ❌ Higher gas costs
+
+3. **Optimistic Oracle:**
+
+- ✅ Economic security
+
+- ✅ Can be used for any type of data (not just prices)
+
+- ✴️ Decider role is the weakest link and should be carefully implemented though it is up to the consuming application whether it wants to wait for a resolution or post another assertion and hope a proposal passes without dispute
+
+- ❌ Higher latency
+
+- ❌ More complex
+
+### 🎯 Understanding the "Why":
+
+Each oracle design solves different problems:
+
+- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount
+
+---
+
+## Checkpoint 6: 💾 Deploy your contracts! 🛰
+
+🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
+
+📡 Edit the `defaultNetwork` to [your choice of public EVM networks](https://ethereum.org/en/developers/docs/networks/) in `packages/hardhat/hardhat.config.ts` (e.g., `sepolia`).
+
+🔐 You will need to generate a **deployer address** using `yarn generate`. This creates a mnemonic and saves it locally.
+
+👩‍🚀 Use `yarn account` to view your deployer account balances.
+
+⛽️ You will need to send ETH to your **deployer address** with your wallet, or get it from a public faucet of your chosen network.
+
+🚀 Run `yarn deploy` to deploy your optimistic oracle contracts to a public network (selected in `hardhat.config.ts`)
+
+> 💬 Hint: You can set the `defaultNetwork` in `hardhat.config.ts` to `sepolia` **OR** you can `yarn deploy --network sepolia`.
+
+---
+
+## Checkpoint 7: 🚢 Ship your frontend! 🚁
+
+✏️ Edit your frontend config in `packages/nextjs/scaffold.config.ts` to change the `targetNetwork` to `chains.sepolia` (or your chosen deployed network).
+
+💻 View your frontend at http://localhost:3000 and verify you see the correct network.
+
+📡 When you are ready to ship the frontend app...
+
+📦 Run `yarn vercel` to package up your frontend and deploy.
+
+> You might need to log in to Vercel first by running `yarn vercel:login`. Once you log in (email, GitHub, etc), the default options should work.
+
+> If you want to redeploy to the same production URL you can run `yarn vercel --prod`. If you omit the `--prod` flag it will deploy it to a preview/test URL.
+
+> Follow the steps to deploy to Vercel. It'll give you a public URL.
+
+> 🦊 Since we have deployed to a public testnet, you will now need to connect using a wallet you own or use a burner wallet. By default 🔥 `burner wallets` are only available on `hardhat` . You can enable them on every chain by setting `onlyLocalBurnerWallet: false` in your frontend config (`scaffold.config.ts` in `packages/nextjs/`)
+
+#### Configuration of Third-Party Services for Production-Grade Apps.
+
+By default, 🏗 Scaffold-ETH 2 provides predefined API keys for popular services such as Alchemy and Etherscan. This allows you to begin developing and testing your applications more easily, avoiding the need to register for these services.
+
+This is great to complete your **SpeedRunEthereum**.
+
+For production-grade applications, it's recommended to obtain your own API keys (to prevent rate limiting issues). You can configure these at:
+
+- 🔷`ALCHEMY_API_KEY` variable in `packages/hardhat/.env` and `packages/nextjs/.env.local`. You can create API keys from the [Alchemy dashboard](https://dashboard.alchemy.com/).
+- 📃`ETHERSCAN_API_KEY` variable in `packages/hardhat/.env` with your generated API key. You can get your key [here](https://etherscan.io/myapikey).
+
+> 💬 Hint: It's recommended to store env's for nextjs in Vercel/system env config for live apps and use .env.local for local testing.
+
+---
+
+## Checkpoint 8: 📜 Contract Verification
+
+📝 Run the `yarn verify --network your_network` command to verify your optimistic oracle contracts on Etherscan 🛰.
+
+👉 Search your deployed optimistic oracle contract addresses on [Sepolia Etherscan](https://sepolia.etherscan.io/) to get the URL you submit to 🏃‍♀️[SpeedRunEthereum.com](https://speedrunethereum.com).
+
+---
+
+> 🎉 Congratulations on completing the Oracle Challenge! You've gained valuable insights into the mechanics of decentralized oracle systems and their critical role in the blockchain ecosystem. You've explored different oracle architectures and built a sophisticated optimistic oracle system from scratch.
+
+> 🏃 Head to your next challenge [here](https://speedrunethereum.com).
+
+> 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
+
+## Checkpoint 9: More On Oracles
+
+Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
+
+🧭 The three oracle designs you've implemented represent the main architectural patterns used in production systems:
+
+- **Whitelist Oracles** are used by protocols that prioritize speed and simplicity over decentralization
+- **Staking Oracles** power most DeFi applications where economic incentives help enforce honest behavior
+- **Optimistic Oracles** are extremely flexible and can be used for anything from world events to cross-chain transfer verification systems
+
+🚀 As you continue your blockchain development journey, you'll encounter many variations and combinations of these patterns. Understanding the fundamental trade-offs will help you choose the right oracle design for your specific use case.
+
+🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 49b9e6a6..d7605e57 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -1,43 +1,66 @@
 export const skipQuickStart = true;
-// CHALLENGE-TODO: Update the readme to reflect your challenge. In the very end you will need a non-template
-// README.md file in the extension root so it is recommended to copy the template in a markdown file and then
-// update extraContents after confirming the template is correct.
-// include following code at the start of checkpoint 0 of the README.md file
-// *Start of the code block*
-// \`\`\`sh
-// npx create-eth@<version> -e {challengeName} {challengeName}
-// cd {challengeName}
-// \`\`\`
 
-// > in the same terminal, start your local network (a blockchain emulator in your computer):
-// *End of the code block*
+export const extraContents = `# 🔮 Oracles
 
-export const extraContents = `# {challengeEmoji} {challengeTitle}
+![readme-oracle](https://raw.githubusercontent.com/scaffold-eth/se-2-challenges/challenge-oracles/extension/packages/nextjs/public/hero.png)
 
-A {challengeDescription}.
+🔗 Build your own decentralized oracle systems! In this challenge, you'll explore three fundamental oracle architectures that power the decentralized web: **Whitelist Oracle**, **Staking Oracle**, and **Optimistic Oracle**.
 
-🌟 The final deliverable is an app that {challengeDeliverable}.
-Deploy your contracts to a testnet then build and upload your app to a public web server. Submit the url on [SpeedRunEthereum.com](https://speedrunethereum.com)!
+🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: how do we trust data that comes from outside the blockchain?
 
-💬 Meet other builders working on this challenge and get help in the {challengeTelegramLink}
+<details markdown='1'><summary>❓ Wondering what an oracle is? Read the overview here.</summary>
+
+Oracles are bridges between blockchains and the external world. They solve a fundamental problem: smart contracts can only access data that exists on the blockchain, but most real-world data (prices, weather, sports scores, etc.) exists off-chain.
+
+🤔 Why are oracles important?
+
+- **DeFi Protocols**: Need accurate price feeds for lending, trading, and liquidation
+- **Insurance**: Require real-world event verification (weather, flight delays)
+- **Gaming**: Need random numbers and external event outcomes
+- **Supply Chain**: Track real-world goods and events
+
+🔒 Why are oracles difficult?
+
+- **Trust**: How do we know the oracle is telling the truth?
+- **Centralization**: Single points of failure can compromise entire protocols
+- **Incentives**: How do we align oracle behavior with protocol needs?
+- **Latency**: Real-time data needs to be fresh and accurate
+
+👍 Now that you understand the basics, let's look at three different oracle systems!
+
+</details>
+
+---
+
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration and hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+
+🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
+
+- **Whitelist Oracle**: Simple and fast, but requires trust in a centralized authority
+- **Staking Oracle**: Decentralized with economic incentives, but more complex
+- **Optimistic Oracle**: Dispute-based with strong security guarantees, but higher latency
+
+📚 This challenge is inspired by real-world oracle systems like [Chainlink](https://chain.link/), [Pyth Network](https://www.pyth.network/), and [UMA Protocol](https://uma.xyz/).
+
+💬 Meet other builders working on this challenge and get help in the [Oracle Challenge Telegram](https://t.me/+AkmcMB3jC3A0NDcx)
 
 ---
 
 ## Checkpoint 0: 📦 Environment 📚
 
-> Start your local network (a blockchain emulator in your computer):
+> 💻 Start your local network (a blockchain emulator in your computer):
 
 \`\`\`sh
 yarn chain
 \`\`\`
 
-> in a second terminal window, 🛰 deploy your contract (locally):
+> 🛰️ In a second terminal window, deploy your contract (locally):
 
 \`\`\`sh
 yarn deploy
 \`\`\`
 
-> in a third terminal window, start your 📱 frontend:
+> 📱 In a third terminal window, start your frontend:
 
 \`\`\`sh
 yarn start
@@ -57,23 +80,1024 @@ yarn start
 
 ---
 
-_Other commonly used Checkpoints (check one Challenge and adapt the texts for your own):_
+## Checkpoint 1: 🏛️ Whitelist Oracle Overview
+
+🔍 Let's start with the simplest of the three oracle designs we'll cover: the Whitelist Oracle. This design uses a centralized authority to control which data sources can provide information, making it simple and fast but requiring trust.
+
+💰 The implementation we'll be looking at is a **price** oracle. Price oracles are one of the most common and critical types of oracles in DeFi, as they enable smart contracts to make decisions based on real-world asset prices. Our whitelist price oracle collects price reports from multiple trusted sources (instances of \`SimpleOracle\`) and returns their median value.
+
+🧭 Let's understand how this oracle system works. We'll examine both the basic building block (SimpleOracle) and how multiple simple oracles can be combined into a more robust system (WhitelistOracle).
+
+### 🔗 Simple Oracle - The Building Block
+
+🔍 Open the \`packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol\` file to examine the basic oracle functionality.
+
+#### 📖 Understanding the Code:
+
+🧩 The \`SimpleOracle\` contract is the fundamental building block of this oracle system:
+
+1. **\`setPrice(uint256 _newPrice)\`** - This function allows the contract owner to update the current price
+
+   * 🔄 Updates the \`price\` state variable with the new value
+
+   * ⏱️ Updates the \`timestamp\` to the current block timestamp
+
+   * 📣 Emits the \`PriceUpdated\` event with the new price
+
+2. **\`getPrice()\`** - This function returns both the current price and timestamp
+
+   * ↩️ Returns them as a tuple: \`(price, timestamp)\`
+
+#### 🤔 Key Insights:
+
+- **Single Source**: Each SimpleOracle represents one data source
+- **Trust Model**: Requires complete trust in whoever updates the price
+- **Limitations**: No consensus mechanism, no economic incentives
+
+### 🏛️ Whitelist Oracle - Aggregating Multiple Sources
+
+🔍 Open the \`packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol\` file to examine how multiple SimpleOracle contracts are aggregated.
+
+#### 📖 Understanding the Relationship:
+
+The \`WhitelistOracle\` contract **aggregates data from multiple SimpleOracle contracts**:
+
+\`\`\`solidity
+
+SimpleOracle[] public oracles;  // Array of SimpleOracle contract instances
+
+\`\`\`
+
+🏗️ This creates a **hierarchical oracle system**:
+
+- **Individual Level**: Each SimpleOracle contract is managed by a trusted (theoretically) data provider
+- **Aggregation Level**: The WhitelistOracle collects and processes data from all whitelisted SimpleOracle contracts
+
+#### 📖 Understanding the Code:
+
+1. **\`addOracle(address oracle)\`** - Adds a SimpleOracle contract to the whitelist
+
+   * ✔️ Validates the oracle address is not zero
+
+   * 🧪 Checks for duplicates in the existing list
+
+   * ➕ Adds the SimpleOracle to the \`oracles\` array
+
+   * 📣 Emits the \`OracleAdded\` event
+
+2. **\`removeOracle(uint256 index)\`** - Removes a SimpleOracle from the whitelist
+
+   * ✔️ Validates the index is within bounds
+
+   * ➖ Efficiently removes the oracle (swaps with last element)
+
+   * 📣 Emits the \`OracleRemoved\` event
+
+3. **\`getPrice()\`** - Aggregates prices from all whitelisted SimpleOracle contracts
+
+   * 🔁 Loops through each SimpleOracle in the whitelist
+
+   * 📡 Calls \`getPrice()\` on each SimpleOracle to get \`(price, timestamp)\`
+
+   * 🧹 Filters out stale prices (older than 10 seconds)
+
+   * ⛔️ Reverts if all prices are stale
+
+   * 🧮 Calculates the median of valid prices
+
+#### 🤔 Key Insights:
+
+- **Composition Pattern**: WhitelistOracle is composed of multiple SimpleOracle contracts
+- **Centralized Authority**: Only the owner can add/remove SimpleOracle contracts
+- **Consensus Mechanism**: Uses median calculation to resist outliers from individual SimpleOracle contracts
+- **Freshness Check**: Filters out stale data from any SimpleOracle
+- **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
+- **Use Cases**: Good for controlled environments where you trust the authority and data providers
+
+### 🔄 How They Work Together:
+
+1. **Data Flow**:
+
+\`\`\`
+
+SimpleOracle A → setPrice(100) → getPrice() → (100, timestamp)
+
+SimpleOracle B → setPrice(102) → getPrice() → (102, timestamp)
+
+SimpleOracle C → setPrice(98)  → getPrice() → (98, timestamp)
+
+\`\`\`
+
+2. **Aggregation**:
+
+\`\`\`
+
+WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
+
+\`\`\`
+
+3. **Benefits**:
+
+- **Redundancy**: If one SimpleOracle fails, others continue providing data
+
+- **Outlier Resistance**: Median calculation ignores extreme values
+
+- **Freshness**: Stale data from any SimpleOracle is filtered out
+
+### 🤔 Critical Thinking: Security Vulnerabilities
+
+- **Question**: How could this whitelist oracle design be exploited or taken advantage of? What are the main attack vectors?
+
+<details markdown='1'>
+
+<summary>💡 Click to see potential vulnerabilities</summary>
+
+1. 🔓 **Whitelist Authority Compromise**: If the owner's private key is compromised, an attacker could:
+
+   - Remove all legitimate oracles and add malicious ones
+
+   - Manipulate which data sources are trusted
+
+   - Add multiple oracles they control to skew the median
+
+2. 👥 **Collusion Among Whitelisted Providers**: If enough whitelisted oracle providers collude, they could:
+
+   - Report coordinated false prices to manipulate the median
+
+   - Extract value from protocols relying on the oracle
+
+3. 🔓 **Data Provider Compromise**: Individual SimpleOracle operators could:
+
+   - Be hacked or coerced to report false prices
+
+   - Sell their influence to manipulators
+
+💡 *Real-World Impact*: These vulnerabilities explain why protocols like [MakerDAO/Sky](https://github.com/sky-ecosystem/medianizer) eventually moved to more decentralized oracle systems as the stakes grew higher!
+
+</details>
+
+👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+
+1. **Change Prices**: Use the frontend to modify individual oracle prices
+
+2. **Add New Nodes**: Deploy and add new SimpleOracle contracts to the whitelist
+
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
+
+🧪 **Live Simulation**: Run the \`yarn simulate:whitelist\` command to see what a live version of this protocol might look like in action:
+
+\`\`\`sh
+
+yarn simulate:whitelist
+
+\`\`\`
+
+🤖 This will start automated bots that simulate real oracle behavior, showing you how the system would work in production with multiple active price feeds.
+
+### 🥅 Goals:
+
+- See how WhitelistOracle aggregates multiple nodes
+- Observe how median calculation provides consensus from multiple sources
+- Understand the benefits of aggregating multiple data sources
+- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+---
+
+## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
+
+🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
+
+🔍 Open the \`packages/hardhat/contracts/01_Staking/StakingOracle.sol\` file to examine the staking oracle implementation.
+
+#### 📖 Understanding the Code:
+
+🧩 The \`StakingOracle\` contract implements a decentralized economic incentive model:
+
+1. **\`registerNode(uint256 initialPrice)\`** - Allows users to register as oracle nodes
+
+   * ⚠️ Requires a minimum stake of 1 ETH
+
+   * 🧪 Checks that the node is not already registered
+
+   * 🏗️ Creates a new \`OracleNode\` struct with the provided data
+
+   * ➕ Adds the node to the \`nodeAddresses\` array
+
+   * 📣 Emits the \`NodeRegistered\` and \`PriceReported\` events
+
+2. **\`reportPrice(uint256 price)\`** - Allows registered nodes to report new prices
+
+   * 🧪 Checks that the caller is a registered node
+
+   * 🔍 Verifies the node has sufficient stake
+
+   * 🔄 Updates the node's last reported price and timestamp
+
+   * 📣 Emits the \`PriceReported\` event
+
+3. **\`separateStaleNodes(address[] memory nodesToSeparate)\`** - Categorizes nodes into fresh and stale based on data recency
+
+   * 📦 Takes an array of node addresses to categorize
+
+   * ⏱️ Checks each node's last reported timestamp against \`STALE_DATA_WINDOW\` (5 seconds)
+
+   * 📊 Separates nodes into two arrays: fresh (recent data) and stale (old data)
+
+   * 🧹 Returns trimmed arrays containing only the relevant addresses
+
+   * 🔍 Used internally by other functions to filter active vs inactive nodes
+
+4. **\`claimReward()\`** - Allows registered nodes to claim their ORA token rewards
+
+   * 🧪 Checks that the caller is a registered node
+
+   * 🔍 Calculates reward amount based on time elapsed since last claim
+
+   * 💰 For active nodes (sufficient stake): rewards based on time since last claim
+
+   * ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+
+   * 🎁 Mints ORA tokens as rewards (time-based, scaled by 10^18)
+
+   * 📣 Emits the \`NodeRewarded\` event
+
+5. **\`slashNodes()\`** - Allows anyone to slash nodes that haven't reported recently
+
+   * 🔎 Identifies nodes with stale data (older than 5 seconds)
+
+   * ✂️ Slashes each stale node by 1 ETH
+
+   * 🏅 Rewards the slasher with 10% of the slashed amount so we can guarantee bad nodes are always slashed
+
+   * 📣 Emits the \`NodeSlashed\` event for each slashed node
+
+6. **\`getPrice()\`** - Aggregates prices from all active nodes
+
+   * 📦 Collects prices from all active nodes
+
+   * 🧹 Filters out nodes with stale data
+
+   * 🧮 Calculates the median of all valid prices
+
+   * ⛔️ Reverts if no valid prices are available
+
+### 🤔 Key Insights:
+
+- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, where in contrast, good behavior rewards the nodes with ORA token
+- **Decentralized**: Anyone can participate by staking, no central authority needed
+- **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
+- **Freshness Enforcement**: Stale data is automatically filtered out
+- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
+
+🔄 Run \`yarn deploy --reset\` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+
+🧪 **Live Simulation**: Run the \`yarn simulate:staking\` command to watch a live simulation of staking oracle behavior with multiple nodes:
+
+\`\`\`sh
+
+yarn simulate:staking
+
+\`\`\`
+
+🤖 This will start automated bots that simulate honest and malicious node behavior, frequent and stale reports, and demonstrate how slashing and median aggregation impact the reported price. You can update the price variance and skip probability from the front-end as well.
+
+### 🥅 Goals:
+
+- Understand how economic incentives drive honest behavior
+- See how slashing mechanisms enforce data freshness
+- Observe the decentralized nature of the system
+- Recognize the trade-offs and risks associated with this type of oracle
+- Oracles that require staking include [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
+
+---
+
+## Checkpoint 3: 🧠 Optimistic Oracle Architecture
+
+🤿 Now let's dive into the most sophisticated of this challenge's three designs: the **Optimistic Oracle**. Unlike the previous two designs that focus on price data, this one will handle any type of binary (true/false) question about real-world events.
+
+🎯 **What makes it "optimistic"?** The system assumes proposals are correct unless someone disputes them. This creates a game-theoretic mechanism where economic incentives encourage honest behavior while providing strong security guarantees through dispute resolution.
 
-## Checkpoint {num}: 💾 Deploy your contract! 🛰
+💡 **Key Innovation**: Instead of requiring constant active participation from multiple parties (like staking oracles), optimistic oracles only require intervention when something goes wrong. This makes them highly efficient for events that don't need frequent updates.
 
-## Checkpoint {num}: 🚢 Ship your frontend! 🚁
+🔍 **Real-World Applications**:
+- **Cross-chain bridges**: "Did transaction X happen on chain Y?"
+- **Insurance claims**: "Did flight ABC get delayed by more than 2 hours?"
+- **Prediction markets**: "Did candidate X win the election?"
+- **DeFi protocols**: "Did token X reach price Y on date Z?"
 
-## Checkpoint {num}: 📜 Contract Verification
+🧭 Before coding, let's understand the flow at a glance.
+
+**Roles**:
+- **asserter**: posts an assertion + reward
+- **proposer**: posts an outcome + bond
+- **disputer**: challenges the proposal + bond
+- **decider**: resolves disputes and sets the winner
+
+**Windows**:
+- Assertion window: when proposals are allowed
+- Dispute window: short period after a proposal when disputes are allowed
+
+**Incentives**:
+- Reward + a bond refund flow to the winner; the loser's bond goes to the decider in disputes
+
+\`\`\`mermaid
+
+sequenceDiagram
+  participant A as Asserter
+  participant P as Proposer
+  participant D as Disputer
+  participant C as Decider
+  participant O as OptimisticOracle
+  A->>O: assertEvent(description, startTime, endTime) + reward
+  Note over O: Wait until startTime
+  alt No proposal before endTime
+    A->>O: claimRefund(assertionId)
+    O-->>A: refund reward
+  else Proposal received
+    P->>O: proposeOutcome(assertionId, outcome) + bond
+    Note over O: Start dispute window
+    alt No dispute before deadline
+      O-->>P: Claim undisputed rewards -> reward + bond refund
+    else Dispute filed in window
+      D->>O: disputeOutcome(assertionId) + bond
+      C->>O: settleAssertion(assertionId, resolvedOutcome)
+      O-->>Winner: claimDisputedReward() -> reward + bond refund
+    end
+  end
+\`\`\`
+
+🧩 The way this system works is someone creates an **assertion**;
+- Something that needs a boolean answer (\`true\` or \`false\`)
+- After a certain time
+- Before a specific deadline
+- With a reward
+
+🦗 If no one answers before the end of the assertion window, the asserter can claim a refund.
+
+💡 If someone knows the answer within the correct time then they **propose** the answer, posting a bond. This bond is a risk to them because if their answer is thought to be wrong by someone else then they might lose it. This keeps people economically tied to the **proposals** they make.
+
+⏳ Then if no one **disputes** the proposal before the dispute window is over then the proposal is considered to be true, and the proposer may claim the reward and their bond. The dispute window should give anyone ample time to submit a dispute.
+
+⚖️ If someone does **dispute** during the dispute window then they must also post a bond equal to the proposer's bond. This kicks the assertion out of any particular timeline and puts it in a state where it is waiting for a decision from the **decider**. Once the decider contract has **settled** the assertion, the winner can claim the reward and their posted bond. The decider gets the loser's bond.
+
+🧑‍⚖️ Now, as we mentioned earlier, this oracle has a role called the **decider**. For this example it is just a simple contract that anyone can call to settle disputes. One could imagine in a live oracle you would want something more robust such as a group of people who vote to settle disputes.
+
+🔗 Look at how [UMA](https://uma.xyz/) does this with their Optimistic Oracle (OO). **This contract is based UMA's OO design**.
+
+## Checkpoint 4: ⚡ Optimistic Oracle - Dispute Resolution
+
+👩‍💻 Now it's (finally) time to build! Unlike the previous checkpoints where you explored existing implementations, this section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
+
+🎯 **Your Mission**: Complete the missing function implementations in the \`OptimisticOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
+
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run \`yarn test\` after implementing each function to verify your solution works correctly.
+
+🔍 Open the \`packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol\` file to implement the optimistic oracle functionality.
+
+### ✏️ Tasks:
+
+1. **Implement \`assertEvent(string memory description, uint256 startTime, uint256 endTime)\`**
+
+* 📣 This function allows users to assert that an event will have a true/false outcome
+
+* 💸 It should require that the reward (\`msg.value\`) is greater than 0 . If it is not then revert with \`NotEnoughValue\`
+
+* ⏱️ It should accept 0 for \`startTime\` and set it to \`block.timestamp\`
+
+* ⏳ It should accept 0 for \`endTime\` and default to \`startTime + MINIMUM_ASSERTION_WINDOW\`
+
+* 🕰️ It should check that the given \`startTime\` is less than the current time (\`block.timestamp\`) and revert with \`InvalidTime\` if it is not
+
+* 🧭 It should validate the time window given is >= \`MINIMUM_ASSERTION_WINDOW\`, otherwise revert with \`InvalidTime\`
+
+* 🏗️ It should create a new \`EventAssertion\` struct with relevant properties set - see if you can figure it out
+
+* 🗂️ That struct should be stored in the \`assertions\` mapping. You can use \`nextAssertionId\` but don't forget to increment it!
+
+* 📣 It should emit the \`EventAsserted\` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Asserting Events</summary>
+
+Here are more granular instructions on setting up the EventAssertion struct:
+- asserter should be \`msg.sender\`
+- reward should be \`msg.value\`
+- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
+- startTime = \`startTime\`
+- endTime = \`endTime\`
+- description = \`description\`
+- any remaining properties can be initialized with the default values (\`false\`, \`address(0)\`, etc.)
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
+        uint256 assertionId = nextAssertionId;
+        nextAssertionId++;
+        if (msg.value == 0) revert NotEnoughValue();
+
+        // Set default times if not provided
+        if (startTime == 0) {
+            startTime = block.timestamp;
+        }
+        if (endTime == 0) {
+            endTime = startTime + MINIMUM_ASSERTION_WINDOW;
+        }
+
+        if (startTime < block.timestamp) revert InvalidTime();
+        if (endTime < startTime + MINIMUM_ASSERTION_WINDOW) revert InvalidTime();
+
+        assertions[assertionId] = EventAssertion({
+            asserter: msg.sender,
+            proposer: address(0),
+            disputer: address(0),
+            proposedOutcome: false,
+            resolvedOutcome: false,
+            reward: msg.value,
+            bond: msg.value * 2,
+            startTime: startTime,
+            endTime: endTime,
+            claimed: false,
+            winner: address(0),
+            description: description
+        });
+
+        emit EventAsserted(assertionId, msg.sender, description, msg.value);
+        return assertionId;
+    }
+\`\`\`
+
+</details>
+</details>
 
 ---
 
-_Create all the required Checkpoints for the Challenge, can also add Side Quests you think may be interesting to complete. Check other Challenges for inspiration._
+2. **Implement \`proposeOutcome(uint256 assertionId, bool outcome)\`**
+
+* 🗳️ This function allows users to propose the outcome for an asserted event
+
+* 🔍 It should check that the assertion exists and hasn't been proposed yet. Otherwise revert with \`AssertionNotFound\` or \`AssertionProposed\`
+
+* ⏱️ It should validate the timing constraints - it has to be after \`startTime\` but before the \`endTime\` or else revert with \`InvalidTime\`
+
+* 💸 It should enforce the correct bond amount is provided or revert with \`NotEnoughValue\`
+
+* ✍️ It should update the assertion with the proposal
+
+* ⏳ It should set the \`endTime\` to \`block.timestamp + MINIMUM_DISPUTE_WINDOW\`
+
+* 📣 It should emit \`OutcomeProposed\`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Proposing Outcomes</summary>
+
+You want to set these properties on the assertion:
+- proposer should be \`msg.sender\`
+- proposedOutcome should be \`outcome\`
+- endTime should be updated to \`block.timestamp + MINIMUM_DISPUTE_WINDOW\`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function proposeOutcome(uint256 assertionId, bool outcome) external payable {
+        EventAssertion storage assertion = assertions[assertionId];
 
-### ⚔️ Side Quests
+        if (assertion.asserter == address(0)) revert AssertionNotFound();
+        if (assertion.proposer != address(0)) revert AssertionProposed();
+        if (block.timestamp < assertion.startTime) revert InvalidTime();
+        if (block.timestamp > assertion.endTime) revert InvalidTime();
+        if (msg.value != assertion.bond) revert NotEnoughValue();
 
-_To finish your README, can add these links_
+        assertion.proposer = msg.sender;
+        assertion.proposedOutcome = outcome;
+        assertion.endTime = block.timestamp + MINIMUM_DISPUTE_WINDOW;
+
+        emit OutcomeProposed(assertionId, msg.sender, outcome);
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+3. **Implement \`disputeOutcome(uint256 assertionId)\`**
+
+* ⚖️ This function allows users to dispute a proposed outcome
+
+* 🔍 It should check that a proposal exists and hasn't been disputed yet, if not then revert with \`NotProposedAssertion\` or \`ProposalDisputed\`
+
+* ⏳ It should validate the timing constraints to make sure the \`endTime\` has not been passed or else it should revert with \`InvalidTime\`
+
+* 💸 It should require the correct bond amount (as set on the assertion)
+
+* 📝 It should record the disputer on the assertion struct
+
+<details markdown='1'>
+
+<summary>💡 Hint: Disputing Outcomes</summary>
+
+The bond amount should be the bond set on the assertion. The same amount that the proposer paid.
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function disputeOutcome(uint256 assertionId) external payable {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer != address(0)) revert ProposalDisputed();
+        if (block.timestamp > assertion.endTime) revert InvalidTime();
+        if (msg.value != assertion.bond) revert NotEnoughValue();
+
+        assertion.disputer = msg.sender;
+
+        emit OutcomeDisputed(assertionId, msg.sender);
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+4. **Implement \`claimUndisputedReward(uint256 assertionId)\`**
+
+We need to allow the proposer to claim the reward when no dispute occurs before the deadline.
+
+* 🧩 A proposal must exist (revert with \`NotProposedAssertion\`)
+
+* 🚫 No dispute must have been raised (revert with \`ProposalDisputed\`)
+
+* ⏰ Current time must be after the dispute \`endTime\` (revert with \`InvalidTime\`)
+
+* 🔒 Not already claimed (revert with \`AlreadyClaimed\`)
+
+* 💸 Transfer \`reward + proposer bond\` to the proposer
+
+* 📣 Emit \`RewardClaimed\`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Claiming Undisputed Rewards</summary>
+
+- Validate the assertion has a proposer and no disputer
+- Check the deadline has passed
+- Mark as claimed first
+- Set \`resolvedOutcome\` to the proposed outcome and \`winner\` to the proposer
+- Compute \`totalReward = reward + bond\`
+- Use safe ETH send with revert on failure
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function claimUndisputedReward(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer != address(0)) revert ProposalDisputed();
+        if (block.timestamp <= assertion.endTime) revert InvalidTime();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+        assertion.resolvedOutcome = assertion.proposedOutcome;
+        assertion.winner = assertion.proposer;
+
+        uint256 totalReward = (assertion.reward + assertion.bond);
+
+        (bool winnerSuccess, ) = payable(assertion.proposer).call{value: totalReward}("");
+        if (!winnerSuccess) revert TransferFailed();
+
+        emit RewardClaimed(assertionId, assertion.proposer, totalReward);
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+5. **Implement \`claimDisputedReward(uint256 assertionId)\`**
+
+Very similar to the last function except this one allows the winner of the dispute to claim *only after the Decider has resolved the dispute*.
+
+* 🧩 A proposal must exist (revert with \`NotProposedAssertion\`)
+
+* ⚖️ A dispute must exist (revert with \`NotDisputedAssertion\`)
+
+* 🧑‍⚖️ The decider must have set a winner (revert with \`AwaitingDecider\`)
+
+* 🔒 Not already claimed (revert with \`AlreadyClaimed\`)
+
+* 📝 Set the \`claimed\` property on the assertion to \`true\`
+
+* 💸 Transfer the loser's bond to the decider, then send the reward and bond refund to the winner
+
+* 📣 Emit \`RewardClaimed\`
+
+<details markdown="1">
+<summary>💡 Hint: Claiming Disputed Rewards</summary>
+
+- Validate assertion state: proposed, disputed, winner set, not yet claimed
+- Mark as claimed *before* paying to avoid re-entrancy
+- Pay the losers bond to the \`decider\`
+- Winner receives \`(reward + bond)\`
+- Use safe ETH sending pattern with revert on failure (\`TransferFailed\`)
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function claimDisputedReward(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer == address(0)) revert NotDisputedAssertion();
+        if (assertion.winner == address(0)) revert AwaitingDecider();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+
+        (bool deciderSuccess, ) = payable(decider).call{value: assertion.bond}("");
+        if (!deciderSuccess) revert TransferFailed();
+        
+        uint256 totalReward = assertion.reward + assertion.bond;
+
+        (bool winnerSuccess, ) = payable(assertion.winner).call{value: totalReward}("");
+        if (!winnerSuccess) revert TransferFailed();
+
+        emit RewardClaimed(assertionId, assertion.winner, totalReward);
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+6. **Implement \`claimRefund(uint256 assertionId)\`**
+
+This function enables the asserter to get a refund of their posted reward when no proposal arrives by the deadline.
+
+* 🚫 No proposer exists (revert with \`AssertionProposed\`)
+
+* ⏰ After assertion endTime ( revert with \`InvalidTime\`)
+
+* 🔒 Not already claimed (revert with \`AlreadyClaimed\`)
+
+* 🛡️ Mark the assertion as claimed to avoid re-entrancy
+
+* 💸 Refund the reward to the asserter
+
+* ✅ Check for successful transfer (revert with \`TransferFailed\`)
+
+* 📣 Emit \`RefundClaimed\`
+
+<details markdown="1">
+<summary>💡 Hint: No Proposal Refund</summary>
+
+- Validate: no proposal, now > endTime, not claimed
+- Mark as claimed then refund
+- Emit refund event
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function claimRefund(uint256 assertionId) external {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer != address(0)) revert AssertionProposed();
+        if (block.timestamp <= assertion.endTime) revert InvalidTime();
+        if (assertion.claimed) revert AlreadyClaimed();
+
+        assertion.claimed = true;
+
+        (bool refundSuccess, ) = payable(assertion.asserter).call{value: assertion.reward}("");
+        if (!refundSuccess) revert TransferFailed();
+        emit RefundClaimed(assertionId, assertion.asserter, assertion.reward);
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+7. **Implement \`settleAssertion(uint256 assertionId, bool resolvedOutcome)\`**
+
+This is the method that the decider will call to settle whether the proposer or disputer are correct.
+
+It should be:
+
+* 🧑‍⚖️ Only callable by the \`decider\` contract
+
+* ⚖️ The assertion must be both proposed and disputed (or revert with \`NotProposedAssertion\` or \`NotDisputedAssertion\`)
+
+* 🔒 We need to make sure the winner has not already been set (or revert with \`AlreadySettled\`)
+
+* ✍️ Now we should set the resolvedOutcome property
+
+* 🏁 Winner = proposer if proposedOutcome == resolvedOutcome, else disputer
+
+* 📣 Emit \`AssertionSettled\`
+
+<details markdown="1">
+<summary>💡 Hint: Decider Sets Winner</summary>
+
+We just need the decider to use the remaining unused properties to establish which party is correct, hence, which party gets to claim the reward.
+
+Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
+
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {
+        EventAssertion storage assertion = assertions[assertionId];
+
+        if (assertion.proposer == address(0)) revert NotProposedAssertion();
+        if (assertion.disputer == address(0)) revert NotDisputedAssertion();
+        if (assertion.winner != address(0)) revert AlreadySettled();
+
+        assertion.resolvedOutcome = resolvedOutcome;
+        
+        assertion.winner = (resolvedOutcome == assertion.proposedOutcome)
+            ? assertion.proposer
+            : assertion.disputer;
+
+        emit AssertionSettled(assertionId, resolvedOutcome, assertion.winner);
+    }
+\`\`\`
+
+</details>
+</details>
+
+8. **Implement \`getState(uint256 assertionId)\`**
+
+This function returns a simple state machine view for UI/testing.
+
+The states are defined as follows in an enum at the top of the contract.
+**States**: Invalid, Asserted, Proposed, Disputed, Settled, Expired
+
+Think through how you can check which properties have been set to derive the current state of the assertion.
+
+For instance, if the \`asserter\` property is empty then you would return an \`Invalid\` state.
+
+Try to deduce the rest without any help.
+
+<details markdown="1">
+<summary>💡 Hint: Derive State</summary>
+
+- \`Invalid\` if no assertion
+- Winner set => \`Settled\`
+- Disputer set => \`Disputed\`
+- No proposer: if past endTime => \`Expired\`, else \`Asserted\`
+- Proposer present: if past endTime => \`Settled\`, else \`Proposed\`
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function getState(uint256 assertionId) external view returns (State) {
+        EventAssertion storage a = assertions[assertionId];
+
+        if (a.asserter == address(0)) return State.Invalid;
+        
+        // If there's a winner, it's settled
+        if (a.winner != address(0)) return State.Settled;
+        
+        // If there's a dispute, it's disputed
+        if (a.disputer != address(0)) return State.Disputed;
+        
+        // If no proposal yet, check if deadline has passed
+        if (a.proposer == address(0)) {
+            if (block.timestamp > a.endTime) return State.Expired;
+            return State.Asserted;
+        }
+        
+        // If no dispute and deadline passed, it's settled (can be claimed)
+        if (block.timestamp > a.endTime) return State.Settled;
+        
+        // Otherwise it's proposed
+        return State.Proposed;
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+9. **Implement \`getResolution(uint256 assertionId)\`**
+
+This function will help everyone know the exact outcome of the assertion.
+
+* 🔎 It should revert with \`AssertionNotFound\` if it doesn't exist
+
+* ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the \`proposedOutcome\` (if the time isn't over then revert with \`InvalidTime\`)
+
+* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the \`winner\` has been set by the decider (or else revert with \`AwaitingDecider\`)
+
+<details markdown="1">
+<summary>💡 Hint: Read Outcome Carefully</summary>
+
+- Handle undisputed vs disputed paths
+- Enforce timing and readiness conditions with appropriate errors
+
+The important thing here is that it reverts if it is not settled and if it has been then it returns the correct outcome, whether that be a proposal that was undisputed or a disputed proposal that was then settled by the decider.
+
+<details markdown="1">
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+    function getResolution(uint256 assertionId) external view returns (bool) {
+        EventAssertion storage a = assertions[assertionId];
+        if (a.asserter == address(0)) revert AssertionNotFound();
+
+        if (a.disputer == address(0)) {
+            if (block.timestamp <= a.endTime) revert InvalidTime();
+            return a.proposedOutcome;
+        } else {
+            if (a.winner == address(0)) revert AwaitingDecider();
+            return a.resolvedOutcome;
+        }
+    }
+\`\`\`
+
+</details>
+</details>
+
+---
+
+✅ Make sure you have implemented everything correctly by running tests with \`yarn test\`. You can dig into any errors by viewing the tests at \`packages/hardhat/test/OptimisticOracle.ts\`.
+
+🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+
+🧪 **Live Simulation**: Run the \`yarn simulate:optimistic\` command to see the full optimistic oracle lifecycle in action:
+
+\`\`\`sh
+
+yarn simulate:optimistic
+
+\`\`\`
+
+🤖 This will start automated bots that create assertions, propose outcomes, and dispute proposals, so you can observe rewards, bonds, fees, and timing windows in a realistic flow. It is up to you to settle disputes!
+
+### 🥅 Goals:
+
+- Users can assert events with descriptions and time windows
+- Users can propose outcomes for asserted events
+- Users can dispute proposed outcomes
+- Undisputed assertions can be claimed after the dispute window
+- The system correctly handles timing constraints
+- Bond amounts are properly validated
+---
+
+## Checkpoint 5: 🔍 Oracle Comparison & Trade-offs
+
+🧠 Now let's analyze the strengths and weaknesses of each oracle design.
+
+### 📊 Comparison Table:
+| Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
+|--------|------------------|----------------|-------------------|
+| **Speed** | Fast | Medium | Slow |
+| **Security** | Low (trusted authority) | Medium (economic incentives) | High (dispute resolution) |
+| **Decentralization** | Low | High | Depends on Decider Implementation |
+| **Cost** | Low | Medium | High |
+| **Complexity** | Simple | Medium | Complex |
+
+### 🤔 Key Trade-offs:
+
+1. **Whitelist Oracle:**
+
+- ✅ Simple and fast
+
+- ✅ Low gas costs
+
+- ❌ Requires trust in centralized authority
+
+- ❌ Single point of failure
+
+2. **Staking Oracle:**
+
+- ✅ Decentralized with economic incentives
+
+- ✅ Self-correcting through slashing
+
+- ❌ More complex to implement
+
+- ❌ Higher gas costs
+
+3. **Optimistic Oracle:**
+
+- ✅ Economic security
+
+- ✅ Can be used for any type of data (not just prices)
+
+- ✴️ Decider role is the weakest link and should be carefully implemented though it is up to the consuming application whether it wants to wait for a resolution or post another assertion and hope a proposal passes without dispute
+
+- ❌ Higher latency
+
+- ❌ More complex
+
+### 🎯 Understanding the "Why":
+
+Each oracle design solves different problems:
+
+- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount
+
+---
+
+## Checkpoint 6: 💾 Deploy your contracts! 🛰
+
+🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
+
+📡 Edit the \`defaultNetwork\` to [your choice of public EVM networks](https://ethereum.org/en/developers/docs/networks/) in \`packages/hardhat/hardhat.config.ts\` (e.g., \`sepolia\`).
+
+🔐 You will need to generate a **deployer address** using \`yarn generate\`. This creates a mnemonic and saves it locally.
+
+👩‍🚀 Use \`yarn account\` to view your deployer account balances.
+
+⛽️ You will need to send ETH to your **deployer address** with your wallet, or get it from a public faucet of your chosen network.
+
+🚀 Run \`yarn deploy\` to deploy your optimistic oracle contracts to a public network (selected in \`hardhat.config.ts\`)
+
+> 💬 Hint: You can set the \`defaultNetwork\` in \`hardhat.config.ts\` to \`sepolia\` **OR** you can \`yarn deploy --network sepolia\`.
+
+---
+
+## Checkpoint 7: 🚢 Ship your frontend! 🚁
+
+✏️ Edit your frontend config in \`packages/nextjs/scaffold.config.ts\` to change the \`targetNetwork\` to \`chains.sepolia\` (or your chosen deployed network).
+
+💻 View your frontend at http://localhost:3000 and verify you see the correct network.
+
+📡 When you are ready to ship the frontend app...
+
+📦 Run \`yarn vercel\` to package up your frontend and deploy.
+
+> You might need to log in to Vercel first by running \`yarn vercel:login\`. Once you log in (email, GitHub, etc), the default options should work.
+
+> If you want to redeploy to the same production URL you can run \`yarn vercel --prod\`. If you omit the \`--prod\` flag it will deploy it to a preview/test URL.
+
+> Follow the steps to deploy to Vercel. It'll give you a public URL.
+
+> 🦊 Since we have deployed to a public testnet, you will now need to connect using a wallet you own or use a burner wallet. By default 🔥 \`burner wallets\` are only available on \`hardhat\` . You can enable them on every chain by setting \`onlyLocalBurnerWallet: false\` in your frontend config (\`scaffold.config.ts\` in \`packages/nextjs/\`)
+
+#### Configuration of Third-Party Services for Production-Grade Apps.
+
+By default, 🏗 Scaffold-ETH 2 provides predefined API keys for popular services such as Alchemy and Etherscan. This allows you to begin developing and testing your applications more easily, avoiding the need to register for these services.
+
+This is great to complete your **SpeedRunEthereum**.
+
+For production-grade applications, it's recommended to obtain your own API keys (to prevent rate limiting issues). You can configure these at:
+
+- 🔷\`ALCHEMY_API_KEY\` variable in \`packages/hardhat/.env\` and \`packages/nextjs/.env.local\`. You can create API keys from the [Alchemy dashboard](https://dashboard.alchemy.com/).
+- 📃\`ETHERSCAN_API_KEY\` variable in \`packages/hardhat/.env\` with your generated API key. You can get your key [here](https://etherscan.io/myapikey).
+
+> 💬 Hint: It's recommended to store env's for nextjs in Vercel/system env config for live apps and use .env.local for local testing.
+
+---
+
+## Checkpoint 8: 📜 Contract Verification
+
+📝 Run the \`yarn verify --network your_network\` command to verify your optimistic oracle contracts on Etherscan 🛰.
+
+👉 Search your deployed optimistic oracle contract addresses on [Sepolia Etherscan](https://sepolia.etherscan.io/) to get the URL you submit to 🏃‍♀️[SpeedRunEthereum.com](https://speedrunethereum.com).
+
+---
+
+> 🎉 Congratulations on completing the Oracle Challenge! You've gained valuable insights into the mechanics of decentralized oracle systems and their critical role in the blockchain ecosystem. You've explored different oracle architectures and built a sophisticated optimistic oracle system from scratch.
 
 > 🏃 Head to your next challenge [here](https://speedrunethereum.com).
 
 > 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
+
+## Checkpoint 9: More On Oracles
+
+Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
+
+🧭 The three oracle designs you've implemented represent the main architectural patterns used in production systems:
+
+- **Whitelist Oracles** are used by protocols that prioritize speed and simplicity over decentralization
+- **Staking Oracles** power most DeFi applications where economic incentives help enforce honest behavior
+- **Optimistic Oracles** are extremely flexible and can be used for anything from world events to cross-chain transfer verification systems
+
+🚀 As you continue your blockchain development journey, you'll encounter many variations and combinations of these patterns. Understanding the fundamental trade-offs will help you choose the right oracle design for your specific use case.
+
+🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
 `;
diff --git a/extension/packages/nextjs/app/layout.tsx.args.mjs b/extension/packages/nextjs/app/layout.tsx.args.mjs
index a4f42f0f..3a6f23fc 100644
--- a/extension/packages/nextjs/app/layout.tsx.args.mjs
+++ b/extension/packages/nextjs/app/layout.tsx.args.mjs
@@ -7,9 +7,8 @@ const spaceGrotesk = Space_Grotesk({
 });
 `;
 
-// CHALLENGE-TODO: Update the metadataOverrides to reflect your challenge
 export const metadataOverrides = {
-  title: "YOUR CHALLENGE TITLE | SpeedRunEthereum",
+  title: "Oracles | SpeedRunEthereum",
   description: "Built with 🏗 Scaffold-ETH 2",
 };
 
diff --git a/extension/packages/nextjs/app/page.tsx.args.mjs b/extension/packages/nextjs/app/page.tsx.args.mjs
index 1d4ed8fc..f07d8121 100644
--- a/extension/packages/nextjs/app/page.tsx.args.mjs
+++ b/extension/packages/nextjs/app/page.tsx.args.mjs
@@ -1,21 +1,32 @@
-// CHALLENGE-TODO: imports and other pre-content
-// export const preContent = ``;
+export const preContent = `import Image from "next/image";`;
 
-// CHALLENGE-TODO: Update the title, description, and deliverable to reflect your challenge
 export const description = `
   <div className="flex items-center flex-col flex-grow mt-4">
     <div className="px-5 w-[90%]">
       <h1 className="text-center mb-6">
-        <span className="block text-4xl font-bold">CHALLENGE TITLE</span>
+        <span className="block text-4xl font-bold">Oracles</span>
       </h1>
       <div className="flex flex-col items-center justify-center">
+        <Image
+          src="/hero.png"
+          width="727"
+          height="231"
+          alt="challenge banner"
+          className="rounded-xl border-4 border-primary"
+        />
         <div className="max-w-3xl">
           <p className="text-center text-lg mt-8">
-            CHALLENGE DESCRIPTION
+            🔮 Build your own decentralized oracle network! In this challenge, you&apos;ll explore different
+            oracle architectures and implementations. You&apos;ll dive deep into concepts like staking
+            mechanisms, consensus algorithms, slashing conditions, and dispute resolution – all crucial
+            components of a robust oracle system.
           </p>
           <p className="text-center text-lg">
-            🌟 The final deliverable is an app that CHALLENGE DELIVERABLE. Deploy your contracts to a
-            testnet then build and upload your app to a public web server. Submit the url on{" "}
+            🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration 
+            and hands-on implementation. You&apos;ll explore two existing oracle systems (Whitelist and Staking) to 
+            understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic 
+            oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements. 
+            Then build and upload your app to a public web server. Submit the url on{" "}
             <a href="https://speedrunethereum.com/" target="_blank" rel="noreferrer" className="underline">
               SpeedRunEthereum.com
             </a>{" "}
@@ -26,5 +37,5 @@ export const description = `
     </div>
   </div>
 `;
-// CHALLENGE-TODO: Update the externalExtensionName to reflect your challenge
-export const externalExtensionName = "SpeedRunEthereum CHALLENGE TITLE";
+
+export const externalExtensionName = "SpeedRunEthereum Oracles";
diff --git a/extension/packages/nextjs/components/Header.tsx.args.mjs b/extension/packages/nextjs/components/Header.tsx.args.mjs
index 494776c9..78479c8e 100644
--- a/extension/packages/nextjs/components/Header.tsx.args.mjs
+++ b/extension/packages/nextjs/components/Header.tsx.args.mjs
@@ -1,15 +1,18 @@
-// CHALLENGE-TODO: change for your imports
-export const preContent = `import { BanknotesIcon } from "@heroicons/react/24/outline";`;
-
-// CHALLENGE-TODO: change for your extra menu links
 export const extraMenuLinksObjects = [
   {
-    label: "Example",
-    href: "/example",
-    icon: '$$<BanknotesIcon className="h-4 w-4" />$$',
+    label: "Whitelist",
+    href: "/whitelist",
+  },
+  {
+    label: "Staking",
+    href: "/staking",
+  },
+  {
+    label: "Optimistic",
+    href: "/optimistic",
   },
 ];
 
 export const logoTitle = "SRE Challenges";
-// CHALLENGE-TODO: Update the logoSubtitle to reflect your challenge title
-export const logoSubtitle = "YOUR CHALLENGE TITLE";
+
+export const logoSubtitle = "Oracles";

From a46360e2cbe8a00c626f6f2865a0120b47623a84 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Thu, 21 Aug 2025 16:34:47 -0400
Subject: [PATCH 04/34] update social card image name

---
 .../packages/nextjs/utils/scaffold-eth/getMetadata.ts.args.mjs  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extension/packages/nextjs/utils/scaffold-eth/getMetadata.ts.args.mjs b/extension/packages/nextjs/utils/scaffold-eth/getMetadata.ts.args.mjs
index b2095690..4f8110e5 100644
--- a/extension/packages/nextjs/utils/scaffold-eth/getMetadata.ts.args.mjs
+++ b/extension/packages/nextjs/utils/scaffold-eth/getMetadata.ts.args.mjs
@@ -1,2 +1,2 @@
 export const titleTemplate = "%s | SpeedRunEthereum";
-export const thumbnailPath = "/thumbnail.png";
+export const thumbnailPath = "/social-card.png";

From c530602d66517a97b42314adfd0a8e2479427ee7 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 22 Aug 2025 14:03:44 -0400
Subject: [PATCH 05/34] second stage

---
 .../contracts/00_Whitelist/SimpleOracle.sol   |  27 +
 .../00_Whitelist/WhitelistOracle.sol          | 125 ++++
 .../contracts/01_Staking/OracleToken.sol      |  20 +
 .../contracts/01_Staking/StakingOracle.sol    | 190 ++++++
 .../contracts/02_Optimistic/Decider.sol       |  40 ++
 .../02_Optimistic/OptimisticOracle.sol        | 110 +++
 .../hardhat/deploy/00_deploy_whitelist.ts     | 112 ++++
 .../hardhat/deploy/01_deploy_staking.ts       |  80 +++
 .../hardhat/deploy/02_deploy_optimistic.ts    |  48 ++
 .../hardhat/scripts/fetchPriceFromUniswap.ts  |  68 ++
 .../hardhat/scripts/oracle-bot/balances.ts    |  29 +
 .../hardhat/scripts/oracle-bot/config.json    |  56 ++
 .../hardhat/scripts/oracle-bot/price.ts       |  16 +
 .../hardhat/scripts/oracle-bot/reporting.ts   |  80 +++
 .../hardhat/scripts/oracle-bot/types.ts       |  19 +
 .../hardhat/scripts/oracle-bot/validation.ts  |  79 +++
 .../hardhat/scripts/runOptimisticBots.ts      | 266 ++++++++
 .../packages/hardhat/scripts/runOracleBots.ts |  64 ++
 .../hardhat/scripts/runWhitelistOracleBots.ts | 120 ++++
 extension/packages/hardhat/scripts/utils.ts   | 114 ++++
 .../packages/hardhat/test/OptimisticOracle.ts | 634 ++++++++++++++++++
 .../app/api/config/price-variance/route.ts    |  56 ++
 .../app/api/config/skip-probability/route.ts  |  56 ++
 .../packages/nextjs/app/optimistic/page.tsx   | 117 ++++
 .../packages/nextjs/app/staking/page.tsx      |  26 +
 .../packages/nextjs/app/whitelist/page.tsx    |  26 +
 .../nextjs/components/MonitorAndTriggerTx.tsx |  65 ++
 .../ScaffoldEthAppWithProviders.tsx.args.mjs  |   8 +
 .../nextjs/components/TooltipInfo.tsx         |  33 +
 .../nextjs/components/oracle/ConfigSlider.tsx |  84 +++
 .../nextjs/components/oracle/EditableCell.tsx | 107 +++
 .../components/oracle/HighlightedCell.tsx     |  41 ++
 .../nextjs/components/oracle/NodeRow.tsx      | 101 +++
 .../nextjs/components/oracle/NodesTable.tsx   | 110 +++
 .../nextjs/components/oracle/PriceWidget.tsx  |  72 ++
 .../oracle/optimistic/AssertedRow.tsx         |  50 ++
 .../oracle/optimistic/AssertedTable.tsx       |  34 +
 .../oracle/optimistic/AssertionModal.tsx      | 260 +++++++
 .../oracle/optimistic/DisputedRow.tsx         |  48 ++
 .../oracle/optimistic/DisputedTable.tsx       |  33 +
 .../components/oracle/optimistic/EmptyRow.tsx |  15 +
 .../oracle/optimistic/ExpiredRow.tsx          |  62 ++
 .../oracle/optimistic/ExpiredTable.tsx        |  31 +
 .../oracle/optimistic/LoadingRow.tsx          |  21 +
 .../oracle/optimistic/ProposedRow.tsx         |  52 ++
 .../oracle/optimistic/ProposedTable.tsx       |  32 +
 .../oracle/optimistic/SettledRow.tsx          |  75 +++
 .../oracle/optimistic/SettledTable.tsx        |  32 +
 .../optimistic/SubmitAssertionButton.tsx      | 245 +++++++
 .../components/oracle/optimistic/TimeLeft.tsx |  55 ++
 .../nextjs/components/oracle/types.ts         |  67 ++
 .../oracle/whitelist/AddOracleButton.tsx      |  72 ++
 .../oracle/whitelist/WhitelistRow.tsx         |  60 ++
 .../oracle/whitelist/WhitelistTable.tsx       | 112 ++++
 extension/packages/nextjs/public/hero.png     | Bin 0 -> 32545 bytes
 .../packages/nextjs/public/social-card.png    | Bin 0 -> 24701 bytes
 .../nextjs/services/store/challengeStore.ts   |  41 ++
 .../packages/nextjs/utils/configUpdater.ts    |  40 ++
 extension/packages/nextjs/utils/constants.ts  | 154 +++++
 extension/packages/nextjs/utils/helpers.ts    |  36 +
 60 files changed, 4826 insertions(+)
 create mode 100644 extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
 create mode 100644 extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
 create mode 100644 extension/packages/hardhat/contracts/01_Staking/OracleToken.sol
 create mode 100644 extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
 create mode 100644 extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
 create mode 100644 extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
 create mode 100644 extension/packages/hardhat/deploy/00_deploy_whitelist.ts
 create mode 100644 extension/packages/hardhat/deploy/01_deploy_staking.ts
 create mode 100644 extension/packages/hardhat/deploy/02_deploy_optimistic.ts
 create mode 100644 extension/packages/hardhat/scripts/fetchPriceFromUniswap.ts
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/balances.ts
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/config.json
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/price.ts
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/reporting.ts
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/types.ts
 create mode 100644 extension/packages/hardhat/scripts/oracle-bot/validation.ts
 create mode 100644 extension/packages/hardhat/scripts/runOptimisticBots.ts
 create mode 100644 extension/packages/hardhat/scripts/runOracleBots.ts
 create mode 100644 extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
 create mode 100644 extension/packages/hardhat/scripts/utils.ts
 create mode 100644 extension/packages/hardhat/test/OptimisticOracle.ts
 create mode 100644 extension/packages/nextjs/app/api/config/price-variance/route.ts
 create mode 100644 extension/packages/nextjs/app/api/config/skip-probability/route.ts
 create mode 100644 extension/packages/nextjs/app/optimistic/page.tsx
 create mode 100644 extension/packages/nextjs/app/staking/page.tsx
 create mode 100644 extension/packages/nextjs/app/whitelist/page.tsx
 create mode 100644 extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
 create mode 100644 extension/packages/nextjs/components/TooltipInfo.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/ConfigSlider.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/EditableCell.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/HighlightedCell.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/NodeRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/NodesTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/PriceWidget.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/AssertedRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/AssertedTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/AssertionModal.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/DisputedRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/DisputedTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/EmptyRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/ExpiredRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/ExpiredTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/LoadingRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/ProposedRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/ProposedTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/SettledRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/SettledTable.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/types.ts
 create mode 100644 extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
 create mode 100644 extension/packages/nextjs/public/hero.png
 create mode 100644 extension/packages/nextjs/public/social-card.png
 create mode 100644 extension/packages/nextjs/services/store/challengeStore.ts
 create mode 100644 extension/packages/nextjs/utils/configUpdater.ts
 create mode 100644 extension/packages/nextjs/utils/constants.ts
 create mode 100644 extension/packages/nextjs/utils/helpers.ts

diff --git a/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
new file mode 100644
index 00000000..a80e92bc
--- /dev/null
+++ b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+contract SimpleOracle {
+    uint256 public price;
+    uint256 public timestamp;
+
+    event PriceUpdated(uint256 newPrice);
+
+    constructor() {}
+
+    modifier onlyOwner() {
+        // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
+        // require(msg.sender == owner, "Not the owner");
+        _;
+    }
+
+    function setPrice(uint256 _newPrice) public onlyOwner {
+        price = _newPrice;
+        timestamp = block.timestamp;
+        emit PriceUpdated(_newPrice);
+    }
+
+    function getPrice() public view returns (uint256, uint256) {
+        return (price, timestamp);
+    }
+}
diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
new file mode 100644
index 00000000..0bc201e8
--- /dev/null
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -0,0 +1,125 @@
+//SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import "./SimpleOracle.sol";
+
+contract WhitelistOracle {
+    address public owner;
+    SimpleOracle[] public oracles;
+
+    event OracleAdded(address oracleAddress);
+    event OracleRemoved(address oracleAddress);
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
+        // require(msg.sender == owner, "Not the owner");
+        _;
+    }
+
+    function addOracle(address oracle) public onlyOwner {
+        require(oracle != address(0), "Invalid oracle address");
+        for (uint256 i = 0; i < oracles.length; i++) {
+            require(address(oracles[i]) != oracle, "Oracle already exists");
+        }
+        oracles.push(SimpleOracle(oracle));
+        emit OracleAdded(oracle);
+    }
+
+    function removeOracle(uint256 index) public onlyOwner {
+        require(index < oracles.length, "Index out of bounds");
+
+        address oracleAddress = address(oracles[index]);
+
+        if (index != oracles.length - 1) {
+            oracles[index] = oracles[oracles.length - 1];
+        }
+
+        oracles.pop();
+
+        emit OracleRemoved(oracleAddress);
+    }
+
+    function getPrice() public view returns (uint256) {
+        require(oracles.length > 0, "No oracles available");
+
+        // Collect prices and timestamps from all oracles
+        uint256[] memory prices = new uint256[](oracles.length);
+        uint256 validCount = 0; // Count of valid prices
+        uint256 currentTime = block.timestamp;
+
+        for (uint256 i = 0; i < oracles.length; i++) {
+            (uint256 price, uint256 timestamp) = oracles[i].getPrice();
+            // Check if the timestamp is within the last 10 seconds
+            if (currentTime - timestamp < 10) {
+                prices[validCount] = price;
+                validCount++;
+            }
+        }
+
+        require(validCount > 0, "No valid prices available");
+
+        uint256[] memory validPrices = new uint256[](validCount);
+        for (uint256 i = 0; i < validCount; i++) {
+            validPrices[i] = prices[i];
+        }
+
+        // NOTE: It is not efficient to sort onchain, but since we only have 10 oracles 
+        // and this is mimicking the early MakerDAO Medianizer exactly, it's fine
+        sort(validPrices);
+
+        uint256 median;
+        if (validCount % 2 == 0) {
+            uint256 midIndex = validCount / 2;
+            median = (validPrices[midIndex - 1] + validPrices[midIndex]) / 2;
+        } else {
+            median = validPrices[validCount / 2];
+        }
+
+        return median;
+    }
+
+    function getActiveOracleNodes() public view returns (address[] memory) {
+        address[] memory tempNodes = new address[](oracles.length);
+        uint256 count = 0;
+
+        for (uint256 i = 0; i < oracles.length; i++) {
+            (, uint256 timestamp) = oracles[i].getPrice();
+            if (timestamp > block.timestamp - 10) {
+                tempNodes[count] = address(oracles[i]);
+                count++;
+            }
+        }
+
+        address[] memory activeNodes = new address[](count);
+        for (uint256 j = 0; j < count; j++) {
+            activeNodes[j] = tempNodes[j];
+        }
+
+        return activeNodes;
+    }
+
+    function transferOwnership(address newOwner) public onlyOwner {
+        require(newOwner != address(0), "New owner cannot be zero address");
+        require(newOwner != owner, "New owner cannot be the same as current owner");
+        owner = newOwner;
+    }
+
+    function sort(uint256[] memory arr) internal pure {
+        uint256 n = arr.length;
+        for (uint256 i = 0; i < n; i++) {
+            uint256 minIndex = i;
+            for (uint256 j = i + 1; j < n; j++) {
+                if (arr[j] < arr[minIndex]) {
+                    minIndex = j;
+                }
+            }
+            if (minIndex != i) {
+                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
+            }
+        }
+    }
+}
diff --git a/extension/packages/hardhat/contracts/01_Staking/OracleToken.sol b/extension/packages/hardhat/contracts/01_Staking/OracleToken.sol
new file mode 100644
index 00000000..fa7a068a
--- /dev/null
+++ b/extension/packages/hardhat/contracts/01_Staking/OracleToken.sol
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+contract ORA is ERC20, Ownable {
+    constructor() ERC20("Oracle Token", "ORA") Ownable(msg.sender) {
+        // Mint initial supply to the contract deployer
+        _mint(msg.sender, 1000000 * 10 ** decimals());
+    }
+
+    function mint(address to, uint256 amount) public onlyOwner {
+        _mint(to, amount);
+    }
+
+    function burn(uint256 amount) public {
+        _burn(msg.sender, amount);
+    }
+}
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
new file mode 100644
index 00000000..40f733ea
--- /dev/null
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol";
+import "./OracleToken.sol";
+
+contract StakingOracle {
+    ORA public oracleToken;
+
+    struct OracleNode {
+        address nodeAddress;
+        uint256 stakedAmount;
+        uint256 lastReportedPrice;
+        uint256 lastReportedTimestamp;
+        uint256 lastClaimedTimestamp;
+        uint256 lastSlashedTimestamp;
+    }
+
+    mapping(address => OracleNode) public nodes;
+    address[] public nodeAddresses;
+
+    uint256 public constant MINIMUM_STAKE = 1 ether;
+    uint256 public constant STALE_DATA_WINDOW = 5 seconds;
+    uint256 public constant SLASHER_REWARD_PERCENTAGE = 10;
+
+    event NodeRegistered(address indexed node, uint256 stakedAmount);
+    event PriceReported(address indexed node, uint256 price);
+
+    event NodeSlashed(address indexed node, uint256 amount);
+    event NodeRewarded(address indexed node, uint256 amount);
+
+    event NodesValidated();
+
+    address public oracleTokenAddress;
+
+    modifier onlyNode() {
+        require(nodes[msg.sender].nodeAddress != address(0), "Node not registered");
+        _;
+    }
+
+    constructor() {
+        oracleToken = new ORA();
+    }
+
+    /* ========== Oracle Node Operation Functions ========== */
+    function registerNode(uint256 initialPrice) public payable {
+        require(msg.value >= MINIMUM_STAKE, "Insufficient stake");
+        require(nodes[msg.sender].nodeAddress == address(0), "Node already registered");
+
+        nodes[msg.sender] = OracleNode({
+            nodeAddress: msg.sender,
+            stakedAmount: msg.value,
+            lastReportedPrice: initialPrice,
+            lastReportedTimestamp: block.timestamp,
+            lastClaimedTimestamp: block.timestamp,
+            lastSlashedTimestamp: 0
+        });
+
+        nodeAddresses.push(msg.sender);
+
+        emit NodeRegistered(msg.sender, msg.value);
+        emit PriceReported(msg.sender, initialPrice);
+    }
+
+    function reportPrice(uint256 price) public onlyNode {
+        OracleNode storage node = nodes[msg.sender];
+        require(node.stakedAmount >= MINIMUM_STAKE, "Not enough stake");
+        node.lastReportedPrice = price;
+        node.lastReportedTimestamp = block.timestamp;
+
+        emit PriceReported(msg.sender, price);
+    }
+
+    function rewardNode(address nodeAddress, uint256 reward) internal {
+        oracleToken.mint(nodeAddress, reward);
+        emit NodeRewarded(nodeAddress, reward);
+    }
+
+    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
+        OracleNode storage node = nodes[nodeToSlash];
+        uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
+        node.stakedAmount -= actualPenalty;
+
+        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
+
+        emit NodeSlashed(nodeToSlash, actualPenalty);
+
+        return reward;
+    }
+
+    function claimReward() public onlyNode {
+        OracleNode memory node = nodes[msg.sender];
+        uint256 rewardAmount = 0;
+
+        if (node.stakedAmount < MINIMUM_STAKE) {
+            if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
+                rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
+            }
+        } else {
+            rewardAmount = block.timestamp - node.lastClaimedTimestamp;
+        }
+
+        require(rewardAmount > 0, "No rewards available");
+
+        nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
+        rewardNode(msg.sender, rewardAmount * 10**18);
+    }
+
+    function slashNodes() public {
+        (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
+        uint256 slasherReward;
+        for (uint i = 0; i < addressesToSlash.length; i++) {
+            slasherReward += slashNode(addressesToSlash[i], 1 ether);
+        }
+
+        (bool sent,) = msg.sender.call{value: slasherReward}("");
+        require(sent, "Failed to send reward");        
+    }
+
+    /* ========== Price Calculation Functions ========== */
+    function getMedian(uint256[] memory arr) internal pure returns (uint256) {
+        uint256 length = arr.length;
+        if (length % 2 == 0) {
+            return (arr[length / 2 - 1] + arr[length / 2]) / 2;
+        } else {
+            return arr[length / 2];
+        }
+    }
+
+    function separateStaleNodes(
+        address[] memory nodesToSeparate
+    ) public view returns (address[] memory fresh, address[] memory stale) {
+        address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
+        address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
+        uint256 freshCount = 0;
+        uint256 staleCount = 0;
+
+        for (uint i = 0; i < nodesToSeparate.length; i++) {
+            address nodeAddress = nodesToSeparate[i];
+            OracleNode memory node = nodes[nodeAddress];
+            uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
+            bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
+
+            if (dataIsStale) {
+                staleNodeAddresses[staleCount] = nodeAddress;
+                staleCount++;
+            } else {
+                freshNodeAddresses[freshCount] = nodeAddress;
+                freshCount++;
+            }
+        }
+
+        address[] memory trimmedFreshNodes = new address[](freshCount);
+        address[] memory trimmedStaleNodes = new address[](staleCount);
+
+        for (uint i = 0; i < freshCount; i++) {
+            trimmedFreshNodes[i] = freshNodeAddresses[i];
+        }
+        for (uint i = 0; i < staleCount; i++) {
+            trimmedStaleNodes[i] = staleNodeAddresses[i];
+        }
+
+        return (trimmedFreshNodes, trimmedStaleNodes);
+    }
+
+    function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
+        uint256[] memory prices = new uint256[](addresses.length);
+
+        for (uint256 i = 0; i < addresses.length; i++) {
+            OracleNode memory node = nodes[addresses[i]];
+            prices[i] = node.lastReportedPrice;
+        }
+
+        return prices;
+    }
+
+    function getPrice() public view returns (uint256) {
+        (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
+        uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
+        require(validPrices.length > 0, "No valid prices available");
+        Arrays.sort(validPrices);
+        return getMedian(validPrices);
+    }
+
+    function getNodeAddresses() public view returns (address[] memory) {
+        return nodeAddresses;
+    }
+
+    // Notably missing a way to unstake and exit your node but not needed for the challenge
+}
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol b/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
new file mode 100644
index 00000000..26f5e6b6
--- /dev/null
+++ b/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import "./OptimisticOracle.sol";
+
+contract Decider {
+    address public owner;
+    OptimisticOracle public oracle;
+    
+    event DisputeSettled(uint256 indexed assertionId, bool resolvedValue);
+    
+    constructor(address _oracle) {
+        owner = msg.sender;
+        oracle = OptimisticOracle(_oracle);
+    }
+    
+    /**
+     * @notice Settle a dispute by determining the true/false outcome
+     * @param assertionId The ID of the assertion to settle
+     * @param resolvedValue The true/false outcome determined by the decider
+     */
+    function settleDispute(uint256 assertionId, bool resolvedValue) external {
+        require(assertionId >= 1, "Invalid assertion ID");
+        
+        // Call the oracle's settleAssertion function
+        oracle.settleAssertion(assertionId, resolvedValue);
+        
+        emit DisputeSettled(assertionId, resolvedValue);
+    }
+    
+    function setOracle(address newOracle) external {
+        require(msg.sender == owner, "Only owner can set oracle");
+        oracle = OptimisticOracle(newOracle);
+    }
+
+    /**
+     * @notice Allow the contract to receive ETH
+     */
+    receive() external payable {}
+} 
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
new file mode 100644
index 00000000..278210fa
--- /dev/null
+++ b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+contract OptimisticOracle {
+    enum State { Invalid, Asserted, Proposed, Disputed, Settled, Expired }
+
+    error AssertionNotFound();
+    error AssertionProposed();
+    error NotEnoughValue();
+    error InvalidTime();
+    error ProposalDisputed();
+    error NotProposedAssertion();
+    error AlreadyClaimed();
+    error AlreadySettled();
+    error AwaitingDecider();
+    error NotDisputedAssertion();
+    error OnlyDecider();
+    error OnlyOwner();
+    error TransferFailed();
+
+    struct EventAssertion {
+        address asserter;
+        address proposer;
+        address disputer;
+        bool proposedOutcome;
+        bool resolvedOutcome;
+        uint256 reward;
+        uint256 bond;
+        uint256 startTime;
+        uint256 endTime;
+        bool claimed;
+        address winner;
+        string description;
+    }
+    uint256 public constant MINIMUM_ASSERTION_WINDOW = 3 minutes;
+    uint256 public constant MINIMUM_DISPUTE_WINDOW = 3 minutes;
+    address public decider;
+    address public owner;
+    uint256 public nextAssertionId = 1;
+    mapping(uint256 => EventAssertion) public assertions;
+
+    event EventAsserted(uint256 assertionId, address asserter, string description, uint256 reward);
+    event OutcomeProposed(uint256 assertionId, address proposer, bool outcome);
+    event OutcomeDisputed(uint256 assertionId, address disputer);
+    event AssertionSettled(uint256 assertionId, bool outcome, address winner);
+    event DeciderUpdated(address oldDecider, address newDecider);
+    event RewardClaimed(uint256 assertionId, address winner, uint256 amount);
+    event RefundClaimed(uint256 assertionId, address asserter, uint256 amount);
+
+    modifier onlyDecider() {
+        if (msg.sender != decider) revert OnlyDecider();
+        _;
+    }
+
+    modifier onlyOwner() {
+        if (msg.sender != owner) revert OnlyOwner();
+        _;
+    }
+
+    constructor(address _decider) {
+        decider = _decider;
+        owner = msg.sender;
+    }
+
+    function setDecider(address _decider) external onlyOwner {
+        address oldDecider = address(decider);
+        decider = _decider;
+        emit DeciderUpdated(oldDecider, _decider);
+    }
+
+    function getAssertion(uint256 assertionId) external view returns (EventAssertion memory) {
+        return assertions[assertionId];
+    }
+
+    function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
+
+    }
+
+    function proposeOutcome(uint256 assertionId, bool outcome) external payable {
+
+    }
+
+    function disputeOutcome(uint256 assertionId) external payable {
+  
+    }
+
+    function claimUndisputedReward(uint256 assertionId) external {
+
+    }
+
+    function claimDisputedReward(uint256 assertionId) external {
+
+    }
+
+    function claimRefund(uint256 assertionId) external {
+
+    }
+
+    function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {
+
+    }
+
+    function getState(uint256 assertionId) external view returns (State) {
+
+    }
+
+    function getResolution(uint256 assertionId) external view returns (bool) {
+
+    }
+}
diff --git a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
new file mode 100644
index 00000000..3bf1431c
--- /dev/null
+++ b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
@@ -0,0 +1,112 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import { fetchPriceFromUniswap } from "../scripts/fetchPriceFromUniswap";
+
+/**
+ * Deploys SimpleOracle instances and a WhitelistOracle contract using viem
+ *
+ * @param hre HardhatRuntimeEnvironment object.
+ */
+const deployWhitelistOracleContracts: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployer } = await hre.getNamedAccounts();
+  const { deploy } = hre.deployments;
+  const { viem } = hre;
+
+  const publicClient = await viem.getPublicClient();
+
+  console.log("Deploying WhitelistOracle contracts...");
+
+  // Get 10 wallet clients (accounts)
+  const accounts = await viem.getWalletClients();
+  const nodeAccounts = accounts.slice(0, 10);
+  const simpleOracleAddresses: string[] = [];
+
+  // Deploy 10 SimpleOracle contracts, each owned by a different account
+  for (let i = 0; i < nodeAccounts.length; i++) {
+    const account = nodeAccounts[i];
+    console.log(`Deploying SimpleOracle ${i + 1}/10 from account: ${account.account.address}`);
+    const simpleOracle = await deploy(`SimpleOracle_${i + 1}`, {
+      contract: "SimpleOracle",
+      from: account.account.address,
+      args: [],
+      log: true,
+      autoMine: true,
+    });
+    simpleOracleAddresses.push(simpleOracle.address);
+  }
+
+  console.log("Deploying WhitelistOracle...");
+
+  const whitelistOracleDeployment = await deploy("WhitelistOracle", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+  const whitelistOracleAddress = whitelistOracleDeployment.address as `0x${string}`;
+  const whitelistOracleAbi = whitelistOracleDeployment.abi;
+
+  // Add all SimpleOracle addresses to WhitelistOracle
+  console.log("Adding SimpleOracle instances to WhitelistOracle...");
+  const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
+  if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
+
+  try {
+    for (let i = 0; i < simpleOracleAddresses.length; i++) {
+      const oracleAddress = simpleOracleAddresses[i] as `0x${string}`;
+      console.log(`Adding SimpleOracle ${i + 1}/10: ${oracleAddress}`);
+      await deployerAccount.writeContract({
+        address: whitelistOracleAddress,
+        abi: whitelistOracleAbi,
+        functionName: "addOracle",
+        args: [oracleAddress],
+      });
+    }
+  } catch (error: any) {
+    if (error.message?.includes("Oracle already exists")) {
+      console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
+      console.error("🔧 Please retry with:");
+      console.error("yarn deploy --reset\n");
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+
+  // Set initial prices for each SimpleOracle
+  console.log("Setting initial prices for each SimpleOracle...");
+  const initialPrice = await fetchPriceFromUniswap();
+  for (let i = 0; i < nodeAccounts.length; i++) {
+    const account = nodeAccounts[i];
+    const simpleOracleDeployment = await hre.deployments.get(`SimpleOracle_${i + 1}`);
+    const simpleOracleAbi = simpleOracleDeployment.abi;
+    const simpleOracleAddress = simpleOracleDeployment.address as `0x${string}`;
+    await account.writeContract({
+      address: simpleOracleAddress,
+      abi: simpleOracleAbi,
+      functionName: "setPrice",
+      args: [initialPrice],
+    });
+
+    await publicClient.transport.request({
+      method: "evm_mine",
+    });
+
+    console.log(`Set price for SimpleOracle_${i + 1} to: ${initialPrice}`);
+  }
+
+  // Calculate initial median price
+  console.log("Calculating initial median price...");
+  const medianPrice = await publicClient.readContract({
+    address: whitelistOracleAddress,
+    abi: whitelistOracleAbi,
+    functionName: "getPrice",
+    args: [],
+  });
+  console.log(`Initial median price: ${medianPrice.toString()}`);
+
+  console.log("All oracle contracts deployed and configured successfully!");
+};
+
+export default deployWhitelistOracleContracts;
+deployWhitelistOracleContracts.tags = ["Oracles"];
diff --git a/extension/packages/hardhat/deploy/01_deploy_staking.ts b/extension/packages/hardhat/deploy/01_deploy_staking.ts
new file mode 100644
index 00000000..f42780ef
--- /dev/null
+++ b/extension/packages/hardhat/deploy/01_deploy_staking.ts
@@ -0,0 +1,80 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import { parseEther } from "viem";
+import { fetchPriceFromUniswap } from "../scripts/fetchPriceFromUniswap";
+
+const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployer } = await hre.getNamedAccounts();
+  const { deploy } = hre.deployments;
+  const { viem } = hre;
+
+  console.log("Deploying Staking Oracle contract...");
+  const deployment = await deploy("StakingOracle", {
+    contract: "StakingOracle",
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+
+  const stakingOracleAddress = deployment.address as `0x${string}`;
+  console.log("StakingOracle deployed at:", stakingOracleAddress);
+
+  const accounts = await viem.getWalletClients();
+  const nodeAccounts = accounts.slice(1, 11);
+
+  const publicClient = await viem.getPublicClient();
+
+  const oraTokenAddress = await publicClient.readContract({
+    address: stakingOracleAddress,
+    abi: deployment.abi,
+    functionName: "oracleToken",
+    args: [],
+  });
+  console.log("ORA Token deployed at:", oraTokenAddress);
+  const initialPrice = await fetchPriceFromUniswap();
+
+  try {
+    await Promise.all(
+      nodeAccounts.map(account => {
+        return account.writeContract({
+          address: stakingOracleAddress,
+          abi: deployment.abi,
+          functionName: "registerNode",
+          args: [initialPrice],
+          value: parseEther("15"),
+        });
+      }),
+    );
+  } catch (error: any) {
+    if (error.message?.includes("Node already registered")) {
+      console.error("\n❌ Deployment failed: Nodes already registered!\n");
+      console.error("🔧 Please retry with:");
+      console.error("yarn deploy --reset\n");
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+
+  await publicClient.transport.request({
+    method: "evm_mine",
+  });
+
+  await Promise.all(
+    nodeAccounts.map(account => {
+      return account.writeContract({
+        address: stakingOracleAddress,
+        abi: deployment.abi,
+        functionName: "reportPrice",
+        args: [initialPrice],
+      });
+    }),
+  );
+
+  await publicClient.transport.request({
+    method: "evm_mine",
+  });
+};
+
+export default deployStakingOracle;
diff --git a/extension/packages/hardhat/deploy/02_deploy_optimistic.ts b/extension/packages/hardhat/deploy/02_deploy_optimistic.ts
new file mode 100644
index 00000000..dc756783
--- /dev/null
+++ b/extension/packages/hardhat/deploy/02_deploy_optimistic.ts
@@ -0,0 +1,48 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+
+const deployOptimisticOracle: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  console.log("Deploying OptimisticOracle...");
+  console.log("Deployer:", deployer);
+  // Get the deployer's current nonce
+  const deployerNonce = await hre.ethers.provider.getTransactionCount(deployer);
+
+  const futureDeciderAddress = hre.ethers.getCreateAddress({
+    from: deployer,
+    nonce: deployerNonce + 1, // +1 because it will be our second deployment
+  });
+  // Deploy the OptimisticOracle contract with deployer as temporary decider
+  const optimisticOracle = await deploy("OptimisticOracle", {
+    contract: "OptimisticOracle",
+    from: deployer,
+    args: [futureDeciderAddress], // Use deployer as temporary decider
+    log: true,
+    autoMine: true,
+  });
+
+  // Deploy the Decider contract
+  const decider = await deploy("Decider", {
+    contract: "Decider",
+    from: deployer,
+    args: [optimisticOracle.address],
+    log: true,
+    autoMine: true,
+  });
+
+  // Check if the decider address matches the expected address
+  if (decider.address !== futureDeciderAddress) {
+    throw new Error("Decider address does not match expected address");
+  }
+
+  console.log("OptimisticOracle deployed to:", optimisticOracle.address);
+  console.log("Decider deployed to:", decider.address);
+};
+
+deployOptimisticOracle.id = "deploy_optimistic_oracle";
+deployOptimisticOracle.tags = ["OptimisticOracle"];
+
+export default deployOptimisticOracle;
diff --git a/extension/packages/hardhat/scripts/fetchPriceFromUniswap.ts b/extension/packages/hardhat/scripts/fetchPriceFromUniswap.ts
new file mode 100644
index 00000000..605d3d5f
--- /dev/null
+++ b/extension/packages/hardhat/scripts/fetchPriceFromUniswap.ts
@@ -0,0 +1,68 @@
+import { ethers } from "hardhat";
+import * as dotenv from "dotenv";
+dotenv.config();
+
+import { config as hardhatConfig } from "hardhat";
+import { getConfig, updatePriceCache } from "./utils";
+import { parseEther, formatEther } from "ethers";
+
+const UNISWAP_V2_PAIR_ABI = [
+  "function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)",
+  "function token0() external view returns (address)",
+  "function token1() external view returns (address)",
+];
+
+const DAI_ADDRESS = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
+const WETH_ADDRESS = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+const UNISWAP_V2_FACTORY = "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f";
+const mainnet = hardhatConfig.networks.mainnet;
+const MAINNET_RPC = "url" in mainnet ? mainnet.url : "";
+
+export const fetchPriceFromUniswap = async (): Promise<bigint> => {
+  const config = getConfig();
+  const cachedPrice = config.PRICE.CACHEDPRICE;
+  const timestamp = config.PRICE.TIMESTAMP;
+
+  if (Date.now() - timestamp < 1000 * 60 * 60) {
+    return parseEther(cachedPrice.toString());
+  }
+  console.log("Cache expired or missing, fetching fresh price from Uniswap...");
+
+  try {
+    const provider = new ethers.JsonRpcProvider(MAINNET_RPC);
+    const tokenAddress = WETH_ADDRESS; // Always use WETH for mainnet
+
+    // Get pair address from Uniswap V2 Factory
+    const factory = new ethers.Contract(
+      UNISWAP_V2_FACTORY,
+      ["function getPair(address tokenA, address tokenB) external view returns (address pair)"],
+      provider,
+    );
+
+    const pairAddress = await factory.getPair(tokenAddress, DAI_ADDRESS);
+    if (pairAddress === ethers.ZeroAddress) {
+      throw new Error("No liquidity pair found");
+    }
+
+    const pairContract = new ethers.Contract(pairAddress, UNISWAP_V2_PAIR_ABI, provider);
+    const [reserves, token0Address] = await Promise.all([pairContract.getReserves(), pairContract.token0()]);
+
+    // Determine which reserve is token and which is DAI
+    const isToken0 = token0Address.toLowerCase() === tokenAddress.toLowerCase();
+    const tokenReserve = isToken0 ? reserves[0] : reserves[1];
+    const daiReserve = isToken0 ? reserves[1] : reserves[0];
+
+    // Calculate price (DAI per token)
+    const price = BigInt(Math.floor((Number(daiReserve) / Number(tokenReserve)) * 1e18));
+
+    // Update cache with fresh price
+    const pricePerEther = parseFloat(formatEther(price));
+    updatePriceCache(pricePerEther, Date.now());
+    console.log(`Fresh price fetched and cached: ${formatEther(price)} ETH`);
+
+    return price;
+  } catch (error) {
+    console.error("Error fetching ETH price from Uniswap: ", error);
+    return parseEther(cachedPrice.toString());
+  }
+};
diff --git a/extension/packages/hardhat/scripts/oracle-bot/balances.ts b/extension/packages/hardhat/scripts/oracle-bot/balances.ts
new file mode 100644
index 00000000..6d7a5d0b
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/balances.ts
@@ -0,0 +1,29 @@
+import { ethers } from "hardhat";
+import { formatEther } from "ethers";
+
+export async function reportBalances() {
+  try {
+    // Get all signers (accounts)
+    const signers = await ethers.getSigners();
+    const oracleNodes = signers.slice(1, 11); // Get oracle node accounts
+
+    // Get the StakingOracle contract
+    const oracleContract = await ethers.getContract("StakingOracle");
+    const oracle = await ethers.getContractAt("StakingOracle", oracleContract.target);
+
+    // Get the ORA token address and create contract instance
+    const oraTokenAddress = await oracle.oracleToken();
+    const oraToken = await ethers.getContractAt("contracts/OracleToken.sol:ORA", oraTokenAddress);
+
+    console.log("\nNode Balances:");
+    for (const node of oracleNodes) {
+      const nodeInfo = await oracle.nodes(node.address);
+      const oraBalance = await oraToken.balanceOf(node.address);
+      console.log(`\nNode ${node.address}:`);
+      console.log(`  Staked ETH: ${formatEther(nodeInfo.stakedAmount)} ETH`);
+      console.log(`  ORA Balance: ${formatEther(oraBalance)} ORA`);
+    }
+  } catch (error) {
+    console.error("Error reporting balances:", error);
+  }
+}
diff --git a/extension/packages/hardhat/scripts/oracle-bot/config.json b/extension/packages/hardhat/scripts/oracle-bot/config.json
new file mode 100644
index 00000000..0220acc3
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/config.json
@@ -0,0 +1,56 @@
+{
+  "PRICE": {
+    "CACHEDPRICE": 4211.966627258689,
+    "TIMESTAMP": 1754950566641
+  },
+  "INTERVALS": {
+    "PRICE_REPORT": 1750,
+    "VALIDATION": 1750
+  },
+  "NODE_CONFIGS": {
+    "default": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0
+    },
+    "0x70997970c51812dc3a010c7d01b50e0d17dc79c8": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0.5,
+      "PRICE_VARIANCE": 0.02
+    },
+    "0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 1,
+      "PRICE_VARIANCE": 0.04
+    },
+    "0x976ea74026e726554db657fa54763abd0c3a0aa9": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0.5,
+      "PRICE_VARIANCE": 0.03
+    },
+    "0x90f79bf6eb2c4f870365e785982e1f101e93b906": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0.01
+    },
+    "0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0.035
+    },
+    "0x15d34aaf54267db7d7c367839aaf71a00a2c6a65": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0.59,
+      "PRICE_VARIANCE": 0.045
+    },
+    "0xbcd4042de499d14e55001ccbb24a551f3b954096": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0.73
+    },
+    "0x14dc79964da2c08b23698b3d3cc7ca32193d9955": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0.025
+    },
+    "0x23618e81e3f5cdf7f54c3d65f7fbc0abf5b21e8f": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 1,
+      "PRICE_VARIANCE": 0
+    },
+    "0xa0ee7a142d267c1f36714e4a8f75612f20a79720": {
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0.05
+    }
+  }
+}
\ No newline at end of file
diff --git a/extension/packages/hardhat/scripts/oracle-bot/price.ts b/extension/packages/hardhat/scripts/oracle-bot/price.ts
new file mode 100644
index 00000000..6de87c0b
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/price.ts
@@ -0,0 +1,16 @@
+import { getConfig } from "../utils";
+
+export const getRandomPrice = async (nodeAddress: string, currentPrice: number): Promise<number> => {
+  const config = getConfig();
+  const nodeConfig = config.NODE_CONFIGS[nodeAddress] || config.NODE_CONFIGS.default;
+
+  // Calculate variance range based on the node's PRICE_VARIANCE
+  // PRICE_VARIANCE of 0 means no variance, higher values mean wider range
+  const varianceRange = Math.floor(currentPrice * nodeConfig.PRICE_VARIANCE);
+
+  // Apply variance to the base price
+  const finalPrice = currentPrice + (Math.random() * 2 - 1) * varianceRange;
+
+  // Round to nearest integer
+  return Math.round(finalPrice);
+};
diff --git a/extension/packages/hardhat/scripts/oracle-bot/reporting.ts b/extension/packages/hardhat/scripts/oracle-bot/reporting.ts
new file mode 100644
index 00000000..007bb5ac
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/reporting.ts
@@ -0,0 +1,80 @@
+import { PublicClient } from "viem";
+import { getRandomPrice } from "./price";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { getConfig } from "../utils";
+import { fetchPriceFromUniswap } from "../fetchPriceFromUniswap";
+import { DeployedContract } from "hardhat-deploy/types";
+
+const getStakedAmount = async (
+  publicClient: PublicClient,
+  nodeAddress: `0x${string}`,
+  oracleContract: DeployedContract,
+) => {
+  const nodeInfo = (await publicClient.readContract({
+    address: oracleContract.address as `0x${string}`,
+    abi: oracleContract.abi,
+    functionName: "nodes",
+    args: [nodeAddress],
+  })) as any[];
+
+  const [, stakedAmount] = nodeInfo;
+  return stakedAmount as bigint;
+};
+
+export const reportPrices = async (hre: HardhatRuntimeEnvironment) => {
+  const { deployments } = hre;
+  const oracleContract = await deployments.get("StakingOracle");
+  const config = getConfig();
+  const accounts = await hre.viem.getWalletClients();
+  const oracleNodeAccounts = accounts.slice(1, 11);
+  const publicClient = await hre.viem.getPublicClient();
+
+  // Get minimum stake requirement from contract
+  const minimumStake = (await publicClient.readContract({
+    address: oracleContract.address as `0x${string}`,
+    abi: oracleContract.abi,
+    functionName: "MINIMUM_STAKE",
+    args: [],
+  })) as unknown as bigint;
+
+  const currentPrice = Number(await fetchPriceFromUniswap());
+  try {
+    return Promise.all(
+      oracleNodeAccounts.map(async account => {
+        const nodeConfig = config.NODE_CONFIGS[account.account.address] || config.NODE_CONFIGS.default;
+        const shouldReport = Math.random() > nodeConfig.PROBABILITY_OF_SKIPPING_REPORT;
+        const stakedAmount = await getStakedAmount(publicClient, account.account.address, oracleContract);
+        if (stakedAmount < minimumStake) {
+          console.log(`Insufficient stake for ${account.account.address} for price reporting`);
+          return Promise.resolve();
+        }
+
+        if (shouldReport) {
+          const price = BigInt(await getRandomPrice(account.account.address, currentPrice));
+          console.log(`Reporting price ${price} from ${account.account.address}`);
+          try {
+            return await account.writeContract({
+              address: oracleContract.address as `0x${string}`,
+              abi: oracleContract.abi,
+              functionName: "reportPrice",
+              args: [price],
+            });
+          } catch (error: any) {
+            if (error.message && error.message.includes("Not enough stake")) {
+              console.log(
+                `Skipping price report from ${account.account.address} - insufficient stake during execution`,
+              );
+              return Promise.resolve();
+            }
+            throw error;
+          }
+        } else {
+          console.log(`Skipping price report from ${account.account.address}`);
+          return Promise.resolve();
+        }
+      }),
+    );
+  } catch (error) {
+    console.error("Error reporting prices:", error);
+  }
+};
diff --git a/extension/packages/hardhat/scripts/oracle-bot/types.ts b/extension/packages/hardhat/scripts/oracle-bot/types.ts
new file mode 100644
index 00000000..b1573c13
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/types.ts
@@ -0,0 +1,19 @@
+interface NodeConfig {
+  PROBABILITY_OF_SKIPPING_REPORT: number;
+  PRICE_VARIANCE: number; // Higher number means wider price range
+}
+
+export interface Config {
+  PRICE: {
+    CACHEDPRICE: number;
+    TIMESTAMP: number;
+  };
+  INTERVALS: {
+    PRICE_REPORT: number;
+    VALIDATION: number;
+  };
+  NODE_CONFIGS: {
+    [key: string]: NodeConfig;
+    default: NodeConfig;
+  };
+}
diff --git a/extension/packages/hardhat/scripts/oracle-bot/validation.ts b/extension/packages/hardhat/scripts/oracle-bot/validation.ts
new file mode 100644
index 00000000..1adcca96
--- /dev/null
+++ b/extension/packages/hardhat/scripts/oracle-bot/validation.ts
@@ -0,0 +1,79 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+const getStakedAmount = async (publicClient: any, nodeAddress: `0x${string}`, oracleContract: any) => {
+  const nodeInfo = (await publicClient.readContract({
+    address: oracleContract.address as `0x${string}`,
+    abi: oracleContract.abi,
+    functionName: "nodes",
+    args: [nodeAddress],
+  })) as any[];
+
+  const [, stakedAmount] = nodeInfo;
+  return stakedAmount as bigint;
+};
+
+export const claimRewards = async (hre: HardhatRuntimeEnvironment) => {
+  const { deployments } = hre;
+  const oracleContract = await deployments.get("StakingOracle");
+  const accounts = await hre.viem.getWalletClients();
+  const oracleNodeAccounts = accounts.slice(1, 11);
+  const publicClient = await hre.viem.getPublicClient();
+
+  // Get minimum stake requirement from contract
+  const minimumStake = (await publicClient.readContract({
+    address: oracleContract.address as `0x${string}`,
+    abi: oracleContract.abi,
+    functionName: "MINIMUM_STAKE",
+    args: [],
+  })) as unknown as bigint;
+
+  try {
+    return Promise.all(
+      oracleNodeAccounts.map(async account => {
+        const stakedAmount = await getStakedAmount(publicClient, account.account.address, oracleContract);
+
+        // Only claim rewards if the node has sufficient stake
+        if (stakedAmount >= minimumStake) {
+          try {
+            console.log(`Claiming rewards for ${account.account.address}`);
+            return await account.writeContract({
+              address: oracleContract.address as `0x${string}`,
+              abi: oracleContract.abi,
+              functionName: "claimReward",
+              args: [],
+            });
+          } catch (error: any) {
+            if (error.message && error.message.includes("No rewards available")) {
+              console.log(`Skipping reward claim for ${account.account.address} - no rewards available`);
+              return Promise.resolve();
+            }
+            throw error;
+          }
+        } else {
+          console.log(`Skipping reward claim for ${account.account.address} - insufficient stake`);
+          return Promise.resolve();
+        }
+      }),
+    );
+  } catch (error) {
+    console.error("Error claiming rewards:", error);
+  }
+};
+
+// Keep the old validateNodes function for backward compatibility if needed
+export const validateNodes = async (hre: HardhatRuntimeEnvironment) => {
+  const { deployments } = hre;
+  const [account] = await hre.viem.getWalletClients();
+  const oracleContract = await deployments.get("StakingOracle");
+
+  try {
+    return await account.writeContract({
+      address: oracleContract.address as `0x${string}`,
+      abi: oracleContract.abi,
+      functionName: "slashNodes",
+      args: [],
+    });
+  } catch (error) {
+    console.error("Error validating nodes:", error);
+  }
+};
diff --git a/extension/packages/hardhat/scripts/runOptimisticBots.ts b/extension/packages/hardhat/scripts/runOptimisticBots.ts
new file mode 100644
index 00000000..6b142ead
--- /dev/null
+++ b/extension/packages/hardhat/scripts/runOptimisticBots.ts
@@ -0,0 +1,266 @@
+import { deployments, ethers } from "hardhat";
+import hre from "hardhat";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { cleanup, getRandomQuestion, sleep } from "./utils";
+import { WalletClient } from "@nomicfoundation/hardhat-viem/types";
+import { Deployment } from "hardhat-deploy/types";
+import { zeroAddress } from "viem";
+import { OptimisticOracle } from "../typechain-types";
+
+const isHalfTimePassed = (assertion: any, currentTimestamp: bigint) => {
+  const startTime: bigint = assertion.startTime;
+  const endTime: bigint = assertion.endTime;
+  const halfTimePassed = (endTime - startTime) / 2n;
+  return currentTimestamp > startTime && startTime + halfTimePassed < currentTimestamp;
+};
+
+const stopTrackingAssertion = (
+  accountToAssertionIds: Record<string, bigint[]>,
+  account: WalletClient,
+  assertionId: bigint,
+) => {
+  accountToAssertionIds[account.account.address] = accountToAssertionIds[account.account.address].filter(
+    id => id !== assertionId,
+  );
+};
+
+const canPropose = (assertion: any, currentTimestamp: bigint) => {
+  const rangeOfSeconds = [10n, 20n, 30n, 40n, 50n, 60n, 70n, 80n, 90n, 100n];
+  const randomSeconds = rangeOfSeconds[Math.floor(Math.random() * rangeOfSeconds.length)];
+  return assertion.proposer === zeroAddress && currentTimestamp > assertion.startTime + randomSeconds;
+};
+
+const createAssertions = async (
+  optimisticDeployment: Deployment,
+  optimisticOracle: OptimisticOracle,
+  otherAccounts: WalletClient[],
+  accountToAssertionIds: Record<string, bigint[]>,
+) => {
+  const minReward = ethers.parseEther("0.01");
+  let nextAssertionId = await optimisticOracle.nextAssertionId();
+
+  for (const account of otherAccounts) {
+    const assertionIds = accountToAssertionIds[account.account.address];
+    if (assertionIds.length === 0 && Math.random() < 0.5) {
+      await account.writeContract({
+        address: optimisticDeployment.address as `0x${string}`,
+        abi: optimisticDeployment.abi,
+        functionName: "assertEvent",
+        args: [getRandomQuestion(), 0n, 0n],
+        value: minReward + (1n * 10n ** 18n * BigInt(Math.floor(Math.random() * 100))) / 100n,
+      });
+      console.log(`✅ created assertion ${nextAssertionId}`);
+
+      // Track the assertion for 80% of cases; otherwise, leave it untracked so it will expire
+      if (Math.random() < 0.8) {
+        accountToAssertionIds[account.account.address].push(nextAssertionId);
+      }
+      nextAssertionId++;
+    }
+  }
+};
+
+const proposeAssertions = async (
+  trueResponder: WalletClient,
+  falseResponder: WalletClient,
+  randomResponder: WalletClient,
+  optimisticDeployment: Deployment,
+  optimisticOracle: OptimisticOracle,
+  currentTimestamp: bigint,
+  otherAccounts: WalletClient[],
+  accountToAssertionIds: Record<string, bigint[]>,
+) => {
+  for (const account of otherAccounts) {
+    const assertionIds = accountToAssertionIds[account.account.address];
+    if (assertionIds.length !== 0) {
+      for (const assertionId of assertionIds) {
+        const assertion = await optimisticOracle.assertions(assertionId);
+        if (canPropose(assertion, currentTimestamp)) {
+          const randomness = Math.random();
+          if (randomness < 0.25) {
+            await trueResponder.writeContract({
+              address: optimisticDeployment.address as `0x${string}`,
+              abi: optimisticDeployment.abi,
+              functionName: "proposeOutcome",
+              args: [assertionId, true],
+              value: assertion.bond,
+            });
+            console.log(`✅ proposed outcome=true for assertion ${assertionId}`);
+          } else if (randomness < 0.5) {
+            await falseResponder.writeContract({
+              address: optimisticDeployment.address as `0x${string}`,
+              abi: optimisticDeployment.abi,
+              functionName: "proposeOutcome",
+              args: [assertionId, false],
+              value: assertion.bond,
+            });
+            console.log(`❌ proposed outcome=false for assertion ${assertionId} `);
+          } else if (randomness < 0.9) {
+            const outcome = Math.random() < 0.5;
+            await randomResponder.writeContract({
+              address: optimisticDeployment.address as `0x${string}`,
+              abi: optimisticDeployment.abi,
+              functionName: "proposeOutcome",
+              args: [assertionId, outcome],
+              value: assertion.bond,
+            });
+            console.log(`${outcome ? "✅" : "❌"} proposed outcome=${outcome} for assertion ${assertionId}`);
+            // if randomly wallet proposed, then remove the assertion from the account (No need to track and dispute)
+            stopTrackingAssertion(accountToAssertionIds, account, assertionId);
+          }
+        }
+      }
+    }
+  }
+};
+
+const disputeAssertions = async (
+  trueResponder: WalletClient,
+  falseResponder: WalletClient,
+  optimisticDeployment: Deployment,
+  optimisticOracle: OptimisticOracle,
+  currentTimestamp: bigint,
+  accountToAssertionIds: Record<string, bigint[]>,
+  otherAccounts: WalletClient[],
+) => {
+  for (const account of otherAccounts) {
+    const assertionIds = accountToAssertionIds[account.account.address];
+    for (const assertionId of assertionIds) {
+      const assertion = await optimisticOracle.assertions(assertionId);
+      if (
+        assertion.proposer.toLowerCase() === trueResponder.account.address.toLowerCase() &&
+        isHalfTimePassed(assertion, currentTimestamp)
+      ) {
+        await falseResponder.writeContract({
+          address: optimisticDeployment.address as `0x${string}`,
+          abi: optimisticDeployment.abi,
+          functionName: "disputeOutcome",
+          args: [assertionId],
+          value: assertion.bond,
+        });
+        console.log(`⚔️ disputed assertion ${assertionId}`);
+        // if disputed, then remove the assertion from the account
+        stopTrackingAssertion(accountToAssertionIds, account, assertionId);
+      } else if (
+        assertion.proposer.toLowerCase() === falseResponder.account.address.toLowerCase() &&
+        isHalfTimePassed(assertion, currentTimestamp)
+      ) {
+        await trueResponder.writeContract({
+          address: optimisticDeployment.address as `0x${string}`,
+          abi: optimisticDeployment.abi,
+          functionName: "disputeOutcome",
+          args: [assertionId],
+          value: assertion.bond,
+        });
+        console.log(`⚔️ disputed assertion ${assertionId}`);
+        // if disputed, then remove the assertion from the account
+        stopTrackingAssertion(accountToAssertionIds, account, assertionId);
+      }
+    }
+  }
+};
+
+let currentAction = 0;
+
+const runCycle = async (
+  hre: HardhatRuntimeEnvironment,
+  accountToAssertionIds: Record<string, bigint[]>,
+  accounts: WalletClient[],
+) => {
+  try {
+    const trueResponder = accounts[0];
+    const falseResponder = accounts[1];
+    const randomResponder = accounts[2];
+    const otherAccounts = accounts.slice(3);
+
+    const optimisticDeployment = await deployments.get("OptimisticOracle");
+    const optimisticOracle = await ethers.getContractAt("OptimisticOracle", optimisticDeployment.address);
+    const publicClient = await hre.viem.getPublicClient();
+
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
+
+    // get current timestamp
+    const latestBlock = await publicClient.getBlock();
+    const currentTimestamp = latestBlock.timestamp;
+    // also track thex of the account start from the third account
+    if (currentAction === 0) {
+      console.log(`\n📝 === CREATING ASSERTIONS PHASE ===`);
+      await createAssertions(optimisticDeployment, optimisticOracle, otherAccounts, accountToAssertionIds);
+    } else if (currentAction === 1) {
+      console.log(`\n🎯 === PROPOSING OUTCOMES PHASE ===`);
+      await proposeAssertions(
+        trueResponder,
+        falseResponder,
+        randomResponder,
+        optimisticDeployment,
+        optimisticOracle,
+        currentTimestamp,
+        otherAccounts,
+        accountToAssertionIds,
+      );
+    } else if (currentAction === 2) {
+      console.log(`\n⚔️ === DISPUTING ASSERTIONS PHASE ===`);
+      await disputeAssertions(
+        trueResponder,
+        falseResponder,
+        optimisticDeployment,
+        optimisticOracle,
+        currentTimestamp,
+        accountToAssertionIds,
+        otherAccounts,
+      );
+    }
+    currentAction = (currentAction + 1) % 3;
+    await publicClient.transport.request({ method: "evm_mine" });
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
+  } catch (error) {
+    console.error("Error in oracle cycle:", error);
+    throw error;
+  }
+};
+
+async function run() {
+  console.log("Starting optimistic oracle bots...");
+  const accountToAssertionIds: Record<string, bigint[]> = {};
+
+  const accounts = (await hre.viem.getWalletClients()).slice(0, 8);
+  for (const account of accounts) {
+    accountToAssertionIds[account.account.address] = [];
+  }
+  while (true) {
+    await runCycle(hre, accountToAssertionIds, accounts);
+    await sleep(3000);
+  }
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});
+
+// Handle process termination signals
+process.on("SIGINT", async () => {
+  console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  console.log("\nReceived SIGTERM. Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+// Handle uncaught exceptions
+process.on("uncaughtException", async error => {
+  console.error("Uncaught Exception:", error);
+  await cleanup();
+  process.exit(1);
+});
+
+// Handle unhandled promise rejections
+process.on("unhandledRejection", async (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+  await cleanup();
+  process.exit(1);
+});
diff --git a/extension/packages/hardhat/scripts/runOracleBots.ts b/extension/packages/hardhat/scripts/runOracleBots.ts
new file mode 100644
index 00000000..8be48b1b
--- /dev/null
+++ b/extension/packages/hardhat/scripts/runOracleBots.ts
@@ -0,0 +1,64 @@
+import { reportPrices } from "./oracle-bot/reporting";
+import { claimRewards, validateNodes } from "./oracle-bot/validation";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import hre from "hardhat";
+import { cleanup, sleep } from "./utils";
+
+const runCycle = async (hre: HardhatRuntimeEnvironment) => {
+  try {
+    const publicClient = await hre.viem.getPublicClient();
+    const blockNumber = await publicClient.getBlockNumber();
+    console.log(`\n[Block ${blockNumber}] Starting new oracle cycle...`);
+
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
+    await reportPrices(hre);
+    await publicClient.transport.request({ method: "evm_mine" });
+
+    await validateNodes(hre);
+    await claimRewards(hre);
+    await publicClient.transport.request({ method: "evm_mine" });
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
+  } catch (error) {
+    console.error("Error in oracle cycle:", error);
+  }
+};
+
+const run = async () => {
+  console.log("Starting oracle bot system...");
+  while (true) {
+    await runCycle(hre);
+    await sleep(3000);
+  }
+};
+
+run().catch(error => {
+  console.error("Fatal error in oracle bot system:", error);
+  process.exit(1);
+});
+
+// Handle process termination signals
+process.on("SIGINT", async () => {
+  console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  console.log("\nReceived SIGTERM. Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+// Handle uncaught exceptions
+process.on("uncaughtException", async error => {
+  console.error("Uncaught Exception:", error);
+  await cleanup();
+  process.exit(1);
+});
+
+// Handle unhandled promise rejections
+process.on("unhandledRejection", async (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+  await cleanup();
+  process.exit(1);
+});
diff --git a/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts b/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
new file mode 100644
index 00000000..57df43b0
--- /dev/null
+++ b/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
@@ -0,0 +1,120 @@
+import { ethers } from "hardhat";
+import { WhitelistOracle } from "../typechain-types";
+import hre from "hardhat";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { fetchPriceFromUniswap } from "./fetchPriceFromUniswap";
+import { cleanup, sleep } from "./utils";
+
+async function getAllOracles() {
+  const [deployer] = await ethers.getSigners();
+  const whitelistContract = await ethers.getContract<WhitelistOracle>("WhitelistOracle", deployer.address);
+
+  const oracleAddresses = [];
+  let index = 0;
+
+  try {
+    while (true) {
+      const oracle = await whitelistContract.oracles(index);
+      oracleAddresses.push(oracle);
+      index++;
+    }
+  } catch {
+    // When we hit an out-of-bounds error, we've found all oracles
+    console.log(`Found ${oracleAddresses.length} oracles`);
+  }
+
+  return oracleAddresses;
+}
+
+function getRandomPrice(basePrice: bigint): bigint {
+  const percentageShifts = [1, 2, 5, 7, 10, 15, 20];
+  const randomIndex = Math.floor(Math.random() * percentageShifts.length);
+  const percentage = BigInt(percentageShifts[randomIndex]);
+
+  const direction = Math.random() < 0.5 ? -1n : 1n;
+  const offset = (basePrice * percentage * direction) / 100n;
+
+  return basePrice + offset;
+}
+
+const runCycle = async (hre: HardhatRuntimeEnvironment, basePrice: bigint) => {
+  try {
+    const accounts = await hre.viem.getWalletClients();
+    const simpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const publicClient = await hre.viem.getPublicClient();
+
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
+    const blockNumber = await publicClient.getBlockNumber();
+    console.log(`\n[Block ${blockNumber}] Starting new whitelist oracle cycle...`);
+    const oracleAddresses = await getAllOracles();
+    if (oracleAddresses.length === 0) {
+      console.log("No oracles found");
+      return;
+    }
+
+    for (const oracleAddress of oracleAddresses) {
+      if (Math.random() < 0.4) {
+        console.log(`Skipping oracle at ${oracleAddress}`);
+        continue;
+      }
+
+      const randomPrice = getRandomPrice(basePrice);
+      console.log(`Setting price for oracle at ${oracleAddress} to ${randomPrice}`);
+
+      await accounts[0].writeContract({
+        address: oracleAddress as `0x${string}`,
+        abi: simpleOracleFactory.interface.fragments,
+        functionName: "setPrice",
+        args: [randomPrice],
+      });
+    }
+
+    await publicClient.transport.request({ method: "evm_mine" });
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
+  } catch (error) {
+    console.error("Error in oracle cycle:", error);
+    throw error;
+  }
+};
+
+async function run() {
+  console.log("Starting whitelist oracle bots...");
+  const basePrice = await fetchPriceFromUniswap();
+
+  while (true) {
+    await runCycle(hre, basePrice);
+    await sleep(4000);
+  }
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});
+
+// Handle process termination signals
+process.on("SIGINT", async () => {
+  console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  console.log("\nReceived SIGTERM. Cleaning up...");
+  await cleanup();
+  process.exit(0);
+});
+
+// Handle uncaught exceptions
+process.on("uncaughtException", async error => {
+  console.error("Uncaught Exception:", error);
+  await cleanup();
+  process.exit(1);
+});
+
+// Handle unhandled promise rejections
+process.on("unhandledRejection", async (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+  await cleanup();
+  process.exit(1);
+});
diff --git a/extension/packages/hardhat/scripts/utils.ts b/extension/packages/hardhat/scripts/utils.ts
new file mode 100644
index 00000000..27b9a322
--- /dev/null
+++ b/extension/packages/hardhat/scripts/utils.ts
@@ -0,0 +1,114 @@
+import { Config } from "./oracle-bot/types";
+import fs from "fs";
+import path from "path";
+import hre from "hardhat";
+
+const getConfigPath = (): string => {
+  return path.join(__dirname, "oracle-bot", "config.json");
+};
+
+export const getConfig = (): Config => {
+  const configPath = getConfigPath();
+  const configContent = fs.readFileSync(configPath, "utf-8");
+  const config = JSON.parse(configContent) as Config;
+  return config;
+};
+
+export const updateConfig = (updates: Partial<Config>): void => {
+  const configPath = getConfigPath();
+  const currentConfig = getConfig();
+  const updatedConfig = { ...currentConfig, ...updates };
+  fs.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
+};
+
+export const updatePriceCache = (price: number, timestamp: number): void => {
+  updateConfig({
+    PRICE: {
+      CACHEDPRICE: price,
+      TIMESTAMP: timestamp,
+    },
+  });
+};
+
+export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+// Cleanup function to ensure automining is turned back on
+export async function cleanup() {
+  try {
+    const publicClient = await hre.viem.getPublicClient();
+    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
+    console.log("\nCleaning up: turning automining back on...");
+  } catch (error) {
+    console.error("Error cleaning up:", error);
+  }
+}
+
+export const QUESTIONS_FOR_OO: string[] = [
+  "Did ETH/USD exceed $3,000 at 00:00 UTC on {MONTH} {DAY}, {YEAR}?",
+  "Did the BTC/ETH ratio fall below 14 on {MONTH} {DAY}, {YEAR}?",
+  "Did Uniswap's TVL exceed $10B on {MONTH} {DAY}, {YEAR}?",
+  "Did the Ethereum Cancun upgrade activate before {MONTH} {DAY}, {YEAR}?",
+  "Did the average gas price on Ethereum exceed 200 gwei on {MONTH} {DAY}, {YEAR}?",
+  "Did Ethereum's staking participation rate exceed 25% on {MONTH} {DAY}, {YEAR}?",
+  "Did Base chain have more than 1M daily transactions on {MONTH} {DAY}, {YEAR}?",
+  "Did the SEC approve a Bitcoin ETF before {MONTH} {DAY}, {YEAR}?",
+  "Did OpenSea's trading volume exceed $500M in {MONTH} {YEAR}?",
+  "Did Farcaster have more than 10K active users on {MONTH} {DAY}, {YEAR}?",
+  "Did ENS domains exceed 5M total registrations before {MONTH} {YEAR}?",
+  "Did the total bridged USDC on Arbitrum exceed $2B on {MONTH} {DAY}, {YEAR}?",
+  "Did Optimism's native token OP increase above $1.50 on {MONTH} {DAY}, {YEAR}?",
+  "Did Aave v3 have higher borrow volume than v2 on {MONTH} {DAY}, {YEAR}?",
+  "Did Compound see more than 1,000 liquidations on {MONTH} {DAY}, {YEAR}?",
+  "Did BTC's 24-hour volume exceed $50B on {MONTH} {DAY}, {YEAR}?",
+  "Did Real Madrid win the UEFA Champions League Final in {YEAR}?",
+  "Did G2 Esports win a major tournament in {MONTH} {YEAR}?",
+  "Did the temperature in New York exceed 35°C on {MONTH} {DAY}, {YEAR}?",
+  "Did it rain more than 50mm in London on {MONTH} {DAY}, {YEAR}?",
+  "Did Tokyo experience an earthquake of magnitude 5.0 or higher in {MONTH} {YEAR}?",
+  "Did the Nasdaq Composite fall more than 3% on {MONTH} {DAY}, {YEAR}?",
+  "Did the S&P 500 set a new all-time high on {MONTH} {DAY}, {YEAR}?",
+  "Did the US unemployment rate drop below 4% in {MONTH} {YEAR}?",
+  "Did the average global temperature for {MONTH} {YEAR} exceed that of the previous year?",
+  "Did gold price exceed $2,200/oz on {MONTH} {DAY}, {YEAR}?",
+  "Did YouTube's most viewed video gain more than 10M new views in {MONTH} {YEAR}?",
+  "Did the population of India officially surpass China according to the UN in {YEAR}?",
+  "Did the UEFA Euro 2024 Final have more than 80,000 attendees in the stadium?",
+  "Did a pigeon successfully complete a 500km race in under 10 hours in {MONTH} {YEAR}?",
+  "Did a goat attend a university graduation ceremony wearing a cap and gown on {MONTH} {DAY}, {YEAR}?",
+  "Did someone eat 100 chicken nuggets in under 10 minutes on {MONTH} {DAY}, {YEAR}?",
+  "Did a cat walk across a live TV weather report in {MONTH} {YEAR}?",
+  "Did a cow escape from a farm and get caught on camera riding a water slide in {YEAR}?",
+  "Did a man legally change his name to 'Bitcoin McMoneyface' on {MONTH} {DAY}, {YEAR}?",
+  "Did a squirrel steal a GoPro and film itself on {MONTH} {DAY}, {YEAR}?",
+  "Did someone cosplay as Shrek and complete a full marathon on {MONTH} {DAY}, {YEAR}?",
+  "Did a group of people attempt to cook the world's largest pancake using a flamethrower?",
+  "Did a man propose using a pizza drone delivery on {MONTH} {DAY}, {YEAR}?",
+  "Did a woman knit a sweater large enough to cover a school bus in {MONTH} {YEAR}?",
+  "Did someone attempt to break the world record for most dad jokes told in 1 hour?",
+  "Did an alpaca accidentally join a Zoom meeting for a tech startup on {MONTH} {DAY}, {YEAR}?",
+];
+
+const generateRandomPastDate = (now: Date): Date => {
+  const daysBack = Math.floor(Math.random() * 45) + 1; // 1 - 45 days
+
+  const pastDate = new Date(now);
+  pastDate.setDate(pastDate.getDate() - daysBack);
+
+  return pastDate;
+};
+
+const replaceDatePlaceholders = (question: string): string => {
+  const now = new Date();
+  const past = generateRandomPastDate(now);
+
+  return question
+    .replace(/\{DAY\}/g, past.getDate().toString())
+    .replace(/\{MONTH\}/g, past.toLocaleDateString("en-US", { month: "long" }))
+    .replace(/\{YEAR\}/g, past.getFullYear().toString());
+};
+
+export const getRandomQuestion = (): string => {
+  const randomIndex = Math.floor(Math.random() * QUESTIONS_FOR_OO.length);
+  const question = QUESTIONS_FOR_OO[randomIndex];
+  return replaceDatePlaceholders(question);
+};
diff --git a/extension/packages/hardhat/test/OptimisticOracle.ts b/extension/packages/hardhat/test/OptimisticOracle.ts
new file mode 100644
index 00000000..88703b55
--- /dev/null
+++ b/extension/packages/hardhat/test/OptimisticOracle.ts
@@ -0,0 +1,634 @@
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import { OptimisticOracle, Decider } from "../typechain-types";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+
+describe("OptimisticOracle", function () {
+  let optimisticOracle: OptimisticOracle;
+  let deciderContract: Decider;
+  let owner: HardhatEthersSigner;
+  let asserter: HardhatEthersSigner;
+  let proposer: HardhatEthersSigner;
+  let disputer: HardhatEthersSigner;
+  let otherUser: HardhatEthersSigner;
+
+  // Enum for state
+  const State = {
+    Invalid: 0n,
+    Asserted: 1n,
+    Proposed: 2n,
+    Disputed: 3n,
+    Settled: 4n,
+    Expired: 5n,
+  };
+
+  beforeEach(async function () {
+    [owner, asserter, proposer, disputer, otherUser] = await ethers.getSigners();
+
+    // Deploy OptimisticOracle with temporary decider (owner)
+    const OptimisticOracleFactory = await ethers.getContractFactory("OptimisticOracle");
+    optimisticOracle = await OptimisticOracleFactory.deploy(owner.address);
+
+    // Deploy Decider
+    const DeciderFactory = await ethers.getContractFactory("Decider");
+    deciderContract = await DeciderFactory.deploy(optimisticOracle.target);
+
+    // Set the decider in the oracle
+    await optimisticOracle.setDecider(deciderContract.target);
+  });
+
+  describe("Deployment", function () {
+    it("Should deploy successfully", function () {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      expect(optimisticOracle.target).to.not.be.undefined;
+    });
+
+    it("Should set the correct owner", async function () {
+      const contractOwner = await optimisticOracle.owner();
+      expect(contractOwner).to.equal(owner.address);
+    });
+
+    it("Should have correct constants", async function () {
+      const minimumAssertionWindow = await optimisticOracle.MINIMUM_ASSERTION_WINDOW();
+      const minimumDisputeWindow = await optimisticOracle.MINIMUM_DISPUTE_WINDOW();
+
+      expect(minimumAssertionWindow).to.equal(180n); // 3 minutes
+      expect(minimumDisputeWindow).to.equal(180n); // 3 minutes
+    });
+
+    it("Should start with nextAssertionId at 1", async function () {
+      const nextAssertionId = await optimisticOracle.nextAssertionId();
+      expect(nextAssertionId).to.equal(1n);
+    });
+
+    it("Should return correct assertionId for first assertion", async function () {
+      const description = "Will Bitcoin reach $1m by end of 2026?";
+      const reward = ethers.parseEther("1");
+
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      // Get the assertionId from the event
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      const assertionId = parsedEvent!.args[0];
+
+      expect(assertionId).to.equal(1n);
+    });
+  });
+
+  describe("Event Assertion", function () {
+    it("Should allow users to assert events with reward", async function () {
+      const description = "Will Bitcoin reach $1m by end of 2026?";
+      const reward = ethers.parseEther("1");
+
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+
+      // Get the assertionId from the event
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      const assertionId = parsedEvent!.args[0];
+
+      expect(tx)
+        .to.emit(optimisticOracle, "EventAsserted")
+        .withArgs(assertionId, asserter.address, description, reward);
+
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Asserted); // Asserted state
+    });
+
+    it("Should reject assertions with insufficient reward", async function () {
+      const description = "Will Bitcoin reach $1m by end of 2026?";
+      const insufficientReward = ethers.parseEther("0.0");
+
+      await expect(
+        optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: insufficientReward }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+    });
+  });
+
+  describe("Outcome Proposal", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      // Get the assertionId from the event
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+    });
+
+    it("Should allow proposing outcomes with correct bond", async function () {
+      const bond = reward * 2n;
+      const outcome = true;
+
+      const tx = await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
+
+      expect(tx).to.emit(optimisticOracle, "OutcomeProposed").withArgs(assertionId, proposer.address, outcome);
+
+      // Check that the proposal was recorded by checking the state
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Proposed); // Proposed state
+    });
+
+    it("Should reject proposals with incorrect bond", async function () {
+      const wrongBond = ethers.parseEther("0.05");
+      const outcome = true;
+
+      await expect(
+        optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: wrongBond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+    });
+
+    it("Should reject duplicate proposals", async function () {
+      const bond = reward * 2n;
+      const outcome = true;
+
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
+
+      await expect(
+        optimisticOracle.connect(otherUser).proposeOutcome(assertionId, !outcome, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "AssertionProposed");
+    });
+  });
+
+  describe("Outcome Dispute", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+    });
+
+    it("Should allow disputing outcomes with correct bond", async function () {
+      const bond = reward * 2n;
+
+      const tx = await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+      expect(tx).to.emit(optimisticOracle, "OutcomeDisputed").withArgs(assertionId, disputer.address);
+
+      // Check that the dispute was recorded by checking the state
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Disputed); // Disputed state
+    });
+
+    it("Should reject disputes with incorrect bond", async function () {
+      const wrongBond = ethers.parseEther("0.05");
+
+      await expect(
+        optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: wrongBond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+    });
+
+    it("Should reject disputes after deadline", async function () {
+      // Fast forward time past dispute window
+      await ethers.provider.send("evm_increaseTime", [181]); // 3 minutes + 1 second
+      await ethers.provider.send("evm_mine");
+
+      const bond = reward * 2n;
+      await expect(
+        optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+    });
+
+    it("Should reject duplicate disputes", async function () {
+      const bond = reward * 2n;
+      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+      await expect(
+        optimisticOracle.connect(otherUser).disputeOutcome(assertionId, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "ProposalDisputed");
+    });
+  });
+
+  describe("Undisputed Reward Claiming", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+    });
+
+    it("Should allow claiming undisputed rewards after deadline", async function () {
+      // Fast forward time past dispute window
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+
+      const initialBalance = await ethers.provider.getBalance(proposer.address);
+      const tx = await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
+      const receipt = await tx.wait();
+      const finalBalance = await ethers.provider.getBalance(proposer.address);
+
+      // Check that proposer received the reward (reward + bond - gas costs)
+      const expectedReward = reward + reward * 2n;
+      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+    });
+
+    it("Should reject claiming before deadline", async function () {
+      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "InvalidTime",
+      );
+    });
+
+    it("Should reject claiming disputed assertions", async function () {
+      const bond = reward * 2n;
+      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "ProposalDisputed",
+      );
+    });
+
+    it("Should reject claiming already claimed rewards", async function () {
+      // Fast forward time and claim
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+      await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
+
+      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "AlreadyClaimed",
+      );
+    });
+  });
+
+  describe("Disputed Reward Claiming", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+    });
+
+    it("Should allow winner to claim disputed rewards after settlement", async function () {
+      // Settle with proposer winning
+      await deciderContract.connect(owner).settleDispute(assertionId, true);
+
+      const initialBalance = await ethers.provider.getBalance(proposer.address);
+      const tx = await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
+      const receipt = await tx.wait();
+      const finalBalance = await ethers.provider.getBalance(proposer.address);
+
+      // Check that proposer received the reward (reward + bond - gas costs)
+      const expectedReward = reward * 3n;
+      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+    });
+
+    it("Should allow disputer to claim when they win", async function () {
+      // Settle with disputer winning
+      await deciderContract.connect(owner).settleDispute(assertionId, false);
+
+      const initialBalance = await ethers.provider.getBalance(disputer.address);
+      const tx = await optimisticOracle.connect(disputer).claimDisputedReward(assertionId);
+      const receipt = await tx.wait();
+      const finalBalance = await ethers.provider.getBalance(disputer.address);
+
+      // Check that disputer received the reward
+      const expectedReward = reward * 3n;
+      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+    });
+
+    it("Should reject claiming before settlement", async function () {
+      await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "AwaitingDecider",
+      );
+    });
+
+    it("Should reject claiming already claimed rewards", async function () {
+      await deciderContract.connect(owner).settleDispute(assertionId, true);
+      await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
+
+      await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "AlreadyClaimed",
+      );
+    });
+  });
+
+  describe("Refund Claiming", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+    });
+
+    it("Should allow asserter to claim refund for assertions without proposals", async function () {
+      // Fast forward time past dispute window
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+
+      const initialBalance = await ethers.provider.getBalance(asserter.address);
+      const tx = await optimisticOracle.connect(asserter).claimRefund(assertionId);
+      const receipt = await tx.wait();
+      const finalBalance = await ethers.provider.getBalance(asserter.address);
+
+      // Check that asserter received the refund (reward - gas costs)
+      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+      expect(finalBalance - initialBalance + gasCost).to.equal(reward);
+    });
+
+    it("Should reject refund claiming for assertions with proposals", async function () {
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+
+      await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "AssertionProposed",
+      );
+    });
+
+    it("Should reject claiming already claimed refunds", async function () {
+      // Fast forward time and claim
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+      await optimisticOracle.connect(asserter).claimRefund(assertionId);
+
+      await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
+        optimisticOracle,
+        "AlreadyClaimed",
+      );
+    });
+  });
+
+  describe("Dispute Settlement", function () {
+    let assertionId: bigint;
+    let description: string;
+    let reward: bigint;
+
+    beforeEach(async function () {
+      description = "Will Bitcoin reach $1m by end of 2026?";
+      reward = ethers.parseEther("1");
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      assertionId = parsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+    });
+
+    it("Should allow decider to settle disputed assertions", async function () {
+      const resolvedOutcome = true;
+      const tx = await deciderContract.connect(owner).settleDispute(assertionId, resolvedOutcome);
+
+      expect(tx).to.emit(optimisticOracle, "AssertionSettled").withArgs(assertionId, resolvedOutcome, proposer.address);
+
+      // Check that the assertion was settled correctly by checking the state
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Settled); // Settled state
+    });
+
+    it("Should reject settlement by non-decider", async function () {
+      const resolvedOutcome = true;
+
+      await expect(
+        optimisticOracle.connect(otherUser).settleAssertion(assertionId, resolvedOutcome),
+      ).to.be.revertedWithCustomError(optimisticOracle, "OnlyDecider");
+    });
+
+    it("Should reject settling undisputed assertions", async function () {
+      // Create a new undisputed assertion
+      const newDescription = "Will Ethereum reach $10k by end of 2024?";
+      const newTx = await optimisticOracle.connect(asserter).assertEvent(newDescription, 0, 0, { value: reward });
+      const newReceipt = await newTx.wait();
+      const newEvent = newReceipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const newParsedEvent = optimisticOracle.interface.parseLog(newEvent as any);
+      const newAssertionId = newParsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(newAssertionId, true, { value: bond });
+
+      const resolvedOutcome = true;
+      await expect(
+        deciderContract.connect(owner).settleDispute(newAssertionId, resolvedOutcome),
+      ).to.be.revertedWithCustomError(optimisticOracle, "NotDisputedAssertion");
+    });
+  });
+
+  describe("State Management", function () {
+    it("Should return correct states for different scenarios", async function () {
+      const description = "Will Bitcoin reach $1m by end of 2026?";
+      const reward = ethers.parseEther("1");
+
+      // Invalid state for non-existent assertion
+      let state = await optimisticOracle.getState(999n);
+      expect(state).to.equal(State.Invalid); // Invalid
+
+      // Asserted state
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      const assertionId = parsedEvent!.args[0];
+
+      state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Asserted); // Asserted
+
+      // Proposed state
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Proposed); // Proposed
+
+      // Disputed state
+      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+      state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Disputed); // Disputed
+
+      // Settled state (after decider resolution)
+      await deciderContract.connect(owner).settleDispute(assertionId, true);
+      state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Settled); // Settled
+    });
+
+    it("Should show settled state for claimable uncontested assertions", async function () {
+      const description = "Will Ethereum reach $10k by end of 2024?";
+      const reward = ethers.parseEther("1");
+
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      const assertionId = parsedEvent!.args[0];
+
+      const bond = reward * 2n;
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+
+      // Fast forward time past dispute window
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Settled); // Settled (can be claimed)
+    });
+
+    it("Should show expired state for assertions without proposals after deadline", async function () {
+      const description = "Will Ethereum reach $10k by end of 2024?";
+      const reward = ethers.parseEther("1");
+
+      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      const assertionId = parsedEvent!.args[0];
+
+      // Fast forward time past dispute window without any proposal
+      await ethers.provider.send("evm_increaseTime", [181]);
+      await ethers.provider.send("evm_mine");
+
+      const state = await optimisticOracle.getState(assertionId);
+      expect(state).to.equal(State.Expired); // Expired
+    });
+  });
+
+  describe("Start and End Time Logic", function () {
+    it("Should not allow proposal before startTime", async function () {
+      const reward = ethers.parseEther("1");
+      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+      const start = now + 1000;
+      const end = start + 1000;
+      const tx = await optimisticOracle.connect(asserter).assertEvent("future event", start, end, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      if (!parsedEvent) throw new Error("Event not found");
+      const assertionId = parsedEvent.args[0];
+
+      const bond = reward * 2n;
+      await expect(
+        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+    });
+
+    it("Should not allow proposal after endTime", async function () {
+      const reward = ethers.parseEther("1");
+      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+      const start = now + 1; // Start time must be in the future
+      const end = now + 200; // 200 seconds, which is more than MINIMUM_DISPUTE_WINDOW (180 seconds)
+      const tx = await optimisticOracle.connect(asserter).assertEvent("short event", start, end, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      if (!parsedEvent) throw new Error("Event not found");
+      const assertionId = parsedEvent.args[0];
+
+      // Wait until after endTime
+      await ethers.provider.send("evm_increaseTime", [201]);
+      await ethers.provider.send("evm_mine");
+
+      const bond = reward * 2n;
+      await expect(
+        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+    });
+
+    it("Should allow proposal only within [startTime, endTime]", async function () {
+      const reward = ethers.parseEther("1");
+      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+      const start = now + 10; // Start time in the future
+      const end = start + 200; // Ensure endTime is far enough in the future
+      const tx = await optimisticOracle.connect(asserter).assertEvent("window event", start, end, { value: reward });
+      const receipt = await tx.wait();
+      const event = receipt!.logs.find(
+        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+      );
+      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+      if (!parsedEvent) throw new Error("Event not found");
+      const assertionId = parsedEvent.args[0];
+
+      const bond = reward * 2n;
+
+      // Before startTime - should fail
+      await expect(
+        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+
+      // Move to startTime
+      await ethers.provider.send("evm_increaseTime", [10]);
+      await ethers.provider.send("evm_mine");
+
+      // Now it should work
+      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+    });
+  });
+});
diff --git a/extension/packages/nextjs/app/api/config/price-variance/route.ts b/extension/packages/nextjs/app/api/config/price-variance/route.ts
new file mode 100644
index 00000000..334704a3
--- /dev/null
+++ b/extension/packages/nextjs/app/api/config/price-variance/route.ts
@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const CONFIG_PATH = path.join(process.cwd(), "..", "hardhat", "scripts", "oracle-bot", "config.json");
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { value, nodeAddress } = body;
+
+    if (typeof value !== "number" || value < 0) {
+      return NextResponse.json({ error: "Value must be a non-negative number" }, { status: 400 });
+    }
+
+    // Read current config
+    const configContent = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(configContent);
+
+    // Update node-specific config
+    if (!config.NODE_CONFIGS[nodeAddress]) {
+      config.NODE_CONFIGS[nodeAddress] = { ...config.NODE_CONFIGS.default };
+    }
+    config.NODE_CONFIGS[nodeAddress].PRICE_VARIANCE = value;
+
+    // Write back to file
+    await fs.promises.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+    return NextResponse.json({ success: true, value });
+  } catch (error) {
+    console.error("Error updating price variance:", error);
+    return NextResponse.json({ error: "Failed to update configuration" }, { status: 500 });
+  }
+}
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const nodeAddress = searchParams.get("nodeAddress");
+
+    if (!nodeAddress) {
+      return NextResponse.json({ error: "nodeAddress parameter is required" }, { status: 400 });
+    }
+
+    const configContent = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(configContent);
+    const nodeConfig = config.NODE_CONFIGS[nodeAddress] || config.NODE_CONFIGS.default;
+
+    return NextResponse.json({
+      value: nodeConfig.PRICE_VARIANCE,
+    });
+  } catch (error) {
+    console.error("Error reading price variance:", error);
+    return NextResponse.json({ error: "Failed to read configuration" }, { status: 500 });
+  }
+}
diff --git a/extension/packages/nextjs/app/api/config/skip-probability/route.ts b/extension/packages/nextjs/app/api/config/skip-probability/route.ts
new file mode 100644
index 00000000..11cbe044
--- /dev/null
+++ b/extension/packages/nextjs/app/api/config/skip-probability/route.ts
@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const CONFIG_PATH = path.join(process.cwd(), "..", "hardhat", "scripts", "oracle-bot", "config.json");
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { value, nodeAddress } = body;
+
+    if (typeof value !== "number" || value < 0 || value > 1) {
+      return NextResponse.json({ error: "Value must be a number between 0 and 1" }, { status: 400 });
+    }
+
+    // Read current config
+    const configContent = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(configContent);
+
+    // Update node-specific config
+    if (!config.NODE_CONFIGS[nodeAddress]) {
+      config.NODE_CONFIGS[nodeAddress] = { ...config.NODE_CONFIGS.default };
+    }
+    config.NODE_CONFIGS[nodeAddress].PROBABILITY_OF_SKIPPING_REPORT = value;
+
+    // Write back to file
+    await fs.promises.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+    return NextResponse.json({ success: true, value });
+  } catch (error) {
+    console.error("Error updating skip probability:", error);
+    return NextResponse.json({ error: "Failed to update configuration" }, { status: 500 });
+  }
+}
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const nodeAddress = searchParams.get("nodeAddress");
+
+    if (!nodeAddress) {
+      return NextResponse.json({ error: "nodeAddress parameter is required" }, { status: 400 });
+    }
+
+    const configContent = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(configContent);
+    const nodeConfig = config.NODE_CONFIGS[nodeAddress] || config.NODE_CONFIGS.default;
+
+    return NextResponse.json({
+      value: nodeConfig.PROBABILITY_OF_SKIPPING_REPORT,
+    });
+  } catch (error) {
+    console.error("Error reading skip probability:", error);
+    return NextResponse.json({ error: "Failed to read configuration" }, { status: 500 });
+  }
+}
diff --git a/extension/packages/nextjs/app/optimistic/page.tsx b/extension/packages/nextjs/app/optimistic/page.tsx
new file mode 100644
index 00000000..fadb869b
--- /dev/null
+++ b/extension/packages/nextjs/app/optimistic/page.tsx
@@ -0,0 +1,117 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import type { NextPage } from "next";
+import { useReadContracts } from "wagmi";
+import { AssertedTable } from "~~/components/oracle/optimistic/AssertedTable";
+import { AssertionModal } from "~~/components/oracle/optimistic/AssertionModal";
+import { DisputedTable } from "~~/components/oracle/optimistic/DisputedTable";
+import { ExpiredTable } from "~~/components/oracle/optimistic/ExpiredTable";
+import { ProposedTable } from "~~/components/oracle/optimistic/ProposedTable";
+import { SettledTable } from "~~/components/oracle/optimistic/SettledTable";
+import { SubmitAssertionButton } from "~~/components/oracle/optimistic/SubmitAssertionButton";
+import { useDeployedContractInfo, useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+// Loading spinner component
+const LoadingSpinner = () => (
+  <div className="flex justify-center items-center min-h-[400px]">
+    <div className="animate-spin rounded-full h-16 w-16 border-b-4 border-blue-500"></div>
+  </div>
+);
+
+const Home: NextPage = () => {
+  const setRefetchAssertionStates = useChallengeState(state => state.setRefetchAssertionStates);
+  const [isInitialLoading, setIsInitialLoading] = useState(true);
+
+  const { data: nextAssertionId, isLoading: isLoadingNextAssertionId } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "nextAssertionId",
+    query: {
+      placeholderData: (previousData: any) => previousData,
+    },
+  });
+
+  // get deployed contract address
+  const { data: deployedContractAddress, isLoading: isLoadingDeployedContract } = useDeployedContractInfo({
+    contractName: "OptimisticOracle",
+  });
+
+  // Create contracts array to get state for all assertions from 1 to nextAssertionId-1
+  const assertionContracts = nextAssertionId
+    ? Array.from({ length: Number(nextAssertionId) - 1 }, (_, i) => ({
+        address: deployedContractAddress?.address as `0x${string}`,
+        abi: deployedContractAddress?.abi,
+        functionName: "getState",
+        args: [BigInt(i + 1)],
+      })).filter(contract => contract.address && contract.abi)
+    : [];
+
+  const {
+    data: assertionStates,
+    refetch: refetchAssertionStates,
+    isLoading: isLoadingAssertionStates,
+  } = useReadContracts({
+    contracts: assertionContracts,
+    query: {
+      placeholderData: (previousData: any) => previousData,
+    },
+  });
+
+  // Set the refetch function in the global store
+  useEffect(() => {
+    if (refetchAssertionStates) {
+      setRefetchAssertionStates(refetchAssertionStates);
+    }
+  }, [refetchAssertionStates, setRefetchAssertionStates]);
+
+  // Map assertion IDs to their states and filter out expired ones (state 5)
+  const assertionStateMap =
+    nextAssertionId && assertionStates
+      ? Array.from({ length: Number(nextAssertionId) - 1 }, (_, i) => ({
+          assertionId: i + 1,
+          state: (assertionStates[i]?.result as number) || 0, // Default to 0 (Invalid) if no result
+        }))
+      : [];
+
+  // Track when initial loading is complete
+  const isFirstLoading =
+    isInitialLoading && (isLoadingNextAssertionId || isLoadingAssertionStates || isLoadingDeployedContract);
+
+  // Mark as initially loaded when all data is available
+  useEffect(() => {
+    if (isInitialLoading && !isLoadingNextAssertionId && !isLoadingDeployedContract && !isLoadingAssertionStates) {
+      setIsInitialLoading(false);
+    }
+  }, [isInitialLoading, isLoadingNextAssertionId, isLoadingDeployedContract, isLoadingAssertionStates]);
+
+  return (
+    <div className="container mx-auto px-8 py-8 max-w-screen-lg xl:max-w-screen-xl">
+      {/* Show loading spinner only during initial load */}
+      {isFirstLoading ? (
+        <LoadingSpinner />
+      ) : (
+        <>
+          {/* Submit Assertion Button with Modal */}
+          <SubmitAssertionButton />
+
+          {/* Tables */}
+          <h2 className="text-2xl font-bold my-4">Asserted</h2>
+          <AssertedTable assertions={assertionStateMap.filter(assertion => assertion.state === 1)} />
+          <h2 className="text-2xl font-bold mt-12 mb-4">Proposed</h2>
+          <ProposedTable assertions={assertionStateMap.filter(assertion => assertion.state === 2)} />
+          <h2 className="text-2xl font-bold mt-12 mb-4">Disputed</h2>
+          <DisputedTable assertions={assertionStateMap.filter(assertion => assertion.state === 3)} />
+          <h2 className="text-2xl font-bold mt-12 mb-4">Settled</h2>
+          <SettledTable assertions={assertionStateMap.filter(assertion => assertion.state === 4)} />
+          <h2 className="text-2xl font-bold mt-12 mb-4">Expired</h2>
+          <ExpiredTable assertions={assertionStateMap.filter(assertion => assertion.state === 5)} />
+        </>
+      )}
+
+      <AssertionModal />
+    </div>
+  );
+};
+
+export default Home;
diff --git a/extension/packages/nextjs/app/staking/page.tsx b/extension/packages/nextjs/app/staking/page.tsx
new file mode 100644
index 00000000..aff773a2
--- /dev/null
+++ b/extension/packages/nextjs/app/staking/page.tsx
@@ -0,0 +1,26 @@
+"use client";
+
+import type { NextPage } from "next";
+import { NodesTable } from "~~/components/oracle/NodesTable";
+import { PriceWidget } from "~~/components/oracle/PriceWidget";
+
+const Home: NextPage = () => {
+  return (
+    <>
+      <div className="flex items-center flex-col flex-grow pt-10">
+        <div className="px-5 w-full max-w-5xl mx-auto">
+          <div className="flex flex-col gap-8">
+            <div className="w-full">
+              <PriceWidget contractName="StakingOracle" />
+            </div>
+            <div className="w-full">
+              <NodesTable />
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default Home;
diff --git a/extension/packages/nextjs/app/whitelist/page.tsx b/extension/packages/nextjs/app/whitelist/page.tsx
new file mode 100644
index 00000000..601d594c
--- /dev/null
+++ b/extension/packages/nextjs/app/whitelist/page.tsx
@@ -0,0 +1,26 @@
+"use client";
+
+import type { NextPage } from "next";
+import { PriceWidget } from "~~/components/oracle/PriceWidget";
+import { WhitelistTable } from "~~/components/oracle/whitelist/WhitelistTable";
+
+const Home: NextPage = () => {
+  return (
+    <>
+      <div className="flex items-center flex-col flex-grow pt-10">
+        <div className="px-5 w-full max-w-5xl mx-auto">
+          <div className="flex flex-col gap-8">
+            <div className="w-full">
+              <PriceWidget contractName="WhitelistOracle" />
+            </div>
+            <div className="w-full">
+              <WhitelistTable />
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default Home;
diff --git a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
new file mode 100644
index 00000000..1e93f98e
--- /dev/null
+++ b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
@@ -0,0 +1,65 @@
+import { useEffect, useRef } from "react";
+import { parseEther } from "viem";
+import { hardhat } from "viem/chains";
+import { useAccount, usePublicClient, useWalletClient } from "wagmi";
+import { useTargetNetwork } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+// This component is used to monitor the block timestamp and trigger a transaction if the timestamp has not changed for 3 seconds
+export const MonitorAndTriggerTx = () => {
+  const publicClient = usePublicClient();
+  const { data: walletClient } = useWalletClient();
+  const { targetNetwork } = useTargetNetwork();
+  const isLocalNetwork = targetNetwork.id === hardhat.id;
+  const { connector } = useAccount();
+  const isBurnerWallet = connector?.id === "burnerWallet";
+
+  const prevTimestampRef = useRef<bigint | null>(null);
+  const currentTimestampRef = useRef<bigint | null>(null);
+
+  const { setTimestamp, refetchAssertionStates } = useChallengeState();
+
+  useEffect(() => {
+    if (!publicClient || !walletClient) return;
+
+    const pollBlock = async () => {
+      try {
+        const block = await publicClient.getBlock();
+        const newTimestamp = block.timestamp;
+
+        const prev = prevTimestampRef.current;
+        const current = currentTimestampRef.current;
+
+        if (prev && newTimestamp === prev) {
+          try {
+            if (isBurnerWallet && isLocalNetwork) {
+              await walletClient.sendTransaction({
+                to: walletClient.account.address,
+                value: parseEther("0.0000001"),
+              });
+            }
+          } catch (err) {
+            console.log("Failed to send tx");
+          }
+        }
+
+        // Update refs
+        prevTimestampRef.current = current;
+        currentTimestampRef.current = newTimestamp;
+        refetchAssertionStates();
+
+        // Also update current timestamp in Zustand store for global access
+        setTimestamp(newTimestamp);
+      } catch (err) {
+        console.log("Polling error");
+      }
+    };
+
+    const interval = setInterval(pollBlock, 3000);
+    pollBlock(); // Initial call
+
+    return () => clearInterval(interval);
+  }, [publicClient, walletClient, isLocalNetwork, isBurnerWallet, setTimestamp, refetchAssertionStates]);
+
+  return null;
+};
diff --git a/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
index fca30389..c30093df 100644
--- a/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
+++ b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
@@ -1 +1,9 @@
+// Reference the example args file: https://github.com/scaffold-eth/create-eth-extensions/blob/example/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
+
+// Default args:
+export const preContent = `import { MonitorAndTriggerTx } from "./MonitorAndTriggerTx";`;
 export const globalClassNames = "font-space-grotesk";
+export const extraProviders = {
+    "MonitorAndTriggerTx": {},
+};
+export const overrideProviders = {};
diff --git a/extension/packages/nextjs/components/TooltipInfo.tsx b/extension/packages/nextjs/components/TooltipInfo.tsx
new file mode 100644
index 00000000..cf033bc4
--- /dev/null
+++ b/extension/packages/nextjs/components/TooltipInfo.tsx
@@ -0,0 +1,33 @@
+import React from "react";
+import { QuestionMarkCircleIcon } from "@heroicons/react/24/outline";
+
+interface TooltipInfoProps {
+  top?: number;
+  right?: number;
+  infoText: string;
+  className?: string;
+}
+
+// Note: The relative positioning is required for the tooltip to work.
+const TooltipInfo: React.FC<TooltipInfoProps> = ({ top, right, infoText, className = "" }) => {
+  const baseClasses = "tooltip tooltip-secondary font-normal";
+  const tooltipClasses = className ? `${baseClasses} ${className}` : `${baseClasses} tooltip-right`;
+
+  if (top !== undefined && right !== undefined) {
+    return (
+      <span className="absolute z-10" style={{ top: `${top * 0.25}rem`, right: `${right * 0.25}rem` }}>
+        <div className={tooltipClasses} data-tip={infoText}>
+          <QuestionMarkCircleIcon className="h-5 w-5 m-1" />
+        </div>
+      </span>
+    );
+  }
+
+  return (
+    <div className={tooltipClasses} data-tip={infoText}>
+      <QuestionMarkCircleIcon className="h-5 w-5 m-1" />
+    </div>
+  );
+};
+
+export default TooltipInfo;
diff --git a/extension/packages/nextjs/components/oracle/ConfigSlider.tsx b/extension/packages/nextjs/components/oracle/ConfigSlider.tsx
new file mode 100644
index 00000000..7653fac9
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/ConfigSlider.tsx
@@ -0,0 +1,84 @@
+import { useEffect, useState } from "react";
+
+interface ConfigSliderProps {
+  nodeAddress: string;
+  endpoint: string;
+  label: string;
+}
+
+export const ConfigSlider = ({ nodeAddress, endpoint, label }: ConfigSliderProps) => {
+  const [value, setValue] = useState<number>(0.0);
+  const [isLoading, setIsLoading] = useState(false);
+  const [localValue, setLocalValue] = useState<number>(0.0);
+
+  // Fetch initial value
+  useEffect(() => {
+    const fetchValue = async () => {
+      try {
+        const response = await fetch(`/api/config/${endpoint}?nodeAddress=${nodeAddress}`);
+        const data = await response.json();
+        if (data.value !== undefined) {
+          setValue(data.value);
+          setLocalValue(data.value);
+        }
+      } catch (error) {
+        console.error(`Error fetching ${endpoint}:`, error);
+      }
+    };
+    fetchValue();
+  }, [nodeAddress, endpoint]);
+
+  const handleChange = (newValue: number) => {
+    setLocalValue(newValue);
+  };
+
+  const handleFinalChange = async () => {
+    if (localValue === value) return; // Don't send request if value hasn't changed
+
+    setIsLoading(true);
+    try {
+      const response = await fetch(`/api/config/${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ value: localValue, nodeAddress }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to update ${endpoint}`);
+      }
+      setValue(localValue); // Update the committed value after successful API call
+    } catch (error) {
+      console.error(`Error updating ${endpoint}:`, error);
+      setLocalValue(value); // Reset to last known good value on error
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <td className="relative">
+      <input
+        type="range"
+        min="0"
+        max="1"
+        step="0.01"
+        value={localValue}
+        onChange={e => handleChange(parseFloat(e.target.value))}
+        onMouseUp={handleFinalChange}
+        onTouchEnd={handleFinalChange}
+        className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer dark:bg-gray-700"
+      />
+      <div className="text-xs text-gray-500 dark:text-gray-400 mt-1 text-center">
+        {(localValue * 100).toFixed(0)}% {label}
+      </div>
+      {isLoading && (
+        <div className="absolute inset-0 bg-white/50 dark:bg-black/50 flex items-center justify-center">
+          <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-primary"></div>
+        </div>
+      )}
+    </td>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/EditableCell.tsx b/extension/packages/nextjs/components/oracle/EditableCell.tsx
new file mode 100644
index 00000000..05bb7292
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/EditableCell.tsx
@@ -0,0 +1,107 @@
+import { useEffect, useRef, useState } from "react";
+import { HighlightedCell } from "./HighlightedCell";
+import { parseEther } from "viem";
+import { useWriteContract } from "wagmi";
+import { PencilIcon } from "@heroicons/react/24/outline";
+import { SIMPLE_ORACLE_ABI } from "~~/utils/constants";
+import { notification } from "~~/utils/scaffold-eth";
+
+type EditableCellProps = {
+  value: string | number;
+  address: string;
+  highlightColor?: string;
+};
+
+export const EditableCell = ({ value, address, highlightColor = "" }: EditableCellProps) => {
+  const [isEditing, setIsEditing] = useState(false);
+  const [editValue, setEditValue] = useState(Number(value.toString()) || "");
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const { writeContractAsync } = useWriteContract();
+
+  // Update edit value when prop value changes
+  useEffect(() => {
+    if (!isEditing) {
+      setEditValue(Number(value.toString()) || "");
+    }
+  }, [value, isEditing]);
+
+  // Focus input when editing starts
+  useEffect(() => {
+    if (isEditing && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [isEditing]);
+
+  const handleSubmit = async () => {
+    const parsedValue = Number(editValue);
+
+    if (isNaN(parsedValue)) {
+      notification.error("Invalid number");
+      return;
+    }
+
+    try {
+      await writeContractAsync({
+        abi: SIMPLE_ORACLE_ABI,
+        address: address,
+        functionName: "setPrice",
+        args: [parseEther(parsedValue.toString())],
+      });
+      setIsEditing(false);
+    } catch (error) {
+      console.error("Submit failed:", error);
+    }
+  };
+
+  const handleCancel = () => {
+    setIsEditing(false);
+  };
+
+  const startEditing = () => {
+    setIsEditing(true);
+  };
+
+  return (
+    <HighlightedCell value={value} highlightColor={highlightColor} className={`w-[40%] max-w-[40%] overflow-hidden`}>
+      <div className="flex w-full items-start">
+        {/* 70% width for value display/editing */}
+        <div className="w-[70%]">
+          {isEditing ? (
+            <div className="relative px-1">
+              <input
+                ref={inputRef}
+                type={"text"}
+                value={editValue}
+                onChange={e => setEditValue(e.target.value)}
+                className="w-full text-sm bg-secondary rounded-md"
+              />
+            </div>
+          ) : (
+            <div className="flex items-center gap-2 h-full items-stretch">
+              {value}
+              <button className="px-2 text-sm bg-primary rounded" onClick={startEditing}>
+                <PencilIcon className="w-2.5 h-2.5" />
+              </button>
+            </div>
+          )}
+        </div>
+
+        {/* 30% width for action buttons */}
+        <div className="w-[30%] items-stretch justify-start pl-2">
+          {isEditing && (
+            <div className="flex items-stretch gap-1 w-full h-full">
+              <button onClick={handleSubmit} className="px-2 text-sm bg-primary rounded">
+                ✓
+              </button>
+              <button onClick={handleCancel} className="px-2 text-sm bg-secondary rounded">
+                ✕
+              </button>
+            </div>
+          )}
+        </div>
+      </div>
+    </HighlightedCell>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/HighlightedCell.tsx b/extension/packages/nextjs/components/oracle/HighlightedCell.tsx
new file mode 100644
index 00000000..08a5c3bf
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/HighlightedCell.tsx
@@ -0,0 +1,41 @@
+import { useEffect, useRef, useState } from "react";
+
+export const HighlightedCell = ({
+  value,
+  highlightColor,
+  children,
+  className,
+  handleClick,
+}: {
+  value: string | number;
+  highlightColor: string;
+  children: React.ReactNode;
+  className?: string;
+  handleClick?: () => void;
+}) => {
+  const [isHighlighted, setIsHighlighted] = useState(false);
+  const prevValue = useRef<string | number | undefined>(undefined);
+
+  useEffect(() => {
+    if (value === undefined) return;
+    if (value === "Not reported") return;
+    if (value === "Loading...") return;
+    const hasPrev = typeof prevValue.current === "number" || typeof prevValue.current === "string";
+
+    if (hasPrev && value !== prevValue.current) {
+      setIsHighlighted(true);
+      const timer = setTimeout(() => setIsHighlighted(false), 1000);
+      return () => clearTimeout(timer);
+    }
+    prevValue.current = value;
+  }, [value]);
+
+  return (
+    <td
+      className={`transition-colors duration-300 ${isHighlighted ? highlightColor : ""} ${className}`}
+      onClick={handleClick}
+    >
+      {children}
+    </td>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/NodeRow.tsx b/extension/packages/nextjs/components/oracle/NodeRow.tsx
new file mode 100644
index 00000000..4c1e5160
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/NodeRow.tsx
@@ -0,0 +1,101 @@
+import { useEffect, useRef } from "react";
+import { ConfigSlider } from "./ConfigSlider";
+import { NodeRowProps } from "./types";
+import { erc20Abi, formatEther } from "viem";
+import { useReadContract, useWatchContractEvent } from "wagmi";
+import { HighlightedCell } from "~~/components/oracle/HighlightedCell";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { getHighlightColorForPrice } from "~~/utils/helpers";
+
+export const NodeRow = ({ address, isStale }: NodeRowProps) => {
+  const { data = [] } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "nodes",
+    args: [address],
+  });
+
+  const { data: oracleTokenAddress } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "oracleToken",
+  });
+
+  const { data: oraBalance, refetch: refetchOraBalance } = useReadContract({
+    address: oracleTokenAddress as `0x${string}`,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [address],
+    query: {
+      enabled: !!oracleTokenAddress,
+    },
+  });
+
+  useWatchContractEvent({
+    address: oracleTokenAddress as `0x${string}`,
+    abi: erc20Abi,
+    eventName: "Transfer",
+    onLogs: logs => {
+      const relevantTransfer = logs.find(
+        log =>
+          log.args.to?.toLowerCase() === address.toLowerCase() ||
+          log.args.from?.toLowerCase() === address.toLowerCase(),
+      );
+      if (relevantTransfer) {
+        refetchOraBalance();
+      }
+    },
+    enabled: !!oracleTokenAddress,
+  });
+
+  const { data: minimumStake } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "MINIMUM_STAKE",
+    args: undefined,
+  });
+
+  const { data: medianPrice } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getPrice",
+  }) as { data: bigint | undefined };
+
+  const [, stakedAmount, lastReportedPrice] = data;
+
+  const prevMedianPrice = useRef<bigint | undefined>(undefined);
+
+  useEffect(() => {
+    if (medianPrice !== undefined && medianPrice !== prevMedianPrice.current) {
+      prevMedianPrice.current = medianPrice;
+    }
+  }, [medianPrice]);
+
+  const stakedAmountFormatted = stakedAmount !== undefined ? Number(formatEther(stakedAmount)) : "Loading...";
+  const lastReportedPriceFormatted =
+    lastReportedPrice !== undefined ? Number(parseFloat(formatEther(lastReportedPrice)).toFixed(2)) : "Not reported";
+  const oraBalanceFormatted = oraBalance !== undefined ? Number(formatEther(oraBalance)) : "Loading...";
+
+  // Check if staked amount is below minimum requirement
+  const isInsufficientStake = stakedAmount !== undefined && minimumStake !== undefined && stakedAmount < minimumStake;
+
+  return (
+    <tr className={isInsufficientStake ? "opacity-40" : ""}>
+      <td>
+        <Address address={address} size="sm" format="short" onlyEnsOrAddress={true} />
+      </td>
+      <HighlightedCell value={stakedAmountFormatted} highlightColor="bg-error">
+        {stakedAmountFormatted}
+      </HighlightedCell>
+      <HighlightedCell
+        value={lastReportedPriceFormatted}
+        highlightColor={getHighlightColorForPrice(lastReportedPrice, medianPrice)}
+        className={isStale ? "opacity-40" : ""}
+      >
+        {lastReportedPriceFormatted}
+      </HighlightedCell>
+      <HighlightedCell value={oraBalanceFormatted} highlightColor="bg-success">
+        {oraBalanceFormatted}
+      </HighlightedCell>
+      <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="skip-probability" label="skip rate" />
+      <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="price-variance" label="variance" />
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/NodesTable.tsx b/extension/packages/nextjs/components/oracle/NodesTable.tsx
new file mode 100644
index 00000000..a2fd3c73
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/NodesTable.tsx
@@ -0,0 +1,110 @@
+import TooltipInfo from "../TooltipInfo";
+import { NodeRow } from "./NodeRow";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+
+const LoadingRow = () => {
+  return (
+    <tr>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-32"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-20"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-24"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-20"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-32"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-32"></div>
+      </td>
+    </tr>
+  );
+};
+
+const NoNodesRow = () => {
+  return (
+    <tr>
+      <td colSpan={6} className="text-center">
+        No nodes found
+      </td>
+    </tr>
+  );
+};
+
+export const NodesTable = () => {
+  const { data: nodeAddresses, isLoading } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getNodeAddresses",
+  });
+
+  const { data: staleNodesData } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "separateStaleNodes",
+    args: [nodeAddresses || []],
+  });
+
+  const tooltipText =
+    "This table displays registered oracle nodes that provide price data to the system. Nodes are displayed as inactive if they don't have enough ETH staked. You can edit the skip probability and price variance of an oracle node with the slider.";
+
+  // Extract stale node addresses from the returned data
+  const staleNodeAddresses = staleNodesData?.[1] || [];
+
+  return (
+    <div className="flex flex-col gap-2">
+      <div className="flex items-center gap-2">
+        <h2 className="text-xl font-bold">Oracle Nodes</h2>
+        <span>
+          <TooltipInfo infoText={tooltipText} />
+        </span>
+      </div>
+      <div className="bg-base-100 rounded-lg p-4 relative">
+        <div className="overflow-x-auto">
+          <table className="table w-full">
+            <thead>
+              <tr>
+                <th>Node Address</th>
+                <th>
+                  <div className="flex items-center gap-1">
+                    Staked Amount (ETH)
+                    <TooltipInfo infoText="Red shows slashing event" />
+                  </div>
+                </th>
+                <th>
+                  <div className="flex items-center gap-1">
+                    Last Reported Price (USD)
+                    <TooltipInfo infoText="Color shows proximity to median price" />
+                  </div>
+                </th>
+                <th>
+                  <div className="flex items-center gap-1">
+                    ORA Balance
+                    <TooltipInfo infoText="Green shows positive balance" />
+                  </div>
+                </th>
+                <th>Skip Probability</th>
+                <th>Price Variance</th>
+              </tr>
+            </thead>
+            <tbody>
+              {isLoading ? (
+                <LoadingRow />
+              ) : nodeAddresses?.length === 0 ? (
+                <NoNodesRow />
+              ) : (
+                nodeAddresses?.map((address: string, index: number) => (
+                  <NodeRow key={index} index={index} address={address} isStale={staleNodeAddresses.includes(address)} />
+                ))
+              )}
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/PriceWidget.tsx b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
new file mode 100644
index 00000000..79c25513
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
@@ -0,0 +1,72 @@
+import { useEffect, useRef, useState } from "react";
+import TooltipInfo from "../TooltipInfo";
+import { formatEther } from "viem";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+
+const getHighlightColor = (oldPrice: bigint | undefined, newPrice: bigint | undefined): string => {
+  if (oldPrice === undefined || newPrice === undefined) return "";
+
+  const change = Math.abs(parseFloat(formatEther(newPrice)) - parseFloat(formatEther(oldPrice)));
+
+  if (change < 50) return "bg-success";
+  if (change < 100) return "bg-warning";
+  return "bg-error";
+};
+
+interface PriceWidgetProps {
+  contractName: "StakingOracle" | "WhitelistOracle";
+}
+
+export const PriceWidget = ({ contractName }: PriceWidgetProps) => {
+  const [highlight, setHighlight] = useState(false);
+  const [highlightColor, setHighlightColor] = useState("");
+  const prevPrice = useRef<bigint | undefined>(undefined);
+
+  const {
+    data: currentPrice,
+    isLoading,
+    isError,
+  } = useScaffoldReadContract({
+    contractName,
+    functionName: "getPrice",
+    watch: true,
+  }) as { data: bigint | undefined; isError: boolean; isLoading: boolean };
+
+  useEffect(() => {
+    if (currentPrice !== undefined && prevPrice.current !== undefined && currentPrice !== prevPrice.current) {
+      setHighlightColor(getHighlightColor(prevPrice.current, currentPrice));
+      setHighlight(true);
+      setTimeout(() => {
+        setHighlight(false);
+        setHighlightColor("");
+      }, 650);
+    }
+    prevPrice.current = currentPrice;
+  }, [currentPrice]);
+
+  return (
+    <div className="flex flex-col gap-2">
+      <h2 className="text-xl font-bold">Current Price</h2>
+      <div className="bg-base-100 rounded-lg p-4 w-1/2 md:w-1/4 mx-auto flex justify-center items-center relative">
+        <TooltipInfo
+          top={0}
+          right={0}
+          infoText="Displays the median price. If no oracle nodes have reported prices in the last 10 seconds, it will display 'No fresh price'. Color highlighting indicates how big of a change there was in the price."
+        />
+        <div className={`rounded-lg transition-colors duration-1000 ${highlight ? highlightColor : ""}`}>
+          <div className="font-bold h-10 text-4xl flex items-center justify-center">
+            {isError ? (
+              <div className="text-error text-xl">No fresh price</div>
+            ) : isLoading || currentPrice === undefined ? (
+              <div className="animate-pulse">
+                <div className="h-10 bg-secondary rounded-md w-32"></div>
+              </div>
+            ) : (
+              `$${parseFloat(formatEther(currentPrice)).toFixed(2)}`
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/AssertedRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/AssertedRow.tsx
new file mode 100644
index 00000000..e65adbdc
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/AssertedRow.tsx
@@ -0,0 +1,50 @@
+import { TimeLeft } from "./TimeLeft";
+import { formatEther } from "viem";
+import { ChevronRightIcon } from "@heroicons/react/24/outline";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+export const AssertedRow = ({ assertionId, state }: { assertionId: number; state: number }) => {
+  const { openAssertionModal } = useChallengeState();
+
+  const { data: assertionData } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "getAssertion",
+    args: [BigInt(assertionId)],
+  });
+
+  if (!assertionData) return null;
+
+  return (
+    <tr
+      key={assertionId}
+      onClick={() => {
+        openAssertionModal({ ...assertionData, assertionId, state });
+      }}
+      className={`group border-b border-base-300 cursor-pointer`}
+    >
+      {/* Description Column */}
+      <td>
+        <div className="group-hover:text-error">{assertionData.description}</div>
+      </td>
+
+      {/* Bond Column */}
+      <td>{formatEther(assertionData.bond)} ETH</td>
+
+      {/* Reward Column */}
+      <td>{formatEther(assertionData.reward)} ETH</td>
+
+      {/* Time Left Column */}
+      <td>
+        <TimeLeft startTime={assertionData.startTime} endTime={assertionData.endTime} />
+      </td>
+
+      {/* Chevron Column */}
+      <td>
+        <div className="w-6 h-6 rounded-full border-error border flex items-center justify-center hover:bg-base-200 group-hover:bg-error transition-colors mx-auto">
+          <ChevronRightIcon className="w-4 h-4 text-error group-hover:text-white stroke-2 transition-colors" />
+        </div>
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/AssertedTable.tsx b/extension/packages/nextjs/components/oracle/optimistic/AssertedTable.tsx
new file mode 100644
index 00000000..c38e7f2f
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/AssertedTable.tsx
@@ -0,0 +1,34 @@
+"use client";
+
+import { OOTableProps } from "../types";
+import { AssertedRow } from "./AssertedRow";
+import { EmptyRow } from "./EmptyRow";
+
+export const AssertedTable = ({ assertions }: OOTableProps) => {
+  return (
+    <div className="bg-base-100 rounded-lg shadow-lg overflow-x-auto">
+      <table className="w-full table-auto [&_th]:px-6 [&_th]:py-4 [&_td]:px-6 [&_td]:py-4">
+        {/* Header */}
+        <thead>
+          <tr className="bg-base-300">
+            <th className="text-left font-semibold w-5/12">Description</th>
+            <th className="text-left font-semibold w-2/12">Bond</th>
+            <th className="text-left font-semibold w-2/12">Reward</th>
+            <th className="text-left font-semibold w-2/12">Time Left</th>
+            <th className="text-left font-semibold w-1/12">{/* Icon column */}</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          {assertions.length > 0 ? (
+            assertions.map(assertion => (
+              <AssertedRow key={assertion.assertionId} assertionId={assertion.assertionId} state={assertion.state} />
+            ))
+          ) : (
+            <EmptyRow colspan={5} />
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/AssertionModal.tsx b/extension/packages/nextjs/components/oracle/optimistic/AssertionModal.tsx
new file mode 100644
index 00000000..1bf0d4a6
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/AssertionModal.tsx
@@ -0,0 +1,260 @@
+"use client";
+
+import { useState } from "react";
+import { AssertionWithIdAndState } from "../types";
+import { formatEther } from "viem";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+import { ZERO_ADDRESS } from "~~/utils/scaffold-eth/common";
+
+const getStateName = (state: number) => {
+  switch (state) {
+    case 0:
+      return "Invalid";
+    case 1:
+      return "Asserted";
+    case 2:
+      return "Proposed";
+    case 3:
+      return "Disputed";
+    case 4:
+      return "Settled";
+    case 5:
+      return "Expired";
+    default:
+      return "Invalid";
+  }
+};
+
+// Helper function to format timestamp to UTC
+const formatTimestamp = (timestamp: bigint | string | number) => {
+  const timestampNumber = Number(timestamp);
+  const date = new Date(timestampNumber * 1000); // Convert from seconds to milliseconds
+  return date.toLocaleString();
+};
+
+const Description = ({ assertion }: { assertion: AssertionWithIdAndState }) => {
+  return (
+    <div className="bg-base-200 p-4 rounded-lg space-y-2 mb-4">
+      <div>
+        <span className="font-bold">AssertionId:</span> {assertion.assertionId}
+      </div>
+
+      <div>
+        <span className="font-bold">Description:</span> {assertion.description}
+      </div>
+
+      <div>
+        <span className="font-bold">Bond:</span> {formatEther(assertion.bond)} ETH
+      </div>
+
+      <div>
+        <span className="font-bold">Reward:</span> {formatEther(assertion.reward)} ETH
+      </div>
+
+      <div>
+        <span className="font-bold">Start Time:</span>
+        <span className="text-sm"> UTC: {formatTimestamp(assertion.startTime)}</span>
+        <span className="text-sm"> Timestamp: {assertion.startTime}</span>
+      </div>
+
+      <div>
+        <span className="font-bold">End Time:</span>
+        <span className="text-sm"> UTC: {formatTimestamp(assertion.endTime)}</span>
+        <span className="text-sm"> Timestamp: {assertion.endTime}</span>
+      </div>
+
+      {assertion.proposer !== ZERO_ADDRESS && (
+        <div>
+          <span className="font-bold">Proposed Outcome:</span> {assertion.proposedOutcome ? "True" : "False"}
+        </div>
+      )}
+
+      {assertion.proposer !== ZERO_ADDRESS && (
+        <div>
+          <span className="font-bold">Proposer:</span>{" "}
+          <Address address={assertion.proposer} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+        </div>
+      )}
+
+      {assertion.disputer !== ZERO_ADDRESS && (
+        <div>
+          <span className="font-bold">Disputer:</span>{" "}
+          <Address address={assertion.disputer} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+        </div>
+      )}
+    </div>
+  );
+};
+
+export const AssertionModal = () => {
+  const [isActionPending, setIsActionPending] = useState(false);
+  const { refetchAssertionStates, openAssertion, closeAssertionModal } = useChallengeState();
+
+  const isOpen = !!openAssertion;
+
+  const { writeContractAsync: writeOOContractAsync } = useScaffoldWriteContract({
+    contractName: "OptimisticOracle",
+  });
+
+  const { writeContractAsync: writeDeciderContractAsync } = useScaffoldWriteContract({
+    contractName: "Decider",
+  });
+
+  const handleAction = async (args: any) => {
+    if (!openAssertion) return;
+
+    try {
+      setIsActionPending(true);
+      if (args.functionName === "settleDispute") {
+        await writeDeciderContractAsync(args);
+      } else {
+        await writeOOContractAsync(args);
+      }
+      refetchAssertionStates();
+      closeAssertionModal();
+    } catch (error) {
+      console.log(error);
+    } finally {
+      setIsActionPending(false);
+    }
+  };
+
+  if (!openAssertion) return null;
+
+  return (
+    <>
+      <input type="checkbox" id="challenge-modal" className="modal-toggle" checked={isOpen} readOnly />
+      <label htmlFor="challenge-modal" className="modal cursor-pointer" onClick={closeAssertionModal}>
+        <label
+          className="modal-box relative max-w-2xl w-full bg-base-100"
+          htmlFor=""
+          onClick={e => e.stopPropagation()}
+        >
+          {/* dummy input to capture event onclick on modal box */}
+          <input className="h-0 w-0 absolute top-0 left-0" />
+
+          {/* Close button */}
+          <button onClick={closeAssertionModal} className="btn btn-ghost btn-sm btn-circle absolute right-3 top-3">
+            ✕
+          </button>
+
+          {/* Modal Content */}
+          <div className="">
+            {/* Header with Current State */}
+            <div className="text-center mb-6">
+              <h2 className="text-lg">
+                Current State: <span className="font-bold">{getStateName(openAssertion.state)}</span>
+              </h2>
+            </div>
+
+            <Description assertion={openAssertion} />
+
+            {openAssertion.state === 1 && (
+              <>
+                {/* Proposed Outcome Section */}
+                <div className="rounded-lg p-4">
+                  <div className="flex justify-center mb-4">
+                    <span className="font-medium">Propose Outcome</span>
+                  </div>
+                  {isActionPending && <span className="loading loading-spinner loading-xs"></span>}
+
+                  <div className="flex justify-center gap-4">
+                    <button
+                      className="btn btn-primary flex-1"
+                      onClick={() =>
+                        handleAction({
+                          functionName: "proposeOutcome",
+                          args: [BigInt(openAssertion.assertionId), true],
+                          value: openAssertion.bond,
+                        })
+                      }
+                      disabled={isActionPending}
+                    >
+                      True
+                    </button>
+                    <button
+                      className="btn btn-primary flex-1"
+                      onClick={() =>
+                        handleAction({
+                          functionName: "proposeOutcome",
+                          args: [BigInt(openAssertion.assertionId), false],
+                          value: openAssertion.bond,
+                        })
+                      }
+                      disabled={isActionPending}
+                    >
+                      False
+                    </button>
+                  </div>
+                </div>
+              </>
+            )}
+            {openAssertion.state === 2 && (
+              <div className="rounded-lg p-4">
+                <div className="flex justify-center mb-4">
+                  <span className="font-medium">Submit Dispute</span>
+                </div>
+
+                {isActionPending && <span className="loading loading-spinner loading-xs"></span>}
+
+                <div className="flex justify-center gap-4">
+                  <button
+                    className="btn btn-primary flex-1"
+                    onClick={() =>
+                      handleAction({
+                        functionName: "disputeOutcome",
+                        args: [BigInt(openAssertion.assertionId)],
+                        value: openAssertion.bond,
+                      })
+                    }
+                    disabled={isActionPending}
+                  >
+                    {!openAssertion.proposedOutcome ? "True" : "False"}
+                  </button>
+                </div>
+              </div>
+            )}
+            {openAssertion.state === 3 && (
+              <div className="rounded-lg p-4">
+                <div className="flex flex-col items-center gap-2 mb-4">
+                  <span className="text-2xl font-medium">Impersonate Decider</span>
+                  <span className="font-medium">Resolve Answer to</span>
+                </div>
+                {isActionPending && <span className="loading loading-spinner loading-xs"></span>}
+
+                <div className="flex justify-center gap-4">
+                  <button
+                    className="btn btn-primary flex-1"
+                    onClick={() =>
+                      handleAction({
+                        functionName: "settleDispute",
+                        args: [BigInt(openAssertion.assertionId), true],
+                      })
+                    }
+                    disabled={isActionPending}
+                  >
+                    True
+                  </button>
+                  <button
+                    className="btn btn-primary flex-1"
+                    onClick={() =>
+                      handleAction({
+                        functionName: "settleDispute",
+                        args: [BigInt(openAssertion.assertionId), false],
+                      })
+                    }
+                    disabled={isActionPending}
+                  >
+                    False
+                  </button>
+                </div>
+              </div>
+            )}
+          </div>
+        </label>
+      </label>
+    </>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/DisputedRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/DisputedRow.tsx
new file mode 100644
index 00000000..c0b22fb7
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/DisputedRow.tsx
@@ -0,0 +1,48 @@
+import { ChevronRightIcon } from "@heroicons/react/24/outline";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+export const DisputedRow = ({ assertionId, state }: { assertionId: number; state: number }) => {
+  const { openAssertionModal } = useChallengeState();
+
+  const { data: assertionData } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "getAssertion",
+    args: [BigInt(assertionId)],
+  });
+
+  if (!assertionData) return null;
+
+  return (
+    <tr
+      key={assertionId}
+      onClick={() => {
+        openAssertionModal({ ...assertionData, assertionId, state });
+      }}
+      className={`group border-b border-base-300 cursor-pointer`}
+    >
+      {/* Description Column */}
+      <td>
+        <div className="group-hover:text-error">{assertionData.description}</div>
+      </td>
+
+      {/* Proposer Column */}
+      <td>
+        <Address address={assertionData.proposer} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+      </td>
+
+      {/* Disputer Column */}
+      <td>
+        <Address address={assertionData.disputer} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+      </td>
+
+      {/* Chevron Column */}
+      <td className="">
+        <div className="w-6 h-6 rounded-full border-error border flex items-center justify-center hover:bg-base-200 group-hover:bg-error transition-colors mx-auto">
+          <ChevronRightIcon className="w-4 h-4 text-error group-hover:text-white stroke-2 transition-colors" />
+        </div>
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/DisputedTable.tsx b/extension/packages/nextjs/components/oracle/optimistic/DisputedTable.tsx
new file mode 100644
index 00000000..6cec3235
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/DisputedTable.tsx
@@ -0,0 +1,33 @@
+"use client";
+
+import { OOTableProps } from "../types";
+import { DisputedRow } from "./DisputedRow";
+import { EmptyRow } from "./EmptyRow";
+
+export const DisputedTable = ({ assertions }: OOTableProps) => {
+  return (
+    <div className="bg-base-100 rounded-lg shadow-lg overflow-x-auto">
+      <table className="w-full table-auto [&_th]:px-6 [&_th]:py-4 [&_td]:px-6 [&_td]:py-4">
+        {/* Header */}
+        <thead>
+          <tr className="bg-base-300">
+            <th className="text-left font-semibold w-5/12">Description</th>
+            <th className="text-left font-semibold w-3/12">Proposer</th>
+            <th className="text-left font-semibold w-3/12">Disputer</th>
+            <th className="text-left font-semibold w-1/12">{/* Icon column */}</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          {assertions.length > 0 ? (
+            assertions.map(assertion => (
+              <DisputedRow key={assertion.assertionId} assertionId={assertion.assertionId} state={assertion.state} />
+            ))
+          ) : (
+            <EmptyRow colspan={4} />
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/EmptyRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/EmptyRow.tsx
new file mode 100644
index 00000000..6fa91c0e
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/EmptyRow.tsx
@@ -0,0 +1,15 @@
+export const EmptyRow = ({
+  message = "No assertions match this state.",
+  colspan = 4,
+}: {
+  message?: string;
+  colspan?: number;
+}) => {
+  return (
+    <tr>
+      <td colSpan={colspan} className="text-center">
+        {message}
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/ExpiredRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/ExpiredRow.tsx
new file mode 100644
index 00000000..263e77b7
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/ExpiredRow.tsx
@@ -0,0 +1,62 @@
+import { useState } from "react";
+import { formatEther } from "viem";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+
+export const ExpiredRow = ({ assertionId }: { assertionId: number }) => {
+  const [isClaiming, setIsClaiming] = useState(false);
+
+  const { data: assertionData } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "getAssertion",
+    args: [BigInt(assertionId)],
+  });
+
+  const { writeContractAsync } = useScaffoldWriteContract({
+    contractName: "OptimisticOracle",
+  });
+
+  const handleClaim = async () => {
+    setIsClaiming(true);
+    try {
+      await writeContractAsync({
+        functionName: "claimRefund",
+        args: [BigInt(assertionId)],
+      });
+    } catch (error) {
+      console.error(error);
+    } finally {
+      setIsClaiming(false);
+    }
+  };
+
+  if (!assertionData) return null;
+
+  return (
+    <tr key={assertionId} className={`border-b border-base-300`}>
+      {/* Description Column */}
+      <td>{assertionData.description}</td>
+
+      {/* Asserter Column */}
+      <td>
+        <Address address={assertionData.asserter} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+      </td>
+
+      {/* Reward Column */}
+      <td>{formatEther(assertionData.reward)} ETH</td>
+
+      {/* Claimed Column */}
+      <td>
+        {assertionData?.claimed ? (
+          <button className="btn btn-primary btn-xs" disabled>
+            Claimed
+          </button>
+        ) : (
+          <button className="btn btn-primary btn-xs" onClick={handleClaim} disabled={isClaiming}>
+            Claim
+          </button>
+        )}
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/ExpiredTable.tsx b/extension/packages/nextjs/components/oracle/optimistic/ExpiredTable.tsx
new file mode 100644
index 00000000..821e27bc
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/ExpiredTable.tsx
@@ -0,0 +1,31 @@
+"use client";
+
+import { OOTableProps } from "../types";
+import { EmptyRow } from "./EmptyRow";
+import { ExpiredRow } from "./ExpiredRow";
+
+export const ExpiredTable = ({ assertions }: OOTableProps) => {
+  return (
+    <div className="bg-base-100 rounded-lg shadow-lg overflow-x-auto">
+      <table className="w-full table-auto [&_th]:px-6 [&_th]:py-4 [&_td]:px-6 [&_td]:py-4">
+        {/* Header */}
+        <thead>
+          <tr className="bg-base-300">
+            <th className="text-left font-semibold w-5/12">Description</th>
+            <th className="text-left font-semibold w-3/12">Asserter</th>
+            <th className="text-left font-semibold w-2/12">Reward</th>
+            <th className="text-left font-semibold w-2/12">Claim Refund</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          {assertions.length > 0 ? (
+            assertions.map(assertion => <ExpiredRow key={assertion.assertionId} assertionId={assertion.assertionId} />)
+          ) : (
+            <EmptyRow colspan={4} />
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/LoadingRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/LoadingRow.tsx
new file mode 100644
index 00000000..df83e9a2
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/LoadingRow.tsx
@@ -0,0 +1,21 @@
+export const LoadingRow = () => {
+  return (
+    <tr className="border-b border-base-300">
+      <td>
+        <div className="h-5 bg-base-300 rounded animate-pulse"></div>
+      </td>
+
+      <td>
+        <div className="h-5 w-24 bg-base-300 rounded animate-pulse"></div>
+      </td>
+
+      <td>
+        <div className="h-5 w-24 bg-base-300 rounded animate-pulse"></div>
+      </td>
+
+      <td>
+        <div className="w-6 h-6 rounded-full bg-base-300 animate-pulse mx-auto"></div>
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/ProposedRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/ProposedRow.tsx
new file mode 100644
index 00000000..4cd27927
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/ProposedRow.tsx
@@ -0,0 +1,52 @@
+"use client";
+
+import { OORowProps } from "../types";
+import { TimeLeft } from "./TimeLeft";
+import { formatEther } from "viem";
+import { ChevronRightIcon } from "@heroicons/react/24/outline";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+export const ProposedRow = ({ assertionId, state }: OORowProps) => {
+  const { openAssertionModal } = useChallengeState();
+  const { data: assertionData } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "getAssertion",
+    args: [BigInt(assertionId)],
+  });
+
+  if (!assertionData) return null;
+
+  return (
+    <tr
+      key={assertionId}
+      className={`group border-b border-base-300 cursor-pointer`}
+      onClick={() => {
+        openAssertionModal({ ...assertionData, assertionId, state });
+      }}
+    >
+      {/* Query Column */}
+      <td>
+        <div className="group-hover:text-error">{assertionData?.description}</div>
+      </td>
+
+      {/* Bond Column */}
+      <td>{formatEther(assertionData?.bond)} ETH</td>
+
+      {/* Proposal Column */}
+      <td>{assertionData?.proposedOutcome ? "True" : "False"}</td>
+
+      {/* Challenge Period Column */}
+      <td>
+        <TimeLeft startTime={assertionData?.startTime} endTime={assertionData?.endTime} />
+      </td>
+
+      {/* Chevron Column */}
+      <td>
+        <div className="w-6 h-6 rounded-full border-error border flex items-center justify-center hover:bg-base-200 group-hover:bg-error transition-colors mx-auto">
+          <ChevronRightIcon className="w-4 h-4 text-error group-hover:text-white stroke-2 transition-colors" />
+        </div>
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/ProposedTable.tsx b/extension/packages/nextjs/components/oracle/optimistic/ProposedTable.tsx
new file mode 100644
index 00000000..091bc860
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/ProposedTable.tsx
@@ -0,0 +1,32 @@
+import { OOTableProps } from "../types";
+import { EmptyRow } from "./EmptyRow";
+import { ProposedRow } from "./ProposedRow";
+
+export const ProposedTable = ({ assertions }: OOTableProps) => {
+  return (
+    <div className="bg-base-100 rounded-lg shadow-lg overflow-x-auto">
+      <table className="w-full table-auto [&_th]:px-6 [&_th]:py-4 [&_td]:px-6 [&_td]:py-4">
+        {/* Header */}
+        <thead>
+          <tr className="bg-base-300">
+            <th className="text-left font-semibold w-5/12">Description</th>
+            <th className="text-left font-semibold w-2/12">Bond</th>
+            <th className="text-left font-semibold w-2/12">Proposal</th>
+            <th className="text-left font-semibold w-2/12">Time Left</th>
+            <th className="text-left font-semibold w-1/12">{/* Icon column */}</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          {assertions.length > 0 ? (
+            assertions.map(assertion => (
+              <ProposedRow key={assertion.assertionId} assertionId={assertion.assertionId} state={assertion.state} />
+            ))
+          ) : (
+            <EmptyRow colspan={5} />
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/SettledRow.tsx b/extension/packages/nextjs/components/oracle/optimistic/SettledRow.tsx
new file mode 100644
index 00000000..e696cd75
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/SettledRow.tsx
@@ -0,0 +1,75 @@
+"use client";
+
+import { useState } from "react";
+import { SettledRowProps } from "../types";
+import { LoadingRow } from "./LoadingRow";
+import { formatEther } from "viem";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { ZERO_ADDRESS } from "~~/utils/scaffold-eth/common";
+
+export const SettledRow = ({ assertionId }: SettledRowProps) => {
+  const [isClaiming, setIsClaiming] = useState(false);
+  const { data: assertionData, isLoading } = useScaffoldReadContract({
+    contractName: "OptimisticOracle",
+    functionName: "getAssertion",
+    args: [BigInt(assertionId)],
+  });
+
+  const { writeContractAsync } = useScaffoldWriteContract({
+    contractName: "OptimisticOracle",
+  });
+
+  if (isLoading) return <LoadingRow />;
+  if (!assertionData) return null;
+
+  const handleClaim = async () => {
+    try {
+      setIsClaiming(true);
+      const functionName = assertionData?.winner === ZERO_ADDRESS ? "claimUndisputedReward" : "claimDisputedReward";
+      await writeContractAsync({
+        functionName,
+        args: [BigInt(assertionId)],
+      });
+    } catch (error) {
+      console.error(error);
+    } finally {
+      setIsClaiming(false);
+    }
+  };
+
+  const winner = assertionData?.winner === ZERO_ADDRESS ? assertionData?.proposer : assertionData?.winner;
+  const outcome =
+    assertionData?.winner === ZERO_ADDRESS ? assertionData?.proposedOutcome : assertionData?.resolvedOutcome;
+
+  return (
+    <tr key={assertionId} className={`border-b border-base-300`}>
+      {/* Query Column */}
+      <td>{assertionData?.description}</td>
+
+      {/* Answer Column */}
+      <td>{outcome ? "True" : "False"}</td>
+
+      {/* Winner Column */}
+      <td>
+        <Address address={winner} format="short" onlyEnsOrAddress disableAddressLink size="sm" />
+      </td>
+
+      {/* Reward Column */}
+      <td>{formatEther(assertionData?.reward)} ETH</td>
+
+      {/* Claimed Column */}
+      <td>
+        {assertionData?.claimed ? (
+          <button className="btn btn-primary btn-xs" disabled>
+            Claimed
+          </button>
+        ) : (
+          <button className="btn btn-primary btn-xs" onClick={handleClaim} disabled={isClaiming}>
+            Claim
+          </button>
+        )}
+      </td>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/SettledTable.tsx b/extension/packages/nextjs/components/oracle/optimistic/SettledTable.tsx
new file mode 100644
index 00000000..bf368286
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/SettledTable.tsx
@@ -0,0 +1,32 @@
+"use client";
+
+import { OOTableProps } from "../types";
+import { EmptyRow } from "./EmptyRow";
+import { SettledRow } from "./SettledRow";
+
+export const SettledTable = ({ assertions }: OOTableProps) => {
+  return (
+    <div className="bg-base-100 rounded-lg shadow-lg overflow-x-auto">
+      <table className="w-full table-auto [&_th]:px-6 [&_th]:py-4 [&_td]:px-6 [&_td]:py-4">
+        {/* Header */}
+        <thead>
+          <tr className="bg-base-300">
+            <th className="text-left font-semibold w-4/12">Description</th>
+            <th className="text-left font-semibold w-1/12">Result</th>
+            <th className="text-left font-semibold w-3/12">Winner</th>
+            <th className="text-left font-semibold w-2/12">Reward</th>
+            <th className="text-left font-semibold w-2/12">Claim</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          {assertions.length > 0 ? (
+            assertions.map(assertion => <SettledRow key={assertion.assertionId} assertionId={assertion.assertionId} />)
+          ) : (
+            <EmptyRow colspan={5} />
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
new file mode 100644
index 00000000..0741b4bf
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
@@ -0,0 +1,245 @@
+"use client";
+
+import { useState } from "react";
+import { parseEther } from "viem";
+import { usePublicClient } from "wagmi";
+import TooltipInfo from "~~/components/TooltipInfo";
+import { IntegerInput } from "~~/components/scaffold-eth";
+import { useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { useChallengeState } from "~~/services/store/challengeStore";
+import { getRandomQuestion } from "~~/utils/helpers";
+import { notification } from "~~/utils/scaffold-eth";
+
+const MINIMUM_ASSERTION_WINDOW = 3;
+
+const getStartTimestamp = (timestamp: bigint, startInMinutes: string) => {
+  if (startInMinutes.length === 0) return 0n;
+  if (Number(startInMinutes) === 0) return 0n;
+  return timestamp + BigInt(startInMinutes) * 60n;
+};
+
+const getEndTimestamp = (timestamp: bigint, startTimestamp: bigint, durationInMinutes: string) => {
+  if (durationInMinutes.length === 0) return 0n;
+  if (Number(durationInMinutes) === MINIMUM_ASSERTION_WINDOW) return 0n;
+  if (startTimestamp === 0n) return timestamp + BigInt(durationInMinutes) * 60n;
+  return startTimestamp + BigInt(durationInMinutes) * 60n;
+};
+
+interface SubmitAssertionModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) => {
+  const { timestamp } = useChallengeState();
+  const [isLoading, setIsLoading] = useState(false);
+  const publicClient = usePublicClient();
+
+  const [description, setDescription] = useState("");
+  const [reward, setReward] = useState<string>("");
+  const [startInMinutes, setStartInMinutes] = useState<string>("");
+  const [durationInMinutes, setDurationInMinutes] = useState<string>("");
+
+  const { writeContractAsync } = useScaffoldWriteContract({ contractName: "OptimisticOracle" });
+
+  const handleRandomQuestion = () => {
+    setDescription(getRandomQuestion());
+  };
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (durationInMinutes.length > 0 && Number(durationInMinutes) < MINIMUM_ASSERTION_WINDOW) {
+      notification.error(
+        `Duration must be at least ${MINIMUM_ASSERTION_WINDOW} minutes or leave blank to use default value`,
+      );
+      return;
+    }
+
+    if (Number(reward) === 0) {
+      notification.error(`Reward must be greater than 0 ETH`);
+      return;
+    }
+
+    if (!publicClient) {
+      notification.error("Public client not found");
+      return;
+    }
+
+    try {
+      setIsLoading(true);
+      let recentTimestamp = timestamp;
+      if (!recentTimestamp) {
+        const block = await publicClient.getBlock();
+        recentTimestamp = block.timestamp;
+      }
+
+      const startTimestamp = getStartTimestamp(recentTimestamp, startInMinutes);
+      const endTimestamp = getEndTimestamp(recentTimestamp, startTimestamp, durationInMinutes);
+
+      await writeContractAsync({
+        functionName: "assertEvent",
+        args: [description.trim(), startTimestamp, endTimestamp],
+        value: parseEther(reward),
+      });
+      // Reset form after successful submission
+      setDescription("");
+      setReward("");
+      setStartInMinutes("");
+      setDurationInMinutes("");
+      onClose();
+    } catch (error) {
+      console.log("Error with submission", error);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleClose = () => {
+    onClose();
+    // Reset form when closing
+    setDescription("");
+    setReward("");
+    setStartInMinutes("");
+    setDurationInMinutes("");
+  };
+
+  if (!isOpen) return null;
+  const readyToSubmit = description.trim().length > 0 && reward.trim().length > 0;
+
+  return (
+    <>
+      <input type="checkbox" id="assertion-modal" className="modal-toggle" checked={isOpen} readOnly />
+      <label htmlFor="assertion-modal" className="modal cursor-pointer" onClick={handleClose}>
+        <label className="modal-box relative max-w-md w-full bg-base-100" htmlFor="" onClick={e => e.stopPropagation()}>
+          {/* dummy input to capture event onclick on modal box */}
+          <input className="h-0 w-0 absolute top-0 left-0" />
+
+          {/* Close button */}
+          <button onClick={handleClose} className="btn btn-ghost btn-sm btn-circle absolute right-3 top-3">
+            ✕
+          </button>
+
+          <div className="relative">
+            <TooltipInfo
+              top={-2}
+              right={5}
+              className="tooltip-left"
+              infoText="Create a new assertion with your reward stake. Leave time inputs blank to use default values."
+            />
+          </div>
+
+          {/* Modal Content */}
+          <div>
+            {/* Header */}
+            <div className="text-center mb-6">
+              <h2 className="text-xl font-bold">Submit New Assertion</h2>
+            </div>
+
+            {/* Form */}
+            <form onSubmit={handleSubmit} className="space-y-4">
+              {/* Description Input */}
+              <div>
+                <label className="label">
+                  <span className="label-text font-medium">
+                    Description <span className="text-red-500">*</span>
+                  </span>
+                </label>
+                <div className="flex gap-2 items-start">
+                  <div className="flex-1">
+                    <div className="flex border-2 border-base-300 bg-base-200 rounded-full text-accent">
+                      <textarea
+                        name="description"
+                        value={description}
+                        onChange={e => setDescription(e.target.value)}
+                        placeholder="Enter assertion description..."
+                        className="input-ghost min-h-[60px] px-4 w-full font-medium placeholder:text-accent/70 text-base-content/70 focus:text-base-content/70 resize-none bg-transparent focus:outline-none focus:border-0"
+                        rows={2}
+                      />
+                    </div>
+                  </div>
+                  <button
+                    type="button"
+                    onClick={handleRandomQuestion}
+                    className="btn btn-secondary btn-sm"
+                    title="Select random question"
+                  >
+                    🎲
+                  </button>
+                </div>
+              </div>
+              <div>
+                <label className="label">
+                  <span className="label-text font-medium">
+                    Reward (ETH) <span className="text-red-500">*</span>
+                  </span>
+                </label>
+                <IntegerInput
+                  name="reward"
+                  placeholder={`0.01 ETH`}
+                  value={reward}
+                  onChange={newValue => setReward(newValue)}
+                  disableMultiplyBy1e18
+                />
+              </div>
+              {/* Start Time and End Time Inputs */}
+              <div className="grid grid-cols-2 gap-4">
+                <div>
+                  <label className="label">
+                    <span className="label-text font-medium">Start in (minutes)</span>
+                  </label>
+                  <IntegerInput
+                    name="startTime"
+                    placeholder="blank = now"
+                    value={startInMinutes}
+                    onChange={newValue => setStartInMinutes(newValue)}
+                    disableMultiplyBy1e18
+                  />
+                </div>
+                <div>
+                  <label className="label">
+                    <span className="label-text font-medium">Duration (minutes)</span>
+                  </label>
+                  <IntegerInput
+                    name="endTime"
+                    placeholder={`minimum ${MINIMUM_ASSERTION_WINDOW} minutes`}
+                    value={durationInMinutes}
+                    onChange={newValue => setDurationInMinutes(newValue)}
+                    disableMultiplyBy1e18
+                  />
+                </div>
+              </div>
+              {/* Action Buttons */}
+              <div className="flex gap-3 mt-6">
+                <button type="submit" className="btn btn-primary flex-1" disabled={isLoading || !readyToSubmit}>
+                  {isLoading && <span className="loading loading-spinner loading-xs"></span>}
+                  Submit
+                </button>
+              </div>
+            </form>
+          </div>
+        </label>
+      </label>
+    </>
+  );
+};
+
+export const SubmitAssertionButton = () => {
+  const [isModalOpen, setIsModalOpen] = useState(false);
+
+  const openModal = () => setIsModalOpen(true);
+  const closeModal = () => setIsModalOpen(false);
+
+  return (
+    <>
+      {/* Button */}
+      <div className="my-8 flex justify-center">
+        <button className="btn btn-primary btn-lg" onClick={openModal}>
+          Submit New Assertion
+        </button>
+      </div>
+
+      {/* Modal - only mounted when open */}
+      {isModalOpen && <SubmitAssertionModal isOpen={isModalOpen} onClose={closeModal} />}
+    </>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx b/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
new file mode 100644
index 00000000..a600d33e
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
@@ -0,0 +1,55 @@
+import { useEffect, useState } from "react";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+function formatDuration(seconds: number, isPending: boolean) {
+  const totalSeconds = Math.max(seconds, 0);
+  const m = Math.floor(totalSeconds / 60);
+  const s = totalSeconds % 60;
+  return `${m} m ${s} s${isPending ? " left to start" : ""}`;
+}
+
+export const TimeLeft = ({ startTime, endTime }: { startTime: bigint; endTime: bigint }) => {
+  const { timestamp, refetchAssertionStates } = useChallengeState();
+  const [currentTime, setCurrentTime] = useState<number>(0);
+
+  // Update current time every second
+  useEffect(() => {
+    // Initialize with timestamp from global state or current time
+    const initialTime = timestamp ? Number(timestamp) : Math.floor(Date.now() / 1000);
+    setCurrentTime(initialTime);
+
+    const interval = setInterval(() => {
+      setCurrentTime(prev => prev + 1);
+    }, 1000);
+
+    return () => clearInterval(interval);
+  }, [timestamp]);
+
+  const start = Number(startTime);
+  const end = Number(endTime);
+  const now = currentTime;
+  const duration = end - now;
+  const ended = duration <= 0;
+  const progressPercent = Math.min(((now - start) / (end - start)) * 100, 100);
+
+  useEffect(() => {
+    if (ended && timestamp) {
+      refetchAssertionStates();
+    }
+  }, [ended, refetchAssertionStates, timestamp]);
+
+  if (!timestamp) return "Calculating...";
+
+  return (
+    <div className="w-full space-y-1">
+      <div className={ended || duration < 60 ? "text-error" : ""}>
+        {ended ? "Ended" : now < start ? formatDuration(start - now, true) : formatDuration(duration, false)}
+      </div>
+      <div
+        className={`w-full h-1 bg-base-300 rounded-full overflow-hidden transition-opacity ${now > start ? "opacity-100" : "opacity-0"}`}
+      >
+        <div className="h-full bg-error transition-all" style={{ width: `${progressPercent}%` }} />
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/types.ts b/extension/packages/nextjs/components/oracle/types.ts
new file mode 100644
index 00000000..e597c186
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/types.ts
@@ -0,0 +1,67 @@
+export interface NodeRowProps {
+  address: string;
+  index: number;
+  isStale?: boolean;
+}
+
+export interface WhitelistRowProps extends NodeRowProps {
+  isActive: boolean;
+}
+
+export interface NodeInfo {
+  stakedAmount: bigint | undefined;
+  lastReportedPrice: bigint | undefined;
+  oraBalance: bigint | undefined;
+}
+
+export interface HighlightState {
+  staked: boolean;
+  price: boolean;
+  oraBalance: boolean;
+}
+
+export interface Assertion {
+  asserter: string;
+  proposer: string;
+  disputer: string;
+  proposedOutcome: boolean;
+  resolvedOutcome: boolean;
+  reward: bigint;
+  bond: bigint;
+  startTime: bigint;
+  endTime: bigint;
+  claimed: boolean;
+  winner: string;
+  description: string;
+}
+
+export interface AssertionWithId extends Assertion {
+  assertionId: number;
+}
+
+export interface AssertionWithIdAndState extends Assertion {
+  assertionId: number;
+  state: number;
+}
+
+export interface AssertionModalProps {
+  assertion: AssertionWithIdAndState;
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+export interface OOTableProps {
+  assertions: {
+    assertionId: number;
+    state: number;
+  }[];
+}
+
+export interface OORowProps {
+  assertionId: number;
+  state: number;
+}
+
+export interface SettledRowProps {
+  assertionId: number;
+}
diff --git a/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx b/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
new file mode 100644
index 00000000..435cb40e
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
@@ -0,0 +1,72 @@
+import { parseEther } from "viem";
+import { usePublicClient, useWalletClient } from "wagmi";
+import { PlusIcon } from "@heroicons/react/24/outline";
+import { useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { useGlobalState } from "~~/services/store/store";
+import { INITIAL_ETH_PRICE, SIMPLE_ORACLE_ABI, SIMPLE_ORACLE_BYTECODE } from "~~/utils/constants";
+import { notification } from "~~/utils/scaffold-eth";
+
+export const AddOracleButton = () => {
+  const { data: walletClient } = useWalletClient();
+  const publicClient = usePublicClient();
+  const nativeCurrencyPrice = useGlobalState(state => state.nativeCurrency.price);
+
+  const { writeContractAsync: writeWhitelistOracle } = useScaffoldWriteContract({ contractName: "WhitelistOracle" });
+
+  const handleAddOracle = async () => {
+    if (!walletClient || !publicClient) {
+      notification.error("Please connect wallet and enter both oracle owner address and initial price");
+      return;
+    }
+
+    try {
+      // Step 1: Deploy new SimpleOracle instance
+      const deployTxHash = await walletClient.deployContract({
+        abi: SIMPLE_ORACLE_ABI,
+        bytecode: SIMPLE_ORACLE_BYTECODE,
+        args: [],
+      });
+
+      // Wait for deployment transaction receipt
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: deployTxHash,
+      });
+
+      const oracleAddress = receipt.contractAddress;
+
+      if (!oracleAddress) {
+        throw new Error("Failed to get deployed contract address");
+      }
+
+      // Step 2: Add oracle to whitelist
+      await writeWhitelistOracle({
+        functionName: "addOracle",
+        args: [oracleAddress],
+      });
+
+      // Step 3: Set initial price on the newly deployed oracle
+      const initialPrice = nativeCurrencyPrice > 0 ? nativeCurrencyPrice : INITIAL_ETH_PRICE;
+      const priceInWei = parseEther(initialPrice.toString());
+
+      const setPriceTxHash = await walletClient.writeContract({
+        address: oracleAddress,
+        abi: SIMPLE_ORACLE_ABI,
+        functionName: "setPrice",
+        args: [priceInWei],
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash: setPriceTxHash,
+      });
+    } catch (error: any) {
+      console.log("Error adding oracle:", error);
+    }
+  };
+
+  return (
+    <button className="btn btn-primary h-full btn-sm font-normal gap-1" onClick={handleAddOracle}>
+      <PlusIcon className="h-4 w-4" />
+      <span>Add Oracle Node</span>
+    </button>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
new file mode 100644
index 00000000..5dcd827f
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
@@ -0,0 +1,60 @@
+import { useEffect } from "react";
+import { EditableCell } from "../EditableCell";
+import { formatEther } from "viem";
+import { useBlockNumber, useReadContract } from "wagmi";
+import { HighlightedCell } from "~~/components/oracle/HighlightedCell";
+import { WhitelistRowProps } from "~~/components/oracle/types";
+import { Address } from "~~/components/scaffold-eth";
+import { useScaffoldReadContract, useSelectedNetwork } from "~~/hooks/scaffold-eth";
+import { SIMPLE_ORACLE_ABI } from "~~/utils/constants";
+import { getHighlightColorForPrice } from "~~/utils/helpers";
+
+export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
+  const selectedNetwork = useSelectedNetwork();
+
+  const { data, refetch } = useReadContract({
+    address: address,
+    abi: SIMPLE_ORACLE_ABI,
+    functionName: "getPrice",
+    query: {
+      enabled: true,
+    },
+  }) as { data: readonly [bigint, bigint] | undefined; refetch: () => void };
+
+  const { data: blockNumber } = useBlockNumber({
+    watch: true,
+    chainId: selectedNetwork.id,
+    query: {
+      enabled: true,
+    },
+  });
+
+  useEffect(() => {
+    refetch();
+  }, [blockNumber, refetch]);
+
+  const { data: medianPrice } = useScaffoldReadContract({
+    contractName: "WhitelistOracle",
+    functionName: "getPrice",
+    watch: true,
+  }) as { data: bigint | undefined };
+
+  const lastReportedPriceFormatted =
+    data !== undefined ? Number(parseFloat(formatEther(data[0])).toFixed(2)) : "Not reported";
+
+  return (
+    <tr className={`table-fixed ${isActive ? "" : "opacity-40"}`}>
+      <td>
+        <Address address={address} size="sm" format="short" onlyEnsOrAddress={true} />
+      </td>
+      <EditableCell
+        value={lastReportedPriceFormatted}
+        address={address}
+        highlightColor={getHighlightColorForPrice(data?.[0], medianPrice)}
+      />
+      <HighlightedCell value={isActive ? "active" : "stale"} highlightColor={""}>
+        {isActive ? "Active" : "Stale"}
+      </HighlightedCell>
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
new file mode 100644
index 00000000..7548d671
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
@@ -0,0 +1,112 @@
+import TooltipInfo from "~~/components/TooltipInfo";
+import { AddOracleButton } from "~~/components/oracle/whitelist/AddOracleButton";
+import { WhitelistRow } from "~~/components/oracle/whitelist/WhitelistRow";
+import { useScaffoldEventHistory, useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+
+const LoadingRow = () => {
+  return (
+    <tr>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-32"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-20"></div>
+      </td>
+      <td className="animate-pulse">
+        <div className="h-8 bg-secondary rounded w-24"></div>
+      </td>
+    </tr>
+  );
+};
+
+const NoNodesRow = () => {
+  return (
+    <tr>
+      <td colSpan={3} className="text-center">
+        No nodes found
+      </td>
+    </tr>
+  );
+};
+
+export const WhitelistTable = () => {
+  const { data: oraclesAdded, isLoading: isLoadingOraclesAdded } = useScaffoldEventHistory({
+    contractName: "WhitelistOracle",
+    eventName: "OracleAdded",
+    fromBlock: 0n,
+    watch: true,
+  });
+
+  const { data: oraclesRemoved, isLoading: isLoadingOraclesRemoved } = useScaffoldEventHistory({
+    contractName: "WhitelistOracle",
+    eventName: "OracleRemoved",
+    fromBlock: 0n,
+    watch: true,
+  });
+
+  const { data: activeOracleNodes } = useScaffoldReadContract({
+    contractName: "WhitelistOracle",
+    functionName: "getActiveOracleNodes",
+    watch: true,
+  });
+
+  const isLoading = isLoadingOraclesAdded || isLoadingOraclesRemoved;
+  const oracleAddresses = oraclesAdded
+    ?.map((item, index) => ({
+      address: item?.args?.oracleAddress as string,
+      originalIndex: index,
+    }))
+    ?.filter(item => !oraclesRemoved?.some(removedOracle => removedOracle?.args?.oracleAddress === item.address));
+
+  const tooltipText = `This table displays registered oracle nodes that provide price data to the system. Nodes are considered active if they've reported within the last 10 seconds. You can add a new oracle node by clicking the "Add Oracle Node" button or edit the price of an oracle node.`;
+
+  return (
+    <div className="flex flex-col gap-2">
+      <div className="flex gap-2 justify-between">
+        <div className="flex items-center gap-2">
+          <h2 className="text-xl font-bold">Oracle Nodes</h2>
+          <span className="text-sm text-gray-500">
+            <TooltipInfo infoText={tooltipText} className="tooltip-right" />
+          </span>
+        </div>
+        <div className="flex gap-2">
+          <AddOracleButton />
+        </div>
+      </div>
+      <div className="bg-base-100 rounded-lg p-4 relative">
+        <div className="overflow-x-auto">
+          <table className="table w-full">
+            <thead>
+              <tr>
+                <th>Node Address</th>
+                <th>
+                  <div className="flex items-center gap-1">
+                    Last Reported Price (USD)
+                    <TooltipInfo infoText="Color shows proximity to median price" />
+                  </div>
+                </th>
+                <th>Last Reported Time</th>
+              </tr>
+            </thead>
+            <tbody>
+              {isLoading ? (
+                <LoadingRow />
+              ) : oracleAddresses?.length === 0 ? (
+                <NoNodesRow />
+              ) : (
+                oracleAddresses?.map((item, arrayIndex) => (
+                  <WhitelistRow
+                    key={arrayIndex}
+                    index={item.originalIndex}
+                    address={item.address}
+                    isActive={activeOracleNodes?.includes(item.address) ?? false}
+                  />
+                ))
+              )}
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/public/hero.png b/extension/packages/nextjs/public/hero.png
new file mode 100644
index 0000000000000000000000000000000000000000..adc0f20d92d665fbdbfcf95d215683d7b1591d1e
GIT binary patch
literal 32545
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
T|J@~o^bZYH-G@~Vp1k^B!DH|X

literal 0
HcmV?d00001

diff --git a/extension/packages/nextjs/public/social-card.png b/extension/packages/nextjs/public/social-card.png
new file mode 100644
index 0000000000000000000000000000000000000000..b003cb0e26e61e64ed8cdedfb9d36bf9e215a395
GIT binary patch
literal 24701
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

literal 0
HcmV?d00001

diff --git a/extension/packages/nextjs/services/store/challengeStore.ts b/extension/packages/nextjs/services/store/challengeStore.ts
new file mode 100644
index 00000000..9c33605e
--- /dev/null
+++ b/extension/packages/nextjs/services/store/challengeStore.ts
@@ -0,0 +1,41 @@
+import { create } from "zustand";
+import { AssertionWithIdAndState } from "~~/components/oracle/types";
+
+/**
+ * Zustand Store
+ *
+ * You can add global state to the app using this useGlobalState, to get & set
+ * values from anywhere in the app.
+ *
+ * Think about it as a global useState.
+ */
+
+type ChallengeState = {
+  // Block timestamp tracking
+  timestamp: bigint | null;
+  setTimestamp: (timestamp: bigint | null) => void;
+  // Optimistic Oracle
+  refetchAssertionStates: () => void;
+  setRefetchAssertionStates: (refetchFn: () => void) => void;
+  // Assertion Modal
+  openAssertion: AssertionWithIdAndState | null;
+  openAssertionModal: (assertion: AssertionWithIdAndState) => void;
+  closeAssertionModal: () => void;
+};
+
+export const useChallengeState = create<ChallengeState>(set => ({
+  // Block timestamp tracking
+  timestamp: null,
+  setTimestamp: (timestamp: bigint | null): void => set(() => ({ timestamp })),
+  // Optimistic Oracle
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  refetchAssertionStates: () => {},
+  setRefetchAssertionStates: (refetchFn: () => void) => set(() => ({ refetchAssertionStates: refetchFn })),
+  // Assertion Modal
+  openAssertion: null,
+  openAssertionModal: (assertion: AssertionWithIdAndState) =>
+    set(state => ({
+      openAssertion: assertion,
+    })),
+  closeAssertionModal: () => set(() => ({ openAssertion: null })),
+}));
diff --git a/extension/packages/nextjs/utils/configUpdater.ts b/extension/packages/nextjs/utils/configUpdater.ts
new file mode 100644
index 00000000..72880a36
--- /dev/null
+++ b/extension/packages/nextjs/utils/configUpdater.ts
@@ -0,0 +1,40 @@
+import fs from "fs";
+import path from "path";
+
+const CONFIG_PATH = path.join(process.cwd(), "..", "hardhat", "scripts", "oracle-bot", "config.json");
+
+export type ConfigKey = "PROBABILITY_OF_SKIPPING_REPORT" | "PRICE_VARIANCE";
+
+export async function updateConfigValue(key: ConfigKey, value: number, nodeAddress?: string): Promise<void> {
+  try {
+    // Read the current config
+    const configContent = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(configContent);
+
+    // Validate the value
+    if (typeof value !== "number" || value < 0) {
+      throw new Error("Value must be a non-negative number");
+    }
+
+    if (key === "PROBABILITY_OF_SKIPPING_REPORT" && value > 1) {
+      throw new Error("Skip probability must be between 0 and 1");
+    }
+
+    if (nodeAddress) {
+      // Update node-specific config
+      if (!config.NODE_CONFIGS[nodeAddress]) {
+        config.NODE_CONFIGS[nodeAddress] = { ...config.NODE_CONFIGS.default };
+      }
+      config.NODE_CONFIGS[nodeAddress][key] = value;
+    } else {
+      // Update default config
+      config.NODE_CONFIGS.default[key] = value;
+    }
+
+    // Write back to file with proper formatting
+    await fs.promises.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error("Error updating config:", error);
+    throw error;
+  }
+}
diff --git a/extension/packages/nextjs/utils/constants.ts b/extension/packages/nextjs/utils/constants.ts
new file mode 100644
index 00000000..d36cc354
--- /dev/null
+++ b/extension/packages/nextjs/utils/constants.ts
@@ -0,0 +1,154 @@
+export const INITIAL_ETH_PRICE = 4000;
+// SimpleOracle bytecode from compiled artifact (Update abi and bytecode if you change the contract)
+export const SIMPLE_ORACLE_BYTECODE =
+  "0x608060405234801561001057600080fd5b50610126806100206000396000f3fe6080604052348015600f57600080fd5b506004361060465760003560e01c806391b7f5ed14604b57806398d5fdca14605c578063a035b1fe14607c578063b80777ea146091575b600080fd5b605a605636600460d8565b6099565b005b600054600154604080519283526020830191909152015b60405180910390f35b608460005481565b6040519081526020016073565b608460015481565b6000819055426001556040518181527f66cbca4f3c64fecf1dcb9ce094abcf7f68c3450a1d4e3a8e917dd621edb4ebe09060200160405180910390a150565b60006020828403121560e957600080fd5b503591905056fea2646970667358221220e7066415d88de574c1c15fd3cdf3d8abc42f8d22a95560aa0d2d03572fd07c3964736f6c63430008140033" as const;
+
+export const SIMPLE_ORACLE_ABI = [
+  {
+    inputs: [],
+    stateMutability: "nonpayable",
+    type: "constructor",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "newPrice",
+        type: "uint256",
+      },
+    ],
+    name: "PriceUpdated",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "getPrice",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "price",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_newPrice",
+        type: "uint256",
+      },
+    ],
+    name: "setPrice",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "timestamp",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+];
+
+export const QUESTIONS_FOR_OO: string[] = [
+  "Did ETH/USD exceed $3,000 at 00:00 UTC on {MONTH} {DAY}, {YEAR}?",
+  "Did the BTC/ETH ratio fall below 14 on {MONTH} {DAY}, {YEAR}?",
+  "Did Uniswap's TVL exceed $10B on {MONTH} {DAY}, {YEAR}?",
+  "Did the Ethereum Cancun upgrade activate before {MONTH} {DAY}, {YEAR}?",
+  "Did the average gas price on Ethereum exceed 200 gwei on {MONTH} {DAY}, {YEAR}?",
+  "Did Ethereum's staking participation rate exceed 25% on {MONTH} {DAY}, {YEAR}?",
+  "Did Base chain have more than 1M daily transactions on {MONTH} {DAY}, {YEAR}?",
+  "Did the SEC approve a Bitcoin ETF before {MONTH} {DAY}, {YEAR}?",
+  "Did OpenSea's trading volume exceed $500M in {MONTH} {YEAR}?",
+  "Did Farcaster have more than 10K active users on {MONTH} {DAY}, {YEAR}?",
+  "Did ENS domains exceed 5M total registrations before {MONTH} {YEAR}?",
+  "Did the total bridged USDC on Arbitrum exceed $2B on {MONTH} {DAY}, {YEAR}?",
+  "Did Optimism's native token OP increase above $1.50 on {MONTH} {DAY}, {YEAR}?",
+  "Did Aave v3 have higher borrow volume than v2 on {MONTH} {DAY}, {YEAR}?",
+  "Did Compound see more than 1,000 liquidations on {MONTH} {DAY}, {YEAR}?",
+  "Did BTC's 24-hour volume exceed $50B on {MONTH} {DAY}, {YEAR}?",
+  "Did Real Madrid win the UEFA Champions League Final in {YEAR}?",
+  "Did G2 Esports win a major tournament in {MONTH} {YEAR}?",
+  "Did the temperature in New York exceed 35°C on {MONTH} {DAY}, {YEAR}?",
+  "Did it rain more than 50mm in London on {MONTH} {DAY}, {YEAR}?",
+  "Did Tokyo experience an earthquake of magnitude 5.0 or higher in {MONTH} {YEAR}?",
+  "Did the Nasdaq Composite fall more than 3% on {MONTH} {DAY}, {YEAR}?",
+  "Did the S&P 500 set a new all-time high on {MONTH} {DAY}, {YEAR}?",
+  "Did the US unemployment rate drop below 4% in {MONTH} {YEAR}?",
+  "Did the average global temperature for {MONTH} {YEAR} exceed that of the previous year?",
+  "Did gold price exceed $2,200/oz on {MONTH} {DAY}, {YEAR}?",
+  "Did YouTube's most viewed video gain more than 10M new views in {MONTH} {YEAR}?",
+  "Did the population of India officially surpass China according to the UN in {YEAR}?",
+  "Did the UEFA Euro 2024 Final have more than 80,000 attendees in the stadium?",
+  "Did a pigeon successfully complete a 500km race in under 10 hours in {MONTH} {YEAR}?",
+  "Did a goat attend a university graduation ceremony wearing a cap and gown on {MONTH} {DAY}, {YEAR}?",
+  "Did someone eat 100 chicken nuggets in under 10 minutes on {MONTH} {DAY}, {YEAR}?",
+  "Did a cat walk across a live TV weather report in {MONTH} {YEAR}?",
+  "Did a cow escape from a farm and get caught on camera riding a water slide in {YEAR}?",
+  "Did a man legally change his name to 'Bitcoin McMoneyface' on {MONTH} {DAY}, {YEAR}?",
+  "Did a squirrel steal a GoPro and film itself on {MONTH} {DAY}, {YEAR}?",
+  "Did someone cosplay as Shrek and complete a full marathon on {MONTH} {DAY}, {YEAR}?",
+  "Did a group of people attempt to cook the world's largest pancake using a flamethrower?",
+  "Did a man propose using a pizza drone delivery on {MONTH} {DAY}, {YEAR}?",
+  "Did a woman knit a sweater large enough to cover a school bus in {MONTH} {YEAR}?",
+  "Did someone attempt to break the world record for most dad jokes told in 1 hour?",
+  "Did an alpaca accidentally join a Zoom meeting for a tech startup on {MONTH} {DAY}, {YEAR}?",
+];
+
+const generateRandomPastDate = (now: Date): Date => {
+  const monthsBack = Math.floor(Math.random() * 2) + 1; // 1–2 months
+  const daysBack = Math.floor(Math.random() * 6) + 10; // 10–15 days
+
+  const pastDate = new Date(now);
+  pastDate.setMonth(pastDate.getMonth() - monthsBack);
+  pastDate.setDate(pastDate.getDate() - daysBack);
+
+  return pastDate;
+};
+
+const replaceDatePlaceholders = (question: string): string => {
+  const now = new Date();
+  const past = generateRandomPastDate(now);
+
+  return question
+    .replace(/\{DAY\}/g, past.getDate().toString())
+    .replace(/\{MONTH\}/g, past.toLocaleDateString("en-US", { month: "long" }))
+    .replace(/\{YEAR\}/g, past.getFullYear().toString());
+};
+
+export const getRandomQuestion = (): string => {
+  const randomIndex = Math.floor(Math.random() * QUESTIONS_FOR_OO.length);
+  const question = QUESTIONS_FOR_OO[randomIndex];
+  return replaceDatePlaceholders(question);
+};
diff --git a/extension/packages/nextjs/utils/helpers.ts b/extension/packages/nextjs/utils/helpers.ts
new file mode 100644
index 00000000..586394ac
--- /dev/null
+++ b/extension/packages/nextjs/utils/helpers.ts
@@ -0,0 +1,36 @@
+import { QUESTIONS_FOR_OO } from "./constants";
+
+const generateRandomPastDate = (now: Date): Date => {
+  const daysBack = Math.floor(Math.random() * 45) + 1; // 1 - 45 days
+
+  const pastDate = new Date(now);
+  pastDate.setDate(pastDate.getDate() - daysBack);
+
+  return pastDate;
+};
+
+const replaceDatePlaceholders = (question: string): string => {
+  const now = new Date();
+  const past = generateRandomPastDate(now);
+
+  return question
+    .replace(/\{DAY\}/g, past.getDate().toString())
+    .replace(/\{MONTH\}/g, past.toLocaleDateString("en-US", { month: "long" }))
+    .replace(/\{YEAR\}/g, past.getFullYear().toString());
+};
+
+export const getRandomQuestion = (): string => {
+  const randomIndex = Math.floor(Math.random() * QUESTIONS_FOR_OO.length);
+  const question = QUESTIONS_FOR_OO[randomIndex];
+  return replaceDatePlaceholders(question);
+};
+
+export const getHighlightColorForPrice = (currentPrice: bigint | undefined, medianPrice: bigint | undefined) => {
+  if (currentPrice === undefined || medianPrice === undefined) return "";
+  const medianPriceNum = Number(medianPrice);
+  if (medianPriceNum === 0) return "";
+  const percentageChange = Math.abs((Number(currentPrice) - medianPriceNum) / medianPriceNum) * 100;
+  if (percentageChange < 5) return "bg-success";
+  else if (percentageChange < 10) return "bg-warning";
+  else return "bg-error";
+};

From c5fea2f2e5ccafffbc974296565042ac57fb49d1 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 22 Aug 2025 14:12:43 -0400
Subject: [PATCH 06/34] formatting changes

---
 .../00_Whitelist/WhitelistOracle.sol          |  2 +-
 .../contracts/01_Staking/StakingOracle.sol    |  6 +--
 .../contracts/02_Optimistic/Decider.sol       | 14 +++---
 .../02_Optimistic/OptimisticOracle.sol        | 49 ++++++++-----------
 .../nextjs/components/MonitorAndTriggerTx.tsx |  1 +
 5 files changed, 33 insertions(+), 39 deletions(-)

diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
index 0bc201e8..e2a2ae45 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -67,7 +67,7 @@ contract WhitelistOracle {
             validPrices[i] = prices[i];
         }
 
-        // NOTE: It is not efficient to sort onchain, but since we only have 10 oracles 
+        // NOTE: It is not efficient to sort onchain, but since we only have 10 oracles
         // and this is mimicking the early MakerDAO Medianizer exactly, it's fine
         sort(validPrices);
 
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index 40f733ea..c08a9393 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -103,7 +103,7 @@ contract StakingOracle {
         require(rewardAmount > 0, "No rewards available");
 
         nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-        rewardNode(msg.sender, rewardAmount * 10**18);
+        rewardNode(msg.sender, rewardAmount * 10 ** 18);
     }
 
     function slashNodes() public {
@@ -113,8 +113,8 @@ contract StakingOracle {
             slasherReward += slashNode(addressesToSlash[i], 1 ether);
         }
 
-        (bool sent,) = msg.sender.call{value: slasherReward}("");
-        require(sent, "Failed to send reward");        
+        (bool sent, ) = msg.sender.call{ value: slasherReward }("");
+        require(sent, "Failed to send reward");
     }
 
     /* ========== Price Calculation Functions ========== */
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol b/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
index 26f5e6b6..817a272c 100644
--- a/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
+++ b/extension/packages/hardhat/contracts/02_Optimistic/Decider.sol
@@ -6,14 +6,14 @@ import "./OptimisticOracle.sol";
 contract Decider {
     address public owner;
     OptimisticOracle public oracle;
-    
+
     event DisputeSettled(uint256 indexed assertionId, bool resolvedValue);
-    
+
     constructor(address _oracle) {
         owner = msg.sender;
         oracle = OptimisticOracle(_oracle);
     }
-    
+
     /**
      * @notice Settle a dispute by determining the true/false outcome
      * @param assertionId The ID of the assertion to settle
@@ -21,13 +21,13 @@ contract Decider {
      */
     function settleDispute(uint256 assertionId, bool resolvedValue) external {
         require(assertionId >= 1, "Invalid assertion ID");
-        
+
         // Call the oracle's settleAssertion function
         oracle.settleAssertion(assertionId, resolvedValue);
-        
+
         emit DisputeSettled(assertionId, resolvedValue);
     }
-    
+
     function setOracle(address newOracle) external {
         require(msg.sender == owner, "Only owner can set oracle");
         oracle = OptimisticOracle(newOracle);
@@ -37,4 +37,4 @@ contract Decider {
      * @notice Allow the contract to receive ETH
      */
     receive() external payable {}
-} 
+}
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
index 278210fa..5b4a8c5a 100644
--- a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
+++ b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
@@ -2,7 +2,14 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 contract OptimisticOracle {
-    enum State { Invalid, Asserted, Proposed, Disputed, Settled, Expired }
+    enum State {
+        Invalid,
+        Asserted,
+        Proposed,
+        Disputed,
+        Settled,
+        Expired
+    }
 
     error AssertionNotFound();
     error AssertionProposed();
@@ -72,39 +79,25 @@ contract OptimisticOracle {
         return assertions[assertionId];
     }
 
-    function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
-
-    }
-
-    function proposeOutcome(uint256 assertionId, bool outcome) external payable {
-
-    }
-
-    function disputeOutcome(uint256 assertionId) external payable {
-  
-    }
-
-    function claimUndisputedReward(uint256 assertionId) external {
+    function assertEvent(
+        string memory description,
+        uint256 startTime,
+        uint256 endTime
+    ) external payable returns (uint256) {}
 
-    }
+    function proposeOutcome(uint256 assertionId, bool outcome) external payable {}
 
-    function claimDisputedReward(uint256 assertionId) external {
+    function disputeOutcome(uint256 assertionId) external payable {}
 
-    }
+    function claimUndisputedReward(uint256 assertionId) external {}
 
-    function claimRefund(uint256 assertionId) external {
+    function claimDisputedReward(uint256 assertionId) external {}
 
-    }
+    function claimRefund(uint256 assertionId) external {}
 
-    function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {
-
-    }
+    function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {}
 
-    function getState(uint256 assertionId) external view returns (State) {
+    function getState(uint256 assertionId) external view returns (State) {}
 
-    }
-
-    function getResolution(uint256 assertionId) external view returns (bool) {
-
-    }
+    function getResolution(uint256 assertionId) external view returns (bool) {}
 }
diff --git a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
index 1e93f98e..bbac5c8c 100644
--- a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
+++ b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { useEffect, useRef } from "react";
 import { parseEther } from "viem";
 import { hardhat } from "viem/chains";

From 8c687359805446f69f3bdba4394a5a545790507d Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 22 Aug 2025 14:30:22 -0400
Subject: [PATCH 07/34] add package.jsons

---
 extension/package.json                                 |  7 +++++++
 extension/packages/hardhat/package.json                | 10 ++++++++++
 .../{runOracleBots.ts => runStakingOracleBots.ts}      |  0
 3 files changed, 17 insertions(+)
 create mode 100644 extension/package.json
 create mode 100644 extension/packages/hardhat/package.json
 rename extension/packages/hardhat/scripts/{runOracleBots.ts => runStakingOracleBots.ts} (100%)

diff --git a/extension/package.json b/extension/package.json
new file mode 100644
index 00000000..4aa4d730
--- /dev/null
+++ b/extension/package.json
@@ -0,0 +1,7 @@
+{
+    "scripts": {
+        "simulate:whitelist": "yarn workspace @se-2/hardhat simulate:whitelist",
+        "simulate:staking": "yarn workspace @se-2/hardhat simulate:staking",
+        "simulate:optimistic": "yarn workspace @se-2/hardhat simulate:optimistic"
+    }
+}
diff --git a/extension/packages/hardhat/package.json b/extension/packages/hardhat/package.json
new file mode 100644
index 00000000..3cdf7454
--- /dev/null
+++ b/extension/packages/hardhat/package.json
@@ -0,0 +1,10 @@
+{
+    "scripts": {
+        "simulate:whitelist": "hardhat run scripts/runWhitelistOracleBots.ts",
+        "simulate:staking": "hardhat run scripts/runStakingOracleBots.ts",
+        "simulate:optimistic": "hardhat run scripts/runOptimisticBots.ts"
+    },
+    "dependencies": {
+        "@nomicfoundation/hardhat-viem": "^2.0.6"
+    }
+}
diff --git a/extension/packages/hardhat/scripts/runOracleBots.ts b/extension/packages/hardhat/scripts/runStakingOracleBots.ts
similarity index 100%
rename from extension/packages/hardhat/scripts/runOracleBots.ts
rename to extension/packages/hardhat/scripts/runStakingOracleBots.ts

From 8350909ef3ded59a4b690679c10fe16074aa09d1 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 22 Aug 2025 15:20:39 -0400
Subject: [PATCH 08/34] add sort function without OZ dep

---
 .../contracts/01_Staking/StakingOracle.sol    | 24 +++++++++++++++----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index c08a9393..593c33ca 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0 <0.9.0;
 
-import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol";
 import "./OracleToken.sol";
 
 contract StakingOracle {
@@ -103,7 +102,7 @@ contract StakingOracle {
         require(rewardAmount > 0, "No rewards available");
 
         nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-        rewardNode(msg.sender, rewardAmount * 10 ** 18);
+        rewardNode(msg.sender, rewardAmount * 10**18);
     }
 
     function slashNodes() public {
@@ -113,8 +112,8 @@ contract StakingOracle {
             slasherReward += slashNode(addressesToSlash[i], 1 ether);
         }
 
-        (bool sent, ) = msg.sender.call{ value: slasherReward }("");
-        require(sent, "Failed to send reward");
+        (bool sent,) = msg.sender.call{value: slasherReward}("");
+        require(sent, "Failed to send reward");        
     }
 
     /* ========== Price Calculation Functions ========== */
@@ -178,7 +177,7 @@ contract StakingOracle {
         (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
         uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
         require(validPrices.length > 0, "No valid prices available");
-        Arrays.sort(validPrices);
+        sort(validPrices);
         return getMedian(validPrices);
     }
 
@@ -186,5 +185,20 @@ contract StakingOracle {
         return nodeAddresses;
     }
 
+    function sort(uint256[] memory arr) internal pure {
+        uint256 n = arr.length;
+        for (uint256 i = 0; i < n; i++) {
+            uint256 minIndex = i;
+            for (uint256 j = i + 1; j < n; j++) {
+                if (arr[j] < arr[minIndex]) {
+                    minIndex = j;
+                }
+            }
+            if (minIndex != i) {
+                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
+            }
+        }
+    }
+
     // Notably missing a way to unstake and exit your node but not needed for the challenge
 }

From e32446b15298e4fa9d205d4bfd4f6fb3806d6a82 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 22 Aug 2025 15:32:30 -0400
Subject: [PATCH 09/34] add Hardhat configuration and formatting updates

---
 .../packages/hardhat/contracts/01_Staking/StakingOracle.sol | 6 +++---
 extension/packages/hardhat/hardhat.config.ts.args.mjs       | 3 +++
 extension/packages/hardhat/scripts/oracle-bot/config.json   | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)
 create mode 100644 extension/packages/hardhat/hardhat.config.ts.args.mjs

diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index 593c33ca..f325ef23 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -102,7 +102,7 @@ contract StakingOracle {
         require(rewardAmount > 0, "No rewards available");
 
         nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-        rewardNode(msg.sender, rewardAmount * 10**18);
+        rewardNode(msg.sender, rewardAmount * 10 ** 18);
     }
 
     function slashNodes() public {
@@ -112,8 +112,8 @@ contract StakingOracle {
             slasherReward += slashNode(addressesToSlash[i], 1 ether);
         }
 
-        (bool sent,) = msg.sender.call{value: slasherReward}("");
-        require(sent, "Failed to send reward");        
+        (bool sent, ) = msg.sender.call{ value: slasherReward }("");
+        require(sent, "Failed to send reward");
     }
 
     /* ========== Price Calculation Functions ========== */
diff --git a/extension/packages/hardhat/hardhat.config.ts.args.mjs b/extension/packages/hardhat/hardhat.config.ts.args.mjs
new file mode 100644
index 00000000..5d4d972a
--- /dev/null
+++ b/extension/packages/hardhat/hardhat.config.ts.args.mjs
@@ -0,0 +1,3 @@
+export const preContent = `
+import "@nomicfoundation/hardhat-viem";
+`;
diff --git a/extension/packages/hardhat/scripts/oracle-bot/config.json b/extension/packages/hardhat/scripts/oracle-bot/config.json
index 0220acc3..7417fecf 100644
--- a/extension/packages/hardhat/scripts/oracle-bot/config.json
+++ b/extension/packages/hardhat/scripts/oracle-bot/config.json
@@ -53,4 +53,4 @@
       "PRICE_VARIANCE": 0.05
     }
   }
-}
\ No newline at end of file
+}

From f95d79c600d2e735ee3b374b5f36796c058e153b Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Sat, 23 Aug 2025 06:33:38 -0400
Subject: [PATCH 10/34] add children to monitor tx

---
 extension/packages/nextjs/components/MonitorAndTriggerTx.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
index bbac5c8c..8ab38318 100644
--- a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
+++ b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
@@ -7,7 +7,7 @@ import { useTargetNetwork } from "~~/hooks/scaffold-eth";
 import { useChallengeState } from "~~/services/store/challengeStore";
 
 // This component is used to monitor the block timestamp and trigger a transaction if the timestamp has not changed for 3 seconds
-export const MonitorAndTriggerTx = () => {
+export const MonitorAndTriggerTx = ({ children }: { children: React.ReactNode }) => {
   const publicClient = usePublicClient();
   const { data: walletClient } = useWalletClient();
   const { targetNetwork } = useTargetNetwork();
@@ -62,5 +62,5 @@ export const MonitorAndTriggerTx = () => {
     return () => clearInterval(interval);
   }, [publicClient, walletClient, isLocalNetwork, isBurnerWallet, setTimestamp, refetchAssertionStates]);
 
-  return null;
+  return <>{children}</>;
 };

From 2c1bf2cd5ee7ec59af92717fb19d4f3fda877d88 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Tue, 26 Aug 2025 13:36:23 -0400
Subject: [PATCH 11/34] update oracle-bot config values, enhance tooltip
 styling, and rename table header for clarity

---
 extension/packages/hardhat/scripts/oracle-bot/config.json  | 4 ++--
 extension/packages/nextjs/components/TooltipInfo.tsx       | 2 +-
 extension/packages/nextjs/components/oracle/NodesTable.tsx | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/extension/packages/hardhat/scripts/oracle-bot/config.json b/extension/packages/hardhat/scripts/oracle-bot/config.json
index 7417fecf..87610b6a 100644
--- a/extension/packages/hardhat/scripts/oracle-bot/config.json
+++ b/extension/packages/hardhat/scripts/oracle-bot/config.json
@@ -1,7 +1,7 @@
 {
   "PRICE": {
-    "CACHEDPRICE": 4211.966627258689,
-    "TIMESTAMP": 1754950566641
+    "CACHEDPRICE": 4727.951731802994,
+    "TIMESTAMP": 1755945851563
   },
   "INTERVALS": {
     "PRICE_REPORT": 1750,
diff --git a/extension/packages/nextjs/components/TooltipInfo.tsx b/extension/packages/nextjs/components/TooltipInfo.tsx
index cf033bc4..b947b19f 100644
--- a/extension/packages/nextjs/components/TooltipInfo.tsx
+++ b/extension/packages/nextjs/components/TooltipInfo.tsx
@@ -10,7 +10,7 @@ interface TooltipInfoProps {
 
 // Note: The relative positioning is required for the tooltip to work.
 const TooltipInfo: React.FC<TooltipInfoProps> = ({ top, right, infoText, className = "" }) => {
-  const baseClasses = "tooltip tooltip-secondary font-normal";
+  const baseClasses = "tooltip tooltip-secondary font-normal [--radius-field:0.25rem]";
   const tooltipClasses = className ? `${baseClasses} ${className}` : `${baseClasses} tooltip-right`;
 
   if (top !== undefined && right !== undefined) {
diff --git a/extension/packages/nextjs/components/oracle/NodesTable.tsx b/extension/packages/nextjs/components/oracle/NodesTable.tsx
index a2fd3c73..1c894cb1 100644
--- a/extension/packages/nextjs/components/oracle/NodesTable.tsx
+++ b/extension/packages/nextjs/components/oracle/NodesTable.tsx
@@ -71,7 +71,7 @@ export const NodesTable = () => {
                 <th>Node Address</th>
                 <th>
                   <div className="flex items-center gap-1">
-                    Staked Amount (ETH)
+                    Staked ETH
                     <TooltipInfo infoText="Red shows slashing event" />
                   </div>
                 </th>

From 70a92573d01aeba0230d5b1a002fcc5a1f43e7c9 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Tue, 26 Aug 2025 14:56:04 -0400
Subject: [PATCH 12/34] Refactor deployment scripts to conditionally execute on
 localhost, ensuring proper handling of oracle additions and price settings.
 Remove unnecessary fromBlock parameters in WhitelistTable component event
 listeners for cleaner code.

---
 .../hardhat/deploy/00_deploy_whitelist.ts     | 110 +++++++++---------
 .../hardhat/deploy/01_deploy_staking.ts       |  16 ++-
 .../oracle/whitelist/WhitelistTable.tsx       |   2 -
 3 files changed, 67 insertions(+), 61 deletions(-)

diff --git a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
index 3bf1431c..c32675ef 100644
--- a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
+++ b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
@@ -46,65 +46,69 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
   const whitelistOracleAddress = whitelistOracleDeployment.address as `0x${string}`;
   const whitelistOracleAbi = whitelistOracleDeployment.abi;
 
-  // Add all SimpleOracle addresses to WhitelistOracle
-  console.log("Adding SimpleOracle instances to WhitelistOracle...");
-  const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
-  if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
+  // Skip the rest of the setup if we are on a live network
+  if (hre.network.name === "localhost") {
+    // Add all SimpleOracle addresses to WhitelistOracle
+    console.log("Adding SimpleOracle instances to WhitelistOracle...");
+    const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
+    if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
 
-  try {
-    for (let i = 0; i < simpleOracleAddresses.length; i++) {
-      const oracleAddress = simpleOracleAddresses[i] as `0x${string}`;
-      console.log(`Adding SimpleOracle ${i + 1}/10: ${oracleAddress}`);
-      await deployerAccount.writeContract({
-        address: whitelistOracleAddress,
-        abi: whitelistOracleAbi,
-        functionName: "addOracle",
-        args: [oracleAddress],
-      });
-    }
-  } catch (error: any) {
-    if (error.message?.includes("Oracle already exists")) {
-      console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
-      console.error("🔧 Please retry with:");
-      console.error("yarn deploy --reset\n");
-      process.exit(1);
-    } else {
-      throw error;
+    try {
+      for (let i = 0; i < simpleOracleAddresses.length; i++) {
+        const oracleAddress = simpleOracleAddresses[i] as `0x${string}`;
+        console.log(`Adding SimpleOracle ${i + 1}/10: ${oracleAddress}`);
+        await deployerAccount.writeContract({
+          address: whitelistOracleAddress,
+          abi: whitelistOracleAbi,
+          functionName: "addOracle",
+          args: [oracleAddress],
+        });
+      }
+    } catch (error: any) {
+      if (hre.network.name === "localhost") {
+        if (error.message?.includes("Oracle already exists")) {
+          console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
+          console.error("🔧 Please retry with:");
+          console.error("yarn deploy --reset\n");
+          process.exit(1);
+        } else {
+          throw error;
+        }
+      }
     }
-  }
 
-  // Set initial prices for each SimpleOracle
-  console.log("Setting initial prices for each SimpleOracle...");
-  const initialPrice = await fetchPriceFromUniswap();
-  for (let i = 0; i < nodeAccounts.length; i++) {
-    const account = nodeAccounts[i];
-    const simpleOracleDeployment = await hre.deployments.get(`SimpleOracle_${i + 1}`);
-    const simpleOracleAbi = simpleOracleDeployment.abi;
-    const simpleOracleAddress = simpleOracleDeployment.address as `0x${string}`;
-    await account.writeContract({
-      address: simpleOracleAddress,
-      abi: simpleOracleAbi,
-      functionName: "setPrice",
-      args: [initialPrice],
-    });
-
-    await publicClient.transport.request({
-      method: "evm_mine",
-    });
+    // Set initial prices for each SimpleOracle
+    console.log("Setting initial prices for each SimpleOracle...");
+    const initialPrice = await fetchPriceFromUniswap();
+    for (let i = 0; i < nodeAccounts.length; i++) {
+      const account = nodeAccounts[i];
+      const simpleOracleDeployment = await hre.deployments.get(`SimpleOracle_${i + 1}`);
+      const simpleOracleAbi = simpleOracleDeployment.abi;
+      const simpleOracleAddress = simpleOracleDeployment.address as `0x${string}`;
+      await account.writeContract({
+        address: simpleOracleAddress,
+        abi: simpleOracleAbi,
+        functionName: "setPrice",
+        args: [initialPrice],
+      });
 
-    console.log(`Set price for SimpleOracle_${i + 1} to: ${initialPrice}`);
-  }
+      await publicClient.transport.request({
+        method: "evm_mine",
+      });
 
-  // Calculate initial median price
-  console.log("Calculating initial median price...");
-  const medianPrice = await publicClient.readContract({
-    address: whitelistOracleAddress,
-    abi: whitelistOracleAbi,
-    functionName: "getPrice",
-    args: [],
-  });
-  console.log(`Initial median price: ${medianPrice.toString()}`);
+      console.log(`Set price for SimpleOracle_${i + 1} to: ${initialPrice}`);
+    }
 
+    // Calculate initial median price
+    console.log("Calculating initial median price...");
+    const medianPrice = await publicClient.readContract({
+      address: whitelistOracleAddress,
+      abi: whitelistOracleAbi,
+      functionName: "getPrice",
+      args: [],
+    });
+    console.log(`Initial median price: ${medianPrice.toString()}`);
+  }
   console.log("All oracle contracts deployed and configured successfully!");
 };
 
diff --git a/extension/packages/hardhat/deploy/01_deploy_staking.ts b/extension/packages/hardhat/deploy/01_deploy_staking.ts
index f42780ef..2dc0463b 100644
--- a/extension/packages/hardhat/deploy/01_deploy_staking.ts
+++ b/extension/packages/hardhat/deploy/01_deploy_staking.ts
@@ -57,9 +57,11 @@ const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeE
     }
   }
 
-  await publicClient.transport.request({
-    method: "evm_mine",
-  });
+  if (hre.network.name === "localhost") {
+    await publicClient.transport.request({
+      method: "evm_mine",
+    });
+  }
 
   await Promise.all(
     nodeAccounts.map(account => {
@@ -72,9 +74,11 @@ const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeE
     }),
   );
 
-  await publicClient.transport.request({
-    method: "evm_mine",
-  });
+  if (hre.network.name === "localhost") {
+    await publicClient.transport.request({
+      method: "evm_mine",
+    });
+  }
 };
 
 export default deployStakingOracle;
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
index 7548d671..5afae28c 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
@@ -33,14 +33,12 @@ export const WhitelistTable = () => {
   const { data: oraclesAdded, isLoading: isLoadingOraclesAdded } = useScaffoldEventHistory({
     contractName: "WhitelistOracle",
     eventName: "OracleAdded",
-    fromBlock: 0n,
     watch: true,
   });
 
   const { data: oraclesRemoved, isLoading: isLoadingOraclesRemoved } = useScaffoldEventHistory({
     contractName: "WhitelistOracle",
     eventName: "OracleRemoved",
-    fromBlock: 0n,
     watch: true,
   });
 

From a6293332d33ac15edfd2df873f532bb04494459a Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Thu, 11 Sep 2025 14:15:52 +0200
Subject: [PATCH 13/34] address feedback

- whitelist as factory contract
- create library which includes sort and gerMedian
- use custom errors
- update deploy script
- fix frontend accordingly
---
 .../contracts/00_Whitelist/SimpleOracle.sol   |  9 ++-
 .../00_Whitelist/WhitelistOracle.sol          | 66 +++++------------
 .../contracts/01_Staking/StakingOracle.sol    | 55 ++++++---------
 .../hardhat/deploy/00_deploy_whitelist.ts     | 70 ++++++++++---------
 .../hardhat/scripts/oracle-bot/config.json    |  6 +-
 .../oracle/whitelist/AddOracleButton.tsx      | 42 ++---------
 .../oracle/whitelist/WhitelistRow.tsx         |  3 +-
 .../oracle/whitelist/WhitelistTable.tsx       |  4 +-
 extension/packages/nextjs/utils/constants.ts  |  3 -
 9 files changed, 97 insertions(+), 161 deletions(-)

diff --git a/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
index a80e92bc..d027e600 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
@@ -2,16 +2,21 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 contract SimpleOracle {
+    error OnlyOwner();
+
     uint256 public price;
     uint256 public timestamp;
+    address public owner;
 
     event PriceUpdated(uint256 newPrice);
 
-    constructor() {}
+    constructor(address _owner) {
+        owner = _owner;
+    }
 
     modifier onlyOwner() {
         // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
-        // require(msg.sender == owner, "Not the owner");
+        // if (msg.sender != owner) revert OnlyOwner();
         _;
     }
 
diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
index e2a2ae45..ebc274a4 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -2,12 +2,19 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 import "./SimpleOracle.sol";
+import { StatisticsUtils } from "../utils/StatisticsUtils.sol";
 
 contract WhitelistOracle {
+    using StatisticsUtils for uint256[];
+
+    error OnlyOwner();
+    error IndexOutOfBounds();
+    error NoOraclesAvailable();
+
     address public owner;
     SimpleOracle[] public oracles;
 
-    event OracleAdded(address oracleAddress);
+    event OracleAdded(address oracleAddress, address oracleOwner);
     event OracleRemoved(address oracleAddress);
 
     constructor() {
@@ -16,21 +23,20 @@ contract WhitelistOracle {
 
     modifier onlyOwner() {
         // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
-        // require(msg.sender == owner, "Not the owner");
+        // if (msg.sender != owner) revert OnlyOwner();
         _;
     }
 
-    function addOracle(address oracle) public onlyOwner {
-        require(oracle != address(0), "Invalid oracle address");
-        for (uint256 i = 0; i < oracles.length; i++) {
-            require(address(oracles[i]) != oracle, "Oracle already exists");
-        }
-        oracles.push(SimpleOracle(oracle));
-        emit OracleAdded(oracle);
+    function addOracle(address _owner) public onlyOwner {
+        SimpleOracle newOracle = new SimpleOracle(_owner);
+        address oracleAddress = address(newOracle);
+
+        oracles.push(newOracle);
+        emit OracleAdded(oracleAddress, _owner);
     }
 
     function removeOracle(uint256 index) public onlyOwner {
-        require(index < oracles.length, "Index out of bounds");
+        if (index >= oracles.length) revert IndexOutOfBounds();
 
         address oracleAddress = address(oracles[index]);
 
@@ -44,7 +50,7 @@ contract WhitelistOracle {
     }
 
     function getPrice() public view returns (uint256) {
-        require(oracles.length > 0, "No oracles available");
+        if (oracles.length == 0) revert NoOraclesAvailable();
 
         // Collect prices and timestamps from all oracles
         uint256[] memory prices = new uint256[](oracles.length);
@@ -60,26 +66,13 @@ contract WhitelistOracle {
             }
         }
 
-        require(validCount > 0, "No valid prices available");
-
         uint256[] memory validPrices = new uint256[](validCount);
         for (uint256 i = 0; i < validCount; i++) {
             validPrices[i] = prices[i];
         }
 
-        // NOTE: It is not efficient to sort onchain, but since we only have 10 oracles
-        // and this is mimicking the early MakerDAO Medianizer exactly, it's fine
-        sort(validPrices);
-
-        uint256 median;
-        if (validCount % 2 == 0) {
-            uint256 midIndex = validCount / 2;
-            median = (validPrices[midIndex - 1] + validPrices[midIndex]) / 2;
-        } else {
-            median = validPrices[validCount / 2];
-        }
-
-        return median;
+        validPrices.sort();
+        return validPrices.getMedian();
     }
 
     function getActiveOracleNodes() public view returns (address[] memory) {
@@ -101,25 +94,4 @@ contract WhitelistOracle {
 
         return activeNodes;
     }
-
-    function transferOwnership(address newOwner) public onlyOwner {
-        require(newOwner != address(0), "New owner cannot be zero address");
-        require(newOwner != owner, "New owner cannot be the same as current owner");
-        owner = newOwner;
-    }
-
-    function sort(uint256[] memory arr) internal pure {
-        uint256 n = arr.length;
-        for (uint256 i = 0; i < n; i++) {
-            uint256 minIndex = i;
-            for (uint256 j = i + 1; j < n; j++) {
-                if (arr[j] < arr[minIndex]) {
-                    minIndex = j;
-                }
-            }
-            if (minIndex != i) {
-                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
-            }
-        }
-    }
 }
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index f325ef23..d46f7c89 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -2,8 +2,19 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 import "./OracleToken.sol";
+import { StatisticsUtils } from "../utils/StatisticsUtils.sol";
 
 contract StakingOracle {
+    using StatisticsUtils for uint256[];
+
+    error NodeNotRegistered();
+    error InsufficientStake();
+    error NodeAlreadyRegistered();
+    error NotEnoughStake();
+    error NoRewardsAvailable();
+    error FailedToSendReward();
+    error NoValidPricesAvailable();
+
     ORA public oracleToken;
 
     struct OracleNode {
@@ -33,7 +44,7 @@ contract StakingOracle {
     address public oracleTokenAddress;
 
     modifier onlyNode() {
-        require(nodes[msg.sender].nodeAddress != address(0), "Node not registered");
+        if (nodes[msg.sender].nodeAddress == address(0)) revert NodeNotRegistered();
         _;
     }
 
@@ -43,8 +54,8 @@ contract StakingOracle {
 
     /* ========== Oracle Node Operation Functions ========== */
     function registerNode(uint256 initialPrice) public payable {
-        require(msg.value >= MINIMUM_STAKE, "Insufficient stake");
-        require(nodes[msg.sender].nodeAddress == address(0), "Node already registered");
+        if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
+        if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
 
         nodes[msg.sender] = OracleNode({
             nodeAddress: msg.sender,
@@ -63,7 +74,7 @@ contract StakingOracle {
 
     function reportPrice(uint256 price) public onlyNode {
         OracleNode storage node = nodes[msg.sender];
-        require(node.stakedAmount >= MINIMUM_STAKE, "Not enough stake");
+        if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
         node.lastReportedPrice = price;
         node.lastReportedTimestamp = block.timestamp;
 
@@ -99,7 +110,7 @@ contract StakingOracle {
             rewardAmount = block.timestamp - node.lastClaimedTimestamp;
         }
 
-        require(rewardAmount > 0, "No rewards available");
+        if (rewardAmount == 0) revert NoRewardsAvailable();
 
         nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
         rewardNode(msg.sender, rewardAmount * 10 ** 18);
@@ -113,17 +124,7 @@ contract StakingOracle {
         }
 
         (bool sent, ) = msg.sender.call{ value: slasherReward }("");
-        require(sent, "Failed to send reward");
-    }
-
-    /* ========== Price Calculation Functions ========== */
-    function getMedian(uint256[] memory arr) internal pure returns (uint256) {
-        uint256 length = arr.length;
-        if (length % 2 == 0) {
-            return (arr[length / 2 - 1] + arr[length / 2]) / 2;
-        } else {
-            return arr[length / 2];
-        }
+        if (!sent) revert FailedToSendReward();
     }
 
     function separateStaleNodes(
@@ -176,29 +177,15 @@ contract StakingOracle {
     function getPrice() public view returns (uint256) {
         (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
         uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
-        require(validPrices.length > 0, "No valid prices available");
-        sort(validPrices);
-        return getMedian(validPrices);
+        if (validPrices.length == 0) revert NoValidPricesAvailable();
+        
+        validPrices.sort();
+        return validPrices.getMedian();
     }
 
     function getNodeAddresses() public view returns (address[] memory) {
         return nodeAddresses;
     }
 
-    function sort(uint256[] memory arr) internal pure {
-        uint256 n = arr.length;
-        for (uint256 i = 0; i < n; i++) {
-            uint256 minIndex = i;
-            for (uint256 j = i + 1; j < n; j++) {
-                if (arr[j] < arr[minIndex]) {
-                    minIndex = j;
-                }
-            }
-            if (minIndex != i) {
-                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
-            }
-        }
-    }
-
     // Notably missing a way to unstake and exit your node but not needed for the challenge
 }
diff --git a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
index c32675ef..f0f9a8e1 100644
--- a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
+++ b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
@@ -22,18 +22,18 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
   const simpleOracleAddresses: string[] = [];
 
   // Deploy 10 SimpleOracle contracts, each owned by a different account
-  for (let i = 0; i < nodeAccounts.length; i++) {
-    const account = nodeAccounts[i];
-    console.log(`Deploying SimpleOracle ${i + 1}/10 from account: ${account.account.address}`);
-    const simpleOracle = await deploy(`SimpleOracle_${i + 1}`, {
-      contract: "SimpleOracle",
-      from: account.account.address,
-      args: [],
-      log: true,
-      autoMine: true,
-    });
-    simpleOracleAddresses.push(simpleOracle.address);
-  }
+  // for (let i = 0; i < nodeAccounts.length; i++) {
+  //   const account = nodeAccounts[i];
+  //   console.log(`Deploying SimpleOracle ${i + 1}/10 from account: ${account.account.address}`);
+  //   const simpleOracle = await deploy(`SimpleOracle_${i + 1}`, {
+  //     contract: "SimpleOracle",
+  //     from: account.account.address,
+  //     args: [],
+  //     log: true,
+  //     autoMine: true,
+  //   });
+  //   simpleOracleAddresses.push(simpleOracle.address);
+  // }
 
   console.log("Deploying WhitelistOracle...");
 
@@ -50,32 +50,38 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
   if (hre.network.name === "localhost") {
     // Add all SimpleOracle addresses to WhitelistOracle
     console.log("Adding SimpleOracle instances to WhitelistOracle...");
-    const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
-    if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
+    const createdOracleAddresses: string[] = [];
+    // const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
+    // if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
 
-    try {
-      for (let i = 0; i < simpleOracleAddresses.length; i++) {
-        const oracleAddress = simpleOracleAddresses[i] as `0x${string}`;
-        console.log(`Adding SimpleOracle ${i + 1}/10: ${oracleAddress}`);
-        await deployerAccount.writeContract({
+    // try {
+      for (let i = 0; i < nodeAccounts.length; i++) {
+        const account = nodeAccounts[i];
+        console.log(`Adding SimpleOracle ${i + 1}/10: ${account.account.address}`);
+        const txHash = await account.writeContract({
           address: whitelistOracleAddress,
           abi: whitelistOracleAbi,
           functionName: "addOracle",
-          args: [oracleAddress],
+          args: [account.account.address],
         });
+
+        const receipt = await publicClient.waitForTransactionReceipt({
+          hash: txHash,
+        });
+        const
       }
-    } catch (error: any) {
-      if (hre.network.name === "localhost") {
-        if (error.message?.includes("Oracle already exists")) {
-          console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
-          console.error("🔧 Please retry with:");
-          console.error("yarn deploy --reset\n");
-          process.exit(1);
-        } else {
-          throw error;
-        }
-      }
-    }
+    // } catch (error: any) {
+    //   if (hre.network.name === "localhost") {
+    //     if (error.message?.includes("Oracle already exists")) {
+    //       console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
+    //       console.error("🔧 Please retry with:");
+    //       console.error("yarn deploy --reset\n");
+    //       process.exit(1);
+    //     } else {
+    //       throw error;
+    //     }
+    //   }
+    // }
 
     // Set initial prices for each SimpleOracle
     console.log("Setting initial prices for each SimpleOracle...");
diff --git a/extension/packages/hardhat/scripts/oracle-bot/config.json b/extension/packages/hardhat/scripts/oracle-bot/config.json
index 87610b6a..6c28ebb5 100644
--- a/extension/packages/hardhat/scripts/oracle-bot/config.json
+++ b/extension/packages/hardhat/scripts/oracle-bot/config.json
@@ -1,7 +1,7 @@
 {
   "PRICE": {
-    "CACHEDPRICE": 4727.951731802994,
-    "TIMESTAMP": 1755945851563
+    "CACHEDPRICE": 4428.637518892757,
+    "TIMESTAMP": 1757587491421
   },
   "INTERVALS": {
     "PRICE_REPORT": 1750,
@@ -53,4 +53,4 @@
       "PRICE_VARIANCE": 0.05
     }
   }
-}
+}
\ No newline at end of file
diff --git a/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx b/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
index 435cb40e..8cf76625 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/AddOracleButton.tsx
@@ -1,15 +1,12 @@
-import { parseEther } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { usePublicClient, useWalletClient } from "wagmi";
 import { PlusIcon } from "@heroicons/react/24/outline";
 import { useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
-import { useGlobalState } from "~~/services/store/store";
-import { INITIAL_ETH_PRICE, SIMPLE_ORACLE_ABI, SIMPLE_ORACLE_BYTECODE } from "~~/utils/constants";
 import { notification } from "~~/utils/scaffold-eth";
 
 export const AddOracleButton = () => {
   const { data: walletClient } = useWalletClient();
   const publicClient = usePublicClient();
-  const nativeCurrencyPrice = useGlobalState(state => state.nativeCurrency.price);
 
   const { writeContractAsync: writeWhitelistOracle } = useScaffoldWriteContract({ contractName: "WhitelistOracle" });
 
@@ -20,44 +17,15 @@ export const AddOracleButton = () => {
     }
 
     try {
-      // Step 1: Deploy new SimpleOracle instance
-      const deployTxHash = await walletClient.deployContract({
-        abi: SIMPLE_ORACLE_ABI,
-        bytecode: SIMPLE_ORACLE_BYTECODE,
-        args: [],
-      });
-
-      // Wait for deployment transaction receipt
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: deployTxHash,
-      });
-
-      const oracleAddress = receipt.contractAddress;
-
-      if (!oracleAddress) {
-        throw new Error("Failed to get deployed contract address");
-      }
+      // Generate a new oracle address
+      const privateKey = generatePrivateKey();
+      const oracleAddress = privateKeyToAccount(privateKey).address;
 
-      // Step 2: Add oracle to whitelist
+      // Add oracle to whitelist
       await writeWhitelistOracle({
         functionName: "addOracle",
         args: [oracleAddress],
       });
-
-      // Step 3: Set initial price on the newly deployed oracle
-      const initialPrice = nativeCurrencyPrice > 0 ? nativeCurrencyPrice : INITIAL_ETH_PRICE;
-      const priceInWei = parseEther(initialPrice.toString());
-
-      const setPriceTxHash = await walletClient.writeContract({
-        address: oracleAddress,
-        abi: SIMPLE_ORACLE_ABI,
-        functionName: "setPrice",
-        args: [priceInWei],
-      });
-
-      await publicClient.waitForTransactionReceipt({
-        hash: setPriceTxHash,
-      });
     } catch (error: any) {
       console.log("Error adding oracle:", error);
     }
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
index 5dcd827f..e467f4b1 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
@@ -39,8 +39,9 @@ export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
     watch: true,
   }) as { data: bigint | undefined };
 
+  const isNotReported = data !== undefined && data[0] === 0n && data[1] === 0n;
   const lastReportedPriceFormatted =
-    data !== undefined ? Number(parseFloat(formatEther(data[0])).toFixed(2)) : "Not reported";
+    data === undefined || isNotReported ? "Not reported" : Number(parseFloat(formatEther(data?.[0] ?? 0n)).toFixed(2));
 
   return (
     <tr className={`table-fixed ${isActive ? "" : "opacity-40"}`}>
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
index 5afae28c..632b9fa9 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
@@ -92,9 +92,9 @@ export const WhitelistTable = () => {
               ) : oracleAddresses?.length === 0 ? (
                 <NoNodesRow />
               ) : (
-                oracleAddresses?.map((item, arrayIndex) => (
+                oracleAddresses?.map(item => (
                   <WhitelistRow
-                    key={arrayIndex}
+                    key={item.address}
                     index={item.originalIndex}
                     address={item.address}
                     isActive={activeOracleNodes?.includes(item.address) ?? false}
diff --git a/extension/packages/nextjs/utils/constants.ts b/extension/packages/nextjs/utils/constants.ts
index d36cc354..0e145ea6 100644
--- a/extension/packages/nextjs/utils/constants.ts
+++ b/extension/packages/nextjs/utils/constants.ts
@@ -1,7 +1,4 @@
 export const INITIAL_ETH_PRICE = 4000;
-// SimpleOracle bytecode from compiled artifact (Update abi and bytecode if you change the contract)
-export const SIMPLE_ORACLE_BYTECODE =
-  "0x608060405234801561001057600080fd5b50610126806100206000396000f3fe6080604052348015600f57600080fd5b506004361060465760003560e01c806391b7f5ed14604b57806398d5fdca14605c578063a035b1fe14607c578063b80777ea146091575b600080fd5b605a605636600460d8565b6099565b005b600054600154604080519283526020830191909152015b60405180910390f35b608460005481565b6040519081526020016073565b608460015481565b6000819055426001556040518181527f66cbca4f3c64fecf1dcb9ce094abcf7f68c3450a1d4e3a8e917dd621edb4ebe09060200160405180910390a150565b60006020828403121560e957600080fd5b503591905056fea2646970667358221220e7066415d88de574c1c15fd3cdf3d8abc42f8d22a95560aa0d2d03572fd07c3964736f6c63430008140033" as const;
 
 export const SIMPLE_ORACLE_ABI = [
   {

From c99eb5d22545992f29cd8740063c0f5485a87233 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Thu, 11 Sep 2025 17:42:13 +0200
Subject: [PATCH 14/34] docs: add natspecs

---
 .../contracts/00_Whitelist/SimpleOracle.sol   |  41 +++++++
 .../00_Whitelist/WhitelistOracle.sol          |  59 +++++++++-
 .../contracts/01_Staking/StakingOracle.sol    |  91 ++++++++++++++-
 .../02_Optimistic/OptimisticOracle.sol        | 108 ++++++++++++++++++
 4 files changed, 292 insertions(+), 7 deletions(-)

diff --git a/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
index d027e600..5ae49a5a 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/SimpleOracle.sol
@@ -2,30 +2,71 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 contract SimpleOracle {
+    /////////////////
+    /// Errors //////
+    /////////////////
+
     error OnlyOwner();
 
+    //////////////////////
+    /// State Variables //
+    //////////////////////
+
     uint256 public price;
     uint256 public timestamp;
     address public owner;
 
+    ////////////////
+    /// Events /////
+    ////////////////
+
     event PriceUpdated(uint256 newPrice);
 
+    ///////////////////
+    /// Constructor ///
+    ///////////////////
+
     constructor(address _owner) {
         owner = _owner;
     }
 
+    ///////////////////
+    /// Modifiers /////
+    ///////////////////
+
+    /**
+     * @notice Modifier to restrict function access to the contract owner
+     * @dev Currently disabled to make it easy for you to impersonate the owner
+     */
     modifier onlyOwner() {
         // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
         // if (msg.sender != owner) revert OnlyOwner();
         _;
     }
 
+    ///////////////////
+    /// Functions /////
+    ///////////////////
+
+    /**
+     * @notice Updates the oracle price with a new value (only contract owner)
+     * @dev Sets the price and records the current block timestamp for freshness tracking.
+     *      Emits PriceUpdated event upon successful update.
+     * @param _newPrice The new price value to set for this oracle
+     */
     function setPrice(uint256 _newPrice) public onlyOwner {
         price = _newPrice;
         timestamp = block.timestamp;
         emit PriceUpdated(_newPrice);
     }
 
+    /**
+     * @notice Returns the current price and its timestamp
+     * @dev Provides both the stored price value and when it was last updated.
+     *      Used by aggregators to determine price freshness.
+     * @return price The current price stored in this oracle
+     * @return timestamp The block timestamp when the price was last updated
+     */
     function getPrice() public view returns (uint256, uint256) {
         return (price, timestamp);
     }
diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
index ebc274a4..f3d0959c 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -7,26 +7,58 @@ import { StatisticsUtils } from "../utils/StatisticsUtils.sol";
 contract WhitelistOracle {
     using StatisticsUtils for uint256[];
 
+    /////////////////
+    /// Errors //////
+    /////////////////
+
     error OnlyOwner();
     error IndexOutOfBounds();
     error NoOraclesAvailable();
 
+    //////////////////////
+    /// State Variables //
+    //////////////////////
+
     address public owner;
     SimpleOracle[] public oracles;
 
+    ////////////////
+    /// Events /////
+    ////////////////
+
     event OracleAdded(address oracleAddress, address oracleOwner);
     event OracleRemoved(address oracleAddress);
 
-    constructor() {
-        owner = msg.sender;
-    }
+    ///////////////////
+    /// Modifiers /////
+    ///////////////////
 
+    /**
+     * @notice Modifier to restrict function access to the contract owner
+     * @dev Currently disabled to make it easy for you to impersonate the owner
+     */
     modifier onlyOwner() {
-        // Intentionally removing the owner requirement to make it easy for you to impersonate the owner
         // if (msg.sender != owner) revert OnlyOwner();
         _;
     }
 
+    ///////////////////
+    /// Constructor ///
+    ///////////////////
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    ///////////////////
+    /// Functions /////
+    ///////////////////
+
+    /**
+     * @notice Adds a new oracle to the whitelist by deploying a SimpleOracle contract (only contract owner)
+     * @dev Creates a new SimpleOracle instance and adds it to the oracles array.
+     * @param _owner The address that will own the newly created oracle and can update its price
+     */
     function addOracle(address _owner) public onlyOwner {
         SimpleOracle newOracle = new SimpleOracle(_owner);
         address oracleAddress = address(newOracle);
@@ -35,6 +67,12 @@ contract WhitelistOracle {
         emit OracleAdded(oracleAddress, _owner);
     }
 
+    /**
+     * @notice Removes an oracle from the whitelist by its array index (only contract owner)
+     * @dev Uses swap-and-pop pattern for gas-efficient removal. Order is not preserved.
+     *      Reverts with IndexOutOfBounds, if the provided index is >= oracles.length.
+     * @param index The index of the oracle to remove from the oracles array
+     */
     function removeOracle(uint256 index) public onlyOwner {
         if (index >= oracles.length) revert IndexOutOfBounds();
 
@@ -49,6 +87,12 @@ contract WhitelistOracle {
         emit OracleRemoved(oracleAddress);
     }
 
+    /**
+     * @notice Returns the aggregated price from all active oracles using median calculation
+     * @dev Filters oracles with timestamps older than 10 seconds, then calculates median
+     *      of remaining valid prices. Uses StatisticsUtils for sorting and median calculation.
+     * @return The median price from all active oracles
+     */
     function getPrice() public view returns (uint256) {
         if (oracles.length == 0) revert NoOraclesAvailable();
 
@@ -75,6 +119,13 @@ contract WhitelistOracle {
         return validPrices.getMedian();
     }
 
+    /**
+     * @notice Returns the addresses of all oracles that have updated their price within the last 10 seconds
+     * @dev Iterates through all oracles and filters those with recent timestamps (within 10 seconds).
+     *      Uses a temporary array to collect active nodes, then creates a right-sized return array
+     *      for gas optimization.
+     * @return An array of addresses representing the currently active oracle contracts
+     */
     function getActiveOracleNodes() public view returns (address[] memory) {
         address[] memory tempNodes = new address[](oracles.length);
         uint256 count = 0;
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index d46f7c89..6e866c2e 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -7,6 +7,10 @@ import { StatisticsUtils } from "../utils/StatisticsUtils.sol";
 contract StakingOracle {
     using StatisticsUtils for uint256[];
 
+    /////////////////
+    /// Errors //////
+    /////////////////
+
     error NodeNotRegistered();
     error InsufficientStake();
     error NodeAlreadyRegistered();
@@ -15,6 +19,10 @@ contract StakingOracle {
     error FailedToSendReward();
     error NoValidPricesAvailable();
 
+    //////////////////////
+    /// State Variables //
+    //////////////////////
+
     ORA public oracleToken;
 
     struct OracleNode {
@@ -33,26 +41,49 @@ contract StakingOracle {
     uint256 public constant STALE_DATA_WINDOW = 5 seconds;
     uint256 public constant SLASHER_REWARD_PERCENTAGE = 10;
 
+    ////////////////
+    /// Events /////
+    ////////////////
+
     event NodeRegistered(address indexed node, uint256 stakedAmount);
     event PriceReported(address indexed node, uint256 price);
-
     event NodeSlashed(address indexed node, uint256 amount);
     event NodeRewarded(address indexed node, uint256 amount);
-
     event NodesValidated();
 
     address public oracleTokenAddress;
 
+    ///////////////////
+    /// Modifiers /////
+    ///////////////////
+
+    /**
+     * @notice Modifier to restrict function access to registered oracle nodes
+     * @dev Checks if the sender has a registered node in the mapping
+     */
     modifier onlyNode() {
         if (nodes[msg.sender].nodeAddress == address(0)) revert NodeNotRegistered();
         _;
     }
 
+    ///////////////////
+    /// Constructor ///
+    ///////////////////
+
     constructor() {
         oracleToken = new ORA();
     }
 
-    /* ========== Oracle Node Operation Functions ========== */
+    ///////////////////
+    /// Functions /////
+    ///////////////////
+
+    /**
+     * @notice Registers a new oracle node with initial ETH stake and price
+     * @dev Creates a new OracleNode struct and adds the sender to the nodeAddresses array.
+     *      Requires minimum stake amount and prevents duplicate registrations.
+     * @param initialPrice The initial price value this oracle node will report
+     */
     function registerNode(uint256 initialPrice) public payable {
         if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
         if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
@@ -72,6 +103,11 @@ contract StakingOracle {
         emit PriceReported(msg.sender, initialPrice);
     }
 
+    /**
+     * @notice Updates the price reported by an oracle node (only registered nodes)
+     * @dev Updates the node's lastReportedPrice and timestamp. Requires sufficient stake.
+     * @param price The new price value to report
+     */
     function reportPrice(uint256 price) public onlyNode {
         OracleNode storage node = nodes[msg.sender];
         if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
@@ -81,11 +117,25 @@ contract StakingOracle {
         emit PriceReported(msg.sender, price);
     }
 
+    /**
+     * @notice Internal function to mint oracle tokens as rewards to a node
+     * @dev Mints ORA tokens to the specified node address and emits reward event
+     * @param nodeAddress The address of the node to reward
+     * @param reward The amount of ORA tokens to mint as reward
+     */
     function rewardNode(address nodeAddress, uint256 reward) internal {
         oracleToken.mint(nodeAddress, reward);
         emit NodeRewarded(nodeAddress, reward);
     }
 
+    /**
+     * @notice Internal function to slash a node's stake for providing stale data
+     * @dev Reduces the node's staked amount and calculates slasher reward as percentage of penalty.
+     *      Cannot slash more than the node's current stake.
+     * @param nodeToSlash The address of the node to penalize
+     * @param penalty The amount of ETH to slash from the node's stake
+     * @return The reward amount for the slasher (percentage of actual penalty)
+     */
     function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
         OracleNode storage node = nodes[nodeToSlash];
         uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
@@ -98,6 +148,11 @@ contract StakingOracle {
         return reward;
     }
 
+    /**
+     * @notice Allows registered nodes to claim accumulated ORA token rewards
+     * @dev Calculates rewards based on time elapsed since last claim. Slashed nodes
+     *      can only claim rewards up to their last slash timestamp.
+     */
     function claimReward() public onlyNode {
         OracleNode memory node = nodes[msg.sender];
         uint256 rewardAmount = 0;
@@ -116,6 +171,11 @@ contract StakingOracle {
         rewardNode(msg.sender, rewardAmount * 10 ** 18);
     }
 
+    /**
+     * @notice Public function to slash all nodes with stale data and reward the caller
+     * @dev Identifies stale nodes, slashes them, and sends accumulated slasher rewards to caller.
+     *      Anyone can call this function to maintain oracle data freshness.
+     */
     function slashNodes() public {
         (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
         uint256 slasherReward;
@@ -127,6 +187,14 @@ contract StakingOracle {
         if (!sent) revert FailedToSendReward();
     }
 
+    /**
+     * @notice Separates oracle nodes into fresh and stale categories based on data recency
+     * @dev Checks each node's last reported timestamp against the STALE_DATA_WINDOW.
+     *      Returns two arrays with fresh and stale node addresses respectively.
+     * @param nodesToSeparate Array of node addresses to categorize
+     * @return fresh Array of addresses with recent data (within STALE_DATA_WINDOW)
+     * @return stale Array of addresses with stale data (older than STALE_DATA_WINDOW)
+     */
     function separateStaleNodes(
         address[] memory nodesToSeparate
     ) public view returns (address[] memory fresh, address[] memory stale) {
@@ -163,6 +231,12 @@ contract StakingOracle {
         return (trimmedFreshNodes, trimmedStaleNodes);
     }
 
+    /**
+     * @notice Internal function to extract price values from an array of node addresses
+     * @dev Iterates through provided addresses and retrieves their last reported prices
+     * @param addresses Array of node addresses to get prices from
+     * @return Array of price values corresponding to the input addresses
+     */
     function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
         uint256[] memory prices = new uint256[](addresses.length);
 
@@ -174,6 +248,12 @@ contract StakingOracle {
         return prices;
     }
 
+    /**
+     * @notice Returns the aggregated price from all active oracle nodes using median calculation
+     * @dev Filters out stale nodes, extracts their prices, sorts them, and calculates median.
+     *      Uses StatisticsUtils for sorting and median calculation.
+     * @return The median price from all nodes with fresh data
+     */
     function getPrice() public view returns (uint256) {
         (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
         uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
@@ -183,6 +263,11 @@ contract StakingOracle {
         return validPrices.getMedian();
     }
 
+    /**
+     * @notice Returns the array of all registered oracle node addresses
+     * @dev Provides access to the complete list of node addresses for external monitoring
+     * @return Array of all registered node addresses
+     */
     function getNodeAddresses() public view returns (address[] memory) {
         return nodeAddresses;
     }
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
index 5b4a8c5a..e381ad11 100644
--- a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
+++ b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
@@ -2,6 +2,10 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 contract OptimisticOracle {
+    ////////////////
+    /// Enums //////
+    ////////////////
+
     enum State {
         Invalid,
         Asserted,
@@ -11,6 +15,10 @@ contract OptimisticOracle {
         Expired
     }
 
+    /////////////////
+    /// Errors //////
+    /////////////////
+
     error AssertionNotFound();
     error AssertionProposed();
     error NotEnoughValue();
@@ -25,6 +33,10 @@ contract OptimisticOracle {
     error OnlyOwner();
     error TransferFailed();
 
+    //////////////////////
+    /// State Variables //
+    //////////////////////
+
     struct EventAssertion {
         address asserter;
         address proposer;
@@ -39,6 +51,7 @@ contract OptimisticOracle {
         address winner;
         string description;
     }
+
     uint256 public constant MINIMUM_ASSERTION_WINDOW = 3 minutes;
     uint256 public constant MINIMUM_DISPUTE_WINDOW = 3 minutes;
     address public decider;
@@ -46,6 +59,10 @@ contract OptimisticOracle {
     uint256 public nextAssertionId = 1;
     mapping(uint256 => EventAssertion) public assertions;
 
+    ////////////////
+    /// Events /////
+    ////////////////
+
     event EventAsserted(uint256 assertionId, address asserter, string description, uint256 reward);
     event OutcomeProposed(uint256 assertionId, address proposer, bool outcome);
     event OutcomeDisputed(uint256 assertionId, address disputer);
@@ -54,50 +71,141 @@ contract OptimisticOracle {
     event RewardClaimed(uint256 assertionId, address winner, uint256 amount);
     event RefundClaimed(uint256 assertionId, address asserter, uint256 amount);
 
+    ///////////////////
+    /// Modifiers /////
+    ///////////////////
+
+    /**
+     * @notice Modifier to restrict function access to the designated decider
+     * @dev Ensures only the decider can settle disputed assertions
+     */
     modifier onlyDecider() {
         if (msg.sender != decider) revert OnlyDecider();
         _;
     }
 
+    /**
+     * @notice Modifier to restrict function access to the contract owner
+     * @dev Ensures only the owner can update critical contract parameters
+     */
     modifier onlyOwner() {
         if (msg.sender != owner) revert OnlyOwner();
         _;
     }
 
+    ///////////////////
+    /// Constructor ///
+    ///////////////////
+
     constructor(address _decider) {
         decider = _decider;
         owner = msg.sender;
     }
 
+    ///////////////////
+    /// Functions /////
+    ///////////////////
+
+    /**
+     * @notice Updates the decider address (only contract owner)
+     * @dev Changes the address authorized to settle disputed assertions.
+     *      Emits DeciderUpdated event with old and new addresses.
+     * @param _decider The new address that will act as decider for disputed assertions
+     */
     function setDecider(address _decider) external onlyOwner {
         address oldDecider = address(decider);
         decider = _decider;
         emit DeciderUpdated(oldDecider, _decider);
     }
 
+    /**
+     * @notice Returns the complete assertion details for a given assertion ID
+     * @dev Provides access to all fields of the EventAssertion struct
+     * @param assertionId The unique identifier of the assertion to retrieve
+     * @return The complete EventAssertion struct containing all assertion data
+     */
     function getAssertion(uint256 assertionId) external view returns (EventAssertion memory) {
         return assertions[assertionId];
     }
 
+    /**
+     * @notice Creates a new assertion about an event with a true/false outcome
+     * @dev Requires ETH payment as reward for correct proposers. Bond requirement is 2x the reward.
+     *      Sets default timestamps if not provided. Validates timing requirements.
+     * @param description Human-readable description of the event (e.g. "Did X happen by time Y?")
+     * @param startTime When proposals can begin (0 for current block timestamp)
+     * @param endTime When the assertion expires (0 for startTime + minimum window)
+     * @return The unique assertion ID for the newly created assertion
+     */
     function assertEvent(
         string memory description,
         uint256 startTime,
         uint256 endTime
     ) external payable returns (uint256) {}
 
+    /**
+     * @notice Proposes the outcome (true or false) for an asserted event
+     * @dev Requires bonding ETH equal to 2x the original reward. Sets dispute window deadline.
+     *      Can only be called once per assertion and within the assertion time window.
+     * @param assertionId The unique identifier of the assertion to propose an outcome for
+     * @param outcome The proposed boolean outcome (true or false) for the event
+     */
     function proposeOutcome(uint256 assertionId, bool outcome) external payable {}
 
+    /**
+     * @notice Disputes a proposed outcome by bonding ETH
+     * @dev Requires bonding ETH equal to the bond amount. Can only dispute once per assertion
+     *      and must be within the dispute window after proposal.
+     * @param assertionId The unique identifier of the assertion to dispute
+     */
     function disputeOutcome(uint256 assertionId) external payable {}
 
+    /**
+     * @notice Claims reward for undisputed assertions after dispute window expires
+     * @dev Anyone can trigger this function. Transfers reward + bond to the proposer.
+     *      Can only be called after dispute window has passed without disputes.
+     * @param assertionId The unique identifier of the assertion to claim rewards for
+     */
     function claimUndisputedReward(uint256 assertionId) external {}
 
+    /**
+     * @notice Claims reward for disputed assertions after decider settlement
+     * @dev Anyone can trigger this function. Pays decider fee and transfers remaining rewards to winner.
+     *      Can only be called after decider has settled the dispute.
+     * @param assertionId The unique identifier of the disputed assertion to claim rewards for
+     */
     function claimDisputedReward(uint256 assertionId) external {}
 
+    /**
+     * @notice Claims refund for assertions that receive no proposals before deadline
+     * @dev Anyone can trigger this function. Returns the original reward to the asserter.
+     *      Can only be called after assertion deadline has passed without any proposals.
+     * @param assertionId The unique identifier of the expired assertion to claim refund for
+     */
     function claimRefund(uint256 assertionId) external {}
 
+    /**
+     * @notice Resolves disputed assertions by determining the correct outcome (only decider)
+     * @dev Sets the resolved outcome and determines winner based on proposal accuracy.
+     * @param assertionId The unique identifier of the disputed assertion to settle
+     * @param resolvedOutcome The decider's determination of the true outcome
+     */
     function settleAssertion(uint256 assertionId, bool resolvedOutcome) external onlyDecider {}
 
+    /**
+     * @notice Returns the current state of an assertion based on its lifecycle stage
+     * @dev Evaluates assertion progress through states: Invalid, Asserted, Proposed, Disputed, Settled, Expired
+     * @param assertionId The unique identifier of the assertion to check state for
+     * @return The current State enum value representing the assertion's status
+     */
     function getState(uint256 assertionId) external view returns (State) {}
 
+    /**
+     * @notice Returns the final resolved outcome of a settled assertion
+     * @dev For undisputed assertions, returns the proposed outcome after dispute window.
+     *      For disputed assertions, returns the decider's resolved outcome.
+     * @param assertionId The unique identifier of the assertion to get resolution for
+     * @return The final boolean outcome of the assertion
+     */
     function getResolution(uint256 assertionId) external view returns (bool) {}
 }

From fc6dc8971e6de596985a346f6557add6bbe6a119 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Sat, 13 Sep 2025 13:42:56 +0200
Subject: [PATCH 15/34] refactor: reorganize StakingOracle functions

---
 .../contracts/01_Staking/StakingOracle.sol    | 118 ++++++++++--------
 1 file changed, 63 insertions(+), 55 deletions(-)

diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index 6e866c2e..8baf52a5 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -117,37 +117,6 @@ contract StakingOracle {
         emit PriceReported(msg.sender, price);
     }
 
-    /**
-     * @notice Internal function to mint oracle tokens as rewards to a node
-     * @dev Mints ORA tokens to the specified node address and emits reward event
-     * @param nodeAddress The address of the node to reward
-     * @param reward The amount of ORA tokens to mint as reward
-     */
-    function rewardNode(address nodeAddress, uint256 reward) internal {
-        oracleToken.mint(nodeAddress, reward);
-        emit NodeRewarded(nodeAddress, reward);
-    }
-
-    /**
-     * @notice Internal function to slash a node's stake for providing stale data
-     * @dev Reduces the node's staked amount and calculates slasher reward as percentage of penalty.
-     *      Cannot slash more than the node's current stake.
-     * @param nodeToSlash The address of the node to penalize
-     * @param penalty The amount of ETH to slash from the node's stake
-     * @return The reward amount for the slasher (percentage of actual penalty)
-     */
-    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
-        OracleNode storage node = nodes[nodeToSlash];
-        uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
-        node.stakedAmount -= actualPenalty;
-
-        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
-
-        emit NodeSlashed(nodeToSlash, actualPenalty);
-
-        return reward;
-    }
-
     /**
      * @notice Allows registered nodes to claim accumulated ORA token rewards
      * @dev Calculates rewards based on time elapsed since last claim. Slashed nodes
@@ -187,6 +156,25 @@ contract StakingOracle {
         if (!sent) revert FailedToSendReward();
     }
 
+    ////////////////////////
+    /// View Functions /////
+    ////////////////////////
+
+    /**
+     * @notice Returns the aggregated price from all active oracle nodes using median calculation
+     * @dev Filters out stale nodes, extracts their prices, sorts them, and calculates median.
+     *      Uses StatisticsUtils for sorting and median calculation.
+     * @return The median price from all nodes with fresh data
+     */
+    function getPrice() public view returns (uint256) {
+        (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
+        uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
+        if (validPrices.length == 0) revert NoValidPricesAvailable();
+
+        validPrices.sort();
+        return validPrices.getMedian();
+    }
+
     /**
      * @notice Separates oracle nodes into fresh and stale categories based on data recency
      * @dev Checks each node's last reported timestamp against the STALE_DATA_WINDOW.
@@ -231,6 +219,50 @@ contract StakingOracle {
         return (trimmedFreshNodes, trimmedStaleNodes);
     }
 
+    /**
+     * @notice Returns the array of all registered oracle node addresses
+     * @dev Provides access to the complete list of node addresses for external monitoring
+     * @return Array of all registered node addresses
+     */
+    function getNodeAddresses() public view returns (address[] memory) {
+        return nodeAddresses;
+    }
+
+    ////////////////////////
+    /// Internal Helpers ///
+    ////////////////////////
+
+    /**
+     * @notice Internal function to mint oracle tokens as rewards to a node
+     * @dev Mints ORA tokens to the specified node address and emits reward event
+     * @param nodeAddress The address of the node to reward
+     * @param reward The amount of ORA tokens to mint as reward
+     */
+    function rewardNode(address nodeAddress, uint256 reward) internal {
+        oracleToken.mint(nodeAddress, reward);
+        emit NodeRewarded(nodeAddress, reward);
+    }
+
+    /**
+     * @notice Internal function to slash a node's stake for providing stale data
+     * @dev Reduces the node's staked amount and calculates slasher reward as percentage of penalty.
+     *      Cannot slash more than the node's current stake.
+     * @param nodeToSlash The address of the node to penalize
+     * @param penalty The amount of ETH to slash from the node's stake
+     * @return The reward amount for the slasher (percentage of actual penalty)
+     */
+    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
+        OracleNode storage node = nodes[nodeToSlash];
+        uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
+        node.stakedAmount -= actualPenalty;
+
+        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
+
+        emit NodeSlashed(nodeToSlash, actualPenalty);
+
+        return reward;
+    }
+
     /**
      * @notice Internal function to extract price values from an array of node addresses
      * @dev Iterates through provided addresses and retrieves their last reported prices
@@ -248,29 +280,5 @@ contract StakingOracle {
         return prices;
     }
 
-    /**
-     * @notice Returns the aggregated price from all active oracle nodes using median calculation
-     * @dev Filters out stale nodes, extracts their prices, sorts them, and calculates median.
-     *      Uses StatisticsUtils for sorting and median calculation.
-     * @return The median price from all nodes with fresh data
-     */
-    function getPrice() public view returns (uint256) {
-        (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
-        uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
-        if (validPrices.length == 0) revert NoValidPricesAvailable();
-        
-        validPrices.sort();
-        return validPrices.getMedian();
-    }
-
-    /**
-     * @notice Returns the array of all registered oracle node addresses
-     * @dev Provides access to the complete list of node addresses for external monitoring
-     * @return Array of all registered node addresses
-     */
-    function getNodeAddresses() public view returns (address[] memory) {
-        return nodeAddresses;
-    }
-
     // Notably missing a way to unstake and exit your node but not needed for the challenge
 }

From 951e599f08cf7be42a9e2808ba3fc80823da0e20 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Sat, 13 Sep 2025 21:41:54 +0200
Subject: [PATCH 16/34] update readme and stale data window time

---
 README.md                                     | 81 +++++++++++++------
 .../00_Whitelist/WhitelistOracle.sol          | 13 +--
 .../contracts/01_Staking/StakingOracle.sol    |  2 +-
 .../contracts/utils/StatisticsUtils.sol       | 54 +++++++++++++
 4 files changed, 119 insertions(+), 31 deletions(-)
 create mode 100644 extension/packages/hardhat/contracts/utils/StatisticsUtils.sol

diff --git a/README.md b/README.md
index e80de368..b71394aa 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 🔗 Build your own decentralized oracle systems! In this challenge, you'll explore three fundamental oracle architectures that power the decentralized web: **Whitelist Oracle**, **Staking Oracle**, and **Optimistic Oracle**.
 
-🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: how do we trust data that comes from outside the blockchain?
+🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: How can we trust data from outside the blockchain, and how do we securely bring it on-chain?
 
 <details markdown='1'><summary>❓ Wondering what an oracle is? Read the overview here.</summary>
 
@@ -175,7 +175,7 @@ SimpleOracle[] public oracles;  // Array of SimpleOracle contract instances
 
    * 📡 Calls `getPrice()` on each SimpleOracle to get `(price, timestamp)`
 
-   * 🧹 Filters out stale prices (older than 10 seconds)
+   * 🧹 Filters out stale prices (older than STALE_DATA_WINDOW = 24 seconds, which is 2x Ethereum's block time to account for network variations)
 
    * ⛔️ Reverts if all prices are stale
 
@@ -459,7 +459,7 @@ sequenceDiagram
 
 🔗 Look at how [UMA](https://uma.xyz/) does this with their Optimistic Oracle (OO). **This contract is based UMA's OO design**.
 
-## Checkpoint 4: ⚡ Optimistic Oracle - Dispute Resolution
+## Checkpoint 4: ⚡ Optimistic Oracle - Core Functions
 
 👩‍💻 Now it's (finally) time to build! Unlike the previous checkpoints where you explored existing implementations, this section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
 
@@ -644,9 +644,28 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
-4. **Implement `claimUndisputedReward(uint256 assertionId)`**
+### 🥅 Goals:
+
+- Users can assert events with descriptions and time windows
+- Users can propose outcomes for asserted events
+- Users can dispute proposed outcomes
+- The system correctly handles timing constraints
+- Bond amounts are properly validated
+
+## Checkpoint 5: 💰 Optimistic Oracle - Reward Claims
+
+🎯 **Your Mission**: Implement the reward claiming mechanisms that allow participants to collect their earnings based on the outcomes of assertions, proposals, and disputes.
+
+💡 **Key Concept**: The optimistic oracle has three different scenarios for claiming rewards:
+- **Undisputed proposals**: Proposer gets reward + bond back
+- **Disputed proposals**: Winner (determined by decider) gets reward + bond back
+- **Refunds**: Asserter gets reward back when no proposals are made
+
+### ✏️ Tasks:
+
+1. **Implement `claimUndisputedReward(uint256 assertionId)`**
 
-We need to allow the proposer to claim the reward when no dispute occurs before the deadline.
+The proposer can claim the reward only after the deadline, as long as no dispute was submitted before it.
 
 * 🧩 A proposal must exist (revert with `NotProposedAssertion`)
 
@@ -702,7 +721,7 @@ We need to allow the proposer to claim the reward when no dispute occurs before
 
 ---
 
-5. **Implement `claimDisputedReward(uint256 assertionId)`**
+2. **Implement `claimDisputedReward(uint256 assertionId)`**
 
 Very similar to the last function except this one allows the winner of the dispute to claim *only after the Decider has resolved the dispute*.
 
@@ -760,7 +779,7 @@ Very similar to the last function except this one allows the winner of the dispu
 
 ---
 
-6. **Implement `claimRefund(uint256 assertionId)`**
+3. **Implement `claimRefund(uint256 assertionId)`**
 
 This function enables the asserter to get a refund of their posted reward when no proposal arrives by the deadline.
 
@@ -807,9 +826,24 @@ This function enables the asserter to get a refund of their posted reward when n
 </details>
 </details>
 
+### 🥅 Goals:
+
+- Proposers can claim rewards for undisputed assertions
+- Winners can claim rewards after disputes are settled
+- Asserters can claim refunds when no proposals are made
+- The system prevents double-claiming and re-entrancy attacks
+- All transfers are handled safely with proper error checking
+
+
 ---
 
-7. **Implement `settleAssertion(uint256 assertionId, bool resolvedOutcome)`**
+## Checkpoint 6: 🧑‍⚖️ Optimistic Oracle - Settlement & State Management
+
+🎯 **Your Mission**: Implement the final pieces of the optimistic oracle: dispute settlement by the decider and utility functions for querying assertion states and resolutions.
+
+### ✏️ Tasks:
+
+1. **Implement `settleAssertion(uint256 assertionId, bool resolvedOutcome)`**
 
 This is the method that the decider will call to settle whether the proposer or disputer are correct.
 
@@ -860,7 +894,7 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
-8. **Implement `getState(uint256 assertionId)`**
+2. **Implement `getState(uint256 assertionId)`**
 
 This function returns a simple state machine view for UI/testing.
 
@@ -916,7 +950,7 @@ Try to deduce the rest without any help.
 
 ---
 
-9. **Implement `getResolution(uint256 assertionId)`**
+3. **Implement `getResolution(uint256 assertionId)`**
 
 This function will help everyone know the exact outcome of the assertion.
 
@@ -973,15 +1007,14 @@ yarn simulate:optimistic
 
 ### 🥅 Goals:
 
-- Users can assert events with descriptions and time windows
-- Users can propose outcomes for asserted events
-- Users can dispute proposed outcomes
-- Undisputed assertions can be claimed after the dispute window
-- The system correctly handles timing constraints
-- Bond amounts are properly validated
+- The decider can settle disputed assertions
+- The system provides clear state information for all assertions
+- Users can query resolved outcomes for both disputed and undisputed assertions
+- All functions handle edge cases and invalid states appropriately
+- The complete optimistic oracle system works end-to-end
 ---
 
-## Checkpoint 5: 🔍 Oracle Comparison & Trade-offs
+## Checkpoint 7: 🔍 Oracle Comparison & Trade-offs
 
 🧠 Now let's analyze the strengths and weaknesses of each oracle design.
 
@@ -1032,13 +1065,13 @@ yarn simulate:optimistic
 
 Each oracle design solves different problems:
 
-- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization
-- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount
+- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization. Works well for binary or predefined questions (e.g., “Is asset X above price Y?”).
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Handles yes/no and numerical data questions that require strong guarantees (e.g., “What is the ETH/USD price?”).
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
 
 ---
 
-## Checkpoint 6: 💾 Deploy your contracts! 🛰
+## Checkpoint 8: 💾 Deploy your contracts! 🛰
 
 🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
 
@@ -1089,7 +1122,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 ---
 
-## Checkpoint 8: 📜 Contract Verification
+## Checkpoint 9: 📜 Contract Verification
 
 📝 Run the `yarn verify --network your_network` command to verify your optimistic oracle contracts on Etherscan 🛰.
 
@@ -1103,7 +1136,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 > 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
 
-## Checkpoint 9: More On Oracles
+## Checkpoint 10: More On Oracles
 
 Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
 
@@ -1115,4 +1148,4 @@ Oracles are fundamental infrastructure for the decentralized web. They enable sm
 
 🚀 As you continue your blockchain development journey, you'll encounter many variations and combinations of these patterns. Understanding the fundamental trade-offs will help you choose the right oracle design for your specific use case.
 
-🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
+🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
\ No newline at end of file
diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
index f3d0959c..1e0fa523 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -21,6 +21,7 @@ contract WhitelistOracle {
 
     address public owner;
     SimpleOracle[] public oracles;
+    uint256 public constant STALE_DATA_WINDOW = 24 seconds;
 
     ////////////////
     /// Events /////
@@ -89,7 +90,7 @@ contract WhitelistOracle {
 
     /**
      * @notice Returns the aggregated price from all active oracles using median calculation
-     * @dev Filters oracles with timestamps older than 10 seconds, then calculates median
+     * @dev Filters oracles with timestamps older than STALE_DATA_WINDOW, then calculates median
      *      of remaining valid prices. Uses StatisticsUtils for sorting and median calculation.
      * @return The median price from all active oracles
      */
@@ -103,8 +104,8 @@ contract WhitelistOracle {
 
         for (uint256 i = 0; i < oracles.length; i++) {
             (uint256 price, uint256 timestamp) = oracles[i].getPrice();
-            // Check if the timestamp is within the last 10 seconds
-            if (currentTime - timestamp < 10) {
+            // Check if the timestamp is within the last STALE_DATA_WINDOW
+            if (currentTime - timestamp < STALE_DATA_WINDOW) {
                 prices[validCount] = price;
                 validCount++;
             }
@@ -120,8 +121,8 @@ contract WhitelistOracle {
     }
 
     /**
-     * @notice Returns the addresses of all oracles that have updated their price within the last 10 seconds
-     * @dev Iterates through all oracles and filters those with recent timestamps (within 10 seconds).
+     * @notice Returns the addresses of all oracles that have updated their price within the last STALE_DATA_WINDOW
+     * @dev Iterates through all oracles and filters those with recent timestamps (within STALE_DATA_WINDOW).
      *      Uses a temporary array to collect active nodes, then creates a right-sized return array
      *      for gas optimization.
      * @return An array of addresses representing the currently active oracle contracts
@@ -132,7 +133,7 @@ contract WhitelistOracle {
 
         for (uint256 i = 0; i < oracles.length; i++) {
             (, uint256 timestamp) = oracles[i].getPrice();
-            if (timestamp > block.timestamp - 10) {
+            if (timestamp > block.timestamp - STALE_DATA_WINDOW) {
                 tempNodes[count] = address(oracles[i]);
                 count++;
             }
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index 8baf52a5..f795eae1 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -38,7 +38,7 @@ contract StakingOracle {
     address[] public nodeAddresses;
 
     uint256 public constant MINIMUM_STAKE = 1 ether;
-    uint256 public constant STALE_DATA_WINDOW = 5 seconds;
+    uint256 public constant STALE_DATA_WINDOW = 24 seconds;
     uint256 public constant SLASHER_REWARD_PERCENTAGE = 10;
 
     ////////////////
diff --git a/extension/packages/hardhat/contracts/utils/StatisticsUtils.sol b/extension/packages/hardhat/contracts/utils/StatisticsUtils.sol
new file mode 100644
index 00000000..f46f588f
--- /dev/null
+++ b/extension/packages/hardhat/contracts/utils/StatisticsUtils.sol
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+library StatisticsUtils {
+    /////////////////
+    /// Errors //////
+    /////////////////
+
+    error EmptyArray();
+
+    ///////////////////
+    /// Functions /////
+    ///////////////////
+
+    /**
+     * @notice Sorts an array of uint256 values in ascending order using selection sort
+     * @dev Uses selection sort algorithm which is not gas-efficient but acceptable for small arrays.
+     *      This implementation mimics the early MakerDAO Medianizer exactly.
+     *      Modifies the input array in-place.
+     * @param arr The array of uint256 values to sort in ascending order
+     */
+    function sort(uint256[] memory arr) internal pure {
+        uint256 n = arr.length;
+        for (uint256 i = 0; i < n; i++) {
+            uint256 minIndex = i;
+            for (uint256 j = i + 1; j < n; j++) {
+                if (arr[j] < arr[minIndex]) {
+                    minIndex = j;
+                }
+            }
+            if (minIndex != i) {
+                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
+            }
+        }
+    }
+
+    /**
+     * @notice Calculates the median value from a sorted array of uint256 values
+     * @dev For arrays with even length, returns the average of the two middle elements.
+     *      For arrays with odd length, returns the middle element.
+     *      Assumes the input array is already sorted in ascending order.
+     * @param arr The sorted array of uint256 values to calculate median from
+     * @return The median value as a uint256
+     */
+    function getMedian(uint256[] memory arr) internal pure returns (uint256) {
+        uint256 length = arr.length;
+        if (length == 0) revert EmptyArray();
+        if (length % 2 == 0) {
+            return (arr[length / 2 - 1] + arr[length / 2]) / 2;
+        } else {
+            return arr[length / 2];
+        }
+    }
+}

From 61b9e22df9dcd02ef18d2cfd203e7a2295b5e4d6 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Sat, 13 Sep 2025 23:01:12 +0200
Subject: [PATCH 17/34] update checkpoint 1

---
 README.md                                     | 239 +++++++++++++++---
 .../00_Whitelist/WhitelistOracle.sol          |  68 +----
 2 files changed, 213 insertions(+), 94 deletions(-)

diff --git a/README.md b/README.md
index b71394aa..80aab96d 100644
--- a/README.md
+++ b/README.md
@@ -112,7 +112,9 @@ yarn start
 
 🧩 The `SimpleOracle` contract is the fundamental building block of this oracle system:
 
-1. **`setPrice(uint256 _newPrice)`** - This function allows the contract owner to update the current price
+1. **Constructor** - Takes an `_owner` address parameter to set who can update the oracle price
+
+2. **`setPrice(uint256 _newPrice)`** - This function allows the contract owner to update the current price
 
    * 🔄 Updates the `price` state variable with the new value
 
@@ -120,7 +122,7 @@ yarn start
 
    * 📣 Emits the `PriceUpdated` event with the new price
 
-2. **`getPrice()`** - This function returns both the current price and timestamp
+3. **`getPrice()`** - This function returns both the current price and timestamp
 
    * ↩️ Returns them as a tuple: `(price, timestamp)`
 
@@ -132,11 +134,13 @@ yarn start
 
 ### 🏛️ Whitelist Oracle - Aggregating Multiple Sources
 
-🔍 Open the `packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol` file to examine how multiple SimpleOracle contracts are aggregated.
+🎯 **Your Mission**: Complete the missing function implementations in the `WhitelistOracle.sol` contract.
+
+🔍 Open the `packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol` file to implement the whitelist oracle functionality.
 
 #### 📖 Understanding the Relationship:
 
-The `WhitelistOracle` contract **aggregates data from multiple SimpleOracle contracts**:
+The `WhitelistOracle` contract **creates and manages multiple SimpleOracle contracts**:
 
 ```solidity
 
@@ -146,46 +150,217 @@ SimpleOracle[] public oracles;  // Array of SimpleOracle contract instances
 
 🏗️ This creates a **hierarchical oracle system**:
 
-- **Individual Level**: Each SimpleOracle contract is managed by a trusted (theoretically) data provider
-- **Aggregation Level**: The WhitelistOracle collects and processes data from all whitelisted SimpleOracle contracts
+- **Individual Level**: Each SimpleOracle contract is managed by a trusted data provider (set during oracle creation)
+- **Aggregation Level**: The WhitelistOracle creates, manages, and processes data from all whitelisted SimpleOracle contracts
 
-#### 📖 Understanding the Code:
+### ✏️ Tasks:
 
-1. **`addOracle(address oracle)`** - Adds a SimpleOracle contract to the whitelist
+1. **Implement `addOracle(address _owner)`**
 
-   * ✔️ Validates the oracle address is not zero
+* 🏭 This function allows the contract owner to add a new oracle to the whitelist by deploying a SimpleOracle contract
 
-   * 🧪 Checks for duplicates in the existing list
+* 🧩 It should create a new `SimpleOracle` instance with the specified `_owner`
 
-   * ➕ Adds the SimpleOracle to the `oracles` array
+* ➕ It should add the newly created SimpleOracle to the `oracles` array
 
-   * 📣 Emits the `OracleAdded` event
+* 📣 It should emit the `OracleAdded` event with both the oracle address and its owner
 
-2. **`removeOracle(uint256 index)`** - Removes a SimpleOracle from the whitelist
+<details markdown='1'>
 
-   * ✔️ Validates the index is within bounds
+<summary>💡 Hint: Creating and Adding Oracles</summary>
 
-   * ➖ Efficiently removes the oracle (swaps with last element)
+Here's what you need to do:
+- Create a new SimpleOracle contract instance using `new SimpleOracle(_owner)`
+- Get the address of the newly created oracle using `address(newOracle)`
+- Push the oracle instance to the `oracles` array
+- Emit the `OracleAdded` event with the oracle address and owner
 
-   * 📣 Emits the `OracleRemoved` event
+<details markdown='1'>
 
-3. **`getPrice()`** - Aggregates prices from all whitelisted SimpleOracle contracts
+<summary>🎯 Solution</summary>
 
-   * 🔁 Loops through each SimpleOracle in the whitelist
+```solidity
+function addOracle(address _owner) public onlyOwner {
+    SimpleOracle newOracle = new SimpleOracle(_owner);
+    address oracleAddress = address(newOracle);
 
-   * 📡 Calls `getPrice()` on each SimpleOracle to get `(price, timestamp)`
+    oracles.push(newOracle);
+    emit OracleAdded(oracleAddress, _owner);
+}
+```
 
-   * 🧹 Filters out stale prices (older than STALE_DATA_WINDOW = 24 seconds, which is 2x Ethereum's block time to account for network variations)
+</details>
+</details>
 
-   * ⛔️ Reverts if all prices are stale
+---
 
-   * 🧮 Calculates the median of valid prices
+2. **Implement `removeOracle(uint256 index)`**
 
-#### 🤔 Key Insights:
+* ✔️ This function allows the contract owner to remove an oracle from the whitelist by its array index
+
+* 🔍 It should validate that the provided index is within bounds, otherwise revert with `IndexOutOfBounds`
+
+* 📝 It should record the oracle address before removal for the event
+
+* ➖ It should efficiently remove the oracle using swap-and-pop pattern (swap with last element, then pop)
+
+* 📣 It should emit the `OracleRemoved` event with the oracle address
+
+<details markdown='1'>
+
+<summary>💡 Hint: Safe Array Removal</summary>
+
+The swap-and-pop pattern:
+- Check if index is valid (< oracles.length)
+- Store the oracle address for the event
+- If not the last element, swap with the last element
+- Pop the last element
+- Emit the removal event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function removeOracle(uint256 index) public onlyOwner {
+    if (index >= oracles.length) revert IndexOutOfBounds();
+
+    address oracleAddress = address(oracles[index]);
+
+    if (index != oracles.length - 1) {
+        oracles[index] = oracles[oracles.length - 1];
+    }
+
+    oracles.pop();
+
+    emit OracleRemoved(oracleAddress);
+}
+```
+
+</details>
+</details>
+
+---
+
+3. **Implement `getPrice()`**
+
+* 📊 This function aggregates prices from all active oracles using median calculation
+
+* ⛔️ It should revert with `NoOraclesAvailable` if no oracles exist in the whitelist
+
+* 🔁 It should loop through each oracle and call `getPrice()` to get `(price, timestamp)`
+
+* 🧹 It should filter out stale prices (older than `STALE_DATA_WINDOW = 24 seconds`)
+
+* 📦 It should collect only fresh prices into a properly sized array
+
+* 🧮 It should use StatisticsUtils library to sort prices and calculate the median
+
+<details markdown='1'>
+
+<summary>💡 Hint: Price Aggregation with Freshness Check</summary>
+
+Here's the process:
+- Check if any oracles exist
+- Create a temporary array to collect fresh prices
+- Loop through all oracles, get their (price, timestamp)
+- Check if timestamp is within STALE_DATA_WINDOW of current time
+- Collect valid prices and count them
+- Create a right-sized array with only valid prices
+- Sort and get median using StatisticsUtils
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getPrice() public view returns (uint256) {
+    if (oracles.length == 0) revert NoOraclesAvailable();
+
+    // Collect prices and timestamps from all oracles
+    uint256[] memory prices = new uint256[](oracles.length);
+    uint256 validCount = 0; // Count of valid prices
+    uint256 currentTime = block.timestamp;
+
+    for (uint256 i = 0; i < oracles.length; i++) {
+        (uint256 price, uint256 timestamp) = oracles[i].getPrice();
+        // Check if the timestamp is within the last STALE_DATA_WINDOW
+        if (currentTime - timestamp < STALE_DATA_WINDOW) {
+            prices[validCount] = price;
+            validCount++;
+        }
+    }
+
+    uint256[] memory validPrices = new uint256[](validCount);
+    for (uint256 i = 0; i < validCount; i++) {
+        validPrices[i] = prices[i];
+    }
+
+    validPrices.sort();
+    return validPrices.getMedian();
+}
+```
+
+</details>
+</details>
+
+---
+
+4. **Implement `getActiveOracleNodes()`**
+
+* 📊 This function returns the addresses of all oracles that have updated their price within the last `STALE_DATA_WINDOW`
+
+* 🔍 It should iterate through all oracles and filter those with recent timestamps
+
+* 📦 It should use a temporary array to collect active nodes, then create a right-sized return array for gas optimization
+
+* 🎯 It should return an array of addresses representing the currently active oracle contracts
+
+<details markdown='1'>
+
+<summary>💡 Hint: Active Node Filtering</summary>
+
+Similar to getPrice(), but instead of collecting prices, collect oracle addresses:
+- Create temporary array to store addresses
+- Loop through oracles, check timestamp freshness
+- Count and collect active oracle addresses
+- Create properly sized result array
+- Return the active oracle addresses
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getActiveOracleNodes() public view returns (address[] memory) {
+    address[] memory tempNodes = new address[](oracles.length);
+    uint256 count = 0;
+
+    for (uint256 i = 0; i < oracles.length; i++) {
+        (, uint256 timestamp) = oracles[i].getPrice();
+        if (timestamp > block.timestamp - STALE_DATA_WINDOW) {
+            tempNodes[count] = address(oracles[i]);
+            count++;
+        }
+    }
+
+    address[] memory activeNodes = new address[](count);
+    for (uint256 j = 0; j < count; j++) {
+        activeNodes[j] = tempNodes[j];
+    }
+
+    return activeNodes;
+}
+```
+
+</details>
+</details>
+
+### 🤔 Key Insights:
 
-- **Composition Pattern**: WhitelistOracle is composed of multiple SimpleOracle contracts
+- **Factory Pattern**: WhitelistOracle creates and manages SimpleOracle contracts
 - **Centralized Authority**: Only the owner can add/remove SimpleOracle contracts
-- **Consensus Mechanism**: Uses median calculation to resist outliers from individual SimpleOracle contracts
+- **Consensus Mechanism**: Uses median calculation with StatisticsUtils library to resist outliers
 - **Freshness Check**: Filters out stale data from any SimpleOracle
 - **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
 - **Use Cases**: Good for controlled environments where you trust the authority and data providers
@@ -208,7 +383,7 @@ SimpleOracle C → setPrice(98)  → getPrice() → (98, timestamp)
 
 ```
 
-WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
+WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] → median(100) → 100
 
 ```
 
@@ -256,7 +431,7 @@ WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
 
 1. **Change Prices**: Use the frontend to modify individual oracle prices
 
-2. **Add New Nodes**: Deploy and add new SimpleOracle contracts to the whitelist
+2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
 3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
 
@@ -272,8 +447,12 @@ yarn simulate:whitelist
 
 ### 🥅 Goals:
 
-- See how WhitelistOracle aggregates multiple nodes
-- Observe how median calculation provides consensus from multiple sources
+- User can add new SimpleOracle instances to the whitelist
+- User can remove oracles
+- System aggregates prices from active oracles using median calculation
+- Stale data is automatically filtered out based on timestamps
+- Users can query which oracle nodes are currently active
+- The system correctly handles edge cases and invalid states
 - Understand the benefits of aggregating multiple data sources
 - Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
 ---
@@ -461,7 +640,7 @@ sequenceDiagram
 
 ## Checkpoint 4: ⚡ Optimistic Oracle - Core Functions
 
-👩‍💻 Now it's (finally) time to build! Unlike the previous checkpoints where you explored existing implementations, this section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
+👩‍💻 This section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
 
 🎯 **Your Mission**: Complete the missing function implementations in the `OptimisticOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
diff --git a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
index 1e0fa523..933bbb8d 100644
--- a/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
+++ b/extension/packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol
@@ -60,13 +60,7 @@ contract WhitelistOracle {
      * @dev Creates a new SimpleOracle instance and adds it to the oracles array.
      * @param _owner The address that will own the newly created oracle and can update its price
      */
-    function addOracle(address _owner) public onlyOwner {
-        SimpleOracle newOracle = new SimpleOracle(_owner);
-        address oracleAddress = address(newOracle);
-
-        oracles.push(newOracle);
-        emit OracleAdded(oracleAddress, _owner);
-    }
+    function addOracle(address _owner) public onlyOwner {}
 
     /**
      * @notice Removes an oracle from the whitelist by its array index (only contract owner)
@@ -74,19 +68,7 @@ contract WhitelistOracle {
      *      Reverts with IndexOutOfBounds, if the provided index is >= oracles.length.
      * @param index The index of the oracle to remove from the oracles array
      */
-    function removeOracle(uint256 index) public onlyOwner {
-        if (index >= oracles.length) revert IndexOutOfBounds();
-
-        address oracleAddress = address(oracles[index]);
-
-        if (index != oracles.length - 1) {
-            oracles[index] = oracles[oracles.length - 1];
-        }
-
-        oracles.pop();
-
-        emit OracleRemoved(oracleAddress);
-    }
+    function removeOracle(uint256 index) public onlyOwner {}
 
     /**
      * @notice Returns the aggregated price from all active oracles using median calculation
@@ -94,31 +76,7 @@ contract WhitelistOracle {
      *      of remaining valid prices. Uses StatisticsUtils for sorting and median calculation.
      * @return The median price from all active oracles
      */
-    function getPrice() public view returns (uint256) {
-        if (oracles.length == 0) revert NoOraclesAvailable();
-
-        // Collect prices and timestamps from all oracles
-        uint256[] memory prices = new uint256[](oracles.length);
-        uint256 validCount = 0; // Count of valid prices
-        uint256 currentTime = block.timestamp;
-
-        for (uint256 i = 0; i < oracles.length; i++) {
-            (uint256 price, uint256 timestamp) = oracles[i].getPrice();
-            // Check if the timestamp is within the last STALE_DATA_WINDOW
-            if (currentTime - timestamp < STALE_DATA_WINDOW) {
-                prices[validCount] = price;
-                validCount++;
-            }
-        }
-
-        uint256[] memory validPrices = new uint256[](validCount);
-        for (uint256 i = 0; i < validCount; i++) {
-            validPrices[i] = prices[i];
-        }
-
-        validPrices.sort();
-        return validPrices.getMedian();
-    }
+    function getPrice() public view returns (uint256) {}
 
     /**
      * @notice Returns the addresses of all oracles that have updated their price within the last STALE_DATA_WINDOW
@@ -127,23 +85,5 @@ contract WhitelistOracle {
      *      for gas optimization.
      * @return An array of addresses representing the currently active oracle contracts
      */
-    function getActiveOracleNodes() public view returns (address[] memory) {
-        address[] memory tempNodes = new address[](oracles.length);
-        uint256 count = 0;
-
-        for (uint256 i = 0; i < oracles.length; i++) {
-            (, uint256 timestamp) = oracles[i].getPrice();
-            if (timestamp > block.timestamp - STALE_DATA_WINDOW) {
-                tempNodes[count] = address(oracles[i]);
-                count++;
-            }
-        }
-
-        address[] memory activeNodes = new address[](count);
-        for (uint256 j = 0; j < count; j++) {
-            activeNodes[j] = tempNodes[j];
-        }
-
-        return activeNodes;
-    }
+    function getActiveOracleNodes() public view returns (address[] memory) {}
 }

From a1e23618f219f5313712241f47ec3036fc0e7b6c Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Sat, 13 Sep 2025 23:29:06 +0200
Subject: [PATCH 18/34] update checkpoint 2

---
 README.md                                     | 347 +++++++++++++++---
 .../contracts/01_Staking/StakingOracle.sol    | 128 +------
 2 files changed, 312 insertions(+), 163 deletions(-)

diff --git a/README.md b/README.md
index 80aab96d..c333d54f 100644
--- a/README.md
+++ b/README.md
@@ -454,90 +454,347 @@ yarn simulate:whitelist
 - Users can query which oracle nodes are currently active
 - The system correctly handles edge cases and invalid states
 - Understand the benefits of aggregating multiple data sources
-- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
+[Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
 ---
 
 ## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
 
 🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
 
-🔍 Open the `packages/hardhat/contracts/01_Staking/StakingOracle.sol` file to examine the staking oracle implementation.
+👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, price reporting, reward distribution, and slashing mechanisms.
 
-#### 📖 Understanding the Code:
+🎯 **Your Mission**: Complete the missing function implementations in the `StakingOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you need to fill in the logic.
+
+🔍 Open the `packages/hardhat/contracts/01_Staking/StakingOracle.sol` file to implement the staking oracle functionality.
+
+### ✏️ Tasks:
+
+1. **Implement `registerNode(uint256 initialPrice)`**
+
+* 🏗️ This function allows users to register as oracle nodes by staking ETH
+
+* ⚠️ It should require a minimum stake of 1 ETH, otherwise revert with `InsufficientStake`
+
+* 🧪 It should check that the node is not already registered, otherwise revert with `NodeAlreadyRegistered`
+
+* 🏗️ It should create a new `OracleNode` struct with the provided data
+
+* ➕ It should add the node address to the `nodeAddresses` array
+
+* 📣 It should emit both `NodeRegistered` and `PriceReported` events
+
+<details markdown='1'>
+
+<summary>💡 Hint: Node Registration</summary>
+
+Here's what you need to set in the OracleNode struct:
+- nodeAddress should be `msg.sender`
+- stakedAmount should be `msg.value`
+- lastReportedPrice should be `initialPrice`
+- lastReportedTimestamp should be `block.timestamp`
+- lastClaimedTimestamp should be `block.timestamp`
+- lastSlashedTimestamp should be `0`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function registerNode(uint256 initialPrice) public payable {
+    if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
+    if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
+
+    nodes[msg.sender] = OracleNode({
+        nodeAddress: msg.sender,
+        stakedAmount: msg.value,
+        lastReportedPrice: initialPrice,
+        lastReportedTimestamp: block.timestamp,
+        lastClaimedTimestamp: block.timestamp,
+        lastSlashedTimestamp: 0
+    });
+
+    nodeAddresses.push(msg.sender);
+
+    emit NodeRegistered(msg.sender, msg.value);
+    emit PriceReported(msg.sender, initialPrice);
+}
+```
+
+</details>
+</details>
+
+---
+
+2. **Implement `reportPrice(uint256 price)`**
+
+* 🧪 This function allows registered nodes to report new prices (uses `onlyNode` modifier)
+
+* 🔍 It should verify the node has sufficient stake, otherwise revert with `NotEnoughStake`
+
+* 🔄 It should update the node's last reported price and timestamp
+
+* 📣 It should emit the `PriceReported` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Price Reporting</summary>
+
+- Get a storage reference to the node using `nodes[msg.sender]`
+- Check if `stakedAmount` is at least `MINIMUM_STAKE`
+- Update `lastReportedPrice` and `lastReportedTimestamp`
+- Emit event with sender and new price
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function reportPrice(uint256 price) public onlyNode {
+    OracleNode storage node = nodes[msg.sender];
+    if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
+    node.lastReportedPrice = price;
+    node.lastReportedTimestamp = block.timestamp;
+
+    emit PriceReported(msg.sender, price);
+}
+```
+
+</details>
+</details>
+
+---
+
+3. **Implement `claimReward()` and `rewardNode()`**
+
+* 🧪 This function allows registered nodes to claim their ORA token rewards (uses `onlyNode` modifier)
+
+* 🔍 It should calculate reward amount based on time elapsed since last claim
+
+* 💰 For active nodes (sufficient stake): rewards based on time since last claim
+
+* ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+
+* 🎁 It should mint ORA tokens as rewards (time-based, scaled by 10^18) using the internal `rewardNode()` helper
+
+* 🔒 It should revert with `NoRewardsAvailable` if no rewards are available
+
+* 📣 It should update `lastClaimedTimestamp` and emit `NodeRewarded` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Reward Implementation</summary>
+
+You need to implement both functions:
 
-🧩 The `StakingOracle` contract implements a decentralized economic incentive model:
+**claimReward()** logic:
+- If node has insufficient stake AND was previously slashed: reward = time between lastClaimedTimestamp and lastSlashedTimestamp
+- If node has sufficient stake: reward = time between lastClaimedTimestamp and now
+- Scale reward by 10^18 for token decimals
+- Update lastClaimedTimestamp to current time
+- Call rewardNode() to mint tokens
 
-1. **`registerNode(uint256 initialPrice)`** - Allows users to register as oracle nodes
+**rewardNode()** logic:
+- Simple internal function that mints ORA tokens and emits event
 
-   * ⚠️ Requires a minimum stake of 1 ETH
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function claimReward() public onlyNode {
+    OracleNode memory node = nodes[msg.sender];
+    uint256 rewardAmount = 0;
+
+    if (node.stakedAmount < MINIMUM_STAKE) {
+        if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
+            rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
+        }
+    } else {
+        rewardAmount = block.timestamp - node.lastClaimedTimestamp;
+    }
 
-   * 🧪 Checks that the node is not already registered
+    if (rewardAmount == 0) revert NoRewardsAvailable();
 
-   * 🏗️ Creates a new `OracleNode` struct with the provided data
+    nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
+    rewardNode(msg.sender, rewardAmount * 10 ** 18);
+}
+
+function rewardNode(address nodeAddress, uint256 reward) internal {
+    oracleToken.mint(nodeAddress, reward);
+    emit NodeRewarded(nodeAddress, reward);
+}
+```
 
-   * ➕ Adds the node to the `nodeAddresses` array
+</details>
+</details>
 
-   * 📣 Emits the `NodeRegistered` and `PriceReported` events
+---
 
-2. **`reportPrice(uint256 price)`** - Allows registered nodes to report new prices
+4. **Implement `slashNodes()`, `separateStaleNodes()`, and `slashNode()`**
 
-   * 🧪 Checks that the caller is a registered node
+* 🔎 This function allows anyone to slash nodes with stale data and get rewarded
 
-   * 🔍 Verifies the node has sufficient stake
+* 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
 
-   * 🔄 Updates the node's last reported price and timestamp
+* ✂️ It should slash each stale node by 1 ETH and calculate slasher rewards
 
-   * 📣 Emits the `PriceReported` event
+* 🏅 It should accumulate slasher rewards and send them to the caller
 
-3. **`separateStaleNodes(address[] memory nodesToSeparate)`** - Categorizes nodes into fresh and stale based on data recency
+* ⚠️ It should revert with `FailedToSendReward` if the transfer fails
 
-   * 📦 Takes an array of node addresses to categorize
+<details markdown='1'>
 
-   * ⏱️ Checks each node's last reported timestamp against `STALE_DATA_WINDOW` (5 seconds)
+<summary>💡 Hint: Complete Slashing Implementation</summary>
 
-   * 📊 Separates nodes into two arrays: fresh (recent data) and stale (old data)
+You need to implement all three functions:
 
-   * 🧹 Returns trimmed arrays containing only the relevant addresses
+**slashNodes()** - public entry point:
+- Use separateStaleNodes to get stale addresses
+- Loop through and slash each one
+- Send accumulated rewards to caller
 
-   * 🔍 Used internally by other functions to filter active vs inactive nodes
+**separateStaleNodes()** - categorization logic:
+- Check timestamps against STALE_DATA_WINDOW
+- Return fresh and stale address arrays
 
-4. **`claimReward()`** - Allows registered nodes to claim their ORA token rewards
+**slashNode()** - internal slashing logic:
+- Reduce stake, update timestamp, calculate reward
+- Return slasher reward (10% of penalty)
 
-   * 🧪 Checks that the caller is a registered node
+<details markdown='1'>
 
-   * 🔍 Calculates reward amount based on time elapsed since last claim
+<summary>🎯 Solution</summary>
 
-   * 💰 For active nodes (sufficient stake): rewards based on time since last claim
+```solidity
+function slashNodes() public {
+    (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
+    uint256 slasherReward;
+    for (uint i = 0; i < addressesToSlash.length; i++) {
+        slasherReward += slashNode(addressesToSlash[i], 1 ether);
+    }
 
-   * ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+    (bool sent, ) = msg.sender.call{ value: slasherReward }("");
+    if (!sent) revert FailedToSendReward();
+}
 
-   * 🎁 Mints ORA tokens as rewards (time-based, scaled by 10^18)
+function separateStaleNodes(
+    address[] memory nodesToSeparate
+) public view returns (address[] memory fresh, address[] memory stale) {
+    address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
+    address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
+    uint256 freshCount = 0;
+    uint256 staleCount = 0;
+
+    for (uint i = 0; i < nodesToSeparate.length; i++) {
+        address nodeAddress = nodesToSeparate[i];
+        OracleNode memory node = nodes[nodeAddress];
+        uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
+        bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
+
+        if (dataIsStale) {
+            staleNodeAddresses[staleCount] = nodeAddress;
+            staleCount++;
+        } else {
+            freshNodeAddresses[freshCount] = nodeAddress;
+            freshCount++;
+        }
+    }
 
-   * 📣 Emits the `NodeRewarded` event
+    address[] memory trimmedFreshNodes = new address[](freshCount);
+    address[] memory trimmedStaleNodes = new address[](staleCount);
 
-5. **`slashNodes()`** - Allows anyone to slash nodes that haven't reported recently
+    for (uint i = 0; i < freshCount; i++) {
+        trimmedFreshNodes[i] = freshNodeAddresses[i];
+    }
+    for (uint i = 0; i < staleCount; i++) {
+        trimmedStaleNodes[i] = staleNodeAddresses[i];
+    }
 
-   * 🔎 Identifies nodes with stale data (older than 5 seconds)
+    return (trimmedFreshNodes, trimmedStaleNodes);
+}
 
-   * ✂️ Slashes each stale node by 1 ETH
+function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
+    OracleNode storage node = nodes[nodeToSlash];
+    uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
+    node.stakedAmount -= actualPenalty;
+    node.lastSlashedTimestamp = block.timestamp;
 
-   * 🏅 Rewards the slasher with 10% of the slashed amount so we can guarantee bad nodes are always slashed
+    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
 
-   * 📣 Emits the `NodeSlashed` event for each slashed node
+    emit NodeSlashed(nodeToSlash, actualPenalty);
 
-6. **`getPrice()`** - Aggregates prices from all active nodes
+    return reward;
+}
+```
 
-   * 📦 Collects prices from all active nodes
+</details>
+</details>
 
-   * 🧹 Filters out nodes with stale data
+---
 
-   * 🧮 Calculates the median of all valid prices
+5. **Implement `getPrice()` and `getPricesFromAddresses()`**
 
-   * ⛔️ Reverts if no valid prices are available
+* 📦 This function aggregates prices from all active nodes using median calculation
+
+* 🧹 It should filter out nodes with stale data using `separateStaleNodes()`
+
+* 🔍 It should extract prices from valid addresses using the internal `getPricesFromAddresses()` helper
+
+* ⛔️ It should revert with `NoValidPricesAvailable` if no valid prices exist
+
+* 🧮 It should sort and calculate the median using StatisticsUtils
+
+<details markdown='1'>
+
+<summary>💡 Hint: Price Aggregation Implementation</summary>
+
+You need to implement both functions:
+
+**getPrice()** logic:
+- Get valid (fresh) addresses from separateStaleNodes
+- Get prices from those addresses using getPricesFromAddresses
+- Check if any valid prices exist
+- Sort prices and return median
+
+**getPricesFromAddresses()** logic:
+- Create array same size as input addresses
+- Loop through addresses and get each node's lastReportedPrice
+- Return the prices array
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getPrice() public view returns (uint256) {
+    (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
+    uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
+    if (validPrices.length == 0) revert NoValidPricesAvailable();
+
+    validPrices.sort();
+    return validPrices.getMedian();
+}
+
+function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
+    uint256[] memory prices = new uint256[](addresses.length);
+
+    for (uint256 i = 0; i < addresses.length; i++) {
+        OracleNode memory node = nodes[addresses[i]];
+        prices[i] = node.lastReportedPrice;
+    }
+
+    return prices;
+}
+```
+</details>
+</details>
+
+---
 
 ### 🤔 Key Insights:
 
-- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, where in contrast, good behavior rewards the nodes with ORA token
+- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
 - **Decentralized**: Anyone can participate by staking, no central authority needed
 - **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
 - **Freshness Enforcement**: Stale data is automatically filtered out
@@ -557,11 +814,13 @@ yarn simulate:staking
 
 ### 🥅 Goals:
 
-- Understand how economic incentives drive honest behavior
-- See how slashing mechanisms enforce data freshness
-- Observe the decentralized nature of the system
-- Recognize the trade-offs and risks associated with this type of oracle
-- Oracles that require staking include [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
+- Users can register as oracle nodes by staking ETH
+- Registered nodes can report prices and claim ORA token rewards
+- Anyone can slash nodes with stale data and earn rewards
+- System aggregates prices from active nodes using median calculation
+- Economic incentives drive honest behavior and data freshness
+- Understand the trade-offs between decentralization and complexity
+- See examples in the wild: [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
 
 ---
 
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index f795eae1..9b2a4c17 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -84,77 +84,28 @@ contract StakingOracle {
      *      Requires minimum stake amount and prevents duplicate registrations.
      * @param initialPrice The initial price value this oracle node will report
      */
-    function registerNode(uint256 initialPrice) public payable {
-        if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
-        if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
-
-        nodes[msg.sender] = OracleNode({
-            nodeAddress: msg.sender,
-            stakedAmount: msg.value,
-            lastReportedPrice: initialPrice,
-            lastReportedTimestamp: block.timestamp,
-            lastClaimedTimestamp: block.timestamp,
-            lastSlashedTimestamp: 0
-        });
-
-        nodeAddresses.push(msg.sender);
-
-        emit NodeRegistered(msg.sender, msg.value);
-        emit PriceReported(msg.sender, initialPrice);
-    }
+    function registerNode(uint256 initialPrice) public payable {}
 
     /**
      * @notice Updates the price reported by an oracle node (only registered nodes)
      * @dev Updates the node's lastReportedPrice and timestamp. Requires sufficient stake.
      * @param price The new price value to report
      */
-    function reportPrice(uint256 price) public onlyNode {
-        OracleNode storage node = nodes[msg.sender];
-        if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
-        node.lastReportedPrice = price;
-        node.lastReportedTimestamp = block.timestamp;
-
-        emit PriceReported(msg.sender, price);
-    }
+    function reportPrice(uint256 price) public onlyNode {}
 
     /**
      * @notice Allows registered nodes to claim accumulated ORA token rewards
      * @dev Calculates rewards based on time elapsed since last claim. Slashed nodes
      *      can only claim rewards up to their last slash timestamp.
      */
-    function claimReward() public onlyNode {
-        OracleNode memory node = nodes[msg.sender];
-        uint256 rewardAmount = 0;
-
-        if (node.stakedAmount < MINIMUM_STAKE) {
-            if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
-                rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
-            }
-        } else {
-            rewardAmount = block.timestamp - node.lastClaimedTimestamp;
-        }
-
-        if (rewardAmount == 0) revert NoRewardsAvailable();
-
-        nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-        rewardNode(msg.sender, rewardAmount * 10 ** 18);
-    }
+    function claimReward() public onlyNode {}
 
     /**
      * @notice Public function to slash all nodes with stale data and reward the caller
      * @dev Identifies stale nodes, slashes them, and sends accumulated slasher rewards to caller.
      *      Anyone can call this function to maintain oracle data freshness.
      */
-    function slashNodes() public {
-        (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
-        uint256 slasherReward;
-        for (uint i = 0; i < addressesToSlash.length; i++) {
-            slasherReward += slashNode(addressesToSlash[i], 1 ether);
-        }
-
-        (bool sent, ) = msg.sender.call{ value: slasherReward }("");
-        if (!sent) revert FailedToSendReward();
-    }
+    function slashNodes() public {}
 
     ////////////////////////
     /// View Functions /////
@@ -166,14 +117,7 @@ contract StakingOracle {
      *      Uses StatisticsUtils for sorting and median calculation.
      * @return The median price from all nodes with fresh data
      */
-    function getPrice() public view returns (uint256) {
-        (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
-        uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
-        if (validPrices.length == 0) revert NoValidPricesAvailable();
-
-        validPrices.sort();
-        return validPrices.getMedian();
-    }
+    function getPrice() public view returns (uint256) {}
 
     /**
      * @notice Separates oracle nodes into fresh and stale categories based on data recency
@@ -185,39 +129,7 @@ contract StakingOracle {
      */
     function separateStaleNodes(
         address[] memory nodesToSeparate
-    ) public view returns (address[] memory fresh, address[] memory stale) {
-        address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
-        address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
-        uint256 freshCount = 0;
-        uint256 staleCount = 0;
-
-        for (uint i = 0; i < nodesToSeparate.length; i++) {
-            address nodeAddress = nodesToSeparate[i];
-            OracleNode memory node = nodes[nodeAddress];
-            uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
-            bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
-
-            if (dataIsStale) {
-                staleNodeAddresses[staleCount] = nodeAddress;
-                staleCount++;
-            } else {
-                freshNodeAddresses[freshCount] = nodeAddress;
-                freshCount++;
-            }
-        }
-
-        address[] memory trimmedFreshNodes = new address[](freshCount);
-        address[] memory trimmedStaleNodes = new address[](staleCount);
-
-        for (uint i = 0; i < freshCount; i++) {
-            trimmedFreshNodes[i] = freshNodeAddresses[i];
-        }
-        for (uint i = 0; i < staleCount; i++) {
-            trimmedStaleNodes[i] = staleNodeAddresses[i];
-        }
-
-        return (trimmedFreshNodes, trimmedStaleNodes);
-    }
+    ) public view returns (address[] memory fresh, address[] memory stale) {}
 
     /**
      * @notice Returns the array of all registered oracle node addresses
@@ -238,10 +150,7 @@ contract StakingOracle {
      * @param nodeAddress The address of the node to reward
      * @param reward The amount of ORA tokens to mint as reward
      */
-    function rewardNode(address nodeAddress, uint256 reward) internal {
-        oracleToken.mint(nodeAddress, reward);
-        emit NodeRewarded(nodeAddress, reward);
-    }
+    function rewardNode(address nodeAddress, uint256 reward) internal {}
 
     /**
      * @notice Internal function to slash a node's stake for providing stale data
@@ -251,17 +160,7 @@ contract StakingOracle {
      * @param penalty The amount of ETH to slash from the node's stake
      * @return The reward amount for the slasher (percentage of actual penalty)
      */
-    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
-        OracleNode storage node = nodes[nodeToSlash];
-        uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
-        node.stakedAmount -= actualPenalty;
-
-        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
-
-        emit NodeSlashed(nodeToSlash, actualPenalty);
-
-        return reward;
-    }
+    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {}
 
     /**
      * @notice Internal function to extract price values from an array of node addresses
@@ -269,16 +168,7 @@ contract StakingOracle {
      * @param addresses Array of node addresses to get prices from
      * @return Array of price values corresponding to the input addresses
      */
-    function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
-        uint256[] memory prices = new uint256[](addresses.length);
-
-        for (uint256 i = 0; i < addresses.length; i++) {
-            OracleNode memory node = nodes[addresses[i]];
-            prices[i] = node.lastReportedPrice;
-        }
-
-        return prices;
-    }
+    function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {}
 
     // Notably missing a way to unstake and exit your node but not needed for the challenge
 }

From b6c2cac2fc66e42bb44c8d24455f06b676f6be03 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Sun, 14 Sep 2025 09:00:38 +0200
Subject: [PATCH 19/34] fix: deploy scripts

---
 .../hardhat/deploy/00_deploy_whitelist.ts     | 125 +++++++++---------
 .../hardhat/deploy/01_deploy_staking.ts       |   8 +-
 2 files changed, 69 insertions(+), 64 deletions(-)

diff --git a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
index f0f9a8e1..1155a342 100644
--- a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
+++ b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
@@ -1,9 +1,10 @@
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import { DeployFunction } from "hardhat-deploy/types";
+import { decodeEventLog } from "viem";
 import { fetchPriceFromUniswap } from "../scripts/fetchPriceFromUniswap";
 
 /**
- * Deploys SimpleOracle instances and a WhitelistOracle contract using viem
+ * Deploys a WhitelistOracle contract and creates SimpleOracle instances through it
  *
  * @param hre HardhatRuntimeEnvironment object.
  */
@@ -14,29 +15,7 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
 
   const publicClient = await viem.getPublicClient();
 
-  console.log("Deploying WhitelistOracle contracts...");
-
-  // Get 10 wallet clients (accounts)
-  const accounts = await viem.getWalletClients();
-  const nodeAccounts = accounts.slice(0, 10);
-  const simpleOracleAddresses: string[] = [];
-
-  // Deploy 10 SimpleOracle contracts, each owned by a different account
-  // for (let i = 0; i < nodeAccounts.length; i++) {
-  //   const account = nodeAccounts[i];
-  //   console.log(`Deploying SimpleOracle ${i + 1}/10 from account: ${account.account.address}`);
-  //   const simpleOracle = await deploy(`SimpleOracle_${i + 1}`, {
-  //     contract: "SimpleOracle",
-  //     from: account.account.address,
-  //     args: [],
-  //     log: true,
-  //     autoMine: true,
-  //   });
-  //   simpleOracleAddresses.push(simpleOracle.address);
-  // }
-
-  console.log("Deploying WhitelistOracle...");
-
+  console.log("Deploying WhitelistOracle contract...");
   const whitelistOracleDeployment = await deploy("WhitelistOracle", {
     from: deployer,
     args: [],
@@ -48,51 +27,71 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
 
   // Skip the rest of the setup if we are on a live network
   if (hre.network.name === "localhost") {
-    // Add all SimpleOracle addresses to WhitelistOracle
-    console.log("Adding SimpleOracle instances to WhitelistOracle...");
+    // Get 10 wallet clients (accounts) to be oracle owners
+    const accounts = await viem.getWalletClients();
+    const nodeAccounts = accounts.slice(0, 10);
+
+    console.log("Creating SimpleOracle instances through WhitelistOracle...");
+    const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
+    if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
+
+    // Create SimpleOracle instances through WhitelistOracle.addOracle()
+    // This creates new SimpleOracle contracts owned by the specified addresses
     const createdOracleAddresses: string[] = [];
-    // const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
-    // if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
-
-    // try {
-      for (let i = 0; i < nodeAccounts.length; i++) {
-        const account = nodeAccounts[i];
-        console.log(`Adding SimpleOracle ${i + 1}/10: ${account.account.address}`);
-        const txHash = await account.writeContract({
-          address: whitelistOracleAddress,
+
+    for (let i = 0; i < nodeAccounts.length; i++) {
+      const ownerAddress = nodeAccounts[i].account.address;
+      console.log(`Creating SimpleOracle ${i + 1}/10 with owner: ${ownerAddress}`);
+
+      // Call addOracle which creates a new SimpleOracle instance
+      const txHash = await deployerAccount.writeContract({
+        address: whitelistOracleAddress,
+        abi: whitelistOracleAbi,
+        functionName: "addOracle",
+        args: [ownerAddress],
+      });
+
+      // Wait for transaction and get the created oracle address from event
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      const oracleAddedEvent = receipt.logs.find(log => {
+        try {
+          const decoded = decodeEventLog({
+            abi: whitelistOracleAbi,
+            data: log.data,
+            topics: log.topics,
+          }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
+          return decoded.eventName === "OracleAdded";
+        } catch {
+          return false;
+        }
+      });
+
+      if (oracleAddedEvent) {
+        const decoded = decodeEventLog({
           abi: whitelistOracleAbi,
-          functionName: "addOracle",
-          args: [account.account.address],
-        });
-
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash: txHash,
-        });
-        const
+          data: oracleAddedEvent.data,
+          topics: oracleAddedEvent.topics,
+        }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
+        const oracleAddress = decoded.args.oracleAddress;
+        createdOracleAddresses.push(oracleAddress);
+        console.log(`✅ Created SimpleOracle at: ${oracleAddress}`);
       }
-    // } catch (error: any) {
-    //   if (hre.network.name === "localhost") {
-    //     if (error.message?.includes("Oracle already exists")) {
-    //       console.error("\n❌ Deployment failed: Oracle contracts already exist!\n");
-    //       console.error("🔧 Please retry with:");
-    //       console.error("yarn deploy --reset\n");
-    //       process.exit(1);
-    //     } else {
-    //       throw error;
-    //     }
-    //   }
-    // }
-
-    // Set initial prices for each SimpleOracle
+    }
+
+    // Set initial prices for each created SimpleOracle
     console.log("Setting initial prices for each SimpleOracle...");
     const initialPrice = await fetchPriceFromUniswap();
-    for (let i = 0; i < nodeAccounts.length; i++) {
+
+    for (let i = 0; i < createdOracleAddresses.length; i++) {
       const account = nodeAccounts[i];
-      const simpleOracleDeployment = await hre.deployments.get(`SimpleOracle_${i + 1}`);
+      const oracleAddress = createdOracleAddresses[i] as `0x${string}`;
+
+      // Get SimpleOracle ABI from deployments
+      const simpleOracleDeployment = await hre.deployments.getArtifact("SimpleOracle");
       const simpleOracleAbi = simpleOracleDeployment.abi;
-      const simpleOracleAddress = simpleOracleDeployment.address as `0x${string}`;
+
       await account.writeContract({
-        address: simpleOracleAddress,
+        address: oracleAddress,
         abi: simpleOracleAbi,
         functionName: "setPrice",
         args: [initialPrice],
@@ -102,7 +101,7 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
         method: "evm_mine",
       });
 
-      console.log(`Set price for SimpleOracle_${i + 1} to: ${initialPrice}`);
+      console.log(`Set price for SimpleOracle ${i + 1} to: ${initialPrice}`);
     }
 
     // Calculate initial median price
@@ -115,7 +114,7 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
     });
     console.log(`Initial median price: ${medianPrice.toString()}`);
   }
-  console.log("All oracle contracts deployed and configured successfully!");
+  console.log("WhitelistOracle contract deployed and configured successfully!");
 };
 
 export default deployWhitelistOracleContracts;
diff --git a/extension/packages/hardhat/deploy/01_deploy_staking.ts b/extension/packages/hardhat/deploy/01_deploy_staking.ts
index 2dc0463b..3e762f89 100644
--- a/extension/packages/hardhat/deploy/01_deploy_staking.ts
+++ b/extension/packages/hardhat/deploy/01_deploy_staking.ts
@@ -63,8 +63,14 @@ const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeE
     });
   }
 
+  const nodeAddresses = await publicClient.readContract({
+    address: stakingOracleAddress,
+    abi: deployment.abi,
+    functionName: "getNodeAddresses",
+    args: [],
+  });
   await Promise.all(
-    nodeAccounts.map(account => {
+    nodeAddresses.map(account => {
       return account.writeContract({
         address: stakingOracleAddress,
         abi: deployment.abi,

From aefb9c33af0bfacf8f678c660eade6d12f20073d Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Mon, 15 Sep 2025 19:13:57 +0200
Subject: [PATCH 20/34] feat: add tests for OO checkpoints

---
 README.md                                     |   40 +-
 .../packages/hardhat/test/OptimisticOracle.ts | 1167 ++++++++---------
 2 files changed, 601 insertions(+), 606 deletions(-)

diff --git a/README.md b/README.md
index c333d54f..c294b005 100644
--- a/README.md
+++ b/README.md
@@ -1264,24 +1264,9 @@ This function enables the asserter to get a refund of their posted reward when n
 </details>
 </details>
 
-### 🥅 Goals:
-
-- Proposers can claim rewards for undisputed assertions
-- Winners can claim rewards after disputes are settled
-- Asserters can claim refunds when no proposals are made
-- The system prevents double-claiming and re-entrancy attacks
-- All transfers are handled safely with proper error checking
-
-
 ---
 
-## Checkpoint 6: 🧑‍⚖️ Optimistic Oracle - Settlement & State Management
-
-🎯 **Your Mission**: Implement the final pieces of the optimistic oracle: dispute settlement by the decider and utility functions for querying assertion states and resolutions.
-
-### ✏️ Tasks:
-
-1. **Implement `settleAssertion(uint256 assertionId, bool resolvedOutcome)`**
+4. **Implement `settleAssertion(uint256 assertionId, bool resolvedOutcome)`**
 
 This is the method that the decider will call to settle whether the proposer or disputer are correct.
 
@@ -1332,7 +1317,25 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
-2. **Implement `getState(uint256 assertionId)`**
+### 🥅 Goals:
+
+- Proposers can claim rewards for undisputed assertions
+- Winners can claim rewards after disputes are settled
+- Asserters can claim refunds when no proposals are made
+- The decider can settle disputed assertions
+- The system prevents double-claiming and re-entrancy attacks
+- All transfers are handled safely with proper error checking
+
+
+---
+
+## Checkpoint 6: 🧑‍⚖️ Optimistic Oracle - State Management
+
+🎯 **Your Mission**: Implement the final pieces of the optimistic oracle: utility functions for querying assertion states and resolutions.
+
+### ✏️ Tasks:
+
+1. **Implement `getState(uint256 assertionId)`**
 
 This function returns a simple state machine view for UI/testing.
 
@@ -1388,7 +1391,7 @@ Try to deduce the rest without any help.
 
 ---
 
-3. **Implement `getResolution(uint256 assertionId)`**
+2. **Implement `getResolution(uint256 assertionId)`**
 
 This function will help everyone know the exact outcome of the assertion.
 
@@ -1445,7 +1448,6 @@ yarn simulate:optimistic
 
 ### 🥅 Goals:
 
-- The decider can settle disputed assertions
 - The system provides clear state information for all assertions
 - Users can query resolved outcomes for both disputed and undisputed assertions
 - All functions handle edge cases and invalid states appropriately
diff --git a/extension/packages/hardhat/test/OptimisticOracle.ts b/extension/packages/hardhat/test/OptimisticOracle.ts
index 88703b55..158cf539 100644
--- a/extension/packages/hardhat/test/OptimisticOracle.ts
+++ b/extension/packages/hardhat/test/OptimisticOracle.ts
@@ -36,599 +36,592 @@ describe("OptimisticOracle", function () {
     // Set the decider in the oracle
     await optimisticOracle.setDecider(deciderContract.target);
   });
-
-  describe("Deployment", function () {
-    it("Should deploy successfully", function () {
-      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-      expect(optimisticOracle.target).to.not.be.undefined;
-    });
-
-    it("Should set the correct owner", async function () {
-      const contractOwner = await optimisticOracle.owner();
-      expect(contractOwner).to.equal(owner.address);
-    });
-
-    it("Should have correct constants", async function () {
-      const minimumAssertionWindow = await optimisticOracle.MINIMUM_ASSERTION_WINDOW();
-      const minimumDisputeWindow = await optimisticOracle.MINIMUM_DISPUTE_WINDOW();
-
-      expect(minimumAssertionWindow).to.equal(180n); // 3 minutes
-      expect(minimumDisputeWindow).to.equal(180n); // 3 minutes
-    });
-
-    it("Should start with nextAssertionId at 1", async function () {
-      const nextAssertionId = await optimisticOracle.nextAssertionId();
-      expect(nextAssertionId).to.equal(1n);
-    });
-
-    it("Should return correct assertionId for first assertion", async function () {
-      const description = "Will Bitcoin reach $1m by end of 2026?";
-      const reward = ethers.parseEther("1");
-
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      // Get the assertionId from the event
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      const assertionId = parsedEvent!.args[0];
-
-      expect(assertionId).to.equal(1n);
+  describe("Checkpoint4", function () {
+    describe("Deployment", function () {
+      it("Should deploy successfully", function () {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(optimisticOracle.target).to.not.be.undefined;
+      });
+
+      it("Should set the correct owner", async function () {
+        const contractOwner = await optimisticOracle.owner();
+        expect(contractOwner).to.equal(owner.address);
+      });
+
+      it("Should have correct constants", async function () {
+        const minimumAssertionWindow = await optimisticOracle.MINIMUM_ASSERTION_WINDOW();
+        const minimumDisputeWindow = await optimisticOracle.MINIMUM_DISPUTE_WINDOW();
+
+        expect(minimumAssertionWindow).to.equal(180n); // 3 minutes
+        expect(minimumDisputeWindow).to.equal(180n); // 3 minutes
+      });
+
+      it("Should start with nextAssertionId at 1", async function () {
+        const nextAssertionId = await optimisticOracle.nextAssertionId();
+        expect(nextAssertionId).to.equal(1n);
+      });
+
+      it("Should return correct assertionId for first assertion", async function () {
+        const description = "Will Bitcoin reach $1m by end of 2026?";
+        const reward = ethers.parseEther("1");
+
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        // Get the assertionId from the event
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        const assertionId = parsedEvent!.args[0];
+
+        expect(assertionId).to.equal(1n);
+      });
+    });
+
+    describe("Event Assertion", function () {
+      it("Should allow users to assert events with reward", async function () {
+        const description = "Will Bitcoin reach $1m by end of 2026?";
+        const reward = ethers.parseEther("1");
+
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+
+        // Get the assertionId from the event
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        const assertionId = parsedEvent!.args[0];
+
+        expect(tx)
+          .to.emit(optimisticOracle, "EventAsserted")
+          .withArgs(assertionId, asserter.address, description, reward);
+      });
+
+      it("Should reject assertions with insufficient reward", async function () {
+        const description = "Will Bitcoin reach $1m by end of 2026?";
+        const insufficientReward = ethers.parseEther("0.0");
+
+        await expect(
+          optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: insufficientReward }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+      });
+    });
+
+    describe("Outcome Proposal", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        // Get the assertionId from the event
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+      });
+
+      it("Should allow proposing outcomes with correct bond", async function () {
+        const bond = reward * 2n;
+        const outcome = true;
+
+        const tx = await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
+
+        expect(tx).to.emit(optimisticOracle, "OutcomeProposed").withArgs(assertionId, proposer.address, outcome);
+      });
+
+      it("Should reject proposals with incorrect bond", async function () {
+        const wrongBond = ethers.parseEther("0.05");
+        const outcome = true;
+
+        await expect(
+          optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: wrongBond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+      });
+
+      it("Should reject duplicate proposals", async function () {
+        const bond = reward * 2n;
+        const outcome = true;
+
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
+
+        await expect(
+          optimisticOracle.connect(otherUser).proposeOutcome(assertionId, !outcome, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "AssertionProposed");
+      });
+    });
+
+    describe("Outcome Dispute", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      });
+
+      it("Should allow disputing outcomes with correct bond", async function () {
+        const bond = reward * 2n;
+
+        const tx = await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+        expect(tx).to.emit(optimisticOracle, "OutcomeDisputed").withArgs(assertionId, disputer.address);
+      });
+
+      it("Should reject disputes with incorrect bond", async function () {
+        const wrongBond = ethers.parseEther("0.05");
+
+        await expect(
+          optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: wrongBond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+      });
+
+      it("Should reject disputes after deadline", async function () {
+        // Fast forward time past dispute window
+        await ethers.provider.send("evm_increaseTime", [181]); // 3 minutes + 1 second
+        await ethers.provider.send("evm_mine");
+
+        const bond = reward * 2n;
+        await expect(
+          optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+      });
+
+      it("Should reject duplicate disputes", async function () {
+        const bond = reward * 2n;
+        await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+        await expect(
+          optimisticOracle.connect(otherUser).disputeOutcome(assertionId, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "ProposalDisputed");
+      });
+    });
+
+    describe("Start and End Time Logic", function () {
+      it("Should not allow proposal before startTime", async function () {
+        const reward = ethers.parseEther("1");
+        const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+        const start = now + 1000;
+        const end = start + 1000;
+        const tx = await optimisticOracle.connect(asserter).assertEvent("future event", start, end, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        if (!parsedEvent) throw new Error("Event not found");
+        const assertionId = parsedEvent.args[0];
+
+        const bond = reward * 2n;
+        await expect(
+          optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+      });
+
+      it("Should not allow proposal after endTime", async function () {
+        const reward = ethers.parseEther("1");
+        const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+        const start = now + 1; // Start time must be in the future
+        const end = now + 200; // 200 seconds, which is more than MINIMUM_DISPUTE_WINDOW (180 seconds)
+        const tx = await optimisticOracle.connect(asserter).assertEvent("short event", start, end, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        if (!parsedEvent) throw new Error("Event not found");
+        const assertionId = parsedEvent.args[0];
+
+        // Wait until after endTime
+        await ethers.provider.send("evm_increaseTime", [201]);
+        await ethers.provider.send("evm_mine");
+
+        const bond = reward * 2n;
+        await expect(
+          optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+      });
+
+      it("Should allow proposal only within [startTime, endTime]", async function () {
+        const reward = ethers.parseEther("1");
+        const now = (await ethers.provider.getBlock("latest"))!.timestamp;
+        const start = now + 10; // Start time in the future
+        const end = start + 200; // Ensure endTime is far enough in the future
+        const tx = await optimisticOracle.connect(asserter).assertEvent("window event", start, end, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        if (!parsedEvent) throw new Error("Event not found");
+        const assertionId = parsedEvent.args[0];
+
+        const bond = reward * 2n;
+
+        // Before startTime - should fail
+        await expect(
+          optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+
+        // Move to startTime
+        await ethers.provider.send("evm_increaseTime", [10]);
+        await ethers.provider.send("evm_mine");
+
+        // Now it should work
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      });
     });
   });
 
-  describe("Event Assertion", function () {
-    it("Should allow users to assert events with reward", async function () {
-      const description = "Will Bitcoin reach $1m by end of 2026?";
-      const reward = ethers.parseEther("1");
-
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-
-      // Get the assertionId from the event
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      const assertionId = parsedEvent!.args[0];
-
-      expect(tx)
-        .to.emit(optimisticOracle, "EventAsserted")
-        .withArgs(assertionId, asserter.address, description, reward);
-
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Asserted); // Asserted state
-    });
-
-    it("Should reject assertions with insufficient reward", async function () {
-      const description = "Will Bitcoin reach $1m by end of 2026?";
-      const insufficientReward = ethers.parseEther("0.0");
-
-      await expect(
-        optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: insufficientReward }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+  describe("Checkpoint5", function () {
+    describe("Undisputed Reward Claiming", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+      });
+
+      it("Should allow claiming undisputed rewards after deadline", async function () {
+        // Fast forward time past dispute window
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+
+        const initialBalance = await ethers.provider.getBalance(proposer.address);
+        const tx = await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
+        const receipt = await tx.wait();
+        const finalBalance = await ethers.provider.getBalance(proposer.address);
+
+        // Check that proposer received the reward (reward + bond - gas costs)
+        const expectedReward = reward + reward * 2n;
+        const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+        expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+      });
+
+      it("Should reject claiming before deadline", async function () {
+        await expect(
+          optimisticOracle.connect(proposer).claimUndisputedReward(assertionId),
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
+      });
+
+      it("Should reject claiming disputed assertions", async function () {
+        const bond = reward * 2n;
+        await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+
+        await expect(
+          optimisticOracle.connect(proposer).claimUndisputedReward(assertionId),
+        ).to.be.revertedWithCustomError(optimisticOracle, "ProposalDisputed");
+      });
+
+      it("Should reject claiming already claimed rewards", async function () {
+        // Fast forward time and claim
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+        await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
+
+        await expect(
+          optimisticOracle.connect(proposer).claimUndisputedReward(assertionId),
+        ).to.be.revertedWithCustomError(optimisticOracle, "AlreadyClaimed");
+      });
+    });
+
+    describe("Disputed Reward Claiming", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+        await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+      });
+
+      it("Should allow winner to claim disputed rewards after settlement", async function () {
+        // Settle with proposer winning
+        await deciderContract.connect(owner).settleDispute(assertionId, true);
+
+        const initialBalance = await ethers.provider.getBalance(proposer.address);
+        const tx = await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
+        const receipt = await tx.wait();
+        const finalBalance = await ethers.provider.getBalance(proposer.address);
+
+        // Check that proposer received the reward (reward + bond - gas costs)
+        const expectedReward = reward * 3n;
+        const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+        expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+      });
+
+      it("Should allow disputer to claim when they win", async function () {
+        // Settle with disputer winning
+        await deciderContract.connect(owner).settleDispute(assertionId, false);
+
+        const initialBalance = await ethers.provider.getBalance(disputer.address);
+        const tx = await optimisticOracle.connect(disputer).claimDisputedReward(assertionId);
+        const receipt = await tx.wait();
+        const finalBalance = await ethers.provider.getBalance(disputer.address);
+
+        // Check that disputer received the reward
+        const expectedReward = reward * 3n;
+        const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+        expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
+      });
+
+      it("Should reject claiming before settlement", async function () {
+        await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
+          optimisticOracle,
+          "AwaitingDecider",
+        );
+      });
+
+      it("Should reject claiming already claimed rewards", async function () {
+        await deciderContract.connect(owner).settleDispute(assertionId, true);
+        await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
+
+        await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
+          optimisticOracle,
+          "AlreadyClaimed",
+        );
+      });
+    });
+
+    describe("Refund Claiming", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+      });
+
+      it("Should allow asserter to claim refund for assertions without proposals", async function () {
+        // Fast forward time past dispute window
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+
+        const initialBalance = await ethers.provider.getBalance(asserter.address);
+        const tx = await optimisticOracle.connect(asserter).claimRefund(assertionId);
+        const receipt = await tx.wait();
+        const finalBalance = await ethers.provider.getBalance(asserter.address);
+
+        // Check that asserter received the refund (reward - gas costs)
+        const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
+        expect(finalBalance - initialBalance + gasCost).to.equal(reward);
+      });
+
+      it("Should reject refund claiming for assertions with proposals", async function () {
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+
+        await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
+          optimisticOracle,
+          "AssertionProposed",
+        );
+      });
+
+      it("Should reject claiming already claimed refunds", async function () {
+        // Fast forward time and claim
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+        await optimisticOracle.connect(asserter).claimRefund(assertionId);
+
+        await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
+          optimisticOracle,
+          "AlreadyClaimed",
+        );
+      });
     });
   });
 
-  describe("Outcome Proposal", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      // Get the assertionId from the event
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-    });
-
-    it("Should allow proposing outcomes with correct bond", async function () {
-      const bond = reward * 2n;
-      const outcome = true;
-
-      const tx = await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
-
-      expect(tx).to.emit(optimisticOracle, "OutcomeProposed").withArgs(assertionId, proposer.address, outcome);
-
-      // Check that the proposal was recorded by checking the state
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Proposed); // Proposed state
-    });
-
-    it("Should reject proposals with incorrect bond", async function () {
-      const wrongBond = ethers.parseEther("0.05");
-      const outcome = true;
-
-      await expect(
-        optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: wrongBond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
-    });
-
-    it("Should reject duplicate proposals", async function () {
-      const bond = reward * 2n;
-      const outcome = true;
-
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: bond });
-
-      await expect(
-        optimisticOracle.connect(otherUser).proposeOutcome(assertionId, !outcome, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "AssertionProposed");
-    });
-  });
-
-  describe("Outcome Dispute", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-    });
-
-    it("Should allow disputing outcomes with correct bond", async function () {
-      const bond = reward * 2n;
-
-      const tx = await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-
-      expect(tx).to.emit(optimisticOracle, "OutcomeDisputed").withArgs(assertionId, disputer.address);
-
-      // Check that the dispute was recorded by checking the state
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Disputed); // Disputed state
-    });
-
-    it("Should reject disputes with incorrect bond", async function () {
-      const wrongBond = ethers.parseEther("0.05");
-
-      await expect(
-        optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: wrongBond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
-    });
-
-    it("Should reject disputes after deadline", async function () {
-      // Fast forward time past dispute window
-      await ethers.provider.send("evm_increaseTime", [181]); // 3 minutes + 1 second
-      await ethers.provider.send("evm_mine");
-
-      const bond = reward * 2n;
-      await expect(
-        optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
-    });
-
-    it("Should reject duplicate disputes", async function () {
-      const bond = reward * 2n;
-      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-
-      await expect(
-        optimisticOracle.connect(otherUser).disputeOutcome(assertionId, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "ProposalDisputed");
-    });
-  });
-
-  describe("Undisputed Reward Claiming", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-    });
-
-    it("Should allow claiming undisputed rewards after deadline", async function () {
-      // Fast forward time past dispute window
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-
-      const initialBalance = await ethers.provider.getBalance(proposer.address);
-      const tx = await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
-      const receipt = await tx.wait();
-      const finalBalance = await ethers.provider.getBalance(proposer.address);
-
-      // Check that proposer received the reward (reward + bond - gas costs)
-      const expectedReward = reward + reward * 2n;
-      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
-      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
-    });
-
-    it("Should reject claiming before deadline", async function () {
-      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "InvalidTime",
-      );
-    });
-
-    it("Should reject claiming disputed assertions", async function () {
-      const bond = reward * 2n;
-      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-
-      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "ProposalDisputed",
-      );
-    });
-
-    it("Should reject claiming already claimed rewards", async function () {
-      // Fast forward time and claim
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-      await optimisticOracle.connect(proposer).claimUndisputedReward(assertionId);
-
-      await expect(optimisticOracle.connect(proposer).claimUndisputedReward(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "AlreadyClaimed",
-      );
-    });
-  });
-
-  describe("Disputed Reward Claiming", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-    });
-
-    it("Should allow winner to claim disputed rewards after settlement", async function () {
-      // Settle with proposer winning
-      await deciderContract.connect(owner).settleDispute(assertionId, true);
-
-      const initialBalance = await ethers.provider.getBalance(proposer.address);
-      const tx = await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
-      const receipt = await tx.wait();
-      const finalBalance = await ethers.provider.getBalance(proposer.address);
-
-      // Check that proposer received the reward (reward + bond - gas costs)
-      const expectedReward = reward * 3n;
-      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
-      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
-    });
-
-    it("Should allow disputer to claim when they win", async function () {
-      // Settle with disputer winning
-      await deciderContract.connect(owner).settleDispute(assertionId, false);
-
-      const initialBalance = await ethers.provider.getBalance(disputer.address);
-      const tx = await optimisticOracle.connect(disputer).claimDisputedReward(assertionId);
-      const receipt = await tx.wait();
-      const finalBalance = await ethers.provider.getBalance(disputer.address);
-
-      // Check that disputer received the reward
-      const expectedReward = reward * 3n;
-      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
-      expect(finalBalance - initialBalance + gasCost).to.equal(expectedReward);
-    });
-
-    it("Should reject claiming before settlement", async function () {
-      await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "AwaitingDecider",
-      );
-    });
-
-    it("Should reject claiming already claimed rewards", async function () {
-      await deciderContract.connect(owner).settleDispute(assertionId, true);
-      await optimisticOracle.connect(proposer).claimDisputedReward(assertionId);
-
-      await expect(optimisticOracle.connect(proposer).claimDisputedReward(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "AlreadyClaimed",
-      );
-    });
-  });
-
-  describe("Refund Claiming", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-    });
-
-    it("Should allow asserter to claim refund for assertions without proposals", async function () {
-      // Fast forward time past dispute window
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-
-      const initialBalance = await ethers.provider.getBalance(asserter.address);
-      const tx = await optimisticOracle.connect(asserter).claimRefund(assertionId);
-      const receipt = await tx.wait();
-      const finalBalance = await ethers.provider.getBalance(asserter.address);
-
-      // Check that asserter received the refund (reward - gas costs)
-      const gasCost = receipt!.gasUsed * receipt!.gasPrice!;
-      expect(finalBalance - initialBalance + gasCost).to.equal(reward);
-    });
-
-    it("Should reject refund claiming for assertions with proposals", async function () {
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-
-      await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "AssertionProposed",
-      );
-    });
-
-    it("Should reject claiming already claimed refunds", async function () {
-      // Fast forward time and claim
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-      await optimisticOracle.connect(asserter).claimRefund(assertionId);
-
-      await expect(optimisticOracle.connect(asserter).claimRefund(assertionId)).to.be.revertedWithCustomError(
-        optimisticOracle,
-        "AlreadyClaimed",
-      );
-    });
-  });
-
-  describe("Dispute Settlement", function () {
-    let assertionId: bigint;
-    let description: string;
-    let reward: bigint;
-
-    beforeEach(async function () {
-      description = "Will Bitcoin reach $1m by end of 2026?";
-      reward = ethers.parseEther("1");
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      assertionId = parsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-    });
-
-    it("Should allow decider to settle disputed assertions", async function () {
-      const resolvedOutcome = true;
-      const tx = await deciderContract.connect(owner).settleDispute(assertionId, resolvedOutcome);
-
-      expect(tx).to.emit(optimisticOracle, "AssertionSettled").withArgs(assertionId, resolvedOutcome, proposer.address);
-
-      // Check that the assertion was settled correctly by checking the state
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Settled); // Settled state
-    });
-
-    it("Should reject settlement by non-decider", async function () {
-      const resolvedOutcome = true;
-
-      await expect(
-        optimisticOracle.connect(otherUser).settleAssertion(assertionId, resolvedOutcome),
-      ).to.be.revertedWithCustomError(optimisticOracle, "OnlyDecider");
-    });
-
-    it("Should reject settling undisputed assertions", async function () {
-      // Create a new undisputed assertion
-      const newDescription = "Will Ethereum reach $10k by end of 2024?";
-      const newTx = await optimisticOracle.connect(asserter).assertEvent(newDescription, 0, 0, { value: reward });
-      const newReceipt = await newTx.wait();
-      const newEvent = newReceipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const newParsedEvent = optimisticOracle.interface.parseLog(newEvent as any);
-      const newAssertionId = newParsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(newAssertionId, true, { value: bond });
-
-      const resolvedOutcome = true;
-      await expect(
-        deciderContract.connect(owner).settleDispute(newAssertionId, resolvedOutcome),
-      ).to.be.revertedWithCustomError(optimisticOracle, "NotDisputedAssertion");
-    });
-  });
-
-  describe("State Management", function () {
-    it("Should return correct states for different scenarios", async function () {
-      const description = "Will Bitcoin reach $1m by end of 2026?";
-      const reward = ethers.parseEther("1");
-
-      // Invalid state for non-existent assertion
-      let state = await optimisticOracle.getState(999n);
-      expect(state).to.equal(State.Invalid); // Invalid
-
-      // Asserted state
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      const assertionId = parsedEvent!.args[0];
-
-      state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Asserted); // Asserted
-
-      // Proposed state
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-      state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Proposed); // Proposed
-
-      // Disputed state
-      await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
-      state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Disputed); // Disputed
-
-      // Settled state (after decider resolution)
-      await deciderContract.connect(owner).settleDispute(assertionId, true);
-      state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Settled); // Settled
-    });
-
-    it("Should show settled state for claimable uncontested assertions", async function () {
-      const description = "Will Ethereum reach $10k by end of 2024?";
-      const reward = ethers.parseEther("1");
-
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      const assertionId = parsedEvent!.args[0];
-
-      const bond = reward * 2n;
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
-
-      // Fast forward time past dispute window
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Settled); // Settled (can be claimed)
-    });
-
-    it("Should show expired state for assertions without proposals after deadline", async function () {
-      const description = "Will Ethereum reach $10k by end of 2024?";
-      const reward = ethers.parseEther("1");
-
-      const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      const assertionId = parsedEvent!.args[0];
-
-      // Fast forward time past dispute window without any proposal
-      await ethers.provider.send("evm_increaseTime", [181]);
-      await ethers.provider.send("evm_mine");
-
-      const state = await optimisticOracle.getState(assertionId);
-      expect(state).to.equal(State.Expired); // Expired
-    });
-  });
-
-  describe("Start and End Time Logic", function () {
-    it("Should not allow proposal before startTime", async function () {
-      const reward = ethers.parseEther("1");
-      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
-      const start = now + 1000;
-      const end = start + 1000;
-      const tx = await optimisticOracle.connect(asserter).assertEvent("future event", start, end, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      if (!parsedEvent) throw new Error("Event not found");
-      const assertionId = parsedEvent.args[0];
-
-      const bond = reward * 2n;
-      await expect(
-        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
-    });
-
-    it("Should not allow proposal after endTime", async function () {
-      const reward = ethers.parseEther("1");
-      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
-      const start = now + 1; // Start time must be in the future
-      const end = now + 200; // 200 seconds, which is more than MINIMUM_DISPUTE_WINDOW (180 seconds)
-      const tx = await optimisticOracle.connect(asserter).assertEvent("short event", start, end, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      if (!parsedEvent) throw new Error("Event not found");
-      const assertionId = parsedEvent.args[0];
-
-      // Wait until after endTime
-      await ethers.provider.send("evm_increaseTime", [201]);
-      await ethers.provider.send("evm_mine");
-
-      const bond = reward * 2n;
-      await expect(
-        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
-    });
-
-    it("Should allow proposal only within [startTime, endTime]", async function () {
-      const reward = ethers.parseEther("1");
-      const now = (await ethers.provider.getBlock("latest"))!.timestamp;
-      const start = now + 10; // Start time in the future
-      const end = start + 200; // Ensure endTime is far enough in the future
-      const tx = await optimisticOracle.connect(asserter).assertEvent("window event", start, end, { value: reward });
-      const receipt = await tx.wait();
-      const event = receipt!.logs.find(
-        log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
-      );
-      const parsedEvent = optimisticOracle.interface.parseLog(event as any);
-      if (!parsedEvent) throw new Error("Event not found");
-      const assertionId = parsedEvent.args[0];
-
-      const bond = reward * 2n;
-
-      // Before startTime - should fail
-      await expect(
-        optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond }),
-      ).to.be.revertedWithCustomError(optimisticOracle, "InvalidTime");
-
-      // Move to startTime
-      await ethers.provider.send("evm_increaseTime", [10]);
-      await ethers.provider.send("evm_mine");
-
-      // Now it should work
-      await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+  describe("Checkpoint6", function () {
+    describe("Dispute Settlement", function () {
+      let assertionId: bigint;
+      let description: string;
+      let reward: bigint;
+
+      beforeEach(async function () {
+        description = "Will Bitcoin reach $1m by end of 2026?";
+        reward = ethers.parseEther("1");
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        assertionId = parsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+        await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+      });
+
+      it("Should allow decider to settle disputed assertions", async function () {
+        const resolvedOutcome = true;
+        const tx = await deciderContract.connect(owner).settleDispute(assertionId, resolvedOutcome);
+
+        expect(tx)
+          .to.emit(optimisticOracle, "AssertionSettled")
+          .withArgs(assertionId, resolvedOutcome, proposer.address);
+
+        // Check that the assertion was settled correctly by checking the state
+        const state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Settled); // Settled state
+      });
+
+      it("Should reject settlement by non-decider", async function () {
+        const resolvedOutcome = true;
+
+        await expect(
+          optimisticOracle.connect(otherUser).settleAssertion(assertionId, resolvedOutcome),
+        ).to.be.revertedWithCustomError(optimisticOracle, "OnlyDecider");
+      });
+
+      it("Should reject settling undisputed assertions", async function () {
+        // Create a new undisputed assertion
+        const newDescription = "Will Ethereum reach $10k by end of 2024?";
+        const newTx = await optimisticOracle.connect(asserter).assertEvent(newDescription, 0, 0, { value: reward });
+        const newReceipt = await newTx.wait();
+        const newEvent = newReceipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const newParsedEvent = optimisticOracle.interface.parseLog(newEvent as any);
+        const newAssertionId = newParsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(newAssertionId, true, { value: bond });
+
+        const resolvedOutcome = true;
+        await expect(
+          deciderContract.connect(owner).settleDispute(newAssertionId, resolvedOutcome),
+        ).to.be.revertedWithCustomError(optimisticOracle, "NotDisputedAssertion");
+      });
+    });
+
+    describe("State Management", function () {
+      it("Should return correct states for different scenarios", async function () {
+        const description = "Will Bitcoin reach $1m by end of 2026?";
+        const reward = ethers.parseEther("1");
+
+        // Invalid state for non-existent assertion
+        let state = await optimisticOracle.getState(999n);
+        expect(state).to.equal(State.Invalid); // Invalid
+
+        // Asserted state
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        const assertionId = parsedEvent!.args[0];
+
+        state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Asserted); // Asserted
+
+        // Proposed state
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+        state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Proposed); // Proposed
+
+        // Disputed state
+        await optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: bond });
+        state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Disputed); // Disputed
+
+        // Settled state (after decider resolution)
+        await deciderContract.connect(owner).settleDispute(assertionId, true);
+        state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Settled); // Settled
+      });
+
+      it("Should show settled state for claimable uncontested assertions", async function () {
+        const description = "Will Ethereum reach $10k by end of 2024?";
+        const reward = ethers.parseEther("1");
+
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        const assertionId = parsedEvent!.args[0];
+
+        const bond = reward * 2n;
+        await optimisticOracle.connect(proposer).proposeOutcome(assertionId, true, { value: bond });
+
+        // Fast forward time past dispute window
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+
+        const state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Settled); // Settled (can be claimed)
+      });
+
+      it("Should show expired state for assertions without proposals after deadline", async function () {
+        const description = "Will Ethereum reach $10k by end of 2024?";
+        const reward = ethers.parseEther("1");
+
+        const tx = await optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: reward });
+        const receipt = await tx.wait();
+        const event = receipt!.logs.find(
+          log => optimisticOracle.interface.parseLog(log as any)?.name === "EventAsserted",
+        );
+        const parsedEvent = optimisticOracle.interface.parseLog(event as any);
+        const assertionId = parsedEvent!.args[0];
+
+        // Fast forward time past dispute window without any proposal
+        await ethers.provider.send("evm_increaseTime", [181]);
+        await ethers.provider.send("evm_mine");
+
+        const state = await optimisticOracle.getState(assertionId);
+        expect(state).to.equal(State.Expired); // Expired
+      });
     });
   });
 });

From 5567499a83942966dd03cca658d1d853a912be8c Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Mon, 15 Sep 2025 21:30:33 +0200
Subject: [PATCH 21/34] add tests for whitelist and staking oracles

---
 .../packages/hardhat/test/StakingOracle.ts    | 409 ++++++++++++++++++
 .../packages/hardhat/test/WhitelistOracle.ts  | 219 ++++++++++
 2 files changed, 628 insertions(+)
 create mode 100644 extension/packages/hardhat/test/StakingOracle.ts
 create mode 100644 extension/packages/hardhat/test/WhitelistOracle.ts

diff --git a/extension/packages/hardhat/test/StakingOracle.ts b/extension/packages/hardhat/test/StakingOracle.ts
new file mode 100644
index 00000000..011f97e5
--- /dev/null
+++ b/extension/packages/hardhat/test/StakingOracle.ts
@@ -0,0 +1,409 @@
+import { expect, assert } from "chai";
+import { ethers } from "hardhat";
+import { time } from "@nomicfoundation/hardhat-network-helpers";
+import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import type { StakingOracle, ORA } from "../typechain-types";
+
+describe("Checkpoint2", function () {
+  let oracle: StakingOracle;
+  let oraToken: ORA;
+  let node1: HardhatEthersSigner;
+  let node2: HardhatEthersSigner;
+  let node3: HardhatEthersSigner;
+  let node4: HardhatEthersSigner;
+  let slasher: HardhatEthersSigner;
+
+  const MINIMUM_STAKE = ethers.parseEther("1");
+  const STALE_DATA_WINDOW = 24;
+
+  beforeEach(async function () {
+    [node1, node2, node3, node4, slasher] = await ethers.getSigners();
+
+    const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
+    oracle = await StakingOracleFactory.deploy();
+
+    const oraTokenAddress = await oracle.oracleToken();
+    const ORAFactory = await ethers.getContractFactory("ORA");
+    oraToken = ORAFactory.attach(oraTokenAddress) as ORA;
+  });
+
+  describe("constructor", function () {
+    it("Should deploy an ORA token and set initial state", async function () {
+      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
+      const newly_deployed_oracle = await StakingOracleFactory.deploy();
+      const tokenAddress = await newly_deployed_oracle.oracleToken();
+      const contractCode = await ethers.provider.getCode(tokenAddress);
+      expect(contractCode).to.not.equal("0x");
+    });
+  });
+
+  describe("getNodeAddresses", function () {
+    it("Should return an empty array when no nodes are registered", async function () {
+      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
+      const newOracle = await StakingOracleFactory.deploy();
+      const nodeAddresses = await newOracle.getNodeAddresses();
+      assert(Array.isArray(nodeAddresses), "nodeAddresses should be an array");
+      assert(nodeAddresses.length === 0, "nodeAddresses should be empty");
+    });
+
+    it("Should return all registered node addresses in order", async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      await oracle.connect(node2).registerNode(1501, { value: MINIMUM_STAKE });
+      await oracle.connect(node3).registerNode(1502, { value: MINIMUM_STAKE });
+      const nodeAddresses = await oracle.getNodeAddresses();
+      expect(nodeAddresses).to.deep.equal([node1.address, node2.address, node3.address]);
+    });
+  });
+
+  describe("Node Registration", function () {
+    it("Should allow nodes to register with minimum stake", async function () {
+      const initialPrice = 1500;
+      await expect(oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }))
+        .to.emit(oracle, "NodeRegistered")
+        .withArgs(node1.address, MINIMUM_STAKE)
+        .and.to.emit(oracle, "PriceReported")
+        .withArgs(node1.address, initialPrice);
+
+      const nodeInfo = await oracle.nodes(node1.address);
+      expect(nodeInfo.nodeAddress).to.equal(node1.address);
+      expect(nodeInfo.stakedAmount).to.equal(MINIMUM_STAKE);
+      expect(nodeInfo.lastReportedPrice).to.equal(initialPrice);
+      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+
+      expect(await oracle.nodeAddresses(0)).to.equal(node1.address);
+    });
+
+    it("Should emit NodeRegistered and PriceReported events on successful registration", async function () {
+      const initialPrice = 1500;
+      await expect(oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }))
+        .to.emit(oracle, "NodeRegistered")
+        .withArgs(node1.address, MINIMUM_STAKE)
+        .and.to.emit(oracle, "PriceReported")
+        .withArgs(node1.address, initialPrice);
+    });
+
+    it("Should reject registration with insufficient stake", async function () {
+      const insufficientStake = ethers.parseEther("0.5");
+      const initialPrice = 1500;
+      await expect(
+        oracle.connect(node1).registerNode(initialPrice, { value: insufficientStake }),
+      ).to.be.revertedWithCustomError(oracle, "InsufficientStake");
+    });
+
+    it("Should reject duplicate node registration", async function () {
+      const initialPrice = 1500;
+      await oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE });
+
+      await expect(
+        oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }),
+      ).to.be.revertedWithCustomError(oracle, "NodeAlreadyRegistered");
+    });
+  });
+
+  describe("Price Reporting", function () {
+    beforeEach(async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+    });
+
+    it("Should record the reported price and timestamp in contract state", async function () {
+      let nodeInfo = await oracle.nodes(node1.address);
+      expect(nodeInfo.lastReportedPrice).to.equal(1500);
+      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+
+      const price = 1600;
+      const tx = await oracle.connect(node1).reportPrice(price);
+      await tx.wait();
+
+      nodeInfo = await oracle.nodes(node1.address);
+      expect(nodeInfo.lastReportedPrice).to.equal(price);
+      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+    });
+
+    it("Should emit PriceReported event when reporting price", async function () {
+      const price = 1500;
+      await expect(oracle.connect(node1).reportPrice(price))
+        .to.emit(oracle, "PriceReported")
+        .withArgs(node1.address, price);
+    });
+
+    it("Should reject price reports from unregistered nodes", async function () {
+      const price = 1500;
+      await expect(oracle.connect(node2).reportPrice(price)).to.be.revertedWithCustomError(oracle, "NodeNotRegistered");
+    });
+
+    it("Should reject price reports from nodes with insufficient stake", async function () {
+      await oracle.connect(node1).reportPrice(1500);
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(slasher).slashNodes();
+
+      const nodeInfo = await oracle.nodes(node1.address);
+      const expectedSlashedAmount = MINIMUM_STAKE - ethers.parseEther("1");
+      expect(nodeInfo.stakedAmount).to.equal(expectedSlashedAmount);
+      expect(nodeInfo.stakedAmount).to.be.lt(MINIMUM_STAKE);
+
+      await expect(oracle.connect(node1).reportPrice(1600)).to.be.revertedWithCustomError(oracle, "NotEnoughStake");
+    });
+  });
+
+  describe("Claim Reward", function () {
+    beforeEach(async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+    });
+
+    it("Should allow nodes to claim rewards based on time elapsed", async function () {
+      await time.increase(100); // 100 seconds
+
+      const balanceBefore = await oraToken.balanceOf(node1.address);
+      await oracle.connect(node1).claimReward();
+      const balanceAfter = await oraToken.balanceOf(node1.address);
+
+      expect(balanceAfter).to.be.gt(balanceBefore);
+    });
+
+    it("Should reject claim from unregistered nodes", async function () {
+      await expect(oracle.connect(node2).claimReward()).to.be.revertedWithCustomError(oracle, "NodeNotRegistered");
+    });
+
+    it("Should update lastClaimedTimestamp after successful claim", async function () {
+      await time.increase(100);
+
+      const nodeInfoBefore = await oracle.nodes(node1.address);
+      await oracle.connect(node1).claimReward();
+      const nodeInfoAfter = await oracle.nodes(node1.address);
+
+      expect(nodeInfoAfter.lastClaimedTimestamp).to.be.gt(nodeInfoBefore.lastClaimedTimestamp);
+    });
+
+    it("Should handle reward calculation for slashed nodes correctly", async function () {
+      // Register and let some time pass
+      await time.increase(50);
+
+      // Get slashed - this will set lastSlashedTimestamp
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(slasher).slashNodes();
+
+      const nodeInfo = await oracle.nodes(node1.address);
+      expect(nodeInfo.stakedAmount).to.be.lt(MINIMUM_STAKE);
+      expect(nodeInfo.lastSlashedTimestamp).to.be.gt(0);
+
+      // Slashed nodes can claim rewards up to their slash timestamp
+      const balanceBefore = await oraToken.balanceOf(node1.address);
+      await oracle.connect(node1).claimReward();
+      const balanceAfter = await oraToken.balanceOf(node1.address);
+
+      // Should get rewards for the time between registration and slashing
+      expect(balanceAfter).to.be.gt(balanceBefore);
+
+      // Trying to claim again should fail since no new rewards accumulated
+      await expect(oracle.connect(node1).claimReward()).to.be.revertedWithCustomError(oracle, "NoRewardsAvailable");
+    });
+
+    it("Should revert when no rewards are available", async function () {
+      // Advance time slightly to account for registration timestamp
+      await time.increase(1);
+
+      // Claim should work with minimal time passed
+      const balanceBefore = await oraToken.balanceOf(node1.address);
+      await oracle.connect(node1).claimReward();
+      const balanceAfter = await oraToken.balanceOf(node1.address);
+
+      expect(balanceAfter).to.be.gt(balanceBefore);
+    });
+  });
+
+  describe("Slashing Mechanism", function () {
+    beforeEach(async function () {
+      await oracle.connect(node1).registerNode(1450, { value: MINIMUM_STAKE });
+      await oracle.connect(node2).registerNode(1500, { value: MINIMUM_STAKE });
+      await oracle.connect(node3).registerNode(1550, { value: MINIMUM_STAKE });
+    });
+
+    it("Should slash stale nodes and reward slasher", async function () {
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(node1).reportPrice(1600); // Keep node1 fresh
+
+      const slasherBalanceBefore = await ethers.provider.getBalance(slasher.address);
+      await oracle.connect(slasher).slashNodes();
+      const slasherBalanceAfter = await ethers.provider.getBalance(slasher.address);
+
+      expect(slasherBalanceAfter).to.be.gt(slasherBalanceBefore);
+
+      const node2Info = await oracle.nodes(node2.address);
+      const node3Info = await oracle.nodes(node3.address);
+
+      const expectedSlashedAmount = MINIMUM_STAKE - ethers.parseEther("1");
+      expect(node2Info.stakedAmount).to.equal(expectedSlashedAmount);
+      expect(node3Info.stakedAmount).to.equal(expectedSlashedAmount);
+    });
+
+    it("Should emit NodeSlashed events for stale nodes", async function () {
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(node1).reportPrice(1600);
+
+      await expect(oracle.connect(slasher).slashNodes())
+        .to.emit(oracle, "NodeSlashed")
+        .withArgs(node2.address, ethers.parseEther("1"))
+        .and.to.emit(oracle, "NodeSlashed")
+        .withArgs(node3.address, ethers.parseEther("1"));
+    });
+
+    it("Should reward slasher with correct percentage of slashed amounts", async function () {
+      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
+      const freshOracle = await StakingOracleFactory.deploy();
+
+      await freshOracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      await freshOracle.connect(node2).registerNode(1501, { value: MINIMUM_STAKE });
+
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await freshOracle.connect(node1).reportPrice(1500); // Keep node1 fresh
+
+      const slasherBalanceBefore = await ethers.provider.getBalance(slasher.address);
+
+      const tx = await freshOracle.connect(slasher).slashNodes();
+      const receipt = await tx.wait();
+      if (!receipt) throw new Error("Transaction receipt is null");
+      const gasUsed = BigInt(receipt.gasUsed) * BigInt(receipt.gasPrice);
+
+      const node2InfoAfter = await freshOracle.nodes(node2.address);
+      expect(node2InfoAfter.stakedAmount).to.equal(MINIMUM_STAKE - ethers.parseEther("1"));
+
+      const SLASHER_REWARD_PERCENTAGE = await freshOracle.SLASHER_REWARD_PERCENTAGE();
+      const expectedReward = (ethers.parseEther("1") * SLASHER_REWARD_PERCENTAGE) / 100n;
+      const slasherBalanceAfter = await ethers.provider.getBalance(slasher.address);
+
+      expect(slasherBalanceAfter).to.equal(slasherBalanceBefore + expectedReward - gasUsed);
+    });
+
+    it("Should update lastSlashedTimestamp when node is slashed", async function () {
+      await time.increase(STALE_DATA_WINDOW + 1);
+
+      const nodeInfoBefore = await oracle.nodes(node2.address);
+      expect(nodeInfoBefore.lastSlashedTimestamp).to.equal(0);
+
+      await oracle.connect(slasher).slashNodes();
+
+      const nodeInfoAfter = await oracle.nodes(node2.address);
+      // The contract now properly updates lastSlashedTimestamp
+      expect(nodeInfoAfter.lastSlashedTimestamp).to.be.gt(0);
+      expect(nodeInfoAfter.stakedAmount).to.be.lt(MINIMUM_STAKE);
+    });
+  });
+
+  describe("Price Aggregation and Node Management", function () {
+    beforeEach(async function () {
+      await oracle.connect(node1).registerNode(1450, { value: MINIMUM_STAKE });
+      await oracle.connect(node2).registerNode(1500, { value: MINIMUM_STAKE });
+      await oracle.connect(node3).registerNode(1550, { value: MINIMUM_STAKE });
+    });
+
+    it("Should correctly calculate median price", async function () {
+      let price = await oracle.getPrice();
+      expect(price).to.equal(1500);
+
+      await oracle.connect(node4).registerNode(1600, { value: MINIMUM_STAKE });
+      price = await oracle.getPrice();
+      expect(price).to.equal(1525);
+    });
+
+    it("Should exclude stale price reports in the median calculation", async function () {
+      let price = await oracle.getPrice();
+      expect(price).to.equal(1500);
+
+      await time.increase(STALE_DATA_WINDOW + 1);
+
+      await oracle.connect(node2).reportPrice(2400);
+      await oracle.connect(node3).reportPrice(2500);
+
+      price = await oracle.getPrice();
+      expect(price).to.equal(2450);
+
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(node1).reportPrice(1700);
+
+      price = await oracle.getPrice();
+      expect(price).to.equal(1700);
+    });
+
+    it("Should handle case when no valid prices are available", async function () {
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await expect(oracle.getPrice()).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
+    });
+
+    it("Should correctly separate fresh and stale nodes (via getPrice behavior)", async function () {
+      // Test the separation logic indirectly through price calculation
+      let price = await oracle.getPrice();
+      expect(price).to.equal(1500); // median of [1450, 1500, 1550]
+
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(node1).reportPrice(1600); // Keep node1 fresh
+
+      // Now only node1 should be fresh, so price should be 1600
+      price = await oracle.getPrice();
+      expect(price).to.equal(1600);
+    });
+
+    it("Should handle empty node array in separateStaleNodes", async function () {
+      const result = await oracle.separateStaleNodes([]);
+      const freshNodes = Array.from(result[0]);
+      const staleNodes = Array.from(result[1]);
+      expect(freshNodes).to.deep.equal([]);
+      expect(staleNodes).to.deep.equal([]);
+    });
+  });
+
+  describe("Node Information Queries", function () {
+    beforeEach(async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+    });
+
+    it("Should return correct node information", async function () {
+      const nodeInfo = await oracle.nodes(node1.address);
+      expect(nodeInfo.nodeAddress).to.equal(node1.address);
+      expect(nodeInfo.stakedAmount).to.equal(MINIMUM_STAKE);
+      expect(nodeInfo.lastReportedPrice).to.equal(1500);
+      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+      expect(nodeInfo.lastClaimedTimestamp).to.be.gt(0);
+      expect(nodeInfo.lastSlashedTimestamp).to.equal(0);
+    });
+
+    it("Should return zero values for unregistered node", async function () {
+      const nodeInfo = await oracle.nodes(node2.address);
+      expect(nodeInfo.nodeAddress).to.equal(ethers.ZeroAddress);
+      expect(nodeInfo.stakedAmount).to.equal(0);
+      expect(nodeInfo.lastReportedPrice).to.equal(0);
+      expect(nodeInfo.lastReportedTimestamp).to.equal(0);
+      expect(nodeInfo.lastClaimedTimestamp).to.equal(0);
+      expect(nodeInfo.lastSlashedTimestamp).to.equal(0);
+    });
+  });
+
+  describe("Edge Cases", function () {
+    it("Should handle single node scenarios", async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      const price = await oracle.getPrice();
+      expect(price).to.equal(1500);
+    });
+
+    it("Should handle all nodes becoming stale", async function () {
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      await oracle.connect(node2).registerNode(1600, { value: MINIMUM_STAKE });
+
+      await time.increase(STALE_DATA_WINDOW + 1);
+
+      await expect(oracle.getPrice()).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
+    });
+
+    it("Should handle slashing with insufficient stake", async function () {
+      // Register with minimal stake
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+
+      // Make stale and slash
+      await time.increase(STALE_DATA_WINDOW + 1);
+      await oracle.connect(slasher).slashNodes();
+
+      const nodeInfo = await oracle.nodes(node1.address);
+      // After slashing 1 ETH from 1 ETH stake, should be 0
+      expect(nodeInfo.stakedAmount).to.equal(0);
+    });
+  });
+});
diff --git a/extension/packages/hardhat/test/WhitelistOracle.ts b/extension/packages/hardhat/test/WhitelistOracle.ts
new file mode 100644
index 00000000..6cc83ea9
--- /dev/null
+++ b/extension/packages/hardhat/test/WhitelistOracle.ts
@@ -0,0 +1,219 @@
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import type { WhitelistOracle, SimpleOracle } from "../typechain-types";
+
+describe("Checkpoint1", function () {
+  let whitelistOracle: WhitelistOracle;
+  let owner: HardhatEthersSigner, addr1: HardhatEthersSigner, addr2: HardhatEthersSigner, addr3: HardhatEthersSigner, addr4: HardhatEthersSigner;
+
+  beforeEach(async function () {
+    [owner, addr1, addr2, addr3, addr4] = await ethers.getSigners();
+    const WhitelistOracleFactory = await ethers.getContractFactory("WhitelistOracle");
+    whitelistOracle = await WhitelistOracleFactory.deploy();
+  });
+
+  it("Should deploy and set owner", async function () {
+    expect(await whitelistOracle.owner()).to.equal(owner.address);
+  });
+
+  it("Should allow adding oracles and deploy SimpleOracle contracts", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    
+    const oracleAddress = await whitelistOracle.oracles(0);
+    expect(oracleAddress).to.not.equal(ethers.ZeroAddress);
+    
+    // Check that the oracle is a SimpleOracle contract
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle = SimpleOracleFactory.attach(oracleAddress) as SimpleOracle;
+    expect(await oracle.owner()).to.equal(addr1.address);
+  });
+
+  it("Should allow removing oracles by index", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    
+    const oracle1Address = await whitelistOracle.oracles(0);
+    
+    await whitelistOracle.removeOracle(0);
+    
+    // After removal, the oracle at index 0 should be different (swapped from end)
+    const newOracle0Address = await whitelistOracle.oracles(0);
+    expect(newOracle0Address).to.not.equal(oracle1Address);
+    
+    // Should only have one oracle left
+    await expect(whitelistOracle.oracles(1)).to.be.reverted;
+  });
+
+  it("Should emit OracleAdded event when an oracle is added", async function () {
+    const tx = await whitelistOracle.addOracle(addr1.address);
+    await tx.wait();
+    const oracleAddress = await whitelistOracle.oracles(0);
+    
+    expect(tx).to.emit(whitelistOracle, "OracleAdded").withArgs(oracleAddress, addr1.address);
+  });
+
+  it("Should emit OracleRemoved event when an oracle is removed", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    const oracleAddress = await whitelistOracle.oracles(0);
+    
+    await expect(whitelistOracle.removeOracle(0))
+      .to.emit(whitelistOracle, "OracleRemoved")
+      .withArgs(oracleAddress);
+  });
+
+  it("Should revert with IndexOutOfBounds when trying to remove non-existent oracle", async function () {
+    await expect(whitelistOracle.removeOracle(0)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
+    
+    await whitelistOracle.addOracle(addr1.address);
+    await expect(whitelistOracle.removeOracle(1)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
+    
+    await whitelistOracle.removeOracle(0);
+    await expect(whitelistOracle.removeOracle(0)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
+  });
+
+  it("Should revert with NoOraclesAvailable when getPrice is called with no oracles", async function () {
+    await expect(whitelistOracle.getPrice()).to.be.revertedWithCustomError(whitelistOracle, "NoOraclesAvailable");
+  });
+
+  it("Should return correct price with one oracle", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    const oracleAddress = await whitelistOracle.oracles(0);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle = SimpleOracleFactory.attach(oracleAddress) as SimpleOracle;
+    
+    await oracle.setPrice(1000n);
+    
+    const price = await whitelistOracle.getPrice();
+    expect(price).to.equal(1000n);
+  });
+
+  it("Should return correct median price with odd number of oracles", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    await whitelistOracle.addOracle(addr3.address);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
+    const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
+    const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
+    
+    await oracle1.setPrice(1000n);
+    await oracle2.setPrice(3000n);
+    await oracle3.setPrice(2000n);
+    
+    const medianPrice = await whitelistOracle.getPrice();
+    expect(medianPrice).to.equal(2000n);
+  });
+
+  it("Should return correct median price with even number of oracles", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    await whitelistOracle.addOracle(addr3.address);
+    await whitelistOracle.addOracle(addr4.address);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
+    const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
+    const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
+    const oracle4 = SimpleOracleFactory.attach(await whitelistOracle.oracles(3)) as SimpleOracle;
+    
+    await oracle1.setPrice(1000n);
+    await oracle2.setPrice(3000n);
+    await oracle3.setPrice(2000n);
+    await oracle4.setPrice(4000n);
+    
+    const medianPrice = await whitelistOracle.getPrice();
+    expect(medianPrice).to.equal(2500n);
+  });
+
+  it("Should exclude price reports older than 24 seconds from median calculation", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    await whitelistOracle.addOracle(addr3.address);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
+    const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
+    const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
+    
+    await oracle1.setPrice(1000n);
+    await oracle2.setPrice(2000n);
+    await oracle3.setPrice(3000n);
+    
+    let medianPrice = await whitelistOracle.getPrice();
+    expect(medianPrice).to.equal(2000n);
+    
+    // Advance time by 25 seconds (more than STALE_DATA_WINDOW of 24 seconds)
+    await ethers.provider.send("evm_increaseTime", [25]);
+    await ethers.provider.send("evm_mine");
+    
+    // Set new prices for only two oracles (the old prices should be stale)
+    await oracle1.setPrice(5000n);
+    await oracle2.setPrice(3000n);
+    
+    // Should only use the two fresh prices: median of [5000, 3000] = 4000
+    medianPrice = await whitelistOracle.getPrice();
+    expect(medianPrice).to.equal(4000n);
+  });
+
+  it("Should return empty array when no oracles are active", async function () {
+    const activeNodes = await whitelistOracle.getActiveOracleNodes();
+    expect(activeNodes.length).to.equal(0);
+  });
+
+  it("Should return correct active oracle nodes", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    
+    const oracle1Address = await whitelistOracle.oracles(0);
+    const oracle2Address = await whitelistOracle.oracles(1);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle1 = SimpleOracleFactory.attach(oracle1Address) as SimpleOracle;
+    const oracle2 = SimpleOracleFactory.attach(oracle2Address) as SimpleOracle;
+    
+    await oracle1.setPrice(1000n);
+    await oracle2.setPrice(2000n);
+    
+    let activeNodes = await whitelistOracle.getActiveOracleNodes();
+    expect(activeNodes.length).to.equal(2);
+    expect(activeNodes).to.include(oracle1Address);
+    expect(activeNodes).to.include(oracle2Address);
+    
+    // Make oracle1's price stale
+    await ethers.provider.send("evm_increaseTime", [25]);
+    await ethers.provider.send("evm_mine");
+    
+    // Update only oracle2
+    await oracle2.setPrice(3000n);
+    
+    activeNodes = await whitelistOracle.getActiveOracleNodes();
+    expect(activeNodes.length).to.equal(1);
+    expect(activeNodes[0]).to.equal(oracle2Address);
+  });
+
+  it("Should handle edge case when all prices are stale but array is not empty", async function () {
+    await whitelistOracle.addOracle(addr1.address);
+    await whitelistOracle.addOracle(addr2.address);
+    
+    const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
+    const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
+    const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
+    
+    await oracle1.setPrice(1000n);
+    await oracle2.setPrice(2000n);
+    
+    // Verify median works initially
+    let medianPrice = await whitelistOracle.getPrice();
+    expect(medianPrice).to.equal(1500n);
+    
+    // Make all prices stale
+    await ethers.provider.send("evm_increaseTime", [25]);
+    await ethers.provider.send("evm_mine");
+    
+    const activeNodes = await whitelistOracle.getActiveOracleNodes();
+    expect(activeNodes.length).to.equal(0);
+  });
+});
\ No newline at end of file

From 0531169a7ada662ff307b62cafab9d02e4847520 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Mon, 15 Sep 2025 21:51:34 +0200
Subject: [PATCH 22/34] update readme

---
 README.md                    |  40 ++
 extension/README.md.args.mjs | 705 ++++++++++++++++++++++++++++++-----
 2 files changed, 649 insertions(+), 96 deletions(-)

diff --git a/README.md b/README.md
index c294b005..a2d79377 100644
--- a/README.md
+++ b/README.md
@@ -435,6 +435,14 @@ WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] 
 
 3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+```sh
+
+yarn test --grep "Checkpoint1"
+
+```
+
 🧪 **Live Simulation**: Run the `yarn simulate:whitelist` command to see what a live version of this protocol might look like in action:
 
 ```sh
@@ -800,6 +808,14 @@ function getPricesFromAddresses(address[] memory addresses) internal view return
 - **Freshness Enforcement**: Stale data is automatically filtered out
 - **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+```sh
+
+yarn test --grep "Checkpoint2"
+
+```
+
 🔄 Run `yarn deploy --reset` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
 
 🧪 **Live Simulation**: Run the `yarn simulate:staking` command to watch a live simulation of staking oracle behavior with multiple nodes:
@@ -1082,6 +1098,14 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+```sh
+
+yarn test --grep "Checkpoint4"
+
+```
+
 ### 🥅 Goals:
 
 - Users can assert events with descriptions and time windows
@@ -1317,6 +1341,14 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+```sh
+
+yarn test --grep "Checkpoint5"
+
+```
+
 ### 🥅 Goals:
 
 - Proposers can claim rewards for undisputed assertions
@@ -1432,6 +1464,14 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+```sh
+
+yarn test --grep "Checkpoint6"
+
+```
+
 ✅ Make sure you have implemented everything correctly by running tests with `yarn test`. You can dig into any errors by viewing the tests at `packages/hardhat/test/OptimisticOracle.ts`.
 
 🔄 Run `yarn deploy --reset` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index d7605e57..536981f2 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -6,7 +6,7 @@ export const extraContents = `# 🔮 Oracles
 
 🔗 Build your own decentralized oracle systems! In this challenge, you'll explore three fundamental oracle architectures that power the decentralized web: **Whitelist Oracle**, **Staking Oracle**, and **Optimistic Oracle**.
 
-🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: how do we trust data that comes from outside the blockchain?
+🧠 You'll dive deep into the mechanics of bringing real-world data onto the blockchain, understanding the critical trade-offs between security, decentralization, and efficiency. Each oracle design represents a different approach to solving the fundamental problem: How can we trust data from outside the blockchain, and how do we securely bring it on-chain?
 
 <details markdown='1'><summary>❓ Wondering what an oracle is? Read the overview here.</summary>
 
@@ -96,7 +96,9 @@ yarn start
 
 🧩 The \`SimpleOracle\` contract is the fundamental building block of this oracle system:
 
-1. **\`setPrice(uint256 _newPrice)\`** - This function allows the contract owner to update the current price
+1. **Constructor** - Takes an \`_owner\` address parameter to set who can update the oracle price
+
+2. **\`setPrice(uint256 _newPrice)\`** - This function allows the contract owner to update the current price
 
    * 🔄 Updates the \`price\` state variable with the new value
 
@@ -104,7 +106,7 @@ yarn start
 
    * 📣 Emits the \`PriceUpdated\` event with the new price
 
-2. **\`getPrice()\`** - This function returns both the current price and timestamp
+3. **\`getPrice()\`** - This function returns both the current price and timestamp
 
    * ↩️ Returns them as a tuple: \`(price, timestamp)\`
 
@@ -116,11 +118,13 @@ yarn start
 
 ### 🏛️ Whitelist Oracle - Aggregating Multiple Sources
 
-🔍 Open the \`packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol\` file to examine how multiple SimpleOracle contracts are aggregated.
+🎯 **Your Mission**: Complete the missing function implementations in the \`WhitelistOracle.sol\` contract.
+
+🔍 Open the \`packages/hardhat/contracts/00_Whitelist/WhitelistOracle.sol\` file to implement the whitelist oracle functionality.
 
 #### 📖 Understanding the Relationship:
 
-The \`WhitelistOracle\` contract **aggregates data from multiple SimpleOracle contracts**:
+The \`WhitelistOracle\` contract **creates and manages multiple SimpleOracle contracts**:
 
 \`\`\`solidity
 
@@ -130,46 +134,217 @@ SimpleOracle[] public oracles;  // Array of SimpleOracle contract instances
 
 🏗️ This creates a **hierarchical oracle system**:
 
-- **Individual Level**: Each SimpleOracle contract is managed by a trusted (theoretically) data provider
-- **Aggregation Level**: The WhitelistOracle collects and processes data from all whitelisted SimpleOracle contracts
+- **Individual Level**: Each SimpleOracle contract is managed by a trusted data provider (set during oracle creation)
+- **Aggregation Level**: The WhitelistOracle creates, manages, and processes data from all whitelisted SimpleOracle contracts
 
-#### 📖 Understanding the Code:
+### ✏️ Tasks:
 
-1. **\`addOracle(address oracle)\`** - Adds a SimpleOracle contract to the whitelist
+1. **Implement \`addOracle(address _owner)\`**
 
-   * ✔️ Validates the oracle address is not zero
+* 🏭 This function allows the contract owner to add a new oracle to the whitelist by deploying a SimpleOracle contract
 
-   * 🧪 Checks for duplicates in the existing list
+* 🧩 It should create a new \`SimpleOracle\` instance with the specified \`_owner\`
 
-   * ➕ Adds the SimpleOracle to the \`oracles\` array
+* ➕ It should add the newly created SimpleOracle to the \`oracles\` array
 
-   * 📣 Emits the \`OracleAdded\` event
+* 📣 It should emit the \`OracleAdded\` event with both the oracle address and its owner
 
-2. **\`removeOracle(uint256 index)\`** - Removes a SimpleOracle from the whitelist
+<details markdown='1'>
 
-   * ✔️ Validates the index is within bounds
+<summary>💡 Hint: Creating and Adding Oracles</summary>
 
-   * ➖ Efficiently removes the oracle (swaps with last element)
+Here's what you need to do:
+- Create a new SimpleOracle contract instance using \`new SimpleOracle(_owner)\`
+- Get the address of the newly created oracle using \`address(newOracle)\`
+- Push the oracle instance to the \`oracles\` array
+- Emit the \`OracleAdded\` event with the oracle address and owner
 
-   * 📣 Emits the \`OracleRemoved\` event
+<details markdown='1'>
 
-3. **\`getPrice()\`** - Aggregates prices from all whitelisted SimpleOracle contracts
+<summary>🎯 Solution</summary>
 
-   * 🔁 Loops through each SimpleOracle in the whitelist
+\`\`\`solidity
+function addOracle(address _owner) public onlyOwner {
+    SimpleOracle newOracle = new SimpleOracle(_owner);
+    address oracleAddress = address(newOracle);
 
-   * 📡 Calls \`getPrice()\` on each SimpleOracle to get \`(price, timestamp)\`
+    oracles.push(newOracle);
+    emit OracleAdded(oracleAddress, _owner);
+}
+\`\`\`
 
-   * 🧹 Filters out stale prices (older than 10 seconds)
+</details>
+</details>
 
-   * ⛔️ Reverts if all prices are stale
+---
 
-   * 🧮 Calculates the median of valid prices
+2. **Implement \`removeOracle(uint256 index)\`**
 
-#### 🤔 Key Insights:
+* ✔️ This function allows the contract owner to remove an oracle from the whitelist by its array index
+
+* 🔍 It should validate that the provided index is within bounds, otherwise revert with \`IndexOutOfBounds\`
+
+* 📝 It should record the oracle address before removal for the event
+
+* ➖ It should efficiently remove the oracle using swap-and-pop pattern (swap with last element, then pop)
+
+* 📣 It should emit the \`OracleRemoved\` event with the oracle address
+
+<details markdown='1'>
+
+<summary>💡 Hint: Safe Array Removal</summary>
+
+The swap-and-pop pattern:
+- Check if index is valid (< oracles.length)
+- Store the oracle address for the event
+- If not the last element, swap with the last element
+- Pop the last element
+- Emit the removal event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function removeOracle(uint256 index) public onlyOwner {
+    if (index >= oracles.length) revert IndexOutOfBounds();
+
+    address oracleAddress = address(oracles[index]);
+
+    if (index != oracles.length - 1) {
+        oracles[index] = oracles[oracles.length - 1];
+    }
+
+    oracles.pop();
+
+    emit OracleRemoved(oracleAddress);
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+3. **Implement \`getPrice()\`**
+
+* 📊 This function aggregates prices from all active oracles using median calculation
+
+* ⛔️ It should revert with \`NoOraclesAvailable\` if no oracles exist in the whitelist
+
+* 🔁 It should loop through each oracle and call \`getPrice()\` to get \`(price, timestamp)\`
+
+* 🧹 It should filter out stale prices (older than \`STALE_DATA_WINDOW = 24 seconds\`)
+
+* 📦 It should collect only fresh prices into a properly sized array
+
+* 🧮 It should use StatisticsUtils library to sort prices and calculate the median
+
+<details markdown='1'>
+
+<summary>💡 Hint: Price Aggregation with Freshness Check</summary>
+
+Here's the process:
+- Check if any oracles exist
+- Create a temporary array to collect fresh prices
+- Loop through all oracles, get their (price, timestamp)
+- Check if timestamp is within STALE_DATA_WINDOW of current time
+- Collect valid prices and count them
+- Create a right-sized array with only valid prices
+- Sort and get median using StatisticsUtils
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getPrice() public view returns (uint256) {
+    if (oracles.length == 0) revert NoOraclesAvailable();
+
+    // Collect prices and timestamps from all oracles
+    uint256[] memory prices = new uint256[](oracles.length);
+    uint256 validCount = 0; // Count of valid prices
+    uint256 currentTime = block.timestamp;
+
+    for (uint256 i = 0; i < oracles.length; i++) {
+        (uint256 price, uint256 timestamp) = oracles[i].getPrice();
+        // Check if the timestamp is within the last STALE_DATA_WINDOW
+        if (currentTime - timestamp < STALE_DATA_WINDOW) {
+            prices[validCount] = price;
+            validCount++;
+        }
+    }
+
+    uint256[] memory validPrices = new uint256[](validCount);
+    for (uint256 i = 0; i < validCount; i++) {
+        validPrices[i] = prices[i];
+    }
+
+    validPrices.sort();
+    return validPrices.getMedian();
+}
+\`\`\`
+
+</details>
+</details>
+
+---
 
-- **Composition Pattern**: WhitelistOracle is composed of multiple SimpleOracle contracts
+4. **Implement \`getActiveOracleNodes()\`**
+
+* 📊 This function returns the addresses of all oracles that have updated their price within the last \`STALE_DATA_WINDOW\`
+
+* 🔍 It should iterate through all oracles and filter those with recent timestamps
+
+* 📦 It should use a temporary array to collect active nodes, then create a right-sized return array for gas optimization
+
+* 🎯 It should return an array of addresses representing the currently active oracle contracts
+
+<details markdown='1'>
+
+<summary>💡 Hint: Active Node Filtering</summary>
+
+Similar to getPrice(), but instead of collecting prices, collect oracle addresses:
+- Create temporary array to store addresses
+- Loop through oracles, check timestamp freshness
+- Count and collect active oracle addresses
+- Create properly sized result array
+- Return the active oracle addresses
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getActiveOracleNodes() public view returns (address[] memory) {
+    address[] memory tempNodes = new address[](oracles.length);
+    uint256 count = 0;
+
+    for (uint256 i = 0; i < oracles.length; i++) {
+        (, uint256 timestamp) = oracles[i].getPrice();
+        if (timestamp > block.timestamp - STALE_DATA_WINDOW) {
+            tempNodes[count] = address(oracles[i]);
+            count++;
+        }
+    }
+
+    address[] memory activeNodes = new address[](count);
+    for (uint256 j = 0; j < count; j++) {
+        activeNodes[j] = tempNodes[j];
+    }
+
+    return activeNodes;
+}
+\`\`\`
+
+</details>
+</details>
+
+### 🤔 Key Insights:
+
+- **Factory Pattern**: WhitelistOracle creates and manages SimpleOracle contracts
 - **Centralized Authority**: Only the owner can add/remove SimpleOracle contracts
-- **Consensus Mechanism**: Uses median calculation to resist outliers from individual SimpleOracle contracts
+- **Consensus Mechanism**: Uses median calculation with StatisticsUtils library to resist outliers
 - **Freshness Check**: Filters out stale data from any SimpleOracle
 - **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
 - **Use Cases**: Good for controlled environments where you trust the authority and data providers
@@ -192,7 +367,7 @@ SimpleOracle C → setPrice(98)  → getPrice() → (98, timestamp)
 
 \`\`\`
 
-WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
+WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] → median(100) → 100
 
 \`\`\`
 
@@ -240,10 +415,18 @@ WhitelistOracle → getPrice() → [100, 102, 98] → median(100) → 100
 
 1. **Change Prices**: Use the frontend to modify individual oracle prices
 
-2. **Add New Nodes**: Deploy and add new SimpleOracle contracts to the whitelist
+2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
 3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+\`\`\`sh
+
+yarn test --grep "Checkpoint1"
+
+\`\`\`
+
 🧪 **Live Simulation**: Run the \`yarn simulate:whitelist\` command to see what a live version of this protocol might look like in action:
 
 \`\`\`sh
@@ -256,98 +439,367 @@ yarn simulate:whitelist
 
 ### 🥅 Goals:
 
-- See how WhitelistOracle aggregates multiple nodes
-- Observe how median calculation provides consensus from multiple sources
+- User can add new SimpleOracle instances to the whitelist
+- User can remove oracles
+- System aggregates prices from active oracles using median calculation
+- Stale data is automatically filtered out based on timestamps
+- Users can query which oracle nodes are currently active
+- The system correctly handles edge cases and invalid states
 - Understand the benefits of aggregating multiple data sources
-- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+- Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
+[Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
 ---
 
 ## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
 
 🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
 
-🔍 Open the \`packages/hardhat/contracts/01_Staking/StakingOracle.sol\` file to examine the staking oracle implementation.
+👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, price reporting, reward distribution, and slashing mechanisms.
 
-#### 📖 Understanding the Code:
+🎯 **Your Mission**: Complete the missing function implementations in the \`StakingOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you need to fill in the logic.
+
+🔍 Open the \`packages/hardhat/contracts/01_Staking/StakingOracle.sol\` file to implement the staking oracle functionality.
+
+### ✏️ Tasks:
+
+1. **Implement \`registerNode(uint256 initialPrice)\`**
+
+* 🏗️ This function allows users to register as oracle nodes by staking ETH
+
+* ⚠️ It should require a minimum stake of 1 ETH, otherwise revert with \`InsufficientStake\`
+
+* 🧪 It should check that the node is not already registered, otherwise revert with \`NodeAlreadyRegistered\`
+
+* 🏗️ It should create a new \`OracleNode\` struct with the provided data
+
+* ➕ It should add the node address to the \`nodeAddresses\` array
+
+* 📣 It should emit both \`NodeRegistered\` and \`PriceReported\` events
+
+<details markdown='1'>
+
+<summary>💡 Hint: Node Registration</summary>
+
+Here's what you need to set in the OracleNode struct:
+- nodeAddress should be \`msg.sender\`
+- stakedAmount should be \`msg.value\`
+- lastReportedPrice should be \`initialPrice\`
+- lastReportedTimestamp should be \`block.timestamp\`
+- lastClaimedTimestamp should be \`block.timestamp\`
+- lastSlashedTimestamp should be \`0\`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function registerNode(uint256 initialPrice) public payable {
+    if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
+    if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
+
+    nodes[msg.sender] = OracleNode({
+        nodeAddress: msg.sender,
+        stakedAmount: msg.value,
+        lastReportedPrice: initialPrice,
+        lastReportedTimestamp: block.timestamp,
+        lastClaimedTimestamp: block.timestamp,
+        lastSlashedTimestamp: 0
+    });
+
+    nodeAddresses.push(msg.sender);
+
+    emit NodeRegistered(msg.sender, msg.value);
+    emit PriceReported(msg.sender, initialPrice);
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+2. **Implement \`reportPrice(uint256 price)\`**
+
+* 🧪 This function allows registered nodes to report new prices (uses \`onlyNode\` modifier)
+
+* 🔍 It should verify the node has sufficient stake, otherwise revert with \`NotEnoughStake\`
+
+* 🔄 It should update the node's last reported price and timestamp
+
+* 📣 It should emit the \`PriceReported\` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Price Reporting</summary>
+
+- Get a storage reference to the node using \`nodes[msg.sender]\`
+- Check if \`stakedAmount\` is at least \`MINIMUM_STAKE\`
+- Update \`lastReportedPrice\` and \`lastReportedTimestamp\`
+- Emit event with sender and new price
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function reportPrice(uint256 price) public onlyNode {
+    OracleNode storage node = nodes[msg.sender];
+    if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
+    node.lastReportedPrice = price;
+    node.lastReportedTimestamp = block.timestamp;
+
+    emit PriceReported(msg.sender, price);
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+3. **Implement \`claimReward()\` and \`rewardNode()\`**
+
+* 🧪 This function allows registered nodes to claim their ORA token rewards (uses \`onlyNode\` modifier)
+
+* 🔍 It should calculate reward amount based on time elapsed since last claim
+
+* 💰 For active nodes (sufficient stake): rewards based on time since last claim
+
+* ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+
+* 🎁 It should mint ORA tokens as rewards (time-based, scaled by 10^18) using the internal \`rewardNode()\` helper
+
+* 🔒 It should revert with \`NoRewardsAvailable\` if no rewards are available
+
+* 📣 It should update \`lastClaimedTimestamp\` and emit \`NodeRewarded\` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Reward Implementation</summary>
+
+You need to implement both functions:
+
+**claimReward()** logic:
+- If node has insufficient stake AND was previously slashed: reward = time between lastClaimedTimestamp and lastSlashedTimestamp
+- If node has sufficient stake: reward = time between lastClaimedTimestamp and now
+- Scale reward by 10^18 for token decimals
+- Update lastClaimedTimestamp to current time
+- Call rewardNode() to mint tokens
+
+**rewardNode()** logic:
+- Simple internal function that mints ORA tokens and emits event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
 
-🧩 The \`StakingOracle\` contract implements a decentralized economic incentive model:
+\`\`\`solidity
+function claimReward() public onlyNode {
+    OracleNode memory node = nodes[msg.sender];
+    uint256 rewardAmount = 0;
 
-1. **\`registerNode(uint256 initialPrice)\`** - Allows users to register as oracle nodes
+    if (node.stakedAmount < MINIMUM_STAKE) {
+        if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
+            rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
+        }
+    } else {
+        rewardAmount = block.timestamp - node.lastClaimedTimestamp;
+    }
 
-   * ⚠️ Requires a minimum stake of 1 ETH
+    if (rewardAmount == 0) revert NoRewardsAvailable();
 
-   * 🧪 Checks that the node is not already registered
+    nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
+    rewardNode(msg.sender, rewardAmount * 10 ** 18);
+}
 
-   * 🏗️ Creates a new \`OracleNode\` struct with the provided data
+function rewardNode(address nodeAddress, uint256 reward) internal {
+    oracleToken.mint(nodeAddress, reward);
+    emit NodeRewarded(nodeAddress, reward);
+}
+\`\`\`
 
-   * ➕ Adds the node to the \`nodeAddresses\` array
+</details>
+</details>
 
-   * 📣 Emits the \`NodeRegistered\` and \`PriceReported\` events
+---
 
-2. **\`reportPrice(uint256 price)\`** - Allows registered nodes to report new prices
+4. **Implement \`slashNodes()\`, \`separateStaleNodes()\`, and \`slashNode()\`**
 
-   * 🧪 Checks that the caller is a registered node
+* 🔎 This function allows anyone to slash nodes with stale data and get rewarded
 
-   * 🔍 Verifies the node has sufficient stake
+* 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
 
-   * 🔄 Updates the node's last reported price and timestamp
+* ✂️ It should slash each stale node by 1 ETH and calculate slasher rewards
 
-   * 📣 Emits the \`PriceReported\` event
+* 🏅 It should accumulate slasher rewards and send them to the caller
 
-3. **\`separateStaleNodes(address[] memory nodesToSeparate)\`** - Categorizes nodes into fresh and stale based on data recency
+* ⚠️ It should revert with \`FailedToSendReward\` if the transfer fails
 
-   * 📦 Takes an array of node addresses to categorize
+<details markdown='1'>
 
-   * ⏱️ Checks each node's last reported timestamp against \`STALE_DATA_WINDOW\` (5 seconds)
+<summary>💡 Hint: Complete Slashing Implementation</summary>
 
-   * 📊 Separates nodes into two arrays: fresh (recent data) and stale (old data)
+You need to implement all three functions:
 
-   * 🧹 Returns trimmed arrays containing only the relevant addresses
+**slashNodes()** - public entry point:
+- Use separateStaleNodes to get stale addresses
+- Loop through and slash each one
+- Send accumulated rewards to caller
 
-   * 🔍 Used internally by other functions to filter active vs inactive nodes
+**separateStaleNodes()** - categorization logic:
+- Check timestamps against STALE_DATA_WINDOW
+- Return fresh and stale address arrays
 
-4. **\`claimReward()\`** - Allows registered nodes to claim their ORA token rewards
+**slashNode()** - internal slashing logic:
+- Reduce stake, update timestamp, calculate reward
+- Return slasher reward (10% of penalty)
 
-   * 🧪 Checks that the caller is a registered node
+<details markdown='1'>
 
-   * 🔍 Calculates reward amount based on time elapsed since last claim
+<summary>🎯 Solution</summary>
 
-   * 💰 For active nodes (sufficient stake): rewards based on time since last claim
+\`\`\`solidity
+function slashNodes() public {
+    (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
+    uint256 slasherReward;
+    for (uint i = 0; i < addressesToSlash.length; i++) {
+        slasherReward += slashNode(addressesToSlash[i], 1 ether);
+    }
 
-   * ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+    (bool sent, ) = msg.sender.call{ value: slasherReward }("");
+    if (!sent) revert FailedToSendReward();
+}
+
+function separateStaleNodes(
+    address[] memory nodesToSeparate
+) public view returns (address[] memory fresh, address[] memory stale) {
+    address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
+    address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
+    uint256 freshCount = 0;
+    uint256 staleCount = 0;
+
+    for (uint i = 0; i < nodesToSeparate.length; i++) {
+        address nodeAddress = nodesToSeparate[i];
+        OracleNode memory node = nodes[nodeAddress];
+        uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
+        bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
+
+        if (dataIsStale) {
+            staleNodeAddresses[staleCount] = nodeAddress;
+            staleCount++;
+        } else {
+            freshNodeAddresses[freshCount] = nodeAddress;
+            freshCount++;
+        }
+    }
 
-   * 🎁 Mints ORA tokens as rewards (time-based, scaled by 10^18)
+    address[] memory trimmedFreshNodes = new address[](freshCount);
+    address[] memory trimmedStaleNodes = new address[](staleCount);
 
-   * 📣 Emits the \`NodeRewarded\` event
+    for (uint i = 0; i < freshCount; i++) {
+        trimmedFreshNodes[i] = freshNodeAddresses[i];
+    }
+    for (uint i = 0; i < staleCount; i++) {
+        trimmedStaleNodes[i] = staleNodeAddresses[i];
+    }
 
-5. **\`slashNodes()\`** - Allows anyone to slash nodes that haven't reported recently
+    return (trimmedFreshNodes, trimmedStaleNodes);
+}
 
-   * 🔎 Identifies nodes with stale data (older than 5 seconds)
+function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
+    OracleNode storage node = nodes[nodeToSlash];
+    uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
+    node.stakedAmount -= actualPenalty;
+    node.lastSlashedTimestamp = block.timestamp;
 
-   * ✂️ Slashes each stale node by 1 ETH
+    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
 
-   * 🏅 Rewards the slasher with 10% of the slashed amount so we can guarantee bad nodes are always slashed
+    emit NodeSlashed(nodeToSlash, actualPenalty);
 
-   * 📣 Emits the \`NodeSlashed\` event for each slashed node
+    return reward;
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+5. **Implement \`getPrice()\` and \`getPricesFromAddresses()\`**
+
+* 📦 This function aggregates prices from all active nodes using median calculation
 
-6. **\`getPrice()\`** - Aggregates prices from all active nodes
+* 🧹 It should filter out nodes with stale data using \`separateStaleNodes()\`
 
-   * 📦 Collects prices from all active nodes
+* 🔍 It should extract prices from valid addresses using the internal \`getPricesFromAddresses()\` helper
 
-   * 🧹 Filters out nodes with stale data
+* ⛔️ It should revert with \`NoValidPricesAvailable\` if no valid prices exist
 
-   * 🧮 Calculates the median of all valid prices
+* 🧮 It should sort and calculate the median using StatisticsUtils
 
-   * ⛔️ Reverts if no valid prices are available
+<details markdown='1'>
+
+<summary>💡 Hint: Price Aggregation Implementation</summary>
+
+You need to implement both functions:
+
+**getPrice()** logic:
+- Get valid (fresh) addresses from separateStaleNodes
+- Get prices from those addresses using getPricesFromAddresses
+- Check if any valid prices exist
+- Sort prices and return median
+
+**getPricesFromAddresses()** logic:
+- Create array same size as input addresses
+- Loop through addresses and get each node's lastReportedPrice
+- Return the prices array
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getPrice() public view returns (uint256) {
+    (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
+    uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
+    if (validPrices.length == 0) revert NoValidPricesAvailable();
+
+    validPrices.sort();
+    return validPrices.getMedian();
+}
+
+function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
+    uint256[] memory prices = new uint256[](addresses.length);
+
+    for (uint256 i = 0; i < addresses.length; i++) {
+        OracleNode memory node = nodes[addresses[i]];
+        prices[i] = node.lastReportedPrice;
+    }
+
+    return prices;
+}
+\`\`\`
+</details>
+</details>
+
+---
 
 ### 🤔 Key Insights:
 
-- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, where in contrast, good behavior rewards the nodes with ORA token
+- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
 - **Decentralized**: Anyone can participate by staking, no central authority needed
 - **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
 - **Freshness Enforcement**: Stale data is automatically filtered out
 - **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+\`\`\`sh
+
+yarn test --grep "Checkpoint2"
+
+\`\`\`
+
 🔄 Run \`yarn deploy --reset\` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
 
 🧪 **Live Simulation**: Run the \`yarn simulate:staking\` command to watch a live simulation of staking oracle behavior with multiple nodes:
@@ -362,11 +814,13 @@ yarn simulate:staking
 
 ### 🥅 Goals:
 
-- Understand how economic incentives drive honest behavior
-- See how slashing mechanisms enforce data freshness
-- Observe the decentralized nature of the system
-- Recognize the trade-offs and risks associated with this type of oracle
-- Oracles that require staking include [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
+- Users can register as oracle nodes by staking ETH
+- Registered nodes can report prices and claim ORA token rewards
+- Anyone can slash nodes with stale data and earn rewards
+- System aggregates prices from active nodes using median calculation
+- Economic incentives drive honest behavior and data freshness
+- Understand the trade-offs between decentralization and complexity
+- See examples in the wild: [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
 
 ---
 
@@ -443,9 +897,9 @@ sequenceDiagram
 
 🔗 Look at how [UMA](https://uma.xyz/) does this with their Optimistic Oracle (OO). **This contract is based UMA's OO design**.
 
-## Checkpoint 4: ⚡ Optimistic Oracle - Dispute Resolution
+## Checkpoint 4: ⚡ Optimistic Oracle - Core Functions
 
-👩‍💻 Now it's (finally) time to build! Unlike the previous checkpoints where you explored existing implementations, this section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
+👩‍💻 This section challenges you to implement the optimistic oracle system from scratch. You'll write the core functions that handle assertions, proposals, disputes, and settlements.
 
 🎯 **Your Mission**: Complete the missing function implementations in the \`OptimisticOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
@@ -628,9 +1082,36 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
-4. **Implement \`claimUndisputedReward(uint256 assertionId)\`**
+🔍 Run the following command to check if you implement the functions correctly.
+
+\`\`\`sh
+
+yarn test --grep "Checkpoint4"
+
+\`\`\`
+
+### 🥅 Goals:
+
+- Users can assert events with descriptions and time windows
+- Users can propose outcomes for asserted events
+- Users can dispute proposed outcomes
+- The system correctly handles timing constraints
+- Bond amounts are properly validated
+
+## Checkpoint 5: 💰 Optimistic Oracle - Reward Claims
 
-We need to allow the proposer to claim the reward when no dispute occurs before the deadline.
+🎯 **Your Mission**: Implement the reward claiming mechanisms that allow participants to collect their earnings based on the outcomes of assertions, proposals, and disputes.
+
+💡 **Key Concept**: The optimistic oracle has three different scenarios for claiming rewards:
+- **Undisputed proposals**: Proposer gets reward + bond back
+- **Disputed proposals**: Winner (determined by decider) gets reward + bond back
+- **Refunds**: Asserter gets reward back when no proposals are made
+
+### ✏️ Tasks:
+
+1. **Implement \`claimUndisputedReward(uint256 assertionId)\`**
+
+The proposer can claim the reward only after the deadline, as long as no dispute was submitted before it.
 
 * 🧩 A proposal must exist (revert with \`NotProposedAssertion\`)
 
@@ -686,7 +1167,7 @@ We need to allow the proposer to claim the reward when no dispute occurs before
 
 ---
 
-5. **Implement \`claimDisputedReward(uint256 assertionId)\`**
+2. **Implement \`claimDisputedReward(uint256 assertionId)\`**
 
 Very similar to the last function except this one allows the winner of the dispute to claim *only after the Decider has resolved the dispute*.
 
@@ -744,7 +1225,7 @@ Very similar to the last function except this one allows the winner of the dispu
 
 ---
 
-6. **Implement \`claimRefund(uint256 assertionId)\`**
+3. **Implement \`claimRefund(uint256 assertionId)\`**
 
 This function enables the asserter to get a refund of their posted reward when no proposal arrives by the deadline.
 
@@ -793,7 +1274,7 @@ This function enables the asserter to get a refund of their posted reward when n
 
 ---
 
-7. **Implement \`settleAssertion(uint256 assertionId, bool resolvedOutcome)\`**
+4. **Implement \`settleAssertion(uint256 assertionId, bool resolvedOutcome)\`**
 
 This is the method that the decider will call to settle whether the proposer or disputer are correct.
 
@@ -844,7 +1325,33 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
-8. **Implement \`getState(uint256 assertionId)\`**
+🔍 Run the following command to check if you implement the functions correctly.
+
+\`\`\`sh
+
+yarn test --grep "Checkpoint5"
+
+\`\`\`
+
+### 🥅 Goals:
+
+- Proposers can claim rewards for undisputed assertions
+- Winners can claim rewards after disputes are settled
+- Asserters can claim refunds when no proposals are made
+- The decider can settle disputed assertions
+- The system prevents double-claiming and re-entrancy attacks
+- All transfers are handled safely with proper error checking
+
+
+---
+
+## Checkpoint 6: 🧑‍⚖️ Optimistic Oracle - State Management
+
+🎯 **Your Mission**: Implement the final pieces of the optimistic oracle: utility functions for querying assertion states and resolutions.
+
+### ✏️ Tasks:
+
+1. **Implement \`getState(uint256 assertionId)\`**
 
 This function returns a simple state machine view for UI/testing.
 
@@ -900,7 +1407,7 @@ Try to deduce the rest without any help.
 
 ---
 
-9. **Implement \`getResolution(uint256 assertionId)\`**
+2. **Implement \`getResolution(uint256 assertionId)\`**
 
 This function will help everyone know the exact outcome of the assertion.
 
@@ -941,6 +1448,14 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
+🔍 Run the following command to check if you implement the functions correctly.
+
+\`\`\`sh
+
+yarn test --grep "Checkpoint6"
+
+\`\`\`
+
 ✅ Make sure you have implemented everything correctly by running tests with \`yarn test\`. You can dig into any errors by viewing the tests at \`packages/hardhat/test/OptimisticOracle.ts\`.
 
 🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
@@ -957,15 +1472,13 @@ yarn simulate:optimistic
 
 ### 🥅 Goals:
 
-- Users can assert events with descriptions and time windows
-- Users can propose outcomes for asserted events
-- Users can dispute proposed outcomes
-- Undisputed assertions can be claimed after the dispute window
-- The system correctly handles timing constraints
-- Bond amounts are properly validated
+- The system provides clear state information for all assertions
+- Users can query resolved outcomes for both disputed and undisputed assertions
+- All functions handle edge cases and invalid states appropriately
+- The complete optimistic oracle system works end-to-end
 ---
 
-## Checkpoint 5: 🔍 Oracle Comparison & Trade-offs
+## Checkpoint 7: 🔍 Oracle Comparison & Trade-offs
 
 🧠 Now let's analyze the strengths and weaknesses of each oracle design.
 
@@ -1016,13 +1529,13 @@ yarn simulate:optimistic
 
 Each oracle design solves different problems:
 
-- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization
-- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount
+- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization. Works well for binary or predefined questions (e.g., “Is asset X above price Y?”).
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Handles yes/no and numerical data questions that require strong guarantees (e.g., “What is the ETH/USD price?”).
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
 
 ---
 
-## Checkpoint 6: 💾 Deploy your contracts! 🛰
+## Checkpoint 8: 💾 Deploy your contracts! 🛰
 
 🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
 
@@ -1073,7 +1586,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 ---
 
-## Checkpoint 8: 📜 Contract Verification
+## Checkpoint 9: 📜 Contract Verification
 
 📝 Run the \`yarn verify --network your_network\` command to verify your optimistic oracle contracts on Etherscan 🛰.
 
@@ -1087,7 +1600,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 > 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
 
-## Checkpoint 9: More On Oracles
+## Checkpoint 10: More On Oracles
 
 Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
 

From 9afb407cb9b60267cdd08a4e5efde54f159b4984 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Mon, 15 Sep 2025 22:44:48 +0200
Subject: [PATCH 23/34] fix: deploy script for stakingOracle and display
 balance of ORA

---
 .../hardhat/deploy/01_deploy_staking.ts       | 106 +++++++++---------
 .../nextjs/components/oracle/NodeRow.tsx      |  22 +---
 2 files changed, 55 insertions(+), 73 deletions(-)

diff --git a/extension/packages/hardhat/deploy/01_deploy_staking.ts b/extension/packages/hardhat/deploy/01_deploy_staking.ts
index 3e762f89..4386d412 100644
--- a/extension/packages/hardhat/deploy/01_deploy_staking.ts
+++ b/extension/packages/hardhat/deploy/01_deploy_staking.ts
@@ -20,70 +20,68 @@ const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeE
   const stakingOracleAddress = deployment.address as `0x${string}`;
   console.log("StakingOracle deployed at:", stakingOracleAddress);
 
-  const accounts = await viem.getWalletClients();
-  const nodeAccounts = accounts.slice(1, 11);
+  if (hre.network.name === "localhost") {
+    const accounts = await viem.getWalletClients();
+    const nodeAccounts = accounts.slice(1, 11);
 
-  const publicClient = await viem.getPublicClient();
+    const publicClient = await viem.getPublicClient();
 
-  const oraTokenAddress = await publicClient.readContract({
-    address: stakingOracleAddress,
-    abi: deployment.abi,
-    functionName: "oracleToken",
-    args: [],
-  });
-  console.log("ORA Token deployed at:", oraTokenAddress);
-  const initialPrice = await fetchPriceFromUniswap();
+    const oraTokenAddress = await publicClient.readContract({
+      address: stakingOracleAddress,
+      abi: deployment.abi,
+      functionName: "oracleToken",
+      args: [],
+    });
+    console.log("ORA Token deployed at:", oraTokenAddress);
+    const initialPrice = await fetchPriceFromUniswap();
+
+    try {
+      await Promise.all(
+        nodeAccounts.map(account => {
+          return account.writeContract({
+            address: stakingOracleAddress,
+            abi: deployment.abi,
+            functionName: "registerNode",
+            args: [initialPrice],
+            value: parseEther("15"),
+          });
+        }),
+      );
+    } catch (error: any) {
+      if (error.message?.includes("NodeAlreadyRegistered")) {
+        console.error("\n❌ Deployment failed: Nodes already registered!\n");
+        console.error("🔧 Please retry with:");
+        console.error("yarn deploy --reset\n");
+        process.exit(1);
+      } else {
+        throw error;
+      }
+    }
+
+    const nodeAddresses = await publicClient.readContract({
+      address: stakingOracleAddress,
+      abi: deployment.abi,
+      functionName: "getNodeAddresses",
+      args: [],
+    });
+
+    // Map node addresses to their corresponding wallet clients
+    const nodeWalletClients = nodeAddresses
+      .map(nodeAddress => {
+        return nodeAccounts.find(client => client.account.address === nodeAddress);
+      })
+      .filter(client => client !== undefined);
 
-  try {
     await Promise.all(
-      nodeAccounts.map(account => {
-        return account.writeContract({
+      nodeWalletClients.map(walletClient => {
+        return walletClient.writeContract({
           address: stakingOracleAddress,
           abi: deployment.abi,
-          functionName: "registerNode",
+          functionName: "reportPrice",
           args: [initialPrice],
-          value: parseEther("15"),
         });
       }),
     );
-  } catch (error: any) {
-    if (error.message?.includes("Node already registered")) {
-      console.error("\n❌ Deployment failed: Nodes already registered!\n");
-      console.error("🔧 Please retry with:");
-      console.error("yarn deploy --reset\n");
-      process.exit(1);
-    } else {
-      throw error;
-    }
-  }
-
-  if (hre.network.name === "localhost") {
-    await publicClient.transport.request({
-      method: "evm_mine",
-    });
-  }
-
-  const nodeAddresses = await publicClient.readContract({
-    address: stakingOracleAddress,
-    abi: deployment.abi,
-    functionName: "getNodeAddresses",
-    args: [],
-  });
-  await Promise.all(
-    nodeAddresses.map(account => {
-      return account.writeContract({
-        address: stakingOracleAddress,
-        abi: deployment.abi,
-        functionName: "reportPrice",
-        args: [initialPrice],
-      });
-    }),
-  );
-
-  if (hre.network.name === "localhost") {
-    await publicClient.transport.request({
-      method: "evm_mine",
-    });
   }
 };
 
diff --git a/extension/packages/nextjs/components/oracle/NodeRow.tsx b/extension/packages/nextjs/components/oracle/NodeRow.tsx
index 4c1e5160..5ab51118 100644
--- a/extension/packages/nextjs/components/oracle/NodeRow.tsx
+++ b/extension/packages/nextjs/components/oracle/NodeRow.tsx
@@ -2,7 +2,7 @@ import { useEffect, useRef } from "react";
 import { ConfigSlider } from "./ConfigSlider";
 import { NodeRowProps } from "./types";
 import { erc20Abi, formatEther } from "viem";
-import { useReadContract, useWatchContractEvent } from "wagmi";
+import { useReadContract } from "wagmi";
 import { HighlightedCell } from "~~/components/oracle/HighlightedCell";
 import { Address } from "~~/components/scaffold-eth";
 import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
@@ -20,33 +20,17 @@ export const NodeRow = ({ address, isStale }: NodeRowProps) => {
     functionName: "oracleToken",
   });
 
-  const { data: oraBalance, refetch: refetchOraBalance } = useReadContract({
+  const { data: oraBalance } = useReadContract({
     address: oracleTokenAddress as `0x${string}`,
     abi: erc20Abi,
     functionName: "balanceOf",
     args: [address],
     query: {
       enabled: !!oracleTokenAddress,
+      refetchInterval: 5000, // Refetch every 5 seconds
     },
   });
 
-  useWatchContractEvent({
-    address: oracleTokenAddress as `0x${string}`,
-    abi: erc20Abi,
-    eventName: "Transfer",
-    onLogs: logs => {
-      const relevantTransfer = logs.find(
-        log =>
-          log.args.to?.toLowerCase() === address.toLowerCase() ||
-          log.args.from?.toLowerCase() === address.toLowerCase(),
-      );
-      if (relevantTransfer) {
-        refetchOraBalance();
-      }
-    },
-    enabled: !!oracleTokenAddress,
-  });
-
   const { data: minimumStake } = useScaffoldReadContract({
     contractName: "StakingOracle",
     functionName: "MINIMUM_STAKE",

From 8443e2e8d39b7e90596e089d6633519335845763 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Mon, 15 Sep 2025 23:08:40 +0200
Subject: [PATCH 24/34] minor fix in readme

---
 README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/README.md b/README.md
index a2d79377..ae3dff60 100644
--- a/README.md
+++ b/README.md
@@ -74,8 +74,6 @@ yarn chain
 
 ```sh
 
-cd challenge-oracles
-
 yarn deploy
 
 ```
@@ -84,8 +82,6 @@ yarn deploy
 
 ```sh
 
-cd challenge-oracles
-
 yarn start
 
 ```

From 47f64ce1afc75704cf72138895dbff2c1bd3cd57 Mon Sep 17 00:00:00 2001
From: Sherkhan Azimov <sherkhanazim@gmail.com>
Date: Thu, 18 Sep 2025 12:23:05 +0200
Subject: [PATCH 25/34] minor readme fixes

---
 README.md                    | 10 ++++++----
 extension/README.md.args.mjs | 10 ++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index ae3dff60..b7fd3368 100644
--- a/README.md
+++ b/README.md
@@ -439,6 +439,8 @@ yarn test --grep "Checkpoint1"
 
 ```
 
+🔄 Run `yarn deploy --reset` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+
 🧪 **Live Simulation**: Run the `yarn simulate:whitelist` command to see what a live version of this protocol might look like in action:
 
 ```sh
@@ -931,7 +933,7 @@ sequenceDiagram
 
 * ⏳ It should accept 0 for `endTime` and default to `startTime + MINIMUM_ASSERTION_WINDOW`
 
-* 🕰️ It should check that the given `startTime` is less than the current time (`block.timestamp`) and revert with `InvalidTime` if it is not
+* 🕰️ It should check that the given `startTime` is less than the current time (`block.timestamp`) and revert with `InvalidTime` if it is
 
 * 🧭 It should validate the time window given is >= `MINIMUM_ASSERTION_WINDOW`, otherwise revert with `InvalidTime`
 
@@ -1565,7 +1567,7 @@ Each oracle design solves different problems:
 
 ---
 
-## Checkpoint 7: 🚢 Ship your frontend! 🚁
+## Checkpoint 9: 🚢 Ship your frontend! 🚁
 
 ✏️ Edit your frontend config in `packages/nextjs/scaffold.config.ts` to change the `targetNetwork` to `chains.sepolia` (or your chosen deployed network).
 
@@ -1598,7 +1600,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 ---
 
-## Checkpoint 9: 📜 Contract Verification
+## Checkpoint 10: 📜 Contract Verification
 
 📝 Run the `yarn verify --network your_network` command to verify your optimistic oracle contracts on Etherscan 🛰.
 
@@ -1612,7 +1614,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 > 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
 
-## Checkpoint 10: More On Oracles
+## Checkpoint 11: More On Oracles
 
 Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
 
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 536981f2..a8c97859 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -427,6 +427,8 @@ yarn test --grep "Checkpoint1"
 
 \`\`\`
 
+🔄 Run \`yarn deploy --reset\` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
+
 🧪 **Live Simulation**: Run the \`yarn simulate:whitelist\` command to see what a live version of this protocol might look like in action:
 
 \`\`\`sh
@@ -919,7 +921,7 @@ sequenceDiagram
 
 * ⏳ It should accept 0 for \`endTime\` and default to \`startTime + MINIMUM_ASSERTION_WINDOW\`
 
-* 🕰️ It should check that the given \`startTime\` is less than the current time (\`block.timestamp\`) and revert with \`InvalidTime\` if it is not
+* 🕰️ It should check that the given \`startTime\` is less than the current time (\`block.timestamp\`) and revert with \`InvalidTime\` if it is
 
 * 🧭 It should validate the time window given is >= \`MINIMUM_ASSERTION_WINDOW\`, otherwise revert with \`InvalidTime\`
 
@@ -1553,7 +1555,7 @@ Each oracle design solves different problems:
 
 ---
 
-## Checkpoint 7: 🚢 Ship your frontend! 🚁
+## Checkpoint 9: 🚢 Ship your frontend! 🚁
 
 ✏️ Edit your frontend config in \`packages/nextjs/scaffold.config.ts\` to change the \`targetNetwork\` to \`chains.sepolia\` (or your chosen deployed network).
 
@@ -1586,7 +1588,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 ---
 
-## Checkpoint 9: 📜 Contract Verification
+## Checkpoint 10: 📜 Contract Verification
 
 📝 Run the \`yarn verify --network your_network\` command to verify your optimistic oracle contracts on Etherscan 🛰.
 
@@ -1600,7 +1602,7 @@ For production-grade applications, it's recommended to obtain your own API keys
 
 > 💬 Problems, questions, comments on the stack? Post them to the [🏗 scaffold-eth developers chat](https://t.me/joinchat/F7nCRK3kI93PoCOk)
 
-## Checkpoint 10: More On Oracles
+## Checkpoint 11: More On Oracles
 
 Oracles are fundamental infrastructure for the decentralized web. They enable smart contracts to interact with real-world data, making blockchain applications truly useful beyond simple token transfers.
 

From 0771f0eb889bda849ef9d7047bfc04225faca255 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Thu, 18 Sep 2025 22:02:10 -0400
Subject: [PATCH 26/34] update readme wording and structure in a few places

---
 README.md                    | 79 ++++++++++++++++-----------------
 extension/README.md.args.mjs | 85 +++++++++++++++++++-----------------
 2 files changed, 86 insertions(+), 78 deletions(-)

diff --git a/README.md b/README.md
index b7fd3368..917b1267 100644
--- a/README.md
+++ b/README.md
@@ -359,7 +359,7 @@ function getActiveOracleNodes() public view returns (address[] memory) {
 - **Consensus Mechanism**: Uses median calculation with StatisticsUtils library to resist outliers
 - **Freshness Check**: Filters out stale data from any SimpleOracle
 - **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
-- **Use Cases**: Good for controlled environments where you trust the authority and data providers
+- **Use Cases**: Good for controlled environments where you trust the centralized entity or where things fall back to the rule of law (RWAs)
 
 ### 🔄 How They Work Together:
 
@@ -423,23 +423,23 @@ WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] 
 
 </details>
 
-👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+🔍 Run the following command to check if you implemented the functions correctly.
 
-1. **Change Prices**: Use the frontend to modify individual oracle prices
+```sh
 
-2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
+yarn test --grep "Checkpoint1"
 
-3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
+```
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔄 If it passes all the tests then run `yarn deploy --reset` to deploy your contract to your local chain.
 
-```sh
+👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Go to your browser and switch to the **Whitelist** page. Make sure you connect with the built-in burner wallet so that you can trigger transactions seamlessly. Now try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
-yarn test --grep "Checkpoint1"
+1. **Change Prices**: Use the frontend to modify individual oracle prices
 
-```
+2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
-🔄 Run `yarn deploy --reset` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles and report different prices
 
 🧪 **Live Simulation**: Run the `yarn simulate:whitelist` command to see what a live version of this protocol might look like in action:
 
@@ -453,11 +453,11 @@ yarn simulate:whitelist
 
 ### 🥅 Goals:
 
-- User can add new SimpleOracle instances to the whitelist
-- User can remove oracles
+- You can add new SimpleOracle instances to the whitelist
+- You can remove oracles
 - System aggregates prices from active oracles using median calculation
 - Stale data is automatically filtered out based on timestamps
-- Users can query which oracle nodes are currently active
+- You can query which oracle nodes are currently active
 - The system correctly handles edge cases and invalid states
 - Understand the benefits of aggregating multiple data sources
 - Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
@@ -573,7 +573,7 @@ function reportPrice(uint256 price) public onlyNode {
 
 3. **Implement `claimReward()` and `rewardNode()`**
 
-* 🧪 This function allows registered nodes to claim their ORA token rewards (uses `onlyNode` modifier)
+* 🧪 These functions allow registered nodes to claim their ORA token rewards (uses `onlyNode` modifier)
 
 * 🔍 It should calculate reward amount based on time elapsed since last claim
 
@@ -639,7 +639,7 @@ function rewardNode(address nodeAddress, uint256 reward) internal {
 
 4. **Implement `slashNodes()`, `separateStaleNodes()`, and `slashNode()`**
 
-* 🔎 This function allows anyone to slash nodes with stale data and get rewarded
+* 🔎 These functions work together to allow anyone to slash nodes with stale data and get rewarded
 
 * 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
 
@@ -741,11 +741,11 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 5. **Implement `getPrice()` and `getPricesFromAddresses()`**
 
-* 📦 This function aggregates prices from all active nodes using median calculation
+* 📦 These functions work together to aggregates prices from all active nodes using median calculation
 
 * 🧹 It should filter out nodes with stale data using `separateStaleNodes()`
 
-* 🔍 It should extract prices from valid addresses using the internal `getPricesFromAddresses()` helper
+* 🔍 It should extract prices reported by the nodes at valid addresses using the internal `getPricesFromAddresses()` helper
 
 * ⛔️ It should revert with `NoValidPricesAvailable` if no valid prices exist
 
@@ -764,7 +764,7 @@ You need to implement both functions:
 - Sort prices and return median
 
 **getPricesFromAddresses()** logic:
-- Create array same size as input addresses
+- Create an array the same size as the input addresses
 - Loop through addresses and get each node's lastReportedPrice
 - Return the prices array
 
@@ -802,11 +802,12 @@ function getPricesFromAddresses(address[] memory addresses) internal view return
 
 - **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
 - **Decentralized**: Anyone can participate by staking, no central authority needed
-- **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
+- **Self-Correcting**: Slashing mechanism punishes inactive nodes
 - **Freshness Enforcement**: Stale data is automatically filtered out
 - **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
+- **Improvements**: This could be enhanced by adding slashing for outlier prices that indicate manipulation
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
 
@@ -814,7 +815,7 @@ yarn test --grep "Checkpoint2"
 
 ```
 
-🔄 Run `yarn deploy --reset` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+🔄 Run `yarn deploy --reset` then test the staking oracle. Go to the Staking page in your browser and try registering nodes, reporting prices, and slashing inactive nodes.
 
 🧪 **Live Simulation**: Run the `yarn simulate:staking` command to watch a live simulation of staking oracle behavior with multiple nodes:
 
@@ -828,7 +829,7 @@ yarn simulate:staking
 
 ### 🥅 Goals:
 
-- Users can register as oracle nodes by staking ETH
+- You can register as oracle nodes by staking ETH
 - Registered nodes can report prices and claim ORA token rewards
 - Anyone can slash nodes with stale data and earn rewards
 - System aggregates prices from active nodes using median calculation
@@ -903,7 +904,7 @@ sequenceDiagram
 
 💡 If someone knows the answer within the correct time then they **propose** the answer, posting a bond. This bond is a risk to them because if their answer is thought to be wrong by someone else then they might lose it. This keeps people economically tied to the **proposals** they make.
 
-⏳ Then if no one **disputes** the proposal before the dispute window is over then the proposal is considered to be true, and the proposer may claim the reward and their bond. The dispute window should give anyone ample time to submit a dispute.
+⏳ Then if no one **disputes** the proposal before the dispute window is over the proposal is considered to be true, and the proposer may claim the reward and get back their bond. The dispute window should give anyone ample time to submit a dispute.
 
 ⚖️ If someone does **dispute** during the dispute window then they must also post a bond equal to the proposer's bond. This kicks the assertion out of any particular timeline and puts it in a state where it is waiting for a decision from the **decider**. Once the decider contract has **settled** the assertion, the winner can claim the reward and their posted bond. The decider gets the loser's bond.
 
@@ -939,7 +940,7 @@ sequenceDiagram
 
 * 🏗️ It should create a new `EventAssertion` struct with relevant properties set - see if you can figure it out
 
-* 🗂️ That struct should be stored in the `assertions` mapping. You can use `nextAssertionId` but don't forget to increment it!
+* 🗂️ That struct should be stored in the `assertions` mapping. You can use `nextAssertionId` but don't forget to increment it afterwards!
 
 * 📣 It should emit the `EventAsserted` event
 
@@ -1096,7 +1097,7 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
 
@@ -1106,9 +1107,9 @@ yarn test --grep "Checkpoint4"
 
 ### 🥅 Goals:
 
-- Users can assert events with descriptions and time windows
-- Users can propose outcomes for asserted events
-- Users can dispute proposed outcomes
+- You can assert events with descriptions and time windows
+- You can propose outcomes for asserted events
+- You can dispute proposed outcomes
 - The system correctly handles timing constraints
 - Bond amounts are properly validated
 
@@ -1339,7 +1340,7 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
 
@@ -1462,7 +1463,7 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
 
@@ -1472,7 +1473,7 @@ yarn test --grep "Checkpoint6"
 
 ✅ Make sure you have implemented everything correctly by running tests with `yarn test`. You can dig into any errors by viewing the tests at `packages/hardhat/test/OptimisticOracle.ts`.
 
-🔄 Run `yarn deploy --reset` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+🔄 Run `yarn deploy --reset` then test the optimistic oracle. Go to the Optimistic page and try creating assertions, proposing outcomes, and disputing them.
 
 🧪 **Live Simulation**: Run the `yarn simulate:optimistic` command to see the full optimistic oracle lifecycle in action:
 
@@ -1487,7 +1488,7 @@ yarn simulate:optimistic
 ### 🥅 Goals:
 
 - The system provides clear state information for all assertions
-- Users can query resolved outcomes for both disputed and undisputed assertions
+- You can query resolved outcomes for both disputed and undisputed assertions
 - All functions handle edge cases and invalid states appropriately
 - The complete optimistic oracle system works end-to-end
 ---
@@ -1499,10 +1500,10 @@ yarn simulate:optimistic
 ### 📊 Comparison Table:
 | Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
 |--------|------------------|----------------|-------------------|
-| **Speed** | Fast | Medium | Slow |
-| **Security** | Low (trusted authority) | Medium (economic incentives) | High (dispute resolution) |
+| **Speed** | Fast | Fast | Slower |
+| **Security** | Low (trusted authority) | High (economic incentives) | High (dispute resolution) |
 | **Decentralization** | Low | High | Depends on Decider Implementation |
-| **Cost** | Low | Medium | High |
+| **Cost** | Low | High (stake) | High (rewards and bonds) |
 | **Complexity** | Simple | Medium | Complex |
 
 ### 🤔 Key Trade-offs:
@@ -1543,9 +1544,9 @@ yarn simulate:optimistic
 
 Each oracle design solves different problems:
 
-- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization. Works well for binary or predefined questions (e.g., “Is asset X above price Y?”).
-- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Handles yes/no and numerical data questions that require strong guarantees (e.g., “What is the ETH/USD price?”).
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
+- **Whitelist Oracle**: Best for setups with trusted intermediaries already in the loop such as RWAs where speed and accuracy are more important than decentralization.
+- **Staking Oracle**: Best for low-latency, high-value DeFi applications where decentralization and security are crucial.
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount and higher latency is not a huge downside. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
 
 ---
 
@@ -1626,4 +1627,4 @@ Oracles are fundamental infrastructure for the decentralized web. They enable sm
 
 🚀 As you continue your blockchain development journey, you'll encounter many variations and combinations of these patterns. Understanding the fundamental trade-offs will help you choose the right oracle design for your specific use case.
 
-🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
\ No newline at end of file
+🧠 Remember: the best oracle is the one that provides the right balance of security, speed, flexibility and cost for your application's needs!
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index a8c97859..fd1dd879 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -1,6 +1,6 @@
 export const skipQuickStart = true;
 
-export const extraContents = `# 🔮 Oracles
+export const extraContents = `# 🔮 Oracle Challenge
 
 ![readme-oracle](https://raw.githubusercontent.com/scaffold-eth/se-2-challenges/challenge-oracles/extension/packages/nextjs/public/hero.png)
 
@@ -51,19 +51,25 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 > 💻 Start your local network (a blockchain emulator in your computer):
 
 \`\`\`sh
+
 yarn chain
+
 \`\`\`
 
 > 🛰️ In a second terminal window, deploy your contract (locally):
 
 \`\`\`sh
+
 yarn deploy
+
 \`\`\`
 
 > 📱 In a third terminal window, start your frontend:
 
 \`\`\`sh
+
 yarn start
+
 \`\`\`
 
 📱 Open http://localhost:3000 to see the app.
@@ -347,7 +353,7 @@ function getActiveOracleNodes() public view returns (address[] memory) {
 - **Consensus Mechanism**: Uses median calculation with StatisticsUtils library to resist outliers
 - **Freshness Check**: Filters out stale data from any SimpleOracle
 - **Trust Model**: Requires trust in the whitelist authority and each SimpleOracle provider
-- **Use Cases**: Good for controlled environments where you trust the authority and data providers
+- **Use Cases**: Good for controlled environments where you trust the centralized entity or where things fall back to the rule of law (RWAs)
 
 ### 🔄 How They Work Together:
 
@@ -411,23 +417,23 @@ WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] 
 
 </details>
 
-👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+🔍 Run the following command to check if you implemented the functions correctly.
 
-1. **Change Prices**: Use the frontend to modify individual oracle prices
+\`\`\`sh
 
-2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
+yarn test --grep "Checkpoint1"
 
-3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
+\`\`\`
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔄 If it passes all the tests then run \`yarn deploy --reset\` to deploy your contract to your local chain.
 
-\`\`\`sh
+👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Go to your browser and switch to the **Whitelist** page. Make sure you connect with the built-in burner wallet so that you can trigger transactions seamlessly. Now try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
-yarn test --grep "Checkpoint1"
+1. **Change Prices**: Use the frontend to modify individual oracle prices
 
-\`\`\`
+2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
-🔄 Run \`yarn deploy --reset\` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles and report different prices
 
 🧪 **Live Simulation**: Run the \`yarn simulate:whitelist\` command to see what a live version of this protocol might look like in action:
 
@@ -441,11 +447,11 @@ yarn simulate:whitelist
 
 ### 🥅 Goals:
 
-- User can add new SimpleOracle instances to the whitelist
-- User can remove oracles
+- You can add new SimpleOracle instances to the whitelist
+- You can remove oracles
 - System aggregates prices from active oracles using median calculation
 - Stale data is automatically filtered out based on timestamps
-- Users can query which oracle nodes are currently active
+- You can query which oracle nodes are currently active
 - The system correctly handles edge cases and invalid states
 - Understand the benefits of aggregating multiple data sources
 - Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
@@ -561,7 +567,7 @@ function reportPrice(uint256 price) public onlyNode {
 
 3. **Implement \`claimReward()\` and \`rewardNode()\`**
 
-* 🧪 This function allows registered nodes to claim their ORA token rewards (uses \`onlyNode\` modifier)
+* 🧪 These functions allow registered nodes to claim their ORA token rewards (uses \`onlyNode\` modifier)
 
 * 🔍 It should calculate reward amount based on time elapsed since last claim
 
@@ -627,7 +633,7 @@ function rewardNode(address nodeAddress, uint256 reward) internal {
 
 4. **Implement \`slashNodes()\`, \`separateStaleNodes()\`, and \`slashNode()\`**
 
-* 🔎 This function allows anyone to slash nodes with stale data and get rewarded
+* 🔎 These functions work together to allow anyone to slash nodes with stale data and get rewarded
 
 * 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
 
@@ -729,11 +735,11 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 5. **Implement \`getPrice()\` and \`getPricesFromAddresses()\`**
 
-* 📦 This function aggregates prices from all active nodes using median calculation
+* 📦 These functions work together to aggregates prices from all active nodes using median calculation
 
 * 🧹 It should filter out nodes with stale data using \`separateStaleNodes()\`
 
-* 🔍 It should extract prices from valid addresses using the internal \`getPricesFromAddresses()\` helper
+* 🔍 It should extract prices reported by the nodes at valid addresses using the internal \`getPricesFromAddresses()\` helper
 
 * ⛔️ It should revert with \`NoValidPricesAvailable\` if no valid prices exist
 
@@ -752,7 +758,7 @@ You need to implement both functions:
 - Sort prices and return median
 
 **getPricesFromAddresses()** logic:
-- Create array same size as input addresses
+- Create an array the same size as the input addresses
 - Loop through addresses and get each node's lastReportedPrice
 - Return the prices array
 
@@ -790,11 +796,12 @@ function getPricesFromAddresses(address[] memory addresses) internal view return
 
 - **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
 - **Decentralized**: Anyone can participate by staking, no central authority needed
-- **Self-Correcting**: Slashing mechanism punishes inactive or malicious nodes
+- **Self-Correcting**: Slashing mechanism punishes inactive nodes
 - **Freshness Enforcement**: Stale data is automatically filtered out
 - **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
+- **Improvements**: This could be enhanced by adding slashing for outlier prices that indicate manipulation
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
 
@@ -802,7 +809,7 @@ yarn test --grep "Checkpoint2"
 
 \`\`\`
 
-🔄 Run \`yarn deploy --reset\` then test the staking oracle. Try registering nodes, reporting prices, and slashing inactive nodes.
+🔄 Run \`yarn deploy --reset\` then test the staking oracle. Go to the Staking page in your browser and try registering nodes, reporting prices, and slashing inactive nodes.
 
 🧪 **Live Simulation**: Run the \`yarn simulate:staking\` command to watch a live simulation of staking oracle behavior with multiple nodes:
 
@@ -816,7 +823,7 @@ yarn simulate:staking
 
 ### 🥅 Goals:
 
-- Users can register as oracle nodes by staking ETH
+- You can register as oracle nodes by staking ETH
 - Registered nodes can report prices and claim ORA token rewards
 - Anyone can slash nodes with stale data and earn rewards
 - System aggregates prices from active nodes using median calculation
@@ -891,7 +898,7 @@ sequenceDiagram
 
 💡 If someone knows the answer within the correct time then they **propose** the answer, posting a bond. This bond is a risk to them because if their answer is thought to be wrong by someone else then they might lose it. This keeps people economically tied to the **proposals** they make.
 
-⏳ Then if no one **disputes** the proposal before the dispute window is over then the proposal is considered to be true, and the proposer may claim the reward and their bond. The dispute window should give anyone ample time to submit a dispute.
+⏳ Then if no one **disputes** the proposal before the dispute window is over the proposal is considered to be true, and the proposer may claim the reward and get back their bond. The dispute window should give anyone ample time to submit a dispute.
 
 ⚖️ If someone does **dispute** during the dispute window then they must also post a bond equal to the proposer's bond. This kicks the assertion out of any particular timeline and puts it in a state where it is waiting for a decision from the **decider**. Once the decider contract has **settled** the assertion, the winner can claim the reward and their posted bond. The decider gets the loser's bond.
 
@@ -927,7 +934,7 @@ sequenceDiagram
 
 * 🏗️ It should create a new \`EventAssertion\` struct with relevant properties set - see if you can figure it out
 
-* 🗂️ That struct should be stored in the \`assertions\` mapping. You can use \`nextAssertionId\` but don't forget to increment it!
+* 🗂️ That struct should be stored in the \`assertions\` mapping. You can use \`nextAssertionId\` but don't forget to increment it afterwards!
 
 * 📣 It should emit the \`EventAsserted\` event
 
@@ -1084,7 +1091,7 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
 
@@ -1094,9 +1101,9 @@ yarn test --grep "Checkpoint4"
 
 ### 🥅 Goals:
 
-- Users can assert events with descriptions and time windows
-- Users can propose outcomes for asserted events
-- Users can dispute proposed outcomes
+- You can assert events with descriptions and time windows
+- You can propose outcomes for asserted events
+- You can dispute proposed outcomes
 - The system correctly handles timing constraints
 - Bond amounts are properly validated
 
@@ -1327,7 +1334,7 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
 
@@ -1450,7 +1457,7 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
-🔍 Run the following command to check if you implement the functions correctly.
+🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
 
@@ -1460,7 +1467,7 @@ yarn test --grep "Checkpoint6"
 
 ✅ Make sure you have implemented everything correctly by running tests with \`yarn test\`. You can dig into any errors by viewing the tests at \`packages/hardhat/test/OptimisticOracle.ts\`.
 
-🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Go to the Optimistic page and try creating assertions, proposing outcomes, and disputing them.
 
 🧪 **Live Simulation**: Run the \`yarn simulate:optimistic\` command to see the full optimistic oracle lifecycle in action:
 
@@ -1475,7 +1482,7 @@ yarn simulate:optimistic
 ### 🥅 Goals:
 
 - The system provides clear state information for all assertions
-- Users can query resolved outcomes for both disputed and undisputed assertions
+- You can query resolved outcomes for both disputed and undisputed assertions
 - All functions handle edge cases and invalid states appropriately
 - The complete optimistic oracle system works end-to-end
 ---
@@ -1487,10 +1494,10 @@ yarn simulate:optimistic
 ### 📊 Comparison Table:
 | Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
 |--------|------------------|----------------|-------------------|
-| **Speed** | Fast | Medium | Slow |
-| **Security** | Low (trusted authority) | Medium (economic incentives) | High (dispute resolution) |
+| **Speed** | Fast | Fast | Slower |
+| **Security** | Low (trusted authority) | High (economic incentives) | High (dispute resolution) |
 | **Decentralization** | Low | High | Depends on Decider Implementation |
-| **Cost** | Low | Medium | High |
+| **Cost** | Low | High (stake) | High (rewards and bonds) |
 | **Complexity** | Simple | Medium | Complex |
 
 ### 🤔 Key Trade-offs:
@@ -1531,9 +1538,9 @@ yarn simulate:optimistic
 
 Each oracle design solves different problems:
 
-- **Whitelist Oracle**: Best for simple, low-value use cases where speed is more important than decentralization. Works well for binary or predefined questions (e.g., “Is asset X above price Y?”).
-- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Handles yes/no and numerical data questions that require strong guarantees (e.g., “What is the ETH/USD price?”).
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
+- **Whitelist Oracle**: Best for setups with trusted intermediaries already in the loop such as RWAs where speed and accuracy are more important than decentralization.
+- **Staking Oracle**: Best for low-latency, high-value DeFi applications where decentralization and security are crucial.
+- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount and higher latency is not a huge downside. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
 
 ---
 

From adc82138ae43afcda5b954a7f71ac2aacabafd16 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Sat, 27 Sep 2025 14:51:22 -0400
Subject: [PATCH 27/34] address quick feedback

---
 README.md                                     | 22 ++++++++-------
 extension/README.md.args.mjs                  | 22 ++++++++-------
 .../packages/nextjs/app/page.tsx.args.mjs     |  4 +--
 .../nextjs/components/oracle/EditableCell.tsx |  6 ++---
 .../nextjs/components/oracle/PriceWidget.tsx  |  2 +-
 .../optimistic/SubmitAssertionButton.tsx      | 10 +++----
 .../oracle/whitelist/WhitelistRow.tsx         |  6 ++++-
 .../oracle/whitelist/WhitelistTable.tsx       |  2 +-
 .../nextjs/styles/globals.css.args.mjs        | 19 +++++++++++++
 extension/packages/nextjs/utils/constants.ts  | 27 -------------------
 10 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/README.md b/README.md
index 917b1267..44298f97 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 
 ---
 
-🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration and hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
 
 🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
 
@@ -204,15 +204,17 @@ function addOracle(address _owner) public onlyOwner {
 
 <details markdown='1'>
 
-<summary>💡 Hint: Safe Array Removal</summary>
+<summary>💡 Hint: Gas Efficient Array Element Removal</summary>
 
-The swap-and-pop pattern:
+Check out this swap-and-pop pattern:
 - Check if index is valid (< oracles.length)
 - Store the oracle address for the event
 - If not the last element, swap with the last element
 - Pop the last element
 - Emit the removal event
 
+This is much more gas efficient than deleting the element and moving all the entries beyond it over one space. O(1) vs O(n).
+
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
@@ -741,7 +743,7 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 5. **Implement `getPrice()` and `getPricesFromAddresses()`**
 
-* 📦 These functions work together to aggregates prices from all active nodes using median calculation
+* 📦 These functions work together to aggregate prices from all active nodes using median calculation
 
 * 🧹 It should filter out nodes with stale data using `separateStaleNodes()`
 
@@ -918,7 +920,7 @@ sequenceDiagram
 
 🎯 **Your Mission**: Complete the missing function implementations in the `OptimisticOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
-🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run `yarn test` after implementing each function to verify your solution works correctly.
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run `yarn test` after implementing each function to verify your solution works correctly. To target a specific method just use the `--grep` flag with the `yarn test` command and write out the test name like this: `yarn test --grep "Name of test"`.
 
 🔍 Open the `packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol` file to implement the optimistic oracle functionality.
 
@@ -928,7 +930,7 @@ sequenceDiagram
 
 * 📣 This function allows users to assert that an event will have a true/false outcome
 
-* 💸 It should require that the reward (`msg.value`) is greater than 0 . If it is not then revert with `NotEnoughValue`
+* 💸 It should require that the reward (`msg.value`) is greater than 0. If it is not then revert with `NotEnoughValue`
 
 * ⏱️ It should accept 0 for `startTime` and set it to `block.timestamp`
 
@@ -951,7 +953,7 @@ sequenceDiagram
 Here are more granular instructions on setting up the EventAssertion struct:
 - asserter should be `msg.sender`
 - reward should be `msg.value`
-- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
+- bond should be the reward x 2 for economic security (You will know why as you understand the economics and game theory)
 - startTime = `startTime`
 - endTime = `endTime`
 - description = `description`
@@ -1246,7 +1248,7 @@ This function enables the asserter to get a refund of their posted reward when n
 
 * 🚫 No proposer exists (revert with `AssertionProposed`)
 
-* ⏰ After assertion endTime ( revert with `InvalidTime`)
+* ⏰ After assertion endTime (revert with `InvalidTime`)
 
 * 🔒 Not already claimed (revert with `AlreadyClaimed`)
 
@@ -1314,7 +1316,7 @@ We just need the decider to use the remaining unused properties to establish whi
 
 Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
 
-Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer if the disputer was correct.
 
 <details markdown="1">
 <summary>🎯 Solution</summary>
@@ -1430,7 +1432,7 @@ This function will help everyone know the exact outcome of the assertion.
 
 * ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the `proposedOutcome` (if the time isn't over then revert with `InvalidTime`)
 
-* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the `winner` has been set by the decider (or else revert with `AwaitingDecider`)
+* 🧑‍⚖️ Otherwise, if a dispute has been made, then we just need to make sure the `winner` has been set by the decider (or else revert with `AwaitingDecider`)
 
 <details markdown="1">
 <summary>💡 Hint: Read Outcome Carefully</summary>
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index fd1dd879..5af8644b 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -32,7 +32,7 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 
 ---
 
-🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration and hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
 
 🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
 
@@ -198,15 +198,17 @@ function addOracle(address _owner) public onlyOwner {
 
 <details markdown='1'>
 
-<summary>💡 Hint: Safe Array Removal</summary>
+<summary>💡 Hint: Gas Efficient Array Element Removal</summary>
 
-The swap-and-pop pattern:
+Check out this swap-and-pop pattern:
 - Check if index is valid (< oracles.length)
 - Store the oracle address for the event
 - If not the last element, swap with the last element
 - Pop the last element
 - Emit the removal event
 
+This is much more gas efficient than deleting the element and moving all the entries beyond it over one space. O(1) vs O(n).
+
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
@@ -735,7 +737,7 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 5. **Implement \`getPrice()\` and \`getPricesFromAddresses()\`**
 
-* 📦 These functions work together to aggregates prices from all active nodes using median calculation
+* 📦 These functions work together to aggregate prices from all active nodes using median calculation
 
 * 🧹 It should filter out nodes with stale data using \`separateStaleNodes()\`
 
@@ -912,7 +914,7 @@ sequenceDiagram
 
 🎯 **Your Mission**: Complete the missing function implementations in the \`OptimisticOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
-🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run \`yarn test\` after implementing each function to verify your solution works correctly.
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run \`yarn test\` after implementing each function to verify your solution works correctly. To target a specific method just use the \`--grep\` flag with the \`yarn test\` command and write out the test name like this: \`yarn test --grep "Name of test"\`.
 
 🔍 Open the \`packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol\` file to implement the optimistic oracle functionality.
 
@@ -922,7 +924,7 @@ sequenceDiagram
 
 * 📣 This function allows users to assert that an event will have a true/false outcome
 
-* 💸 It should require that the reward (\`msg.value\`) is greater than 0 . If it is not then revert with \`NotEnoughValue\`
+* 💸 It should require that the reward (\`msg.value\`) is greater than 0. If it is not then revert with \`NotEnoughValue\`
 
 * ⏱️ It should accept 0 for \`startTime\` and set it to \`block.timestamp\`
 
@@ -945,7 +947,7 @@ sequenceDiagram
 Here are more granular instructions on setting up the EventAssertion struct:
 - asserter should be \`msg.sender\`
 - reward should be \`msg.value\`
-- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
+- bond should be the reward x 2 for economic security (You will know why as you understand the economics and game theory)
 - startTime = \`startTime\`
 - endTime = \`endTime\`
 - description = \`description\`
@@ -1240,7 +1242,7 @@ This function enables the asserter to get a refund of their posted reward when n
 
 * 🚫 No proposer exists (revert with \`AssertionProposed\`)
 
-* ⏰ After assertion endTime ( revert with \`InvalidTime\`)
+* ⏰ After assertion endTime (revert with \`InvalidTime\`)
 
 * 🔒 Not already claimed (revert with \`AlreadyClaimed\`)
 
@@ -1308,7 +1310,7 @@ We just need the decider to use the remaining unused properties to establish whi
 
 Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
 
-Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer if the disputer was correct.
 
 <details markdown="1">
 <summary>🎯 Solution</summary>
@@ -1424,7 +1426,7 @@ This function will help everyone know the exact outcome of the assertion.
 
 * ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the \`proposedOutcome\` (if the time isn't over then revert with \`InvalidTime\`)
 
-* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the \`winner\` has been set by the decider (or else revert with \`AwaitingDecider\`)
+* 🧑‍⚖️ Otherwise, if a dispute has been made, then we just need to make sure the \`winner\` has been set by the decider (or else revert with \`AwaitingDecider\`)
 
 <details markdown="1">
 <summary>💡 Hint: Read Outcome Carefully</summary>
diff --git a/extension/packages/nextjs/app/page.tsx.args.mjs b/extension/packages/nextjs/app/page.tsx.args.mjs
index f07d8121..c8c21042 100644
--- a/extension/packages/nextjs/app/page.tsx.args.mjs
+++ b/extension/packages/nextjs/app/page.tsx.args.mjs
@@ -22,8 +22,8 @@ export const description = `
             components of a robust oracle system.
           </p>
           <p className="text-center text-lg">
-            🌟 The final deliverable is a comprehensive understanding of oracle architectures through exploration 
-            and hands-on implementation. You&apos;ll explore two existing oracle systems (Whitelist and Staking) to 
+            🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on 
+            implementation. You&apos;ll explore two existing oracle systems (Whitelist and Staking) to 
             understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic 
             oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements. 
             Then build and upload your app to a public web server. Submit the url on{" "}
diff --git a/extension/packages/nextjs/components/oracle/EditableCell.tsx b/extension/packages/nextjs/components/oracle/EditableCell.tsx
index 05bb7292..9ac93870 100644
--- a/extension/packages/nextjs/components/oracle/EditableCell.tsx
+++ b/extension/packages/nextjs/components/oracle/EditableCell.tsx
@@ -81,7 +81,7 @@ export const EditableCell = ({ value, address, highlightColor = "" }: EditableCe
           ) : (
             <div className="flex items-center gap-2 h-full items-stretch">
               {value}
-              <button className="px-2 text-sm bg-primary rounded" onClick={startEditing}>
+              <button className="px-2 text-sm bg-primary rounded cursor-pointer" onClick={startEditing}>
                 <PencilIcon className="w-2.5 h-2.5" />
               </button>
             </div>
@@ -92,10 +92,10 @@ export const EditableCell = ({ value, address, highlightColor = "" }: EditableCe
         <div className="w-[30%] items-stretch justify-start pl-2">
           {isEditing && (
             <div className="flex items-stretch gap-1 w-full h-full">
-              <button onClick={handleSubmit} className="px-2 text-sm bg-primary rounded">
+              <button onClick={handleSubmit} className="px-2 text-sm bg-primary rounded cursor-pointer">
                 ✓
               </button>
-              <button onClick={handleCancel} className="px-2 text-sm bg-secondary rounded">
+              <button onClick={handleCancel} className="px-2 text-sm bg-secondary rounded cursor-pointer">
                 ✕
               </button>
             </div>
diff --git a/extension/packages/nextjs/components/oracle/PriceWidget.tsx b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
index 79c25513..b66c2d68 100644
--- a/extension/packages/nextjs/components/oracle/PriceWidget.tsx
+++ b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
@@ -51,7 +51,7 @@ export const PriceWidget = ({ contractName }: PriceWidgetProps) => {
         <TooltipInfo
           top={0}
           right={0}
-          infoText="Displays the median price. If no oracle nodes have reported prices in the last 10 seconds, it will display 'No fresh price'. Color highlighting indicates how big of a change there was in the price."
+          infoText="Displays the median price. If no oracle nodes have reported prices in the last 24 seconds, it will display 'No fresh price'. Color highlighting indicates how big of a change there was in the price."
         />
         <div className={`rounded-lg transition-colors duration-1000 ${highlight ? highlightColor : ""}`}>
           <div className="font-bold h-10 text-4xl flex items-center justify-center">
diff --git a/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
index 0741b4bf..3bdf3933 100644
--- a/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
+++ b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
@@ -140,7 +140,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
               {/* Description Input */}
               <div>
                 <label className="label">
-                  <span className="label-text font-medium">
+                  <span className="text-accent font-medium">
                     Description <span className="text-red-500">*</span>
                   </span>
                 </label>
@@ -152,7 +152,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
                         value={description}
                         onChange={e => setDescription(e.target.value)}
                         placeholder="Enter assertion description..."
-                        className="input-ghost min-h-[60px] px-4 w-full font-medium placeholder:text-accent/70 text-base-content/70 focus:text-base-content/70 resize-none bg-transparent focus:outline-none focus:border-0"
+                        className="input input-ghost focus-within:border-transparent leading-8 focus:outline-hidden focus:bg-transparent h-auto min-h-[2.2rem] px-4 border w-full font-medium placeholder:text-accent/70 text-base-content/70 focus:text-base-content/70 whitespace-pre-wrap overflow-x-hidden"
                         rows={2}
                       />
                     </div>
@@ -169,7 +169,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
               </div>
               <div>
                 <label className="label">
-                  <span className="label-text font-medium">
+                  <span className="text-accent font-medium">
                     Reward (ETH) <span className="text-red-500">*</span>
                   </span>
                 </label>
@@ -185,7 +185,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
               <div className="grid grid-cols-2 gap-4">
                 <div>
                   <label className="label">
-                    <span className="label-text font-medium">Start in (minutes)</span>
+                    <span className="text-accent font-medium">Start in (minutes)</span>
                   </label>
                   <IntegerInput
                     name="startTime"
@@ -197,7 +197,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
                 </div>
                 <div>
                   <label className="label">
-                    <span className="label-text font-medium">Duration (minutes)</span>
+                    <span className="text-accent font-medium">Duration (minutes)</span>
                   </label>
                   <IntegerInput
                     name="endTime"
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
index e467f4b1..6b7b3a11 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
@@ -53,7 +53,11 @@ export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
         address={address}
         highlightColor={getHighlightColorForPrice(data?.[0], medianPrice)}
       />
-      <HighlightedCell value={isActive ? "active" : "stale"} highlightColor={""}>
+      <HighlightedCell
+        value={isActive ? "active" : "stale"}
+        highlightColor={""}
+        className={isActive ? "text-success" : "text-error"}
+      >
         {isActive ? "Active" : "Stale"}
       </HighlightedCell>
     </tr>
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
index 632b9fa9..c7b86906 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistTable.tsx
@@ -56,7 +56,7 @@ export const WhitelistTable = () => {
     }))
     ?.filter(item => !oraclesRemoved?.some(removedOracle => removedOracle?.args?.oracleAddress === item.address));
 
-  const tooltipText = `This table displays registered oracle nodes that provide price data to the system. Nodes are considered active if they've reported within the last 10 seconds. You can add a new oracle node by clicking the "Add Oracle Node" button or edit the price of an oracle node.`;
+  const tooltipText = `This table displays registered oracle nodes that provide price data to the system. Nodes are considered active if they've reported within the last 24 seconds. You can add a new oracle node by clicking the "Add Oracle Node" button or edit the price of an oracle node.`;
 
   return (
     <div className="flex flex-col gap-2">
diff --git a/extension/packages/nextjs/styles/globals.css.args.mjs b/extension/packages/nextjs/styles/globals.css.args.mjs
index f813d5bc..b062c66f 100644
--- a/extension/packages/nextjs/styles/globals.css.args.mjs
+++ b/extension/packages/nextjs/styles/globals.css.args.mjs
@@ -57,4 +57,23 @@ export const postContent = `
 
 @theme inline {
   --font-space-grotesk: var(--font-space-grotesk);
+}
+
+@layer base {
+  input::placeholder,
+  textarea::placeholder {
+    font-style: italic;
+  }
+}
+
+@layer utilities {
+  /* Override all uses of the utility 'placeholder:text-accent/70' */
+  .placeholder\:text-accent\/70::placeholder {
+    @apply !text-accent/40;
+  }
+
+  /* Also catch responsive/state-prefixed variants like 'sm:placeholder:text-accent/70' */
+  [class*="placeholder:text-accent/70"]::placeholder {
+    @apply !text-accent/40;
+  }
 }`;
diff --git a/extension/packages/nextjs/utils/constants.ts b/extension/packages/nextjs/utils/constants.ts
index 0e145ea6..2f9845ff 100644
--- a/extension/packages/nextjs/utils/constants.ts
+++ b/extension/packages/nextjs/utils/constants.ts
@@ -122,30 +122,3 @@ export const QUESTIONS_FOR_OO: string[] = [
   "Did someone attempt to break the world record for most dad jokes told in 1 hour?",
   "Did an alpaca accidentally join a Zoom meeting for a tech startup on {MONTH} {DAY}, {YEAR}?",
 ];
-
-const generateRandomPastDate = (now: Date): Date => {
-  const monthsBack = Math.floor(Math.random() * 2) + 1; // 1–2 months
-  const daysBack = Math.floor(Math.random() * 6) + 10; // 10–15 days
-
-  const pastDate = new Date(now);
-  pastDate.setMonth(pastDate.getMonth() - monthsBack);
-  pastDate.setDate(pastDate.getDate() - daysBack);
-
-  return pastDate;
-};
-
-const replaceDatePlaceholders = (question: string): string => {
-  const now = new Date();
-  const past = generateRandomPastDate(now);
-
-  return question
-    .replace(/\{DAY\}/g, past.getDate().toString())
-    .replace(/\{MONTH\}/g, past.toLocaleDateString("en-US", { month: "long" }))
-    .replace(/\{YEAR\}/g, past.getFullYear().toString());
-};
-
-export const getRandomQuestion = (): string => {
-  const randomIndex = Math.floor(Math.random() * QUESTIONS_FOR_OO.length);
-  const question = QUESTIONS_FOR_OO[randomIndex];
-  return replaceDatePlaceholders(question);
-};

From eba41e4c810b81327456be023877cc9690d53500 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 10:58:25 -0400
Subject: [PATCH 28/34] change staking challenge tobe more interactive, have
 slashing based on price deviations

---
 README.md                                     | 833 +++++++++++++-----
 extension/README.md.args.mjs                  | 825 ++++++++++++-----
 .../contracts/01_Staking/StakingOracle.sol    | 298 +++++--
 .../02_Optimistic/OptimisticOracle.sol        |   4 +-
 .../hardhat/deploy/00_deploy_whitelist.ts     |  78 +-
 .../hardhat/deploy/01_deploy_staking.ts       |  25 -
 .../hardhat/deploy/02_deploy_optimistic.ts    |   4 +-
 .../hardhat/hardhat.config.ts.args.mjs        |  11 +
 .../hardhat/scripts/oracle-bot/config.json    |  34 +-
 .../hardhat/scripts/runOptimisticBots.ts      |  10 +-
 .../hardhat/scripts/runStakingOracleBots.ts   | 386 +++++++-
 .../hardhat/scripts/runWhitelistOracleBots.ts |  10 +-
 extension/packages/hardhat/scripts/utils.ts   |  12 -
 .../packages/hardhat/test/OptimisticOracle.ts |  31 +-
 .../packages/hardhat/test/StakingOracle.ts    | 700 ++++++++-------
 .../packages/hardhat/test/WhitelistOracle.ts  |  93 +-
 .../packages/nextjs/app/staking/page.tsx      |  14 +-
 .../nextjs/components/MonitorAndTriggerTx.tsx |  66 --
 .../components/oracle/BucketCountdown.tsx     |  86 ++
 .../nextjs/components/oracle/EditableCell.tsx |  53 +-
 .../nextjs/components/oracle/NodeRow.tsx      | 205 ++++-
 .../nextjs/components/oracle/NodesTable.tsx   | 554 ++++++++++--
 .../nextjs/components/oracle/PriceWidget.tsx  |  44 +-
 .../components/oracle/SelfNodeReporter.tsx    | 183 ++++
 .../nextjs/components/oracle/SelfNodeRow.tsx  | 228 +++++
 .../components/oracle/StakingEditableCell.tsx | 174 ++++
 .../nextjs/components/oracle/TimeAgo.tsx      |  55 ++
 .../components/oracle/TotalSlashedWidget.tsx  |  40 +
 .../optimistic/SubmitAssertionButton.tsx      |   2 +-
 .../components/oracle/optimistic/TimeLeft.tsx |  33 +-
 .../nextjs/components/oracle/types.ts         |   4 +-
 .../oracle/whitelist/WhitelistRow.tsx         |  18 +-
 .../nextjs/services/store/challengeStore.ts   |   3 +-
 33 files changed, 3871 insertions(+), 1245 deletions(-)
 delete mode 100644 extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/BucketCountdown.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/SelfNodeReporter.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/SelfNodeRow.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/StakingEditableCell.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/TimeAgo.tsx
 create mode 100644 extension/packages/nextjs/components/oracle/TotalSlashedWidget.tsx

diff --git a/README.md b/README.md
index 44298f97..1960cfb3 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 
 ---
 
-🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore three oracle systems, a Whitelist oracle, Staking-based oracle and an Optimistic oracle, implementing each one. In the end you will deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
 
 🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
 
@@ -46,13 +46,7 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 
 ## Checkpoint 0: 📦 Environment 📚
 
-🛠️ Before you begin, make sure you have the following tools installed:
-
-- [Node (>=20.18.3)](https://nodejs.org/en/download/)
-- Yarn ([v1](https://classic.yarnpkg.com/en/docs/install/) or [v2+](https://yarnpkg.com/getting-started/install))
-- [Git](https://git-scm.com/downloads)
-
-📥 Then download the challenge to your computer and install dependencies by running:
+> 💻 Start your local network (a blockchain emulator in your computer):
 
 ```sh
 
@@ -204,9 +198,9 @@ function addOracle(address _owner) public onlyOwner {
 
 <details markdown='1'>
 
-<summary>💡 Hint: Gas Efficient Array Element Removal</summary>
+<summary>💡 Hint: Safe Array Removal</summary>
 
-Check out this swap-and-pop pattern:
+The swap-and-pop pattern:
 - Check if index is valid (< oracles.length)
 - Store the oracle address for the event
 - If not the last element, swap with the last element
@@ -425,6 +419,10 @@ WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] 
 
 </details>
 
+---
+
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
@@ -433,15 +431,21 @@ yarn test --grep "Checkpoint1"
 
 ```
 
-🔄 If it passes all the tests then run `yarn deploy --reset` to deploy your contract to your local chain.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at `packages/hardhat/test/WhitelistOracle.ts`.
 
-👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Go to your browser and switch to the **Whitelist** page. Make sure you connect with the built-in burner wallet so that you can trigger transactions seamlessly. Now try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+### Try it out!
+
+🔄 Run `yarn deploy --reset` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
+
+![WhiteListOracle](SCREENSHOT)
+
+👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
 1. **Change Prices**: Use the frontend to modify individual oracle prices
 
 2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
-3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles and report different prices
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
 
 🧪 **Live Simulation**: Run the `yarn simulate:whitelist` command to see what a live version of this protocol might look like in action:
 
@@ -456,7 +460,6 @@ yarn simulate:whitelist
 ### 🥅 Goals:
 
 - You can add new SimpleOracle instances to the whitelist
-- You can remove oracles
 - System aggregates prices from active oracles using median calculation
 - Stale data is automatically filtered out based on timestamps
 - You can query which oracle nodes are currently active
@@ -464,21 +467,100 @@ yarn simulate:whitelist
 - Understand the benefits of aggregating multiple data sources
 - Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
 [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+
 ---
 
 ## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
 
-🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
+🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for reporting prices that deviate too far from the average. The system uses a bucket-based approach where prices are organized into discrete time windows (24 blocks per bucket), and nodes must report once per bucket or else there will be a small inactivity leak in their stake. We will also issue rewards in the form of an ERC20 token called ORA (1 ORA per report) to incentivise participation in the system.
 
-👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, price reporting, reward distribution, and slashing mechanisms.
+👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, bucket-based price reporting, reward distribution based on report count, and slashing mechanisms for price deviations.
 
-🎯 **Your Mission**: Complete the missing function implementations in the `StakingOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you need to fill in the logic.
+🎯 **Your Mission**: Complete the missing function implementations in the `StakingOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers but you need to fill in the logic.
 
 🔍 Open the `packages/hardhat/contracts/01_Staking/StakingOracle.sol` file to implement the staking oracle functionality.
 
 ### ✏️ Tasks:
 
-1. **Implement `registerNode(uint256 initialPrice)`**
+1. **Implement `getCurrentBucketNumber()`**
+
+* 🕒 This view function maps the current `block.number` into a bucket index (24-block window)
+
+* 🧮 It should divide the block number by `BUCKET_WINDOW` and add 1 (buckets are indexed starting from 1, not 0)
+
+<details markdown='1'>
+
+<summary>💡 Hint: Bucket Number</summary>
+
+- Buckets advance every `BUCKET_WINDOW` blocks
+- Integer division will floor the result automatically
+- Remember to add 1 so the very first bucket starts at index 1
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getCurrentBucketNumber() public view returns (uint256) {
+    return (block.number / BUCKET_WINDOW) + 1;
+}
+```
+
+</details>
+</details>
+
+---
+
+2. **Implement `getEffectiveStake(address nodeAddress)`**
+
+* 📉 This view function returns a node's stake after inactivity penalties
+
+* 🔍 It should return `0` for inactive nodes
+
+* 🧮 It should compute expected reports based on completed buckets since registration
+
+* ✂️ For each missed report, subtract `INACTIVITY_PENALTY`, floored at zero
+
+<details markdown='1'>
+
+<summary>💡 Hint: Effective Stake</summary>
+
+- Load the node into memory for cheaper reads
+- If the node is inactive, return `0`
+- Determine `currentBucket` using `getCurrentBucketNumber()`
+- Expected reports = `currentBucket - n.firstBucket`
+- Use `n.reportCount` as completed reports but subtract one if the last report happened in the current bucket (it isn't completed yet)
+- Penalty = `missed * INACTIVITY_PENALTY`; cap at the staked amount
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getEffectiveStake(address nodeAddress) public view returns (uint256) {
+    OracleNode memory n = nodes[nodeAddress];
+    if (!n.active) return 0;
+    uint256 currentBucket = getCurrentBucketNumber();
+    if (currentBucket == n.firstBucket) return n.stakedAmount;
+    uint256 expectedReports = currentBucket - n.firstBucket;
+    uint256 actualReportsCompleted = n.reportCount;
+    if (n.lastReportedBucket == currentBucket && actualReportsCompleted > 0) {
+        actualReportsCompleted -= 1;
+    }
+    if (actualReportsCompleted >= expectedReports) return n.stakedAmount;
+    uint256 missed = expectedReports - actualReportsCompleted;
+    uint256 penalty = missed * INACTIVITY_PENALTY;
+    if (penalty > n.stakedAmount) return 0;
+    return n.stakedAmount - penalty;
+}
+```
+
+</details>
+</details>
+
+---
+
+3. **Implement `registerNode(uint256 price)`**
 
 * 🏗️ This function allows users to register as oracle nodes by staking ETH
 
@@ -486,46 +568,47 @@ yarn simulate:whitelist
 
 * 🧪 It should check that the node is not already registered, otherwise revert with `NodeAlreadyRegistered`
 
-* 🏗️ It should create a new `OracleNode` struct with the provided data
+* 🏗️ It should create a new `OracleNode` struct with the correct data
 
 * ➕ It should add the node address to the `nodeAddresses` array
 
-* 📣 It should emit both `NodeRegistered` and `PriceReported` events
+* 💲 It should call `reportPrice(price)` (you'll implement this later) to record the first report in the current bucket
+
+* 📣 It should emit the `NodeRegistered` event
 
 <details markdown='1'>
 
 <summary>💡 Hint: Node Registration</summary>
 
-Here's what you need to set in the OracleNode struct:
-- nodeAddress should be `msg.sender`
-- stakedAmount should be `msg.value`
-- lastReportedPrice should be `initialPrice`
-- lastReportedTimestamp should be `block.timestamp`
-- lastClaimedTimestamp should be `block.timestamp`
-- lastSlashedTimestamp should be `0`
+Here's what you need to set in the `OracleNode` struct:
+- `stakedAmount` should be `msg.value`
+- `lastReportedBucket` should be `0` (will be updated in `reportPrice`)
+- `reportCount` should be `0`
+- `claimedReportCount` should be `0`
+- `firstBucket` should be `getCurrentBucketNumber()` (the bucket when the node registered)
+- `active` should be `true`
+
+After creating the struct, push the node into `nodeAddresses`, call `reportPrice(price)`, and emit the event.
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 ```solidity
-function registerNode(uint256 initialPrice) public payable {
+function registerNode(uint256 price) public payable {
     if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
-    if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
-
+    if (nodes[msg.sender].active) revert NodeAlreadyRegistered();
     nodes[msg.sender] = OracleNode({
-        nodeAddress: msg.sender,
         stakedAmount: msg.value,
-        lastReportedPrice: initialPrice,
-        lastReportedTimestamp: block.timestamp,
-        lastClaimedTimestamp: block.timestamp,
-        lastSlashedTimestamp: 0
+        lastReportedBucket: 0,
+        reportCount: 0,
+        claimedReportCount: 0,
+        firstBucket: getCurrentBucketNumber(),
+        active: true
     });
-
     nodeAddresses.push(msg.sender);
-
+    reportPrice(price);
     emit NodeRegistered(msg.sender, msg.value);
-    emit PriceReported(msg.sender, initialPrice);
 }
 ```
 
@@ -534,24 +617,69 @@ function registerNode(uint256 initialPrice) public payable {
 
 ---
 
-2. **Implement `reportPrice(uint256 price)`**
+4. **Implement `addStake()`**
+
+* 💸 This payable function lets an active node increase its stake
+
+* ⚠️ It should revert with `InsufficientStake` if `msg.value == 0`
+
+* ➕ It should add the sent value to the node's `stakedAmount`
+
+* 📣 It should emit the `StakeAdded` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Adding Stake</summary>
+
+- Use the `onlyNode` modifier to ensure sender is active
+- Update `nodes[msg.sender].stakedAmount`
+- Emit `StakeAdded`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function addStake() public payable onlyNode {
+    if (msg.value == 0) revert InsufficientStake();
+    nodes[msg.sender].stakedAmount += msg.value;
+    emit StakeAdded(msg.sender, msg.value);
+}
+```
+
+</details>
+</details>
+
+---
+
+5. **Implement `reportPrice(uint256 price)`**
 
 * 🧪 This function allows registered nodes to report new prices (uses `onlyNode` modifier)
 
-* 🔍 It should verify the node has sufficient stake, otherwise revert with `NotEnoughStake`
+* 🔍 It should verify the given price is not zero, otherwise revert with `InvalidPrice`
+
+* 🔍 It should verify the node has sufficient stake (using `getEffectiveStake`), otherwise revert with `InsufficientStake`
+
+* 🚫 It should prevent reporting twice in the same bucket, otherwise revert with `AlreadyReportedInCurrentBucket`
+
+* 📊 It should store the node's price in the current bucket's `TimeBucket` mapping
 
-* 🔄 It should update the node's last reported price and timestamp
+* 📈 It should increment the bucket's `countReports` and add the price to `sumPrices`. This will be useful for deriving the average later
 
-* 📣 It should emit the `PriceReported` event
+* 🔄 It should update the node's `lastReportedBucket` and `reportCount`
+
+* 📣 It should emit the `PriceReported` event with the sender, price, and bucket number
 
 <details markdown='1'>
 
 <summary>💡 Hint: Price Reporting</summary>
 
-- Get a storage reference to the node using `nodes[msg.sender]`
-- Check if `stakedAmount` is at least `MINIMUM_STAKE`
-- Update `lastReportedPrice` and `lastReportedTimestamp`
-- Emit event with sender and new price
+- Pull `OracleNode storage node = nodes[msg.sender]`
+- Validate price and stake before touching bucket state
+- Use `timeBuckets[getCurrentBucketNumber()]`
+- Update bucket mappings and aggregates
+- Update the node's `lastReportedBucket` to `getCurrentBucketNumber()`
+- Increment the node's `reportCount`
 
 <details markdown='1'>
 
@@ -559,12 +687,18 @@ function registerNode(uint256 initialPrice) public payable {
 
 ```solidity
 function reportPrice(uint256 price) public onlyNode {
+    if (price == 0) revert InvalidPrice();
     OracleNode storage node = nodes[msg.sender];
-    if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
-    node.lastReportedPrice = price;
-    node.lastReportedTimestamp = block.timestamp;
-
-    emit PriceReported(msg.sender, price);
+    if (getEffectiveStake(msg.sender) < MINIMUM_STAKE) revert InsufficientStake();
+    if (node.lastReportedBucket == getCurrentBucketNumber()) revert AlreadyReportedInCurrentBucket();
+    TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber()];
+    bucket.prices[msg.sender] = price;
+    bucket.countReports++;
+    bucket.sumPrices += price;
+
+    node.lastReportedBucket = getCurrentBucketNumber();
+    node.reportCount++;
+    emit PriceReported(msg.sender, price, getCurrentBucketNumber());
 }
 ```
 
@@ -573,64 +707,122 @@ function reportPrice(uint256 price) public onlyNode {
 
 ---
 
-3. **Implement `claimReward()` and `rewardNode()`**
-
-* 🧪 These functions allow registered nodes to claim their ORA token rewards (uses `onlyNode` modifier)
+6. **Implement `claimReward()`**
 
-* 🔍 It should calculate reward amount based on time elapsed since last claim
+* 🧪 This function allows past and present nodes to claim their ORA token rewards
 
-* 💰 For active nodes (sufficient stake): rewards based on time since last claim
+* 🔍 It should calculate reward amount based on the difference between `reportCount` and `claimedReportCount`. We will call this number the `delta`
 
-* ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+* 🔒 It should revert with `NoRewardsAvailable` if `delta == 0`
 
-* 🎁 It should mint ORA tokens as rewards (time-based, scaled by 10^18) using the internal `rewardNode()` helper
+* 🔢 It should update `claimedReportCount` to `reportCount` *before* minting the tokens (reentrancy safe)
 
-* 🔒 It should revert with `NoRewardsAvailable` if no rewards are available
+* 💰 It should mint `delta * REWARD_PER_REPORT` ORA tokens
 
-* 📣 It should update `lastClaimedTimestamp` and emit `NodeRewarded` event
+* 📣 It should emit the `NodeRewarded` event
 
 <details markdown='1'>
 
 <summary>💡 Hint: Reward Implementation</summary>
 
-You need to implement both functions:
+- Load the node in storage
+- Compute `delta`
+- Revert if `delta == 0`
+- Update `claimedReportCount`
+- Mint the reward and emit the event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function claimReward() public {
+    OracleNode storage node = nodes[msg.sender];
+
+    uint256 delta = node.reportCount - node.claimedReportCount;
+    if (delta == 0) revert NoRewardsAvailable();
+
+    node.claimedReportCount = node.reportCount;
+    oracleToken.mint(msg.sender, delta * REWARD_PER_REPORT);
+    emit NodeRewarded(msg.sender, delta * REWARD_PER_REPORT);
+}
+```
+
+</details>
+</details>
+
+---
+
+7. **Implement `_removeNode(address nodeAddress, uint256 index)`**
+
+* 🗂️ This internal function removes a node from the `nodeAddresses` array while keeping the array packed. By forcing the caller to provide the index and simply verifying it is at that position we are removing the need to iterate over a potentially large array
+
+* 🔍 It should ensure the provided `index` is within bounds, otherwise revert with `IndexOutOfBounds`
+
+* ✅ It should ensure the address at the given index matches `nodeAddress`, otherwise revert with `NodeNotAtGivenIndex`
+
+* 🔁 It should use the pop-and-swap pattern to remove the entry efficiently
+
+* 🚫 It should mark the node as inactive without deleting the entire struct (other functions may rely on historical data)
+
+<details markdown='1'>
 
-**claimReward()** logic:
-- If node has insufficient stake AND was previously slashed: reward = time between lastClaimedTimestamp and lastSlashedTimestamp
-- If node has sufficient stake: reward = time between lastClaimedTimestamp and now
-- Scale reward by 10^18 for token decimals
-- Update lastClaimedTimestamp to current time
-- Call rewardNode() to mint tokens
+<summary>💡 Hint: Removing Nodes</summary>
 
-**rewardNode()** logic:
-- Simple internal function that mints ORA tokens and emits event
+- Check `index < nodeAddresses.length`
+- Check `nodeAddresses[index] == nodeAddress`
+- Assign the last address into the `index` slot, then pop
+- Set `nodes[nodeAddress].active = false`
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 ```solidity
-function claimReward() public onlyNode {
-    OracleNode memory node = nodes[msg.sender];
-    uint256 rewardAmount = 0;
+function _removeNode(address nodeAddress, uint256 index) internal {
+    if (nodeAddresses.length <= index) revert IndexOutOfBounds();
+    if (nodeAddresses[index] != nodeAddress) revert NodeNotAtGivenIndex();
+    nodeAddresses[index] = nodeAddresses[nodeAddresses.length - 1];
+    nodeAddresses.pop();
+    nodes[nodeAddress].active = false;
+}
+```
 
-    if (node.stakedAmount < MINIMUM_STAKE) {
-        if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
-            rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
-        }
-    } else {
-        rewardAmount = block.timestamp - node.lastClaimedTimestamp;
-    }
+</details>
+</details>
+
+---
 
-    if (rewardAmount == 0) revert NoRewardsAvailable();
+8. **Implement `_checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice)`**
 
-    nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-    rewardNode(msg.sender, rewardAmount * 10 ** 18);
-}
+* 🧮 This internal pure function determines whether a reported price deviates beyond the allowed threshold
+
+* 🔢 It should compute the absolute difference between the reported price and the average
+
+* 📐 It should convert the deviation to basis points and compare it against `MAX_DEVIATION_BPS`
+
+* 🔁 It should return `true` when the deviation is greater than the threshold, otherwise `false`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Deviation Check</summary>
+
+- Use a simple conditional to compute the absolute deviation
+- Multiply the deviation by 10,000 (basis points) before dividing by `averagePrice`. This will allow for greater precision
+- Compare the result against `MAX_DEVIATION_BPS`
+
+<details markdown='1'>
 
-function rewardNode(address nodeAddress, uint256 reward) internal {
-    oracleToken.mint(nodeAddress, reward);
-    emit NodeRewarded(nodeAddress, reward);
+<summary>🎯 Solution</summary>
+
+```solidity
+function _checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice) internal pure returns (bool) {
+    uint256 deviation = reportedPrice > averagePrice ? reportedPrice - averagePrice : averagePrice - reportedPrice;
+    uint256 deviationBps = (deviation * 10_000) / averagePrice;
+    if (deviationBps > MAX_DEVIATION_BPS) {
+        return true;
+    }
+    return false;
 }
 ```
 
@@ -639,100 +831,156 @@ function rewardNode(address nodeAddress, uint256 reward) internal {
 
 ---
 
-4. **Implement `slashNodes()`, `separateStaleNodes()`, and `slashNode()`**
+9. **Implement `slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index)`**
 
-* 🔎 These functions work together to allow anyone to slash nodes with stale data and get rewarded
+* 🔎 This function allows anyone to slash nodes that reported prices deviating too far from the average
 
-* 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
+* 🧪 It should verify the node is active, otherwise revert with `NodeNotRegistered`
 
-* ✂️ It should slash each stale node by 1 ETH and calculate slasher rewards
+* ⏰ It should verify the bucket is in the past (not current), otherwise revert with `OnlyPastBucketsAllowed`
 
-* 🏅 It should accumulate slasher rewards and send them to the caller
+* 🚫 It should verify the node hasn't already been slashed in this bucket, otherwise revert with `NodeAlreadySlashed`
 
-* ⚠️ It should revert with `FailedToSendReward` if the transfer fails
+* 📊 It should verify the node reported a price in this bucket, otherwise revert with `NodeDidNotReport`
 
-<details markdown='1'>
+* ✂️ It should mark the node as slashed and remove their price from the bucket's sum and count
 
-<summary>💡 Hint: Complete Slashing Implementation</summary>
+* 🧮 It should recalculate the average price after removing the node's price
+
+* 🔍 It should verify the node's price deviates beyond the threshold using `_checkPriceDeviated`, otherwise revert with `NotDeviated`
+
+* 💰 It should slash the node by `MISREPORT_PENALTY` (or their full stake if less)
+
+* 🏅 It should send 10% of the penalty to the slasher (`msg.sender`)
 
-You need to implement all three functions:
+* 🗑️ It should remove the node if their stake reaches zero after slashing using `_removeNode`
 
-**slashNodes()** - public entry point:
-- Use separateStaleNodes to get stale addresses
-- Loop through and slash each one
-- Send accumulated rewards to caller
+* ⚠️ It should revert with `FailedToSend` if the reward transfer fails
 
-**separateStaleNodes()** - categorization logic:
-- Check timestamps against STALE_DATA_WINDOW
-- Return fresh and stale address arrays
+* 📣 It should emit `NodeSlashed` and `NodeExited` (if the node is removed)
 
-**slashNode()** - internal slashing logic:
-- Reduce stake, update timestamp, calculate reward
-- Return slasher reward (10% of penalty)
+<details markdown='1'>
+
+<summary>💡 Hint: Complete Slashing Implementation</summary>
+
+Follow these steps:
+- Validate node state and bucket recency
+- Ensure the node actually reported in that bucket and hasn't been slashed yet
+- Remove their contribution from `sumPrices`/`countReports`
+- Recompute the average (excluding the offender) and check deviation with `_checkPriceDeviated`
+- Apply the penalty by reducing the node's `stakedAmount`
+- If the node is fully slashed (`stakedAmount` == 0), remove them with `_removeNode`
+- Calculate the reward, and transfer it
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 ```solidity
-function slashNodes() public {
-    (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
-    uint256 slasherReward;
-    for (uint i = 0; i < addressesToSlash.length; i++) {
-        slasherReward += slashNode(addressesToSlash[i], 1 ether);
+function slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index) public {
+    if (!nodes[nodeToSlash].active) revert NodeNotRegistered();
+    if (getCurrentBucketNumber() == bucketNumber) revert OnlyPastBucketsAllowed();
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    if (bucket.slashedOffenses[nodeToSlash]) revert NodeAlreadySlashed();
+    uint256 reportedPrice = bucket.prices[nodeToSlash];
+    if (reportedPrice == 0) revert NodeDidNotReport();
+    bucket.slashedOffenses[nodeToSlash] = true;
+    bucket.sumPrices -= reportedPrice;
+    bucket.countReports--;
+    uint256 averagePrice = bucket.sumPrices / bucket.countReports;
+    if (!_checkPriceDeviated(reportedPrice, averagePrice)) {
+        revert NotDeviated();
     }
+    OracleNode storage node = nodes[nodeToSlash];
+    uint256 actualPenalty = MISREPORT_PENALTY > node.stakedAmount ? node.stakedAmount : MISREPORT_PENALTY;
+    node.stakedAmount -= actualPenalty;
 
-    (bool sent, ) = msg.sender.call{ value: slasherReward }("");
-    if (!sent) revert FailedToSendReward();
-}
+    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
 
-function separateStaleNodes(
-    address[] memory nodesToSeparate
-) public view returns (address[] memory fresh, address[] memory stale) {
-    address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
-    address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
-    uint256 freshCount = 0;
-    uint256 staleCount = 0;
-
-    for (uint i = 0; i < nodesToSeparate.length; i++) {
-        address nodeAddress = nodesToSeparate[i];
-        OracleNode memory node = nodes[nodeAddress];
-        uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
-        bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
-
-        if (dataIsStale) {
-            staleNodeAddresses[staleCount] = nodeAddress;
-            staleCount++;
-        } else {
-            freshNodeAddresses[freshCount] = nodeAddress;
-            freshCount++;
-        }
+    (bool sent, ) = msg.sender.call{ value: reward }("");
+    if (!sent) revert FailedToSend();
+
+    if (node.stakedAmount == 0) {
+        _removeNode(nodeToSlash, index);
+        emit NodeExited(nodeToSlash, 0);
     }
 
-    address[] memory trimmedFreshNodes = new address[](freshCount);
-    address[] memory trimmedStaleNodes = new address[](staleCount);
+    emit NodeSlashed(nodeToSlash, actualPenalty);
+}
+```
+
+</details>
+</details>
 
-    for (uint i = 0; i < freshCount; i++) {
-        trimmedFreshNodes[i] = freshNodeAddresses[i];
-    }
-    for (uint i = 0; i < staleCount; i++) {
-        trimmedStaleNodes[i] = staleNodeAddresses[i];
-    }
+---
+
+10. **Implement `exitNode(uint256 index)`**
+
+* 🚪 This function allows a node to exit and withdraw its stake after a waiting period
+
+* ⏳ It should ensure the node waited at least `WAITING_PERIOD` buckets since their last report, otherwise revert with `WaitingPeriodNotOver`. This way there is ample time to slash them before they exit
+
+* 💰 It should compute the withdrawable stake using `getEffectiveStake` before removing the node
+
+* 🗑️ It should call `_removeNode(msg.sender, index)` to mark the node inactive and keep the node array tidy
+
+* 🧹 It should send the stake back to the sender
+
+* ⚠️ It should revert with `FailedToSend` if the withdrawal transfer fails
+
+* 📣 It should emit the `NodeExited` event with the withdrawn amount
 
-    return (trimmedFreshNodes, trimmedStaleNodes);
+<details markdown='1'>
+
+<summary>💡 Hint: Exit Logic</summary>
+
+- Fetch the node in storage
+- Require `node.lastReportedBucket + WAITING_PERIOD <= getCurrentBucketNumber()`
+- Compute `stake = getEffectiveStake(msg.sender)` **before** removing
+- Call `_removeNode`
+- Transfer the stake using `call`
+- Emit the event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function exitNode(uint256 index) public onlyNode {
+    OracleNode storage node = nodes[msg.sender];
+    if (node.lastReportedBucket + WAITING_PERIOD > getCurrentBucketNumber()) revert WaitingPeriodNotOver();
+    uint256 stake = getEffectiveStake(msg.sender);
+    _removeNode(msg.sender, index);
+    (bool sent, ) = msg.sender.call{ value: stake }("");
+    if (!sent) revert FailedToSend();
+
+    emit NodeExited(msg.sender, stake);
 }
+```
 
-function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
-    OracleNode storage node = nodes[nodeToSlash];
-    uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
-    node.stakedAmount -= actualPenalty;
-    node.lastSlashedTimestamp = block.timestamp;
+</details>
+</details>
 
-    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
+---
 
-    emit NodeSlashed(nodeToSlash, actualPenalty);
+11. **Implement `getNodeAddresses()`**
+
+* 📚 This view function should return every registered node address in order. This is convenient for the front-end 
+
+<details markdown='1'>
+
+<summary>💡 Hint: Node List</summary>
+
+- The array `nodeAddresses` tracks the registration order
+- Just return the array
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
 
-    return reward;
+```solidity
+function getNodeAddresses() public view returns (address[] memory) {
+    return nodeAddresses;
 }
 ```
 
@@ -741,60 +989,149 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 ---
 
-5. **Implement `getPrice()` and `getPricesFromAddresses()`**
+12. **Implement `getLatestPrice()`**
 
-* 📦 These functions work together to aggregate prices from all active nodes using median calculation
+* 📦 This function returns the aggregated price from the most recent completed bucket
 
-* 🧹 It should filter out nodes with stale data using `separateStaleNodes()`
+* 🔍 It should get the previous bucket (current bucket - 1) since the current bucket is still being filled
 
-* 🔍 It should extract prices reported by the nodes at valid addresses using the internal `getPricesFromAddresses()` helper
+* 📊 It should retrieve the `TimeBucket` for that bucket
 
-* ⛔️ It should revert with `NoValidPricesAvailable` if no valid prices exist
+* ⛔️ It should revert with `NoValidPricesAvailable` if `bucket.countReports == 0`
 
-* 🧮 It should sort and calculate the median using StatisticsUtils
+* 🧮 It should return the average price: `bucket.sumPrices / bucket.countReports`
 
 <details markdown='1'>
 
-<summary>💡 Hint: Price Aggregation Implementation</summary>
+<summary>💡 Hint: Latest Price</summary>
+
+- Use `getCurrentBucketNumber() - 1`
+- Access the bucket mapping
+- Guard against empty buckets
+- Return the average
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getLatestPrice() public view returns (uint256) {
+    TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber() - 1];
+    if (bucket.countReports == 0) revert NoValidPricesAvailable();
+    return bucket.sumPrices / bucket.countReports;
+}
+```
+
+</details>
+</details>
+
+---
+
+13. **Implement `getPastPrice(uint256 bucketNumber)`**
+
+* 🕰️ Because we are storing pricing in time-segmented buckets we can enable retrieving a price from any one of these buckets. This view function returns the average price for any historical bucket
 
-You need to implement both functions:
+* ⛔️ It should revert with `NoValidPricesAvailable` if that bucket has no reports
 
-**getPrice()** logic:
-- Get valid (fresh) addresses from separateStaleNodes
-- Get prices from those addresses using getPricesFromAddresses
-- Check if any valid prices exist
-- Sort prices and return median
+<details markdown='1'>
+
+<summary>💡 Hint: Past Price</summary>
 
-**getPricesFromAddresses()** logic:
-- Create an array the same size as the input addresses
-- Loop through addresses and get each node's lastReportedPrice
-- Return the prices array
+- Grab `TimeBucket storage bucket = timeBuckets[bucketNumber]`
+- Check `bucket.countReports`
+- Return `bucket.sumPrices / bucket.countReports`
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 ```solidity
-function getPrice() public view returns (uint256) {
-    (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
-    uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
-    if (validPrices.length == 0) revert NoValidPricesAvailable();
+function getPastPrice(uint256 bucketNumber) public view returns (uint256) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    if (bucket.countReports == 0) revert NoValidPricesAvailable();
+    return bucket.sumPrices / bucket.countReports;
+}
+```
 
-    validPrices.sort();
-    return validPrices.getMedian();
+</details>
+</details>
+
+---
+
+14. **Implement `getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber)`**
+
+* 🔎 This view function returns the price a node reported in a bucket and whether they were slashed there
+
+<details markdown='1'>
+
+<summary>💡 Hint: Bucket Data</summary>
+
+- Access the bucket mapping and return both `prices[nodeAddress]` and `slashedOffenses[nodeAddress]`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber) public view returns (uint256, bool) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    return (bucket.prices[nodeAddress], bucket.slashedOffenses[nodeAddress]);
 }
+```
 
-function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
-    uint256[] memory prices = new uint256[](addresses.length);
+</details>
+</details>
 
-    for (uint256 i = 0; i < addresses.length; i++) {
-        OracleNode memory node = nodes[addresses[i]];
-        prices[i] = node.lastReportedPrice;
-    }
+---
+
+15. **Implement `getOutlierNodes(uint256 bucketNumber)`**
+
+* 📊 This view function identifies nodes whose price deviates beyond the maximum deviation in a given bucket
+
+* 🗃️ It should iterate over all `nodeAddresses` (this is fine since it is a view method)
+
+* 🧮 For each reported price, calculate the average of the remaining reports and test deviation with `_checkPriceDeviated`
+
+* 🧹 Collect only the outliers and trim the array before returning
+
+<details markdown='1'>
+
+<summary>💡 Hint: Outlier Detection</summary>
 
-    return prices;
+- Allocate a temporary array of size `bucket.countReports`
+- Loop through `nodeAddresses`
+- Skip addresses that did not report (`reportedPrice == 0`)
+- Compute `averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1)`
+- If `_checkPriceDeviated(...)` returns true, store the address in the temp array and increment a counter
+- Allocate a trimmed array of length `outlierCount` and copy the collected addresses
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+```solidity
+function getOutlierNodes(uint256 bucketNumber) public view returns (address[] memory) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    address[] memory outliers = new address[](bucket.countReports);
+    uint256 outlierCount = 0;
+    for (uint256 i = 0; i < nodeAddresses.length; i++) {
+        address nodeAddress = nodeAddresses[i];
+        uint256 reportedPrice = bucket.prices[nodeAddress];
+        if (reportedPrice == 0) continue;
+        uint256 averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1);
+        if (_checkPriceDeviated(reportedPrice, averagePrice)) {
+            outliers[outlierCount] = nodeAddress;
+            outlierCount++;
+        }
+    }
+    address[] memory trimmed = new address[](outlierCount);
+    for (uint256 i = 0; i < outlierCount; i++) {
+        trimmed[i] = outliers[i];
+    }
+    return trimmed;
 }
 ```
+
 </details>
 </details>
 
@@ -802,12 +1139,21 @@ function getPricesFromAddresses(address[] memory addresses) internal view return
 
 ### 🤔 Key Insights:
 
-- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
+- **Bucket-Based System**: Prices are organized into time buckets (24 blocks each), allowing for discrete time windows and preventing double-reporting within the same bucket
+- **Economic Incentives**: Nodes stake ETH and can be slashed for reporting prices that deviate too far from the average, while good behavior rewards nodes with ORA tokens (1 ORA per report)
+- **Effective Stake**: Nodes face inactivity penalties for missed buckets, reducing their effective stake over time if they fail to report regularly
 - **Decentralized**: Anyone can participate by staking, no central authority needed
-- **Self-Correcting**: Slashing mechanism punishes inactive nodes
-- **Freshness Enforcement**: Stale data is automatically filtered out
-- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
-- **Improvements**: This could be enhanced by adding slashing for outlier prices that indicate manipulation
+- **Self-Correcting**: Slashing mechanism punishes nodes that report prices deviating beyond the threshold (10% by default)
+- **Average Aggregation**: Prices are aggregated using a simple average from all reports in a completed bucket, providing a fair representation of the collective price
+- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial and price updates occur at regular intervals
+
+### 🤔 Critical Thinking: Security Vulnerabilities
+
+- **Robustness vs. Whitelist Oracle**: Unlike the whitelist oracle which relies on a single trusted authority, the staking oracle's design distributes trust among all staking nodes. Manipulating the output requires a majority of nodes to collude, which is economically disincentivized due to the risk of slashing. As a result, unless an attacker controls a majority of the total effective stake, they cannot egregiously manipulate the reported price—making the system considerably more robust than one with simple whitelist control.
+
+---
+
+### Testing your progress
 
 🔍 Run the following command to check if you implemented the functions correctly.
 
@@ -817,7 +1163,27 @@ yarn test --grep "Checkpoint2"
 
 ```
 
-🔄 Run `yarn deploy --reset` then test the staking oracle. Go to the Staking page in your browser and try registering nodes, reporting prices, and slashing inactive nodes.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at `packages/hardhat/test/StakingOracle.ts`.
+
+### Try it out!
+
+🌎 In the real world this oracle would have too much latency to be very useful due to the need for 24 block windows. However, this was done to make it possible for you to see how the oracle operates in real time without everything happening too fast to comprehend. There is no reason why this couldn't work with single block windows although in decentralized systems you must always consider that the lower the latency requirements, the fewer nodes can participate
+
+🔄 Run `yarn deploy --reset` then test the staking oracle. Go to the `Staking` page and try registering your own node and reporting prices.
+
+🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
+
+![Staking Buttons Panel](SCREENSHOT)
+
+> 🗺️ You can navigate to past buckets using the arrows. 
+
+✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
+
+![SelfNodeRow](SCREENSHOT)
+
+> ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
+
+😮‍💨 *Whew!* That was a lot of work pressing all those buttons to keep from getting the inactive penalty! Much easier when bots are doing all the work and you can just watch. Exit your node (if it stresses you) and lets have some fun.
 
 🧪 **Live Simulation**: Run the `yarn simulate:staking` command to watch a live simulation of staking oracle behavior with multiple nodes:
 
@@ -827,16 +1193,25 @@ yarn simulate:staking
 
 ```
 
-🤖 This will start automated bots that simulate honest and malicious node behavior, frequent and stale reports, and demonstrate how slashing and median aggregation impact the reported price. You can update the price variance and skip probability from the front-end as well.
+🤖 This will start automated bots and demonstrate how slashing and average aggregation impact the reported price. Right now they are all on default settings so the price won't deviate, but...
+
+⚙️ You can update the price deviation and skip probability by pressing the gear icon. Go ahead and make some bots start to produce wild deviations then view the past buckets (by using the arrows) to see the "slash" button activated. Press it to slash any deviated nodes.
+
+🥱 If you get tired of slashing deviated nodes but still want to see them get slashed you can re-run the command with this environment variable:
+
+```sh
+AUTO_SLASH=true yarn simulate:staking
+```
 
 ### 🥅 Goals:
 
-- You can register as oracle nodes by staking ETH
-- Registered nodes can report prices and claim ORA token rewards
-- Anyone can slash nodes with stale data and earn rewards
-- System aggregates prices from active nodes using median calculation
-- Economic incentives drive honest behavior and data freshness
-- Understand the trade-offs between decentralization and complexity
+- You can register as an oracle node by staking ETH
+- Registered nodes can report prices once per bucket and claim ORA token rewards based on report count
+- Anyone can slash nodes that report prices deviating too far from the average and earn rewards
+- System aggregates prices from completed buckets using average calculation
+- Inactivity penalties reduce effective stake for nodes that miss reporting in buckets
+- Economic incentives drive honest behavior and regular participation
+- Understand the trade-offs between decentralization and latency
 - See examples in the wild: [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
 
 ---
@@ -920,7 +1295,7 @@ sequenceDiagram
 
 🎯 **Your Mission**: Complete the missing function implementations in the `OptimisticOracle.sol` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
-🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run `yarn test` after implementing each function to verify your solution works correctly. To target a specific method just use the `--grep` flag with the `yarn test` command and write out the test name like this: `yarn test --grep "Name of test"`.
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run `yarn test` after implementing each function to verify your solution works correctly.
 
 🔍 Open the `packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol` file to implement the optimistic oracle functionality.
 
@@ -930,7 +1305,7 @@ sequenceDiagram
 
 * 📣 This function allows users to assert that an event will have a true/false outcome
 
-* 💸 It should require that the reward (`msg.value`) is greater than 0. If it is not then revert with `NotEnoughValue`
+* 💸 It should require that the reward (`msg.value`) is greater than 0 . If it is not then revert with `InvalidValue`
 
 * ⏱️ It should accept 0 for `startTime` and set it to `block.timestamp`
 
@@ -953,7 +1328,7 @@ sequenceDiagram
 Here are more granular instructions on setting up the EventAssertion struct:
 - asserter should be `msg.sender`
 - reward should be `msg.value`
-- bond should be the reward x 2 for economic security (You will know why as you understand the economics and game theory)
+- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
 - startTime = `startTime`
 - endTime = `endTime`
 - description = `description`
@@ -967,7 +1342,7 @@ Here are more granular instructions on setting up the EventAssertion struct:
     function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
         uint256 assertionId = nextAssertionId;
         nextAssertionId++;
-        if (msg.value == 0) revert NotEnoughValue();
+        if (msg.value == 0) revert InvalidValue();
 
         // Set default times if not provided
         if (startTime == 0) {
@@ -1013,7 +1388,7 @@ Here are more granular instructions on setting up the EventAssertion struct:
 
 * ⏱️ It should validate the timing constraints - it has to be after `startTime` but before the `endTime` or else revert with `InvalidTime`
 
-* 💸 It should enforce the correct bond amount is provided or revert with `NotEnoughValue`
+* 💸 It should enforce the correct bond amount is provided or revert with `InvalidValue`
 
 * ✍️ It should update the assertion with the proposal
 
@@ -1042,7 +1417,7 @@ You want to set these properties on the assertion:
         if (assertion.proposer != address(0)) revert AssertionProposed();
         if (block.timestamp < assertion.startTime) revert InvalidTime();
         if (block.timestamp > assertion.endTime) revert InvalidTime();
-        if (msg.value != assertion.bond) revert NotEnoughValue();
+        if (msg.value != assertion.bond) revert InvalidValue();
 
         assertion.proposer = msg.sender;
         assertion.proposedOutcome = outcome;
@@ -1086,7 +1461,7 @@ The bond amount should be the bond set on the assertion. The same amount that th
         if (assertion.proposer == address(0)) revert NotProposedAssertion();
         if (assertion.disputer != address(0)) revert ProposalDisputed();
         if (block.timestamp > assertion.endTime) revert InvalidTime();
-        if (msg.value != assertion.bond) revert NotEnoughValue();
+        if (msg.value != assertion.bond) revert InvalidValue();
 
         assertion.disputer = msg.sender;
 
@@ -1099,6 +1474,8 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
@@ -1248,7 +1625,7 @@ This function enables the asserter to get a refund of their posted reward when n
 
 * 🚫 No proposer exists (revert with `AssertionProposed`)
 
-* ⏰ After assertion endTime (revert with `InvalidTime`)
+* ⏰ After assertion endTime ( revert with `InvalidTime`)
 
 * 🔒 Not already claimed (revert with `AlreadyClaimed`)
 
@@ -1316,7 +1693,7 @@ We just need the decider to use the remaining unused properties to establish whi
 
 Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
 
-Then set the winner to the proposer if the proposer was correct *or* set it to the disputer if the disputer was correct.
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
 
 <details markdown="1">
 <summary>🎯 Solution</summary>
@@ -1342,6 +1719,10 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
+---
+
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
@@ -1432,7 +1813,7 @@ This function will help everyone know the exact outcome of the assertion.
 
 * ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the `proposedOutcome` (if the time isn't over then revert with `InvalidTime`)
 
-* 🧑‍⚖️ Otherwise, if a dispute has been made, then we just need to make sure the `winner` has been set by the decider (or else revert with `AwaitingDecider`)
+* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the `winner` has been set by the decider (or else revert with `AwaitingDecider`)
 
 <details markdown="1">
 <summary>💡 Hint: Read Outcome Carefully</summary>
@@ -1465,6 +1846,8 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 ```sh
@@ -1473,9 +1856,35 @@ yarn test --grep "Checkpoint6"
 
 ```
 
-✅ Make sure you have implemented everything correctly by running tests with `yarn test`. You can dig into any errors by viewing the tests at `packages/hardhat/test/OptimisticOracle.ts`.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at `packages/hardhat/test/OptimisticOracle.ts`.
+
+### Try it out!
+
+🔄 Run `yarn deploy --reset` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+
+🖥️ Go to the Optimistic page to interact with your new protocol
+
+![OptimisticOracle](SCREENSHOT)
+
+1. **Submit a New Assertion**:  
+   Go to the "Optimistic" page and fill in the required fields to create a new assertion.  
+   - Enter the assertion details and submit.
+
+2. **Propose an Outcome**:  
+   Once an assertion is created, use the UI to propose an outcome for your assertion.  
+
+3. **Dispute an Outcome**:  
+   If someone disagrees with the proposed outcome, they can dispute it using the dispute button shown in the table for pending assertions.
+
+4. **Wait for Dispute Window & Settlement**:  
+   - Wait for the dispute window (the protocol’s timer) to expire.  
+   - If no dispute is made, the assertion settles automatically.
+   - If disputed, the decider must choose the winner; monitor status updates in the table.
+
+5. **Check Outcomes**:  
+   View the resolution and settlement status for each assertion directly in the UI.  
 
-🔄 Run `yarn deploy --reset` then test the optimistic oracle. Go to the Optimistic page and try creating assertions, proposing outcomes, and disputing them.
+🧑‍💻 Experiment by creating, proposing, and disputing assertions to observe the full optimistic oracle workflow in the frontend.
 
 🧪 **Live Simulation**: Run the `yarn simulate:optimistic` command to see the full optimistic oracle lifecycle in action:
 
@@ -1490,7 +1899,7 @@ yarn simulate:optimistic
 ### 🥅 Goals:
 
 - The system provides clear state information for all assertions
-- You can query resolved outcomes for both disputed and undisputed assertions
+- Users can query resolved outcomes for both disputed and undisputed assertions
 - All functions handle edge cases and invalid states appropriately
 - The complete optimistic oracle system works end-to-end
 ---
@@ -1502,10 +1911,10 @@ yarn simulate:optimistic
 ### 📊 Comparison Table:
 | Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
 |--------|------------------|----------------|-------------------|
-| **Speed** | Fast | Fast | Slower |
+| **Speed** | Fast | Medium | Slow |
 | **Security** | Low (trusted authority) | High (economic incentives) | High (dispute resolution) |
 | **Decentralization** | Low | High | Depends on Decider Implementation |
-| **Cost** | Low | High (stake) | High (rewards and bonds) |
+| **Cost** | Low | Medium (stake) | High (rewards and bonds) |
 | **Complexity** | Simple | Medium | Complex |
 
 ### 🤔 Key Trade-offs:
@@ -1547,12 +1956,12 @@ yarn simulate:optimistic
 Each oracle design solves different problems:
 
 - **Whitelist Oracle**: Best for setups with trusted intermediaries already in the loop such as RWAs where speed and accuracy are more important than decentralization.
-- **Staking Oracle**: Best for low-latency, high-value DeFi applications where decentralization and security are crucial.
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount and higher latency is not a huge downside. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Decentralization and latency rise and fall together.
+- **Optimistic Oracle**: Best for answering complex questions and where more latency is not a huge problem. Flexible enough to resolve open-ended questions that don't have a strict binary format (e.g., "Which team won the match?").
 
 ---
 
-## Checkpoint 8: 💾 Deploy your contracts! 🛰
+## Checkpoint 8: 💾 Deploy your contract! 🛰
 
 🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
 
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 5af8644b..18a1d124 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -32,7 +32,7 @@ Oracles are bridges between blockchains and the external world. They solve a fun
 
 ---
 
-🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore two existing oracle systems (Whitelist and Staking) to understand their mechanics, then implement the Optimistic Oracle from scratch. Deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
+🌟 The final deliverable is a comprehensive understanding of oracle architectures through hands-on implementation. You'll explore three oracle systems, a Whitelist oracle, Staking-based oracle and an Optimistic oracle, implementing each one. In the end you will deploy your optimistic oracle to a testnet and demonstrate how it handles assertions, proposals, disputes, and settlements.
 
 🔍 First, let's understand why we need multiple oracle designs. Each approach has different strengths:
 
@@ -198,9 +198,9 @@ function addOracle(address _owner) public onlyOwner {
 
 <details markdown='1'>
 
-<summary>💡 Hint: Gas Efficient Array Element Removal</summary>
+<summary>💡 Hint: Safe Array Removal</summary>
 
-Check out this swap-and-pop pattern:
+The swap-and-pop pattern:
 - Check if index is valid (< oracles.length)
 - Store the oracle address for the event
 - If not the last element, swap with the last element
@@ -419,6 +419,10 @@ WhitelistOracle → getPrice() → [100, 102, 98] → sort → [98, 100, 102] 
 
 </details>
 
+---
+
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
@@ -427,15 +431,21 @@ yarn test --grep "Checkpoint1"
 
 \`\`\`
 
-🔄 If it passes all the tests then run \`yarn deploy --reset\` to deploy your contract to your local chain.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at \`packages/hardhat/test/WhitelistOracle.ts\`.
+
+### Try it out!
+
+🔄 Run \`yarn deploy --reset\` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
 
-👊 **Manual Testing**: Notice how the onlyOwner modifiers are commented out to allow you to have full control. Go to your browser and switch to the **Whitelist** page. Make sure you connect with the built-in burner wallet so that you can trigger transactions seamlessly. Now try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
+![WhiteListOracle](SCREENSHOT)
+
+👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
 1. **Change Prices**: Use the frontend to modify individual oracle prices
 
 2. **Add New Nodes**: Create new SimpleOracle contracts through the whitelist oracle
 
-3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles and report different prices
+3. **Observe Aggregation**: Watch how the median price changes as you add/remove oracles
 
 🧪 **Live Simulation**: Run the \`yarn simulate:whitelist\` command to see what a live version of this protocol might look like in action:
 
@@ -450,7 +460,6 @@ yarn simulate:whitelist
 ### 🥅 Goals:
 
 - You can add new SimpleOracle instances to the whitelist
-- You can remove oracles
 - System aggregates prices from active oracles using median calculation
 - Stale data is automatically filtered out based on timestamps
 - You can query which oracle nodes are currently active
@@ -458,21 +467,100 @@ yarn simulate:whitelist
 - Understand the benefits of aggregating multiple data sources
 - Look at these examples "in the wild" from early DeFi: [Simple Oracle](https://github.com/dapphub/ds-value), 
 [Whitelist Oracle](https://github.com/sky-ecosystem/medianizer)
+
 ---
 
 ## Checkpoint 2: 💰 Staking Oracle - Economic Incentives
 
-🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for bad behavior. We will also issue rewards in the form of an ERC20 token called ORA to incentivise participation in the system.
+🧭 Now let's explore a decentralized oracle that uses economic incentives to ensure honest behavior. Nodes stake ETH to participate and can be slashed for reporting prices that deviate too far from the average. The system uses a bucket-based approach where prices are organized into discrete time windows (24 blocks per bucket), and nodes must report once per bucket or else there will be a small inactivity leak in their stake. We will also issue rewards in the form of an ERC20 token called ORA (1 ORA per report) to incentivise participation in the system.
 
-👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, price reporting, reward distribution, and slashing mechanisms.
+👩‍💻 This section challenges you to implement the staking oracle system from scratch. You'll write the core functions that handle node registration, bucket-based price reporting, reward distribution based on report count, and slashing mechanisms for price deviations.
 
-🎯 **Your Mission**: Complete the missing function implementations in the \`StakingOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you need to fill in the logic.
+🎯 **Your Mission**: Complete the missing function implementations in the \`StakingOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers but you need to fill in the logic.
 
 🔍 Open the \`packages/hardhat/contracts/01_Staking/StakingOracle.sol\` file to implement the staking oracle functionality.
 
 ### ✏️ Tasks:
 
-1. **Implement \`registerNode(uint256 initialPrice)\`**
+1. **Implement \`getCurrentBucketNumber()\`**
+
+* 🕒 This view function maps the current \`block.number\` into a bucket index (24-block window)
+
+* 🧮 It should divide the block number by \`BUCKET_WINDOW\` and add 1 (buckets are indexed starting from 1, not 0)
+
+<details markdown='1'>
+
+<summary>💡 Hint: Bucket Number</summary>
+
+- Buckets advance every \`BUCKET_WINDOW\` blocks
+- Integer division will floor the result automatically
+- Remember to add 1 so the very first bucket starts at index 1
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getCurrentBucketNumber() public view returns (uint256) {
+    return (block.number / BUCKET_WINDOW) + 1;
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+2. **Implement \`getEffectiveStake(address nodeAddress)\`**
+
+* 📉 This view function returns a node's stake after inactivity penalties
+
+* 🔍 It should return \`0\` for inactive nodes
+
+* 🧮 It should compute expected reports based on completed buckets since registration
+
+* ✂️ For each missed report, subtract \`INACTIVITY_PENALTY\`, floored at zero
+
+<details markdown='1'>
+
+<summary>💡 Hint: Effective Stake</summary>
+
+- Load the node into memory for cheaper reads
+- If the node is inactive, return \`0\`
+- Determine \`currentBucket\` using \`getCurrentBucketNumber()\`
+- Expected reports = \`currentBucket - n.firstBucket\`
+- Use \`n.reportCount\` as completed reports but subtract one if the last report happened in the current bucket (it isn't completed yet)
+- Penalty = \`missed * INACTIVITY_PENALTY\`; cap at the staked amount
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getEffectiveStake(address nodeAddress) public view returns (uint256) {
+    OracleNode memory n = nodes[nodeAddress];
+    if (!n.active) return 0;
+    uint256 currentBucket = getCurrentBucketNumber();
+    if (currentBucket == n.firstBucket) return n.stakedAmount;
+    uint256 expectedReports = currentBucket - n.firstBucket;
+    uint256 actualReportsCompleted = n.reportCount;
+    if (n.lastReportedBucket == currentBucket && actualReportsCompleted > 0) {
+        actualReportsCompleted -= 1;
+    }
+    if (actualReportsCompleted >= expectedReports) return n.stakedAmount;
+    uint256 missed = expectedReports - actualReportsCompleted;
+    uint256 penalty = missed * INACTIVITY_PENALTY;
+    if (penalty > n.stakedAmount) return 0;
+    return n.stakedAmount - penalty;
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+3. **Implement \`registerNode(uint256 price)\`**
 
 * 🏗️ This function allows users to register as oracle nodes by staking ETH
 
@@ -480,46 +568,47 @@ yarn simulate:whitelist
 
 * 🧪 It should check that the node is not already registered, otherwise revert with \`NodeAlreadyRegistered\`
 
-* 🏗️ It should create a new \`OracleNode\` struct with the provided data
+* 🏗️ It should create a new \`OracleNode\` struct with the correct data
 
 * ➕ It should add the node address to the \`nodeAddresses\` array
 
-* 📣 It should emit both \`NodeRegistered\` and \`PriceReported\` events
+* 💲 It should call \`reportPrice(price)\` (you'll implement this later) to record the first report in the current bucket
+
+* 📣 It should emit the \`NodeRegistered\` event
 
 <details markdown='1'>
 
 <summary>💡 Hint: Node Registration</summary>
 
-Here's what you need to set in the OracleNode struct:
-- nodeAddress should be \`msg.sender\`
-- stakedAmount should be \`msg.value\`
-- lastReportedPrice should be \`initialPrice\`
-- lastReportedTimestamp should be \`block.timestamp\`
-- lastClaimedTimestamp should be \`block.timestamp\`
-- lastSlashedTimestamp should be \`0\`
+Here's what you need to set in the \`OracleNode\` struct:
+- \`stakedAmount\` should be \`msg.value\`
+- \`lastReportedBucket\` should be \`0\` (will be updated in \`reportPrice\`)
+- \`reportCount\` should be \`0\`
+- \`claimedReportCount\` should be \`0\`
+- \`firstBucket\` should be \`getCurrentBucketNumber()\` (the bucket when the node registered)
+- \`active\` should be \`true\`
+
+After creating the struct, push the node into \`nodeAddresses\`, call \`reportPrice(price)\`, and emit the event.
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 \`\`\`solidity
-function registerNode(uint256 initialPrice) public payable {
+function registerNode(uint256 price) public payable {
     if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
-    if (nodes[msg.sender].nodeAddress != address(0)) revert NodeAlreadyRegistered();
-
+    if (nodes[msg.sender].active) revert NodeAlreadyRegistered();
     nodes[msg.sender] = OracleNode({
-        nodeAddress: msg.sender,
         stakedAmount: msg.value,
-        lastReportedPrice: initialPrice,
-        lastReportedTimestamp: block.timestamp,
-        lastClaimedTimestamp: block.timestamp,
-        lastSlashedTimestamp: 0
+        lastReportedBucket: 0,
+        reportCount: 0,
+        claimedReportCount: 0,
+        firstBucket: getCurrentBucketNumber(),
+        active: true
     });
-
     nodeAddresses.push(msg.sender);
-
+    reportPrice(price);
     emit NodeRegistered(msg.sender, msg.value);
-    emit PriceReported(msg.sender, initialPrice);
 }
 \`\`\`
 
@@ -528,24 +617,69 @@ function registerNode(uint256 initialPrice) public payable {
 
 ---
 
-2. **Implement \`reportPrice(uint256 price)\`**
+4. **Implement \`addStake()\`**
+
+* 💸 This payable function lets an active node increase its stake
+
+* ⚠️ It should revert with \`InsufficientStake\` if \`msg.value == 0\`
+
+* ➕ It should add the sent value to the node's \`stakedAmount\`
+
+* 📣 It should emit the \`StakeAdded\` event
+
+<details markdown='1'>
+
+<summary>💡 Hint: Adding Stake</summary>
+
+- Use the \`onlyNode\` modifier to ensure sender is active
+- Update \`nodes[msg.sender].stakedAmount\`
+- Emit \`StakeAdded\`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function addStake() public payable onlyNode {
+    if (msg.value == 0) revert InsufficientStake();
+    nodes[msg.sender].stakedAmount += msg.value;
+    emit StakeAdded(msg.sender, msg.value);
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+5. **Implement \`reportPrice(uint256 price)\`**
 
 * 🧪 This function allows registered nodes to report new prices (uses \`onlyNode\` modifier)
 
-* 🔍 It should verify the node has sufficient stake, otherwise revert with \`NotEnoughStake\`
+* 🔍 It should verify the given price is not zero, otherwise revert with \`InvalidPrice\`
+
+* 🔍 It should verify the node has sufficient stake (using \`getEffectiveStake\`), otherwise revert with \`InsufficientStake\`
+
+* 🚫 It should prevent reporting twice in the same bucket, otherwise revert with \`AlreadyReportedInCurrentBucket\`
+
+* 📊 It should store the node's price in the current bucket's \`TimeBucket\` mapping
+
+* 📈 It should increment the bucket's \`countReports\` and add the price to \`sumPrices\`. This will be useful for deriving the average later
 
-* 🔄 It should update the node's last reported price and timestamp
+* 🔄 It should update the node's \`lastReportedBucket\` and \`reportCount\`
 
-* 📣 It should emit the \`PriceReported\` event
+* 📣 It should emit the \`PriceReported\` event with the sender, price, and bucket number
 
 <details markdown='1'>
 
 <summary>💡 Hint: Price Reporting</summary>
 
-- Get a storage reference to the node using \`nodes[msg.sender]\`
-- Check if \`stakedAmount\` is at least \`MINIMUM_STAKE\`
-- Update \`lastReportedPrice\` and \`lastReportedTimestamp\`
-- Emit event with sender and new price
+- Pull \`OracleNode storage node = nodes[msg.sender]\`
+- Validate price and stake before touching bucket state
+- Use \`timeBuckets[getCurrentBucketNumber()]\`
+- Update bucket mappings and aggregates
+- Update the node's \`lastReportedBucket\` to \`getCurrentBucketNumber()\`
+- Increment the node's \`reportCount\`
 
 <details markdown='1'>
 
@@ -553,12 +687,18 @@ function registerNode(uint256 initialPrice) public payable {
 
 \`\`\`solidity
 function reportPrice(uint256 price) public onlyNode {
+    if (price == 0) revert InvalidPrice();
     OracleNode storage node = nodes[msg.sender];
-    if (node.stakedAmount < MINIMUM_STAKE) revert NotEnoughStake();
-    node.lastReportedPrice = price;
-    node.lastReportedTimestamp = block.timestamp;
-
-    emit PriceReported(msg.sender, price);
+    if (getEffectiveStake(msg.sender) < MINIMUM_STAKE) revert InsufficientStake();
+    if (node.lastReportedBucket == getCurrentBucketNumber()) revert AlreadyReportedInCurrentBucket();
+    TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber()];
+    bucket.prices[msg.sender] = price;
+    bucket.countReports++;
+    bucket.sumPrices += price;
+
+    node.lastReportedBucket = getCurrentBucketNumber();
+    node.reportCount++;
+    emit PriceReported(msg.sender, price, getCurrentBucketNumber());
 }
 \`\`\`
 
@@ -567,64 +707,122 @@ function reportPrice(uint256 price) public onlyNode {
 
 ---
 
-3. **Implement \`claimReward()\` and \`rewardNode()\`**
-
-* 🧪 These functions allow registered nodes to claim their ORA token rewards (uses \`onlyNode\` modifier)
+6. **Implement \`claimReward()\`**
 
-* 🔍 It should calculate reward amount based on time elapsed since last claim
+* 🧪 This function allows past and present nodes to claim their ORA token rewards
 
-* 💰 For active nodes (sufficient stake): rewards based on time since last claim
+* 🔍 It should calculate reward amount based on the difference between \`reportCount\` and \`claimedReportCount\`. We will call this number the \`delta\`
 
-* ⚠️ For slashed nodes (insufficient stake): limited rewards only up to when they were slashed
+* 🔒 It should revert with \`NoRewardsAvailable\` if \`delta == 0\`
 
-* 🎁 It should mint ORA tokens as rewards (time-based, scaled by 10^18) using the internal \`rewardNode()\` helper
+* 🔢 It should update \`claimedReportCount\` to \`reportCount\` *before* minting the tokens (reentrancy safe)
 
-* 🔒 It should revert with \`NoRewardsAvailable\` if no rewards are available
+* 💰 It should mint \`delta * REWARD_PER_REPORT\` ORA tokens
 
-* 📣 It should update \`lastClaimedTimestamp\` and emit \`NodeRewarded\` event
+* 📣 It should emit the \`NodeRewarded\` event
 
 <details markdown='1'>
 
 <summary>💡 Hint: Reward Implementation</summary>
 
-You need to implement both functions:
+- Load the node in storage
+- Compute \`delta\`
+- Revert if \`delta == 0\`
+- Update \`claimedReportCount\`
+- Mint the reward and emit the event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function claimReward() public {
+    OracleNode storage node = nodes[msg.sender];
+
+    uint256 delta = node.reportCount - node.claimedReportCount;
+    if (delta == 0) revert NoRewardsAvailable();
+
+    node.claimedReportCount = node.reportCount;
+    oracleToken.mint(msg.sender, delta * REWARD_PER_REPORT);
+    emit NodeRewarded(msg.sender, delta * REWARD_PER_REPORT);
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+7. **Implement \`_removeNode(address nodeAddress, uint256 index)\`**
+
+* 🗂️ This internal function removes a node from the \`nodeAddresses\` array while keeping the array packed. By forcing the caller to provide the index and simply verifying it is at that position we are removing the need to iterate over a potentially large array
+
+* 🔍 It should ensure the provided \`index\` is within bounds, otherwise revert with \`IndexOutOfBounds\`
 
-**claimReward()** logic:
-- If node has insufficient stake AND was previously slashed: reward = time between lastClaimedTimestamp and lastSlashedTimestamp
-- If node has sufficient stake: reward = time between lastClaimedTimestamp and now
-- Scale reward by 10^18 for token decimals
-- Update lastClaimedTimestamp to current time
-- Call rewardNode() to mint tokens
+* ✅ It should ensure the address at the given index matches \`nodeAddress\`, otherwise revert with \`NodeNotAtGivenIndex\`
 
-**rewardNode()** logic:
-- Simple internal function that mints ORA tokens and emits event
+* 🔁 It should use the pop-and-swap pattern to remove the entry efficiently
+
+* 🚫 It should mark the node as inactive without deleting the entire struct (other functions may rely on historical data)
+
+<details markdown='1'>
+
+<summary>💡 Hint: Removing Nodes</summary>
+
+- Check \`index < nodeAddresses.length\`
+- Check \`nodeAddresses[index] == nodeAddress\`
+- Assign the last address into the \`index\` slot, then pop
+- Set \`nodes[nodeAddress].active = false\`
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 \`\`\`solidity
-function claimReward() public onlyNode {
-    OracleNode memory node = nodes[msg.sender];
-    uint256 rewardAmount = 0;
+function _removeNode(address nodeAddress, uint256 index) internal {
+    if (nodeAddresses.length <= index) revert IndexOutOfBounds();
+    if (nodeAddresses[index] != nodeAddress) revert NodeNotAtGivenIndex();
+    nodeAddresses[index] = nodeAddresses[nodeAddresses.length - 1];
+    nodeAddresses.pop();
+    nodes[nodeAddress].active = false;
+}
+\`\`\`
 
-    if (node.stakedAmount < MINIMUM_STAKE) {
-        if (node.lastClaimedTimestamp < node.lastSlashedTimestamp) {
-            rewardAmount = node.lastSlashedTimestamp - node.lastClaimedTimestamp;
-        }
-    } else {
-        rewardAmount = block.timestamp - node.lastClaimedTimestamp;
-    }
+</details>
+</details>
 
-    if (rewardAmount == 0) revert NoRewardsAvailable();
+---
 
-    nodes[msg.sender].lastClaimedTimestamp = block.timestamp;
-    rewardNode(msg.sender, rewardAmount * 10 ** 18);
-}
+8. **Implement \`_checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice)\`**
+
+* 🧮 This internal pure function determines whether a reported price deviates beyond the allowed threshold
+
+* 🔢 It should compute the absolute difference between the reported price and the average
+
+* 📐 It should convert the deviation to basis points and compare it against \`MAX_DEVIATION_BPS\`
+
+* 🔁 It should return \`true\` when the deviation is greater than the threshold, otherwise \`false\`
+
+<details markdown='1'>
+
+<summary>💡 Hint: Deviation Check</summary>
+
+- Use a simple conditional to compute the absolute deviation
+- Multiply the deviation by 10,000 (basis points) before dividing by \`averagePrice\`. This will allow for greater precision
+- Compare the result against \`MAX_DEVIATION_BPS\`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
 
-function rewardNode(address nodeAddress, uint256 reward) internal {
-    oracleToken.mint(nodeAddress, reward);
-    emit NodeRewarded(nodeAddress, reward);
+\`\`\`solidity
+function _checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice) internal pure returns (bool) {
+    uint256 deviation = reportedPrice > averagePrice ? reportedPrice - averagePrice : averagePrice - reportedPrice;
+    uint256 deviationBps = (deviation * 10_000) / averagePrice;
+    if (deviationBps > MAX_DEVIATION_BPS) {
+        return true;
+    }
+    return false;
 }
 \`\`\`
 
@@ -633,100 +831,156 @@ function rewardNode(address nodeAddress, uint256 reward) internal {
 
 ---
 
-4. **Implement \`slashNodes()\`, \`separateStaleNodes()\`, and \`slashNode()\`**
+9. **Implement \`slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index)\`**
 
-* 🔎 These functions work together to allow anyone to slash nodes with stale data and get rewarded
+* 🔎 This function allows anyone to slash nodes that reported prices deviating too far from the average
 
-* 📊 It should identify stale nodes by categorizing them into fresh and stale based on data recency
+* 🧪 It should verify the node is active, otherwise revert with \`NodeNotRegistered\`
 
-* ✂️ It should slash each stale node by 1 ETH and calculate slasher rewards
+* ⏰ It should verify the bucket is in the past (not current), otherwise revert with \`OnlyPastBucketsAllowed\`
 
-* 🏅 It should accumulate slasher rewards and send them to the caller
+* 🚫 It should verify the node hasn't already been slashed in this bucket, otherwise revert with \`NodeAlreadySlashed\`
 
-* ⚠️ It should revert with \`FailedToSendReward\` if the transfer fails
+* 📊 It should verify the node reported a price in this bucket, otherwise revert with \`NodeDidNotReport\`
 
-<details markdown='1'>
+* ✂️ It should mark the node as slashed and remove their price from the bucket's sum and count
 
-<summary>💡 Hint: Complete Slashing Implementation</summary>
+* 🧮 It should recalculate the average price after removing the node's price
+
+* 🔍 It should verify the node's price deviates beyond the threshold using \`_checkPriceDeviated\`, otherwise revert with \`NotDeviated\`
+
+* 💰 It should slash the node by \`MISREPORT_PENALTY\` (or their full stake if less)
+
+* 🏅 It should send 10% of the penalty to the slasher (\`msg.sender\`)
+
+* 🗑️ It should remove the node if their stake reaches zero after slashing using \`_removeNode\`
 
-You need to implement all three functions:
+* ⚠️ It should revert with \`FailedToSend\` if the reward transfer fails
 
-**slashNodes()** - public entry point:
-- Use separateStaleNodes to get stale addresses
-- Loop through and slash each one
-- Send accumulated rewards to caller
+* 📣 It should emit \`NodeSlashed\` and \`NodeExited\` (if the node is removed)
 
-**separateStaleNodes()** - categorization logic:
-- Check timestamps against STALE_DATA_WINDOW
-- Return fresh and stale address arrays
+<details markdown='1'>
+
+<summary>💡 Hint: Complete Slashing Implementation</summary>
 
-**slashNode()** - internal slashing logic:
-- Reduce stake, update timestamp, calculate reward
-- Return slasher reward (10% of penalty)
+Follow these steps:
+- Validate node state and bucket recency
+- Ensure the node actually reported in that bucket and hasn't been slashed yet
+- Remove their contribution from \`sumPrices\`/\`countReports\`
+- Recompute the average (excluding the offender) and check deviation with \`_checkPriceDeviated\`
+- Apply the penalty by reducing the node's \`stakedAmount\`
+- If the node is fully slashed (\`stakedAmount\` == 0), remove them with \`_removeNode\`
+- Calculate the reward, and transfer it
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 \`\`\`solidity
-function slashNodes() public {
-    (, address[] memory addressesToSlash) = separateStaleNodes(nodeAddresses);
-    uint256 slasherReward;
-    for (uint i = 0; i < addressesToSlash.length; i++) {
-        slasherReward += slashNode(addressesToSlash[i], 1 ether);
+function slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index) public {
+    if (!nodes[nodeToSlash].active) revert NodeNotRegistered();
+    if (getCurrentBucketNumber() == bucketNumber) revert OnlyPastBucketsAllowed();
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    if (bucket.slashedOffenses[nodeToSlash]) revert NodeAlreadySlashed();
+    uint256 reportedPrice = bucket.prices[nodeToSlash];
+    if (reportedPrice == 0) revert NodeDidNotReport();
+    bucket.slashedOffenses[nodeToSlash] = true;
+    bucket.sumPrices -= reportedPrice;
+    bucket.countReports--;
+    uint256 averagePrice = bucket.sumPrices / bucket.countReports;
+    if (!_checkPriceDeviated(reportedPrice, averagePrice)) {
+        revert NotDeviated();
     }
+    OracleNode storage node = nodes[nodeToSlash];
+    uint256 actualPenalty = MISREPORT_PENALTY > node.stakedAmount ? node.stakedAmount : MISREPORT_PENALTY;
+    node.stakedAmount -= actualPenalty;
 
-    (bool sent, ) = msg.sender.call{ value: slasherReward }("");
-    if (!sent) revert FailedToSendReward();
-}
+    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
 
-function separateStaleNodes(
-    address[] memory nodesToSeparate
-) public view returns (address[] memory fresh, address[] memory stale) {
-    address[] memory freshNodeAddresses = new address[](nodesToSeparate.length);
-    address[] memory staleNodeAddresses = new address[](nodesToSeparate.length);
-    uint256 freshCount = 0;
-    uint256 staleCount = 0;
-
-    for (uint i = 0; i < nodesToSeparate.length; i++) {
-        address nodeAddress = nodesToSeparate[i];
-        OracleNode memory node = nodes[nodeAddress];
-        uint256 timeElapsed = block.timestamp - node.lastReportedTimestamp;
-        bool dataIsStale = timeElapsed > STALE_DATA_WINDOW;
-
-        if (dataIsStale) {
-            staleNodeAddresses[staleCount] = nodeAddress;
-            staleCount++;
-        } else {
-            freshNodeAddresses[freshCount] = nodeAddress;
-            freshCount++;
-        }
+    (bool sent, ) = msg.sender.call{ value: reward }("");
+    if (!sent) revert FailedToSend();
+
+    if (node.stakedAmount == 0) {
+        _removeNode(nodeToSlash, index);
+        emit NodeExited(nodeToSlash, 0);
     }
 
-    address[] memory trimmedFreshNodes = new address[](freshCount);
-    address[] memory trimmedStaleNodes = new address[](staleCount);
+    emit NodeSlashed(nodeToSlash, actualPenalty);
+}
+\`\`\`
 
-    for (uint i = 0; i < freshCount; i++) {
-        trimmedFreshNodes[i] = freshNodeAddresses[i];
-    }
-    for (uint i = 0; i < staleCount; i++) {
-        trimmedStaleNodes[i] = staleNodeAddresses[i];
-    }
+</details>
+</details>
+
+---
+
+10. **Implement \`exitNode(uint256 index)\`**
+
+* 🚪 This function allows a node to exit and withdraw its stake after a waiting period
+
+* ⏳ It should ensure the node waited at least \`WAITING_PERIOD\` buckets since their last report, otherwise revert with \`WaitingPeriodNotOver\`. This way there is ample time to slash them before they exit
+
+* 💰 It should compute the withdrawable stake using \`getEffectiveStake\` before removing the node
+
+* 🗑️ It should call \`_removeNode(msg.sender, index)\` to mark the node inactive and keep the node array tidy
+
+* 🧹 It should send the stake back to the sender
+
+* ⚠️ It should revert with \`FailedToSend\` if the withdrawal transfer fails
+
+* 📣 It should emit the \`NodeExited\` event with the withdrawn amount
 
-    return (trimmedFreshNodes, trimmedStaleNodes);
+<details markdown='1'>
+
+<summary>💡 Hint: Exit Logic</summary>
+
+- Fetch the node in storage
+- Require \`node.lastReportedBucket + WAITING_PERIOD <= getCurrentBucketNumber()\`
+- Compute \`stake = getEffectiveStake(msg.sender)\` **before** removing
+- Call \`_removeNode\`
+- Transfer the stake using \`call\`
+- Emit the event
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function exitNode(uint256 index) public onlyNode {
+    OracleNode storage node = nodes[msg.sender];
+    if (node.lastReportedBucket + WAITING_PERIOD > getCurrentBucketNumber()) revert WaitingPeriodNotOver();
+    uint256 stake = getEffectiveStake(msg.sender);
+    _removeNode(msg.sender, index);
+    (bool sent, ) = msg.sender.call{ value: stake }("");
+    if (!sent) revert FailedToSend();
+
+    emit NodeExited(msg.sender, stake);
 }
+\`\`\`
 
-function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {
-    OracleNode storage node = nodes[nodeToSlash];
-    uint256 actualPenalty = penalty > node.stakedAmount ? node.stakedAmount : penalty;
-    node.stakedAmount -= actualPenalty;
-    node.lastSlashedTimestamp = block.timestamp;
+</details>
+</details>
 
-    uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
+---
 
-    emit NodeSlashed(nodeToSlash, actualPenalty);
+11. **Implement \`getNodeAddresses()\`**
+
+* 📚 This view function should return every registered node address in order. This is convenient for the front-end 
+
+<details markdown='1'>
+
+<summary>💡 Hint: Node List</summary>
+
+- The array \`nodeAddresses\` tracks the registration order
+- Just return the array
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
 
-    return reward;
+\`\`\`solidity
+function getNodeAddresses() public view returns (address[] memory) {
+    return nodeAddresses;
 }
 \`\`\`
 
@@ -735,60 +989,149 @@ function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint2
 
 ---
 
-5. **Implement \`getPrice()\` and \`getPricesFromAddresses()\`**
+12. **Implement \`getLatestPrice()\`**
 
-* 📦 These functions work together to aggregate prices from all active nodes using median calculation
+* 📦 This function returns the aggregated price from the most recent completed bucket
 
-* 🧹 It should filter out nodes with stale data using \`separateStaleNodes()\`
+* 🔍 It should get the previous bucket (current bucket - 1) since the current bucket is still being filled
 
-* 🔍 It should extract prices reported by the nodes at valid addresses using the internal \`getPricesFromAddresses()\` helper
+* 📊 It should retrieve the \`TimeBucket\` for that bucket
 
-* ⛔️ It should revert with \`NoValidPricesAvailable\` if no valid prices exist
+* ⛔️ It should revert with \`NoValidPricesAvailable\` if \`bucket.countReports == 0\`
 
-* 🧮 It should sort and calculate the median using StatisticsUtils
+* 🧮 It should return the average price: \`bucket.sumPrices / bucket.countReports\`
 
 <details markdown='1'>
 
-<summary>💡 Hint: Price Aggregation Implementation</summary>
+<summary>💡 Hint: Latest Price</summary>
+
+- Use \`getCurrentBucketNumber() - 1\`
+- Access the bucket mapping
+- Guard against empty buckets
+- Return the average
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getLatestPrice() public view returns (uint256) {
+    TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber() - 1];
+    if (bucket.countReports == 0) revert NoValidPricesAvailable();
+    return bucket.sumPrices / bucket.countReports;
+}
+\`\`\`
+
+</details>
+</details>
+
+---
+
+13. **Implement \`getPastPrice(uint256 bucketNumber)\`**
+
+* 🕰️ Because we are storing pricing in time-segmented buckets we can enable retrieving a price from any one of these buckets. This view function returns the average price for any historical bucket
 
-You need to implement both functions:
+* ⛔️ It should revert with \`NoValidPricesAvailable\` if that bucket has no reports
 
-**getPrice()** logic:
-- Get valid (fresh) addresses from separateStaleNodes
-- Get prices from those addresses using getPricesFromAddresses
-- Check if any valid prices exist
-- Sort prices and return median
+<details markdown='1'>
+
+<summary>💡 Hint: Past Price</summary>
 
-**getPricesFromAddresses()** logic:
-- Create an array the same size as the input addresses
-- Loop through addresses and get each node's lastReportedPrice
-- Return the prices array
+- Grab \`TimeBucket storage bucket = timeBuckets[bucketNumber]\`
+- Check \`bucket.countReports\`
+- Return \`bucket.sumPrices / bucket.countReports\`
 
 <details markdown='1'>
 
 <summary>🎯 Solution</summary>
 
 \`\`\`solidity
-function getPrice() public view returns (uint256) {
-    (address[] memory validAddresses, ) = separateStaleNodes(nodeAddresses);
-    uint256[] memory validPrices = getPricesFromAddresses(validAddresses);
-    if (validPrices.length == 0) revert NoValidPricesAvailable();
+function getPastPrice(uint256 bucketNumber) public view returns (uint256) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    if (bucket.countReports == 0) revert NoValidPricesAvailable();
+    return bucket.sumPrices / bucket.countReports;
+}
+\`\`\`
 
-    validPrices.sort();
-    return validPrices.getMedian();
+</details>
+</details>
+
+---
+
+14. **Implement \`getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber)\`**
+
+* 🔎 This view function returns the price a node reported in a bucket and whether they were slashed there
+
+<details markdown='1'>
+
+<summary>💡 Hint: Bucket Data</summary>
+
+- Access the bucket mapping and return both \`prices[nodeAddress]\` and \`slashedOffenses[nodeAddress]\`
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber) public view returns (uint256, bool) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    return (bucket.prices[nodeAddress], bucket.slashedOffenses[nodeAddress]);
 }
+\`\`\`
 
-function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {
-    uint256[] memory prices = new uint256[](addresses.length);
+</details>
+</details>
 
-    for (uint256 i = 0; i < addresses.length; i++) {
-        OracleNode memory node = nodes[addresses[i]];
-        prices[i] = node.lastReportedPrice;
-    }
+---
+
+15. **Implement \`getOutlierNodes(uint256 bucketNumber)\`**
+
+* 📊 This view function identifies nodes whose price deviates beyond the maximum deviation in a given bucket
+
+* 🗃️ It should iterate over all \`nodeAddresses\` (this is fine since it is a view method)
+
+* 🧮 For each reported price, calculate the average of the remaining reports and test deviation with \`_checkPriceDeviated\`
+
+* 🧹 Collect only the outliers and trim the array before returning
+
+<details markdown='1'>
+
+<summary>💡 Hint: Outlier Detection</summary>
 
-    return prices;
+- Allocate a temporary array of size \`bucket.countReports\`
+- Loop through \`nodeAddresses\`
+- Skip addresses that did not report (\`reportedPrice == 0\`)
+- Compute \`averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1)\`
+- If \`_checkPriceDeviated(...)\` returns true, store the address in the temp array and increment a counter
+- Allocate a trimmed array of length \`outlierCount\` and copy the collected addresses
+
+<details markdown='1'>
+
+<summary>🎯 Solution</summary>
+
+\`\`\`solidity
+function getOutlierNodes(uint256 bucketNumber) public view returns (address[] memory) {
+    TimeBucket storage bucket = timeBuckets[bucketNumber];
+    address[] memory outliers = new address[](bucket.countReports);
+    uint256 outlierCount = 0;
+    for (uint256 i = 0; i < nodeAddresses.length; i++) {
+        address nodeAddress = nodeAddresses[i];
+        uint256 reportedPrice = bucket.prices[nodeAddress];
+        if (reportedPrice == 0) continue;
+        uint256 averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1);
+        if (_checkPriceDeviated(reportedPrice, averagePrice)) {
+            outliers[outlierCount] = nodeAddress;
+            outlierCount++;
+        }
+    }
+    address[] memory trimmed = new address[](outlierCount);
+    for (uint256 i = 0; i < outlierCount; i++) {
+        trimmed[i] = outliers[i];
+    }
+    return trimmed;
 }
 \`\`\`
+
 </details>
 </details>
 
@@ -796,12 +1139,21 @@ function getPricesFromAddresses(address[] memory addresses) internal view return
 
 ### 🤔 Key Insights:
 
-- **Economic Incentives**: Nodes stake ETH and can be slashed for bad behavior, while good behavior rewards nodes with ORA tokens
+- **Bucket-Based System**: Prices are organized into time buckets (24 blocks each), allowing for discrete time windows and preventing double-reporting within the same bucket
+- **Economic Incentives**: Nodes stake ETH and can be slashed for reporting prices that deviate too far from the average, while good behavior rewards nodes with ORA tokens (1 ORA per report)
+- **Effective Stake**: Nodes face inactivity penalties for missed buckets, reducing their effective stake over time if they fail to report regularly
 - **Decentralized**: Anyone can participate by staking, no central authority needed
-- **Self-Correcting**: Slashing mechanism punishes inactive nodes
-- **Freshness Enforcement**: Stale data is automatically filtered out
-- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial
-- **Improvements**: This could be enhanced by adding slashing for outlier prices that indicate manipulation
+- **Self-Correcting**: Slashing mechanism punishes nodes that report prices deviating beyond the threshold (10% by default)
+- **Average Aggregation**: Prices are aggregated using a simple average from all reports in a completed bucket, providing a fair representation of the collective price
+- **Use Cases**: Excellent for DeFi applications where economic alignment is crucial and price updates occur at regular intervals
+
+### 🤔 Critical Thinking: Security Vulnerabilities
+
+- **Robustness vs. Whitelist Oracle**: Unlike the whitelist oracle which relies on a single trusted authority, the staking oracle's design distributes trust among all staking nodes. Manipulating the output requires a majority of nodes to collude, which is economically disincentivized due to the risk of slashing. As a result, unless an attacker controls a majority of the total effective stake, they cannot egregiously manipulate the reported price—making the system considerably more robust than one with simple whitelist control.
+
+---
+
+### Testing your progress
 
 🔍 Run the following command to check if you implemented the functions correctly.
 
@@ -811,7 +1163,27 @@ yarn test --grep "Checkpoint2"
 
 \`\`\`
 
-🔄 Run \`yarn deploy --reset\` then test the staking oracle. Go to the Staking page in your browser and try registering nodes, reporting prices, and slashing inactive nodes.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at \`packages/hardhat/test/StakingOracle.ts\`.
+
+### Try it out!
+
+🌎 In the real world this oracle would have too much latency to be very useful due to the need for 24 block windows. However, this was done to make it possible for you to see how the oracle operates in real time without everything happening too fast to comprehend. There is no reason why this couldn't work with single block windows although in decentralized systems you must always consider that the lower the latency requirements, the fewer nodes can participate
+
+🔄 Run \`yarn deploy --reset\` then test the staking oracle. Go to the \`Staking\` page and try registering your own node and reporting prices.
+
+🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
+
+![Staking Buttons Panel](SCREENSHOT)
+
+> 🗺️ You can navigate to past buckets using the arrows. 
+
+✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
+
+![SelfNodeRow](SCREENSHOT)
+
+> ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
+
+😮‍💨 *Whew!* That was a lot of work pressing all those buttons to keep from getting the inactive penalty! Much easier when bots are doing all the work and you can just watch. Exit your node (if it stresses you) and lets have some fun.
 
 🧪 **Live Simulation**: Run the \`yarn simulate:staking\` command to watch a live simulation of staking oracle behavior with multiple nodes:
 
@@ -821,16 +1193,25 @@ yarn simulate:staking
 
 \`\`\`
 
-🤖 This will start automated bots that simulate honest and malicious node behavior, frequent and stale reports, and demonstrate how slashing and median aggregation impact the reported price. You can update the price variance and skip probability from the front-end as well.
+🤖 This will start automated bots and demonstrate how slashing and average aggregation impact the reported price. Right now they are all on default settings so the price won't deviate, but...
+
+⚙️ You can update the price deviation and skip probability by pressing the gear icon. Go ahead and make some bots start to produce wild deviations then view the past buckets (by using the arrows) to see the "slash" button activated. Press it to slash any deviated nodes.
+
+🥱 If you get tired of slashing deviated nodes but still want to see them get slashed you can re-run the command with this environment variable:
+
+\`\`\`sh
+AUTO_SLASH=true yarn simulate:staking
+\`\`\`
 
 ### 🥅 Goals:
 
-- You can register as oracle nodes by staking ETH
-- Registered nodes can report prices and claim ORA token rewards
-- Anyone can slash nodes with stale data and earn rewards
-- System aggregates prices from active nodes using median calculation
-- Economic incentives drive honest behavior and data freshness
-- Understand the trade-offs between decentralization and complexity
+- You can register as an oracle node by staking ETH
+- Registered nodes can report prices once per bucket and claim ORA token rewards based on report count
+- Anyone can slash nodes that report prices deviating too far from the average and earn rewards
+- System aggregates prices from completed buckets using average calculation
+- Inactivity penalties reduce effective stake for nodes that miss reporting in buckets
+- Economic incentives drive honest behavior and regular participation
+- Understand the trade-offs between decentralization and latency
 - See examples in the wild: [Chainlink](https://chain.link) and [PYTH](https://www.pyth.network/)
 
 ---
@@ -914,7 +1295,7 @@ sequenceDiagram
 
 🎯 **Your Mission**: Complete the missing function implementations in the \`OptimisticOracle.sol\` contract. The contract skeleton is already provided with all the necessary structs, events, and modifiers - you just need to fill in the logic.
 
-🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run \`yarn test\` after implementing each function to verify your solution works correctly. To target a specific method just use the \`--grep\` flag with the \`yarn test\` command and write out the test name like this: \`yarn test --grep "Name of test"\`.
+🧪 **Testing Strategy**: Each function you implement can be tested individually using the provided test suite. Run \`yarn test\` after implementing each function to verify your solution works correctly.
 
 🔍 Open the \`packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol\` file to implement the optimistic oracle functionality.
 
@@ -924,7 +1305,7 @@ sequenceDiagram
 
 * 📣 This function allows users to assert that an event will have a true/false outcome
 
-* 💸 It should require that the reward (\`msg.value\`) is greater than 0. If it is not then revert with \`NotEnoughValue\`
+* 💸 It should require that the reward (\`msg.value\`) is greater than 0 . If it is not then revert with \`InvalidValue\`
 
 * ⏱️ It should accept 0 for \`startTime\` and set it to \`block.timestamp\`
 
@@ -947,7 +1328,7 @@ sequenceDiagram
 Here are more granular instructions on setting up the EventAssertion struct:
 - asserter should be \`msg.sender\`
 - reward should be \`msg.value\`
-- bond should be the reward x 2 for economic security (You will know why as you understand the economics and game theory)
+- bond should be the reward x 2 (You will know why as you understand the economics and game theory)
 - startTime = \`startTime\`
 - endTime = \`endTime\`
 - description = \`description\`
@@ -961,7 +1342,7 @@ Here are more granular instructions on setting up the EventAssertion struct:
     function assertEvent(string memory description, uint256 startTime, uint256 endTime) external payable returns (uint256) {
         uint256 assertionId = nextAssertionId;
         nextAssertionId++;
-        if (msg.value == 0) revert NotEnoughValue();
+        if (msg.value == 0) revert InvalidValue();
 
         // Set default times if not provided
         if (startTime == 0) {
@@ -1007,7 +1388,7 @@ Here are more granular instructions on setting up the EventAssertion struct:
 
 * ⏱️ It should validate the timing constraints - it has to be after \`startTime\` but before the \`endTime\` or else revert with \`InvalidTime\`
 
-* 💸 It should enforce the correct bond amount is provided or revert with \`NotEnoughValue\`
+* 💸 It should enforce the correct bond amount is provided or revert with \`InvalidValue\`
 
 * ✍️ It should update the assertion with the proposal
 
@@ -1036,7 +1417,7 @@ You want to set these properties on the assertion:
         if (assertion.proposer != address(0)) revert AssertionProposed();
         if (block.timestamp < assertion.startTime) revert InvalidTime();
         if (block.timestamp > assertion.endTime) revert InvalidTime();
-        if (msg.value != assertion.bond) revert NotEnoughValue();
+        if (msg.value != assertion.bond) revert InvalidValue();
 
         assertion.proposer = msg.sender;
         assertion.proposedOutcome = outcome;
@@ -1080,7 +1461,7 @@ The bond amount should be the bond set on the assertion. The same amount that th
         if (assertion.proposer == address(0)) revert NotProposedAssertion();
         if (assertion.disputer != address(0)) revert ProposalDisputed();
         if (block.timestamp > assertion.endTime) revert InvalidTime();
-        if (msg.value != assertion.bond) revert NotEnoughValue();
+        if (msg.value != assertion.bond) revert InvalidValue();
 
         assertion.disputer = msg.sender;
 
@@ -1093,6 +1474,8 @@ The bond amount should be the bond set on the assertion. The same amount that th
 
 ---
 
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
@@ -1242,7 +1625,7 @@ This function enables the asserter to get a refund of their posted reward when n
 
 * 🚫 No proposer exists (revert with \`AssertionProposed\`)
 
-* ⏰ After assertion endTime (revert with \`InvalidTime\`)
+* ⏰ After assertion endTime ( revert with \`InvalidTime\`)
 
 * 🔒 Not already claimed (revert with \`AlreadyClaimed\`)
 
@@ -1310,7 +1693,7 @@ We just need the decider to use the remaining unused properties to establish whi
 
 Set resolvedOutcome to true or false based on what is the actual truth regarding an assertion.
 
-Then set the winner to the proposer if the proposer was correct *or* set it to the disputer if the disputer was correct.
+Then set the winner to the proposer if the proposer was correct *or* set it to the disputer is the disputer was correct.
 
 <details markdown="1">
 <summary>🎯 Solution</summary>
@@ -1336,6 +1719,10 @@ Then set the winner to the proposer if the proposer was correct *or* set it to t
 </details>
 </details>
 
+---
+
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
@@ -1426,7 +1813,7 @@ This function will help everyone know the exact outcome of the assertion.
 
 * ⏳ Then we just need to check if anyone disputed it and that the dispute window is up to know we can rely on the \`proposedOutcome\` (if the time isn't over then revert with \`InvalidTime\`)
 
-* 🧑‍⚖️ Otherwise, if a dispute has been made, then we just need to make sure the \`winner\` has been set by the decider (or else revert with \`AwaitingDecider\`)
+* 🧑‍⚖️ Otherwise, if a disupte has been made, then we just need to make sure the \`winner\` has been set by the decider (or else revert with \`AwaitingDecider\`)
 
 <details markdown="1">
 <summary>💡 Hint: Read Outcome Carefully</summary>
@@ -1459,6 +1846,8 @@ The important thing here is that it reverts if it is not settled and if it has b
 
 ---
 
+### Testing your progress
+
 🔍 Run the following command to check if you implemented the functions correctly.
 
 \`\`\`sh
@@ -1467,9 +1856,35 @@ yarn test --grep "Checkpoint6"
 
 \`\`\`
 
-✅ Make sure you have implemented everything correctly by running tests with \`yarn test\`. You can dig into any errors by viewing the tests at \`packages/hardhat/test/OptimisticOracle.ts\`.
+✅ Did the tests pass? You can dig into any errors by viewing the tests at \`packages/hardhat/test/OptimisticOracle.ts\`.
+
+### Try it out!
+
+🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Try creating assertions, proposing outcomes, and disputing them.
+
+🖥️ Go to the Optimistic page to interact with your new protocol
+
+![OptimisticOracle](SCREENSHOT)
+
+1. **Submit a New Assertion**:  
+   Go to the "Optimistic" page and fill in the required fields to create a new assertion.  
+   - Enter the assertion details and submit.
+
+2. **Propose an Outcome**:  
+   Once an assertion is created, use the UI to propose an outcome for your assertion.  
+
+3. **Dispute an Outcome**:  
+   If someone disagrees with the proposed outcome, they can dispute it using the dispute button shown in the table for pending assertions.
+
+4. **Wait for Dispute Window & Settlement**:  
+   - Wait for the dispute window (the protocol’s timer) to expire.  
+   - If no dispute is made, the assertion settles automatically.
+   - If disputed, the decider must choose the winner; monitor status updates in the table.
+
+5. **Check Outcomes**:  
+   View the resolution and settlement status for each assertion directly in the UI.  
 
-🔄 Run \`yarn deploy --reset\` then test the optimistic oracle. Go to the Optimistic page and try creating assertions, proposing outcomes, and disputing them.
+🧑‍💻 Experiment by creating, proposing, and disputing assertions to observe the full optimistic oracle workflow in the frontend.
 
 🧪 **Live Simulation**: Run the \`yarn simulate:optimistic\` command to see the full optimistic oracle lifecycle in action:
 
@@ -1484,7 +1899,7 @@ yarn simulate:optimistic
 ### 🥅 Goals:
 
 - The system provides clear state information for all assertions
-- You can query resolved outcomes for both disputed and undisputed assertions
+- Users can query resolved outcomes for both disputed and undisputed assertions
 - All functions handle edge cases and invalid states appropriately
 - The complete optimistic oracle system works end-to-end
 ---
@@ -1496,10 +1911,10 @@ yarn simulate:optimistic
 ### 📊 Comparison Table:
 | Aspect | Whitelist Oracle | Staking Oracle | Optimistic Oracle |
 |--------|------------------|----------------|-------------------|
-| **Speed** | Fast | Fast | Slower |
+| **Speed** | Fast | Medium | Slow |
 | **Security** | Low (trusted authority) | High (economic incentives) | High (dispute resolution) |
 | **Decentralization** | Low | High | Depends on Decider Implementation |
-| **Cost** | Low | High (stake) | High (rewards and bonds) |
+| **Cost** | Low | Medium (stake) | High (rewards and bonds) |
 | **Complexity** | Simple | Medium | Complex |
 
 ### 🤔 Key Trade-offs:
@@ -1541,12 +1956,12 @@ yarn simulate:optimistic
 Each oracle design solves different problems:
 
 - **Whitelist Oracle**: Best for setups with trusted intermediaries already in the loop such as RWAs where speed and accuracy are more important than decentralization.
-- **Staking Oracle**: Best for low-latency, high-value DeFi applications where decentralization and security are crucial.
-- **Optimistic Oracle**: Best for complex, high-stakes applications where absolute truth is paramount and higher latency is not a huge downside. Flexible enough to resolve open-ended questions that don’t have a strict binary format (e.g., “Which team won the match?”).
+- **Staking Oracle**: Best for high-value DeFi applications where decentralization and security are crucial. Decentralization and latency rise and fall together.
+- **Optimistic Oracle**: Best for answering complex questions and where more latency is not a huge problem. Flexible enough to resolve open-ended questions that don't have a strict binary format (e.g., "Which team won the match?").
 
 ---
 
-## Checkpoint 8: 💾 Deploy your contracts! 🛰
+## Checkpoint 8: 💾 Deploy your contract! 🛰
 
 🎉 Well done on building the optimistic oracle system! Now, let's get it on a public testnet.
 
diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index 9b2a4c17..caefc959 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -14,10 +14,18 @@ contract StakingOracle {
     error NodeNotRegistered();
     error InsufficientStake();
     error NodeAlreadyRegistered();
-    error NotEnoughStake();
     error NoRewardsAvailable();
-    error FailedToSendReward();
+    error FailedToSend();
     error NoValidPricesAvailable();
+    error OnlyPastBucketsAllowed();
+    error NodeAlreadySlashed();
+    error AlreadyReportedInCurrentBucket();
+    error NotDeviated();
+    error WaitingPeriodNotOver();
+    error NodeDidNotReport();
+    error InvalidPrice();
+    error IndexOutOfBounds();
+    error NodeNotAtGivenIndex();
 
     //////////////////////
     /// State Variables //
@@ -26,30 +34,44 @@ contract StakingOracle {
     ORA public oracleToken;
 
     struct OracleNode {
-        address nodeAddress;
         uint256 stakedAmount;
-        uint256 lastReportedPrice;
-        uint256 lastReportedTimestamp;
-        uint256 lastClaimedTimestamp;
-        uint256 lastSlashedTimestamp;
+        uint256 lastReportedBucket;
+        uint256 reportCount;
+        uint256 claimedReportCount;
+        uint256 firstBucket; // block when node registered
+        bool active;
+    }
+
+    struct TimeBucket {
+        mapping(address => uint256) prices;
+        mapping(address => bool) slashedOffenses;
+        uint256 countReports;
+        uint256 sumPrices;
     }
 
     mapping(address => OracleNode) public nodes;
+    mapping(uint256 => TimeBucket) public timeBuckets; // one bucket per 24 blocks
     address[] public nodeAddresses;
 
     uint256 public constant MINIMUM_STAKE = 1 ether;
-    uint256 public constant STALE_DATA_WINDOW = 24 seconds;
+    uint256 public constant BUCKET_WINDOW = 24 seconds;
     uint256 public constant SLASHER_REWARD_PERCENTAGE = 10;
+    uint256 public constant REWARD_PER_REPORT = 1 ether; // ORA Token reward per report
+    uint256 public constant INACTIVITY_PENALTY = 0.01 ether;
+    uint256 public constant MISREPORT_PENALTY = 1 ether;
+    uint256 public constant MAX_DEVIATION_BPS = 1000; // 10% default threshold
+    uint256 public constant WAITING_PERIOD = 2; // 2 buckets
 
     ////////////////
     /// Events /////
     ////////////////
 
     event NodeRegistered(address indexed node, uint256 stakedAmount);
-    event PriceReported(address indexed node, uint256 price);
+    event PriceReported(address indexed node, uint256 price, uint256 bucketNumber);
     event NodeSlashed(address indexed node, uint256 amount);
     event NodeRewarded(address indexed node, uint256 amount);
-    event NodesValidated();
+    event StakeAdded(address indexed node, uint256 amount);
+    event NodeExited(address indexed node, uint256 amount);
 
     address public oracleTokenAddress;
 
@@ -62,7 +84,7 @@ contract StakingOracle {
      * @dev Checks if the sender has a registered node in the mapping
      */
     modifier onlyNode() {
-        if (nodes[msg.sender].nodeAddress == address(0)) revert NodeNotRegistered();
+        if (nodes[msg.sender].active == false) revert NodeNotRegistered();
         _;
     }
 
@@ -84,91 +106,249 @@ contract StakingOracle {
      *      Requires minimum stake amount and prevents duplicate registrations.
      * @param initialPrice The initial price value this oracle node will report
      */
-    function registerNode(uint256 initialPrice) public payable {}
+    function registerNode(uint256 initialPrice) public payable {
+        if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
+        if (nodes[msg.sender].active) revert NodeAlreadyRegistered();
+        nodes[msg.sender] = OracleNode({
+            stakedAmount: msg.value,
+            lastReportedBucket: 0, // updated in reportPrice
+            reportCount: 0,
+            claimedReportCount: 0,
+            firstBucket: getCurrentBucketNumber(),
+            active: true
+        });
+        nodeAddresses.push(msg.sender);
+        reportPrice(initialPrice);
+        emit NodeRegistered(msg.sender, msg.value);
+    }
 
     /**
      * @notice Updates the price reported by an oracle node (only registered nodes)
-     * @dev Updates the node's lastReportedPrice and timestamp. Requires sufficient stake.
+     * @dev Updates the node's lastReportedBucket and price in that bucket. Requires sufficient stake.
      * @param price The new price value to report
      */
-    function reportPrice(uint256 price) public onlyNode {}
+    function reportPrice(uint256 price) public onlyNode {
+        if (price == 0) revert InvalidPrice();
+        OracleNode storage node = nodes[msg.sender];
+        if (getEffectiveStake(msg.sender) < MINIMUM_STAKE) revert InsufficientStake();
+        if (node.lastReportedBucket == getCurrentBucketNumber()) revert AlreadyReportedInCurrentBucket();
+        TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber()];
+        bucket.prices[msg.sender] = price;
+        bucket.countReports++;
+        bucket.sumPrices += price;
+        
+        node.lastReportedBucket = getCurrentBucketNumber();
+        node.reportCount++;
+        emit PriceReported(msg.sender, price, getCurrentBucketNumber());
+    }
+
+    /**
+     * @notice Allows active and inactive nodes to claim accumulated ORA token rewards
+     * @dev Calculates rewards based on time elapsed since last claim.
+     */
+    function claimReward() public {
+        OracleNode storage node = nodes[msg.sender];
+
+        uint256 delta = node.reportCount - node.claimedReportCount;
+        if (delta == 0) revert NoRewardsAvailable();
+
+        node.claimedReportCount = node.reportCount;
+        oracleToken.mint(msg.sender, delta * REWARD_PER_REPORT);
+        emit NodeRewarded(msg.sender, delta * REWARD_PER_REPORT);
+    }
 
     /**
-     * @notice Allows registered nodes to claim accumulated ORA token rewards
-     * @dev Calculates rewards based on time elapsed since last claim. Slashed nodes
-     *      can only claim rewards up to their last slash timestamp.
+     * @notice Allows a registered node to increase its stake
+     * @dev Increases the sender's stakedAmount by msg.value
      */
-    function claimReward() public onlyNode {}
+    function addStake() public payable onlyNode {
+        if (msg.value == 0) revert InsufficientStake();
+        nodes[msg.sender].stakedAmount += msg.value;
+        emit StakeAdded(msg.sender, msg.value);
+    }
 
     /**
-     * @notice Public function to slash all nodes with stale data and reward the caller
-     * @dev Identifies stale nodes, slashes them, and sends accumulated slasher rewards to caller.
-     *      Anyone can call this function to maintain oracle data freshness.
+     * @notice Slashes a node for giving a price that is deviated too far from the average excluding it's own reported price
      */
-    function slashNodes() public {}
+    function slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index) public {
+        if (!nodes[nodeToSlash].active) revert NodeNotRegistered();
+        if (getCurrentBucketNumber() == bucketNumber) revert OnlyPastBucketsAllowed();
+        TimeBucket storage bucket = timeBuckets[bucketNumber];
+        if (bucket.slashedOffenses[nodeToSlash]) revert NodeAlreadySlashed();
+        uint256 reportedPrice = bucket.prices[nodeToSlash];
+        if (reportedPrice == 0) revert NodeDidNotReport();
+        bucket.slashedOffenses[nodeToSlash] = true;
+        // Remove the price from the sum and count
+        bucket.sumPrices -= reportedPrice;
+        bucket.countReports--;
+        uint256 averagePrice = bucket.sumPrices / bucket.countReports;
+        // Check if the price deviation is greater than the threshold
+        if (!_checkPriceDeviated(reportedPrice, averagePrice)) {
+            revert NotDeviated();
+        }
+        OracleNode storage node = nodes[nodeToSlash];
+        // Slash the node
+        uint256 actualPenalty = MISREPORT_PENALTY > node.stakedAmount ? node.stakedAmount : MISREPORT_PENALTY;
+        node.stakedAmount -= actualPenalty;
+
+        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
+
+        (bool sent, ) = msg.sender.call{ value: reward }("");
+        if (!sent) revert FailedToSend();
+
+        if (node.stakedAmount == 0) {
+            _removeNode(nodeToSlash, index);
+            emit NodeExited(nodeToSlash, 0);
+        }
+
+        emit NodeSlashed(nodeToSlash, actualPenalty);
+    }
+
+    function exitNode(uint256 index) public onlyNode {
+        OracleNode storage node = nodes[msg.sender];
+        if (node.lastReportedBucket + WAITING_PERIOD > getCurrentBucketNumber()) revert WaitingPeriodNotOver();
+        // Get effective stake before removing node (since getEffectiveStake returns 0 for inactive nodes)
+        uint256 stake = getEffectiveStake(msg.sender);
+        _removeNode(msg.sender, index);
+        // Withdraw the stake
+        delete nodes[msg.sender];
+        (bool sent, ) = msg.sender.call{ value: stake }("");
+        if (!sent) revert FailedToSend();
+    
+        emit NodeExited(msg.sender, stake);
+    }
 
     ////////////////////////
     /// View Functions /////
     ////////////////////////
 
+    /**
+     * @notice Returns the list of registered oracle node addresses
+     * @return Array of registered oracle node addresses
+     */
+    function getNodeAddresses() public view returns (address[] memory) {
+        return nodeAddresses;
+    }
+
     /**
      * @notice Returns the aggregated price from all active oracle nodes using median calculation
      * @dev Filters out stale nodes, extracts their prices, sorts them, and calculates median.
      *      Uses StatisticsUtils for sorting and median calculation.
      * @return The median price from all nodes with fresh data
      */
-    function getPrice() public view returns (uint256) {}
+    function getLatestPrice() public view returns (uint256) {
+        TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber() - 1];
+        if (bucket.countReports == 0) revert NoValidPricesAvailable();
+        return bucket.sumPrices / bucket.countReports;
+    }
 
     /**
-     * @notice Separates oracle nodes into fresh and stale categories based on data recency
-     * @dev Checks each node's last reported timestamp against the STALE_DATA_WINDOW.
-     *      Returns two arrays with fresh and stale node addresses respectively.
-     * @param nodesToSeparate Array of node addresses to categorize
-     * @return fresh Array of addresses with recent data (within STALE_DATA_WINDOW)
-     * @return stale Array of addresses with stale data (older than STALE_DATA_WINDOW)
+     * @notice Returns the average price from a past bucket
+     * @param bucketNumber The bucket number to get the average price from
+     * @return The average price from the bucket
      */
-    function separateStaleNodes(
-        address[] memory nodesToSeparate
-    ) public view returns (address[] memory fresh, address[] memory stale) {}
+    function getPastPrice(uint256 bucketNumber) public view returns (uint256) {
+        TimeBucket storage bucket = timeBuckets[bucketNumber];
+        if (bucket.countReports == 0) revert NoValidPricesAvailable();
+        return bucket.sumPrices / bucket.countReports;
+    }
+
+    function getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber) public view returns (uint256, bool) {
+        TimeBucket storage bucket = timeBuckets[bucketNumber];
+        return (bucket.prices[nodeAddress], bucket.slashedOffenses[nodeAddress]);
+    }
 
     /**
-     * @notice Returns the array of all registered oracle node addresses
-     * @dev Provides access to the complete list of node addresses for external monitoring
-     * @return Array of all registered node addresses
+     * @notice Returns the current bucket number
+     * @dev Returns the current bucket number based on the block number
+     * @return The current bucket number
      */
-    function getNodeAddresses() public view returns (address[] memory) {
-        return nodeAddresses;
+    function getCurrentBucketNumber() public view returns (uint256) {
+        return (block.number / BUCKET_WINDOW) + 1;
     }
 
-    ////////////////////////
-    /// Internal Helpers ///
-    ////////////////////////
-
     /**
-     * @notice Internal function to mint oracle tokens as rewards to a node
-     * @dev Mints ORA tokens to the specified node address and emits reward event
-     * @param nodeAddress The address of the node to reward
-     * @param reward The amount of ORA tokens to mint as reward
+     * @notice Returns the effective stake accounting for inactivity penalties via missed buckets
+     * @dev Effective stake = stakedAmount - (missedBuckets * INACTIVITY_PENALTY), floored at 0
      */
-    function rewardNode(address nodeAddress, uint256 reward) internal {}
+    function getEffectiveStake(address nodeAddress) public view returns (uint256) {
+        OracleNode memory n = nodes[nodeAddress];
+        if (!n.active) return 0;
+        uint256 currentBucket = getCurrentBucketNumber();
+        if (currentBucket == n.firstBucket) return n.stakedAmount;
+        // Expected reports are only for fully completed buckets since registration (exclude current bucket)
+        uint256 expectedReports = currentBucket - n.firstBucket;
+        // Do not assume future reports; penalize only after a bucket has passed
+        uint256 actualReportsCompleted = n.reportCount;
+        // Exclude a report made in the current bucket from completed reports to avoid reducing past penalties
+        if (n.lastReportedBucket == currentBucket && actualReportsCompleted > 0) {
+            actualReportsCompleted -= 1;
+        }
+        if (actualReportsCompleted >= expectedReports) return n.stakedAmount; // no penalty if on target
+        uint256 missed = expectedReports - actualReportsCompleted;
+        uint256 penalty = missed * INACTIVITY_PENALTY;
+        if (penalty > n.stakedAmount) return 0;
+        return n.stakedAmount - penalty;
+    }
 
     /**
-     * @notice Internal function to slash a node's stake for providing stale data
-     * @dev Reduces the node's staked amount and calculates slasher reward as percentage of penalty.
-     *      Cannot slash more than the node's current stake.
-     * @param nodeToSlash The address of the node to penalize
-     * @param penalty The amount of ETH to slash from the node's stake
-     * @return The reward amount for the slasher (percentage of actual penalty)
+     * @notice Returns the addresses of nodes in a bucket whose reported price deviates beyond the threshold
+     * @param bucketNumber The bucket number to get the outliers from
+     * @return Array of node addresses considered outliers
      */
-    function slashNode(address nodeToSlash, uint256 penalty) internal returns (uint256) {}
+    function getOutlierNodes(uint256 bucketNumber) public view returns (address[] memory) {
+        TimeBucket storage bucket = timeBuckets[bucketNumber];
+        address[] memory outliers = new address[](bucket.countReports);
+        uint256 outlierCount = 0;
+        for (uint256 i = 0; i < nodeAddresses.length; i++) {
+            address nodeAddress = nodeAddresses[i];
+            uint256 reportedPrice = bucket.prices[nodeAddress];
+            if (reportedPrice == 0) continue;
+            uint256 averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1);
+            // Check if the price deviation is greater than the threshold
+            if (_checkPriceDeviated(reportedPrice, averagePrice)) {
+                outliers[outlierCount] = nodeAddress;
+                outlierCount++;
+            }
+        }
+        address[] memory trimmed = new address[](outlierCount);
+        for (uint256 i = 0; i < outlierCount; i++) {
+            trimmed[i] = outliers[i];
+        }
+        return trimmed;
+    }
+
+    //////////////////////////
+    /// Internal Functions ///
+    //////////////////////////
 
     /**
-     * @notice Internal function to extract price values from an array of node addresses
-     * @dev Iterates through provided addresses and retrieves their last reported prices
-     * @param addresses Array of node addresses to get prices from
-     * @return Array of price values corresponding to the input addresses
+     * @notice Removes a node from the nodeAddresses array
+     * @param nodeAddress The address of the node to remove
+     * @param index The index of the node to remove
      */
-    function getPricesFromAddresses(address[] memory addresses) internal view returns (uint256[] memory) {}
+    function _removeNode(address nodeAddress, uint256 index) internal {
+        if (nodeAddresses.length <= index) revert IndexOutOfBounds();
+        if (nodeAddresses[index] != nodeAddress) revert NodeNotAtGivenIndex();
+        // Pop and swap pattern
+        nodeAddresses[index] = nodeAddresses[nodeAddresses.length - 1];
+        nodeAddresses.pop();
+        // Set the node to inactive
+        nodes[nodeAddress].active = false;
+    }
 
-    // Notably missing a way to unstake and exit your node but not needed for the challenge
+    /**
+     * @notice Checks if the price deviation is greater than the threshold
+     * @param reportedPrice The price reported by the node
+     * @param averagePrice The average price of the bucket
+     * @return True if the price deviation is greater than the threshold, false otherwise
+     */
+    function _checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice) internal pure returns (bool) {
+        uint256 deviation = reportedPrice > averagePrice ? reportedPrice - averagePrice : averagePrice - reportedPrice;
+        uint256 deviationBps = (deviation * 10_000) / averagePrice;
+        if (deviationBps > MAX_DEVIATION_BPS) {
+            return true;
+        }
+        return false;
+    }
 }
diff --git a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
index e381ad11..082ab172 100644
--- a/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
+++ b/extension/packages/hardhat/contracts/02_Optimistic/OptimisticOracle.sol
@@ -21,7 +21,7 @@ contract OptimisticOracle {
 
     error AssertionNotFound();
     error AssertionProposed();
-    error NotEnoughValue();
+    error InvalidValue();
     error InvalidTime();
     error ProposalDisputed();
     error NotProposedAssertion();
@@ -53,7 +53,7 @@ contract OptimisticOracle {
     }
 
     uint256 public constant MINIMUM_ASSERTION_WINDOW = 3 minutes;
-    uint256 public constant MINIMUM_DISPUTE_WINDOW = 3 minutes;
+    uint256 public constant DISPUTE_WINDOW = 3 minutes;
     address public decider;
     address public owner;
     uint256 public nextAssertionId = 1;
diff --git a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
index 1155a342..96a768fa 100644
--- a/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
+++ b/extension/packages/hardhat/deploy/00_deploy_whitelist.ts
@@ -35,24 +35,29 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
     const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
     if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
 
-    // Create SimpleOracle instances through WhitelistOracle.addOracle()
+    // Create SimpleOracle instances through WhitelistOracle.addOracle() concurrently
     // This creates new SimpleOracle contracts owned by the specified addresses
-    const createdOracleAddresses: string[] = [];
-
-    for (let i = 0; i < nodeAccounts.length; i++) {
-      const ownerAddress = nodeAccounts[i].account.address;
+    const nonce = await publicClient.getTransactionCount({ address: deployerAccount.account.address });
+    const addOracleTxPromises = nodeAccounts.map((nodeAccount, i) => {
+      const ownerAddress = nodeAccount.account.address;
       console.log(`Creating SimpleOracle ${i + 1}/10 with owner: ${ownerAddress}`);
-
-      // Call addOracle which creates a new SimpleOracle instance
-      const txHash = await deployerAccount.writeContract({
+      return deployerAccount.writeContract({
         address: whitelistOracleAddress,
         abi: whitelistOracleAbi,
         functionName: "addOracle",
         args: [ownerAddress],
+        nonce: nonce + i,
       });
+    });
 
-      // Wait for transaction and get the created oracle address from event
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    const addOracleTxHashes = await Promise.all(addOracleTxPromises);
+    const addOracleReceipts = await Promise.all(
+      addOracleTxHashes.map(hash => publicClient.waitForTransactionReceipt({ hash })),
+    );
+
+    // Map owner => created oracle address from events
+    const ownerToOracleAddress = new Map<string, string>();
+    for (const receipt of addOracleReceipts) {
       const oracleAddedEvent = receipt.logs.find(log => {
         try {
           const decoded = decodeEventLog({
@@ -65,42 +70,41 @@ const deployWhitelistOracleContracts: DeployFunction = async function (hre: Hard
           return false;
         }
       });
-
-      if (oracleAddedEvent) {
-        const decoded = decodeEventLog({
-          abi: whitelistOracleAbi,
-          data: oracleAddedEvent.data,
-          topics: oracleAddedEvent.topics,
-        }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
-        const oracleAddress = decoded.args.oracleAddress;
-        createdOracleAddresses.push(oracleAddress);
-        console.log(`✅ Created SimpleOracle at: ${oracleAddress}`);
-      }
+      if (!oracleAddedEvent) continue;
+      const decoded = decodeEventLog({
+        abi: whitelistOracleAbi,
+        data: oracleAddedEvent.data,
+        topics: oracleAddedEvent.topics,
+      }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
+      ownerToOracleAddress.set(decoded.args.oracleOwner.toLowerCase(), decoded.args.oracleAddress);
+      console.log(`✅ Created SimpleOracle at: ${decoded.args.oracleAddress}`);
     }
 
+    const createdOracleAddresses: string[] = nodeAccounts.map(acc => {
+      const addr = ownerToOracleAddress.get(acc.account.address.toLowerCase());
+      if (!addr) throw new Error(`Missing oracle address for owner ${acc.account.address}`);
+      return addr;
+    });
+
     // Set initial prices for each created SimpleOracle
     console.log("Setting initial prices for each SimpleOracle...");
     const initialPrice = await fetchPriceFromUniswap();
-
-    for (let i = 0; i < createdOracleAddresses.length; i++) {
-      const account = nodeAccounts[i];
-      const oracleAddress = createdOracleAddresses[i] as `0x${string}`;
-
-      // Get SimpleOracle ABI from deployments
-      const simpleOracleDeployment = await hre.deployments.getArtifact("SimpleOracle");
-      const simpleOracleAbi = simpleOracleDeployment.abi;
-
-      await account.writeContract({
-        address: oracleAddress,
+    // Get SimpleOracle ABI from deployments
+    const simpleOracleDeployment = await hre.deployments.getArtifact("SimpleOracle");
+    const simpleOracleAbi = simpleOracleDeployment.abi;
+    // Fire all setPrice transactions concurrently from each node owner
+    const setPriceTxPromises = nodeAccounts.map((account, i) => {
+      const oracleAddress = createdOracleAddresses[i];
+      return account.writeContract({
+        address: oracleAddress as `0x${string}`,
         abi: simpleOracleAbi,
         functionName: "setPrice",
         args: [initialPrice],
       });
-
-      await publicClient.transport.request({
-        method: "evm_mine",
-      });
-
+    });
+    const setPriceTxHashes = await Promise.all(setPriceTxPromises);
+    await Promise.all(setPriceTxHashes.map(hash => publicClient.waitForTransactionReceipt({ hash })));
+    for (let i = 0; i < createdOracleAddresses.length; i++) {
       console.log(`Set price for SimpleOracle ${i + 1} to: ${initialPrice}`);
     }
 
diff --git a/extension/packages/hardhat/deploy/01_deploy_staking.ts b/extension/packages/hardhat/deploy/01_deploy_staking.ts
index 4386d412..ddb87097 100644
--- a/extension/packages/hardhat/deploy/01_deploy_staking.ts
+++ b/extension/packages/hardhat/deploy/01_deploy_staking.ts
@@ -57,31 +57,6 @@ const deployStakingOracle: DeployFunction = async function (hre: HardhatRuntimeE
         throw error;
       }
     }
-
-    const nodeAddresses = await publicClient.readContract({
-      address: stakingOracleAddress,
-      abi: deployment.abi,
-      functionName: "getNodeAddresses",
-      args: [],
-    });
-
-    // Map node addresses to their corresponding wallet clients
-    const nodeWalletClients = nodeAddresses
-      .map(nodeAddress => {
-        return nodeAccounts.find(client => client.account.address === nodeAddress);
-      })
-      .filter(client => client !== undefined);
-
-    await Promise.all(
-      nodeWalletClients.map(walletClient => {
-        return walletClient.writeContract({
-          address: stakingOracleAddress,
-          abi: deployment.abi,
-          functionName: "reportPrice",
-          args: [initialPrice],
-        });
-      }),
-    );
   }
 };
 
diff --git a/extension/packages/hardhat/deploy/02_deploy_optimistic.ts b/extension/packages/hardhat/deploy/02_deploy_optimistic.ts
index dc756783..a00ff5df 100644
--- a/extension/packages/hardhat/deploy/02_deploy_optimistic.ts
+++ b/extension/packages/hardhat/deploy/02_deploy_optimistic.ts
@@ -19,9 +19,8 @@ const deployOptimisticOracle: DeployFunction = async function (hre: HardhatRunti
   const optimisticOracle = await deploy("OptimisticOracle", {
     contract: "OptimisticOracle",
     from: deployer,
-    args: [futureDeciderAddress], // Use deployer as temporary decider
+    args: [futureDeciderAddress],
     log: true,
-    autoMine: true,
   });
 
   // Deploy the Decider contract
@@ -30,7 +29,6 @@ const deployOptimisticOracle: DeployFunction = async function (hre: HardhatRunti
     from: deployer,
     args: [optimisticOracle.address],
     log: true,
-    autoMine: true,
   });
 
   // Check if the decider address matches the expected address
diff --git a/extension/packages/hardhat/hardhat.config.ts.args.mjs b/extension/packages/hardhat/hardhat.config.ts.args.mjs
index 5d4d972a..edd7ffcd 100644
--- a/extension/packages/hardhat/hardhat.config.ts.args.mjs
+++ b/extension/packages/hardhat/hardhat.config.ts.args.mjs
@@ -1,3 +1,14 @@
 export const preContent = `
 import "@nomicfoundation/hardhat-viem";
 `;
+
+export const configOverrides = {
+    networks: {
+      hardhat: {
+        mining: {
+            auto: false,
+            interval: 1000,
+        }
+      },
+    },
+  };
diff --git a/extension/packages/hardhat/scripts/oracle-bot/config.json b/extension/packages/hardhat/scripts/oracle-bot/config.json
index 6c28ebb5..a2b95667 100644
--- a/extension/packages/hardhat/scripts/oracle-bot/config.json
+++ b/extension/packages/hardhat/scripts/oracle-bot/config.json
@@ -1,7 +1,7 @@
 {
   "PRICE": {
-    "CACHEDPRICE": 4428.637518892757,
-    "TIMESTAMP": 1757587491421
+    "CACHEDPRICE": 4000,
+    "TIMESTAMP": 1761680177006
   },
   "INTERVALS": {
     "PRICE_REPORT": 1750,
@@ -13,44 +13,44 @@
       "PRICE_VARIANCE": 0
     },
     "0x70997970c51812dc3a010c7d01b50e0d17dc79c8": {
-      "PROBABILITY_OF_SKIPPING_REPORT": 0.5,
-      "PRICE_VARIANCE": 0.02
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0
     },
     "0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc": {
-      "PROBABILITY_OF_SKIPPING_REPORT": 1,
-      "PRICE_VARIANCE": 0.04
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0
     },
     "0x976ea74026e726554db657fa54763abd0c3a0aa9": {
-      "PROBABILITY_OF_SKIPPING_REPORT": 0.5,
-      "PRICE_VARIANCE": 0.03
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0
     },
     "0x90f79bf6eb2c4f870365e785982e1f101e93b906": {
       "PROBABILITY_OF_SKIPPING_REPORT": 0,
-      "PRICE_VARIANCE": 0.01
+      "PRICE_VARIANCE": 0
     },
     "0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc": {
       "PROBABILITY_OF_SKIPPING_REPORT": 0,
-      "PRICE_VARIANCE": 0.035
+      "PRICE_VARIANCE": 0
     },
     "0x15d34aaf54267db7d7c367839aaf71a00a2c6a65": {
-      "PROBABILITY_OF_SKIPPING_REPORT": 0.59,
-      "PRICE_VARIANCE": 0.045
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
+      "PRICE_VARIANCE": 0
     },
     "0xbcd4042de499d14e55001ccbb24a551f3b954096": {
       "PROBABILITY_OF_SKIPPING_REPORT": 0,
-      "PRICE_VARIANCE": 0.73
+      "PRICE_VARIANCE": 0
     },
     "0x14dc79964da2c08b23698b3d3cc7ca32193d9955": {
       "PROBABILITY_OF_SKIPPING_REPORT": 0,
-      "PRICE_VARIANCE": 0.025
+      "PRICE_VARIANCE": 0
     },
     "0x23618e81e3f5cdf7f54c3d65f7fbc0abf5b21e8f": {
-      "PROBABILITY_OF_SKIPPING_REPORT": 1,
+      "PROBABILITY_OF_SKIPPING_REPORT": 0,
       "PRICE_VARIANCE": 0
     },
     "0xa0ee7a142d267c1f36714e4a8f75612f20a79720": {
       "PROBABILITY_OF_SKIPPING_REPORT": 0,
-      "PRICE_VARIANCE": 0.05
+      "PRICE_VARIANCE": 0
     }
   }
-}
\ No newline at end of file
+}
diff --git a/extension/packages/hardhat/scripts/runOptimisticBots.ts b/extension/packages/hardhat/scripts/runOptimisticBots.ts
index 6b142ead..a47a2c43 100644
--- a/extension/packages/hardhat/scripts/runOptimisticBots.ts
+++ b/extension/packages/hardhat/scripts/runOptimisticBots.ts
@@ -1,7 +1,7 @@
 import { deployments, ethers } from "hardhat";
 import hre from "hardhat";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
-import { cleanup, getRandomQuestion, sleep } from "./utils";
+import { getRandomQuestion, sleep } from "./utils";
 import { WalletClient } from "@nomicfoundation/hardhat-viem/types";
 import { Deployment } from "hardhat-deploy/types";
 import { zeroAddress } from "viem";
@@ -177,8 +177,6 @@ const runCycle = async (
     const optimisticOracle = await ethers.getContractAt("OptimisticOracle", optimisticDeployment.address);
     const publicClient = await hre.viem.getPublicClient();
 
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
-
     // get current timestamp
     const latestBlock = await publicClient.getBlock();
     const currentTimestamp = latestBlock.timestamp;
@@ -211,8 +209,6 @@ const runCycle = async (
       );
     }
     currentAction = (currentAction + 1) % 3;
-    await publicClient.transport.request({ method: "evm_mine" });
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
   } catch (error) {
     console.error("Error in oracle cycle:", error);
     throw error;
@@ -241,26 +237,22 @@ run().catch(error => {
 // Handle process termination signals
 process.on("SIGINT", async () => {
   console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 process.on("SIGTERM", async () => {
   console.log("\nReceived SIGTERM. Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 // Handle uncaught exceptions
 process.on("uncaughtException", async error => {
   console.error("Uncaught Exception:", error);
-  await cleanup();
   process.exit(1);
 });
 
 // Handle unhandled promise rejections
 process.on("unhandledRejection", async (reason, promise) => {
   console.error("Unhandled Rejection at:", promise, "reason:", reason);
-  await cleanup();
   process.exit(1);
 });
diff --git a/extension/packages/hardhat/scripts/runStakingOracleBots.ts b/extension/packages/hardhat/scripts/runStakingOracleBots.ts
index 8be48b1b..86dfd0f1 100644
--- a/extension/packages/hardhat/scripts/runStakingOracleBots.ts
+++ b/extension/packages/hardhat/scripts/runStakingOracleBots.ts
@@ -1,23 +1,319 @@
-import { reportPrices } from "./oracle-bot/reporting";
-import { claimRewards, validateNodes } from "./oracle-bot/validation";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import hre from "hardhat";
-import { cleanup, sleep } from "./utils";
+import { sleep, getConfig } from "./utils";
+import { parseEther } from "viem";
+import { fetchPriceFromUniswap } from "./fetchPriceFromUniswap";
 
-const runCycle = async (hre: HardhatRuntimeEnvironment) => {
+type WalletClient = Awaited<ReturnType<typeof hre.viem.getWalletClients>>[number];
+
+const normalizeNodeInfo = (raw: any) => {
+  const zero = 0n;
+  if (!raw)
+    return {
+      stakedAmount: zero,
+      lastReportedBucket: zero,
+      reportCount: zero,
+      claimedReportCount: zero,
+      firstBucket: zero,
+      active: false,
+    };
+  const get = (idx: number, name: string) => {
+    const byName = raw[name];
+    const byIndex = Array.isArray(raw) ? raw[idx] : undefined;
+    if (typeof byName === "bigint") return byName as bigint;
+    if (typeof byIndex === "bigint") return byIndex as bigint;
+    const val = byName ?? byIndex ?? 0;
+    try {
+      return BigInt(String(val));
+    } catch {
+      return zero;
+    }
+  };
+  return {
+    stakedAmount: get(0, "stakedAmount"),
+    lastReportedBucket: get(1, "lastReportedBucket"),
+    reportCount: get(2, "reportCount"),
+    claimedReportCount: get(3, "claimedReportCount"),
+    firstBucket: get(4, "firstBucket"),
+  };
+};
+
+// Current base price used by the bot. Initialized once at start from Uniswap
+// and updated from on-chain contract prices thereafter.
+let currentPrice: bigint | null = null;
+
+const stringToBool = (value: string | undefined | null): boolean => {
+  if (!value) return false;
+  const normalized = value.toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+};
+
+// Feature flag: enable automatic slashing when the AUTO_SLASH environment variable is truthy
+const AUTO_SLASH: boolean = stringToBool(process.env.AUTO_SLASH);
+
+const getStakingOracleDeployment = async (runtime: HardhatRuntimeEnvironment) => {
+  const deployment = await runtime.deployments.get("StakingOracle");
+  return {
+    address: deployment.address as `0x${string}`,
+    abi: deployment.abi,
+  } as const;
+};
+
+const getActiveNodeWalletClients = async (
+  runtime: HardhatRuntimeEnvironment,
+  stakingAddress: `0x${string}`,
+  stakingAbi: any,
+): Promise<WalletClient[]> => {
+  const accounts = await runtime.viem.getWalletClients();
+  // Filter to only those that are registered (firstBucket != 0)
+  const publicClient = await runtime.viem.getPublicClient();
+  const nodeClients: WalletClient[] = [];
+  for (const client of accounts) {
+    try {
+      const rawNodeInfo = await publicClient.readContract({
+        address: stakingAddress,
+        abi: stakingAbi,
+        functionName: "nodes",
+        args: [client.account.address],
+      });
+      const node = normalizeNodeInfo(rawNodeInfo);
+      if (node.firstBucket !== 0n) {
+        nodeClients.push(client);
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return nodeClients;
+};
+
+const findNodeIndex = async (
+  runtime: HardhatRuntimeEnvironment,
+  stakingAddress: `0x${string}`,
+  stakingAbi: any,
+  nodeAddress: `0x${string}`,
+): Promise<number | null> => {
+  const publicClient = await runtime.viem.getPublicClient();
+  // Iterate indices until out-of-bounds revert
   try {
-    const publicClient = await hre.viem.getPublicClient();
+    const addresses = (await publicClient.readContract({
+      address: stakingAddress,
+      abi: stakingAbi,
+      functionName: "getNodeAddresses",
+      args: [],
+    })) as `0x${string}`[];
+    return addresses.findIndex(addr => addr.toLowerCase() === nodeAddress.toLowerCase());
+  } catch {}
+  return null;
+};
+
+const runCycle = async (runtime: HardhatRuntimeEnvironment) => {
+  try {
+    const { address, abi } = await getStakingOracleDeployment(runtime);
+    const publicClient = await runtime.viem.getPublicClient();
+    const allWalletClients = await runtime.viem.getWalletClients();
     const blockNumber = await publicClient.getBlockNumber();
     console.log(`\n[Block ${blockNumber}] Starting new oracle cycle...`);
 
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
-    await reportPrices(hre);
-    await publicClient.transport.request({ method: "evm_mine" });
+    // Read current bucket window and bucket number
+    const [bucketWindow, currentBucket] = await Promise.all([
+      publicClient
+        .readContract({ address, abi, functionName: "BUCKET_WINDOW", args: [] })
+        .then(value => BigInt(String(value))),
+      publicClient
+        .readContract({ address, abi, functionName: "getCurrentBucketNumber", args: [] })
+        .then(value => BigInt(String(value))),
+    ]);
+    const previousBucket = currentBucket > 0n ? currentBucket - 1n : 0n;
+    console.log(`BUCKET_WINDOW=${bucketWindow} | currentBucket=${currentBucket}`);
 
-    await validateNodes(hre);
-    await claimRewards(hre);
-    await publicClient.transport.request({ method: "evm_mine" });
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
+    // Update base price from previous bucket, excluding slashable and already-slashed reports.
+    // Fallback to contract's latest price, then to previous cached value.
+    try {
+      // Determine adjusted average from the previous bucket excluding outliers and slashed reports
+      const previous = previousBucket;
+      if (previous > 0n) {
+        let adjustedAvg: bigint | null = null;
+        try {
+          const [outliers, nodeAddresses] = await Promise.all([
+            publicClient.readContract({ address, abi, functionName: "getOutlierNodes", args: [previous] }) as Promise<
+              `0x${string}`[]
+            >,
+            publicClient.readContract({ address, abi, functionName: "getNodeAddresses", args: [] }) as Promise<
+              `0x${string}`[]
+            >,
+          ]);
+          const outlierSet = new Set(outliers.map(a => a.toLowerCase()));
+          const dataForNodes = await Promise.all(
+            nodeAddresses.map(async nodeAddr => {
+              try {
+                const result: any = await publicClient.readContract({
+                  address,
+                  abi,
+                  functionName: "getAddressDataAtBucket",
+                  args: [nodeAddr, previous],
+                });
+                // result could be array-like [price, slashed] or object with named props
+                const priceVal = Array.isArray(result) ? result[0] : (result?.[0] ?? result?.price);
+                const slashedVal = Array.isArray(result) ? result[1] : (result?.[1] ?? result?.slashed);
+                const price = BigInt(String(priceVal ?? 0));
+                const slashed = Boolean(slashedVal);
+                return { nodeAddr, price, slashed } as const;
+              } catch {
+                return { nodeAddr, price: 0n, slashed: false } as const;
+              }
+            }),
+          );
+          const valid = dataForNodes.filter(
+            d => d.price > 0n && !d.slashed && !outlierSet.has(d.nodeAddr.toLowerCase()),
+          );
+          if (valid.length > 0) {
+            const sum = valid.reduce((acc, d) => acc + d.price, 0n);
+            adjustedAvg = sum / BigInt(valid.length);
+          }
+        } catch {
+          // ignore and fall back
+        }
+
+        if (adjustedAvg !== null) {
+          currentPrice = adjustedAvg;
+        } else {
+          // Fallback to on-chain latest average (previous bucket average)
+          try {
+            const onchain = await publicClient.readContract({ address, abi, functionName: "getLatestPrice", args: [] });
+            currentPrice = BigInt(String(onchain));
+          } catch {
+            // keep prior currentPrice
+          }
+        }
+      }
+    } catch {
+      // keep prior currentPrice
+    }
+
+    // Load config once per cycle so runtime edits to the config file are picked up
+    const cfg = getConfig();
+
+    // 1) Reporting: each node only once per bucket
+    const nodeWalletClients = await getActiveNodeWalletClients(runtime, address, abi);
+    // Ensure we have an initial price (set once at startup in run())
+    if (currentPrice === null) {
+      currentPrice = await fetchPriceFromUniswap();
+    }
+    const reportTxHashes: `0x${string}`[] = [];
+    for (const client of nodeWalletClients) {
+      try {
+        const rawNodeInfo = await publicClient.readContract({
+          address,
+          abi,
+          functionName: "nodes",
+          args: [client.account.address],
+        });
+        const node = normalizeNodeInfo(rawNodeInfo);
+        if (node.lastReportedBucket !== currentBucket) {
+          // Determine node config (probability to skip and variance)
+          const nodeCfg = cfg.NODE_CONFIGS[client.account.address.toLowerCase()] || cfg.NODE_CONFIGS.default;
+          const skipProb = Number(nodeCfg.PROBABILITY_OF_SKIPPING_REPORT ?? 0);
+          if (Math.random() < skipProb) {
+            console.log(`Skipping report (by probability) for ${client.account.address}`);
+            continue;
+          }
+          // Compute deviated price as integer math using parts-per-million (ppm)
+          const variancePpm = Math.floor((Number(nodeCfg.PRICE_VARIANCE) || 0) * 1_000_000);
+          const randomPpm = variancePpm > 0 ? Math.floor(Math.random() * (variancePpm * 2 + 1)) - variancePpm : 0;
+          const basePrice = currentPrice!; // derived from previous bucket excluding outliers
+          const delta = (basePrice * BigInt(randomPpm)) / 1_000_000n;
+          const priceToReport = basePrice + delta;
+
+          console.log(
+            `Reporting price for node ${client.account.address} in bucket ${currentBucket} (price=${priceToReport})...`,
+          );
+          const txHash = await client.writeContract({
+            address,
+            abi,
+            functionName: "reportPrice",
+            args: [priceToReport],
+          });
+          reportTxHashes.push(txHash as `0x${string}`);
+        }
+      } catch (err) {
+        console.warn(`Skipping report for ${client.account.address}:`, (err as Error).message);
+      }
+    }
+
+    // Wait for report transactions to be mined so subsequent reads (claiming) see the updated state.
+    if (reportTxHashes.length > 0) {
+      try {
+        await Promise.all(reportTxHashes.map(hash => publicClient.waitForTransactionReceipt({ hash } as any)));
+      } catch (err) {
+        // If waiting fails, continue — claims will be attempted anyway but may not see the latest reports.
+        console.warn("Error while waiting for report tx receipts:", (err as Error).message);
+      }
+    }
+
+    // 2) Slashing: if previous bucket had outliers
+    if (AUTO_SLASH) {
+      try {
+        const outliers = (await publicClient.readContract({
+          address,
+          abi,
+          functionName: "getOutlierNodes",
+          args: [previousBucket],
+        })) as `0x${string}`[];
+
+        if (outliers.length > 0) {
+          console.log(`Found ${outliers.length} outliers in bucket ${previousBucket}, attempting to slash...`);
+          // Use the first wallet (deployer) to slash
+          const slasher = allWalletClients[0];
+          for (const nodeAddr of outliers) {
+            const index = await findNodeIndex(runtime, address, abi, nodeAddr);
+            if (index === null) {
+              console.warn(`Index not found for node ${nodeAddr}, skipping slashing.`);
+              continue;
+            }
+            try {
+              await slasher.writeContract({
+                address,
+                abi,
+                functionName: "slashNode",
+                args: [nodeAddr, previousBucket, index],
+              });
+              console.log(`Slashed node ${nodeAddr} for bucket ${previousBucket} at index ${index}`);
+            } catch (err) {
+              console.warn(`Failed to slash ${nodeAddr}:`, (err as Error).message);
+            }
+          }
+        }
+      } catch (err) {
+        // getOutlierNodes may revert for small sample sizes (e.g., 0 or 1 report)
+        console.log(`Skipping slashing check for bucket ${previousBucket}:`, (err as Error).message);
+      }
+    } else {
+      // Auto-slash disabled by flag
+      console.log(`Auto-slash disabled; skipping slashing for bucket ${previousBucket}`);
+    }
+
+    // 3) Rewards: claim when there are unclaimed reports
+    // Wait a couple seconds after reports have been mined before claiming
+    console.log("Waiting 2s before claiming rewards...");
+    await sleep(2000);
+    for (const client of nodeWalletClients) {
+      try {
+        const rawNodeInfo = await publicClient.readContract({
+          address,
+          abi,
+          functionName: "nodes",
+          args: [client.account.address],
+        });
+        const node = normalizeNodeInfo(rawNodeInfo);
+        if (node.reportCount > node.claimedReportCount) {
+          await client.writeContract({ address, abi, functionName: "claimReward", args: [] });
+          console.log(`Claimed rewards for ${client.account.address}`);
+        }
+      } catch (err) {
+        console.warn(`Failed to claim rewards for ${client.account.address}:`, (err as Error).message);
+      }
+    }
   } catch (error) {
     console.error("Error in oracle cycle:", error);
   }
@@ -25,9 +321,69 @@ const runCycle = async (hre: HardhatRuntimeEnvironment) => {
 
 const run = async () => {
   console.log("Starting oracle bot system...");
+  // Fetch Uniswap price once at startup; subsequent cycles will base price on on-chain reports
+  currentPrice = await fetchPriceFromUniswap();
+  console.log(`Initial base price from Uniswap: ${currentPrice}`);
+
+  // Spin up nodes (register) for local testing if they aren't registered yet.
+  try {
+    const { address, abi } = await getStakingOracleDeployment(hre);
+    const publicClient = await hre.viem.getPublicClient();
+    const accounts = await hre.viem.getWalletClients();
+    // Mirror deploy script: use accounts[1..10] as oracle nodes
+    const nodeAccounts = accounts.slice(1, 11);
+    const registerTxHashes: `0x${string}`[] = [];
+
+    for (const account of nodeAccounts) {
+      try {
+        const rawNodeInfo = await publicClient.readContract({
+          address,
+          abi,
+          functionName: "nodes",
+          args: [account.account.address],
+        });
+        const node = normalizeNodeInfo(rawNodeInfo);
+        if (node.firstBucket !== 0n) {
+          console.log(`Node already registered: ${account.account.address}`);
+          continue;
+        }
+      } catch {
+        // If read fails, proceed to attempt registration
+      }
+
+      try {
+        console.log(`Registering node ${account.account.address} with initial price ${currentPrice} and stake 15 ETH`);
+        const txHash = await account.writeContract({
+          address,
+          abi,
+          functionName: "registerNode",
+          args: [currentPrice],
+          value: parseEther("15"),
+        });
+        registerTxHashes.push(txHash as `0x${string}`);
+      } catch (err: any) {
+        if (err?.message?.includes("NodeAlreadyRegistered")) {
+          console.log(`Node already registered during attempt: ${account.account.address}`);
+        } else {
+          console.warn(`Failed to register node ${account.account.address}:`, err?.message ?? err);
+        }
+      }
+    }
+
+    if (registerTxHashes.length > 0) {
+      try {
+        await Promise.all(registerTxHashes.map(h => publicClient.waitForTransactionReceipt({ hash: h } as any)));
+        console.log("All node registration txs mined");
+      } catch (err) {
+        console.warn("Error waiting for registration receipts:", (err as Error).message);
+      }
+    }
+  } catch (err) {
+    console.warn("Node registration step failed:", (err as Error).message);
+  }
   while (true) {
     await runCycle(hre);
-    await sleep(3000);
+    await sleep(12000);
   }
 };
 
@@ -39,26 +395,22 @@ run().catch(error => {
 // Handle process termination signals
 process.on("SIGINT", async () => {
   console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 process.on("SIGTERM", async () => {
   console.log("\nReceived SIGTERM. Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 // Handle uncaught exceptions
 process.on("uncaughtException", async error => {
   console.error("Uncaught Exception:", error);
-  await cleanup();
   process.exit(1);
 });
 
 // Handle unhandled promise rejections
 process.on("unhandledRejection", async (reason, promise) => {
   console.error("Unhandled Rejection at:", promise, "reason:", reason);
-  await cleanup();
   process.exit(1);
 });
diff --git a/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts b/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
index 57df43b0..1bdd7e78 100644
--- a/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
+++ b/extension/packages/hardhat/scripts/runWhitelistOracleBots.ts
@@ -3,7 +3,7 @@ import { WhitelistOracle } from "../typechain-types";
 import hre from "hardhat";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import { fetchPriceFromUniswap } from "./fetchPriceFromUniswap";
-import { cleanup, sleep } from "./utils";
+import { sleep } from "./utils";
 
 async function getAllOracles() {
   const [deployer] = await ethers.getSigners();
@@ -43,7 +43,6 @@ const runCycle = async (hre: HardhatRuntimeEnvironment, basePrice: bigint) => {
     const simpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const publicClient = await hre.viem.getPublicClient();
 
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [false] });
     const blockNumber = await publicClient.getBlockNumber();
     console.log(`\n[Block ${blockNumber}] Starting new whitelist oracle cycle...`);
     const oracleAddresses = await getAllOracles();
@@ -68,9 +67,6 @@ const runCycle = async (hre: HardhatRuntimeEnvironment, basePrice: bigint) => {
         args: [randomPrice],
       });
     }
-
-    await publicClient.transport.request({ method: "evm_mine" });
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
   } catch (error) {
     console.error("Error in oracle cycle:", error);
     throw error;
@@ -95,26 +91,22 @@ run().catch(error => {
 // Handle process termination signals
 process.on("SIGINT", async () => {
   console.log("\nReceived SIGINT (Ctrl+C). Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 process.on("SIGTERM", async () => {
   console.log("\nReceived SIGTERM. Cleaning up...");
-  await cleanup();
   process.exit(0);
 });
 
 // Handle uncaught exceptions
 process.on("uncaughtException", async error => {
   console.error("Uncaught Exception:", error);
-  await cleanup();
   process.exit(1);
 });
 
 // Handle unhandled promise rejections
 process.on("unhandledRejection", async (reason, promise) => {
   console.error("Unhandled Rejection at:", promise, "reason:", reason);
-  await cleanup();
   process.exit(1);
 });
diff --git a/extension/packages/hardhat/scripts/utils.ts b/extension/packages/hardhat/scripts/utils.ts
index 27b9a322..6e4a114d 100644
--- a/extension/packages/hardhat/scripts/utils.ts
+++ b/extension/packages/hardhat/scripts/utils.ts
@@ -1,7 +1,6 @@
 import { Config } from "./oracle-bot/types";
 import fs from "fs";
 import path from "path";
-import hre from "hardhat";
 
 const getConfigPath = (): string => {
   return path.join(__dirname, "oracle-bot", "config.json");
@@ -32,17 +31,6 @@ export const updatePriceCache = (price: number, timestamp: number): void => {
 
 export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-// Cleanup function to ensure automining is turned back on
-export async function cleanup() {
-  try {
-    const publicClient = await hre.viem.getPublicClient();
-    await publicClient.transport.request({ method: "evm_setAutomine", params: [true] });
-    console.log("\nCleaning up: turning automining back on...");
-  } catch (error) {
-    console.error("Error cleaning up:", error);
-  }
-}
-
 export const QUESTIONS_FOR_OO: string[] = [
   "Did ETH/USD exceed $3,000 at 00:00 UTC on {MONTH} {DAY}, {YEAR}?",
   "Did the BTC/ETH ratio fall below 14 on {MONTH} {DAY}, {YEAR}?",
diff --git a/extension/packages/hardhat/test/OptimisticOracle.ts b/extension/packages/hardhat/test/OptimisticOracle.ts
index 158cf539..704a5689 100644
--- a/extension/packages/hardhat/test/OptimisticOracle.ts
+++ b/extension/packages/hardhat/test/OptimisticOracle.ts
@@ -4,6 +4,11 @@ import { OptimisticOracle, Decider } from "../typechain-types";
 import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
 
 describe("OptimisticOracle", function () {
+  before(async () => {
+    await ethers.provider.send("evm_setAutomine", [true]);
+    await ethers.provider.send("evm_setIntervalMining", [0]);
+  });
+
   let optimisticOracle: OptimisticOracle;
   let deciderContract: Decider;
   let owner: HardhatEthersSigner;
@@ -12,6 +17,16 @@ describe("OptimisticOracle", function () {
   let disputer: HardhatEthersSigner;
   let otherUser: HardhatEthersSigner;
 
+  const contractAddress = process.env.CONTRACT_ADDRESS;
+
+  let contractArtifact: string;
+  if (contractAddress) {
+    // For the autograder
+    contractArtifact = `contracts/download-${contractAddress}.sol:OptimisticOracle`;
+  } else {
+    contractArtifact = "contracts/02_Optimistic/OptimisticOracle.sol:OptimisticOracle";
+  }
+
   // Enum for state
   const State = {
     Invalid: 0n,
@@ -26,8 +41,8 @@ describe("OptimisticOracle", function () {
     [owner, asserter, proposer, disputer, otherUser] = await ethers.getSigners();
 
     // Deploy OptimisticOracle with temporary decider (owner)
-    const OptimisticOracleFactory = await ethers.getContractFactory("OptimisticOracle");
-    optimisticOracle = await OptimisticOracleFactory.deploy(owner.address);
+    const OptimisticOracleFactory = await ethers.getContractFactory(contractArtifact);
+    optimisticOracle = (await OptimisticOracleFactory.deploy(owner.address)) as OptimisticOracle;
 
     // Deploy Decider
     const DeciderFactory = await ethers.getContractFactory("Decider");
@@ -50,10 +65,10 @@ describe("OptimisticOracle", function () {
 
       it("Should have correct constants", async function () {
         const minimumAssertionWindow = await optimisticOracle.MINIMUM_ASSERTION_WINDOW();
-        const minimumDisputeWindow = await optimisticOracle.MINIMUM_DISPUTE_WINDOW();
+        const disputeWindow = await optimisticOracle.DISPUTE_WINDOW();
 
         expect(minimumAssertionWindow).to.equal(180n); // 3 minutes
-        expect(minimumDisputeWindow).to.equal(180n); // 3 minutes
+        expect(disputeWindow).to.equal(180n); // 3 minutes
       });
 
       it("Should start with nextAssertionId at 1", async function () {
@@ -104,7 +119,7 @@ describe("OptimisticOracle", function () {
 
         await expect(
           optimisticOracle.connect(asserter).assertEvent(description, 0, 0, { value: insufficientReward }),
-        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidValue");
       });
     });
 
@@ -141,7 +156,7 @@ describe("OptimisticOracle", function () {
 
         await expect(
           optimisticOracle.connect(proposer).proposeOutcome(assertionId, outcome, { value: wrongBond }),
-        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidValue");
       });
 
       it("Should reject duplicate proposals", async function () {
@@ -189,7 +204,7 @@ describe("OptimisticOracle", function () {
 
         await expect(
           optimisticOracle.connect(disputer).disputeOutcome(assertionId, { value: wrongBond }),
-        ).to.be.revertedWithCustomError(optimisticOracle, "NotEnoughValue");
+        ).to.be.revertedWithCustomError(optimisticOracle, "InvalidValue");
       });
 
       it("Should reject disputes after deadline", async function () {
@@ -238,7 +253,7 @@ describe("OptimisticOracle", function () {
         const reward = ethers.parseEther("1");
         const now = (await ethers.provider.getBlock("latest"))!.timestamp;
         const start = now + 1; // Start time must be in the future
-        const end = now + 200; // 200 seconds, which is more than MINIMUM_DISPUTE_WINDOW (180 seconds)
+        const end = now + 200; // 200 seconds, which is more than DISPUTE_WINDOW (180 seconds)
         const tx = await optimisticOracle.connect(asserter).assertEvent("short event", start, end, { value: reward });
         const receipt = await tx.wait();
         const event = receipt!.logs.find(
diff --git a/extension/packages/hardhat/test/StakingOracle.ts b/extension/packages/hardhat/test/StakingOracle.ts
index 011f97e5..f7543c1f 100644
--- a/extension/packages/hardhat/test/StakingOracle.ts
+++ b/extension/packages/hardhat/test/StakingOracle.ts
@@ -1,409 +1,425 @@
-import { expect, assert } from "chai";
+import { expect } from "chai";
 import { ethers } from "hardhat";
-import { time } from "@nomicfoundation/hardhat-network-helpers";
+import { mine } from "@nomicfoundation/hardhat-network-helpers";
 import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
 import type { StakingOracle, ORA } from "../typechain-types";
 
 describe("Checkpoint2", function () {
+  before(async () => {
+    await ethers.provider.send("evm_setAutomine", [true]);
+    await ethers.provider.send("evm_setIntervalMining", [0]);
+  });
+
   let oracle: StakingOracle;
   let oraToken: ORA;
   let node1: HardhatEthersSigner;
   let node2: HardhatEthersSigner;
   let node3: HardhatEthersSigner;
   let node4: HardhatEthersSigner;
+  let node5: HardhatEthersSigner;
+  let node6: HardhatEthersSigner;
   let slasher: HardhatEthersSigner;
-
   const MINIMUM_STAKE = ethers.parseEther("1");
-  const STALE_DATA_WINDOW = 24;
-
+  async function mineBuckets(count: number) {
+    const bucketWindow = Number(await oracle.BUCKET_WINDOW());
+    await mine(bucketWindow * count);
+  }
   beforeEach(async function () {
-    [node1, node2, node3, node4, slasher] = await ethers.getSigners();
-
+    [node1, node2, node3, node4, node5, node6, slasher] = await ethers.getSigners();
     const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
-    oracle = await StakingOracleFactory.deploy();
-
+    oracle = (await StakingOracleFactory.deploy()) as StakingOracle;
+    await oracle.waitForDeployment();
     const oraTokenAddress = await oracle.oracleToken();
     const ORAFactory = await ethers.getContractFactory("ORA");
     oraToken = ORAFactory.attach(oraTokenAddress) as ORA;
   });
-
   describe("constructor", function () {
-    it("Should deploy an ORA token and set initial state", async function () {
-      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
-      const newly_deployed_oracle = await StakingOracleFactory.deploy();
-      const tokenAddress = await newly_deployed_oracle.oracleToken();
-      const contractCode = await ethers.provider.getCode(tokenAddress);
-      expect(contractCode).to.not.equal("0x");
+    it("deploys ORA token", async function () {
+      const tokenAddress = await oracle.oracleToken();
+      const code = await ethers.provider.getCode(tokenAddress);
+      expect(code).to.not.equal("0x");
     });
   });
-
   describe("getNodeAddresses", function () {
-    it("Should return an empty array when no nodes are registered", async function () {
-      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
-      const newOracle = await StakingOracleFactory.deploy();
-      const nodeAddresses = await newOracle.getNodeAddresses();
-      assert(Array.isArray(nodeAddresses), "nodeAddresses should be an array");
-      assert(nodeAddresses.length === 0, "nodeAddresses should be empty");
-    });
-
-    it("Should return all registered node addresses in order", async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-      await oracle.connect(node2).registerNode(1501, { value: MINIMUM_STAKE });
-      await oracle.connect(node3).registerNode(1502, { value: MINIMUM_STAKE });
+    it("returns all registered nodes in order", async function () {
+      await (await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node2).registerNode(1501, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node3).registerNode(1502, { value: MINIMUM_STAKE })).wait();
       const nodeAddresses = await oracle.getNodeAddresses();
-      expect(nodeAddresses).to.deep.equal([node1.address, node2.address, node3.address]);
+      expect(nodeAddresses.length).to.equal(3);
+      expect(nodeAddresses[0]).to.equal(node1.address);
+      expect(nodeAddresses[1]).to.equal(node2.address);
+      expect(nodeAddresses[2]).to.equal(node3.address);
     });
   });
-
   describe("Node Registration", function () {
-    it("Should allow nodes to register with minimum stake", async function () {
-      const initialPrice = 1500;
-      await expect(oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }))
-        .to.emit(oracle, "NodeRegistered")
-        .withArgs(node1.address, MINIMUM_STAKE)
-        .and.to.emit(oracle, "PriceReported")
-        .withArgs(node1.address, initialPrice);
-
-      const nodeInfo = await oracle.nodes(node1.address);
-      expect(nodeInfo.nodeAddress).to.equal(node1.address);
-      expect(nodeInfo.stakedAmount).to.equal(MINIMUM_STAKE);
-      expect(nodeInfo.lastReportedPrice).to.equal(initialPrice);
-      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
-
-      expect(await oracle.nodeAddresses(0)).to.equal(node1.address);
-    });
-
-    it("Should emit NodeRegistered and PriceReported events on successful registration", async function () {
+    it("allows register with minimum stake and emits events", async function () {
       const initialPrice = 1500;
-      await expect(oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }))
-        .to.emit(oracle, "NodeRegistered")
-        .withArgs(node1.address, MINIMUM_STAKE)
-        .and.to.emit(oracle, "PriceReported")
-        .withArgs(node1.address, initialPrice);
+      await (await oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE })).wait();
+      const info = await oracle.nodes(node1.address);
+      expect(info.stakedAmount).to.equal(MINIMUM_STAKE);
+      expect(info.active).to.equal(true);
+      expect(await oracle.getNodeAddresses()).to.deep.equal([node1.address]);
     });
-
-    it("Should reject registration with insufficient stake", async function () {
-      const insufficientStake = ethers.parseEther("0.5");
-      const initialPrice = 1500;
+    it("rejects insufficient stake and duplicate registration", async function () {
       await expect(
-        oracle.connect(node1).registerNode(initialPrice, { value: insufficientStake }),
+        oracle.connect(node1).registerNode(1500, { value: ethers.parseEther("0.5") }),
       ).to.be.revertedWithCustomError(oracle, "InsufficientStake");
-    });
-
-    it("Should reject duplicate node registration", async function () {
-      const initialPrice = 1500;
-      await oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE });
-
-      await expect(
-        oracle.connect(node1).registerNode(initialPrice, { value: MINIMUM_STAKE }),
-      ).to.be.revertedWithCustomError(oracle, "NodeAlreadyRegistered");
+      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      await expect(oracle.connect(node1).registerNode(1501, { value: MINIMUM_STAKE })).to.be.revertedWithCustomError(
+        oracle,
+        "NodeAlreadyRegistered",
+      );
     });
   });
-
   describe("Price Reporting", function () {
     beforeEach(async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
+      await (await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE })).wait();
     });
 
-    it("Should record the reported price and timestamp in contract state", async function () {
-      let nodeInfo = await oracle.nodes(node1.address);
-      expect(nodeInfo.lastReportedPrice).to.equal(1500);
-      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+    it("emits PriceReported and prevents double report in same bucket", async function () {
+      await mineBuckets(1);
+      const currentBucket = await oracle.getCurrentBucketNumber();
+      await (await oracle.connect(node1).reportPrice(1600)).wait();
+      const [p] = await oracle.getAddressDataAtBucket(node1.address, currentBucket);
+      expect(p).to.equal(1600);
 
-      const price = 1600;
-      const tx = await oracle.connect(node1).reportPrice(price);
-      await tx.wait();
-
-      nodeInfo = await oracle.nodes(node1.address);
-      expect(nodeInfo.lastReportedPrice).to.equal(price);
-      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
+      await expect(oracle.connect(node1).reportPrice(1700)).to.be.revertedWithCustomError(
+        oracle,
+        "AlreadyReportedInCurrentBucket",
+      );
     });
 
-    it("Should emit PriceReported event when reporting price", async function () {
-      const price = 1500;
-      await expect(oracle.connect(node1).reportPrice(price))
-        .to.emit(oracle, "PriceReported")
-        .withArgs(node1.address, price);
+    it("rejects zero price and unregistered node", async function () {
+      await expect(oracle.connect(node1).reportPrice(0)).to.be.revertedWithCustomError(oracle, "InvalidPrice");
+      await expect(oracle.connect(node2).reportPrice(1000)).to.be.revertedWithCustomError(oracle, "NodeNotRegistered");
     });
 
-    it("Should reject price reports from unregistered nodes", async function () {
-      const price = 1500;
-      await expect(oracle.connect(node2).reportPrice(price)).to.be.revertedWithCustomError(oracle, "NodeNotRegistered");
-    });
-
-    it("Should reject price reports from nodes with insufficient stake", async function () {
-      await oracle.connect(node1).reportPrice(1500);
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(slasher).slashNodes();
-
-      const nodeInfo = await oracle.nodes(node1.address);
-      const expectedSlashedAmount = MINIMUM_STAKE - ethers.parseEther("1");
-      expect(nodeInfo.stakedAmount).to.equal(expectedSlashedAmount);
-      expect(nodeInfo.stakedAmount).to.be.lt(MINIMUM_STAKE);
-
-      await expect(oracle.connect(node1).reportPrice(1600)).to.be.revertedWithCustomError(oracle, "NotEnoughStake");
+    it("rejects when effective stake falls below minimum after missed buckets", async function () {
+      // Miss 2 full buckets without reporting -> 1 missed expected report => 0.01 ETH penalty
+      await mineBuckets(2);
+      // Now attempting to report should fail due to effectiveStake < 1 ETH
+      await expect(oracle.connect(node1).reportPrice(1600)).to.be.revertedWithCustomError(oracle, "InsufficientStake");
     });
   });
 
   describe("Claim Reward", function () {
     beforeEach(async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-    });
-
-    it("Should allow nodes to claim rewards based on time elapsed", async function () {
-      await time.increase(100); // 100 seconds
-
-      const balanceBefore = await oraToken.balanceOf(node1.address);
-      await oracle.connect(node1).claimReward();
-      const balanceAfter = await oraToken.balanceOf(node1.address);
-
-      expect(balanceAfter).to.be.gt(balanceBefore);
+      await (await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE })).wait();
     });
 
-    it("Should reject claim from unregistered nodes", async function () {
-      await expect(oracle.connect(node2).claimReward()).to.be.revertedWithCustomError(oracle, "NodeNotRegistered");
-    });
-
-    it("Should update lastClaimedTimestamp after successful claim", async function () {
-      await time.increase(100);
-
-      const nodeInfoBefore = await oracle.nodes(node1.address);
-      await oracle.connect(node1).claimReward();
-      const nodeInfoAfter = await oracle.nodes(node1.address);
-
-      expect(nodeInfoAfter.lastClaimedTimestamp).to.be.gt(nodeInfoBefore.lastClaimedTimestamp);
-    });
-
-    it("Should handle reward calculation for slashed nodes correctly", async function () {
-      // Register and let some time pass
-      await time.increase(50);
-
-      // Get slashed - this will set lastSlashedTimestamp
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(slasher).slashNodes();
-
-      const nodeInfo = await oracle.nodes(node1.address);
-      expect(nodeInfo.stakedAmount).to.be.lt(MINIMUM_STAKE);
-      expect(nodeInfo.lastSlashedTimestamp).to.be.gt(0);
-
-      // Slashed nodes can claim rewards up to their slash timestamp
-      const balanceBefore = await oraToken.balanceOf(node1.address);
-      await oracle.connect(node1).claimReward();
-      const balanceAfter = await oraToken.balanceOf(node1.address);
-
-      // Should get rewards for the time between registration and slashing
-      expect(balanceAfter).to.be.gt(balanceBefore);
-
-      // Trying to claim again should fail since no new rewards accumulated
+    it("mints 1 ORA per report and reverts with no rewards", async function () {
+      const beforeBal = await oraToken.balanceOf(node1.address);
+      await (await oracle.connect(node1).claimReward()).wait();
+      const afterBal = await oraToken.balanceOf(node1.address);
+      expect(afterBal).to.be.gt(beforeBal);
       await expect(oracle.connect(node1).claimReward()).to.be.revertedWithCustomError(oracle, "NoRewardsAvailable");
     });
 
-    it("Should revert when no rewards are available", async function () {
-      // Advance time slightly to account for registration timestamp
-      await time.increase(1);
-
-      // Claim should work with minimal time passed
-      const balanceBefore = await oraToken.balanceOf(node1.address);
-      await oracle.connect(node1).claimReward();
-      const balanceAfter = await oraToken.balanceOf(node1.address);
-
-      expect(balanceAfter).to.be.gt(balanceBefore);
+    it("accumulates rewards across buckets", async function () {
+      await (await oracle.connect(node1).claimReward()).wait();
+      await mineBuckets(1);
+      await (await oracle.connect(node1).reportPrice(1600)).wait();
+      await mineBuckets(1);
+      await (await oracle.connect(node1).reportPrice(1700)).wait();
+      const beforeBal = await oraToken.balanceOf(node1.address);
+      await (await oracle.connect(node1).claimReward()).wait();
+      const afterBal = await oraToken.balanceOf(node1.address);
+      expect(afterBal - beforeBal).to.equal(ethers.parseEther("2"));
     });
   });
-
-  describe("Slashing Mechanism", function () {
+  describe("Prices by bucket", function () {
     beforeEach(async function () {
-      await oracle.connect(node1).registerNode(1450, { value: MINIMUM_STAKE });
-      await oracle.connect(node2).registerNode(1500, { value: MINIMUM_STAKE });
-      await oracle.connect(node3).registerNode(1550, { value: MINIMUM_STAKE });
-    });
-
-    it("Should slash stale nodes and reward slasher", async function () {
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(node1).reportPrice(1600); // Keep node1 fresh
-
-      const slasherBalanceBefore = await ethers.provider.getBalance(slasher.address);
-      await oracle.connect(slasher).slashNodes();
-      const slasherBalanceAfter = await ethers.provider.getBalance(slasher.address);
-
-      expect(slasherBalanceAfter).to.be.gt(slasherBalanceBefore);
-
-      const node2Info = await oracle.nodes(node2.address);
-      const node3Info = await oracle.nodes(node3.address);
-
-      const expectedSlashedAmount = MINIMUM_STAKE - ethers.parseEther("1");
-      expect(node2Info.stakedAmount).to.equal(expectedSlashedAmount);
-      expect(node3Info.stakedAmount).to.equal(expectedSlashedAmount);
-    });
-
-    it("Should emit NodeSlashed events for stale nodes", async function () {
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(node1).reportPrice(1600);
-
-      await expect(oracle.connect(slasher).slashNodes())
-        .to.emit(oracle, "NodeSlashed")
-        .withArgs(node2.address, ethers.parseEther("1"))
-        .and.to.emit(oracle, "NodeSlashed")
-        .withArgs(node3.address, ethers.parseEther("1"));
-    });
-
-    it("Should reward slasher with correct percentage of slashed amounts", async function () {
-      const StakingOracleFactory = await ethers.getContractFactory("StakingOracle");
-      const freshOracle = await StakingOracleFactory.deploy();
-
-      await freshOracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-      await freshOracle.connect(node2).registerNode(1501, { value: MINIMUM_STAKE });
-
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await freshOracle.connect(node1).reportPrice(1500); // Keep node1 fresh
-
-      const slasherBalanceBefore = await ethers.provider.getBalance(slasher.address);
-
-      const tx = await freshOracle.connect(slasher).slashNodes();
-      const receipt = await tx.wait();
-      if (!receipt) throw new Error("Transaction receipt is null");
-      const gasUsed = BigInt(receipt.gasUsed) * BigInt(receipt.gasPrice);
-
-      const node2InfoAfter = await freshOracle.nodes(node2.address);
-      expect(node2InfoAfter.stakedAmount).to.equal(MINIMUM_STAKE - ethers.parseEther("1"));
-
-      const SLASHER_REWARD_PERCENTAGE = await freshOracle.SLASHER_REWARD_PERCENTAGE();
-      const expectedReward = (ethers.parseEther("1") * SLASHER_REWARD_PERCENTAGE) / 100n;
-      const slasherBalanceAfter = await ethers.provider.getBalance(slasher.address);
-
-      expect(slasherBalanceAfter).to.equal(slasherBalanceBefore + expectedReward - gasUsed);
-    });
-
-    it("Should update lastSlashedTimestamp when node is slashed", async function () {
-      await time.increase(STALE_DATA_WINDOW + 1);
-
-      const nodeInfoBefore = await oracle.nodes(node2.address);
-      expect(nodeInfoBefore.lastSlashedTimestamp).to.equal(0);
-
-      await oracle.connect(slasher).slashNodes();
-
-      const nodeInfoAfter = await oracle.nodes(node2.address);
-      // The contract now properly updates lastSlashedTimestamp
-      expect(nodeInfoAfter.lastSlashedTimestamp).to.be.gt(0);
-      expect(nodeInfoAfter.stakedAmount).to.be.lt(MINIMUM_STAKE);
+      await (await oracle.connect(node1).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node2).registerNode(1100, { value: MINIMUM_STAKE })).wait();
+    });
+    it("returns average for previous bucket via getLatestPrice", async function () {
+      await expect(oracle.getLatestPrice()).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
+      await mineBuckets(1);
+      const latest = await oracle.getLatestPrice();
+      expect(latest).to.equal(1050);
+    });
+    it("getPastPrice returns stored average and getAddressDataAtBucket matches", async function () {
+      const bucketA = await oracle.getCurrentBucketNumber();
+      await mineBuckets(1);
+      const pastAvg = await oracle.getPastPrice(bucketA);
+      expect(pastAvg).to.equal(1050);
+      const [p1] = await oracle.getAddressDataAtBucket(node1.address, bucketA);
+      const [p2] = await oracle.getAddressDataAtBucket(node2.address, bucketA);
+      expect(p1).to.equal(1000);
+      expect(p2).to.equal(1100);
+    });
+    it("getPastPrice reverts for empty bucket", async function () {
+      await mineBuckets(1);
+      const futureBucket = await oracle.getCurrentBucketNumber();
+      await expect(oracle.getPastPrice(futureBucket)).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
     });
   });
-
-  describe("Price Aggregation and Node Management", function () {
+  describe("Effective stake and addStake", function () {
     beforeEach(async function () {
-      await oracle.connect(node1).registerNode(1450, { value: MINIMUM_STAKE });
-      await oracle.connect(node2).registerNode(1500, { value: MINIMUM_STAKE });
-      await oracle.connect(node3).registerNode(1550, { value: MINIMUM_STAKE });
-    });
-
-    it("Should correctly calculate median price", async function () {
-      let price = await oracle.getPrice();
-      expect(price).to.equal(1500);
-
-      await oracle.connect(node4).registerNode(1600, { value: MINIMUM_STAKE });
-      price = await oracle.getPrice();
-      expect(price).to.equal(1525);
-    });
-
-    it("Should exclude stale price reports in the median calculation", async function () {
-      let price = await oracle.getPrice();
-      expect(price).to.equal(1500);
-
-      await time.increase(STALE_DATA_WINDOW + 1);
-
-      await oracle.connect(node2).reportPrice(2400);
-      await oracle.connect(node3).reportPrice(2500);
-
-      price = await oracle.getPrice();
-      expect(price).to.equal(2450);
-
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(node1).reportPrice(1700);
-
-      price = await oracle.getPrice();
-      expect(price).to.equal(1700);
-    });
-
-    it("Should handle case when no valid prices are available", async function () {
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await expect(oracle.getPrice()).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
-    });
-
-    it("Should correctly separate fresh and stale nodes (via getPrice behavior)", async function () {
-      // Test the separation logic indirectly through price calculation
-      let price = await oracle.getPrice();
-      expect(price).to.equal(1500); // median of [1450, 1500, 1550]
-
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(node1).reportPrice(1600); // Keep node1 fresh
-
-      // Now only node1 should be fresh, so price should be 1600
-      price = await oracle.getPrice();
-      expect(price).to.equal(1600);
-    });
-
-    it("Should handle empty node array in separateStaleNodes", async function () {
-      const result = await oracle.separateStaleNodes([]);
-      const freshNodes = Array.from(result[0]);
-      const staleNodes = Array.from(result[1]);
-      expect(freshNodes).to.deep.equal([]);
-      expect(staleNodes).to.deep.equal([]);
+      await (await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE })).wait();
+    });
+    it("penalizes missed buckets and floors at zero; addStake increases", async function () {
+      await mineBuckets(2);
+      const eff1 = await oracle.getEffectiveStake(node1.address);
+      expect(eff1).to.equal(ethers.parseEther("0.99"));
+      await (await oracle.connect(node1).addStake({ value: ethers.parseEther("0.5") })).wait();
+      const eff2 = await oracle.getEffectiveStake(node1.address);
+      expect(eff2).to.equal(ethers.parseEther("1.49"));
+    });
+    it("rejects zero value stake addition", async function () {
+      await expect(oracle.connect(node1).addStake({ value: 0 })).to.be.revertedWithCustomError(
+        oracle,
+        "InsufficientStake",
+      );
     });
   });
-
-  describe("Node Information Queries", function () {
+  describe("Slashing - deviation in past bucket", function () {
+    async function indexOf(address: string) {
+      const arr = await oracle.getNodeAddresses();
+      return arr.findIndex(a => a.toLowerCase() === address.toLowerCase());
+    }
     beforeEach(async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-    });
-
-    it("Should return correct node information", async function () {
-      const nodeInfo = await oracle.nodes(node1.address);
-      expect(nodeInfo.nodeAddress).to.equal(node1.address);
-      expect(nodeInfo.stakedAmount).to.equal(MINIMUM_STAKE);
-      expect(nodeInfo.lastReportedPrice).to.equal(1500);
-      expect(nodeInfo.lastReportedTimestamp).to.be.gt(0);
-      expect(nodeInfo.lastClaimedTimestamp).to.be.gt(0);
-      expect(nodeInfo.lastSlashedTimestamp).to.equal(0);
-    });
-
-    it("Should return zero values for unregistered node", async function () {
-      const nodeInfo = await oracle.nodes(node2.address);
-      expect(nodeInfo.nodeAddress).to.equal(ethers.ZeroAddress);
-      expect(nodeInfo.stakedAmount).to.equal(0);
-      expect(nodeInfo.lastReportedPrice).to.equal(0);
-      expect(nodeInfo.lastReportedTimestamp).to.equal(0);
-      expect(nodeInfo.lastClaimedTimestamp).to.equal(0);
-      expect(nodeInfo.lastSlashedTimestamp).to.equal(0);
+      // Move to beginning of bucket window before registering nodes so that we have 24 blocks to report in the same bucket.
+      const bucketWindow = Number(await oracle.BUCKET_WINDOW());
+      const blockNum = await ethers.provider.getBlockNumber();
+      const toNext = (bucketWindow - (blockNum % bucketWindow)) % bucketWindow; // 0..bucketWindow-1
+      await mine(toNext + 1);
+      await (await oracle.connect(node1).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node2).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node3).registerNode(1200, { value: MINIMUM_STAKE })).wait();
+      await mineBuckets(1);
+    });
+    it("reverts for current bucket and for non-deviated prices", async function () {
+      const current = await oracle.getCurrentBucketNumber();
+      const idx = await indexOf(node3.address);
+      await expect(oracle.connect(slasher).slashNode(node3.address, current, idx)).to.be.revertedWithCustomError(
+        oracle,
+        "OnlyPastBucketsAllowed",
+      );
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node3).reportPrice(1050)).wait();
+      const bucketB = await oracle.getCurrentBucketNumber();
+      await mineBuckets(1);
+      const idxB = await indexOf(node3.address);
+      await expect(oracle.connect(slasher).slashNode(node3.address, bucketB, idxB)).to.be.revertedWithCustomError(
+        oracle,
+        "NotDeviated",
+      );
+    });
+    it("slashes deviated node, rewards slasher, and cannot slash again", async function () {
+      await (await oracle.connect(node3).addStake({ value: ethers.parseEther("2") })).wait();
+      const pastBucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const idx = await indexOf(node3.address);
+      const slasherBalBefore = await ethers.provider.getBalance(slasher.address);
+      const tx = await oracle.connect(slasher).slashNode(node3.address, pastBucket, idx);
+      const rcpt = await tx.wait();
+      if (!rcpt) throw new Error("no receipt");
+      const gasCost = BigInt(rcpt.gasUsed) * BigInt(rcpt.gasPrice);
+      const SLASHER_REWARD_PERCENTAGE = await oracle.SLASHER_REWARD_PERCENTAGE();
+      const expectedReward = (ethers.parseEther("1") * SLASHER_REWARD_PERCENTAGE) / 100n;
+      const slasherBalAfter = await ethers.provider.getBalance(slasher.address);
+      expect(slasherBalAfter).to.equal(slasherBalBefore + expectedReward - gasCost);
+      await expect(oracle.connect(slasher).slashNode(node3.address, pastBucket, idx)).to.be.revertedWithCustomError(
+        oracle,
+        "NodeAlreadySlashed",
+      );
+    });
+    it("slashes deviated node and removes when stake hits zero", async function () {
+      const pastBucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const idx = await indexOf(node3.address);
+      const slasherBalBefore = await ethers.provider.getBalance(slasher.address);
+      const tx = await oracle.connect(slasher).slashNode(node3.address, pastBucket, idx);
+      const rcpt = await tx.wait();
+      if (!rcpt) throw new Error("no receipt");
+      const gasCost = BigInt(rcpt.gasUsed) * BigInt(rcpt.gasPrice);
+      const SLASHER_REWARD_PERCENTAGE = await oracle.SLASHER_REWARD_PERCENTAGE();
+      const expectedReward = (ethers.parseEther("1") * SLASHER_REWARD_PERCENTAGE) / 100n;
+      const slasherBalAfter = await ethers.provider.getBalance(slasher.address);
+      expect(slasherBalAfter).to.equal(slasherBalBefore + expectedReward - gasCost);
+      const addresses = await oracle.getNodeAddresses();
+      expect(addresses).to.not.include(node3.address);
+    });
+    it("reverts NodeDidNotReport for registered node that did not report in that bucket", async function () {
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      // node3 is registered but did not report in this bucket
+      const bucketC = await oracle.getCurrentBucketNumber();
+      await mineBuckets(1);
+      const idx3 = await indexOf(node3.address);
+      await expect(oracle.connect(slasher).slashNode(node3.address, bucketC, idx3)).to.be.revertedWithCustomError(
+        oracle,
+        "NodeDidNotReport",
+      );
+    });
+    it("verifies slashed flag is set correctly after slashing", async function () {
+      const pastBucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const idx = await indexOf(node3.address);
+      await (await oracle.connect(slasher).slashNode(node3.address, pastBucket, idx)).wait();
+      const [price, slashed] = await oracle.getAddressDataAtBucket(node3.address, pastBucket);
+      expect(price).to.equal(1200);
+      expect(slashed).to.equal(true);
+    });
+    it("reverts for exact 10% deviation threshold (should not slash)", async function () {
+      // Average is 1000, so 10% deviation means 1100 or 900
+      // With MAX_DEVIATION_BPS = 1000 (10%), exactly 10% should NOT slash (strict >)
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      // node3 reports 1100, which is exactly 10% deviation from average of 1000
+      await (await oracle.connect(node3).reportPrice(1100)).wait();
+      const bucketD = await oracle.getCurrentBucketNumber();
+      await mineBuckets(1);
+      const idx3 = await indexOf(node3.address);
+      // Should revert because exactly 10% is not > 10%
+      await expect(oracle.connect(slasher).slashNode(node3.address, bucketD, idx3)).to.be.revertedWithCustomError(
+        oracle,
+        "NotDeviated",
+      );
+    });
+    it("reverts IndexOutOfBounds when index is out of range", async function () {
+      const pastBucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const addresses = await oracle.getNodeAddresses();
+      const invalidIndex = addresses.length; // Index out of bounds
+      await expect(
+        oracle.connect(slasher).slashNode(node3.address, pastBucket, invalidIndex),
+      ).to.be.revertedWithCustomError(oracle, "IndexOutOfBounds");
+    });
+    it("reverts NodeNotAtGivenIndex when index doesn't match address", async function () {
+      const pastBucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const idx1 = await indexOf(node1.address);
+      // Try to slash node3 but use node1's index
+      await expect(oracle.connect(slasher).slashNode(node3.address, pastBucket, idx1)).to.be.revertedWithCustomError(
+        oracle,
+        "NodeNotAtGivenIndex",
+      );
     });
   });
-
-  describe("Edge Cases", function () {
-    it("Should handle single node scenarios", async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-      const price = await oracle.getPrice();
-      expect(price).to.equal(1500);
-    });
-
-    it("Should handle all nodes becoming stale", async function () {
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-      await oracle.connect(node2).registerNode(1600, { value: MINIMUM_STAKE });
-
-      await time.increase(STALE_DATA_WINDOW + 1);
-
-      await expect(oracle.getPrice()).to.be.revertedWithCustomError(oracle, "NoValidPricesAvailable");
+  describe("exitNode", function () {
+    async function indexOf(address: string) {
+      const arr = await oracle.getNodeAddresses();
+      return arr.findIndex(a => a.toLowerCase() === address.toLowerCase());
+    }
+    beforeEach(async function () {
+      await (await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node2).registerNode(1600, { value: MINIMUM_STAKE })).wait();
+    });
+    it("reverts before waiting period and exits with effective stake after", async function () {
+      const idx = await indexOf(node1.address);
+      await expect(oracle.connect(node1).exitNode(idx)).to.be.revertedWithCustomError(oracle, "WaitingPeriodNotOver");
+      await mineBuckets(2);
+      const effectiveStake = await oracle.getEffectiveStake(node1.address);
+      const balBefore = await ethers.provider.getBalance(node1.address);
+      const tx = await oracle.connect(node1).exitNode(idx);
+      const rcpt = await tx.wait();
+      if (!rcpt) throw new Error("no receipt");
+      const gasCost = BigInt(rcpt.gasUsed) * BigInt(rcpt.gasPrice);
+      const balAfter = await ethers.provider.getBalance(node1.address);
+      // Verify the balance changed by approximately the effective stake minus gas
+      const balanceChange = balAfter - balBefore;
+      // The change should be approximately effectiveStake - gasCost
+      // Allow tolerance for gas estimation differences
+      expect(balanceChange + gasCost).to.be.closeTo(effectiveStake, ethers.parseEther("0.02"));
+      // Verify node is removed
+      const addresses = await oracle.getNodeAddresses();
+      expect(addresses).to.not.include(node1.address);
+      // Verify node is deleted (effectiveStake should be 0 for inactive nodes)
+      expect(await oracle.getEffectiveStake(node1.address)).to.equal(0);
+    });
+    it("reverts IndexOutOfBounds when index is out of range", async function () {
+      await mineBuckets(2);
+      const addresses = await oracle.getNodeAddresses();
+      const invalidIndex = addresses.length; // Index out of bounds
+      await expect(oracle.connect(node1).exitNode(invalidIndex)).to.be.revertedWithCustomError(
+        oracle,
+        "IndexOutOfBounds",
+      );
+    });
+    it("reverts NodeNotAtGivenIndex when index doesn't match address", async function () {
+      await mineBuckets(2);
+      const idx2 = await indexOf(node2.address);
+      // Try to exit node1 but use node2's index
+      await expect(oracle.connect(node1).exitNode(idx2)).to.be.revertedWithCustomError(oracle, "NodeNotAtGivenIndex");
     });
-
-    it("Should handle slashing with insufficient stake", async function () {
-      // Register with minimal stake
-      await oracle.connect(node1).registerNode(1500, { value: MINIMUM_STAKE });
-
-      // Make stale and slash
-      await time.increase(STALE_DATA_WINDOW + 1);
-      await oracle.connect(slasher).slashNodes();
-
-      const nodeInfo = await oracle.nodes(node1.address);
-      // After slashing 1 ETH from 1 ETH stake, should be 0
-      expect(nodeInfo.stakedAmount).to.equal(0);
+  });
+  describe("getOutlierNodes", function () {
+    beforeEach(async function () {
+      const bucketWindow = Number(await oracle.BUCKET_WINDOW());
+      const blockNum = await ethers.provider.getBlockNumber();
+      const toNext = (bucketWindow - (blockNum % bucketWindow)) % bucketWindow;
+      await mine(toNext + 1);
+      await (await oracle.connect(node1).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node2).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node3).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node4).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node5).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+      await (await oracle.connect(node6).registerNode(1000, { value: MINIMUM_STAKE })).wait();
+    });
+    it("returns empty array when no outliers exist", async function () {
+      // All nodes report the same price in a new bucket
+      await mineBuckets(1);
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node3).reportPrice(1000)).wait();
+      await (await oracle.connect(node4).reportPrice(1000)).wait();
+      await (await oracle.connect(node5).reportPrice(1000)).wait();
+      await (await oracle.connect(node6).reportPrice(1000)).wait();
+      await mineBuckets(1);
+      const bucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const outliers = await oracle.getOutlierNodes(bucket);
+      expect(outliers.length).to.equal(0);
+    });
+    it("returns deviated node addresses", async function () {
+      // node4 reports 1200 while others report 1000 (average = 1000)
+      // Deviation = (1200 - 1000) / 1000 = 20% > 10% threshold
+      await mineBuckets(1);
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node3).reportPrice(1000)).wait();
+      await (await oracle.connect(node4).reportPrice(1200)).wait();
+      await mineBuckets(1);
+      const bucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const outliers = await oracle.getOutlierNodes(bucket);
+      expect(outliers.length).to.equal(1);
+      expect(outliers[0]).to.equal(node4.address);
+    });
+    it("excludes nodes that did not report in the bucket", async function () {
+      // Only node1 and node2 report, node3 doesn't report
+      await mineBuckets(1);
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node4).reportPrice(1200)).wait();
+      await mineBuckets(1);
+      const bucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const outliers = await oracle.getOutlierNodes(bucket);
+      expect(outliers.length).to.equal(1);
+      expect(outliers[0]).to.equal(node4.address);
+      expect(outliers).to.not.include(node3.address);
+    });
+    it("handles multiple outliers correctly", async function () {
+      await mineBuckets(1);
+      // Set up prices so that only node3 and node4 are outliers
+      // We need enough "normal" nodes to keep the average stable
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node3).reportPrice(1000)).wait(); // Normal
+      await (await oracle.connect(node4).reportPrice(1500)).wait(); // Outlier (50% from avg of 1000)
+      await (await oracle.connect(node5).reportPrice(1000)).wait();
+      await (await oracle.connect(node6).reportPrice(1000)).wait();
+      await mineBuckets(1);
+      // Now in a new bucket, make node3 an outlier too
+      await (await oracle.connect(node1).reportPrice(1000)).wait();
+      await (await oracle.connect(node2).reportPrice(1000)).wait();
+      await (await oracle.connect(node3).reportPrice(1200)).wait(); // Outlier (avg without node3 = (1000+1000+1500)/3 ≈ 1166, deviation ≈ 20%)
+      await (await oracle.connect(node4).reportPrice(1200)).wait(); // Outlier (avg without node4 = (1000+1000+1400)/3 = 1133, deviation ≈ 32%)
+      await (await oracle.connect(node5).reportPrice(1000)).wait();
+      await (await oracle.connect(node6).reportPrice(1000)).wait();
+      await mineBuckets(1);
+      const bucket = (await oracle.getCurrentBucketNumber()) - 1n;
+      const outliers = await oracle.getOutlierNodes(bucket);
+      expect(outliers.length).to.equal(2);
+      expect(outliers).to.include(node3.address);
+      expect(outliers).to.include(node4.address);
     });
   });
 });
diff --git a/extension/packages/hardhat/test/WhitelistOracle.ts b/extension/packages/hardhat/test/WhitelistOracle.ts
index 6cc83ea9..60f8a244 100644
--- a/extension/packages/hardhat/test/WhitelistOracle.ts
+++ b/extension/packages/hardhat/test/WhitelistOracle.ts
@@ -4,8 +4,17 @@ import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signer
 import type { WhitelistOracle, SimpleOracle } from "../typechain-types";
 
 describe("Checkpoint1", function () {
+  before(async () => {
+    await ethers.provider.send("evm_setAutomine", [true]);
+    await ethers.provider.send("evm_setIntervalMining", [0]);
+  });
+
   let whitelistOracle: WhitelistOracle;
-  let owner: HardhatEthersSigner, addr1: HardhatEthersSigner, addr2: HardhatEthersSigner, addr3: HardhatEthersSigner, addr4: HardhatEthersSigner;
+  let owner: HardhatEthersSigner,
+    addr1: HardhatEthersSigner,
+    addr2: HardhatEthersSigner,
+    addr3: HardhatEthersSigner,
+    addr4: HardhatEthersSigner;
 
   beforeEach(async function () {
     [owner, addr1, addr2, addr3, addr4] = await ethers.getSigners();
@@ -19,10 +28,10 @@ describe("Checkpoint1", function () {
 
   it("Should allow adding oracles and deploy SimpleOracle contracts", async function () {
     await whitelistOracle.addOracle(addr1.address);
-    
+
     const oracleAddress = await whitelistOracle.oracles(0);
     expect(oracleAddress).to.not.equal(ethers.ZeroAddress);
-    
+
     // Check that the oracle is a SimpleOracle contract
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle = SimpleOracleFactory.attach(oracleAddress) as SimpleOracle;
@@ -32,15 +41,15 @@ describe("Checkpoint1", function () {
   it("Should allow removing oracles by index", async function () {
     await whitelistOracle.addOracle(addr1.address);
     await whitelistOracle.addOracle(addr2.address);
-    
+
     const oracle1Address = await whitelistOracle.oracles(0);
-    
+
     await whitelistOracle.removeOracle(0);
-    
+
     // After removal, the oracle at index 0 should be different (swapped from end)
     const newOracle0Address = await whitelistOracle.oracles(0);
     expect(newOracle0Address).to.not.equal(oracle1Address);
-    
+
     // Should only have one oracle left
     await expect(whitelistOracle.oracles(1)).to.be.reverted;
   });
@@ -49,25 +58,23 @@ describe("Checkpoint1", function () {
     const tx = await whitelistOracle.addOracle(addr1.address);
     await tx.wait();
     const oracleAddress = await whitelistOracle.oracles(0);
-    
+
     expect(tx).to.emit(whitelistOracle, "OracleAdded").withArgs(oracleAddress, addr1.address);
   });
 
   it("Should emit OracleRemoved event when an oracle is removed", async function () {
     await whitelistOracle.addOracle(addr1.address);
     const oracleAddress = await whitelistOracle.oracles(0);
-    
-    await expect(whitelistOracle.removeOracle(0))
-      .to.emit(whitelistOracle, "OracleRemoved")
-      .withArgs(oracleAddress);
+
+    await expect(whitelistOracle.removeOracle(0)).to.emit(whitelistOracle, "OracleRemoved").withArgs(oracleAddress);
   });
 
   it("Should revert with IndexOutOfBounds when trying to remove non-existent oracle", async function () {
     await expect(whitelistOracle.removeOracle(0)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
-    
+
     await whitelistOracle.addOracle(addr1.address);
     await expect(whitelistOracle.removeOracle(1)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
-    
+
     await whitelistOracle.removeOracle(0);
     await expect(whitelistOracle.removeOracle(0)).to.be.revertedWithCustomError(whitelistOracle, "IndexOutOfBounds");
   });
@@ -79,12 +86,12 @@ describe("Checkpoint1", function () {
   it("Should return correct price with one oracle", async function () {
     await whitelistOracle.addOracle(addr1.address);
     const oracleAddress = await whitelistOracle.oracles(0);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle = SimpleOracleFactory.attach(oracleAddress) as SimpleOracle;
-    
+
     await oracle.setPrice(1000n);
-    
+
     const price = await whitelistOracle.getPrice();
     expect(price).to.equal(1000n);
   });
@@ -93,16 +100,16 @@ describe("Checkpoint1", function () {
     await whitelistOracle.addOracle(addr1.address);
     await whitelistOracle.addOracle(addr2.address);
     await whitelistOracle.addOracle(addr3.address);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
     const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
     const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
-    
+
     await oracle1.setPrice(1000n);
     await oracle2.setPrice(3000n);
     await oracle3.setPrice(2000n);
-    
+
     const medianPrice = await whitelistOracle.getPrice();
     expect(medianPrice).to.equal(2000n);
   });
@@ -112,18 +119,18 @@ describe("Checkpoint1", function () {
     await whitelistOracle.addOracle(addr2.address);
     await whitelistOracle.addOracle(addr3.address);
     await whitelistOracle.addOracle(addr4.address);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
     const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
     const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
     const oracle4 = SimpleOracleFactory.attach(await whitelistOracle.oracles(3)) as SimpleOracle;
-    
+
     await oracle1.setPrice(1000n);
     await oracle2.setPrice(3000n);
     await oracle3.setPrice(2000n);
     await oracle4.setPrice(4000n);
-    
+
     const medianPrice = await whitelistOracle.getPrice();
     expect(medianPrice).to.equal(2500n);
   });
@@ -132,27 +139,27 @@ describe("Checkpoint1", function () {
     await whitelistOracle.addOracle(addr1.address);
     await whitelistOracle.addOracle(addr2.address);
     await whitelistOracle.addOracle(addr3.address);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
     const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
     const oracle3 = SimpleOracleFactory.attach(await whitelistOracle.oracles(2)) as SimpleOracle;
-    
+
     await oracle1.setPrice(1000n);
     await oracle2.setPrice(2000n);
     await oracle3.setPrice(3000n);
-    
+
     let medianPrice = await whitelistOracle.getPrice();
     expect(medianPrice).to.equal(2000n);
-    
+
     // Advance time by 25 seconds (more than STALE_DATA_WINDOW of 24 seconds)
     await ethers.provider.send("evm_increaseTime", [25]);
     await ethers.provider.send("evm_mine");
-    
+
     // Set new prices for only two oracles (the old prices should be stale)
     await oracle1.setPrice(5000n);
     await oracle2.setPrice(3000n);
-    
+
     // Should only use the two fresh prices: median of [5000, 3000] = 4000
     medianPrice = await whitelistOracle.getPrice();
     expect(medianPrice).to.equal(4000n);
@@ -166,29 +173,29 @@ describe("Checkpoint1", function () {
   it("Should return correct active oracle nodes", async function () {
     await whitelistOracle.addOracle(addr1.address);
     await whitelistOracle.addOracle(addr2.address);
-    
+
     const oracle1Address = await whitelistOracle.oracles(0);
     const oracle2Address = await whitelistOracle.oracles(1);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle1 = SimpleOracleFactory.attach(oracle1Address) as SimpleOracle;
     const oracle2 = SimpleOracleFactory.attach(oracle2Address) as SimpleOracle;
-    
+
     await oracle1.setPrice(1000n);
     await oracle2.setPrice(2000n);
-    
+
     let activeNodes = await whitelistOracle.getActiveOracleNodes();
     expect(activeNodes.length).to.equal(2);
     expect(activeNodes).to.include(oracle1Address);
     expect(activeNodes).to.include(oracle2Address);
-    
+
     // Make oracle1's price stale
     await ethers.provider.send("evm_increaseTime", [25]);
     await ethers.provider.send("evm_mine");
-    
+
     // Update only oracle2
     await oracle2.setPrice(3000n);
-    
+
     activeNodes = await whitelistOracle.getActiveOracleNodes();
     expect(activeNodes.length).to.equal(1);
     expect(activeNodes[0]).to.equal(oracle2Address);
@@ -197,23 +204,23 @@ describe("Checkpoint1", function () {
   it("Should handle edge case when all prices are stale but array is not empty", async function () {
     await whitelistOracle.addOracle(addr1.address);
     await whitelistOracle.addOracle(addr2.address);
-    
+
     const SimpleOracleFactory = await ethers.getContractFactory("SimpleOracle");
     const oracle1 = SimpleOracleFactory.attach(await whitelistOracle.oracles(0)) as SimpleOracle;
     const oracle2 = SimpleOracleFactory.attach(await whitelistOracle.oracles(1)) as SimpleOracle;
-    
+
     await oracle1.setPrice(1000n);
     await oracle2.setPrice(2000n);
-    
+
     // Verify median works initially
-    let medianPrice = await whitelistOracle.getPrice();
+    const medianPrice = await whitelistOracle.getPrice();
     expect(medianPrice).to.equal(1500n);
-    
+
     // Make all prices stale
     await ethers.provider.send("evm_increaseTime", [25]);
     await ethers.provider.send("evm_mine");
-    
+
     const activeNodes = await whitelistOracle.getActiveOracleNodes();
     expect(activeNodes.length).to.equal(0);
   });
-});
\ No newline at end of file
+});
diff --git a/extension/packages/nextjs/app/staking/page.tsx b/extension/packages/nextjs/app/staking/page.tsx
index aff773a2..667dd856 100644
--- a/extension/packages/nextjs/app/staking/page.tsx
+++ b/extension/packages/nextjs/app/staking/page.tsx
@@ -1,20 +1,30 @@
 "use client";
 
 import type { NextPage } from "next";
+import { useState } from "react";
+import { BucketCountdown } from "~~/components/oracle/BucketCountdown";
 import { NodesTable } from "~~/components/oracle/NodesTable";
 import { PriceWidget } from "~~/components/oracle/PriceWidget";
+import { TotalSlashedWidget } from "~~/components/oracle/TotalSlashedWidget";
+ 
 
 const Home: NextPage = () => {
+  const [selectedBucket, setSelectedBucket] = useState<bigint | "current">("current");
+
   return (
     <>
       <div className="flex items-center flex-col flex-grow pt-10">
         <div className="px-5 w-full max-w-5xl mx-auto">
           <div className="flex flex-col gap-8">
             <div className="w-full">
-              <PriceWidget contractName="StakingOracle" />
+              <div className="grid w-full items-stretch grid-cols-1 md:grid-cols-3 gap-4">
+                <PriceWidget contractName="StakingOracle" />
+                <BucketCountdown />
+                <TotalSlashedWidget />
+              </div>
             </div>
             <div className="w-full">
-              <NodesTable />
+              <NodesTable selectedBucket={selectedBucket} onBucketChange={setSelectedBucket} />
             </div>
           </div>
         </div>
diff --git a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx b/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
deleted file mode 100644
index 8ab38318..00000000
--- a/extension/packages/nextjs/components/MonitorAndTriggerTx.tsx
+++ /dev/null
@@ -1,66 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { useEffect, useRef } from "react";
-import { parseEther } from "viem";
-import { hardhat } from "viem/chains";
-import { useAccount, usePublicClient, useWalletClient } from "wagmi";
-import { useTargetNetwork } from "~~/hooks/scaffold-eth";
-import { useChallengeState } from "~~/services/store/challengeStore";
-
-// This component is used to monitor the block timestamp and trigger a transaction if the timestamp has not changed for 3 seconds
-export const MonitorAndTriggerTx = ({ children }: { children: React.ReactNode }) => {
-  const publicClient = usePublicClient();
-  const { data: walletClient } = useWalletClient();
-  const { targetNetwork } = useTargetNetwork();
-  const isLocalNetwork = targetNetwork.id === hardhat.id;
-  const { connector } = useAccount();
-  const isBurnerWallet = connector?.id === "burnerWallet";
-
-  const prevTimestampRef = useRef<bigint | null>(null);
-  const currentTimestampRef = useRef<bigint | null>(null);
-
-  const { setTimestamp, refetchAssertionStates } = useChallengeState();
-
-  useEffect(() => {
-    if (!publicClient || !walletClient) return;
-
-    const pollBlock = async () => {
-      try {
-        const block = await publicClient.getBlock();
-        const newTimestamp = block.timestamp;
-
-        const prev = prevTimestampRef.current;
-        const current = currentTimestampRef.current;
-
-        if (prev && newTimestamp === prev) {
-          try {
-            if (isBurnerWallet && isLocalNetwork) {
-              await walletClient.sendTransaction({
-                to: walletClient.account.address,
-                value: parseEther("0.0000001"),
-              });
-            }
-          } catch (err) {
-            console.log("Failed to send tx");
-          }
-        }
-
-        // Update refs
-        prevTimestampRef.current = current;
-        currentTimestampRef.current = newTimestamp;
-        refetchAssertionStates();
-
-        // Also update current timestamp in Zustand store for global access
-        setTimestamp(newTimestamp);
-      } catch (err) {
-        console.log("Polling error");
-      }
-    };
-
-    const interval = setInterval(pollBlock, 3000);
-    pollBlock(); // Initial call
-
-    return () => clearInterval(interval);
-  }, [publicClient, walletClient, isLocalNetwork, isBurnerWallet, setTimestamp, refetchAssertionStates]);
-
-  return <>{children}</>;
-};
diff --git a/extension/packages/nextjs/components/oracle/BucketCountdown.tsx b/extension/packages/nextjs/components/oracle/BucketCountdown.tsx
new file mode 100644
index 00000000..319b44ac
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/BucketCountdown.tsx
@@ -0,0 +1,86 @@
+import { useEffect, useRef, useState } from "react";
+import TooltipInfo from "../TooltipInfo";
+import { usePublicClient } from "wagmi";
+import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+
+export const BucketCountdown = () => {
+  const publicClient = usePublicClient();
+  const { data: bucketWindow } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "BUCKET_WINDOW",
+  }) as { data: bigint | undefined };
+
+  const [remainingSec, setRemainingSec] = useState<number | null>(null);
+  const [currentBucketNum, setCurrentBucketNum] = useState<bigint | null>(null);
+  const lastBucketCheckTime = useRef<number>(0);
+
+  // Poll getCurrentBucketNumber every second for accuracy
+  const { data: contractBucketNum } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getCurrentBucketNumber",
+    watch: true,
+  }) as { data: bigint | undefined };
+
+  useEffect(() => {
+    if (contractBucketNum !== undefined) {
+      setCurrentBucketNum(contractBucketNum);
+      lastBucketCheckTime.current = Date.now();
+    }
+  }, [contractBucketNum]);
+
+  useEffect(() => {
+    if (!bucketWindow || !publicClient || !currentBucketNum) return;
+    let mounted = true;
+    const update = async () => {
+      try {
+        const block = await publicClient.getBlock();
+        const blockNum = Number(block.number);
+        const w = Number(bucketWindow);
+        if (w <= 0) {
+          setRemainingSec(null);
+          return;
+        }
+
+        // Calculate blocks remaining in current bucket
+        // Bucket number = (block.number / BUCKET_WINDOW) + 1
+        // So current bucket started at: (currentBucketNum - 1) * BUCKET_WINDOW
+        const bucketStartBlock = (Number(currentBucketNum) - 1) * w;
+        const nextBucketBlock = bucketStartBlock + w;
+        const blocksRemaining = nextBucketBlock - blockNum;
+
+        // Add 3 second offset since node is ahead of system time
+        const estimatedSecondsRemaining = Math.max(0, blocksRemaining + 3);
+
+        if (mounted) setRemainingSec(estimatedSecondsRemaining);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (e) {
+        // ignore
+      }
+    };
+    update();
+    const id = setInterval(update, 1000);
+    return () => {
+      mounted = false;
+      clearInterval(id);
+    };
+  }, [bucketWindow, publicClient, currentBucketNum]);
+
+  return (
+    <div className="flex flex-col gap-2 h-full">
+      <h2 className="text-xl font-bold">Bucket Countdown</h2>
+      <div className="bg-base-100 rounded-lg p-4 w-full flex justify-center items-center relative h-full min-h-[140px]">
+        <TooltipInfo
+          top={0}
+          right={0}
+          className="tooltip-left"
+          infoText="Shows the current bucket number and countdown to the next bucket. Each bucket lasts 24 blocks."
+        />
+        <div className="flex flex-col items-center gap-2">
+          <div className="text-sm text-gray-500">Bucket #{currentBucketNum?.toString() ?? "..."}</div>
+          <div className="font-bold text-3xl">{remainingSec !== null ? `${remainingSec}s` : "..."}</div>
+          <div className="text-xs text-gray-400">until next bucket</div>
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/EditableCell.tsx b/extension/packages/nextjs/components/oracle/EditableCell.tsx
index 9ac93870..1dde18ae 100644
--- a/extension/packages/nextjs/components/oracle/EditableCell.tsx
+++ b/extension/packages/nextjs/components/oracle/EditableCell.tsx
@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from "react";
 import { HighlightedCell } from "./HighlightedCell";
 import { parseEther } from "viem";
 import { useWriteContract } from "wagmi";
-import { PencilIcon } from "@heroicons/react/24/outline";
+import { ArrowPathIcon, PencilIcon } from "@heroicons/react/24/outline";
 import { SIMPLE_ORACLE_ABI } from "~~/utils/constants";
 import { notification } from "~~/utils/scaffold-eth";
 
@@ -14,6 +14,7 @@ type EditableCellProps = {
 
 export const EditableCell = ({ value, address, highlightColor = "" }: EditableCellProps) => {
   const [isEditing, setIsEditing] = useState(false);
+  const [isRefreshing, setIsRefreshing] = useState(false);
   const [editValue, setEditValue] = useState(Number(value.toString()) || "");
   const inputRef = useRef<HTMLInputElement>(null);
 
@@ -55,6 +56,25 @@ export const EditableCell = ({ value, address, highlightColor = "" }: EditableCe
     }
   };
 
+  // Resubmits the currently displayed value without entering edit mode
+  const handleRefresh = async () => {
+    const parsedValue = Number(value.toString());
+    if (isNaN(parsedValue)) {
+      notification.error("Invalid number");
+      return;
+    }
+    try {
+      await writeContractAsync({
+        abi: SIMPLE_ORACLE_ABI,
+        address: address,
+        functionName: "setPrice",
+        args: [parseEther(parsedValue.toString())],
+      });
+    } catch (error) {
+      console.error("Refresh failed:", error);
+    }
+  };
+
   const handleCancel = () => {
     setIsEditing(false);
   };
@@ -64,7 +84,11 @@ export const EditableCell = ({ value, address, highlightColor = "" }: EditableCe
   };
 
   return (
-    <HighlightedCell value={value} highlightColor={highlightColor} className={`w-[40%] max-w-[40%] overflow-hidden`}>
+    <HighlightedCell
+      value={value}
+      highlightColor={highlightColor}
+      className={`w-[6rem] max-w-[6rem] whitespace-nowrap overflow-hidden`}
+    >
       <div className="flex w-full items-start">
         {/* 70% width for value display/editing */}
         <div className="w-[70%]">
@@ -80,10 +104,27 @@ export const EditableCell = ({ value, address, highlightColor = "" }: EditableCe
             </div>
           ) : (
             <div className="flex items-center gap-2 h-full items-stretch">
-              {value}
-              <button className="px-2 text-sm bg-primary rounded cursor-pointer" onClick={startEditing}>
-                <PencilIcon className="w-2.5 h-2.5" />
-              </button>
+              <span className="truncate">{value}</span>
+              <div className="flex items-stretch gap-1">
+                <button className="px-2 text-sm bg-primary rounded cursor-pointer" onClick={startEditing} title="Edit price">
+                  <PencilIcon className="w-2.5 h-2.5" />
+                </button>
+                <button
+                  className="px-2 text-sm bg-secondary rounded cursor-pointer disabled:opacity-50"
+                  onClick={() => {
+                    if (isRefreshing) return;
+                    setIsRefreshing(true);
+                    try {
+                      void handleRefresh();
+                    } catch {}
+                    setTimeout(() => setIsRefreshing(false), 3000);
+                  }}
+                  disabled={isRefreshing}
+                  title="Resubmit price"
+                >
+                  <ArrowPathIcon className={`w-2.5 h-2.5 ${isRefreshing ? "animate-spin" : ""}`} />
+                </button>
+              </div>
             </div>
           )}
         </div>
diff --git a/extension/packages/nextjs/components/oracle/NodeRow.tsx b/extension/packages/nextjs/components/oracle/NodeRow.tsx
index 5ab51118..30e048a9 100644
--- a/extension/packages/nextjs/components/oracle/NodeRow.tsx
+++ b/extension/packages/nextjs/components/oracle/NodeRow.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useMemo } from "react";
 import { ConfigSlider } from "./ConfigSlider";
 import { NodeRowProps } from "./types";
 import { erc20Abi, formatEther } from "viem";
@@ -8,78 +8,199 @@ import { Address } from "~~/components/scaffold-eth";
 import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
 import { getHighlightColorForPrice } from "~~/utils/helpers";
 
-export const NodeRow = ({ address, isStale }: NodeRowProps) => {
+export interface NodeRowEditRequest {
+  address: string;
+  buttonRect: { top: number; left: number; bottom: number; right: number };
+}
+
+interface NodeRowWithEditProps extends NodeRowProps {
+  onEditRequest?: (req: NodeRowEditRequest) => void;
+  isEditing?: boolean;
+  showInlineSettings?: boolean;
+}
+
+export const NodeRow = ({ address, bucketNumber, showInlineSettings }: NodeRowWithEditProps) => {
+  // Hooks and contract reads
   const { data = [] } = useScaffoldReadContract({
     contractName: "StakingOracle",
     functionName: "nodes",
     args: [address],
+    watch: true,
   });
-
   const { data: oracleTokenAddress } = useScaffoldReadContract({
     contractName: "StakingOracle",
     functionName: "oracleToken",
   });
-
   const { data: oraBalance } = useReadContract({
     address: oracleTokenAddress as `0x${string}`,
     abi: erc20Abi,
     functionName: "balanceOf",
     args: [address],
-    query: {
-      enabled: !!oracleTokenAddress,
-      refetchInterval: 5000, // Refetch every 5 seconds
-    },
+    query: { enabled: !!oracleTokenAddress, refetchInterval: 5000 },
   });
-
   const { data: minimumStake } = useScaffoldReadContract({
     contractName: "StakingOracle",
     functionName: "MINIMUM_STAKE",
     args: undefined,
   });
+  const { data: currentBucket } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getCurrentBucketNumber",
+  }) as { data: bigint | undefined };
 
-  const { data: medianPrice } = useScaffoldReadContract({
+  const previousBucket = useMemo(
+    () => (currentBucket && currentBucket > 0n ? currentBucket - 1n : 0n),
+    [currentBucket],
+  );
+
+  const { data: prevBucketAverage } = useScaffoldReadContract({
     contractName: "StakingOracle",
-    functionName: "getPrice",
+    functionName: "getPastPrice",
+    args: [previousBucket] as any,
   }) as { data: bigint | undefined };
 
-  const [, stakedAmount, lastReportedPrice] = data;
+  // Get bucket stats for the selected past bucket (for deviation calculation)
+  // Temporarily using any to bypass TypeScript until contract is redeployed
+  const { data: selectedBucketStats } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "timeBuckets",
+    args: (bucketNumber !== null && bucketNumber !== undefined ? [bucketNumber] : [0n]) as any,
+  }) as { data?: [bigint, bigint] };
 
-  const prevMedianPrice = useRef<bigint | undefined>(undefined);
+  const { data: effectiveStake } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getEffectiveStake",
+    args: [address],
+  }) as { data: bigint | undefined };
 
-  useEffect(() => {
-    if (medianPrice !== undefined && medianPrice !== prevMedianPrice.current) {
-      prevMedianPrice.current = medianPrice;
-    }
-  }, [medianPrice]);
+  // Get current bucket price
+  const { data: currentBucketPrice } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getAddressDataAtBucket",
+    args: [address, currentBucket ?? 0n] as const,
+    watch: true,
+  }) as { data?: [bigint, boolean] };
+
+  const reportedPriceInCurrentBucket = currentBucketPrice?.[0];
+
+  // Past bucket data (always call hook; gate via enabled)
+  const isCurrentView = bucketNumber === null || bucketNumber === undefined;
+
+  const { data: addressDataAtBucket } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getAddressDataAtBucket",
+    args: [address, (bucketNumber ?? 0n) as any],
+    query: { enabled: !isCurrentView },
+  }) as { data?: [bigint, boolean] };
+
+  const pastReportedPrice = !isCurrentView && addressDataAtBucket ? addressDataAtBucket[0] : undefined;
+  const pastSlashed = !isCurrentView && addressDataAtBucket ? addressDataAtBucket[1] : undefined;
 
-  const stakedAmountFormatted = stakedAmount !== undefined ? Number(formatEther(stakedAmount)) : "Loading...";
+  // Formatting
+  const stakedAmountFormatted = effectiveStake !== undefined ? Number(formatEther(effectiveStake)) : "Loading...";
   const lastReportedPriceFormatted =
-    lastReportedPrice !== undefined ? Number(parseFloat(formatEther(lastReportedPrice)).toFixed(2)) : "Not reported";
+    reportedPriceInCurrentBucket !== undefined && reportedPriceInCurrentBucket !== 0n
+      ? `$${Number(parseFloat(formatEther(reportedPriceInCurrentBucket)).toFixed(2))}`
+      : "Not reported";
   const oraBalanceFormatted = oraBalance !== undefined ? Number(formatEther(oraBalance)) : "Loading...";
+  const isInsufficientStake =
+    effectiveStake !== undefined && minimumStake !== undefined && effectiveStake < (minimumStake as bigint);
+
+  // Calculate deviation for past buckets
+  const deviationText = useMemo(() => {
+    if (isCurrentView) return "—";
+    if (!pastReportedPrice || pastReportedPrice === 0n || !bucketNumber) return "—";
+    if (!selectedBucketStats || !selectedBucketStats[0] || !selectedBucketStats[1]) return "—";
+
+    const [countReports, sumPrices] = selectedBucketStats;
+
+    // Exclude this node's price from the average calculation
+    const adjustedCount = countReports - 1n;
+    const adjustedSum = sumPrices - pastReportedPrice;
+
+    if (adjustedCount === 0n || adjustedSum === 0n) return "—";
+
+    const averageWithoutNode = Number(adjustedSum) / Number(adjustedCount);
+    const price = Number(pastReportedPrice);
+
+    if (averageWithoutNode === 0) return "—";
+    const pct = ((price - averageWithoutNode) / averageWithoutNode) * 100;
+    const sign = pct > 0 ? "+" : "";
+    return `${sign}${pct.toFixed(2)}%`;
+  }, [selectedBucketStats, pastReportedPrice, bucketNumber, isCurrentView]);
 
-  // Check if staked amount is below minimum requirement
-  const isInsufficientStake = stakedAmount !== undefined && minimumStake !== undefined && stakedAmount < minimumStake;
+  // Deviation for current bucket vs previous bucket average
+  const currentDeviationText = useMemo(() => {
+    if (!isCurrentView) return "—";
+    if (!reportedPriceInCurrentBucket || reportedPriceInCurrentBucket === 0n) return "—";
+    if (!prevBucketAverage || prevBucketAverage === 0n) return "—";
+    const avg = Number(prevBucketAverage);
+    const price = Number(reportedPriceInCurrentBucket);
+    if (avg === 0) return "—";
+    const pct = ((price - avg) / avg) * 100;
+    const sign = pct > 0 ? "+" : "";
+    return `${sign}${pct.toFixed(2)}%`;
+  }, [isCurrentView, reportedPriceInCurrentBucket, prevBucketAverage]);
 
   return (
-    <tr className={isInsufficientStake ? "opacity-40" : ""}>
-      <td>
-        <Address address={address} size="sm" format="short" onlyEnsOrAddress={true} />
-      </td>
-      <HighlightedCell value={stakedAmountFormatted} highlightColor="bg-error">
-        {stakedAmountFormatted}
-      </HighlightedCell>
-      <HighlightedCell
-        value={lastReportedPriceFormatted}
-        highlightColor={getHighlightColorForPrice(lastReportedPrice, medianPrice)}
-        className={isStale ? "opacity-40" : ""}
-      >
-        {lastReportedPriceFormatted}
-      </HighlightedCell>
-      <HighlightedCell value={oraBalanceFormatted} highlightColor="bg-success">
-        {oraBalanceFormatted}
-      </HighlightedCell>
-      <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="skip-probability" label="skip rate" />
-      <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="price-variance" label="variance" />
-    </tr>
+    <>
+      <tr className={isInsufficientStake ? "opacity-40" : ""}>
+        <td>
+          <Address address={address} size="sm" format="short" onlyEnsOrAddress={true} />
+        </td>
+        {showInlineSettings ? (
+          // Inline settings mode: only show the settings sliders column
+          <td className="whitespace-nowrap">
+            <div className="flex flex-col gap-2 min-w-[220px]">
+              <div className="flex items-center gap-2">
+                <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="skip-probability" label="skip rate" />
+                <ConfigSlider nodeAddress={address.toLowerCase()} endpoint="price-variance" label="price deviation" />
+              </div>
+            </div>
+          </td>
+        ) : isCurrentView ? (
+          <>
+            <HighlightedCell value={stakedAmountFormatted} highlightColor="bg-error">
+              Ξ {stakedAmountFormatted}
+            </HighlightedCell>
+            <HighlightedCell value={oraBalanceFormatted} highlightColor="bg-success">
+              {oraBalanceFormatted}
+            </HighlightedCell>
+            <HighlightedCell
+              value={lastReportedPriceFormatted}
+              highlightColor={getHighlightColorForPrice(
+                data && data.length > 0 && typeof data[1] === "bigint" ? data[1] : 0n,
+                prevBucketAverage,
+              )}
+              className={""}
+            >
+              {lastReportedPriceFormatted}
+            </HighlightedCell>
+            <td>{currentDeviationText}</td>
+          </>
+        ) : (
+          <>
+            <HighlightedCell
+              value={
+                pastReportedPrice !== undefined && pastReportedPrice !== 0n
+                  ? `$${Number(parseFloat(formatEther(pastReportedPrice)).toFixed(2))}`
+                  : "Not reported"
+              }
+              highlightColor={
+                pastSlashed ? "bg-error" : getHighlightColorForPrice(pastReportedPrice, prevBucketAverage)
+              }
+              className={pastSlashed ? "border-2 border-error" : ""}
+            >
+              {pastReportedPrice !== undefined && pastReportedPrice !== 0n
+                ? `$${Number(parseFloat(formatEther(pastReportedPrice)).toFixed(2))}`
+                : "Not reported"}
+              {pastSlashed && <span className="ml-2 text-xs text-error">Slashed</span>}
+            </HighlightedCell>
+            <td>{deviationText}</td>
+          </>
+        )}
+      </tr>
+      {/* No inline editor row; editor is rendered by parent as floating panel */}
+    </>
   );
 };
diff --git a/extension/packages/nextjs/components/oracle/NodesTable.tsx b/extension/packages/nextjs/components/oracle/NodesTable.tsx
index 1c894cb1..6239e7af 100644
--- a/extension/packages/nextjs/components/oracle/NodesTable.tsx
+++ b/extension/packages/nextjs/components/oracle/NodesTable.tsx
@@ -1,110 +1,482 @@
+import React, { useEffect, useMemo, useRef, useState } from "react";
 import TooltipInfo from "../TooltipInfo";
-import { NodeRow } from "./NodeRow";
-import { useScaffoldReadContract } from "~~/hooks/scaffold-eth";
+import { ConfigSlider } from "./ConfigSlider";
+import { NodeRow, NodeRowEditRequest } from "./NodeRow";
+import { SelfNodeRow } from "./SelfNodeRow";
+import { parseEther } from "viem";
+import { useAccount, usePublicClient } from "wagmi";
+import { Cog6ToothIcon } from "@heroicons/react/24/outline";
+import {
+  useDeployedContractInfo,
+  useScaffoldEventHistory,
+  useScaffoldReadContract,
+  useScaffoldWriteContract,
+} from "~~/hooks/scaffold-eth";
+import { useGlobalState } from "~~/services/store/store";
 
-const LoadingRow = () => {
-  return (
-    <tr>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-32"></div>
-      </td>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-20"></div>
-      </td>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-24"></div>
-      </td>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-20"></div>
-      </td>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-32"></div>
-      </td>
-      <td className="animate-pulse">
-        <div className="h-8 bg-secondary rounded w-32"></div>
-      </td>
-    </tr>
-  );
-};
+const LoadingRow = ({ colCount = 5 }: { colCount?: number }) => (
+  <tr>
+    <td colSpan={colCount} className="animate-pulse">
+      <div className="h-8 bg-secondary rounded w-full" />
+    </td>
+  </tr>
+);
+const NoNodesRow = ({ colSpan = 5 }: { colSpan?: number }) => (
+  <tr>
+    <td colSpan={colSpan} className="text-center">
+      No nodes found
+    </td>
+  </tr>
+);
+
+const SlashAllButton = ({ selectedBucket }: { selectedBucket: bigint }) => {
+  const publicClient = usePublicClient();
+  const { data: stakingDeployment } = useDeployedContractInfo({ contractName: "StakingOracle" });
+  const { writeContractAsync: writeStakingOracle } = useScaffoldWriteContract({ contractName: "StakingOracle" });
+  const { data: outliers } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getOutlierNodes",
+    args: [selectedBucket] as any,
+    watch: true,
+  }) as { data: string[] | undefined };
+  const { data: nodeAddresses } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getNodeAddresses",
+    watch: true,
+  }) as { data: string[] | undefined };
+
+  const [unslashed, setUnslashed] = React.useState<string[]>([]);
+
+  React.useEffect(() => {
+    const check = async () => {
+      if (!outliers || !publicClient || !stakingDeployment) {
+        setUnslashed([]);
+        return;
+      }
+      const list: string[] = [];
+      for (const addr of outliers) {
+        try {
+          const [, isSlashed] = (await publicClient.readContract({
+            address: stakingDeployment.address as `0x${string}`,
+            abi: stakingDeployment.abi as any,
+            functionName: "getAddressDataAtBucket",
+            args: [addr, selectedBucket],
+          })) as [bigint, boolean];
+          if (!isSlashed) list.push(addr);
+        } catch {
+          // assume not slashed on read error
+          list.push(addr);
+        }
+      }
+      setUnslashed(list);
+    };
+    check();
+    const id = setInterval(check, 2000);
+    return () => clearInterval(id);
+  }, [outliers, selectedBucket, publicClient, stakingDeployment]);
+
+  const handleSlashAll = async () => {
+    if (!unslashed.length || !nodeAddresses) return;
+    try {
+      for (const addr of unslashed) {
+        const idx = nodeAddresses.findIndex(a => a?.toLowerCase() === addr.toLowerCase());
+        if (idx === -1) continue;
+        try {
+          await writeStakingOracle({
+            functionName: "slashNode",
+            args: [addr as `0x${string}`, selectedBucket, BigInt(idx)],
+          });
+        } catch {
+          // continue slashing the rest
+        }
+      }
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
 
-const NoNodesRow = () => {
   return (
-    <tr>
-      <td colSpan={6} className="text-center">
-        No nodes found
-      </td>
-    </tr>
+    <button
+      className="btn btn-error btn-sm mr-2"
+      onClick={handleSlashAll}
+      disabled={unslashed.length === 0}
+      title={unslashed.length ? `Slash ${unslashed.length} outlier node(s)` : "No slashable nodes"}
+    >
+      Slash{unslashed.length ? ` (${unslashed.length})` : ""}
+    </button>
   );
 };
 
-export const NodesTable = () => {
-  const { data: nodeAddresses, isLoading } = useScaffoldReadContract({
+export const NodesTable = ({
+  selectedBucket: externalSelectedBucket,
+  onBucketChange,
+}: {
+  selectedBucket?: bigint | "current";
+  onBucketChange?: (bucket: bigint | "current") => void;
+} = {}) => {
+  const [editingNode, setEditingNode] = useState<{ address: string; pos: { top: number; left: number } } | null>(null);
+  const [showInlineSettings, setShowInlineSettings] = useState(false);
+  const handleEditRequest = (req: NodeRowEditRequest) => {
+    setEditingNode({ address: req.address, pos: { top: req.buttonRect.bottom + 8, left: req.buttonRect.left } });
+  };
+  const handleCloseEditor = () => setEditingNode(null);
+  const { address: connectedAddress } = useAccount();
+  const { data: currentBucketData } = useScaffoldReadContract({
     contractName: "StakingOracle",
-    functionName: "getNodeAddresses",
+    functionName: "getCurrentBucketNumber",
+  }) as { data: bigint | undefined };
+  const currentBucket = currentBucketData ?? undefined;
+  const [internalSelectedBucket, setInternalSelectedBucket] = useState<bigint | "current">("current");
+  const selectedBucket = externalSelectedBucket ?? internalSelectedBucket;
+  const setSelectedBucket = (bucket: bigint | "current") => {
+    setInternalSelectedBucket(bucket);
+    onBucketChange?.(bucket);
+  };
+  const [animateDir, setAnimateDir] = useState<"left" | "right" | null>(null);
+  const [animateKey, setAnimateKey] = useState(0);
+  const [entering, setEntering] = useState(true);
+  const lastCurrentBucketRef = useRef<bigint | null>(null);
+  const { data: registeredEvents, isLoading: isLoadingRegistered } = useScaffoldEventHistory({
+    contractName: "StakingOracle",
+    eventName: "NodeRegistered",
+    watch: true,
   });
-
-  const { data: staleNodesData } = useScaffoldReadContract({
+  const { data: exitedEvents, isLoading: isLoadingExited } = useScaffoldEventHistory({
     contractName: "StakingOracle",
-    functionName: "separateStaleNodes",
-    args: [nodeAddresses || []],
+    eventName: "NodeExited",
+    watch: true,
   });
-
+  const eventDerivedNodeAddresses: string[] = (() => {
+    const set = new Set<string>();
+    (registeredEvents || []).forEach(ev => {
+      const addr = (ev?.args?.node as string | undefined)?.toLowerCase();
+      if (addr) set.add(addr);
+    });
+    (exitedEvents || []).forEach(ev => {
+      const addr = (ev?.args?.node as string | undefined)?.toLowerCase();
+      if (addr) set.delete(addr);
+    });
+    return Array.from(set.values());
+  })();
+  const hasEverRegisteredSelf = useMemo(() => {
+    if (!connectedAddress) return false;
+    const lower = connectedAddress.toLowerCase();
+    return (registeredEvents || []).some(ev => {
+      const addr = (ev?.args?.node as string | undefined)?.toLowerCase();
+      return addr === lower;
+    });
+  }, [registeredEvents, connectedAddress]);
+  useEffect(() => {
+    if (currentBucket === undefined) return;
+    const last = lastCurrentBucketRef.current;
+    // In inline settings mode, keep the UI stable (no animation on bucket changes)
+    if (showInlineSettings) {
+      lastCurrentBucketRef.current = currentBucket;
+      return;
+    }
+    if (last !== null && currentBucket > last) {
+      if (selectedBucket === "current") {
+        setAnimateDir("left");
+        setAnimateKey(k => k + 1);
+        setEntering(false);
+        setTimeout(() => setEntering(true), 20);
+      }
+    }
+    lastCurrentBucketRef.current = currentBucket;
+  }, [currentBucket, selectedBucket, showInlineSettings]);
+  const changeBucketWithAnimation = (newBucket: bigint | "current", dir: "left" | "right") => {
+    setAnimateDir(dir);
+    setAnimateKey(k => k + 1);
+    setEntering(false);
+    setSelectedBucket(newBucket);
+    setTimeout(() => setEntering(true), 20);
+  };
+  const triggerSlide = (dir: "left" | "right") => {
+    setAnimateDir(dir);
+    setAnimateKey(k => k + 1);
+    setEntering(false);
+    setTimeout(() => setEntering(true), 20);
+  };
   const tooltipText =
     "This table displays registered oracle nodes that provide price data to the system. Nodes are displayed as inactive if they don't have enough ETH staked. You can edit the skip probability and price variance of an oracle node with the slider.";
+  const { writeContractAsync: writeStakingOracle } = useScaffoldWriteContract({ contractName: "StakingOracle" });
+  const nativeCurrencyPrice = useGlobalState(state => state.nativeCurrency.price);
+  const { data: nodeAddresses } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getNodeAddresses",
+    watch: true,
+  });
+  const isSelfRegistered = Boolean(
+    (nodeAddresses as string[] | undefined)?.some(
+      addr => addr?.toLowerCase() === (connectedAddress || "").toLowerCase(),
+    ),
+  );
+  const handleRegisterSelf = async () => {
+    if (!connectedAddress) return;
+    try {
+      const initialPrice = nativeCurrencyPrice > 0 ? parseEther(nativeCurrencyPrice.toString()) : 0n;
+      await writeStakingOracle({ functionName: "registerNode", args: [initialPrice], value: parseEther("1") });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+  const handleClaimRewards = async () => {
+    if (!connectedAddress) return;
+    try {
+      await writeStakingOracle({ functionName: "claimReward" });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+  const handleExitNode = async () => {
+    if (!connectedAddress) return;
+    if (!isSelfRegistered) return;
+    if (!nodeAddresses) return;
+    const list = nodeAddresses as string[];
+    const idx = list.findIndex(addr => addr?.toLowerCase() === connectedAddress.toLowerCase());
+    if (idx === -1) return;
+    try {
+      await writeStakingOracle({ functionName: "exitNode", args: [BigInt(idx)] });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+  const filteredNodeAddresses = (eventDerivedNodeAddresses || []).filter(
+    (addr: string) => addr?.toLowerCase() !== (connectedAddress || "").toLowerCase(),
+  );
+  return (
+    <>
+      <div className="flex flex-col gap-2">
+        <div className="flex items-center gap-2 justify-between">
+          <div className="flex items-center gap-2">
+            <h2 className="text-xl font-bold">Oracle Nodes</h2>
+            <span>
+              <TooltipInfo infoText={tooltipText} />
+            </span>
+          </div>
+          <div className="flex items-center gap-2">
+            <div className="flex items-center gap-1">
+              {/* Slash button near navigation (left of left arrow) */}
+              {selectedBucket !== "current" && <SlashAllButton selectedBucket={selectedBucket as bigint} />}
+              {/* Previous (<) */}
+              <button
+                className="btn btn-ghost btn-sm"
+                onClick={() => {
+                  if (selectedBucket === "current" && currentBucket && currentBucket > 1n) {
+                    changeBucketWithAnimation(currentBucket - 1n, "right");
+                  } else if (typeof selectedBucket === "bigint" && selectedBucket > 1n) {
+                    changeBucketWithAnimation(selectedBucket - 1n, "right");
+                  }
+                }}
+                disabled={selectedBucket === "current" ? !currentBucket || currentBucket <= 1n : selectedBucket <= 1n}
+                title="Previous bucket"
+              >
+                ←
+              </button>
 
-  // Extract stale node addresses from the returned data
-  const staleNodeAddresses = staleNodesData?.[1] || [];
+              {/* Current selected bucket label (non-clickable) */}
+              <span className="px-2 text-sm tabular-nums select-none">
+                {selectedBucket === "current"
+                  ? currentBucket !== undefined
+                    ? currentBucket.toString()
+                    : "..."
+                  : (selectedBucket as bigint).toString()}
+              </span>
 
-  return (
-    <div className="flex flex-col gap-2">
-      <div className="flex items-center gap-2">
-        <h2 className="text-xl font-bold">Oracle Nodes</h2>
-        <span>
-          <TooltipInfo infoText={tooltipText} />
-        </span>
-      </div>
-      <div className="bg-base-100 rounded-lg p-4 relative">
-        <div className="overflow-x-auto">
-          <table className="table w-full">
-            <thead>
-              <tr>
-                <th>Node Address</th>
-                <th>
-                  <div className="flex items-center gap-1">
-                    Staked ETH
-                    <TooltipInfo infoText="Red shows slashing event" />
-                  </div>
-                </th>
-                <th>
-                  <div className="flex items-center gap-1">
-                    Last Reported Price (USD)
-                    <TooltipInfo infoText="Color shows proximity to median price" />
-                  </div>
-                </th>
-                <th>
-                  <div className="flex items-center gap-1">
-                    ORA Balance
-                    <TooltipInfo infoText="Green shows positive balance" />
-                  </div>
-                </th>
-                <th>Skip Probability</th>
-                <th>Price Variance</th>
-              </tr>
-            </thead>
-            <tbody>
-              {isLoading ? (
-                <LoadingRow />
-              ) : nodeAddresses?.length === 0 ? (
-                <NoNodesRow />
-              ) : (
-                nodeAddresses?.map((address: string, index: number) => (
-                  <NodeRow key={index} index={index} address={address} isStale={staleNodeAddresses.includes(address)} />
-                ))
-              )}
-            </tbody>
-          </table>
+              {/* Next (>) */}
+              <button
+                className="btn btn-ghost btn-sm"
+                onClick={() => {
+                  if (selectedBucket === "current") return;
+                  if (typeof selectedBucket === "bigint" && currentBucket && selectedBucket < currentBucket - 1n) {
+                    changeBucketWithAnimation(selectedBucket + 1n, "left");
+                  } else if (
+                    typeof selectedBucket === "bigint" &&
+                    currentBucket &&
+                    selectedBucket === currentBucket - 1n
+                  ) {
+                    changeBucketWithAnimation("current", "left");
+                  }
+                }}
+                disabled={
+                  selectedBucket === "current" ||
+                  currentBucket === undefined ||
+                  (typeof selectedBucket === "bigint" && selectedBucket >= currentBucket)
+                }
+                title="Next bucket"
+              >
+                →
+              </button>
+
+              {/* Go to Current button */}
+              <button
+                className="btn btn-ghost btn-sm ml-2"
+                onClick={() => {
+                  const dir: "left" | "right" = showInlineSettings ? "right" : "left";
+                  if (showInlineSettings) setShowInlineSettings(false);
+                  changeBucketWithAnimation("current", dir);
+                }}
+                disabled={showInlineSettings ? false : selectedBucket === "current"}
+                title="Go to current bucket"
+              >
+                Go to Current
+              </button>
+
+              {/* Inline settings toggle */}
+              <button
+                className={`btn btn-ghost btn-sm ml-1 ${showInlineSettings ? "text-primary" : ""}`}
+                onClick={() => {
+                  if (!showInlineSettings) {
+                    // Opening settings: slide left
+                    triggerSlide("left");
+                  } else {
+                    // Closing settings: slide right for a natural return
+                    triggerSlide("right");
+                  }
+                  setShowInlineSettings(v => !v);
+                }}
+                title={showInlineSettings ? "Hide inline settings" : "Show inline settings"}
+              >
+                <Cog6ToothIcon className="w-4 h-4" />
+              </button>
+            </div>
+            {connectedAddress && !isSelfRegistered ? (
+              <button className="btn btn-primary btn-sm font-normal" onClick={handleRegisterSelf}>
+                Register Node (1 ETH)
+              </button>
+            ) : (
+              <>
+                <button
+                  className="btn btn-primary btn-sm font-normal"
+                  onClick={handleClaimRewards}
+                  disabled={!isSelfRegistered}
+                >
+                  Claim Rewards
+                </button>
+                <button
+                  className="btn btn-error btn-sm font-normal"
+                  onClick={handleExitNode}
+                  disabled={!isSelfRegistered}
+                >
+                  Exit Node
+                </button>
+              </>
+            )}
+          </div>
+        </div>
+        <div className="bg-base-100 rounded-lg p-4 relative">
+          <div className="overflow-x-auto">
+            <div
+              key={animateKey}
+              className={`transform transition-transform duration-300 ${
+                entering ? "translate-x-0" : animateDir === "left" ? "translate-x-full" : "-translate-x-full"
+              }`}
+            >
+              <table className="table w-full">
+                <thead>
+                  <tr>
+                    {showInlineSettings ? (
+                      <>
+                        <th>Node Address</th>
+                        <th>Node Settings</th>
+                      </>
+                    ) : selectedBucket === "current" ? (
+                      <>
+                        <th>Node Address</th>
+                        <th>Stake</th>
+                        <th>ORA</th>
+                        <th>Reported Price</th>
+                        <th>
+                          <div className="flex items-center gap-1">
+                            Deviation
+                            <TooltipInfo
+                              className="tooltip-left"
+                              infoText="Percentage difference from the average of all other reported prices"
+                            />
+                          </div>
+                        </th>
+                      </>
+                    ) : (
+                      <>
+                        <th>Node Address</th>
+                        <th>Reported Price</th>
+                        <th>
+                          <div className="flex items-center gap-1">
+                            Deviation
+                            <TooltipInfo
+                              className="tooltip-left"
+                              infoText="Percentage difference from the average of all other reported prices"
+                            />
+                          </div>
+                        </th>
+                      </>
+                    )}
+                  </tr>
+                </thead>
+                <tbody>
+                  {!showInlineSettings && (
+                    <>
+                      {selectedBucket === "current" ? (
+                        isSelfRegistered || hasEverRegisteredSelf ? (
+                          <SelfNodeRow isStale={false} bucketNumber={null} />
+                        ) : null
+                      ) : isSelfRegistered || hasEverRegisteredSelf ? (
+                        <SelfNodeRow isStale={false} bucketNumber={selectedBucket as bigint} />
+                      ) : null}
+                      {isSelfRegistered && (
+                        <tr>
+                          <td colSpan={9} className="py-2">
+                            <div className="text-center text-xs uppercase tracking-wider">Simulation Script Nodes</div>
+                          </td>
+                        </tr>
+                      )}
+                    </>
+                  )}
+                  {isLoadingRegistered || isLoadingExited ? (
+                    <LoadingRow colCount={showInlineSettings ? 2 : selectedBucket === "current" ? 5 : 4} />
+                  ) : filteredNodeAddresses.length === 0 ? (
+                    <NoNodesRow colSpan={showInlineSettings ? 2 : selectedBucket === "current" ? 5 : 4} />
+                  ) : (
+                    filteredNodeAddresses.map((address: string, index: number) => (
+                      <NodeRow
+                        key={index}
+                        index={index}
+                        address={address}
+                        bucketNumber={selectedBucket === "current" ? null : (selectedBucket as bigint)}
+                        onEditRequest={
+                          !showInlineSettings && selectedBucket === "current" ? handleEditRequest : undefined
+                        }
+                        showInlineSettings={showInlineSettings}
+                        isEditing={editingNode?.address === address}
+                      />
+                    ))
+                  )}
+                </tbody>
+              </table>
+            </div>
+          </div>
         </div>
       </div>
-    </div>
+      {editingNode && (
+        <div
+          style={{ position: "fixed", top: editingNode.pos.top, left: editingNode.pos.left, zIndex: 60, minWidth: 220 }}
+          className="mt-2 p-3 bg-base-200 rounded shadow-lg border"
+        >
+          <div className="flex flex-col gap-2">
+            <ConfigSlider
+              nodeAddress={editingNode.address.toLowerCase()}
+              endpoint="skip-probability"
+              label="skip rate"
+            />
+            <ConfigSlider nodeAddress={editingNode.address.toLowerCase()} endpoint="price-variance" label="variance" />
+            <div className="flex justify-end">
+              <button className="btn btn-sm btn-ghost" onClick={handleCloseEditor}>
+                Close
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </>
   );
 };
diff --git a/extension/packages/nextjs/components/oracle/PriceWidget.tsx b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
index b66c2d68..38b7553f 100644
--- a/extension/packages/nextjs/components/oracle/PriceWidget.tsx
+++ b/extension/packages/nextjs/components/oracle/PriceWidget.tsx
@@ -21,14 +21,31 @@ export const PriceWidget = ({ contractName }: PriceWidgetProps) => {
   const [highlight, setHighlight] = useState(false);
   const [highlightColor, setHighlightColor] = useState("");
   const prevPrice = useRef<bigint | undefined>(undefined);
+  const prevBucket = useRef<bigint | null>(null);
+  const [showBucketLoading, setShowBucketLoading] = useState(false);
 
-  const {
-    data: currentPrice,
-    isLoading,
-    isError,
-  } = useScaffoldReadContract({
+  // Poll getCurrentBucketNumber to detect bucket changes
+  const { data: contractBucketNum } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getCurrentBucketNumber",
+    watch: true,
+  }) as { data: bigint | undefined };
+
+  useEffect(() => {
+    if (contractBucketNum !== undefined) {
+      // Check if bucket changed
+      if (prevBucket.current !== null && contractBucketNum !== prevBucket.current) {
+        setShowBucketLoading(true);
+        setTimeout(() => setShowBucketLoading(false), 2000); // Show loading for 2 seconds after bucket change
+      }
+      prevBucket.current = contractBucketNum;
+    }
+  }, [contractBucketNum]);
+
+  const isStaking = contractName === "StakingOracle";
+  const { data: currentPrice, isError } = useScaffoldReadContract({
     contractName,
-    functionName: "getPrice",
+    functionName: isStaking ? ("getLatestPrice" as any) : ("getPrice" as any),
     watch: true,
   }) as { data: bigint | undefined; isError: boolean; isLoading: boolean };
 
@@ -45,24 +62,25 @@ export const PriceWidget = ({ contractName }: PriceWidgetProps) => {
   }, [currentPrice]);
 
   return (
-    <div className="flex flex-col gap-2">
+    <div className="flex flex-col gap-2 h-full">
       <h2 className="text-xl font-bold">Current Price</h2>
-      <div className="bg-base-100 rounded-lg p-4 w-1/2 md:w-1/4 mx-auto flex justify-center items-center relative">
+      <div className="bg-base-100 rounded-lg p-4 w-full flex justify-center items-center relative h-full min-h-[140px]">
         <TooltipInfo
           top={0}
           right={0}
+          className="tooltip-left"
           infoText="Displays the median price. If no oracle nodes have reported prices in the last 24 seconds, it will display 'No fresh price'. Color highlighting indicates how big of a change there was in the price."
         />
         <div className={`rounded-lg transition-colors duration-1000 ${highlight ? highlightColor : ""}`}>
-          <div className="font-bold h-10 text-4xl flex items-center justify-center">
-            {isError ? (
-              <div className="text-error text-xl">No fresh price</div>
-            ) : isLoading || currentPrice === undefined ? (
+          <div className="font-bold h-10 text-4xl flex items-center justify-center gap-4">
+            {showBucketLoading ? (
               <div className="animate-pulse">
                 <div className="h-10 bg-secondary rounded-md w-32"></div>
               </div>
+            ) : isError || currentPrice === undefined || currentPrice === 0n ? (
+              <div className="text-error text-xl">No fresh price</div>
             ) : (
-              `$${parseFloat(formatEther(currentPrice)).toFixed(2)}`
+              <span>{`$${parseFloat(formatEther(currentPrice)).toFixed(2)}`}</span>
             )}
           </div>
         </div>
diff --git a/extension/packages/nextjs/components/oracle/SelfNodeReporter.tsx b/extension/packages/nextjs/components/oracle/SelfNodeReporter.tsx
new file mode 100644
index 00000000..d7ce42e9
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/SelfNodeReporter.tsx
@@ -0,0 +1,183 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { formatEther, parseEther } from "viem";
+import { useAccount } from "wagmi";
+import TooltipInfo from "~~/components/TooltipInfo";
+import { useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { notification } from "~~/utils/scaffold-eth";
+
+export const SelfNodeReporter = () => {
+  const { address: connectedAddress } = useAccount();
+  const [stakeAmount, setStakeAmount] = useState<string>("1");
+  const [newPrice, setNewPrice] = useState<string>("");
+  // Helper to get node index for connected address
+  const { data: nodeAddresses } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getNodeAddresses",
+    watch: true,
+  });
+  const [initialPrice, setInitialPrice] = useState<string>("");
+  // Add exit node handler
+  const handleExitNode = async () => {
+    if (!isRegistered) {
+      return;
+    }
+    if (!nodeAddresses || !connectedAddress) {
+      return;
+    }
+    // Find index of connected address in nodeAddresses
+    const index = nodeAddresses.findIndex((addr: string) => addr.toLowerCase() === connectedAddress.toLowerCase());
+    if (index === -1) {
+      return;
+    }
+    try {
+      await writeStaking({ functionName: "exitNode", args: [BigInt(index)] });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+
+  const { data: nodeData } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "nodes",
+    args: [connectedAddress ?? "0x0000000000000000000000000000000000000000"] as any,
+    watch: true,
+  });
+
+  // firstBucket is at index 4 of OracleNode struct
+  const firstBucket = (nodeData?.[4] as bigint | undefined) ?? undefined;
+  const lastReportedBucket = (nodeData?.[1] as bigint | undefined) ?? undefined;
+  const stakedAmountRaw = (nodeData?.[0] as bigint | undefined) ?? undefined;
+
+  const { writeContractAsync: writeStaking } = useScaffoldWriteContract({ contractName: "StakingOracle" });
+
+  const isRegistered = useMemo(() => {
+    return Boolean(firstBucket && firstBucket > 0n);
+  }, [firstBucket]);
+
+  // Fetch last reported price using helper view: getAddressDataAtBucket(address, bucket)
+  const { data: addressDataAtBucket } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getAddressDataAtBucket",
+    args: [connectedAddress ?? "0x0000000000000000000000000000000000000000", lastReportedBucket ?? 0n] as any,
+    watch: true,
+  });
+  const lastReportedPrice = (addressDataAtBucket?.[0] as bigint | undefined) ?? undefined;
+
+  const handleStake = async () => {
+    if (!connectedAddress) {
+      return;
+    }
+    const amount = Number(stakeAmount);
+    if (isNaN(amount) || amount <= 0) {
+      return;
+    }
+    const priceNum = Number(initialPrice);
+    if (isNaN(priceNum) || priceNum <= 0) {
+      notification.error("Enter a valid initial price (USD)");
+      return;
+    }
+    try {
+      await writeStaking({
+        functionName: "registerNode",
+        args: [parseEther(priceNum.toString())],
+        value: parseEther(amount.toString()),
+      });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+
+  const handleReport = async () => {
+    const price = Number(newPrice);
+    if (isNaN(price)) {
+      notification.error("Enter a valid price");
+      return;
+    }
+    try {
+      await writeStaking({ functionName: "reportPrice", args: [parseEther(price.toString())] });
+      setNewPrice("");
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+
+  return (
+    <div className="bg-base-100 rounded-lg p-4 relative">
+      <div className="flex items-center justify-between mb-3">
+        <div className="flex items-center gap-2">
+          <h2 className="text-xl font-bold">My Node</h2>
+          <TooltipInfo infoText="Manage your own node with the connected wallet: stake to register, then report prices." />
+        </div>
+      </div>
+      <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+        <div className="flex flex-col gap-2">
+          <div className="text-sm text-gray-500">Node Address</div>
+          <div className="font-mono break-all">{connectedAddress ?? "Not connected"}</div>
+          <div className="text-sm text-gray-500">Staked ETH</div>
+          <div className="font-semibold">
+            {stakedAmountRaw !== undefined ? Number(formatEther(stakedAmountRaw)).toFixed(4) : "—"}
+          </div>
+          <div className="text-sm text-gray-500">Last Reported Price (USD)</div>
+          <div className="font-semibold">
+            {lastReportedPrice !== undefined ? Number(formatEther(lastReportedPrice)).toFixed(2) : "—"}
+          </div>
+          <div className="text-sm text-gray-500">ORA Balance</div>
+          <div className="font-semibold">{/* Displayed in NodeRow via ERC20 read; keep simple here */}—</div>
+          {/* Claim rewards and Exit Node buttons (shown if registered) */}
+          {isRegistered && (
+            <div className="flex gap-2 mt-2">
+              <button className="btn btn-secondary btn-sm" onClick={handleExitNode} disabled={!connectedAddress}>
+                Exit Node
+              </button>
+              {/* Placeholder for Claim Rewards button if/when implemented */}
+            </div>
+          )}
+        </div>
+        <div className="flex flex-col gap-3">
+          {!isRegistered ? (
+            <div className="flex items-end gap-2">
+              <div>
+                <div className="text-sm text-gray-500">Stake Amount (ETH)</div>
+                <input
+                  className="input input-bordered input-sm w-40"
+                  type="text"
+                  value={stakeAmount}
+                  onChange={e => setStakeAmount(e.target.value)}
+                />
+              </div>
+              <div>
+                <div className="text-sm text-gray-500">Initial Price (USD)</div>
+                <input
+                  className="input input-bordered input-sm w-40"
+                  type="text"
+                  value={initialPrice}
+                  onChange={e => setInitialPrice(e.target.value)}
+                />
+              </div>
+              <button className="btn btn-primary btn-sm" onClick={handleStake} disabled={!connectedAddress}>
+                Stake & Register
+              </button>
+            </div>
+          ) : (
+            <div className="flex items-end gap-2">
+              <div>
+                <div className="text-sm text-gray-500">Report Price (USD)</div>
+                <input
+                  className="input input-bordered input-sm w-40"
+                  type="text"
+                  value={newPrice}
+                  onChange={e => setNewPrice(e.target.value)}
+                />
+              </div>
+              <button className="btn btn-primary btn-sm" onClick={handleReport} disabled={!connectedAddress}>
+                Report
+              </button>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/SelfNodeRow.tsx b/extension/packages/nextjs/components/oracle/SelfNodeRow.tsx
new file mode 100644
index 00000000..b90f18a6
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/SelfNodeRow.tsx
@@ -0,0 +1,228 @@
+import { useEffect, useMemo, useRef } from "react";
+import { erc20Abi, formatEther, parseEther } from "viem";
+import { useAccount, useReadContract } from "wagmi";
+import { PlusIcon } from "@heroicons/react/24/outline";
+import { HighlightedCell } from "~~/components/oracle/HighlightedCell";
+import { StakingEditableCell } from "~~/components/oracle/StakingEditableCell";
+import { Address } from "~~/components/scaffold-eth";
+import { useDeployedContractInfo, useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { getHighlightColorForPrice } from "~~/utils/helpers";
+
+type SelfNodeRowProps = {
+  isStale: boolean;
+  bucketNumber?: bigint | null;
+};
+
+export const SelfNodeRow = ({ isStale, bucketNumber }: SelfNodeRowProps) => {
+  const { address: connectedAddress } = useAccount();
+
+  const { data: nodeData } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "nodes",
+    args: [connectedAddress as any],
+    watch: true,
+  });
+  // OracleNode struct layout: [0]=stakedAmount, [1]=lastReportedBucket, [2]=reportCount, [3]=claimedReportCount, [4]=firstBucket
+  const stakedAmount = nodeData?.[0] as bigint | undefined;
+
+  const { data: currentBucket } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getCurrentBucketNumber",
+  }) as { data: bigint | undefined };
+
+  const previousBucket = currentBucket && currentBucket > 0n ? currentBucket - 1n : 0n;
+
+  const { data: medianPrice } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getPastPrice",
+    args: [previousBucket] as any,
+  }) as { data: bigint | undefined };
+
+  const { data: oracleTokenAddress } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "oracleToken",
+  });
+
+  // Registered addresses array; authoritative for current membership
+  const { data: allNodeAddresses } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getNodeAddresses",
+    watch: true,
+  }) as { data: string[] | undefined };
+
+  const { data: oraBalance } = useReadContract({
+    address: oracleTokenAddress as `0x${string}`,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: connectedAddress ? [connectedAddress] : undefined,
+    query: { enabled: !!oracleTokenAddress && !!connectedAddress, refetchInterval: 5000 },
+  });
+
+  const { writeContractAsync: writeStaking } = useScaffoldWriteContract({ contractName: "StakingOracle" });
+  const { data: stakingDeployment } = useDeployedContractInfo({ contractName: "StakingOracle" });
+
+  const isRegistered = useMemo(() => {
+    if (!connectedAddress) return false;
+    if (!allNodeAddresses) return false;
+    return allNodeAddresses.some(a => a?.toLowerCase() === connectedAddress.toLowerCase());
+  }, [allNodeAddresses, connectedAddress]);
+
+  // Use wagmi's useReadContract for enabled gating to avoid reverts when not registered
+  const { data: effectiveStake } = useReadContract({
+    address: (stakingDeployment?.address as `0x${string}`) || undefined,
+    abi: (stakingDeployment?.abi as any) || undefined,
+    functionName: "getEffectiveStake",
+    args: connectedAddress ? [connectedAddress] : undefined,
+    query: { enabled: !!stakingDeployment?.address && !!connectedAddress && isRegistered, refetchInterval: 5000 },
+  }) as { data: bigint | undefined };
+
+  const stakedAmountFormatted = effectiveStake !== undefined ? Number(formatEther(effectiveStake)) : "Loading...";
+  // Current bucket reported price from contract (align with NodeRow)
+  const { data: currentBucketPrice } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getAddressDataAtBucket",
+    args: [connectedAddress || "0x0000000000000000000000000000000000000000", currentBucket ?? 0n] as const,
+    watch: true,
+  }) as { data?: [bigint, boolean] };
+  const reportedPriceInCurrentBucket = currentBucketPrice?.[0];
+  const hasReportedThisBucket = reportedPriceInCurrentBucket !== undefined && reportedPriceInCurrentBucket !== 0n;
+  const lastReportedPriceFormatted =
+    reportedPriceInCurrentBucket !== undefined && reportedPriceInCurrentBucket !== 0n
+      ? `$${Number(parseFloat(formatEther(reportedPriceInCurrentBucket)).toFixed(2))}`
+      : "Not reported";
+  const oraBalanceFormatted = oraBalance !== undefined ? Number(formatEther(oraBalance as bigint)) : "Loading...";
+
+  // Track previous staked amount to determine up/down changes for highlight
+  const prevStakedAmountRef = useRef<bigint | undefined>(undefined);
+  const prevStakedAmount = prevStakedAmountRef.current;
+  let stakeHighlightColor = "";
+  if (prevStakedAmount !== undefined && stakedAmount !== undefined && stakedAmount !== prevStakedAmount) {
+    stakeHighlightColor = stakedAmount > prevStakedAmount ? "bg-success" : "bg-error";
+  }
+  useEffect(() => {
+    prevStakedAmountRef.current = stakedAmount;
+  }, [stakedAmount]);
+
+  // Deviation for current bucket vs previous bucket average
+  const currentDeviationText = useMemo(() => {
+    if (!reportedPriceInCurrentBucket || reportedPriceInCurrentBucket === 0n) return "—";
+    if (!medianPrice || medianPrice === 0n) return "—";
+    const avg = Number(medianPrice);
+    const price = Number(reportedPriceInCurrentBucket);
+    if (avg === 0) return "—";
+    const pct = ((price - avg) / avg) * 100;
+    const sign = pct > 0 ? "+" : "";
+    return `${sign}${pct.toFixed(2)}%`;
+  }, [reportedPriceInCurrentBucket, medianPrice]);
+
+  const isCurrentView = bucketNumber === null || bucketNumber === undefined;
+
+  // For past buckets, fetch the reported price at that bucket
+  const { data: pastBucketPrice } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getAddressDataAtBucket",
+    args: [
+      connectedAddress || "0x0000000000000000000000000000000000000000",
+      !isCurrentView && bucketNumber ? bucketNumber : 0n,
+    ] as const,
+    watch: true,
+  }) as { data?: [bigint, boolean] };
+
+  const pastReportedPrice = !isCurrentView && pastBucketPrice ? pastBucketPrice[0] : undefined;
+  const pastSlashed = !isCurrentView && pastBucketPrice ? pastBucketPrice[1] : undefined;
+
+  // Calculate deviation for past bucket
+  const pastDeviationText = useMemo(() => {
+    if (isCurrentView) return "—";
+    if (!pastReportedPrice || pastReportedPrice === 0n || !bucketNumber) return "—";
+    if (!medianPrice || medianPrice === 0n) return "—";
+    const avg = Number(medianPrice);
+    const price = Number(pastReportedPrice);
+    if (avg === 0) return "—";
+    const pct = ((price - avg) / avg) * 100;
+    const sign = pct > 0 ? "+" : "";
+    return `${sign}${pct.toFixed(2)}%`;
+  }, [isCurrentView, pastReportedPrice, medianPrice, bucketNumber]);
+
+  const handleAddStake = async () => {
+    if (!connectedAddress) return;
+    try {
+      await writeStaking({ functionName: "addStake", value: parseEther("1") });
+    } catch (e: any) {
+      console.error(e);
+    }
+  };
+
+  return (
+    <tr className={isStale ? "opacity-40" : ""}>
+      <td>
+        {connectedAddress ? <Address address={connectedAddress} size="sm" format="short" onlyEnsOrAddress /> : "—"}
+      </td>
+      {isCurrentView ? (
+        isRegistered ? (
+          <>
+            <HighlightedCell value={stakedAmountFormatted} highlightColor={stakeHighlightColor}>
+              <div className="flex items-center gap-2 h-full items-stretch">
+                <span>Ξ {stakedAmountFormatted}</span>
+                <button
+                  className="px-2 text-sm bg-primary rounded cursor-pointer"
+                  onClick={handleAddStake}
+                  title="Add 1 ETH"
+                >
+                  <PlusIcon className="w-2.5 h-2.5" />
+                </button>
+              </div>
+            </HighlightedCell>
+            <HighlightedCell value={oraBalanceFormatted} highlightColor="bg-success">
+              {oraBalanceFormatted}
+            </HighlightedCell>
+            <StakingEditableCell
+              value={lastReportedPriceFormatted}
+              nodeAddress={connectedAddress || "0x0000000000000000000000000000000000000000"}
+              highlightColor={getHighlightColorForPrice(reportedPriceInCurrentBucket, medianPrice)}
+              className={""}
+              canEdit={isRegistered}
+              disabled={hasReportedThisBucket}
+            />
+            <td>{currentDeviationText}</td>
+          </>
+        ) : (
+          <>
+            <HighlightedCell value={"—"} highlightColor="">
+              Ξ —
+            </HighlightedCell>
+            <HighlightedCell value={oraBalanceFormatted} highlightColor="bg-success">
+              {oraBalanceFormatted}
+            </HighlightedCell>
+            <StakingEditableCell
+              value={"Must re-register"}
+              nodeAddress={connectedAddress || "0x0000000000000000000000000000000000000000"}
+              highlightColor={""}
+              className={""}
+              canEdit={false}
+            />
+            <td>—</td>
+          </>
+        )
+      ) : (
+        <>
+          <HighlightedCell
+            value={
+              pastReportedPrice !== undefined && pastReportedPrice !== 0n
+                ? `$${Number(parseFloat(formatEther(pastReportedPrice)).toFixed(2))}`
+                : "Not reported"
+            }
+            highlightColor={pastSlashed ? "bg-error" : getHighlightColorForPrice(pastReportedPrice, medianPrice)}
+            className={pastSlashed ? "border-2 border-error" : ""}
+          >
+            {pastReportedPrice !== undefined && pastReportedPrice !== 0n
+              ? `$${Number(parseFloat(formatEther(pastReportedPrice)).toFixed(2))}`
+              : "Not reported"}
+            {pastSlashed && <span className="ml-2 text-xs text-error">Slashed</span>}
+          </HighlightedCell>
+          <td>{pastDeviationText}</td>
+        </>
+      )}
+    </tr>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/StakingEditableCell.tsx b/extension/packages/nextjs/components/oracle/StakingEditableCell.tsx
new file mode 100644
index 00000000..b762e2ac
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/StakingEditableCell.tsx
@@ -0,0 +1,174 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { HighlightedCell } from "./HighlightedCell";
+import { formatEther, parseEther } from "viem";
+import { ArrowPathIcon, PencilIcon } from "@heroicons/react/24/outline";
+import { useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
+import { notification } from "~~/utils/scaffold-eth";
+
+type StakingEditableCellProps = {
+  value: string | number;
+  nodeAddress: string;
+  highlightColor?: string;
+  className?: string;
+  canEdit?: boolean;
+  disabled?: boolean;
+};
+
+export const StakingEditableCell = ({
+  value,
+  nodeAddress,
+  highlightColor = "",
+  className = "",
+  canEdit = true,
+  disabled = false,
+}: StakingEditableCellProps) => {
+  const [isEditing, setIsEditing] = useState(false);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const coerceToNumber = (val: string | number) => {
+    if (typeof val === "number") return val;
+    const numeric = Number(String(val).replace(/[^0-9.\-]/g, ""));
+    return Number.isFinite(numeric) ? numeric : NaN;
+  };
+  const [editValue, setEditValue] = useState<number | string>(coerceToNumber(value) || "");
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const { writeContractAsync: writeStakingOracle } = useScaffoldWriteContract({ contractName: "StakingOracle" });
+
+  // Read current bucket and previous bucket average for refresh
+  const { data: currentBucket } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getCurrentBucketNumber",
+  }) as { data: bigint | undefined };
+
+  const previousBucket = useMemo(() => (currentBucket && currentBucket > 0n ? currentBucket - 1n : 0n), [currentBucket]);
+
+  const { data: prevBucketAverage } = useScaffoldReadContract({
+    contractName: "StakingOracle",
+    functionName: "getPastPrice",
+    args: [previousBucket] as any,
+  }) as { data: bigint | undefined };
+
+  const hasPrevAvg = typeof prevBucketAverage === "bigint" && prevBucketAverage > 0n;
+
+  useEffect(() => {
+    if (!isEditing) {
+      setEditValue(coerceToNumber(value) || "");
+    }
+  }, [value, isEditing]);
+
+  useEffect(() => {
+    if (isEditing && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [isEditing]);
+
+  const handleSubmit = async () => {
+    const parsedValue = Number(editValue);
+    if (isNaN(parsedValue)) {
+      notification.error("Invalid number");
+      return;
+    }
+    try {
+      await writeStakingOracle({
+        functionName: "reportPrice",
+        args: [parseEther(parsedValue.toString())],
+        account: nodeAddress as `0x${string}`,
+      });
+      setIsEditing(false);
+    } catch (error: any) {
+      console.error(error?.shortMessage || "Failed to update price");
+    }
+  };
+
+  // Resubmits the average price from the previous bucket
+  const handleRefresh = async () => {
+    if (!prevBucketAverage || prevBucketAverage === 0n) {
+      notification.error("No previous bucket average available");
+      return;
+    }
+    const avgPrice = Number(formatEther(prevBucketAverage));
+    try {
+      await writeStakingOracle({
+        functionName: "reportPrice",
+        args: [parseEther(avgPrice.toString())],
+        account: nodeAddress as `0x${string}`,
+      });
+    } catch (error: any) {
+      console.error(error);
+    }
+  };
+
+  const handleCancel = () => setIsEditing(false);
+  const startEditing = () => {
+    if (!canEdit || disabled) return;
+    setIsEditing(true);
+  };
+
+  return (
+    <HighlightedCell
+      value={value}
+      highlightColor={highlightColor}
+      className={`min-w-[14rem] w-[16rem] whitespace-nowrap overflow-visible ${className}`}
+    >
+      <div className="flex w-full items-start">
+        <div className="flex-1 min-w-0">
+          {isEditing ? (
+            <div className="relative px-1">
+              <input
+                ref={inputRef}
+                type="text"
+                value={editValue}
+                onChange={e => setEditValue(e.target.value)}
+                className="w-full text-sm bg-secondary rounded-md"
+              />
+            </div>
+          ) : (
+            <div className="flex items-center gap-2 h-full items-stretch">
+              <span className="truncate">{value}</span>
+              {canEdit && (
+                <div className="flex items-stretch gap-1">
+                  <button
+                    className="px-2 text-sm bg-primary rounded disabled:opacity-50 cursor-pointer"
+                    onClick={startEditing}
+                    disabled={!canEdit || disabled}
+                    title="Edit price"
+                  >
+                    <PencilIcon className="w-2.5 h-2.5" />
+                  </button>
+                  <button
+                    className="px-2 text-sm bg-secondary rounded disabled:opacity-50 disabled:cursor-not-allowed cursor-pointer"
+                    onClick={() => {
+                      if (isRefreshing || !hasPrevAvg || disabled) return;
+                      setIsRefreshing(true);
+                      try {
+                        void handleRefresh();
+                      } catch {}
+                      setTimeout(() => setIsRefreshing(false), 3000);
+                    }}
+                    disabled={!canEdit || disabled || isRefreshing || !hasPrevAvg}
+                    title={hasPrevAvg ? "Report previous bucket average" : "No past price available"}
+                  >
+                    <ArrowPathIcon className={`w-2.5 h-2.5 ${isRefreshing ? "animate-spin" : ""}`} />
+                  </button>
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+        <div className="shrink-0 items-stretch justify-start pl-2">
+          {isEditing && (
+            <div className="flex items-stretch gap-1 w-full h-full">
+              <button onClick={handleSubmit} className="px-2 text-sm bg-primary rounded cursor-pointer">
+                ✓
+              </button>
+              <button onClick={handleCancel} className="px-2 text-sm bg-secondary rounded cursor-pointer">
+                ✕
+              </button>
+            </div>
+          )}
+        </div>
+      </div>
+    </HighlightedCell>
+  );
+};
diff --git a/extension/packages/nextjs/components/oracle/TimeAgo.tsx b/extension/packages/nextjs/components/oracle/TimeAgo.tsx
new file mode 100644
index 00000000..069f8d84
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/TimeAgo.tsx
@@ -0,0 +1,55 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useChallengeState } from "~~/services/store/challengeStore";
+
+type TimeAgoProps = {
+  timestamp?: bigint;
+  staleWindow?: bigint;
+  className?: string;
+};
+
+const formatTimeAgo = (tsSec: number | undefined, nowSec: number): string => {
+  if (tsSec === undefined) return "—";
+  if (tsSec === 0) return "never";
+  // Clamp to avoid negative display in rare race conditions
+  const diffSec = Math.max(0, nowSec - tsSec);
+  if (diffSec < 60) return `${diffSec}s ago`;
+  const diffMin = Math.floor(diffSec / 60);
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHr = Math.floor(diffMin / 60);
+  return `${diffHr}h ago`;
+};
+
+export const TimeAgo = ({ timestamp, staleWindow, className = "" }: TimeAgoProps) => {
+  const { timestamp: networkTimestamp } = useChallengeState();
+  const [currentTime, setCurrentTime] = useState<number>(() =>
+    networkTimestamp ? Number(networkTimestamp) : Math.floor(Date.now() / 1000),
+  );
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setCurrentTime(prev => prev + 1);
+    }, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  const tsSec = typeof timestamp === "bigint" ? Number(timestamp) : timestamp;
+  const displayNow = currentTime;
+  const text = formatTimeAgo(tsSec, displayNow);
+
+  // Determine staleness coloring
+  let colorClass = "";
+  if (tsSec === undefined) {
+    colorClass = "";
+  } else if (tsSec === 0) {
+    colorClass = "text-error";
+  } else if (typeof staleWindow === "bigint") {
+    const isStale = tsSec === undefined ? false : displayNow - tsSec > Number(staleWindow);
+    colorClass = isStale ? "text-error" : "text-success";
+  }
+
+  return <span className={`whitespace-nowrap ${colorClass} ${className}`}>{text}</span>;
+};
+
+export default TimeAgo;
diff --git a/extension/packages/nextjs/components/oracle/TotalSlashedWidget.tsx b/extension/packages/nextjs/components/oracle/TotalSlashedWidget.tsx
new file mode 100644
index 00000000..e56362bc
--- /dev/null
+++ b/extension/packages/nextjs/components/oracle/TotalSlashedWidget.tsx
@@ -0,0 +1,40 @@
+import { useMemo } from "react";
+import TooltipInfo from "~~/components/TooltipInfo";
+import { useScaffoldEventHistory } from "~~/hooks/scaffold-eth";
+import { formatEther } from "viem";
+
+export const TotalSlashedWidget = () => {
+  const { data: slashedEvents, isLoading } = useScaffoldEventHistory({
+    contractName: "StakingOracle",
+    eventName: "NodeSlashed",
+    watch: true,
+  });
+
+  const totalSlashedWei = useMemo(() => {
+    if (!slashedEvents) return 0n;
+    return slashedEvents.reduce((acc: bigint, current) => {
+      const amount = (current?.args?.amount as bigint | undefined) ?? 0n;
+      return acc + amount;
+    }, 0n);
+  }, [slashedEvents]);
+
+  const tooltipText = "Aggregated ETH slashed across all nodes. Sums the amount from every NodeSlashed event.";
+
+  return (
+    <div className="flex flex-col gap-2 h-full">
+      <h2 className="text-xl font-bold">Total Slashed</h2>
+      <div className="bg-base-100 rounded-lg p-4 relative w-full h-full min-h-[140px]">
+        <TooltipInfo top={0} right={0} infoText={tooltipText} className="tooltip-left" />
+        <div className="flex flex-col gap-1 h-full items-center justify-center">
+          {isLoading ? (
+            <div className="animate-pulse h-10 bg-secondary rounded-md w-32" />
+          ) : (
+            <div className="font-bold text-4xl">Ξ {Number(formatEther(totalSlashedWei)).toFixed(4)}</div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+
diff --git a/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
index 3bdf3933..7ace1cda 100644
--- a/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
+++ b/extension/packages/nextjs/components/oracle/optimistic/SubmitAssertionButton.tsx
@@ -175,7 +175,7 @@ const SubmitAssertionModal = ({ isOpen, onClose }: SubmitAssertionModalProps) =>
                 </label>
                 <IntegerInput
                   name="reward"
-                  placeholder={`0.01 ETH`}
+                  placeholder={`0.01`}
                   value={reward}
                   onChange={newValue => setReward(newValue)}
                   disableMultiplyBy1e18
diff --git a/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx b/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
index a600d33e..09528988 100644
--- a/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
+++ b/extension/packages/nextjs/components/oracle/optimistic/TimeLeft.tsx
@@ -1,3 +1,5 @@
+"use client";
+
 import { useEffect, useState } from "react";
 import { useChallengeState } from "~~/services/store/challengeStore";
 
@@ -10,27 +12,27 @@ function formatDuration(seconds: number, isPending: boolean) {
 
 export const TimeLeft = ({ startTime, endTime }: { startTime: bigint; endTime: bigint }) => {
   const { timestamp, refetchAssertionStates } = useChallengeState();
-  const [currentTime, setCurrentTime] = useState<number>(0);
+  const [currentTime, setCurrentTime] = useState<number>(() =>
+    timestamp ? Number(timestamp) : Math.floor(Date.now() / 1000),
+  );
 
-  // Update current time every second
   useEffect(() => {
-    // Initialize with timestamp from global state or current time
-    const initialTime = timestamp ? Number(timestamp) : Math.floor(Date.now() / 1000);
-    setCurrentTime(initialTime);
-
     const interval = setInterval(() => {
       setCurrentTime(prev => prev + 1);
     }, 1000);
-
     return () => clearInterval(interval);
-  }, [timestamp]);
+  }, []);
 
   const start = Number(startTime);
   const end = Number(endTime);
   const now = currentTime;
   const duration = end - now;
   const ended = duration <= 0;
-  const progressPercent = Math.min(((now - start) / (end - start)) * 100, 100);
+
+  // Guard against division by zero and clamp to [0, 100]
+  const totalWindow = Math.max(end - start, 1);
+  const rawPercent = ((now - start) / totalWindow) * 100;
+  const progressPercent = Math.max(0, Math.min(100, rawPercent));
 
   useEffect(() => {
     if (ended && timestamp) {
@@ -38,13 +40,18 @@ export const TimeLeft = ({ startTime, endTime }: { startTime: bigint; endTime: b
     }
   }, [ended, refetchAssertionStates, timestamp]);
 
-  if (!timestamp) return "Calculating...";
+  let displayText: string;
+  if (ended) {
+    displayText = "Ended";
+  } else if (now < start) {
+    displayText = formatDuration(start - now, true);
+  } else {
+    displayText = formatDuration(Math.max(duration, 0), false);
+  }
 
   return (
     <div className="w-full space-y-1">
-      <div className={ended || duration < 60 ? "text-error" : ""}>
-        {ended ? "Ended" : now < start ? formatDuration(start - now, true) : formatDuration(duration, false)}
-      </div>
+      <div className={ended || duration < 60 ? "text-error" : ""}>{displayText}</div>
       <div
         className={`w-full h-1 bg-base-300 rounded-full overflow-hidden transition-opacity ${now > start ? "opacity-100" : "opacity-0"}`}
       >
diff --git a/extension/packages/nextjs/components/oracle/types.ts b/extension/packages/nextjs/components/oracle/types.ts
index e597c186..e247d27d 100644
--- a/extension/packages/nextjs/components/oracle/types.ts
+++ b/extension/packages/nextjs/components/oracle/types.ts
@@ -1,7 +1,9 @@
 export interface NodeRowProps {
   address: string;
-  index: number;
+  index?: number;
   isStale?: boolean;
+  // When provided, the row should render data for this bucket. If omitted, shows current/latest.
+  bucketNumber?: bigint | null;
 }
 
 export interface WhitelistRowProps extends NodeRowProps {
diff --git a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
index 6b7b3a11..87bdec09 100644
--- a/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
+++ b/extension/packages/nextjs/components/oracle/whitelist/WhitelistRow.tsx
@@ -3,13 +3,14 @@ import { EditableCell } from "../EditableCell";
 import { formatEther } from "viem";
 import { useBlockNumber, useReadContract } from "wagmi";
 import { HighlightedCell } from "~~/components/oracle/HighlightedCell";
+import { TimeAgo } from "~~/components/oracle/TimeAgo";
 import { WhitelistRowProps } from "~~/components/oracle/types";
 import { Address } from "~~/components/scaffold-eth";
 import { useScaffoldReadContract, useSelectedNetwork } from "~~/hooks/scaffold-eth";
 import { SIMPLE_ORACLE_ABI } from "~~/utils/constants";
 import { getHighlightColorForPrice } from "~~/utils/helpers";
 
-export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
+export const WhitelistRow = ({ address }: WhitelistRowProps) => {
   const selectedNetwork = useSelectedNetwork();
 
   const { data, refetch } = useReadContract({
@@ -39,12 +40,17 @@ export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
     watch: true,
   }) as { data: bigint | undefined };
 
+  const { data: staleWindow } = useScaffoldReadContract({
+    contractName: "WhitelistOracle",
+    functionName: "STALE_DATA_WINDOW",
+  }) as { data: bigint | undefined };
+
   const isNotReported = data !== undefined && data[0] === 0n && data[1] === 0n;
   const lastReportedPriceFormatted =
     data === undefined || isNotReported ? "Not reported" : Number(parseFloat(formatEther(data?.[0] ?? 0n)).toFixed(2));
 
   return (
-    <tr className={`table-fixed ${isActive ? "" : "opacity-40"}`}>
+    <tr className={`table-fixed`}>
       <td>
         <Address address={address} size="sm" format="short" onlyEnsOrAddress={true} />
       </td>
@@ -53,12 +59,8 @@ export const WhitelistRow = ({ address, isActive }: WhitelistRowProps) => {
         address={address}
         highlightColor={getHighlightColorForPrice(data?.[0], medianPrice)}
       />
-      <HighlightedCell
-        value={isActive ? "active" : "stale"}
-        highlightColor={""}
-        className={isActive ? "text-success" : "text-error"}
-      >
-        {isActive ? "Active" : "Stale"}
+      <HighlightedCell value={0} highlightColor={""}>
+        <TimeAgo timestamp={data?.[1]} staleWindow={staleWindow} />
       </HighlightedCell>
     </tr>
   );
diff --git a/extension/packages/nextjs/services/store/challengeStore.ts b/extension/packages/nextjs/services/store/challengeStore.ts
index 9c33605e..583c298a 100644
--- a/extension/packages/nextjs/services/store/challengeStore.ts
+++ b/extension/packages/nextjs/services/store/challengeStore.ts
@@ -28,13 +28,12 @@ export const useChallengeState = create<ChallengeState>(set => ({
   timestamp: null,
   setTimestamp: (timestamp: bigint | null): void => set(() => ({ timestamp })),
   // Optimistic Oracle
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   refetchAssertionStates: () => {},
   setRefetchAssertionStates: (refetchFn: () => void) => set(() => ({ refetchAssertionStates: refetchFn })),
   // Assertion Modal
   openAssertion: null,
   openAssertionModal: (assertion: AssertionWithIdAndState) =>
-    set(state => ({
+    set(() => ({
       openAssertion: assertion,
     })),
   closeAssertionModal: () => set(() => ({ openAssertion: null })),

From 0123bc90f3cc3cca75be664474df0976d193c632 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 13:38:38 -0400
Subject: [PATCH 29/34] refactor: remove unused args and providers from
 ScaffoldEthAppWithProviders

---
 .../components/ScaffoldEthAppWithProviders.tsx.args.mjs     | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
index c30093df..b377c303 100644
--- a/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
+++ b/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
@@ -1,9 +1,3 @@
 // Reference the example args file: https://github.com/scaffold-eth/create-eth-extensions/blob/example/extension/packages/nextjs/components/ScaffoldEthAppWithProviders.tsx.args.mjs
 
-// Default args:
-export const preContent = `import { MonitorAndTriggerTx } from "./MonitorAndTriggerTx";`;
 export const globalClassNames = "font-space-grotesk";
-export const extraProviders = {
-    "MonitorAndTriggerTx": {},
-};
-export const overrideProviders = {};

From b3788d4acda33ae1d0d2ee05cf6810acb2e154c6 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 13:46:13 -0400
Subject: [PATCH 30/34] Replace placeholder images with actual URLs

Updated image links in the README to point to GitHub assets.
---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 1960cfb3..df663dff 100644
--- a/README.md
+++ b/README.md
@@ -437,7 +437,7 @@ yarn test --grep "Checkpoint1"
 
 🔄 Run `yarn deploy --reset` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
 
-![WhiteListOracle](SCREENSHOT)
+![WhiteListOracle]("https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc")
 
 👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
@@ -1173,13 +1173,13 @@ yarn test --grep "Checkpoint2"
 
 🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
 
-![Staking Buttons Panel](SCREENSHOT)
+![Staking Buttons Panel]("https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45")
 
 > 🗺️ You can navigate to past buckets using the arrows. 
 
 ✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
 
-![SelfNodeRow](SCREENSHOT)
+![SelfNodeRow]("https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533")
 
 > ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
 
@@ -1864,7 +1864,7 @@ yarn test --grep "Checkpoint6"
 
 🖥️ Go to the Optimistic page to interact with your new protocol
 
-![OptimisticOracle](SCREENSHOT)
+![OptimisticOracle]("https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905")
 
 1. **Submit a New Assertion**:  
    Go to the "Optimistic" page and fill in the required fields to create a new assertion.  

From 37b039a2b3d70fd329efc1cf944959af739fff26 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 13:50:43 -0400
Subject: [PATCH 31/34] update images in args.mjs readme file

---
 extension/README.md.args.mjs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 18a1d124..29ec207c 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -437,7 +437,7 @@ yarn test --grep "Checkpoint1"
 
 🔄 Run \`yarn deploy --reset\` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
 
-![WhiteListOracle](SCREENSHOT)
+![WhiteListOracle]("https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc")
 
 👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
@@ -1173,13 +1173,13 @@ yarn test --grep "Checkpoint2"
 
 🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
 
-![Staking Buttons Panel](SCREENSHOT)
+![Staking Buttons Panel]("https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45")
 
 > 🗺️ You can navigate to past buckets using the arrows. 
 
 ✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
 
-![SelfNodeRow](SCREENSHOT)
+![SelfNodeRow]("https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533")
 
 > ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
 
@@ -1864,7 +1864,7 @@ yarn test --grep "Checkpoint6"
 
 🖥️ Go to the Optimistic page to interact with your new protocol
 
-![OptimisticOracle](SCREENSHOT)
+![OptimisticOracle]("https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905")
 
 1. **Submit a New Assertion**:  
    Go to the "Optimistic" page and fill in the required fields to create a new assertion.  

From be604596c57a999bd40ba3aae6122de80b375ff9 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 14:02:02 -0400
Subject: [PATCH 32/34] Empty contract functions

---
 .../contracts/01_Staking/StakingOracle.sol    | 188 ++----------------
 1 file changed, 21 insertions(+), 167 deletions(-)

diff --git a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
index caefc959..f8d12e8b 100644
--- a/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
+++ b/extension/packages/hardhat/contracts/01_Staking/StakingOracle.sol
@@ -106,117 +106,33 @@ contract StakingOracle {
      *      Requires minimum stake amount and prevents duplicate registrations.
      * @param initialPrice The initial price value this oracle node will report
      */
-    function registerNode(uint256 initialPrice) public payable {
-        if (msg.value < MINIMUM_STAKE) revert InsufficientStake();
-        if (nodes[msg.sender].active) revert NodeAlreadyRegistered();
-        nodes[msg.sender] = OracleNode({
-            stakedAmount: msg.value,
-            lastReportedBucket: 0, // updated in reportPrice
-            reportCount: 0,
-            claimedReportCount: 0,
-            firstBucket: getCurrentBucketNumber(),
-            active: true
-        });
-        nodeAddresses.push(msg.sender);
-        reportPrice(initialPrice);
-        emit NodeRegistered(msg.sender, msg.value);
-    }
+    function registerNode(uint256 initialPrice) public payable {}
 
     /**
      * @notice Updates the price reported by an oracle node (only registered nodes)
      * @dev Updates the node's lastReportedBucket and price in that bucket. Requires sufficient stake.
      * @param price The new price value to report
      */
-    function reportPrice(uint256 price) public onlyNode {
-        if (price == 0) revert InvalidPrice();
-        OracleNode storage node = nodes[msg.sender];
-        if (getEffectiveStake(msg.sender) < MINIMUM_STAKE) revert InsufficientStake();
-        if (node.lastReportedBucket == getCurrentBucketNumber()) revert AlreadyReportedInCurrentBucket();
-        TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber()];
-        bucket.prices[msg.sender] = price;
-        bucket.countReports++;
-        bucket.sumPrices += price;
-        
-        node.lastReportedBucket = getCurrentBucketNumber();
-        node.reportCount++;
-        emit PriceReported(msg.sender, price, getCurrentBucketNumber());
-    }
+    function reportPrice(uint256 price) public onlyNode {}
 
     /**
      * @notice Allows active and inactive nodes to claim accumulated ORA token rewards
      * @dev Calculates rewards based on time elapsed since last claim.
      */
-    function claimReward() public {
-        OracleNode storage node = nodes[msg.sender];
-
-        uint256 delta = node.reportCount - node.claimedReportCount;
-        if (delta == 0) revert NoRewardsAvailable();
-
-        node.claimedReportCount = node.reportCount;
-        oracleToken.mint(msg.sender, delta * REWARD_PER_REPORT);
-        emit NodeRewarded(msg.sender, delta * REWARD_PER_REPORT);
-    }
+    function claimReward() public {}
 
     /**
      * @notice Allows a registered node to increase its stake
      * @dev Increases the sender's stakedAmount by msg.value
      */
-    function addStake() public payable onlyNode {
-        if (msg.value == 0) revert InsufficientStake();
-        nodes[msg.sender].stakedAmount += msg.value;
-        emit StakeAdded(msg.sender, msg.value);
-    }
+    function addStake() public payable onlyNode {}
 
     /**
      * @notice Slashes a node for giving a price that is deviated too far from the average excluding it's own reported price
      */
-    function slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index) public {
-        if (!nodes[nodeToSlash].active) revert NodeNotRegistered();
-        if (getCurrentBucketNumber() == bucketNumber) revert OnlyPastBucketsAllowed();
-        TimeBucket storage bucket = timeBuckets[bucketNumber];
-        if (bucket.slashedOffenses[nodeToSlash]) revert NodeAlreadySlashed();
-        uint256 reportedPrice = bucket.prices[nodeToSlash];
-        if (reportedPrice == 0) revert NodeDidNotReport();
-        bucket.slashedOffenses[nodeToSlash] = true;
-        // Remove the price from the sum and count
-        bucket.sumPrices -= reportedPrice;
-        bucket.countReports--;
-        uint256 averagePrice = bucket.sumPrices / bucket.countReports;
-        // Check if the price deviation is greater than the threshold
-        if (!_checkPriceDeviated(reportedPrice, averagePrice)) {
-            revert NotDeviated();
-        }
-        OracleNode storage node = nodes[nodeToSlash];
-        // Slash the node
-        uint256 actualPenalty = MISREPORT_PENALTY > node.stakedAmount ? node.stakedAmount : MISREPORT_PENALTY;
-        node.stakedAmount -= actualPenalty;
-
-        uint256 reward = (actualPenalty * SLASHER_REWARD_PERCENTAGE) / 100;
-
-        (bool sent, ) = msg.sender.call{ value: reward }("");
-        if (!sent) revert FailedToSend();
-
-        if (node.stakedAmount == 0) {
-            _removeNode(nodeToSlash, index);
-            emit NodeExited(nodeToSlash, 0);
-        }
-
-        emit NodeSlashed(nodeToSlash, actualPenalty);
-    }
+    function slashNode(address nodeToSlash, uint256 bucketNumber, uint256 index) public {}
 
-    function exitNode(uint256 index) public onlyNode {
-        OracleNode storage node = nodes[msg.sender];
-        if (node.lastReportedBucket + WAITING_PERIOD > getCurrentBucketNumber()) revert WaitingPeriodNotOver();
-        // Get effective stake before removing node (since getEffectiveStake returns 0 for inactive nodes)
-        uint256 stake = getEffectiveStake(msg.sender);
-        _removeNode(msg.sender, index);
-        // Withdraw the stake
-        delete nodes[msg.sender];
-        (bool sent, ) = msg.sender.call{ value: stake }("");
-        if (!sent) revert FailedToSend();
-    
-        emit NodeExited(msg.sender, stake);
-    }
+    function exitNode(uint256 index) public onlyNode {}
 
     ////////////////////////
     /// View Functions /////
@@ -226,9 +142,7 @@ contract StakingOracle {
      * @notice Returns the list of registered oracle node addresses
      * @return Array of registered oracle node addresses
      */
-    function getNodeAddresses() public view returns (address[] memory) {
-        return nodeAddresses;
-    }
+    function getNodeAddresses() public view returns (address[] memory) {}
 
     /**
      * @notice Returns the aggregated price from all active oracle nodes using median calculation
@@ -236,87 +150,42 @@ contract StakingOracle {
      *      Uses StatisticsUtils for sorting and median calculation.
      * @return The median price from all nodes with fresh data
      */
-    function getLatestPrice() public view returns (uint256) {
-        TimeBucket storage bucket = timeBuckets[getCurrentBucketNumber() - 1];
-        if (bucket.countReports == 0) revert NoValidPricesAvailable();
-        return bucket.sumPrices / bucket.countReports;
-    }
+    function getLatestPrice() public view returns (uint256) {}
 
     /**
      * @notice Returns the average price from a past bucket
      * @param bucketNumber The bucket number to get the average price from
      * @return The average price from the bucket
      */
-    function getPastPrice(uint256 bucketNumber) public view returns (uint256) {
-        TimeBucket storage bucket = timeBuckets[bucketNumber];
-        if (bucket.countReports == 0) revert NoValidPricesAvailable();
-        return bucket.sumPrices / bucket.countReports;
-    }
+    function getPastPrice(uint256 bucketNumber) public view returns (uint256) {}
 
-    function getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber) public view returns (uint256, bool) {
-        TimeBucket storage bucket = timeBuckets[bucketNumber];
-        return (bucket.prices[nodeAddress], bucket.slashedOffenses[nodeAddress]);
-    }
+    /**
+     * @notice Returns the price and slashed status of a node at a given bucket
+     * @param nodeAddress The address of the node to get the data for
+     * @param bucketNumber The bucket number to get the data from
+     * @return The price and slashed status of the node at the bucket
+     */
+    function getAddressDataAtBucket(address nodeAddress, uint256 bucketNumber) public view returns (uint256, bool) {}
 
     /**
      * @notice Returns the current bucket number
      * @dev Returns the current bucket number based on the block number
      * @return The current bucket number
      */
-    function getCurrentBucketNumber() public view returns (uint256) {
-        return (block.number / BUCKET_WINDOW) + 1;
-    }
+    function getCurrentBucketNumber() public view returns (uint256) {}
 
     /**
      * @notice Returns the effective stake accounting for inactivity penalties via missed buckets
      * @dev Effective stake = stakedAmount - (missedBuckets * INACTIVITY_PENALTY), floored at 0
      */
-    function getEffectiveStake(address nodeAddress) public view returns (uint256) {
-        OracleNode memory n = nodes[nodeAddress];
-        if (!n.active) return 0;
-        uint256 currentBucket = getCurrentBucketNumber();
-        if (currentBucket == n.firstBucket) return n.stakedAmount;
-        // Expected reports are only for fully completed buckets since registration (exclude current bucket)
-        uint256 expectedReports = currentBucket - n.firstBucket;
-        // Do not assume future reports; penalize only after a bucket has passed
-        uint256 actualReportsCompleted = n.reportCount;
-        // Exclude a report made in the current bucket from completed reports to avoid reducing past penalties
-        if (n.lastReportedBucket == currentBucket && actualReportsCompleted > 0) {
-            actualReportsCompleted -= 1;
-        }
-        if (actualReportsCompleted >= expectedReports) return n.stakedAmount; // no penalty if on target
-        uint256 missed = expectedReports - actualReportsCompleted;
-        uint256 penalty = missed * INACTIVITY_PENALTY;
-        if (penalty > n.stakedAmount) return 0;
-        return n.stakedAmount - penalty;
-    }
+    function getEffectiveStake(address nodeAddress) public view returns (uint256) {}
 
     /**
      * @notice Returns the addresses of nodes in a bucket whose reported price deviates beyond the threshold
      * @param bucketNumber The bucket number to get the outliers from
      * @return Array of node addresses considered outliers
      */
-    function getOutlierNodes(uint256 bucketNumber) public view returns (address[] memory) {
-        TimeBucket storage bucket = timeBuckets[bucketNumber];
-        address[] memory outliers = new address[](bucket.countReports);
-        uint256 outlierCount = 0;
-        for (uint256 i = 0; i < nodeAddresses.length; i++) {
-            address nodeAddress = nodeAddresses[i];
-            uint256 reportedPrice = bucket.prices[nodeAddress];
-            if (reportedPrice == 0) continue;
-            uint256 averagePrice = (bucket.sumPrices - reportedPrice) / (bucket.countReports - 1);
-            // Check if the price deviation is greater than the threshold
-            if (_checkPriceDeviated(reportedPrice, averagePrice)) {
-                outliers[outlierCount] = nodeAddress;
-                outlierCount++;
-            }
-        }
-        address[] memory trimmed = new address[](outlierCount);
-        for (uint256 i = 0; i < outlierCount; i++) {
-            trimmed[i] = outliers[i];
-        }
-        return trimmed;
-    }
+    function getOutlierNodes(uint256 bucketNumber) public view returns (address[] memory) {}
 
     //////////////////////////
     /// Internal Functions ///
@@ -327,15 +196,7 @@ contract StakingOracle {
      * @param nodeAddress The address of the node to remove
      * @param index The index of the node to remove
      */
-    function _removeNode(address nodeAddress, uint256 index) internal {
-        if (nodeAddresses.length <= index) revert IndexOutOfBounds();
-        if (nodeAddresses[index] != nodeAddress) revert NodeNotAtGivenIndex();
-        // Pop and swap pattern
-        nodeAddresses[index] = nodeAddresses[nodeAddresses.length - 1];
-        nodeAddresses.pop();
-        // Set the node to inactive
-        nodes[nodeAddress].active = false;
-    }
+    function _removeNode(address nodeAddress, uint256 index) internal {}
 
     /**
      * @notice Checks if the price deviation is greater than the threshold
@@ -343,12 +204,5 @@ contract StakingOracle {
      * @param averagePrice The average price of the bucket
      * @return True if the price deviation is greater than the threshold, false otherwise
      */
-    function _checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice) internal pure returns (bool) {
-        uint256 deviation = reportedPrice > averagePrice ? reportedPrice - averagePrice : averagePrice - reportedPrice;
-        uint256 deviationBps = (deviation * 10_000) / averagePrice;
-        if (deviationBps > MAX_DEVIATION_BPS) {
-            return true;
-        }
-        return false;
-    }
+    function _checkPriceDeviated(uint256 reportedPrice, uint256 averagePrice) internal pure returns (bool) {}
 }

From ad99f378bf02b0b125c427a9c3f5b91cfbb092c3 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 14:09:12 -0400
Subject: [PATCH 33/34] remove quotes from images in markdown

---
 README.md                    | 8 ++++----
 extension/README.md.args.mjs | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index df663dff..923245cb 100644
--- a/README.md
+++ b/README.md
@@ -437,7 +437,7 @@ yarn test --grep "Checkpoint1"
 
 🔄 Run `yarn deploy --reset` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
 
-![WhiteListOracle]("https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc")
+![WhiteListOracle](https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc)
 
 👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
@@ -1173,13 +1173,13 @@ yarn test --grep "Checkpoint2"
 
 🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
 
-![Staking Buttons Panel]("https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45")
+![Staking Buttons Panel](https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45)
 
 > 🗺️ You can navigate to past buckets using the arrows. 
 
 ✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
 
-![SelfNodeRow]("https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533")
+![SelfNodeRow](https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533)
 
 > ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
 
@@ -1864,7 +1864,7 @@ yarn test --grep "Checkpoint6"
 
 🖥️ Go to the Optimistic page to interact with your new protocol
 
-![OptimisticOracle]("https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905")
+![OptimisticOracle](https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905)
 
 1. **Submit a New Assertion**:  
    Go to the "Optimistic" page and fill in the required fields to create a new assertion.  
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 29ec207c..7859a162 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -437,7 +437,7 @@ yarn test --grep "Checkpoint1"
 
 🔄 Run \`yarn deploy --reset\` then test the whitelist oracle. Try adding and removing oracles, and observing how the aggregated price changes.
 
-![WhiteListOracle]("https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc")
+![WhiteListOracle](https://github.com/user-attachments/assets/1fabc2d8-a1a4-4b0e-b00c-49f3fefec7fc)
 
 👊 Notice how the onlyOwner modifiers are commented out to allow you to have full control. Try manually changing the price of individual SimpleOracle contracts and adding new oracle nodes to see how the aggregated price changes:
 
@@ -1173,13 +1173,13 @@ yarn test --grep "Checkpoint2"
 
 🚰 Make sure you get a couple ETH from the faucet and then press the "Register Node" button.
 
-![Staking Buttons Panel]("https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45")
+![Staking Buttons Panel](https://github.com/user-attachments/assets/c32b9bdc-eb1e-4630-ae9f-e57a34deac45)
 
 > 🗺️ You can navigate to past buckets using the arrows. 
 
 ✏️ Now you can press the pencil icon to report a new price. Enter your price and press the checkmark button to confirm. If you want to report the same price in the next block then just press the refresh icon next to the pencil.
 
-![SelfNodeRow]("https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533")
+![SelfNodeRow](https://github.com/user-attachments/assets/32952de3-bd72-4cc6-98ba-a6b374539533)
 
 > ‼️ "Insufficient Stake" errors? Look at your staked balance 👀. It has fallen below the minimum amount of stake because you let some blocks pass without reporting. Just press the + button next to your stake to add an extra ETH (get it from the faucet if you have less than 1 in your wallet).
 
@@ -1864,7 +1864,7 @@ yarn test --grep "Checkpoint6"
 
 🖥️ Go to the Optimistic page to interact with your new protocol
 
-![OptimisticOracle]("https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905")
+![OptimisticOracle](https://github.com/user-attachments/assets/9ed4f066-152b-43a9-a5d4-933221137905)
 
 1. **Submit a New Assertion**:  
    Go to the "Optimistic" page and fill in the required fields to create a new assertion.  

From 2ca644f9c0abf9590292a30b9e4c64e1a369dcc6 Mon Sep 17 00:00:00 2001
From: Elliott Alexander <escottalexander@gmail.com>
Date: Fri, 31 Oct 2025 14:34:56 -0400
Subject: [PATCH 34/34] warnings about first deploy

---
 README.md                    | 2 ++
 extension/README.md.args.mjs | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 923245cb..9e9378f7 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,8 @@ yarn deploy
 
 ```
 
+> 🚨 This will likely fail when you run it since the contracts aren't ready to be deployed yet
+
 > 📱 In a third terminal window, start your frontend:
 
 ```sh
diff --git a/extension/README.md.args.mjs b/extension/README.md.args.mjs
index 7859a162..7e0a9a78 100644
--- a/extension/README.md.args.mjs
+++ b/extension/README.md.args.mjs
@@ -64,6 +64,8 @@ yarn deploy
 
 \`\`\`
 
+> 🚨 This will likely fail when you run it since the contracts aren't ready to be deployed yet
+
 > 📱 In a third terminal window, start your frontend:
 
 \`\`\`sh