Delivered six contracts, ABI exports, tests, and deployment documentation.

Build and formatting pass; 86 offline tests and 4 mainnet fork tests pass.

The fallback median-pricing convention is explicitly flagged for independent review. Manifest generation and deployment remain later workflow steps.

The manifest is written and verified. Only launch.json was added to the tree.

What launch.json contains

• kind evm_project, token LaunchToken named and symbolized pIMD with 18 decimals, taken from src/LaunchToken.sol and matching its no-argument constructor.
• Five application contracts in constructor dependency order: PimdRegistry, BoundaryProofVerifier, BoundaryOracle, PimdSwap, PimdMarkets. Every constructor argument list matches the exported ABI exactly, one entry per parameter in declaration order.
• Ownership goes only through $owner, on PimdRegistry and PimdMarkets. All $contract references point backward and fill address-typed parameters only. BoundaryProofVerifier has no constructor and gets an empty list.
• Pool uses the IMD pair address in lowercase, fee 12500, tick spacing 60 and the one-to-one initialPrice, exactly as the launch facts give them. The pool guard and MerkleDistributor are not listed.
• Notes describe each contract, the owner's role and limits, and that no contract receives launch supply. They are well under the 4,000 character cap.

Checks run

• forge build succeeds and forge test with the verifier's fuzz seed passes all 86 tests across 8 suites, including the invariant and fuzz suites.
• A scratch script in test/scratch cross-checked the manifest against docs/abi for every contract: key set, name rules, argument counts, reference direction and types, pool values and notes length all pass.
• git status shows launch.json as the only new or changed file. No configuration, lib, or source file was touched.

The review is done and .imd-findings.json holds two findings, plus a coverage row for each of the 30 entry points. I changed no tracked files. The scratch test was removed afterwards, and its full source is in finding 1's proof field.

Finding 1 (medium): one bad price proposal can block the fallback price for that boundary for good (src/BoundaryOracle.sol:122)

• The gap: each (version, boundary) gets exactly one proposal, ever. The proposer picks the starting block number (firstBlock), and the contract can't check it on-chain. If the dispute then ends in onFailure or timeout, the proposal is closed for good, the proposer gets their whole bond back, and nobody can propose again.
• Steps:
  1. No one proves the boundary within 27 h.
  2. An attacker calls propose(1, B, 1, 1) with a wrong firstBlock.
  3. An honest user disputes and pays the 1 IMD oracle fee.
  4. The oracle refuses the bad block window and the Intake calls onFailure.
  5. An honest propose(1, B, 2000e18, 26_000_000) now reverts with InvalidState, although more than 40 h remain before the 3-day cutoff.
• Result: the boundary is never priced, so every market starting or ending there is voided. In a market UP won, UP holders get 1 USDC instead of 1 USDC + 1 IMD, and the losing DOWN holders get 1 IMD per share instead of nothing. The attacker pays only gas; the honest disputer loses the oracle fee.
• Verified: the Foundry test failed on the current code at exactly that last propose call. I had it trace each call to confirm the earlier steps succeed and the bonds and fee move as described.
• Fix: on failure or timeout, delete or reopen the proposal so a new one can be made while time remains. This still refunds both bonds, which the spec requires.

Finding 2 (low): orders and claims that attach a proof fail if that boundary is already proven (src/PimdMarkets.sol:287)

• oracle.prove reverts once a price is recorded, and _prove doesn't skip proofs that are already recorded.
• Anyone can copy the proof from a pending placeWithProofs or claimWithProofs and submit it first, and the user's whole transaction then reverts. Two users attaching the same new proof in one block causes the same thing by accident.
• Fix: skip proofs whose price is already set.
• I traced this in the code but did not write a test for it.

Coverage: I checked all 30 entry points. 23 hold, including every owner-only function in the registry, each callback's restriction to its caller, the restriction of cancel to the order's owner, and the swap callback's protection against outside calls. 7 entry points are tied to the two findings. None are left unreached.

Not reported:

• Already documented by the authors: sandwich risk on swaps within the user's own maximum, unchallenged wrong proposals standing after 1 h, and the fallback price being calculated differently from the proof price.
• Leads I couldn't confirm:
  • The contract doesn't check that the request ID inside the oracle attestation matches the request being answered. The Intake is trusted, so I left it out.
  • If the real Intake refunds fees on failure, the refund could get stuck in the contract. I don't know how the Intake behaves, so this stays a lead.
