DOOMWARE
On-chain system intelligence

READ THE
MACHINE STATE.

DoomWare converts fragmented on-chain state into deterministic market intelligence.
Inspect contracts. Measure liquidity. Resolve market conditions. Expose machine-readable results.

Launch system →View protocol
System /
Live
Block /
—
Latency /
—
BLOCK
eth_getBlockByNumber(latest)
POOL
factory.getPool(a, b, fee)
LIQUIDITY
pool.getReserves() · slot0()
HOLDERS
explorer /tokens/:a/holders
SUPPLY
erc20.totalSupply()
VOLUME
indexer volume_usd.h24
PRICE
sqrtPriceX96 → quote / asset
CONTRACT
eth_getCode · EIP-1967 slots
ROUTE
v2 · v3 · curve adapters

RAW STATE IS NOT INTELLIGENCE.

On-chain data is fragmented across contracts, pools, RPC endpoints and market venues.

ONE STATE.
ONE BLOCK.

DoomWare normalizes contract, liquidity and market state against a single deterministic observation point.

  1. RPC↓
  2. Contract state↓
  3. Pool state↓
  4. Normalization↓
  5. DoomWare engine
DoomWare / Market state READING
Asset
WETH · Robinhood Chain
Liquidity
…
Depth
…
Holder concentration
…
Price
…
Impact $1k
…
Price confidence
…
Block
…
Verdict…

A NUMBER IS NOT ALWAYS AN ANSWER.

When market conditions are unreliable, DoomWare returns a verdict instead of pretending certainty.

Run DoomWare
Real system

RUN DOOMWARE

Enter a contract or pool address. The pipeline validates it, detects the chain, reads the node, discovers every registered pool, simulates depth, measures concentration and returns a verdict with its reasons.

Machine API

HUMANS READ DASHBOARDS. AGENTS READ STATE.

DoomWare exposes structured market intelligence for both. One GET returns network, block, asset, market, risk, scores, verdict, freshness and the sources behind every field.

API reference →Live JSON · WETH
GET /api/v1/inspect/:address
const state = await fetch(
  "/api/v1/inspect/0x..."
).then(r => r.json())

if (state.verdict === "LIQUID") {
  // continue
}
Live system feed
0 events
  1. No events yet. Events appear when a block is observed, a scan completes, or a state changes between two observations.
Compare mode

SAME BLOCK.\nSIDE BY SIDE.

Up to four assets through the same pipeline. Rows are aligned, differences are highlighted, and every cell keeps its source.

Architecture

FROM CHAIN STATE TO MACHINE STATE.

A provider layer (EVM, liquidity, price, explorer) feeds a deterministic engine. Swapping a data source touches one file, never a component.

  1. CHAIN
    Blocks, contracts, pools — the machine.
    ↓
  2. RPC
    Failover JSON-RPC, chain-id asserted, Multicall3 block-stamped batches.
    ↓
  3. DOOMWARE INGEST
    Bytecode, proxy slots, ERC-20 metadata, factory discovery, pool state, holder list, indexer.
    ↓
  4. NORMALIZATION
    One block, one USD reference, one decimal system. Missing = null, never zero.
    ↓
  5. MARKET ENGINE
    Depth ladder simulated with each venue’s own math; concentration on circulating supply; confidence from documented factors.
    ↓
  6. VERDICT
    Six words, ordered rules, reasons attached. UNKNOWN when certainty is not available.
    ↓
  7. API / USER / AGENT
    The same JSON for the scanner, the inspector, the compare table and any agent.
Token

$DOOM

The DoomWare token on Robinhood Chain. The contract address is published here and nowhere else first. Once it is set, $DOOM is read by the same pipeline as every other asset: price from its own pools, liquidity, holder concentration, verification, verdict — no hand-typed numbers.

Follow @DoomWareRH
$DOOM / contract
Reading
Contract address · —
CA: SOON
Copy CA
Not deployed yet. Anything claiming to be $DOOM before this field shows an address is not $DOOM. When it goes live the address appears here, in the footer and at /api/v1/token.
Protocol

EVERY FORMULA.
EVERY THRESHOLD.
PRINTED.

Observation, normalization, measurement, confidence, verdict, data freshness. The methodology page lists the numbers the engine runs on and the sources it reads per network.

Read the docs →Open inspector