# Tradar > Search indexed Ethereum contracts by address, code hash, function selectors and the opcodes they contain. Every answer carries the coverage it was drawn from. Platform · intelligence Contract search over indexed Ethereum bytecode. Ask which deployed contracts contain a `DELEGATECALL`, hold an unverified source, or answer a particular function selector — then open any of them in the workbench. Tradar is **available today** from your account, and every answer states the slice of the chain it was drawn from. Illustrative contract search. A query asks for contracts containing a delegatecall opcode whose admin is a keypair account and whose source is unverified. Three code families are returned with their deployment counts, and the response footer states that coverage is incomplete. What it is ## A search engine over deployed bytecode Block explorers index transactions and let you look up one address at a time. Tradar indexes what the *code* does — the opcodes it contains, the selectors it answers, the proxy and admin shape it has — so a question about a whole population of contracts is one query rather than a scraping project. - Indexed: Ethereum contract bytecode and the facts recovered from it - Grouped by: code family — identical code counted once - Returns: matching families, the evidence that matched, and the coverage - Status: available today from your account [Open contract search in the workbench →](https://app.trilocore.ai/?view=code_search) The query surface ## What you can ask about One expression language, combined with `and` / `or`. Every field below is a fact recovered from the deployed code or its verified source — nothing is inferred from a label someone typed. ### Identity Address, code hash, and **code id** — the key that treats two deployments of the same contract, differing only in their compiler metadata footer, as one thing. ### Interface Function selectors and how many a contract answers, plus resolved signature names where a 4-byte or Sourcify entry exists for them. ### Opcodes Presence and count of the eight opcodes that decide how a contract can behave: `CALL`, `CALLCODE`, `CREATE`, `CREATE2`, `DELEGATECALL`, `SELFDESTRUCT`, `SSTORE`, `STATICCALL`. ### Proxy and authority Proxy shape and type, the implementation behind it, the admin and what kind of account holds it, the declared owner, and the creator. ### Source and build Whether a verified source exists at all, and when it does: compiler, compiler version, language, optimizer runs and EVM version. ### Behaviour and links Whether the code reads or writes storage, which guard patterns are present, the token standard it implements, and which contracts it calls or is called by. Coverage ## How much of the chain is indexed Tradar indexes **200,000 deployments** — a slice taken from a corpus of **5,982,001** Ethereum contracts — which resolve to **51,338 distinct code families**. That slice is the honest number, and the API reports its coverage as incomplete on *every* response rather than only when a search comes back empty. It matters because of what a silent index would imply: a query that returns nothing would otherwise read as “no contract on Ethereum does this”, when the truthful answer is “nothing in the indexed slice does this”. Those are different claims and only one of them is supportable. - Network: Ethereum. No other network is indexed - Indexed: 200,000 deployments of 5,982,001 - Code families: 51,338 - Coverage: reported as incomplete on every response Illustrative refusal. A query for the SLOAD opcode is refused with an explanation that it is not one of the indexed opcodes, and the eight searchable opcode names are listed. A second line notes that returning zero results instead would have been misleading. Scope ## What a match is, and what it is not Tradar finds code with a given shape. Deciding whether that shape is a problem in a given contract is the workbench’s job, and it is done by execution — which is why the two are joined rather than merged. ### A match is structural “This contract contains a `DELEGATECALL` and its admin is a single keypair account” is a fact about the code. It is not a vulnerability, and Tradar does not present it as one. ### Proof happens in the fork Take a candidate into the Auditing IDE, open it on a fork of live chain state, and drive it. A finding is something that replayed — the same bar every other surface is held to. ### No monitoring, no alerts Tradar answers questions you ask. It does not watch the chain, raise alerts, or score contracts for risk on its own. Those are not available. ## Find the population, then prove the one Contract search is in the workbench, beside the surfaces that take a candidate apart. [Open contract search](https://app.trilocore.ai/?view=code_search) [Book a demo](https://trilocore.com/demo) --- [Canonical HTML version](https://trilocore.com/platform/radar)