• No launch.json yet: the manifest step hasn't run, so I couldn't check that the registry and markets constructors both get $owner.

The math review is finished: I found one medium and one low defect, and the core matching, settlement and price math held up. Results are in .imd-findings.json, with 2 findings and a coverage row for each of the 30 listed entry points plus 2 invariants I checked. I changed no source files.

Findings

1. Medium: BoundaryOracle.propose accepts any firstBlock (src/BoundaryOracle.sol:122)

• What's missing: propose only checks that firstBlock is not zero and is in the past. It never checks that the block window actually spans the boundary time.
• Attack: anyone can propose with firstBlock = 1. If someone disputes, the oracle refuses the question and onFailure refunds the bad proposer's bond in full. The challenger loses the 1 IMD oracle fee.
• Result: the proposal is marked finished, so propose reverts for that boundary from then on, and prove closed at boundary + 27 h. The boundary can never be priced and its markets void after 3 days. If nobody disputes, the wrong price is finalized instead.
• Checked: a local Foundry test reproduced this exactly (attacker credit 10e18, challenger 10e18 after paying the fee, price 0, a corrected propose reverts). That test passes on the current code rather than failing, so I didn't attach it as a proof.

2. Low: fallback answers lose precision on cheap tokens (src/BoundaryOracle.sol:245, question text at OracleRequest.sol:26)

• Cause: the oracle question asks for each pool's price per 10¹⁸ base units, rounded down.
• Example: take a future asset quoted directly against USDC.
  • At $4e-7 the answer rounds to 0, every answer is rejected, and a disputed boundary can only void.
  • At $5.4e-6 versus $5.9e-6 both answers round to 5. Strike and close come out equal, so the market refunds instead of settling Up.
• Scope: the launch IMD route is not affected. This only bites assets the owner lists later, and configureAsset doesn't guard against it.

What held (Math Precision, Boundary, Numerical Gap)

• Order matching and escrow: each fill's USDC legs add up to exactly the pair's 1 USDC. The 1,024-unit rounding reserve covers rounding over the maximum 1,024 fills. Buy-DOWN escrow can't run short.
• Fees: the formula's units are correct for fees paid in both USDC and IMD.
• Settlement and claims: claims and voids are always covered by the market's reserves.
• Price proofs: the square-root price math, the 3-block median and the Slot0 field extraction are correct.
• Time windows: the 27 h proof window, 1 h dispute window and 3 day timeout meet with no gaps or overlaps.
• Calendar: month boundaries matched a reference date algorithm over 20,000 fuzzed timestamps from 1970 to 9999. The median function also passed fuzzing.
• Swap: the exact-output signs, price limits and delta unpacking in PimdSwap are correct.

Limits

• I didn't run the project's full test suite or its mainnet-fork tests.
• I read the RLP and Merkle-Patricia proof decoders by hand but didn't fuzz them.
• I followed the static-analysis reentrancy leads only as far as the math required; they're the permissions and control-flow reviewers' area.
• I deleted my scratch tests. git status shows untracked dotfiles (.bashrc, .claude/, .vscode and others) that I didn't create and left alone.

Review complete. The findings file is written at .imd-findings.json with four findings, two of them backed by failing Foundry proof tests, plus 33 coverage rows covering every listed entry point. No source, config or documentation files were changed; only the findings file and the two scratch tests under test/scratch/ were created.

Findings

• High. A market whose strike can never be recorded is still tradable, and its certain void pays the wrong party. For non-ladder markets the strike is the oracle price at the start boundary. Once the 27-hour proof window and the 3-day proposal window have passed with no price, nothing can ever set it, so settlement is guaranteed to be Refund. Weekly and monthly markets keep accepting orders for days or weeks in that state, and the Refund branch pays every UP share 1 USDC regardless of what the buyer paid. An informed UP buyer at 0.01 takes 0.99 USDC per share from the DOWN buyer risk-free. Proof test test/scratch/DoomedMarket.t.sol fails on the current code.
• Medium. A late fallback proposal leaves a one-second finalize window and burns the boundary's only proposal slot for free. Proposing at the last allowed second puts the dispute deadline one second before the 3-day timeout. If no transaction lands in that exact slot, finalize reverts forever, timeout refunds the full bond, nobody else may propose, and every market starting or ending at that boundary voids. Proof test test/scratch/LateProposal.t.sol fails on the current code.
• Low. Orders rest with any fee budget, including zero. Phantom best-priced liquidity costs only gas, misleads the book, and consumes real takers' matching steps before being closed and fully refunded.
• Low. Dispute winner is decided by bit-exact equality with the oracle's composed value. A 1-wei difference in rounding or recipe convention hands an honest proposer's 10 IMD bond to the challenger, which discourages anyone from using the fallback.

