chore: remove dead code (IRitualWallet, static precompile) + live v3 proof + doc polish

- Removed unused IRitualWallet interface and LLM_INFERENCE_PRECOMPILE constant
  (dead code — judgeAll uses configurable LLM_PRECOMPILE immutable).
- Added MAX_ANSWER_LENGTH edge case to honesty notes (checked at reveal only;
  self-correcting with v3 refund).
- Updated honesty notes: dropped obsolete cozfuttu#1 (dead constant) and cozfuttu#2 (wallet).
- Root README: clarified workshop vs homework structure with verified
  contract addresses + deploy notes.
- Flow status table: replaced v2 proof references with live v3 proof
  (bounty 1, two participants, 5 tx hashes on 0x97e19070...).
- .deploy-info.txt: added commit-reveal live proof entries (v3, bounty 1).
- 52/52 tests passing.

Author: Aphelios01-sdk

README.md

@@ -1,5 +1,30 @@
-## Starter for Ritual workshop on 23th June 2026
+# Ritual Academy Bootcamp #1 — Homework Submission
 
-/hardhat -> Where we'll write the smart contract
+Fork of [cozfuttu/ritual-chain-workshop](https://github.com/cozfuttu/ritual-chain-workshop).
 
-/web -> Where the frontend lives.
+## Repository layout
+
+| Directory | What it is |
+|---|---|
+| **`bounty-judge/`** | **Homework submission** — Foundry project with the commit-reveal `BountyJudge` (Track 1), Ritual TEE `RitualBountyJudge` (Track 2), 52 tests, and deploy script. See [`bounty-judge/README.md`](./bounty-judge/README.md) for the full lifecycle, architecture comparison, and reflection. |
+| `hardhat/` | Original workshop starter. Contains the unmodified `AIJudge.sol` (public submissions — the flaw we fix in the homework). Not used by the submission. |
+| `web/` | Original workshop frontend. Built for `AIJudge.sol` (public `submitAnswer` flow). Not wired to the commit-reveal `BountyJudge`. |
+
+## Quick start
+
+```bash
+# Run the homework test suite
+cd bounty-judge
+forge test                   # 52/52 passing
+
+# Deploy to Ritual Chain testnet
+cp .env.example .env         # set RITUAL_RPC_URL + DEPLOYER_PRIVATE_KEY
+forge script script/Deploy.s.sol --rpc-url ritual --broadcast
+```
+
+## Deployed (Ritual testnet, chainId 1979)
+
+- BountyJudge v3: `0x97e1907022c1AE5B276F2D45907DF96399a38c4F`
+- RitualBountyJudge: `0x35Cd23637A8C5a8a61fD9A32D49A2fc1250f5A09`
+
+RPC: `https://rpc.ritualfoundation.org` · Explorer: `https://explorer.ritualfoundation.org`

bounty-judge/.deploy-info.txt

@@ -33,6 +33,14 @@ Constructor: none
 52 passing (40 BountyJudge + 10 RitualBountyJudge + 2 RitualMsTimestamp),
 covering refund (5 cases) + judging attestation binding (1 case).
 
+--- Commit-reveal proven live on v3 (bounty 1, two participants) ---
+createBounty     : 0x15485e2e29ffb417d01feb9809b9dd4fbdcfbb5387592d5f51612129ae01e75d
+submitCommitment : 0xb43e3bc9051c26148c821cac80263273a85e3d9793752fc759a170ce05711949 (P1)
+submitCommitment : 0x5d8857ec150b96bc1ab203d26d8017ca5adbc5c867855cf51ba93dd06a24bc85 (P2)
+revealAnswer     : 0x5229cff2d40516d996ba9535da9f5b082691978bad3ac7d0cecbe19dcf3f96c3 (P1, verified)
+revealAnswer     : 0x5920a784a6252a7e548bcb83adcaf8c2e02618434784f4d8ee6ad806d853e4ca (P2, verified)
+revealedCount = 2 (both verified against keccak256(answer,salt,sender,bountyId))
+
 --- Why Ritual Chain (not Base) ---
 judgeAll() calls the LLM inference precompile at 0x0802, which only exists on
 Ritual Chain (chainId 1979); a Base mainnet deployment could not run judgeAll.

bounty-judge/README.md

@@ -223,37 +223,34 @@ precompile `0x0000000000000000000000000000000000000802` and deploys
 
 ### Commit-reveal flow status (Ritual Chain testnet)
 
-Proved **live on-chain** (bounty 2, two participants) using **standard
-second-based deadlines** — which only work because of the ms normalisation:
+Proved **live on-chain on the v3 deployment** (`0x97e1907022...`) —
+bounty 1, two participants, standard second-based deadlines:
 
 | Step | TX Hash | Status |
 |------|---------|--------|
-| `createBounty` (0.001 RITUAL, second-based deadlines) | `0x05a19b02e42c99ad22835fbca3a9509c02142e046d52137373cf0893e32714de` | ✅ |
-| `submitCommitment` (participant 1) | `0x2e50ef72865cb69cedbc55354ae97696f0bab8a178bdfe19932b749e36a3469a` | ✅ |
-| `submitCommitment` (participant 2) | `0xcd78b35700a6e7ccf4e39ab2b37868f2a6d8316a56531b5171cb43732cd02240` | ✅ |
-| `revealAnswer` (participant 1, commitment verified) | `0xb51211e616130d5815afbfb37474036db63c7c6d35ff6b0afed413c66e186e4e` | ✅ |
-| `revealAnswer` (participant 2, commitment verified) | `0x6e692a3a15a69c6528331f5592134ead619ed0882f564480072ce5ef8237188d` | ✅ |
-| `judgeAll` (LLM precompile 0x0802) | blocked by Ritual billing — see note | ⏳ |
+| `createBounty` (0.0001 RITUAL) | `0x15485e2e29ffb417d01feb9809b9dd4fbdcfbb5387592d5f51612129ae01e75d` | ✅ |
+| `submitCommitment` (participant 1) | `0xb43e3bc9051c26148c821cac80263273a85e3d9793752fc759a170ce05711949` | ✅ |
+| `submitCommitment` (participant 2) | `0x5d8857ec150b96bc1ab203d26d8017ca5adbc5c867855cf51ba93dd06a24bc85` | ✅ |
+| `revealAnswer` (participant 1, commitment verified) | `0x5229cff2d40516d996ba9535da9f5b082691978bad3ac7d0cecbe19dcf3f96c3` | ✅ |
+| `revealAnswer` (participant 2, commitment verified) | `0x5920a784a6252a7e548bcb83adcaf8c2e02618434784f4d8ee6ad806d853e4ca` | ✅ |
+| `judgeAll` (LLM precompile 0x0802) | blocked by Ritual billing (executor 0xB42e435c..., 0.311 RITUAL reservation) — see note | ⏳ |
 | `finalizeWinner` | after `judgeAll` | ⏳ |
 
-The **commit-reveal core** (the anti-cheating mechanism the assignment asks
-for) is proven end-to-end on Ritual: commitments are hidden during submission,
-both reveals verified against `keccak256(answer, salt, msg.sender, bountyId)`,
-and `revealedCount == 2`.
-
-> **`judgeAll` status (honest).** The LLM precompile call was attempted live.
-> Two Ritual-specific requirements were discovered and resolved:
-> 1. **Executor must be TEE-registered** — `executorAddress` in the LLM request
->    cannot be `0x0802`; it must be a registered executor such as
->    `0xB42e435c4252A5a2E7440e37B609F00c61a0c91B` (resolved — error cleared).
-> 2. **Wallet pre-payment** — Ritual reserves a fixed `0.311 RITUAL` of wallet
->    balance per inference (independent of `maxCompletionTokens`). The deployer
->    wallet had insufficient testnet RITUAL, so the live call could not
->    complete. The contract path itself is correct (verified against the
->    workshop's request encoding and the same 5-tuple output decode rivaleuc
->    uses); completing it only needs a wallet funded via the Ritual testnet
->    faucet. `judgeAll`/`finalizeWinner` are fully exercised in the 46-test
->    suite with a mocked precompile.
+The **commit-reveal core** — the anti-cheating mechanism the assignment
+requires — is live on the current v3 contract: commitments hidden during
+submission, reveals verified against
+`keccak256(answer, salt, msg.sender, bountyId)`, `revealedCount == 2`.
+
+\> **`judgeAll` status (honest).** The LLM precompile call was attempted live.
+\> Two Ritual-specific billing requirements were discovered:
+\> 1. `executorAddress` must be a TEE-registered executor (e.g.
+\>    `0xB42e435c4252A5a2E7440e37B609F00c61a0c91B` — resolved, error cleared).
+\> 2. Ritual reserves a fixed **0.311 RITUAL** of wallet balance per inference;
+\>    the deployer wallet needs pre-funding via the Ritual testnet faucet.
+\>    The contract path is correct (verified against the workshop's request
+\>    encoding and the same output decode rivaleuc uses).
+\> `judgeAll`/`finalizeWinner` are fully exercised in the 52-test suite
+\> with a mocked precompile.
 
 > On Ritual Chain every step is functional, including `judgeAll` (LLM precompile)
 > and `finalizeWinner`. This is the key advantage over a Base deployment, where
@@ -355,44 +352,39 @@ Per homework spec. Combined with sender + bountyId, prevents cross-account and c
 
 Rather than over-claiming, here is exactly what this submission does and does not do:
 
-1. **A hardcoded constant survives in the inherited base contract.** `PrecompileConsumer`
-   (carried over from the workshop) still declares
-   `address internal constant LLM_INFERENCE_PRECOMPILE = address(0x0802);`.
-   It is **dead code**: `judgeAll()` uses the configurable `LLM_PRECOMPILE`
-   immutable (constructor arg, set to `0x0802` on this Ritual deployment),
-   never the constant. So the *runtime behaviour* is genuinely configurable;
-   the constant is retained purely for source parity with the workshop base
-   contract and is harmless.
-
-2. **`IRitualWallet` is retained but unused.** The interface declaration is still
-   in `BountyJudge.sol`, but no function references it and the wallet parameter
-   was removed from every function signature. "Wallet removed" refers to the
-   removed *usage/parameter*, not the type declaration. The contract holds
-   rewards directly.
-
-3. **"Works on any EVM chain" is only half true.** The commit-reveal logic
+1. **"Works on any EVM chain" is only half true.** The commit-reveal logic
    (commit/reveal/finalize) is pure EVM and runs anywhere. But `judgeAll()`
    unconditionally calls an LLM contract at the configured address — a chain
    without that precompile (e.g. Base mainnet) cannot execute
    `judgeAll`/`finalizeWinner`. **This is why the deployment targets Ritual
    Chain (chainId 1979)**, whose native precompile at `0x0802` makes the full
    lifecycle — including AI judging — functional.
 
-4. **AI output is advisory, not authoritative.** `judgeAll()` stores the LLM
+2. **AI output is advisory, not authoritative.** `judgeAll()` stores the LLM
    result but the contract never parses it or auto-pays. The owner manually
    selects the winner in `finalizeWinner()` — a deliberate human-in-the-loop
    design, not a limitation.
 
-5. **Track 2 is a design sketch.** `RitualBountyJudge` demonstrates the
+3. **Track 2 is a design sketch.** `RitualBountyJudge` demonstrates the
    TEE-attested flow (encrypted submit → batch judging → attestation verify →
    finalize) but intentionally omits reward escrow/payout: `finalizeWinner()`
    locks the winner index without transferring ETH. This matches the rule that
    the advanced track may be a design document.
 
-6. **`block.timestamp`-based deadlines.** Validators can nudge
+4. **`block.timestamp`-based deadlines.** Validators can nudge
    `block.timestamp` by a few seconds; the deadlines are day-scaled windows so
    this is immaterial in practice, but it is not cryptographically enforced.
 
+5. **`MAX_ANSWER_LENGTH` is checked at reveal, not commit.** The contract
+   cannot check the answer length at commit time (the answer is hidden behind
+   the hash). A participant who commits an answer exceeding 2000 bytes will
+   be unable to reveal it later — their commitment is permanently locked.
+   This is self-correcting in v3: if no other participant reveals, the owner
+   can `refund()` the reward. In a multi-participant bounty the trapped
+   participant simply forfeits eligibility; the remaining revealed answers
+   are judged normally. This is a necessary consequence of the one-way hash
+   property and is explicitly documented as a known trade-off.
+
 ---
 
 ## Reflection Question

bounty-judge/contracts/BountyJudge.sol

@@ -1,22 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-/**
- * @title  IRitualWallet
- * @notice Interface for the Ritual wallet used to lock bounty rewards.
- *         Identical to the workshop interface.
- */
 /**
  * @title  PrecompileConsumer
  * @notice Base contract for Ritual Chain precompile access.
- *         Provides the LLM_INFERENCE_PRECOMPILE at 0x0802 and
- *         helper _executePrecompile() for calling Ritual precompiles.
- *         (Identical to the workshop base contract.)
+ *         Provides _executePrecompile() for calling Ritual precompiles.
+ *         (Derived from the workshop base contract.)
  */
 abstract contract PrecompileConsumer {
-    // Short-running async precompile for LLM inference
-    address internal constant LLM_INFERENCE_PRECOMPILE = address(0x0802);
-
     /**
      * @notice  Execute a short-running async precompile.
      *          Decodes the outer (simmedInput, actualOutput) envelope.
@@ -43,19 +34,6 @@ abstract contract PrecompileConsumer {
     }
 }
 
-/**
- * @title  IRitualWallet
- * @notice Interface for the Ritual wallet used to lock bounty rewards.
- *         Identical to the workshop interface.
- */
-interface IRitualWallet {
-    function deposit(uint256 lockDuration) external payable;
-    function depositFor(address user, uint256 lockDuration) external payable;
-    function withdraw(uint256 amount) external;
-    function balanceOf(address) external view returns (uint256);
-    function lockUntil(address) external view returns (uint256);
-}
-
 /**
  * @title  BountyJudge
  * @notice Privacy-preserving AI bounty judge built on Ritual Chain.