# TraceFast (remote · tracefast.xyz)

Ethereum data for agents: blocks, transactions, traces, tokens, and facts about addresses.

- Trust score: 74/100 (medium)
- Change this week: +35
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `tracefast.xyz`: 74/100 (this document), [markdown](https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast.md), [page](https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast)

## Channel facts

- Endpoint: `https://tracefast.xyz/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.2.0+acd465fb`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 53271 tokens (~484/item across 110 items; 110 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 13/100
  - Stability observed for 4 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 110 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 111 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the TraceFast MCP server?

TraceFast is a hosted endpoint at https://tracefast.xyz/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http xyz-tracefast-mcp 'https://tracefast.xyz/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "xyz-tracefast-mcp": {
      "url": "https://tracefast.xyz/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "xyz-tracefast-mcp": {
      "type": "http",
      "url": "https://tracefast.xyz/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.xyz-tracefast-mcp]
url = "https://tracefast.xyz/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xyz-tracefast-mcp": {
      "type": "remote",
      "url": "https://tracefast.xyz/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add xyz-tracefast-mcp --url 'https://tracefast.xyz/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  xyz-tracefast-mcp:
    url: "https://tracefast.xyz/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "xyz-tracefast-mcp": {
      "Transport": "http",
      "Url": "https://tracefast.xyz/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add xyz-tracefast-mcp -t streamable-http -u 'https://tracefast.xyz/mcp'
```

### Other

```json
{
  "mcpServers": {
    "xyz-tracefast-mcp": {
      "type": "http",
      "url": "https://tracefast.xyz/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 74, +1)

- [security] Tool “get_entity_token_transfers” rewrote its description, which is the text the model reads
- [functional] Server version: 0.2.0+b52148c7 → 0.2.0+1a728c5e
- [cosmetic] “get_entity_token_transfers” reworded the description of “counterparty”
- [cosmetic] “get_transaction” reworded the description of “includeTokenTransfers”

### 2026-11-20 (score 73, 0)

- [security] Tool “get_blacklist_issuers” rewrote its description, which is the text the model reads
- [security] Tool “get_block_transactions” rewrote its description, which is the text the model reads
- [security] Tool “get_contract_decompilation” rewrote its description, which is the text the model reads
- [security] Tool “get_contract_function_calls” rewrote its description, which is the text the model reads
- [security] Tool “get_contract_selectors” rewrote its description, which is the text the model reads
- [security] Tool “get_pools_for_pair” rewrote its description, which is the text the model reads
- [security] Tool “get_signal_rates” rewrote its description, which is the text the model reads
- [security] Tool “get_token_pools” rewrote its description, which is the text the model reads
- [security] Tool “get_top_pools” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_failures” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_liquidity_events” rewrote its description, which is the text the model reads
- [security] Tool “resolve_entity” rewrote its description, which is the text the model reads
- [functional] Server version: 0.2.0+6df1eebb → 0.2.0+b52148c7
- [cosmetic] “get_contract_function_calls” added an optional parameter “cursor”
- [cosmetic] “get_contract_selectors” added an optional parameter “cursor”
- [cosmetic] “get_pools_for_pair” added an optional parameter “cursor”
- [cosmetic] “get_top_pools” added an optional parameter “cursor”
- [cosmetic] “get_transaction_liquidity_events” added an optional parameter “cursor”
- [cosmetic] “get_entity_transactions” reworded the description of “methodName”
- [cosmetic] “get_top_pools” reworded the description of “limit”

### 2026-11-19 (score 73, 0)

- [security] Tool “get_block_transactions” rewrote its description, which is the text the model reads
- [security] Tool “get_contract_events” rewrote its description, which is the text the model reads
- [security] Tool “get_entity_counterparties” rewrote its description, which is the text the model reads
- [security] Tool “get_entity_internal_transfers” rewrote its description, which is the text the model reads
- [security] Tool “get_entity_token_transfers” rewrote its description, which is the text the model reads
- [security] Tool “get_entity_transactions” rewrote its description, which is the text the model reads
- [security] Tool “get_token_holders” rewrote its description, which is the text the model reads
- [security] Tool “get_trace_frames” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_events” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_trace” rewrote its description, which is the text the model reads
- [functional] Server version: 0.2.0+66022eb5 → 0.2.0+6df1eebb
- [cosmetic] “get_block_transactions” added an optional parameter “maxValueWei”
- [cosmetic] “get_block_transactions” added an optional parameter “methodId”
- [cosmetic] “get_block_transactions” added an optional parameter “minValueWei”
- [cosmetic] “get_block_transactions” added an optional parameter “sort”
- [cosmetic] “get_block_transactions” added an optional parameter “status”
- [cosmetic] “get_block_transactions” added an optional parameter “txType”
- [cosmetic] “get_entity_counterparties” added an optional parameter “counterparty”
- [cosmetic] “get_entity_counterparties” added an optional parameter “cursor”
- [cosmetic] “get_entity_counterparties” added an optional parameter “window”
- [cosmetic] “get_entity_internal_transfers” added an optional parameter “callType”
- [cosmetic] “get_entity_internal_transfers” added an optional parameter “fromTimestamp”
- [cosmetic] “get_entity_internal_transfers” added an optional parameter “order”
- [cosmetic] “get_entity_internal_transfers” added an optional parameter “toTimestamp”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “eventType”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “fromTimestamp”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “maxValue”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “minValue”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “order”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “toTimestamp”
- [cosmetic] “get_entity_token_transfers” added an optional parameter “tokenStandard”
- [cosmetic] “get_entity_transactions” added an optional parameter “fromTimestamp”
- [cosmetic] “get_entity_transactions” added an optional parameter “maxValueWei”
- [cosmetic] “get_entity_transactions” added an optional parameter “methodName”
- [cosmetic] “get_entity_transactions” added an optional parameter “minValueWei”
- [cosmetic] “get_entity_transactions” added an optional parameter “order”
- [cosmetic] “get_entity_transactions” added an optional parameter “toTimestamp”
- [cosmetic] “get_token_holders” added an optional parameter “cursor”
- [cosmetic] “get_transaction” added an optional parameter “includeTokenTransfers”
- [cosmetic] “get_entity_counterparties” reworded the description of “block”
- [cosmetic] “get_transaction_trace” reworded the description of “includeCalldata”
- [cosmetic] Tool “get_entity_counterparties” changed its title: Top counterparties of an address → Counterparties of an address, ranked

### 2026-11-18 (score 73, +1)

- [security] Tool “get_contract_events” rewrote its description, which is the text the model reads
- [security] Tool “get_entity_portfolio” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_events” rewrote its description, which is the text the model reads
- [security] Tool “get_transaction_storage_writes” rewrote its description, which is the text the model reads
- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 0.2.0+acd465fb → 0.2.0+66022eb5
- [functional] New tool “get_transaction_storage_slots”
- [cosmetic] “get_contract_events” added an optional parameter “eventName”
- [cosmetic] “get_contract_events” added an optional parameter “order”
- [cosmetic] “get_entity_portfolio” added an optional parameter “cursor”

### 2026-11-17 (score 72, +33)

- [security regression] Authorization: pass → partial
- [security improvement] Transport: unverified → pass
- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100
- [functional] First check of Tool coverage: 100

### 2026-11-14 (score 39)

First indexed and scored.

## MCP tools (110)

### `get_blacklist_events` (~501 tokens)

Blacklist events about one address

Every blacklist event an issuer contract recorded about an address, newest first — listed (`add`), removed (`remove`) or enforced against (`enforce`: funds destroyed or frozen) — each with the issuer and its weight (`authorityTier`), the event's name as the issuer's contract declares it, and the transaction that emitted it. Facts the issuers' own contracts recorded on chain; no external sanctions lists. `issuerContract` or `action` narrows the list. Use it to see when, and by whom, an address was listed or frozen. Not for one row per issuer with its current standing: use get_blacklist_status. Not for every blacklist event on the chain: use get_blacklist_feed.

Arguments: address; optional limit (default 10, at most 100), cursor, issuerContract, action. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-events

Input parameters:

- `action` (string): Only events of this kind: `add`, `remove` or `enforce`.
- `address` (string, required): The address, `0x`-prefixed, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `issuerContract` (string): Only events emitted by this issuer contract, `0x`-prefixed.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_blacklist_feed` (~532 tokens)

Every blacklist event on the chain, newest first

Every blacklist event any issuer contract recorded on the chain, newest first — an address listed (`add`), removed (`remove`) or enforced against (`enforce`: funds destroyed or frozen) — each with the address, the issuer contract and its weight (`authorityTier`), the event's name as the issuer's contract declares it, and the block and transaction that emitted it. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. `issuerContract` or `action` narrows the feed. Use it to follow what issuers listed or froze recently: page until the events reach the block you last read. Not for one address's events: use get_blacklist_events. Not for the addresses listed now: use get_blacklisted_addresses. Not for the issuers and how many addresses each lists: use get_blacklist_issuers.

Arguments: none required; optional limit (default 10, at most 100), cursor, issuerContract, action. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-feed

Input parameters:

- `action` (string): Only events of this kind: `add`, `remove` or `enforce`.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `issuerContract` (string): Only events emitted by this issuer contract, `0x`-prefixed.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_blacklist_issuers` (~481 tokens)

The issuer contracts that keep blacklists

The contracts that keep on-chain blacklists — every contract that ever recorded a blacklist event, with its weight (`authorityTier`), its token symbol where it is a token (as the contract declares it, not verified), and how many addresses it lists now (`currentlyListed`), has ever listed (`everListed`) and has enforced against (`enforced`) — most addresses listed now first; plus totals over every issuer: `issuerCount`, `listedPairs` (an address listed by two issuers counts twice) and `listedAddresses`. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. The counts trail the newest events by a few minutes. The top of the ranking only: the maximum `limit` is the deepest it goes, and a list of issuers with long declared symbols can end before it (bounded in bytes; `issuersTruncated` says so). Use it to see which issuers keep blacklists and how large each is. Not for the listed addresses (get_blacklisted_addresses) or one address's standing (get_blacklist_status). Not for the issuers' latest events: use get_blacklist_feed.

Arguments: none required; optional limit (default 25, at most 1000). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-issuers

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 1000, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_blacklist_status` (~314 tokens)

Which issuer contracts list one address

Every issuer contract that ever placed an address on its on-chain blacklist — one row each, listed now or not, with the issuer's weight (`authorityTier`), its first and latest events and how many times it listed and removed the address — plus, as a separate fact, the issuers that enforced against it (funds destroyed or frozen). Facts the issuers' own contracts recorded on chain; no external sanctions lists, and no single verdict: a listing is one issuer's decision. Empty lists mean no issuer recorded anything about the address. Use it to check whether token issuers such as stablecoins have listed or frozen an address. Not for the individual events: use get_blacklist_events. Not for every address listed now: use get_blacklisted_addresses.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-status

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_blacklisted_addresses` (~506 tokens)

The addresses issuer contracts list now

Every (address, issuer contract) pair where the issuer's on-chain blacklist holds the address now, in address order — with the issuer's weight (`authorityTier`), the block it first listed the address, its latest event about the address of any kind (`lastEventKind`; not the start of the current listing) and how many times it enforced against it. An address listed by two issuers appears twice. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. `issuerContract` narrows the list to one issuer. The listings trail the newest events by a few minutes, which get_blacklist_feed shows first. Use it to enumerate the addresses listed now. Not for whether one address is listed: use get_blacklist_status. Not for how many addresses each issuer lists: use get_blacklist_issuers.

Arguments: none required; optional limit (default 10, at most 100), cursor, issuerContract. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklisted

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `issuerContract` (string): Only the addresses this issuer contract lists, `0x`-prefixed.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_blobs_daily` (~346 tokens)

Blobs per day

Per UTC day over a window of dates, oldest first: the EIP-4844 blobs posted (`blobs`), the transactions that carried them (`blobTransactions`) and how many distinct addresses sent those transactions (`uniqueSenders`). `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; days before blobs existed and any day with no figures are absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart blob usage over time. Not for gas prices and transaction types (get_gas_daily) or the network's blocks, fees and blob gas (get_network_daily).

Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-blobs

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (string): The first UTC date, `YYYY-MM-DD`.
- `to` (string): The last UTC date, `YYYY-MM-DD`. Default: today.

### `get_block` (~288 tokens)

One block

One block by height: its header (hash, parent, roots, fee recipient, gas, base fee, blob gas) and the totals of what it contains — transactions by outcome, contract creations, blob transactions, logs, withdrawals, value moved, fees burnt and paid. A height not served yet is refused (`not_found`). Use it to inspect a known height. Not for the newest block: use get_latest_block. Not for its transactions one by one: use get_block_transactions. Not for the withdrawals it paid one by one: use get_block_withdrawals. Not for the accounts whose state it changed: use get_block_addresses.

Arguments: number. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/block

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `number` (integer, required): Block height.

### `get_block_addresses` (~470 tokens)

Accounts touched by one block

Every account whose own state — native balance, nonce or code — changed in one block, in address order, each with what changed, whether it was created in this block, and its native balance before and after the block — plus `addressCount`, the block's whole count. An account only mentioned by the block's activity, with no state change, is not listed; a block with no account change answers an empty list, which is a fact about that block. A height above the chain head is refused (`not_found`). Use it to find whose state a block changed. Not for the block's transactions (get_block_transactions) or one address's activity over time (get_entity_daily_activity). Not for every address the block touched, its state changed or not, with its roles: use get_block_participants.

Arguments: number; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/block-addresses

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): Block height.

### `get_block_at_time` (~353 tokens)

Which block was the chain's at a given time

Which block the chain was at at a moment: for `timestamp` (Unix seconds), the last block whose time is at or before it (`block`, its number and time) and the first block after it (`nextBlock`). Block times rise strictly with the height, so the bracket is exact. `final` is false when the time is after the newest block served: a later block may still land at or before it, `nextBlock` is absent, and the same question may answer differently later. When blocks around the time are temporarily unavailable the call is refused (`block_not_available`, `details.reason` `coverage_gap`) rather than bracketed across the gap — retry later. Use it to turn a date or time into a block height for the tools that take a block. Not for the block's contents: pass `block.number` to get_block. Not for the newest block now: use get_latest_block.

Arguments: timestamp. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/block-at-time

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `timestamp` (integer, required): Unix time, seconds. Required.

### `get_block_authorizations` (~504 tokens)

EIP-7702 authorizations of one block

The EIP-7702 authorizations carried by the transactions of one block, in transaction order and then list order — each with the contract the signing account delegates its code to, the signing account itself (`authority`, with `authorityStatus`: `recovered`, `recovery_failed` for an invalid signature, `not_available` while not determined), the chain id and nonce it was signed for, the signature, and the carrying transaction's hash and position. Empty when the block carries no type-4 transaction. A height above the chain head is refused (`not_found`). Use it to see which delegations a block carried. Not for where an account delegates now: use get_entity_relations; not for the block's transactions: use get_block_transactions.

Arguments: number; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/block-authorizations

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): Block height.

### `get_block_internal_transfers` (~595 tokens)

Every internal ETH transfer of a block

Every call frame of one block that moved ETH below a transaction's own top-level call — sends from contracts, value carried by inner calls, self-destruct payouts, contract creations with value — in transaction order, each with the transaction and who sent it (`txSender`), the frame's depth (`callDepth`, 2 = called by the transaction's target), its kind (`callType`), from, to, the amount in wei and the frame's own outcome (`status`). A frame that succeeded inside a reverted transaction, or under a reverted parent, moved nothing in the end. `total` counts the whole block. A height not served yet is refused (`not_found`); a block the traces do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later — never answered with an empty list, so an empty list is a fact about the block. Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy block at the maximum. Use it to see all the ETH a block moved through contracts. Not for one address's internal transfers across blocks (get_entity_internal_transfers) or one transaction's whole call tree (get_transaction_trace).

Arguments: number; optional limit (default 25, at most 200), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class:…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): The block height.

### `get_block_participants` (~613 tokens)

Every address a block touched, and how

Every address that took part in one block, in the block's order — system calls before the first transaction, then by first transaction, then the rest (withdrawals, the fee recipient) — each with its `roles` (transaction sender or recipient, caller or callee, token party, created, named in an event and more), the one class it is counted under (`primaryClass`), how many of the block's transactions it took part in, whether its own account changed with the balance before and after and the signed ETH delta (`stateChange`), its token transfers in the block summed per token in raw units (`tokenFlows`: transfers, not balance changes), and what TraceFast states the address was at that block (`nature`, only when `natureState` is `known`; `not_computed` says nothing about the address). The block's counts come with every page. No names or labels. A block whose participants are not computed yet is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later — never answered empty. Keep the same `limit` for every page of one walk: a cursor does not continue under another. Use it to see whom a block touched and how. Not for only the accounts whose state changed (get_block_addresses) or the block's transactions (get_block_transactions).

Arguments: number; optional limit (default 25, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes);…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): The block height.

### `get_block_proposers` (~475 tokens)

Block-proposal leaderboard

Which validators proposed the most blocks over a window (`period`: `7d` by default, `30d`, `90d`, `1y` or `all`), or — with `groupBy` set to `address` — which withdrawal addresses their proposals add up to, with the window's total blocks and distinct proposers. The proposer is the validator whose duty the slot was, never the block's fee recipient (usually a builder); a withdrawal address is where payouts go, not an operator. The two groupings rank different sets. The top of the ranking only: the maximum `limit` is the deepest it goes. Use it to see who proposes the chain's blocks. Not for one validator's payouts: use get_validator_withdrawals. Not for one validator's proposals and misses slot by slot: use get_consensus_validator_slots.

Arguments: none required; optional period, groupBy, limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/consensus-proposers

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `groupBy` (string): `validator` (default) or `address`.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `period` (string): `7d` (default), `30d`, `90d`, `1y` or `all`.

### `get_block_token_transfers` (~537 tokens)

Every token transfer of a block

Every token transfer event of one block, in transaction and log order — ERC-20, ERC-721 and ERC-1155 transfers, mints, burns, vault deposits and withdrawals, WETH wraps and unwraps — each with the token contract and its standard (`tokenStandard`), the event kind (`eventType`), from, to, the raw amount (not scaled by decimals) or token id, and the transaction with its sender and target. No symbols: identify a token by its address and read its decimals with get_token. `total` counts the whole block; a block with no token transfers answers an empty list, which is a fact about that block. A height not served yet is refused (`not_found`), and a block temporarily unavailable is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later. Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy block at the maximum. Use it to see every token movement of a block. Not for one token's transfers across blocks (get_token_transfers) or one address's (get_entity_token_transfers).

Arguments: number; optional limit (default 25, at most 200), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/block-token-transfers

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): The block height.

### `get_block_transactions` (~840 tokens)

Transactions of one block

The transactions of one block in their order within it — each with sender, recipient, value, nonce, type, gas limit and gas used, the fee fields of its type and the price paid per gas, the called function's selector (`methodId`) and the receipt's outcome — plus `txCount`, the block's whole count. `status`, `methodId` (a selector), `minValueWei` / `maxValueWei` and `txType` narrow it, with `matchCount` the narrowed count; `sort` `value` lists the largest value first. A height not served yet is refused (`not_found`). A page of transactions with long revert texts can hold fewer than `limit` (pages are bounded in bytes too); `nextCursor` then continues it. Every call is one request against your rate limit and quota whatever its `limit`, so walk a whole block at the maximum. Use it to list what a block contains. Not for the block's header and totals (get_block) or what one transaction emitted or executed (get_transaction_events, get_transaction_trace). Not for the token transfers its transactions emitted: use get_block_token_transfers. Not for the ETH moved by inner calls: use get_block_internal_transfers.

Arguments: number; optional limit (default 10, at most 100), cursor, status, methodId, minValueWei, maxValueWei, txType, sort. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/block-transactions

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `maxValueWei` (string): Only transactions moving at most this value, in wei: a non-negative integer of at most 38 digits, not below `minValueWei`.
- `methodId` (string): Only calls of this function: its selector, `0x` + 8 hex characters, as `methodId` carries it. A transaction whose input is shorter than four bytes has no selector and never matches.
- `minValueWei` (string): Only transactions moving at least this value, in wei: a non-negative integer of at most 38 digits.
- `number` (integer, required): Block height.
- `sort` (string): `index` (the default): in transaction-index order. `value`: largest `valueWei` first, equal values in transaction-index order. The direction of each is fixed.
- `status` (string): Only transactions with this receipt outcome: `1` (success) or `0` (failure). A transaction whose receipt is not available yet matches neither.
- `txType` (integer): Only transactions of this type: 0 legacy, 1 EIP-2930, 2 EIP-1559, 3 EIP-4844 (blobs), 4 EIP-7702; any integer up to 127 is accepted.

### `get_block_withdrawals` (~482 tokens)

Validator withdrawals of one block

The validator withdrawals paid out in one block, in withdrawal-index order — each with its global index, the validator, the address paid and the amount in gwei — plus `withdrawalCount`. A block holds at most 16, so the default page is the whole block; `validatorIndex` or `address` narrows it to one validator or one recipient. A block with no withdrawals answers an empty list, which is a fact about that block; a height above the chain head is refused (`not_found`). Use it to see who was paid in a block. Not for one validator across blocks: use get_validator_withdrawals.

Arguments: number; optional limit (default 16, at most 100), cursor, validatorIndex, address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/block-withdrawals

Input parameters:

- `address` (string): Only withdrawals paid to this address, `0x`-prefixed.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 16. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `number` (integer, required): Block height.
- `validatorIndex` (integer): Only withdrawals of this validator index.

### `get_consensus_epochs` (~487 tokens)

Epoch health

Complete epochs of the beacon chain (32 slots each), newest first — slots proposed and missed (`missedRatio`), distinct proposers, average sync committee participation, attestations, blob commitments, deposits, voluntary exits, slashings, BLS credential changes, execution-layer requests (EIP-7685) and execution gas and transactions. The epoch in progress is absent until it is complete, and a field the epoch's fork had not introduced yet is absent, not zero. `publishedThroughEpoch` is the newest epoch published; `notHeldEpochs` counts epochs in the page's span that TraceFast does not hold right now and so does not list. Use it to follow consensus participation epoch by epoch. Not for one slot (get_consensus_slot) or whether the chain is finalizing now (get_consensus_health).

Arguments: none required; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-epochs

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_consensus_health` (~420 tokens)

Consensus liveness

The liveness of the consensus layer now: the newest head and finalized slot TraceFast saw and when (`head`, `finalized`), the distance between them (`finalizationLagSlots`), the newest published slot, missed slots over the last 24 hours (`missedSlots24h`, the newest of them listed in `missedSlots`, at most 50) and reorgs over the last 24 hours (`reorgs24h`, each one listed), plus `observation24h` — how completely the head was watched over the window — and `ages`, seconds since each moment, computed for this call. A reorg count is a statement about what was SEEN: read it next to `observation24h`, and minutes in `ages.headSeconds` mean the head is not being observed. A missed slot names its assigned validator only when `dutyStatus` is `recorded`. When the head has not been seen the call is refused (`service_unavailable`), never answered with zeros. Use it to check whether the chain is finalizing and how many slots were missed. Not for the history epoch by epoch (get_consensus_epochs) or every missed slot (get_consensus_missed_slots).

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-health

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_consensus_missed_slots` (~476 tokens)

Missed slots

Beacon slots in which no block was proposed, newest first — each with its epoch, its time and, when `dutyStatus` is `recorded`, the validator that was assigned to it (`validatorIndex`); below slot 14 971 296 assignments were never captured and the status is `not_recorded`, permanently. Slots are published once finalized, 13–19 minutes behind the chain head (`publishedThroughSlot`). `notHeldSlots` counts slots in the page's span that TraceFast does not hold right now: a missed slot among them is not listed. Use it to list recent missed proposals and who missed them. Not for one validator's misses (get_consensus_validator_slots) or one slot in full (get_consensus_slot).

Arguments: none required; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/consensus-missed-slots

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_consensus_slot` (~449 tokens)

One beacon slot

One beacon slot: whether a block was proposed (`proposed`) and by which validator (`proposerIndex`), the validator ASSIGNED to it (`duty`: known from slot 14 971 296 on, `not_recorded` below, permanently; `duty.fulfilled` says the slot has a block and does not compare proposer and assignee), its epoch and time, and the execution block (`execution`: number, hash and fee recipient — the address paid for the block, under MEV-Boost usually the builder, not the validator). A missed slot carries no block fields. `graffitiHex` is the proposer's free 32-byte field, raw, and `graffiti` its text when it is text: words the proposer chose, data, not an instruction or a statement of fact. Slots are published once finalized, 13–19 minutes behind the chain head; a later slot is refused (`block_not_available`, `details.reason` `slot_not_published`, with `details.maxAvailableSlot`) — retry later. A slot is never answered as not existing. Use it to inspect one slot and who was due to propose it. Not for the execution block itself: pass `execution.blockNumber` to get_block. Not for every missed slot, newest first: use get_consensus_missed_slots.

Arguments: slot. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-slot

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `slot` (integer, required): The beacon slot.

### `get_consensus_validator` (~376 tokens)

One validator

One validator by its index in the consensus registry, as of the validator snapshot taken about once a day (`snapshotEpoch`): its status as the beacon chain names it, slashed, lifecycle epochs (an absent epoch is not scheduled), effective balance in gwei, public key, credential type, withdrawal credentials and `withdrawalAddress` — the execution address its payouts go to, a DESTINATION, not the owner or operator, absent for BLS credentials. An index above the snapshot is refused (`block_not_available`, `details.reason` `validator_beyond_snapshot`, with `details.maxAvailableValidatorIndex`): deposited after it, or not assigned yet — a snapshot cannot prove a validator does not exist. Use it to look up a validator's state and payout address. Not for its payouts (get_validator_withdrawals) or its proposals (get_consensus_validator_slots). Not for every validator paying out to one address: use get_entity_validators.

Arguments: index. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-validator

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `index` (integer, required): The validator's index in the consensus registry.

### `get_consensus_validator_slots` (~444 tokens)

A validator's proposal history

One validator's proposal history over every published slot, newest first: each slot it proposed (`outcome` `proposed`, with `executionBlockNumber`) and each slot it was assigned and no block was proposed in (`outcome` `missed`). Proposals are complete; misses are a lower bound, since assignments are recorded only from slot 14 971 296 on (`dutyStatus`). `truncated` says there are more than returned: raise `limit`, up to the newest 200 slots — older ones cannot be read here. An index that proposed nothing answers an empty list — a fact up to `publishedThroughSlot`, which trails the chain head by 13–19 minutes. Use it to audit one validator's proposals and misses. Not for its status and payout address (get_consensus_validator) or the network's misses (get_consensus_missed_slots).

Arguments: index; optional limit (default 25, at most 200). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/consensus-validator-slots

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `index` (integer, required): The validator's index in the consensus registry.
- `limit` (integer): How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_contract` (~347 tokens)

One contract

One deployed contract: the hash and size of its current code, what the code exposes (the four ERC-20 view functions, ERC-165, an EIP-1167 minimal proxy and its target), the proxy pattern detected in it, and its lifecycle — the deploying account, the creating transaction, code changes and self-destruction. An address with no indexed code is refused (`not_found`). Use it to learn how a contract is built. Not for the selectors in its code (get_contract_selectors), its implementations (get_contract_proxy) or the address as an account (get_entity_overview). Not for its code hashes and fingerprint in one place: use get_contract_identity. Not for how its code can change: use get_contract_security.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_bytecode` (~306 tokens)

Bytecode of a contract

The current runtime bytecode of a contract as hex — up to 24 576 bytes of code — with its code hash and a structural fingerprint that is equal across contracts sharing the same logic. An address with no indexed code is refused (`not_found`). Use it to read or compare a contract's code. Not for a readable summary: use get_contract or get_contract_selectors. Not for its instructions one by one: use get_contract_disassembly. Not for the code as readable pseudocode: use get_contract_decompilation.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-bytecode

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_capabilities` (~382 tokens)

What a contract can do: mint, pause, blacklist, upgrade

The powers of one contract, each answered as three separate questions — `inCode` (its code exposes the power), `availableNow` (it can be used right now) and `usedBefore` (it has been used on chain) — with the block each answer was evaluated at (`referenceBlock`). Powers include `mint`, `burn`, `pause`, `blacklist`, `freeze`, `seize`, `upgrade` and `emergency_withdraw`; others may appear. An answer is present only when it is proven: an absent answer means not proven, never "no". `otherFacts` lists the remaining proven capability facts by id (for example `capability:currently_paused`); `graphReached` false means TraceFast has not evaluated the address yet, so nothing here is an answer about it. Use it to check what an issuer or admin could do to a token or its holders. Not for how the code is built or can change: use get_contract_security.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; each attribute or relation carries the block it was evaluated at, and the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-capabilities

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_clones` (~506 tokens)

Contracts running exactly the same code

Every contract running exactly the same code as this one — byte for byte, the same `codeHash` — in address order, each with the block its code was set at, plus `contractCount`, the size of the whole list. The same code says nothing about owner or deployer: factories, templates and copies produce identical code for unrelated parties, and clones can hold different state. Code that differs only in its metadata or constructor-set values is not listed: compare `fingerprint` from get_contract_identity. For an EIP-7702 account the shared code is the delegation, so the list is the accounts delegated to the same contract. The list is updated once a day: a contract deployed or changed since then, this one included, is missing or still listed under its earlier code. An address with no indexed code is refused (`not_found`). Use it to find other deployments of a known contract. Not for the contracts an address created: use get_entity_deployments.

Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: a ranking recomputed daily; it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-clones

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_contract_control_history` (~505 tokens)

Who changed a proxy's implementation or admin, and when

Every write to a proxy's control slots — the EIP-1967 implementation, admin and beacon slots and the older OpenZeppelin slot — newest first, one row per write: the block and transaction, which `slot`, `oldValue` and `newValue`, who called the frame that wrote it (`callerAddress`) and whose code ran in it (`executionAddress`). `kind` is `upgrade` (a value written), `unset` (the slot written to zero) or `cleared` (wiped with the account by a pre-Cancun SELFDESTRUCT); other values may be added. An `upgrade` from an all-zero value means the slot was empty before, not necessarily the proxy's deployment. Changes of an owner role are not here: only the storage slots proxies use for control. Use it to see who upgraded a proxy or changed its admin, and when. Not for the implementations themselves with the blocks each was seen at: use get_contract_proxy.

Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-control-history

Input parameters:

- `address` (string, required): The proxy, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_contract_decompilation` (~668 tokens)

Decompiled code of a contract

A contract's code reconstructed as readable Solidity-like pseudocode, for contracts with or without published source — by default the code that runs at the address (through a proxy, a beacon, a minimal proxy or an EIP-7702 delegation), at the latest block or at `block`. The answer is a table of contents of the functions, named where known; `selector` returns one function's body, `bodies` the bodies in order, a page at a time; the table of contents is paged too (about 512 KiB a page: `hasMore`, `nextCursor`); a body larger than 512 KiB as written comes without `text` (`textState` `withheld_for_size` and `textLength` instead). The reconstruction is best-effort and every answer says so. A code not analysed yet is analysed on request: the call is then refused (`decompilation_pending`) with `retryAfterSeconds` — call again after it, usually within a minute. Each account starts a limited number of analyses per day; reading an analysed code is not limited. Use it to understand what an unverified contract does. Not for the selectors its bytecode refers to: use get_contract_selectors. Not for the instructions behind a body's pcs: use get_contract_disassembly.

Arguments: address; optional block, target, selector, bodies, cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-decompilation

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer): The block to resolve the code at. Default: the latest covered block.
- `bodies` (boolean): `true`: the first page of bodies in table-of-contents order.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `selector` (string): One function's body: `0x` + 8 hex characters, or `fallback` / `receive`. Not with `bodies` or `cursor`.
- `target` (string): `auto` (default): the code that runs at the address, one hop through a proxy. `self`: the address's own code (a proxy's own).

### `get_contract_disassembly` (~511 tokens)

Disassembly of a contract

A contract's code as EVM instructions with their byte offsets (pc), in order, a page at a time — the same pcs the decompiled view refers to. By default the code that runs at the address, through a proxy, at the latest block or at `block`. The compiler's metadata at the end of the code is named and every instruction inside it is marked: it is data that happens to decode as instructions. Use it to inspect a contract at the instruction level. Not for the raw code as hex: use get_contract_bytecode.

Arguments: address; optional block, target, limit (default 500, at most 2000), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-disassembly

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer): The block to resolve the code at. Default: the latest covered block.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 2000, default 500. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `target` (string): `auto` (default): the code that runs at the address, one hop through a proxy. `self`: the address's own code.

### `get_contract_events` (~807 tokens)

Events emitted by a contract

The event logs a contract emitted, newest first (`order` `asc` for oldest first) — each with its topics, data, transaction and position and, where the signature is known, the decoded event and arguments with a stated confidence (`decodeStatus`), plus the readings (`decoded.candidates`, at most 8; `candidateCount` is the true count) when more than one known signature fits. One event's readings are bounded in size: a value too large to include is `valueState` `withheld_for_size`, without `value` (the log's `data` carries its bytes), and a decoding stopped by its work budget before every known signature was tried says `decodeSearch` `incomplete` — `ambiguous` with a reading, no `decodeStatus` without one, never `failed`. A log whose data is longer than 49 151 bytes comes without `data`: `dataState` `withheld_for_size` and `dataLength` (bytes) instead, topics and decoding still given. A page holds at most `limit` events and may hold fewer when their data is large; a log is never cut. `topic0` narrows to one event signature, `eventName` to one event name and `fromBlock` / `toBlock` to a block window; on a very active contract `topic0` and `eventName` are answered only inside a window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to read a contract's event history. Not for what one transaction emitted: use get_transaction_events.

Arguments: address; optional limit (default 10, at most 100), cursor, topic0, eventName, order, fromBlock, toBlock. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minut…

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `eventName` (string): Only events whose name, as TraceFast's event index records it, is this value, e.g. `Transfer`: 1 to 100 letters, digits or underscores. Case-sensitive. An event the index holds no name for is not mat…
- `fromBlock` (integer): Inclusive lower block bound.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `order` (string): `desc` (default): newest first. `asc`: oldest first — the start of the contract's history on the first page.
- `toBlock` (integer): Inclusive upper block bound.
- `topic0` (string): The event signature hash to narrow to, `0x`-prefixed, 64 hex characters.

### `get_contract_function_calls` (~475 tokens)

Calls per function of a contract

How often each function of an address was called — the transactions sent to it per 4-byte selector, most called first, with the block of the last call and the function's name where known — plus the first and the last block in which it received any call. Top-level calls only: a call made from inside another contract is not counted, and a proxy's calls are counted at the proxy. An address nobody called answers an empty list. At most the 1 000 most called selectors (`truncated` when more exist; `entryCount` is the whole list's), paged by bytes: about 448 KiB a page, a whole entry at a time; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`; a cursor from a list recounted since is refused (`invalid_cursor`: restart). Use it to see which functions of a contract are actually used. Not for the transactions themselves: use get_entity_transactions. Not for the calls one by one, internal ones included: use get_entity_calls_received.

Arguments: address; optional cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: current all-time counters, refreshed periodically; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-function-calls

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.

### `get_contract_hot_slots` (~426 tokens)

The storage slots of a contract that changed most recently

The 25 storage slots of a contract whose value changed in the most blocks of a recent window (`windowBlocks`, about a day by default, at most a week), each with how many blocks it changed in and the last of them, plus `totalSlotsInWindow`, every slot that changed. A change is a block in which the value differs: several writes in one block are one change, and a write of the value already held is none. A slot not listed changed in fewer blocks than the 25 listed, or not at all. The window ends at the newest block known (`windowToBlock`); an empty window answers an empty list with `lastChangeBlock`, the contract's newest change before it, where known. A window too wide to read right now is refused (`service_unavailable`); a `windowBlocks` no larger than `details.maxBacklogBlocks` is always answered. Use it to see which state of a contract is busy right now. Not for one slot's values over time: use get_contract_slot_history. Not for every declared variable with its current value: use get_contract_storage_parameters.

Arguments: address; optional windowBlocks. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-hot-slots

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `windowBlocks` (integer): The window's width in blocks, 1 to 50400 (one week), default 7200 (about a day).

### `get_contract_identity` (~365 tokens)

Which code a contract runs, its hashes, and how it came to be

Which code a contract runs and how it came to be: the Keccak-256 hash of its current code (`codeHash`), the SHA-256 of the same code (`runtimeSha256`, the hash source verifiers such as Sourcify key on), a structural `fingerprint` equal across contracts sharing the same logic, the code's size and kind (`bytecodeVariant`), and its `lifecycle` — deploying and signing account, creating transaction, code changes and self-destruction. Fields not recorded are absent. For an account delegated by EIP-7702 the stored bytes are the delegation, not code, so `runtimeSha256` and `fingerprint` are absent. An address with no indexed code is refused (`not_found`). Use it to match a contract against verified source or other deployments. Not for other contracts with exactly this code: use get_contract_clones.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-identity

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_proxy` (~417 tokens)

Implementations of a proxy contract

The implementations a proxy contract has been seen delegating to, newest first — read from its EIP-1167 bytecode, its EIP-1967 implementation or beacon slot, or its OpenZeppelin v1 slot — each with the blocks it was seen at and whether it has since been replaced. `supersededBy` has three states: absent when storage cannot say, `null` when the pointer is current, an address when it was replaced. For a beacon proxy the address listed is the beacon, and `beacon` says what that beacon handed out: each logic contract with its block range, newest first (`state: proven`), or `not_proven` when the beacon's implementation could not be established. An empty list means no pointer was seen, not that the address is not a proxy. Use it for a proxy's implementation history as its code and storage show it. Not for the relations TraceFast has proven: use get_entity_relations. Not for every write to its control slots, with who made it: use get_contract_control_history.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-proxy

Input parameters:

- `address` (string, required): The proxy contract address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_security` (~363 tokens)

How a contract's code is built and how it can change

How one contract's current code is built and how it can change: the proxy pattern detected in it (`proxyFamily`) with its confidence, its opcode-level features (`codeFeatures`: DELEGATECALL, CALLCODE, a DELEGATECALL target read from storage), and what TraceFast has proven about its architecture (`architecture`: for example immutable, an upgradeable proxy, a mutable implementation slot, metamorphic), each fact with its evaluation block. Only proven facts are stated: an absent one means not proven, never "no"; `graphReached` false means the address is not evaluated yet. An address with no indexed code is refused (`not_found`). Use it to judge whether a contract's behaviour can change under its users. Not for who changed a proxy's implementation and when (get_contract_control_history) or what the contract can do (get_contract_capabilities).

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-security

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_selectors` (~488 tokens)

Function selectors of a contract

The 4-byte selectors found as constants in a contract's bytecode, each resolved to a known signature and function name where one exists, with how many known signatures share it and how confident the resolution is (`decodeStatus`). The list holds the contract's own functions together with the selectors of functions it calls on other contracts and of its custom errors, not told apart: a selector here is not proof the contract implements it. A known signature whose text is not served says `nameState: withheld`. Paged: at most 1 000 selectors and about 224 KiB a page; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`. An address with no indexed code is refused (`not_found`). Use it to see which known functions and errors a contract's code refers to. Not for the calls it received (get_entity_transactions) or the events it emitted (get_contract_events). Not for how often each function was called: use get_contract_function_calls.

Arguments: address; optional cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-selectors

Input parameters:

- `address` (string, required): The contract address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.

### `get_contract_slot_history` (~534 tokens)

How one storage slot of a contract changed over time

Every block in which one storage slot (`key`, 32 bytes) of a contract changed value, newest first — `valueBefore` and `valueAfter` the block, and the transactions that wrote the slot in it (`writerTxs`). One entry per block: several writes in one block are one change, and a write of the value already held is none. `valueAfter` is absent on the newest change when it is not stated, never a zero standing in; `writerTxs` is empty for a system write with no transaction, and absent until the block is attributed (usually seconds). `readThroughBlock` is the newest block the page was read through. A page can be shorter than `limit` and still continue: one call reads a bounded span of history. Use it to follow one variable of a contract over time. Not for finding which slots matter: use get_contract_hot_slots or get_contract_storage_parameters.

Arguments: address, key; optional limit (default 25, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-slot-history

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `key` (string, required): The 32-byte slot key, `0x` + 64 hex.
- `limit` (integer): How many rows to return: 1 to 100, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_contract_storage_activity` (~339 tokens)

How a contract's storage was read and written, per day

For each UTC day of a window (`days`, 90 by default, at most 365), oldest first, how many transactions touched a contract's storage, read it, wrote it, or only read it (a dependency on its state); the SLOAD and SSTORE opcode counts (reverted frames included — executions, not distinct slots); the transient-storage opcodes TLOAD and TSTORE; and the slot touches (distinct slots per transaction, summed). Only days with activity have a row: a missing day is not a stated zero. The last day is partial, through `readThroughBlock`. Use it to see how a contract's state is used over time and how many transactions read it without writing. Not for who writes it: use get_contract_storage_writers.

Arguments: address; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-storage-activity

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `days` (integer): The window in UTC days, 1 to 365, default 90.

### `get_contract_storage_parameters` (~528 tokens)

The direct storage slots of a contract (its declared variables) and their values

The direct storage slots of a contract — the slots below 2^64 that hold its declared variables, packed fields and fixed-array elements, not mapping entries — in slot order, each with how many blocks changed it, the first and last of them, and its current value. `currentValueStatus` says whether the value can be stated: `observed` (then `currentValue`), `system_writes`, `ambiguous_order`, `storage_cleared`, `no_transaction_write`, or `not_computed` (the newest blocks are not processed yet: retry); `currentValue` is absent in every state but `observed`, never a zero. Variable names are not stated, and only slots whose value ever changed are listed: absence is not "no such variable". A contract with too many or too densely changed direct slots is refused (`storage_parameters_unavailable`) — read single slots with get_contract_slot_history. Use it to read a contract's configuration and state variables. Not for mapping entries such as balances: use get_contract_slot_history with the slot key.

Arguments: address; optional limit (default 25, at most 200), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-storage-parameters

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_contract_storage_profile` (~323 tokens)

Totals of a contract's storage writes

The totals of every write to a contract's storage over its history: how many writes (`totalWrites`), distinct slots, callers and executing code addresses (estimates on large contracts), the first and last block written, how many writes ran through DELEGATECALL (`delegatecallWrites`, code borrowed from another contract as in a proxy) and their share, and the deepest call depth a write happened at. Refreshed hourly: the newest writes are not counted yet, and an address whose first write is that recent is refused (`not_found`) like one that never wrote. No names. Use it to size a contract's storage footprint at a glance. Not for who the writers are: use get_contract_storage_writers. Not for reads and writes day by day: use get_contract_storage_activity.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: current all-time counters, refreshed periodically; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-storage-profile

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_contract_storage_writers` (~400 tokens)

Who writes a contract's storage

The accounts that wrote a contract's storage, ranked by number of writes — each row a pair of the caller (`callerAddress`, who called the frame that wrote) and the execution address (`executionAddress`, whose code ran: the contract itself, or an implementation it delegated to) — with the writes, the transactions (an estimate on large contracts) and the first and last block. `totalPairs` counts every pair; the list is the top of the ranking only, ties broken by caller then execution address. The ranking is refreshed once a day, the counts and blocks hourly: a pair that started writing or moved up since then is not reflected yet. No names. Use it to find which accounts and code change a contract's state. Not for the totals: use get_contract_storage_profile.

Arguments: address; optional limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: a ranking recomputed daily; it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-storage-writers

Input parameters:

- `address` (string, required): The contract, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_dex_volume_daily` (~383 tokens)

DEX volume per day, by protocol

Per UTC day over a window of dates, oldest first: the DEX trading of each protocol — swaps, USD volume, active pools and the pools that could not be priced (`unpricedPools`) — and the day's totals. A USD volume adds only the pools that could be priced, so a figure beside `unpricedPools` is a partial sum, and it covers the pools TraceFast decodes, not every venue. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent. Days marked `provisional` may still change: today, and the last four days, whose USD values are revised once a day. Use it to chart DEX activity by protocol. Not for which tokens or pools traded most: use get_top_dex_tokens or get_top_pools.

Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-dex-volume

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (string): The first UTC date, `YYYY-MM-DD`.
- `to` (string): The last UTC date, `YYYY-MM-DD`. Default: today.

### `get_entity_activity` (~312 tokens)

Activity of an address

When an address was active, as three separate answers: when it was first mentioned anywhere on chain; when its own account state last changed and how many times; and the newest block at which it took part in anything (a top-level transaction, a token transfer, an emitted log, a value-bearing call), with the sources that answer covers. Read `lastActivity` as "last active": a contract only ever called by other contracts never changes its own state after deployment. Use it to date an address. Not for who it deals with: use get_entity_counterparties. Not for activity day by day: use get_entity_daily_activity. Not for the transactions themselves: use get_entity_transactions.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-activity

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_attribute_history` (~407 tokens)

Attribute history of an address

Every attribute interval an address has held, oldest first — when it became a contract, when its code was removed, when it first held state — each with the blocks it started and ended at. Covers the attribute families listed in `coveredFamilies`; an empty or short timeline says nothing about other families. Intervals of the `behavior` family state an observed pattern, not a verdict, and the most recent of them may shorten or disappear as later blocks are evaluated. `truncated` is true when the timeline was cut at `limit`: ask again with a larger `limit` (the maximum holds the whole timeline of the busiest address). Use it for "since when" and "until when". Not for the current set: use get_entity_attributes; for one past block use get_entity_attributes_at_block.

Arguments: address; optional limit (default 25, at most 500). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-attribute-history

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 500, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_attribute_proof` (~333 tokens)

Proof of one attribute of an address

The evidence behind one proven attribute of an address — the facts that were checked with their expected and observed values, the conditions that had to be false, opaque ids of the sources read, and the block and block hash the evaluation was pinned to — so the claim can be checked rather than trusted. `attribute_id` is an id get_entity_attributes lists in `attributes` (`family:name`; `attributeId` in its details). An attribute with no recorded proof is refused (`not_found`). Use it to verify why TraceFast states an attribute. Not for the attributes themselves: use get_entity_attributes.

Arguments: address, attribute_id. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a proof is the record of one evaluation, pinned to the block it read (`data.referenceBlock`); `meta.asOfBlock` is the highest block the proof records reach. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-attribute-proof

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `attribute_id` (string, required): The attribute id, `family:name`, as listed by the attributes method.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_attributes` (~345 tokens)

Attributes of an address

The facts TraceFast has proven about an address now — what kind of account it is, how it has been used, what it is known to be: the proven attribute ids (`family:name`), each with its evaluation result and the block it was evaluated at, and, while the address is not evaluated yet, a provisional classification from on-chain evidence. An absent attribute is not proven; absence never means the opposite. Use it to learn what an address is. Not for the past: use get_entity_attributes_at_block or get_entity_attribute_history; not for balances or activity: use get_entity_overview. For the evidence behind one proven attribute, use get_entity_attribute_proof. Not for a contract's powers (mint, pause, blacklist, upgrade) arranged per power: use get_contract_capabilities.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; each attribute or relation carries the block it was evaluated at, and the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-attributes

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_attributes_at_block` (~338 tokens)

Attributes of an address at a block

The attributes an address held at the end of one past block, each with the window it held for. Answered from the attribute history, which covers the families listed in `coveredFamilies` and the single ids listed in `coveredAttributeIds`: any other attribute is not listed whether or not it held, so its absence is not a negative — compare with get_entity_attributes for those. `behavior` is in `coveredFamilies` only for a block the family has been computed to. Use it for "what was this address at block N". Not for the current set (get_entity_attributes) or the whole timeline (get_entity_attribute_history).

Arguments: address, block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the state at the end of the `block` you pass; `meta.asOfBlock` is the highest block the history covers, and a later `block` is refused (`block_not_available`). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-attributes-at-block

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer, required): The block to answer about. Required.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_balance_history` (~423 tokens)

Native balance history of an address

The native ETH balance of an address at the end of each day it changed, oldest first — with the day's net change, its balance-changing events and the USD value at the day's last hour (none for the current, unfinished day) — plus totals over the days returned: start and end balance, minimum and maximum, and inflow / outflow as sums of the days' NET changes — ether that arrived and left within one day is not counted in either, so they are not gross amounts received or sent. Days without a change have no point; `limit` counts the most recent days with a change. Use it to chart an address's ETH balance over time. Not for token balances (get_entity_portfolio) or the balance now (get_entity_overview). Not for every block that changed the balance, nonce or code: use get_entity_state_changes.

Arguments: address; optional limit (default 30, at most 365). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-balance-history

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 365, default 30. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_calls_received` (~505 tokens)

Transactions that called an address

Every transaction with a call frame in this address's context — it was called, as the transaction's own target (`transactionTarget`) or from inside another contract, reverted or not, with or without ETH — newest first: the block, the transaction, its sender (`txSender`) and whether it succeeded, how many frames ran in the address's context and how many of them failed, their kinds (`callTypes`) and whether any carried ETH. `txSender` signed the transaction; the direct caller may be a contract it reached. A proxy's frames include the runs of its implementation, so an implementation behind a proxy is not listed for those runs. A contract's own deployment is not a call. Known up to `meta.asOfBlock`, which trails the chain head: an empty list means no call up to that block. Use it to see who uses a contract, internal calls included. Not for the transactions the address itself sent or received at top level: use get_entity_transactions.

Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-calls-received

Input parameters:

- `address` (string, required): The address, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_counterparties` (~902 tokens)

Counterparties of an address, ranked

The addresses one address has interacted with most, ranked by successful transactions across top-level transactions (with or without ETH, so a called token contract counts), internal ETH transfers and token Transfer events (as emitted: not checked against a balance change, zero amounts included, so address-poisoning events count) — each with its transaction counts, first and last block of interaction, the surfaces the relation was seen on and the token classes involved — plus `corpus`, how many counterparties the ranking covered. The zero address and the address itself are never ranked. Pass `nextCursor` back as `cursor` to go past the first page: the ranking holds `rankingDepth` counterparties (up to 1 000; 100 at a past block and for the largest addresses) and `rankingTruncated` says whether more rank below; a cursor from before the ranking was recomputed is refused (`invalid_cursor`: start again) — for a window that can happen after about 2 minutes, all-time and past-block cursors last longer. `window` `24h` or `7d` ranks the rolling last 24 hours or 7 days instead of the whole history. With `block`, the ranking as it stood at the end of that block, computed over the whole history up to it. With `counterparty`, the figures of that one pair (in the same window or block) read from the relationship graph — for the largest addresses that is not the daily top list their ranking comes from, so a pair can be newer than its ranking row — or `lookup.found: false`; `lookup.excludedFromRanking` marks the zero address and the address itself. Very large addresses are refused for a past block (a ranking or a pair) or a window with the bound stated (never answered with a narrowed set). Use it to see whom an address interacts with, or whether two addresses interacted; a row is not proof that value moved between the two — check the transfers themselves. Not for declared links such as proxy to implementation: use get_entity_relations. Not for the transactions themselves: use get_…

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer): State at the end of this block (everything up to and including it). Absent: the current ranking. Not with `window`.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `counterparty` (string): One counterparty, `0x` + 40 hex characters: answers that pair's figures (or `lookup.found: false`) instead of a ranking. Not with `limit` or `cursor`.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `window` (string): `all` (default: the whole history), `24h` or `7d` — the rolling last 24 hours or 7 days, ending at the newest block counted. Not with `block`.

### `get_entity_daily_activity` (~339 tokens)

Daily activity of an address

For each day of a window (`period`: `30d`, `90d` by default, or `365d`), how many blocks changed an address's own account state and what changed — balance, nonce (transactions sent), code, creation — plus the window's active days and total active blocks. Days without activity have no entry. Activity that does not change the address's own state, such as receiving a token or being called, is not counted here. Use it to see how regularly an address acts. Not for when it was first or last active (get_entity_activity) or its balance over time (get_entity_balance_history).

Arguments: address; optional period. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-daily-activity

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `period` (string): `30d`, `90d` (default) or `365d`.

### `get_entity_deployments` (~495 tokens)

Contracts an address created

Every contract creation an address made — each successful CREATE or CREATE2 frame it called — oldest first: the created contract, the block, the transaction, `callType`, the code it deployed (`codeHash`, `isEip1167Proxy`) and the wallet that signed the transaction (`originAddress`). The address is the DIRECT creator: for a factory that is the factory, so a wallet's deployments made through a factory are listed under the factory, not the wallet. A row is a creation event: `outcome` `rolled_back` means a frame above it or the transaction failed and no contract came from it. One address can appear more than once (re-created after self-destruction, or rolled-back attempts). An empty list means no creation is recorded up to `meta.asOfBlock`. Use it to list what a deployer or factory created. Not for one contract's own origin: use get_contract_identity.

Arguments: address; optional limit (default 10, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-deployments

Input parameters:

- `address` (string, required): The creating address, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_dex_trades` (~533 tokens)

DEX trades an address took part in

The DEX swaps an address sent or received the output of, newest first — the venue (`protocol`, `protocolVersion`), the pool (`poolAddress`, or `poolId` for a pool with no address of its own), the tokens sold and bought with their raw amounts, decimals and self-declared symbols, this address's part (`role`), and `valueUsd`, an estimate at the hour of the trade (`valuedLeg` says which leg; absent when neither can be valued). Coverage is the pools TraceFast has discovered: swaps on other pools are missing, and Balancer V2 swaps (whose event names no trader) are not listed, so an empty list is not proof the address never traded. The address is matched as the swap event's sender or recipient: a trade routed through a contract is listed under that contract. Use it to read an address's trading. Not for its token movements in general: use get_entity_token_transfers. Not for every swap of one pool: use get_pool_swaps.

Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-dex-trades

Input parameters:

- `address` (string, required): The address, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_internal_transfers` (~841 tokens)

Internal transfers of an address

The value-carrying calls an address sent or received inside transactions, newest first — each with its position and depth in the call tree, the kind of call, the value moved in wei, the other party and the frame's own outcome. The transaction's own top-level call is not one of these: it is the transaction, listed by get_entity_transactions. `direction` (`sent` or `received`), `counterparty` and `callType` (`call`, `callcode`, `create`, `create2`, `selfdestruct`) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address a filter is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to find ETH an address moved or received through contracts. Not for one transaction's whole call tree: use get_transaction_trace.

Arguments: address; optional limit (default 10, at most 100), cursor, direction, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, callType. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/entity-internal-transfers

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `callType` (string): One kind of call, as served in `callType`: `call`, `callcode`, `create`, `create2` or `selfdestruct`.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `counterparty` (string): Only rows whose other side is this address (`0x` + 40 hex). A filter like the others: on a very active address it is answered only inside a block window, and the refusal names the window it needs (`f…
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `direction` (string): `sent` or `received`.
- `fromBlock` (integer): Inclusive lower block bound.
- `fromTimestamp` (integer): Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `order` (string): `desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
- `toBlock` (integer): Inclusive upper block bound.
- `toTimestamp` (integer): Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.

### `get_entity_overview` (~345 tokens)

One address

One address as the chain sees it now: how it exists (an account whose state was touched, or an address only ever mentioned by other operations), whether it holds code, for an account whether it delegates its code with EIP-7702 (`eip7702`: to which contract and since which block), its native ETH balance and nonce, when it was first mentioned and last active, and its direct-transaction counters. No names, labels or prices. An address mentioned nowhere on chain is refused (`not_found`). The starting point for any address: use it first. Not for what the address is (use get_entity_attributes), what it holds (get_entity_portfolio) or who it deals with (get_entity_counterparties). Not for its transactions one by one: use get_entity_transactions. Not for how a contract is built: use get_contract.

Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_portfolio` (~538 tokens)

Portfolio of an address

What an address holds, valued in USD: its token balances and native ETH, each with the balance, the hourly USD price, the USD value and the share of the total, in descending USD value — plus `totalUsd`, `pricedCount` and `hiddenCount` over the WHOLE holding, not just the rows returned; the pages walk every valued position. A position is listed only when it can be valued; the rest is counted in `hiddenCount`. Token balances are served for the covered tokens (`coveredTokenCount`); a token outside that set is absent, not zero. No NFTs, DeFi positions or pool shares. With `block`, the exact state at the end of that block, priced at that block's hour. Use it to value an address's holdings. Not for one token: use get_entity_token_balance. Not for the ETH balance over time: use get_entity_balance_history.

Arguments: address; optional block, limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-portfolio

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer): State at the end of this block. Absent: the current state.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_relation_history` (~564 tokens)

Relation history of an address

Every relation interval an address has held, oldest first (`order` `desc`: newest first) — as the subject (what it pointed at, the default) or as the object (who pointed at it) — each with the blocks it started and ended at. Covers the relation ids listed in `coveredFamilies`; an empty or short timeline says nothing about other relations. A long timeline is paged: pass `nextCursor` back as `cursor` until it is absent. `total` is the length of the whole timeline as the subject; there is none as the object. Use it for "when did this proxy change implementation" or "every delegation this account signed". Not for the relations now: use get_entity_relations.

Arguments: address; optional direction, limit (default 25, at most 500), cursor, attributeId, order. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-relation-history

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `attributeId` (string): Only this relation id, for example `relation:eip7702_delegates_to` — every EIP-7702 delegation the account signed, with `total` counting them.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `direction` (string): `subject` (default) or `object`.
- `limit` (integer): How many rows to return: 1 to 500, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `order` (string): `asc` (default): oldest interval first. `desc`: newest first — the recent end of a long timeline on the first page.

### `get_entity_relation_proof` (~417 tokens)

Proof of one relation of an address

The evidence behind one proven relation between two addresses — the facts checked with their expected and observed values, the conditions that had to be false, opaque ids of the sources read, and the block and block hash the evaluation was pinned to. `address` is the relation's subject and `object` the address it points at; `attribute_id` is the relation id (`relation:name`), a get_entity_relations row's `attributeId`. A row listed with `direction` `object` is the other way round: its `counterpart` is the subject, so pass it as `address` and the address you listed as `object`. A relation with no recorded proof is refused (`not_found`). Use it to verify why TraceFast states a relation, such as a proxy's implementation. Not for the relations themselves: use get_entity_relations.

Arguments: address, attribute_id, object. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a proof is the record of one evaluation, pinned to the block it read (`data.referenceBlock`); `meta.asOfBlock` is the highest block the proof records reach. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-relation-proof

Input parameters:

- `address` (string, required): The subject address, `0x`-prefixed, 40 hex characters, any case.
- `attribute_id` (string, required): The relation id, `relation:name`, as listed by the relations method.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `object` (string, required): The object address of the relation, `0x`-prefixed, 40 hex characters, any case.

### `get_entity_relations` (~580 tokens)

Relations of an address

The relations an address holds now — which implementation a proxy points at, which beacon it reads, who administers it, where an account has delegated, which lending market lists a token — as the subject (what it points at, the default) or as the object (who points at it). One hop from this address: to follow a counterpart, call the tool on it. Ordered by relation id, then counterpart. One implementation can be pointed at by millions of proxies, so the first page of the object side also states `counts`: how many addresses point at it per relation id. Use it to find a proxy's implementation, a contract's administrator or an account's delegate. Not for a past block (get_entity_relations_at_block), the timeline (get_entity_relation_history) or interaction partners (get_entity_counterparties). For the evidence behind one relation, use get_entity_relation_proof. Not for a proxy's implementation history as its code and storage show it: use get_contract_proxy.

Arguments: address; optional direction, attributeId, limit (default 10, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; each attribute or relation carries the block it was evaluated at, and the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-relations

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `attributeId` (string): Narrow to one relation id, `relation:name`. Any id the graph publishes is accepted.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `direction` (string): `subject` (default) or `object`.
- `limit` (integer): How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_relations_at_block` (~311 tokens)