Coverage. The order book, pair backing, fee split and rebate, escrow bounds, swap adapter, deposits and withdrawals, registry configuration, and the oracle bond flows were traced for the Economic Security, Invariant and Flow Gap failure modes and hold. The existing 86-test suite, including the stateful conservation invariants, passes. No launch.json exists in the tree yet. The README's constructor table uses $owner for both owner-taking contracts and $contract references in dependency order, so there is nothing to flag there.

Not reached in depth. Merkle Patricia and RLP proof verification, the EIP-712 attestation path, and the external oracle recipe's decimal convention belong to other areas and were only checked for how they feed into the economics.

Validation passed: the JSON parses, all three snippets match their cited lines exactly, and the coverage record answers all 30 listed entry points plus three invariant rows.

Review complete. Findings are in .imd-findings.json; the scratch tests that reproduce them are under test/scratch/.

What I found

1. Medium, oracle fallback. The proposer picks the oracle window firstBlock with no tie to the boundary. A nonsense window means a dispute can only end in refusal, which refunds both bonds, never reimburses the challenger's advanced oracle fee, and leaves the proposal slot occupied so the boundary can never be priced. Every market at that boundary then voids. The attack is free and pays a losing DOWN holder 1 IMD per share instead of 0. Reproduced with a mock Intake.
2. Medium, market creation. A daily, weekly or monthly market whose start price was never recorded, and can no longer be recorded after the 3-day window, is still created and traded. It is certain to void, so anyone who reads that state buys UP below 1 USDC risk-free from uninformed shorts. Reproduced: alice nets +4.96 USDC, bob loses 5 USDC on a January market opened on January 5.
3. Low, order book. Resting orders may lock a zero fee budget. They are fully refunded when matching closes them, so spam costs only gas while each spam order burns one of a taker's 64 steps. Reproduced: 70 spam bids leave an incoming 10-share order with zero fills.

What held under tracing

• Escrow and collateral conservation across every action pair, including the IMD-only short swap path, rounding reserves and fee rebates.
• The v4 swap adapter: callback authentication, backward exact-output hops, delta checks and ETH netting.
• Oracle result validation, bond and credit accounting, RLP and Merkle Patricia strictness, header chain and EIP-2935 anchoring.
• Static-analysis reentrancy leads: all guarded by nonReentrant or immutable callees; none reproduced.

Not reached

• No launch.json exists yet, so the manifest row is marked unreached. The README deployment table matches the constructors and $owner wiring.
• No proofs attached: no finding reached high severity, and a fix-dependent test for the oracle window would mislead the fixer.

Added failure-path, fuzz, proof-integration tests, and four stateful invariant suites. All changes are under test/.

Validation passed with the required seed:

• forge build
• forge test: 157 passed, 0 failed, 0 skipped

The live-fork suite was not run.

I've written the review to .imd-findings.json. It holds 6 findings: 2 medium and 4 low, none critical or high. It also has 32 coverage rows: all 30 listed entry points plus two extra checks (collateral backing and the manifest). No repository files were changed. I deleted my scratch test folder afterwards, and git status is clean.

Findings kept, each checked against the code:

