Proof of one relation of an address

Open the USDC contract in TraceFast →

The evidence behind one proven relation between two addresses: the facts that were checked, with their expected and observed values; the conditions that had to be false; and the block the evaluation was pinned to, with its hash. The record is the evaluator's own, so you can check the claim instead of trusting it.

GET https://tracefast.xyz/api/v1/chains/1/entities/{address}/relations/{attribute_id}/{object}/proof

Parameter	In	Type	Notes
`address`	path	string	the subject address, `0x`-prefixed, 40 hex characters, any case
`attribute_id`	path	string	the relation id, `relation:name`, as listed by the relations method
`object`	path	string	the object address of the relation, `0x`-prefixed, 40 hex characters, any case

Access — an API key on the Intelligence plan or higher (plans), or no key at all: pay per call with x402 at the same path on https://mpp.tracefast.xyz/api/v1, at the price its 402 states. As a tool for AI agents: get_entity_relation_proof on the MCP server. Stable — see stability.

chains/1 is a literal: other chain ids answer 404 chain_not_supported. The method takes no query parameters; an unknown one is refused.

The three path segments come straight from a row of relations with direction=subject: the address you asked about, the row's attributeId and its counterpart. From a direction=object row, swap them — the counterpart is the subject.

Response

200 application/json, for the USDC proxy and its current implementation (relation:proxy_uses_implementation):

{
  "data": {
    "chainId": 1,
    "subject": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "attributeId": "relation:proxy_uses_implementation",
    "object": "0x43506849d7c04f9138d1a2050bbf3a0c054402dd",
    "result": "pass",
    "definitionVersion": "1.0.0",
    "graphRevision": "rev:e7ea6ccecae0",
    "referenceBlock": 18963716,
    "referenceBlockHash": "0xc483608123b3773b2c32ea3f3ca07ac1d6340a2ea36810fb20db8536b0e9a3a7",
    "snapshotId": "eth-mainnet@18963716",
    "selectedFamilyId": "current_impl_slot",
    "factResults": [
      { "fact_id": "subject_is_proxy", "observed": true, "operator": "exists", "threshold": 1 },
      { "expected": "0x0000000000000000000000000000000000000000", "fact_id": "current_implementation_nonzero", "observed": true, "operator": "neq" }
    ],
    "negativeControlResults": [
      { "control_id": "impl_not_equal_proxy", "evaluation": "must_be_false", "observed": false },
      { "control_id": "impl_not_equal_admin", "evaluation": "must_be_false", "observed": false },
      { "control_id": "not_beacon_kind", "evaluation": "must_be_false", "observed": false },
      { "control_id": "object_not_protocol_special_address", "evaluation": "must_be_false", "observed": false }
    ],
    "dependencyProofRefs": [],
    "bindingVersions": {
      "ev:22b5ea06b80f": "ev:b3b5cd326177",
      "ev:635ced63233b": "ev:837ee9e797c6",
      "ev:6acc44d8c777": "ev:c440e5422048",
      "ev:cf835b186e5e": "ev:cbe9848fb2a3"
    },
    "sourceEvidenceRefs": [
      { "sourceId": "ev:392b2d3bf123" },
      { "sourceId": "ev:5176ccbabe05" },
      { "sourceId": "ev:353c5d7285c9" },
      { "sourceId": "ev:025e9376b1e6" }
    ],
    "evaluatorVersion": "1.0.0",
    "evaluatedAt": 1788725145,
    "failureReasonCodes": [],
    "proofHash": "sha256:d3d70ce9453f978304b83aedd4e15867257ba461e158c5dce398f843351a8388"
  },
  "meta": {
    "chain": "ethereum",
    "timestamp": 1789063643602,
    "cached": false,
    "asOfBlock": 25924975,
    "docs": "https://docs.tracefast.xyz/api/address-relation-proof"
  }
}

The proof reads: the subject is a proxy, its implementation slot is not zero, and four things that would make the relation meaningless were checked and found false — the implementation is not the proxy itself, not its admin, the proxy is not a beacon proxy, and the object is not a protocol-reserved address. The evidence was read from four sources, each named by an opaque ev: id.

`data`

Field	Meaning
`chainId`	`1`, Ethereum mainnet
`subject`	the subject address, lowercase
`attributeId`	the relation, `relation:name`
`object`	the object address, lowercase
`result`	`pass` means the relation is proven
`value`	the relation's value, for relations that carry one; absent otherwise
`referenceBlock`	the block the evidence was read at
`referenceBlockHash`	that block's hash — it pins the evidence to one chain state
`snapshotId`	the chain snapshot the evaluation ran on
`selectedFamilyId`	which of the relation's alternative lines of evidence satisfied it
`factResults[]`	the facts checked, each with its operator, the expected value or threshold and the observed value. JSON as the evaluator produced it — its keys are snake_case
`negativeControlResults[]`	conditions that had to be false for the relation to hold, each with what was observed
`dependencyProofRefs[]`	other proofs this one depends on
`failureReasonCodes[]`	reason codes when `result` is not `pass`; empty on a passing relation
`sourceEvidenceRefs[]`	the evidence sources the evaluation read — see below. Absent, not empty, when the record cannot be read
`bindingVersions`	the version of each data binding the evaluation read, keyed by an evidence-source id; each value is a version or another `ev:` id. Absent, not empty, when the record cannot be read
`definitionVersion`	version of the relation's definition
`graphRevision`	revision of the knowledge graph's rule set — an opaque id, `rev:` and 12 hex digits. One revision has one id in every proof; compare ids for equality only, they have no order
`evaluatorVersion`	version of the evaluator, for example `1.0.0`
`evaluatedAt`	when the evaluation ran, Unix seconds
`proofHash`	digest of the whole record, `sha256:` + hex

An evidence source

Field	Meaning
`sourceId`	an opaque, stable identifier: `ev:` + 12 hex characters. The same source carries the same id in every proof, so sources can be told apart and matched across proofs. It is the only field of an evidence source

Read the contents of factResults and negativeControlResults as the evaluator's record, not a contract: parse them to show or archive a proof, do not branch on them. Evidence-source ids are opaque but stable — compare them, do not decode them. The stable parts are result, referenceBlock, referenceBlockHash, proofHash and the ev: ids.

Not every relation has a proof

Proofs are recorded for relations that hold now. A relation that appears only in the history — a past implementation of a proxy, a delegation that was replaced — answers 404, and so can a current relation whose evaluation was not recorded. A 404 never means the relation is false.

Errors

Status	`code`	When	`details`
400	`bad_request`	`attribute_id` is not a short identifier of letters, digits and `:_.-`	`reason: attribute_id_invalid`
404	`not_found`	no proof is recorded for this relation between these two addresses	—

Malformed input, unknown parameters and the key check's 401/403/429 are the same for every method — see conventions and API keys.

Relations of an address — where the three path segments come from
Relation history of an address — when each relation started and ended
Proof of one attribute — the same record for an attribute
Implementations of a proxy contract — the proxy's implementations, read from the contract side

Last updated 22 Oct 2026, 08:06 UTC · verified against TraceFast v1.0.261 · Markdown