Relations of an address at a block

The relations an address was the subject of at the end of one past block — which implementation a proxy pointed at, which beacon it read, who administered it, where an account had delegated — each with the window it held for. Covers the relation ids listed in `coveredFamilies`. Subject side only. Use it for "what did this proxy point at, at block N". Not for the relations now (get_entity_relations) or who pointed at the address (get_entity_relation_history with direction object).

Arguments: address, block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the state at the end of the `block` you pass; `meta.asOfBlock` is the highest block the history covers, and a later `block` is refused (`block_not_available`). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-relations-at-block

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer, required): The block to answer about. Required.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_entity_state_changes` (~458 tokens)

Every block that changed an account's balance, nonce or code

The history of one account's own state, newest first — one entry per block that changed its balance, nonce or code, with the values before and after the block (`balanceBefore` / `balanceAfter`, nonce, code hash) and whether the account was created in it. The net change over the whole block, not per transaction. A change made by someone else counts too: receiving ETH, a validator withdrawal, being self-destructed into. Known up to `meta.asOfBlock`, which can trail the chain head by a few minutes. Use it to see exactly when and how an account's balance, nonce or code moved. Not for the transactions behind a change (get_entity_transactions) or the ETH balance per day (get_entity_balance_history).

Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-state-changes

Input parameters:

- `address` (string, required): The account, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_entity_token_balance` (~359 tokens)