1. Medium: a fallback proposal can block its boundary for good (src/BoundaryOracle.sol:122). Three specialists reported this; it is merged into one. Each boundary allows only one proposal, and propose() does not check that the proposer's firstBlock matches the boundary. If a disputed proposal ends in the oracle failing or timing out, the proposer gets the full bond back, the challenger loses the oracle fee, and nobody can propose again. Every market starting or ending at that boundary then voids. The specialist's proof test fails on this code as described.
2. Medium: markets whose start price can no longer be recorded are still created and traded (src/PimdMarkets.sol:211). Two reports merged, and I lowered one from high. Once the 27 h proof window and the 3-day proposal window have passed with no start price, the market is certain to void. Anyone who sees that can buy UP below 1 USDC and collect 1 USDC. It is medium rather than high because it costs other traders under specific conditions, not the protocol. The proof test fails on this code as described.
3. Low: zero-fee resting orders (PimdMarkets.sol:311). Two reports merged. Orders that can never pay the maker fee are accepted. They sit at the top of the book and each one uses up a taker's matching step. Nothing is lost from balances.
4. Low: placeWithProofs / claimWithProofs revert (PimdMarkets.sol:287) when someone else proved the attached boundary first, for example by front-running.
5. Low: late proposals can barely be finalized (BoundaryOracle.sol:121). I lowered this from medium. A proposal made at the very end of the window leaves about one second to finalize it. But nobody else could have proposed at that point anyway, so the late proposer doesn't block anyone.
6. Low: fallback answers lose precision (src/libraries/OracleRequest.sol:26). For very cheap assets the owner might add later, the oracle question rounds the answer down to 0, so a dispute can never resolve. The launch IMD route is not affected.

Findings 1, 2 and 5 carry the specialists' Foundry proof tests, which I ran with forge test --match-path; all three fail on the current code for the stated reason. Findings 3, 4 and 6 have no runnable test. Their reproductions are traced through the code: the exact calls, inputs and the lines that cause the result.

Dropped: the claim that the dispute winner is decided by an exact match with the oracle's value (e44014ba). The oracle's calculation is fully deterministic and documented, so an honest proposer can compute the exact value in advance. The specialist's 1-wei mismatch only happens if the proposer uses a different calculation.

My own pass: I traced these and found no further defects:

• the price proofs (header chain, the EIP-2935 block-hash check, account and storage proofs, decoding of the pool price);
• the four ways two orders can match and their rounding, which always leave every pair backed by exactly 1 USDC + 1 IMD;
• fee calculation and payouts;
• the swap callback;
• the registry;
• the token.

I also checked launch.json: its constructor arguments match the contracts, $owner is used for the owner roles, and all contracts are under the size limits.

The static-analysis reentrancy warnings are calls to the project's own or fixed trusted contracts, behind reentrancy guards, so I reported none of them.

Both reopened findings reproduced on the starting tree and are fixed; all four advisory findings were real and are fixed as well. The reviewer's two proofs now pass, along with the full suite.

What changed

• Reopenable proposal slots (src/BoundaryOracle.sol). A refunded proposal, whether from an oracle failure or a timeout, no longer locks its boundary. A new proposal can follow while the proposal window is open, and the dead proposal's oracle requests are rejected if the Intake answers them late. Bonds on failure are still returned intact, as the proof asserts. The residual griefing cost, one oracle fee per refused round for the challenger, is documented, with the bond-forfeit alternative flagged as a requester policy choice.
• Frozen doomed markets (src/PimdMarkets.sol). A new oracle view reports whether a boundary's price exists or can still be recorded. Normal markets check it for their start boundary on placement, split and permissionless matching, and revert once the void is certain. Cancel, merge, settle and claim still work. Only periods longer than 71 hours can reach that state.
• Fee budget floor. An order's fee budget must cover its own full execution at its limit price, so free unfillable orders can no longer sit at the top of the book.
• Proof skipping. Attached proofs for a boundary somebody already recorded are skipped instead of reverting the order or claim.
• Late finalization. An unchallenged proposal is final any time after its hour, including after the three-day timeout. Timeout now applies only to disputed proposals.
• Wider hop base. Fallback questions ask per 10^36 currency0 units instead of 10^18, so low-valued routes get nonzero, precise answers. The IMD route composes to the same price.

Verification

Nine new or rewritten tests cover each change. README, the security handoff, the ABI guide, the validation record and the regenerated oracle ABI document the new behavior. The responses file answers all six findings as fixed. No manifest was written.

The accepted launch.json is correct as it stands, and this revision needs no change to it.

What I verified

• No findings came with this revision, so I checked the manifest against the accepted tree instead of guessing at a change.
• Every constructor in launch.json matches both the source and the ABI exports in docs/abi: PimdRegistry takes the owner, BoundaryProofVerifier takes nothing, BoundaryOracle takes the registry and verifier, PimdSwap takes the registry, and PimdMarkets takes the owner, registry, oracle and swapper. The order is backward-referencing dependency order.
• The token entry names LaunchToken with the name and symbol pIMD and 18 decimals, exactly as src/LaunchToken.sol sets them, with no constructor arguments.
• The pool block carries the launch facts verbatim: IMD as paired currency in lowercase, fee 12500, tick spacing 60, and the one-to-one sqrt price.
• The manifest has only the five schema keys, all names are unique and under 32 characters, and the notes are 1,870 characters.
• Ownership flows only through $owner. No wallet is hard-coded and no initialization calls are described.