Balance of one token on an address

The balance of one token on one address — what `balanceOf` returns at the end of a block; a balance of "0" is a real zero. Served for the covered tokens (a growing set); another token is refused (`token_not_covered`) rather than answered with a meaningless zero. With `block`, the exact balance then; a pair with no recorded balance at or before it is refused (`balance_not_available`). Use it to read one token's exact balance. Not for everything an address holds (get_entity_portfolio) or a token's largest holders (get_token_holders).

Arguments: address, token; optional block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-token-balance

Input parameters:

- `address` (string, required): The holder address, `0x`-prefixed, 40 hex characters, any case.
- `block` (integer): State at the end of this block. Absent: the current balance.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `token` (string, required): The token contract address, `0x`-prefixed, 40 hex characters, any case.

### `get_entity_token_transfers` (~1163 tokens)

Token transfers of an address

The token transfers an address sent or received, newest first — ERC-20, ERC-721 and ERC-1155 transfers and the other value events get_token_transfers lists under `eventType` — each with the token as its contract declares itself (a symbol such as `ETH` or `USDT` is self-declared and may be an imitation: identify the token by its address, and ask resolve_entity whether that address is flagged), the raw amount (not scaled by decimals) or token id, the parties and this address's side (`role`), and the transaction that emitted it with who sent that transaction, which on a router or a batch disburser is another party entirely. A transfer the address made to itself is shown once. `direction` (`sent` or `received`), `token`, `counterparty`, `tokenStandard`, `eventType` and `minValue` / `maxValue` (the raw amount, decimal digits) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address, `tokenStandard` and `eventType` alone are answered without a block window when a page of matches lies near where the list starts (the newest transfers, the oldest under `order` `asc`, or the cursor); any other filter, and those two otherwise, is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to follow an address's token flows. Not for balances (get_entity_portfolio) or one token's transfers across all holders (get_token_transfers). Not for its DEX swaps with a USD value: use get_entity_dex_trades.

Arguments: address; optional limit (default 10, at most 100), cursor, direction, token, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, tokenStandard, eventType, minValue, maxValue. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is co…

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `counterparty` (string): Only rows whose other side is this address (`0x` + 40 hex). On a very active address it is answered only inside a block window, alone or beside any other filter, and the refusal names the window it n…
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `direction` (string): `sent` or `received`.
- `eventType` (string): One kind of transfer, as served in `eventType`: `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap` or `unwrap`.
- `fromBlock` (integer): Inclusive lower block bound.
- `fromTimestamp` (integer): Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `maxValue` (string): Inclusive upper bound on the raw amount `value`: decimal digits, up to 2^256 - 1.
- `minValue` (string): Inclusive lower bound on the raw amount `value` (not scaled by decimals): decimal digits, up to 2^256 - 1. A transfer without an amount never matches a value bound.
- `order` (string): `desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
- `toBlock` (integer): Inclusive upper block bound.
- `toTimestamp` (integer): Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.
- `token` (string): One token contract, `0x`-prefixed, 40 hex characters.
- `tokenStandard` (string): One token standard: `erc20`, `erc721`, `erc1155`, `erc777` or `erc4626`.

### `get_entity_transactions` (~1007 tokens)

Transactions of an address

The transactions an address sent or received, newest first — each with sender, recipient, value, fee, the called function where its selector is known, the outcome, and this address's side (`role`: sender, receiver, or self when it is both). `direction` (`sent` or `received`), `status` (the string "1" for success or "0" for failure), `counterparty`, `methodName` (the called function's name as served, not a selector) and `minValueWei` / `maxValueWei` (wei, at most 38 digits) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address a filter is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to read an address's own transactions. Not for token movements (get_entity_token_transfers), value moved by inner calls (get_entity_internal_transfers) or who it deals with most (get_entity_counterparties). Not for calls that reached the address from inside other contracts: use get_entity_calls_received.

Arguments: address; optional limit (default 10, at most 100), cursor, direction, status, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, methodName, minValueWei, maxValueWei. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/entity-transactions

Input parameters:

- `address` (string, required): The address, `0x`-prefixed, 40 hex characters, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `counterparty` (string): Only rows whose other side is this address (`0x` + 40 hex). A filter like the others: on a very active address it is answered only inside a block window, and the refusal names the window it needs (`f…
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `direction` (string): `sent` or `received`. Absent: both, with a transaction the address sent to itself shown once.
- `fromBlock` (integer): Inclusive lower block bound.
- `fromTimestamp` (integer): Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `maxValueWei` (string): Inclusive upper bound on `valueWei`: wei, decimal digits, at most 38 digits.
- `methodName` (string): Only transactions calling the function of this name, exact match (an identifier of at most 128 characters: letters, digits, `_`, `$`), as served in `methodName`. A name, not a 4-byte selector; a tran…
- `minValueWei` (string): Inclusive lower bound on `valueWei`: wei, decimal digits, at most 38 digits.
- `order` (string): `desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
- `status` (string): `1` success, `0` failure.
- `toBlock` (integer): Inclusive upper block bound.
- `toTimestamp` (integer): Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.

### `get_entity_validators` (~440 tokens)

Validators paying out to an address

The validators that direct their withdrawals to an address, as of the validator snapshot taken about once a day (`snapshotEpoch`): counts over ALL of them whatever `limit` (`validatorCount`, active, withdrawn, slashed, by credential type, and the total effective balance in gwei) and the validators themselves, lowest index first, each with status, slashed, credential type, effective balance and public key. The address is where the payouts GO, not the owner or operator of the validators. An address no validator pays out to answers zeros, a fact as of the snapshot. `truncated` says more validators exist than listed; the list does not continue past the maximum `limit`. Use it to see how much stake pays out to an address. Not for one validator (get_consensus_validator) or the payouts themselves (get_validator_withdrawals).

Arguments: address; optional limit (default 25, at most 500). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/entity-validators

Input parameters:

- `address` (string, required): The address, `0x` + 40 hex, any case.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 500, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_gas_daily` (~384 tokens)