Checks run

• forge build succeeds.
• forge test with the verifier's fuzz seed passes all 93 tests across 8 suites.
• A scratch test in test/scratch deployed the token and the five contracts in manifest order with a fake factory as sender on an empty chain. The whole supply stayed with the factory, both owned contracts report the launch owner, and no application contract holds launch tokens.

The working tree is clean. launch.json is unchanged from the accepted version, and no other file was touched.

The whole suite now passes with the verifier's fuzz seed: 173 tests, none failing. forge build also succeeds, with only lint notes. Only five files under test/ changed, and I didn't commit anything.

Why tests broke. Since my last round, the implementation changed four rules on purpose, and four of my tests still expected the old behaviour:

• An unchallenged proposal can no longer be timed out. It can still be finalized after the boundary's timeout.
• A refunded proposal frees its slot, so someone can propose again.
• A normal market whose start price can no longer be recorded refuses new pairs, orders and matching.
• Placing an order now needs a recorded price, and the fee budget must cover the order's own fee.

The README documents all four, so I updated the tests to match rather than treating the changes as defects.

What changed in the tests:

• OracleAdversarial.t.sol: I replaced the old timeout test and added failure-path tests:
  • Calling timeout on an unchallenged proposal reverts. It can still be finalized 30 days later, and only once.
  • A disputed proposal can't be timed out one second early, and after its timeout the boundary can never be priced.
  • A refunded slot reopens clean. Answers or failure notices from the old proposal's oracle requests are refused, both before and after the new dispute.
  • A live or recorded slot refuses another proposal.
  • priceable is checked at each window edge and fuzzed against what a proposer can actually still do.
• OracleBondInvariant.t.sol: the random-sequence handler now re-proposes refunded slots and finalizes late proposals. It expects timeout to revert on unchallenged ones and closes each open proposal the right way at the end of a run. The bond accounting invariants are unchanged, and a new unit test drives the reopen path explicitly.
• MarketLifecycleInvariant.t.sol: split on a market whose start price can no longer exist must revert InvalidMarket. The handler test now hits that case.
• ProofTradingIntegration.t.sol: the rollback test now first records an earlier boundary's price, so the resting bid can be placed while the boundary under test stays unproven. New tests cover:
  • placing with no recorded price reverts MissingPrice, and attaching a proof makes it work;
  • a proof someone else already recorded is skipped, not reverted;
  • a fee budget one unit below feeQuote is refused for both resting and immediate orders.
• test/PROPERTIES.md describes the changes above.

Findings: I found no defects, so there is no .imd-findings.json. One thing operators should know, which follows the brief's own void rule: settling a market doesn't finalize a pending proposal. If nobody finalizes an unchallenged proposal for a market's end boundary before end + 3 days, anyone can void the market first. I recorded this in PROPERTIES.md.

The findings file is valid (0 findings, 30 coverage rows covering all 30 entry points — 100%). The scratch tests are cleaned up, and the only untracked files are environment files I didn't create. No project files were modified.

Summary

This was a settle-round review. I confirmed each of my prior findings against the revised code by running the attached proofs and reading the fix:

Both previously-blocking mediums are fixed:

• 60258d46 (refunded proposal slot reuse) — propose() now blocks only a live proposal (proposer != 0 && !finished, line 135) and deletes a refunded slot (line 138), so an honest re-proposal follows a failed/timed-out one while the window is open. _refund marks all three requests non-pending, so stale onOracleResult/onFailure callbacks revert InvalidState and cannot touch the new proposal. Proof Proof_60258d46e1f8 now passes.
• 6352e19c (doomed market traded) — BoundaryOracle.priceable() was added, and PimdMarkets gates _place, split and matchMarket through _requireStrikeObtainable (lines 244/312/370), reverting InvalidMarket once a normal market's start price can no longer exist. Proof Proof_6352e19c1da6 passes.

All four advisory lows are fixed:

• 097a0 (free unfillable orders) — _place now requires feeBudget >= floor (line 318).
• 79489 (proof front-run revert) — _prove skips already-recorded boundaries (line 296).
• 6b3bb3 (one-second finalize window) — finalize dropped the < boundary+TIMEOUT bound, timeout now requires a challenger. Proof Proof_81a80a2f6f00 passes.
• 6441cf (low-value-hop precision) — OracleRequest.HOP_BASE = 1e36 with matching composition in onOracleResult.

The fresh senior-auditor pass over the changed and surrounding code (re-propose/stale-callback interaction, priceable edge cases, swap callback authentication, registry gating, settlement/claim payout) found no new reproducible defect. The findings list is empty, with a full coverage record for all 30 entry points.

Implemented source, static export and the verified deployment manifest within the allowed paths. Deliverables total 3.0 MB.

Build/typecheck, 26 mocked browser checks, 10 live read-only checks and all 16 design checks passed. No transactions were broadcast.

Validation · Design documentation

I found 3 issues: 2 medium-or-lower bugs and 1 low taste note. None is high. Every brief requirement the build can deliver is met. The deployment config, contract addresses and ABIs match the handoff, and the taste@1 probe passed all 16 checks. The findings are in .imd-findings.json; no tracked files were changed.

What I couldn't check:

• Safari (WebKit): it would not start on this machine because a system library (libevent-2.1.so.7) is missing. Everything below is from Chromium only.
• Live chain data: in my own browser run the public RPCs were blocked by CORS (curl confirms both hosts send the CORS headers, so it looks local). I passed their requests through Node to the same public endpoints, and the page then read the live chain.
• Wallet steps: I have no wallet, so nothing that needs connecting or signing was tried.

Requirements

• "Bet UP or DOWN on IMD. Fully onchain." banner: met, market.tsx:304.
• Left menu by period: met. It is a sidebar on desktop and a select at 390.
• IMD live, and pIMD/YOLO/FWA/INFER/IMDSTR/HIVE/OG marked Soon with the holders-vote line: met, sidebar.
• Market cards like Polymarket: met, the "Find your timeframe" cards.
• Price To Beat, Current Price, countdown: met. Live run showed $2.70254 and 00:42:50.
• Chart with Target line, Past/now/next, book, rules: met, the Chart / Order book / Rules / Resolution tabs.
• Coin / $ / % price toggle: met.
• Buy/Sell, Market/Limit, limit price, shares, expiry, total, to win, estimated payout, fees popup, swap cost: met, market.tsx:652-1177.
• Pay Down with IMD only, with the 5% buffer: met, market.tsx:993.
• Future market shows an estimated price to beat: met, market.tsx:390.
• Split and Merge: met.
• Ended market shows the result and Claim: met, resolution.tsx.
• Portfolio with stats, balance, positions, open orders and Claim all: met, portfolio.tsx:428.
• Leaderboard by PnL with filters and sortable columns, built from contract events: met, pages.tsx:168-176. It shows no sample rankings.
• Docs and tokenomics 50/35/10/5: met, token.tsx:388.
• Logo (bold p, green over red) and favicon: met.
• Light/dark toggle: met.
• 390 and desktop layouts, no console errors: met. The probe found no horizontal scroll or overlap.
• Wallets: met for EIP-6963 and Coinbase.
• WalletConnect: needs the requester: a WalletConnect project ID. The site says plainly "No WalletConnect relay is configured", so this is not faked.
• Static export with dist/imd-deployment.json loaded at runtime: met.
• Deployment handoff copied exactly: met. The contracts, addresses, abiHash values, poolKey, sourceCommit, attestationHash, network and walletAddChain all match the handoff and network.json.
• Asset hashes: met. All 18 files hash correctly; the export is 1.6 MB.
• Hosting and IPFS: after review.

The idea in one sentence: a Polymarket-style Up/Down trading desk for IMD, carried by one green/red split for Up and Down that runs from the logo to the outcome buttons.

Findings

1. Medium, bug: before the schedule loads, or after the RPC fails, the market header shows a green "Open" status and a countdown of "00:00:00". That says the market is open and has no time left at once. While loading it should show a neutral status and "–" for the countdown (web/src/market.tsx:383, :231).
2. Low, bug: when the RPC fails, the "Find your timeframe" heading shows over an empty grid. The section should only render when there are periods to show (web/src/market.tsx:576).
3. Low, taste: the headline "Take a position." could belo