Gas prices and transaction types per day

Per UTC day over a window of dates, oldest first: the effective gas price transactions paid (average, median, 10th and 90th percentile, wei), the priority fee (average and median, wei) and how many transactions there were of each type — legacy, access list (EIP-2930), EIP-1559, blob (EIP-4844) and set-code (EIP-7702). `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart gas prices or the adoption of transaction types. Not for the base fee, block counts and burnt fees (get_network_daily) or blob counts (get_blobs_daily).

Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-gas

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (string): The first UTC date, `YYYY-MM-DD`.
- `to` (string): The last UTC date, `YYYY-MM-DD`. Default: today.

### `get_largest_liquidity_removals` (~463 tokens)

The largest liquidity removals from DEX pools

The largest removals of liquidity from DEX pools over a window of blocks ending at `meta.asOfBlock` (`window`: `24h`, `7d` by default, or `30d`; the blocks are echoed as `fromBlock` / `toBlock`), largest USD first — each with the pool, its protocol, the provider the event names, the transaction and block, the event as the pool names it, and how many of its token legs could be priced. Only events with at least one priced leg rank, and `usdRemoved` covers the priced legs only. Uniswap v4 pools are not covered. The top of the ranking only: the maximum `limit` is the deepest it goes. Use it to spot the largest exits of liquidity across all pools. Not for one pool's events over time: use get_pool_liquidity_events. Not for every token leg of one removal: use get_transaction_liquidity_events. Not for one pool's flow day by day: use get_pool_liquidity_flow.

Arguments: none required; optional window, limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pools-liquidity-removals

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `window` (string): `24h`, `7d` (default) or `30d`.

### `get_latest_block` (~216 tokens)

The latest block

The newest block TraceFast serves, with its header and the totals of what it contains — transaction counts by outcome, gas, fees, value moved, withdrawals. Use it to learn the current height before asking about recent data. Not for a given height: use get_block. Not for the block at a given time: use get_block_at_time.

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the newest block TraceFast serves; `meta.asOfBlock` is its height. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/block-latest

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_lending_market_config` (~392 tokens)

The risk configuration of a lending protocol's markets

The risk configuration of every asset of a lending protocol's markets, or of one with `asset`, as the protocol's last configuration events set it — loan-to-value, liquidation threshold, reserve factor and liquidation protocol fee in basis points, the liquidation bonus in basis points over the debt repaid (500 = 5 %), supply and borrow caps in whole tokens (absent means no cap), whether the asset is active, frozen or paused, its price oracle, its receipt and debt token contracts and rate strategy, and the block of its last configuration change. `protocol` must be a covered one (`aave_v3` today; another is refused, `protocol_invalid`, with the covered list), and `coveredMarkets` names the markets read. A value is absent when the asset's initialization lies outside the history TraceFast reads. Use it to read a lending market's parameters. Not for one token's amounts and rates: use get_token_lending_markets.

Arguments: protocol; optional asset. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/lending-config

Input parameters:

- `asset` (string): Only this asset (`0x` + 40 hex).
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `protocol` (string, required): A covered protocol, for example `aave_v3`; another value is refused (`protocol_invalid`) with the covered list.

### `get_network_daily` (~427 tokens)

The network per day: blocks, transactions, gas, base fee, burnt fees

Per UTC day over a window of dates, oldest first, the network's totals: blocks (count, first and last), transactions (all, successful, failed, contract creations) and the ETH they moved, gas used and the average block's utilization, the average block time, withdrawals, the base fee (average, median, 10th and 90th percentile, wei), the fees burnt and the blob gas used. Before the Byzantium fork (2017-10-16) receipts carry no status, so the successful and failed counts read 0 there and are not counts. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart the chain's activity and fees over time. Not for one block (get_block) or the gas prices paid and transaction types (get_gas_daily). Not for the new accounts and contracts of each day: use get_new_accounts_daily.

Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-daily

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (string): The first UTC date, `YYYY-MM-DD`.
- `to` (string): The last UTC date, `YYYY-MM-DD`. Default: today.

### `get_new_accounts_daily` (~323 tokens)

New accounts and contracts per day

Per UTC day over a window of dates, oldest first: how many externally owned accounts (`newEoas`) and how many contracts (`newContracts`) appeared on the chain for the first time. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart how fast the chain gains accounts and contracts. Not for when one address first appeared: use get_entity_activity.

Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-new-accounts

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (string): The first UTC date, `YYYY-MM-DD`.
- `to` (string): The last UTC date, `YYYY-MM-DD`. Default: today.

### `get_new_pools` (~456 tokens)

The newest DEX pools, by their first swap

DEX pools in the order of their first swap, newest first — the pool (its address, or `poolId` for a Uniswap v4 pool), its protocol and version, and its first swap's block, time, transaction, tokens and amounts in token units. A pool appears once it has swapped: one created but never traded is not listed. The list is updated hourly and complete through `meta.asOfBlock`; a few protocols lag the others by some hours. No USD value is stated: a new pool's price is the least reliable one. Use it to find pools that just started trading. Not for every pool of one token, by creation: use get_token_pools. For one pool in full, use get_pool. Not for a new pool's later swaps: use get_pool_swaps.

Arguments: none required; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/pools-new

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_pool` (~451 tokens)

A DEX pool

One DEX pool by its address or, for a pool without one, its 32-byte id (a Uniswap v4 PoolId) — its protocol and version, its tokens with the symbol, name and decimals each token contract declares (verbatim, not verified), the fee tier and tick spacing where recorded, the factory, hook, vault, gauge and LP token where it has them, its creation block and transaction, and its USD volume and swaps over UTC days (`volumeUsd2d` / `swaps2d`: yesterday and today; `volumeUsd8d` / `swaps8d`: today and the 7 days before). A volume over days not all priced is a partial sum, with the unpriced days counted beside it. A pool that trades but is not registered with TraceFast answers what its swaps show (`registered: false`); an unknown one is refused (`not_found`). No names or verdicts. Use it to identify a pool. Not for its trades (get_pool_swaps) or what it holds now (get_pool_reserves). Not for its volume day by day: use get_pool_volume. Not for the liquidity added and removed day by day: use get_pool_liquidity_flow.

Arguments: pool. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or a Uniswap v4 PoolId (`0x` + 64 hex); any case.

### `get_pool_liquidity_events` (~642 tokens)

Who added and removed liquidity in a DEX pool

The liquidity events of one DEX pool inside a block window, newest first — the block, time and transaction, the provider the event names, `action` (`add` or `remove`) and the event as the pool names it, and the USD added or removed over the token legs that could be priced (`pricedLegs` / `unpricedLegs`; absent when none could). The window is `fromBlock` to `toBlock`, at most 216 000 blocks (about 30 days), by default the 7 days up to `meta.asOfBlock`; a wider one is refused with the bound, never narrowed, and a `toBlock` past `meta.asOfBlock` is refused (`block_not_available`). Uniswap v4 pools are not covered and are refused (`pool_not_covered`) rather than answered empty. Use it to see who added or removed liquidity in a pool. Not for daily totals: use get_pool_liquidity_flow. Not for every token leg of one transaction's events: use get_transaction_liquidity_events. Not for the largest removals across all pools: use get_largest_liquidity_removals.

Arguments: pool; optional fromBlock, toBlock, limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pool-liquidity-events

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `fromBlock` (integer): The window's first block. Default: 7 days of blocks below `toBlock`.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.
- `toBlock` (integer): The window's last block. Default: the last block the liquidity events have reached (`meta.asOfBlock`).

### `get_pool_liquidity_flow` (~403 tokens)

Liquidity added to and removed from a DEX pool per day

Per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first: the USD value of the liquidity added to and removed from a DEX pool and the net flow, the add and remove events and the distinct providers behind them, and how many of the events' token legs could be priced (`pricedLegs` of `totalLegs`: below it the USD figures cover the priced legs only). A day without liquidity events has no entry. Uniswap v4 pools are not covered and are refused (`pool_not_covered`) rather than answered empty. Use it to see whether liquidity is entering or leaving a pool over time. Not for the individual events: use get_pool_liquidity_events. Not for what the pool holds now: use get_pool_reserves.

Arguments: pool; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-liquidity-flow

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `days` (integer): 1 to 365, default 30.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

### `get_pool_reserves` (~386 tokens)

What a DEX pool holds now

What a DEX pool holds now, token by token — the raw reserve, the amount in token units where the decimals are known, and its USD value where the token has a price TraceFast trusts at that size — and `totalTvlUsd`, the USD total over the legs that could be valued (absent when none could). The total is an estimate, not an accounting value, and says how far it can be relied on: `isTvlTrusted`, `reserveStatus`, `accuracyBand` and `accuracyDeltaBps` (the gap to a direct read of the pool), with the snapshot's block and age (`snapshotBlock`, `snapshotLagSeconds`). A pool whose reserves TraceFast does not track is refused (`not_found`). Use it to see how deep a pool is. Not for its trading over time: use get_pool_volume. Not for the liquidity added and removed over time: use get_pool_liquidity_flow.

Arguments: pool. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the latest snapshot, which names its own block and age; the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-reserves

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or a Uniswap v4 PoolId (`0x` + 64 hex); any case.

### `get_pool_swaps` (~535 tokens)

A DEX pool's swaps, newest first

Every swap of one DEX pool, newest first — the block, time and transaction, the sender and recipient as the pool's event states them (the sender is often a router), the token sold in and the token bought out with raw amounts, decimals and the symbols the tokens declare (verbatim, not verified), and `valueUsd`, an estimate at the hour of the swap: the bought leg at that hour's price, else the sold one (`valuedLeg`); a leg larger than its price can vouch for is left unvalued, never capped. `pool` is the pool's address or its 32-byte id (a Uniswap v4 PoolId or a Balancer v2 poolId). Use it to read a pool's trades. Not for daily totals (get_pool_volume) or one address's trades across pools (get_entity_dex_trades).

Arguments: pool; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pool-swaps

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

### `get_pool_volume` (~406 tokens)

A DEX pool's daily volume

A DEX pool's trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — USD volume, swaps, the volume of each of its two tokens in token units and how many distinct addresses sent swaps — with the totals. A day's USD volume adds the hours that could be priced: a day with swaps but no priced hour has no `volumeUsd` and is counted in `unpricedDays` (then `totalVolumeUsd` is a partial sum); a day priced only in part is not marked. A day without swaps has no entry. A pool not registered with TraceFast is refused (`not_found`). Use it to chart a pool's trading. Not for the swaps themselves: use get_pool_swaps. Not for the liquidity added and removed: use get_pool_liquidity_flow.

Arguments: pool; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-volume

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `days` (integer): 1 to 365, default 30.
- `pool` (string, required): The pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

### `get_pools_for_pair` (~521 tokens)

The DEX pools that hold two given tokens

Every DEX pool that holds both `tokenA` and `tokenB` — in either order, including pools of three or more tokens that hold both — newest created first, each with its protocol and version, fee tier where recorded (absent does not mean no fee), approximate creation block (`creationBlockApprox`), its tokens and its USD volume over the last 7 days (`volumeUsd7d`; absent when none could be priced, not zero). Uniswap v4 pools are included and named by their `poolId`. At most the 200 newest pools (`truncated` says when more exist), paged by bytes: about 224 KiB a page, a whole pool at a time; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`. A pool lists at most 8 of its tokens (`tokenCount` when it holds more). Use it to find where two tokens trade against each other. Not for every pool of one token: use get_token_pools. For one pool in full, use get_pool.

Arguments: tokenA, tokenB; optional cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/pools-by-pair

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `tokenA` (string, required): One token contract, `0x` + 40 hex. Required.
- `tokenB` (string, required): The other token contract, `0x` + 40 hex. Required.

### `get_signal_kinds` (~301 tokens)

The vocabulary of the signals

The vocabulary of TraceFast's detector signals: every kind get_signals serves as a row (`rowKinds`), each with the detector that raises it, whether it is always in the trader view (`alwaysTrader`) and the evidence fields it carries (`a.b` means only the field `b` of the object `a`); the kinds get_signal_rates counts instead of listing (`countedKinds`); and the detectors whose coverage get_signal_rates states. A kind names what a detector looks for — a hypothesis about what happened, never a finding about an address. Use it to learn the values `kind` takes and how to read a signal's `evidence`. Not for the signals themselves: use get_signals.

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the vocabulary TraceFast serves now; it changes only when its detectors do, and states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/signal-kinds

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_signal_rates` (~405 tokens)

Signal counts, detector coverage and the largest delegated outflows of 24 hours

Over the same 7 200 blocks as get_signals (about 24 hours, ending at `meta.asOfBlock`): how many signals were raised of each kind get_signals does not list (`counts`; the `countedKinds` of get_signal_kinds always appear, zero included), flash-loan transactions by class (`flashLoans`), how far each detector has covered the window (`coverage`), and the ten delegated (EIP-7702) account outflows with the largest net ETH out, gas included, with the tokens that left (raw amounts; `decimals` absent when unknown — then print the amount raw): at most 5 tokens an outflow (`tokensTruncated` when more left) and 5 NFT ids a token (`tokenIdCount` when more left). An absent coverage field is unknown, and a count beside unknown or partial coverage is not "nothing happened". Recomputed at most once a minute. A signal is a detector's hypothesis, not a fact about an address. Use it for the window's counts and to check a detector's coverage before reading an empty get_signals page as quiet. Not for the signals themselves: use get_signals. Not for the flash loans of one transaction: use get_transaction_flash_loans.

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/signal-rates

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_signals` (~648 tokens)

Detector signals of the last 24 hours

The signals TraceFast's detectors raised over the last 7 200 blocks (about 24 hours, ending at `meta.asOfBlock`), newest block first. A signal is a detector's fast hypothesis about what it saw on chain, never a fact about an address: read its `evidence`. Each row names its `kind`, `detector` and `subject` (the contract or account it is about), its block, its transaction where it is about one, its position where stated (`logIndexInTx`, `callPath`, `slot`), whether the detector read every input (`complete`) and the evidence fields of its kind; `horizonTruncated` says the window's oldest signals are missing. `kind` (comma-separated), `address` (the subject or any address in the evidence) and `trader` (the trader view) select the set before the page. A detector that has not covered a block cannot raise a signal in it: check get_signal_rates before reading an empty page as quiet. Use it to see what the detectors raised recently. Not for the kinds and their evidence fields: use get_signal_kinds. Not for issuers listing or freezing addresses: use get_blacklist_feed.

Arguments: none required; optional kind, address, trader, limit (default 25, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/signals

Input parameters:

- `address` (string): Only signals naming this address (`0x` + 40 hex) as their subject or anywhere in their evidence.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `kind` (string): Row kinds, comma-separated (for example `lp_drained,lookalike_paid`); each must be a row kind of getSignalKinds, or the request is refused (`kind_invalid`) with the list.
- `limit` (integer): How many rows to return: 1 to 100, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `trader` (boolean): `true`: only the trader view; `false`: only the others; absent: both.

### `get_token` (~349 tokens)

One token contract

One token contract: its standard as observed from its events (erc20, erc721, erc1155), the symbol, name and decimals it declares (verbatim, not verified), its all-time transfer count, how many addresses hold it now (`holderCount`, the same number get_token_holders states; absent where holders are not covered, such as NFT collections) and how many ever held it (`holderCountAllTime`). A contract with no transfer events is refused (`not_found`). No price here. Use it to identify a token contract and read its decimals. Not for its holders (use get_token_holders) or the contract as an address (get_entity_overview). Not for its transfers: use get_token_transfers. For its USD price, use get_token_price. Not for the DEX pools that hold it: use get_token_pools.

Arguments: token. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: current all-time counters, refreshed periodically; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `token` (string, required): The token contract address, `0x`-prefixed, 40 hex characters, any case.

### `get_token_dex_volume` (~415 tokens)

A token's daily DEX volume

A token's DEX trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — the USD volume and the swaps by the token's position in the pair (`swapsAsToken0` / `swapsAsToken1`: the pair position, not a buy or sell direction) — with the totals. A day's USD volume adds the hours that could be priced: a day with swaps but no priced hour has no `volumeUsd` and is counted in `unpricedDays` (then `totalVolumeUsd` is a partial sum); a day priced only in part is not marked. A day without swaps has no entry. Only the pools TraceFast decodes are counted, which may lag a newly created pool. Use it to chart how much a token trades. Not for where it trades: use get_token_pools. Not for the whole chain's DEX volume: use get_dex_volume_daily. Not for the tokens that trade most: use get_top_dex_tokens.

Arguments: token; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-dex-volume

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `days` (integer): 1 to 365, default 30.
- `token` (string, required): The token contract, `0x` + 40 hex, any case.

### `get_token_holders` (~524 tokens)

Top holders of a token

The largest current holders of a token, in descending balance order, with the balance in the token's smallest unit, plus `holderCount` — how many addresses hold a positive balance now — the same balances get_entity_token_balance answers, and `asOfBlock`, the block the ranking is valid at (absent when the ranking was being recomputed while it was read). Current ranking only. Pass `nextCursor` back as `cursor` to go past the first page: the ranking holds `rankingDepth` holders (up to 1 000) and `rankingTruncated` says whether more rank below; a cursor from before the ranking was recomputed (about hourly, at the earliest after 5 minutes) is refused (`invalid_cursor`: start again). A token whose holders are not covered (every NFT collection today) is refused (`token_not_covered`) rather than answered with zero holders. Use it to find who holds a token. Not for one holder's exact balance: use get_entity_token_balance.

Arguments: token; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-holders

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `token` (string, required): The token contract address, `0x`-prefixed, 40 hex characters, any case.

### `get_token_lending_markets` (~410 tokens)

The lending markets of a token

The lending markets where a token is listed, one per market — its roles there (`supply`, `borrow`, `collateral`), the amounts supplied and borrowed (raw units, and USD at the protocol's own oracle price), the supply and borrow rates as yearly fractions, loan-to-value and liquidation threshold in basis points, the liquidation bonus in basis points over the debt repaid (500 = 5 %), the caps (absent means no cap) and how much of each is used — above 100 % when a cap was lowered below what is already supplied — and whether the market is active, frozen or paused. `coveredMarkets` names the markets TraceFast reads (Aave V3's main Ethereum market today): an empty `markets` means not listed on those, never not lendable anywhere. The amounts use the market's interest index of its last rate update, so on a quiet market the interest accrued since is not in them. Use it to see where, and on what terms, a token can be supplied or borrowed. Not for a protocol's whole configuration: use get_lending_market_config. Not for the token's market price over time: use get_token_price_history.

Arguments: token. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-lending-markets

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `token` (string, required): The token contract, `0x` + 40 hex.

### `get_token_pools` (~550 tokens)

The DEX pools holding a token

The DEX pools that hold a token, newest created first — each with its protocol and version, fee tier where recorded (absent does not mean no fee), approximate creation block, its tokens (address, declared symbol and decimals, role, weight where the pool declares one) and its USD volume over the last 7 days (`volumeUsd7d`; absent when none could be priced, not zero). A Uniswap v4 pool has no address and is named by its `poolId`. At most the 10 000 most recently created pools of a token are ranked; `rankedPools` says how many. A page of pools whose tokens declare long texts can hold fewer than `limit` (pages are bounded in bytes); `nextCursor` then continues it. A pool lists at most 8 of its tokens (`tokenCount` when it holds more). Use it to find where a token trades. Not for the pools of two given tokens: use get_pools_for_pair. Not for the pools that just started trading: use get_new_pools.

Arguments: token; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/token-pools

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `token` (string, required): The token contract, `0x` + 40 hex, any case.

### `get_token_price` (~454 tokens)

A token's USD price, now or as of a past time or block

The USD price of a token for one hour — the newest priced hour by default, or the newest at or before `timestamp` (Unix seconds) or the time of `block` (one or the other): `priceUsd`, the hour it is for (`hour`), what it is (`priceSource`: an oracle reading, a DEX observation, a peg, or one carried over from an earlier hour, with `observedHour` and `ageHours`), and `maxTrustedValueUsd`, the largest USD value it may vouch for (absent means no bound): an amount worth more at this price is not valued by it. The DEX and oracle sides it was chosen from are separate blocks (`dex`, `oracle`), with how far they disagree (`divergencePct`: a number, not a verdict). TraceFast prices a selected set of tokens; any other is refused (`not_found`). Use it to value a token amount. Not for prices over time (get_token_price_history) or an address's holdings in USD (get_entity_portfolio).

Arguments: token; optional timestamp, block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: hourly USD prices; the newest hour is usually the current or the previous one, and each price names its hour. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-price

Input parameters:

- `block` (integer): A block: the price as of the hour holding its time. Not with `timestamp`.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `timestamp` (integer): Unix time, seconds: the price as of the hour holding it. Not with `block`.
- `token` (string, required): The token contract, `0x` + 40 hex, any case.

### `get_token_price_history` (~426 tokens)

A token's hourly USD prices over a window

A token's USD price for every priced hour of a window (`from` to `to`, Unix seconds; the last 7 days by default, at most 90 days), oldest first — each with `priceUsd`, what it is (`priceSource`), whether it was carried over from an earlier hour (`carried`), `maxTrustedValueUsd` (absent means no bound) and the hour's DEX and oracle prices where they exist. An hour without a price has no entry, not a zero. A window over 90 days is refused with the bound, never narrowed. TraceFast prices a selected set of tokens: any other answers an empty list here, while get_token_price refuses it. Use it to chart a token's price. Not for one hour's price with its sources in detail: use get_token_price. Not for how much it trades: use get_token_dex_volume.

Arguments: token; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: hourly USD prices; the newest hour is usually the current or the previous one, and each price names its hour. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/token-price-history

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `from` (integer): Unix time, seconds: the window's start (its hour included). Default: 7 days before `to`.
- `to` (integer): Unix time, seconds: the window's end (its hour included). Default: now.
- `token` (string, required): The token contract, `0x` + 40 hex, any case.

### `get_token_stats` (~226 tokens)

Token statistics of the network

How many token contracts, transfer events and holder positions (one address holding one token; not distinct addresses) the chain counts, in total and per standard (ERC-20, ERC-721, ERC-1155, ERC-777, ERC-4626). Use it for the size of the chain's token landscape. Not for one token: use get_token.

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: network-wide all-time counters, recomputed daily; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-stats

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_token_transfers` (~766 tokens)

Transfers of a token

The transfer events of one token contract, newest first — the parties, the raw amount (not scaled by decimals) or token id, the event kind, and the transaction that emitted it with who sent that transaction, which on a router or a batch disburser is another party entirely. ERC-20, ERC-721 and ERC-1155 transfers, and the token's other value events: `eventType` is one of `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap` or `unwrap`. `deposit` and `withdraw` are vault (ERC-4626) events; wrapping and unwrapping ether (WETH) are `wrap` (no sender) and `unwrap` (no recipient). `from`, `to`, `eventType` and `fromBlock` / `toBlock` narrow the list; on a very active token `from`, `to` or `eventType` is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to follow a token's movements. Not for one address's transfers across tokens (get_entity_token_transfers) or who holds it now (get_token_holders).

Arguments: token; optional limit (default 10, at most 100), cursor, from, to, eventType, fromBlock, toBlock. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/token-transfers

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `eventType` (string): One event kind: `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap`, `unwrap`. `deposit` and `withdraw` are vault (ERC-4626) events; wrapping an…
- `from` (string): Only transfers sent by this address, `0x`-prefixed.
- `fromBlock` (integer): Inclusive lower block bound.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `to` (string): Only transfers received by this address, `0x`-prefixed.
- `toBlock` (integer): Inclusive upper block bound.
- `token` (string, required): The token contract address, `0x`-prefixed, 40 hex characters, any case.

### `get_top_dex_tokens` (~498 tokens)

The tokens traded most on DEXes

The tokens with the most USD volume on the DEXes TraceFast decodes over the last `days` UTC days (1 to 30, default 7; today included and still being counted), most volume first — each with the symbol its contract declares (verbatim, not verified: identify a token by its address), its USD volume, its swaps by its position in the pair (`swapsAsToken0`, `swapsAsToken1`: the pair position, not a buy or sell side) and the most pools it traded in on one day. A volume adds only what could be priced: `unpricedDays` counts the days with no price at all (the volume is then partial), and a day priced in part counts as priced, so the ranking may order partial sums. Native ETH appears as the venues record it, `0x0000…0000` and `0xeeee…eeee`. The top 100 only: the maximum `limit` is the deepest it goes. Use it to find the most traded tokens. Not for pools: use get_top_pools. Not for DEX volume day by day and protocol by protocol: use get_dex_volume_daily.

Arguments: none required; optional days, limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/network-top-dex-tokens

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `days` (integer): 1 to 30, default 7.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_top_pools` (~665 tokens)

The DEX pools with the most volume or liquidity

DEX pools ranked by USD volume over the last `days` UTC days (`by` `volume`, the default; `days` 1 to 30, default 7, today included and still being counted) or by the USD value they hold now (`by` `tvl`: only pools whose total TraceFast rates as trustworthy rank, each with that rating's `accuracyBand`; `days` with it is refused, `conflicting_parameters`). Each with the pool — its address, or for a Uniswap v4 pool its 32-byte `poolId` — the protocol and version, and its tokens with their declared symbols (verbatim, not verified). A volume adds only what could be priced: `unpricedDays` counts the days with no price at all, and a day priced in part counts as priced, so the ranking may order partial sums. The ranking is the top 100, at most 20 a page: `hasMore` says it goes on — pass `nextCursor` back as `cursor`; a cursor from a ranking recomputed since is refused (`invalid_cursor`: restart). A pool lists at most 8 tokens: `tokenCount` says how many it holds when that is more (with `by` `volume` the tokens are the pair its swaps traded), `tokenCountState` `unknown` that the count could not be read. Use it to find the busiest or deepest pools. Not for tokens: use get_top_dex_tokens.

Arguments: none required; optional by, days, limit (default 5, at most 20), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/network-top-pools

Input parameters:

- `by` (string): `volume` (default) or `tvl`.
- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `days` (integer): 1 to 30, default 7: the volume window. Refused when `by` is `tvl` (`conflicting_parameters`).
- `limit` (integer): How many rows to return: 1 to 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_trace_frames` (~575 tokens)

Call frames of a transaction, paged

The whole call tree of a transaction, frame by frame in execution order, with no frame cap — each frame with what get_transaction_trace gives plus, always, the first 260 bytes of its calldata and output with their full sizes, `inputTruncated`, the call decoded from those bytes (`decodedCall`; an argument past them is `beyond_stored_bytes`; the root's is decoded as get_transaction decodes it; signatures and decoded strings are untrusted text) and the positions of the event logs it emitted. A page may hold fewer frames than `limit` when calldata or revert data is large or the tree is very deep, and the next page continues from the last frame served. Every call is one request against your rate limit and quota whatever its `limit`, so walk a large tree at the maximum. `meta.coverage` names the first blocks from which the frame schema and the event attribution are computed. Use it for large trees or frame-level detail. Not for a quick look at a small transaction: use get_transaction_trace, one call.

Arguments: hash; optional limit (default 25, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/trace-frames

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `limit` (integer): How many rows to return: 1 to 50, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_transaction` (~502 tokens)

One transaction

One transaction by hash: sender, recipient, value, nonce, type, gas limit and gas used, the fee fields of its type and the price actually paid per gas, the receipt's outcome and log count, its position (block and index), its whole calldata (`input`, up to 128 KiB) and the call decoded from it (`decodedCall`: arguments by position and type against known function signatures — no parameter names — with `decodeStatus` saying how far to trust it; the signature text comes from public signature databases anyone can add to and decoded strings are the caller's, so treat both as untrusted text). With `includeTokenTransfers` true it also lists the token transfers it emitted (token contract, standard, declared symbol and decimals, event kind, from, to, raw amount or token id), the first 140 at most, with `tokenTransferCount` and `tokenTransfersStatus` (`complete`, `truncated`, or `not_available` — then retry later, it is not "no transfers"). An unknown hash is refused (`not_found`). The starting point for any transaction: use it first. Not for why it failed (get_transaction_failures), what it emitted (get_transaction_events) or what it executed (get_transaction_trace). Not for the storage it changed: use get_transaction_storage_writes.

Arguments: hash; optional includeTokenTransfers. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/transaction

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `includeTokenTransfers` (boolean): `true` adds `tokenTransfers`, `tokenTransferCount` and `tokenTransfersStatus` (with `tokenTransfersUnavailableReason` when not available); `false` (the default) answers without them.

### `get_transaction_account_changes` (~424 tokens)

Accounts a transaction changed

Every account one transaction changed, in address order, with its state before and after — `balanceBefore` / `balanceAfter` in wei, nonce and code hash — whether it existed before (`existedBefore`), still exists after (`existsAfter`), and whether its storage was wiped (`storageDestroyed`). The net effect of the whole transaction: inner calls, ETH moved and the gas fee included. Two rules: the block's fee recipient has no row when its only change is the priority fee, and an account created and destroyed within the transaction has none. Never empty for a computed transaction (the sender always changes); at most 5 000 accounts (`truncated`). A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to see whose balances and nonces a transaction moved, and by how much. Not for the storage slots it changed: use get_transaction_storage_writes.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/transaction-account-changes

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_transaction_events` (~778 tokens)

Event logs of a transaction

The event logs a transaction emitted, in emission order, each with the emitting contract, topics and data and, when the signature is known, the decoded event name and arguments with a stated confidence; an unknown signature is returned raw with `decodeStatus` `abi_missing`, and a known one whose layout does not fit the log with `failed` — raw as well, no `decoded`; when more than one known signature fits, the readings are listed (`decoded.candidates`, at most 8; `candidateCount` is the true count). One event's readings are bounded in size: a value too large to include is `valueState` `withheld_for_size`, without `value`, and a decoding stopped by its work budget before every known signature was tried says `decodeSearch` `incomplete` — `ambiguous` with a reading, no `decodeStatus` without one, never `failed`. A log whose data is longer than 49 151 bytes comes without `data`: `dataState` `withheld_for_size` and `dataLength` (bytes) instead, topics and decoding still given. Each event names the call frame that emitted it (`callPath`, `callDepth`), the path the trace uses, where that is known. A page holds at most `limit` logs and may hold fewer when their data is large — a log is never cut. An unknown hash is refused (`not_found`). Use it to read what a transaction emitted — transfers, swaps, approvals. Not for the call tree: use get_transaction_trace. Not for the flash loans taken inside it, already identified: use get_transaction_flash_loans. Not for the DEX liquidity it added or removed, valued per token: use get_transaction_liquidity_events.

Arguments: hash; optional limit (default 10, at most 50), cursor, eventName, topic0. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is t…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `eventName` (string): Only events whose name, as TraceFast's event index records it, is this value, e.g. `Transfer`: 1 to 100 letters, digits or underscores. Case-sensitive. An event the index holds no name for is not mat…
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `limit` (integer): How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `topic0` (string): Only events whose first topic (the event signature hash) is this value: `0x` + 64 hex characters.

### `get_transaction_execution_profile` (~380 tokens)

How heavy a transaction was inside the EVM

How heavy one transaction was inside the EVM: opcode counts over every frame, reverted frames included — `sloadTotal`, `sstoreTotal`, `tloadTotal`, `tstoreTotal`, `keccakTotal`, precompile calls, CREATE and SELFDESTRUCT counts — whether a DELEGATECALL ran (`delegatecallExecuted`), the distinct contracts whose storage it touched, and the gas spent in frames that reverted. Executions, not committed effects: `sstoreTotal` is not the number of storage writes that took effect. A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to gauge a transaction's EVM workload. Not for the storage it actually changed: use get_transaction_storage_writes.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/transaction-execution-profile

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_transaction_failures` (~384 tokens)

Why a transaction reverted

Why a transaction reverted: its failed call frames — position in the call tree, caller and target, the kind of failure (revert, panic, custom error, out of gas and others), the revert payload with its selector, and the error name when the selector is known. Root frame first, then nested frames in tree order, at most 100 and about 320 KiB of frames (`framesTruncated` says when there are more). An empty list is not a statement of success: a successful transaction and an unknown one both answer empty — read the outcome with get_transaction. Use it when only the failure matters: cheaper than a trace. Not for the whole call tree: use get_transaction_trace.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the failure classification is built in batches and trails the newest blocks by minutes, at times by an hour or more; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block; an unknown hash answers empty and states no block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/transaction-failures

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_transaction_flash_loans` (~416 tokens)

Flash loans taken inside a transaction

The flash loans taken inside one transaction from the lenders TraceFast indexes — Aave V2 and V3 (its official markets), Balancer V2 and Uniswap V3 pool flashes — in log order: `protocol` and `protocolVersion`, the lending contract (`poolAddress`), the borrower and initiator where the event states them, the token and the raw amount (`amountRaw`, not scaled: get_token gives the decimals). Some Aave V2 forks are listed under their own names (`radiant`, `aave_fork`): they are not Aave. An empty list means none from these lenders — a Uniswap V2 flash swap or a Maker, Morpho, Euler or Balancer V3 flash loan is not covered. An unknown hash is refused (`not_found`). Use it to find borrowed capital inside a transaction, as in an exploit or an arbitrage. Not for the transfers that moved the funds: use get_transaction_events.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined transaction from an index written in batches that trail the newest blocks. For a transaction above the indexed range, what is found is returned and may still be incomplete for a short while, and an empty answer is refused (`block_not_available`, with `details.maxAvailableBlock`) — retry later. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/transaction-flash-loans

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_transaction_liquidity_events` (~599 tokens)

The DEX liquidity added and removed in a transaction

Every DEX liquidity event in one transaction, in log order — the pool, its protocol and version, the provider the event names, `action` (`add` or `remove`) and the event as the pool names it, and each token leg: the token with its declared symbol and decimals (verbatim, not verified), the amount raw and in token units, whether it went into or out of the pool, and its USD value and price where it could be priced, with how it was valued. An empty list means no liquidity event happened in the transaction. The events are written behind the chain: a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the transaction; an unknown hash is refused (`not_found`). Uniswap v4 liquidity events are not recorded. Paged by bytes: about 112 KiB a page, a whole event at a time; `hasMore` says more follow — pass `nextCursor` back as `cursor`. An event lists at most 8 legs (`legCount` when it has more). Use it to see what liquidity a transaction added or removed. Not for every event it emitted: use get_transaction_events. Not for one pool's events over a window: use get_pool_liquidity_events. Not for the flash loans it took: use get_transaction_flash_loans.

Arguments: hash; optional cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined transaction from an index written in batches that trail the newest blocks. For a transaction above the indexed range, what is found is returned and may still be incomplete for a short while, and an empty answer is refused (`block_not_available`, with `details.maxAvailableBlock`) — retry later. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast r…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `hash` (string, required): The transaction hash, `0x` + 64 hex, any case.

### `get_transaction_state_dependencies` (~424 tokens)

Transactions of the same block it depends on

How one transaction depends, through storage, on the other transactions of its block: each read-after-write edge — a slot it read whose last write before it in the block was an earlier transaction's (`role` `reader`), or a slot it wrote that a later transaction then read (`role` `writer`) — with the slot (`storageAddress`, `storageKey`) and both transactions' positions and hashes, and the same edges folded per pair of transactions (`pairs`, with slot and contract counts). Facts of execution order only, never a statement about intent. An empty answer for a computed transaction means no dependency; `truncated` says the edges were cut, and `pairsComplete` false that the pairs were folded from the cut list. A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to see which transactions of a block another one's outcome relied on. Not for the slots it wrote: use get_transaction_storage_writes.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/transaction-state-dependencies

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_transaction_storage_slots` (~611 tokens)

What the storage slots a transaction wrote are

What each storage slot a transaction wrote IS: the distinct slots (contract and slot key) in the order of each slot's first write, how many times it was written, and how its key was computed — an entry of a mapping or a dynamic array (`derived`, with the mapping keys and the declared variable's slot where they were traced), a plain variable's fixed slot (`fixed_slot`, with its number), or not known (`unknown`, which is not a statement that the slot is a plain variable; `not_computed`, ask again later; `before_coverage`). `meaning` is absent on a slot no answer could be had for. On every page, `slotsTruncated` is true when the transaction made more than the 5 000 writes read; the counts are then within those writes. An unknown hash is refused (`not_found`). A heavy call: each page traces up to `limit` slots, so ask only for the slots you need. Use it to tell which balances, allowances or variables a transaction changed. Not for the values written and before: use get_transaction_storage_writes.

Arguments: hash; optional limit (default 5, at most 20), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: storage writes are computed after inclusion and trail the newest blocks; a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the transaction — and one below the first block they are computed from is refused with `details.minAvailableBlock`. `meta.asOfBlock` is the transaction's block; `meta.coverage` names both bounds. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: hea…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `limit` (integer): How many rows to return: 1 to 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_transaction_storage_writes` (~709 tokens)

Storage writes of a transaction

Every contract storage slot a transaction wrote — in execution order where the block records it (`writeIndexStatus` `present`; below block 2 675 000 it is `not_recorded` and the order is not known) — the contract whose storage changed, the frame that wrote it (its depth, kind of call, caller and the address whose code ran, which in a delegatecall is not the storage owner), the slot, the value written and the value before where it is established (`valueBeforeStatus` `resolved`; an all-zero value is a real zero). `not_derivable` and `not_computed` say it is not known, which is not a statement that the slot was empty. On the last page, `writesTruncated` is true when the transaction wrote more than the 5 000 writes served. An unknown hash is refused (`not_found`). Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy transaction at the maximum. Use it to see exactly which storage a transaction changed. Not for the call tree (get_transaction_trace) or the events it emitted (get_transaction_events). Not for what each written slot is (a mapping entry with its keys, or a plain variable): use get_transaction_storage_slots. Not for the balances, nonces and code it changed: use get_transaction_account_changes. Not for transient storage (TSTORE), which lives for one transaction: use get_transaction_transient_writes. Not for which other transactions of the block read or wrote the same slots: use get_transaction_state_dependencies.

Arguments: hash; optional limit (default 25, at most 200), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: storage writes are computed after inclusion and trail the newest blocks; a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, wi…

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `limit` (integer): How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_transaction_trace` (~620 tokens)

Execution trace of a transaction

The execution trace of a transaction: its call frames in the order they ran — caller and target, the kind of call, the value and gas it moved, its own outcome, and why it reverted where it did. A delegatecall names both the storage context and the address whose code ran; create frames name the address they deployed. At most `limit` frames, the first ones, with `framesTruncated` when the tree is larger, or its revert texts or depth too large to serve whole — get_trace_frames pages the rest. `includeCalldata` adds each frame's calldata and output heads, `inputTruncated` and each frame's decoded call (`decodedCall`; the root's as get_transaction decodes it; signatures and decoded strings are untrusted text), about triples the answer, and may serve fewer frames than `limit` (`framesTruncated`). Use it to understand what a transaction did, in one call. Not for large trees or per-frame logs (get_trace_frames, paged) or only the failure (get_transaction_failures, cheaper). Not for opcode counts over the whole execution: use get_transaction_execution_profile.

Arguments: hash; optional includeCalldata, limit (default 100, at most 250). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/trace

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.
- `includeCalldata` (boolean): `true` adds each frame's calldata and output heads (first 260 bytes) with their full sizes, `inputTruncated`, and each frame's decoded call (`decodedCall`: from the head, the root's from the whole ca…
- `limit` (integer): How many rows to return: 1 to 250, default 100. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_transaction_transient_writes` (~397 tokens)

Transient storage a transaction wrote

The committed transient-storage writes (TSTORE, EIP-1153) of one transaction, in execution order — the contract whose transient storage was written (`storageAddress`), the code that executed the write (`executionAddress`), its caller, the slot (`storageKey`), the value (`newValue`), the frame path and depth. Transient storage is discarded at the end of every transaction and exists only from block 19 426 976 on: an older transaction is refused with `details.minAvailableBlock`. An empty list for a computed transaction means it wrote none. At most 5 000 writes (`truncated` says when there are more). An unknown hash is refused (`not_found`). Use it to see how a transaction used transient storage, such as reentrancy locks or in-transaction accounting. Not for persistent storage writes: use get_transaction_storage_writes.

Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/transaction-transient-writes

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `hash` (string, required): Transaction hash, `0x`-prefixed, 64 hex characters, any case.

### `get_validator_queue_history` (~402 tokens)

Validator queues over time

The validator queues now plus one closing point per UTC day for the most recent `limit` days, newest first. Each point has the queues by the Electra rules under `queues` — pending deposits (new validators vs top-ups), the exit queue, consolidations, each as a count and gwei, with wait ESTIMATES in epochs; `null` on days before they were sampled — and validator counts by STATUS under `status`, which since Electra are not the queues. The span between the end of the reconstruction and the start of sampling is listed in `gaps`: a break, not a zero. Use it to chart the queues over time. Not for the status averages, the registry weights and recent flow: use get_validator_queues.

Arguments: none required; optional limit (default 14, at most 90). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-queues

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 90, default 14. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

### `get_validator_queues` (~379 tokens)

Validator queues now

The validator queues now, by the Electra rules, under `queues`: pending deposits (the entry queue of new validators, and top-ups), the exit queue (consolidation sources excluded), consolidations, partial withdrawals and validators awaiting withdrawal — each as a count and gwei — plus the active set, the per-epoch churn limits and wait ESTIMATES in epochs and days (queue balance over churn, entry also bounded by 16 deposits an epoch; for the queue as a whole, not a promise to any one validator). Also recent exits and deposits that landed, and validator counts by STATUS under `status` — since Electra a status count is not the queue. Observed facts and arithmetic over them only — no score or verdict; a value not sampled yet is `null`, never zero. Use it for the current state of validator entry and exit. Not for the queues over time: use get_validator_queue_history. Not for whether the chain is finalizing and how many slots were missed: use get_consensus_health.

Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-current

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.

### `get_validator_withdrawals` (~524 tokens)

Withdrawals of a validator

The withdrawals paid out for one validator (`index`, its position in the consensus registry), newest first — the block, the global withdrawal index, the address paid and the amount in gwei — inside a block window of at most 216 000 blocks (about 30 days). Without `fromBlock` and `toBlock` the newest window is answered and echoed in `window`; read older history by asking again with `toBlock` one below `window.fromBlock`. A wider window is refused with the bound, never narrowed. An index the chain does not know yet answers an empty list, as does a validator paid nothing in the window. Use it to trace one validator's payouts. Not for every withdrawal of one block: use get_block_withdrawals. Not for the validator's status and withdrawal address: use get_consensus_validator.

Arguments: index; optional limit (default 10, at most 100), cursor, fromBlock, toBlock. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/validator-withdrawals

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `cursor` (string): `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
- `fromBlock` (integer): Inclusive lower block bound. Default: `toBlock - 215999`.
- `index` (integer, required): The validator's index in the consensus registry.
- `limit` (integer): How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `toBlock` (integer): Inclusive upper block bound. Default: the newest covered block.

### `resolve_entity` (~565 tokens)

Resolve a name, symbol or address

Resolves a reference to Ethereum addresses. Given an address (`0x` + 40 hex), it describes it: the name TraceFast shows for it, how TraceFast presents it (`nameStanding`: verified, normal, qualified, warning or danger; `impersonates` when it is flagged as imitating an asset), what kind of address it is (`type.attributes`) and its token identity. Given a name, an ENS name, a token symbol or a token name, it returns the matching addresses best first — verified addresses, then projects, exchanges and ENS names TraceFast knows by name (flagged ones included: "tornado" finds Tornado Cash), then the rest, with impersonations last and never hidden; inside each group exact, then prefix, then substring matches; `searched` lists the collections the text was looked up in, and `hasMore` says a more specific query would show more (also set when the matches' texts are long: the list is bounded in bytes). Use it first when you have a name and need an address, then pass the address to get_entity_overview. A transaction hash is answered in `transaction`, a whole number as `block` when that block exists. Not for a block hash: use get_block by its number.

Arguments: q; optional limit (default 5, at most 20). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the names and presentation TraceFast shows now — every name returned is current, though a name added within the last hour may not be found yet — and token identities as the contracts declare them. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds.

Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-resolve

Input parameters:

- `chain_id` (integer): Chain id. Only 1 (Ethereum mainnet) is served; the default.
- `limit` (integer): How many rows to return: 1 to 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
- `q` (string, required): What to resolve: an address (`0x` + 40 hex, any case), or a name, ENS name, token symbol or token name — at least 2 and at most 100 characters, matched ignoring ASCII case.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast#diagnostics

## Score history

- 2026-11-21: 74
- 2026-11-20: 73
- 2026-11-19: 73
- 2026-11-18: 73
- 2026-11-17: 72
- 2026-11-16: 39
- 2026-11-15: 39
- 2026-11-14: 39

## Common questions

### What is the TraceFast MCP server?

TraceFast is an MCP server listed in the public MCP registry as xyz.tracefast/mcp. Ethereum data for agents: blocks, transactions, traces, tokens, and facts about addresses. This page covers its hosted endpoint (https://tracefast.xyz/mcp).

### Is the TraceFast MCP server safe to use?

TraceFast scores 74 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the TraceFast MCP server expose?

TraceFast exposes 110 tools: get_blacklist_events, get_blacklist_feed, get_blacklist_issuers, get_blacklist_status, get_blacklisted_addresses, and 105 more. Their descriptions and schemas cost roughly 52,848 tokens of context every time the server is loaded.

### Does the TraceFast MCP server require authentication?

No. We connected to TraceFast without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the TraceFast MCP server still maintained?

TraceFast is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the TraceFast MCP server?

VerifyMCP ran 13 checks on TraceFast, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://tracefast.xyz/mcp
- Website: https://tracefast.xyz/
- Changelog RSS feed: https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast.xml
- Changelog JSON feed: https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast.json
- HTML version of this page: https://verifymcp.io/servers/xyz-tracefast-mcp/tracefast
