> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blockgence.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Follow a bridge crossing to the destination network

> Reconstructs the other side of a bridge crossing. From the deposit transaction, it detects the protocol, gets
its deterministic identifier (for example, the Circle CCTP `nonce`, the Across `depositId`, the Wormhole VAA or
the Celer cBridge `transferId`), confirms it with the official bridge explorer or with the destination event,
and finds the withdrawal on the destination network. Returns an `origin → bridge → destination` graph, with
some hops already traced on the destination network.

**Request body (JSON).**
- `tx_hash` (required): hash of the deposit transaction.
- `chain`: network of the transaction; default `ethereum`.
- `log_index` (integer ≥ 0, optional): only the deposit whose event is at that position in the receipt. Without
 it, every deposit in the transaction is resolved, up to 12; the rest are declared in `degraded_sources` and
 are requested with `log_index`.

**Response.** Each crossing edge (`kind: "bridge"`) carries `dst_chain`, `protocol`, `dst_tx`, `crossings` and
the link quality: `linkage` (`deterministic` if the same identifier appears on both sides; `probabilistic` if
it is inferred from amount and time) and `confidence` (0 to 1). A transfer refunded at the origin is drawn as a
`kind: "refund"` edge to whoever received the refund. Only a deposit emitted by the registered bridge contract
on that network counts.

**Non-200 responses.**
- `404`: the receipt was read and contains no recognizable crossing, the transaction does not exist or
 `log_index` does not match a deposit; the text states the positions of the deposits.
- `503 source_unavailable`, with no charge: the receipt of the deposit transaction could not be read.

**Coverage.** If the deposit date, the destination verification or the trace on the other side fails, the
response is `200` and declares it in `degraded_sources` and in the `coverage_gaps` of the edge or node. Up to 4
recipients are traced on the destination network; the rest are declared.

**Cost:** 25 credits base. Some operations charge less when they reuse a saved result; never more.



## OpenAPI

````yaml /openapi.en.json post /v1/stitch
openapi: 3.1.0
info:
  title: blockgence API
  description: >-
    The **blockgence** API provides fund tracing, entity attribution and
    explainable risk screening across several

    networks, with the evidence behind every result.


    ### Authentication

    Every `/v1/*` route requires an **API key**, sent in the `X-API-Key: <key>`
    header or as

    `Authorization: Bearer <key>`. Your organization issues the key. The
    evidence verification routes

    (`/v1/evidence/*`) do not require a key.


    ### Credits and limits

    Each plan has a **per-minute request limit** and a **monthly credit
    allowance**. Each operation states its cost in

    credits. **Only successful responses (status below 400) are charged:** an
    error response is recorded with 0

    credits. Check your usage with `GET /v1/account`.


    ### Data that could not be read

    If the data source cannot read what you requested, the response is `503
    source_unavailable`, with no charge,

    stating the source, the network, the query, the reason and whether a retry
    is advisable. If an intermediate step

    fails, the response is 200 and declares it in `degraded_sources` and in the
    `coverage_gaps` of the node or edge:

    in those cases, missing data does not mean missing activity.


    ### Networks

    `ethereum`, `bsc`, `polygon`, `arbitrum`, `base` and `optimism`; plus `tron`
    for tracing, profile, funding, network

    probing and transactions. `GET /v1/chains` states what can be queried on
    each network, at no cost. The networks

    `monero`, `bitcoin`, `litecoin` and `solana` are recognized in `/screening`
    and `/address`, where the network is

    inferred from the address format. Any other network returns `400`: it is
    never replaced with Ethereum.
  contact:
    name: blockgence
    url: https://www.blockgence.com/
  version: 1.0.0
servers:
  - url: https://app.blockgence.com
    description: Production
security: []
tags:
  - name: Platform
    description: >-
      Available networks, what can be queried on each one, from which sources
      and under which methodology. No cost.
  - name: Tracing
    description: >-
      Fund-flow tracing and reads of an address or a transaction: a
      time-consistent graph in both directions, funding, counterparties,
      bridges, swaps, mixers, labels and on-chain data.
  - name: Screening
    description: >-
      Risk screening of an address, with a recommendation (allow, review or
      block), its reasons and its sources.
  - name: Contracts
    description: Contract inspection and simulation of a transaction before signing it.
  - name: Tokens
    description: Token profile, with its issuer, supply, holders and risk signals.
  - name: Compromise
    description: >-
      Compromise vector of a stolen wallet, that is, how control of the funds
      was lost.
  - name: Incidents
    description: >-
      Incident response for victims, hacks and scams: playbook, freeze requests
      to issuers, post-mortem and deliverables.
  - name: Copilot
    description: >-
      AI investigation copilot that answers in natural language and cites the
      evidence (SSE streaming).
  - name: Cases
    description: >-
      Investigation cases to save, share and export, with their evidence,
      activity and annotations.
  - name: Permissions
    description: >-
      Approvals, delegations and signatures that grant access to an address's
      funds (ERC-20, Permit2 and EIP-7702).
  - name: Guard
    description: Wallet and protocol monitoring, with alerts by webhook and email.
  - name: Travel Rule
    description: >-
      Travel Rule without third-party connections: ownership challenge,
      counterparty, reconciliation and validation of IVMS101 messages.
  - name: Audit
    description: >-
      Smart contract audits, with the status, findings and evidence of each
      audit.
  - name: Evidence
    description: >-
      Verification of sealed evidence, with the signing public key and
      timestamps. No API key or charge required.
  - name: Monero
    description: >-
      Public profile of a Monero transaction and verification of a payment
      proof. Monero does not publish senders or amounts, so it is not traced.
  - name: Account
    description: Usage and limits of your API key.
  - name: Icons
    description: Entity logos to render graphs in your own interface. No cost.
  - name: Service
    description: Service status.
paths:
  /v1/stitch:
    post:
      tags:
        - Tracing
      summary: Follow a bridge crossing to the destination network
      description: >-
        Reconstructs the other side of a bridge crossing. From the deposit
        transaction, it detects the protocol, gets

        its deterministic identifier (for example, the Circle CCTP `nonce`, the
        Across `depositId`, the Wormhole VAA or

        the Celer cBridge `transferId`), confirms it with the official bridge
        explorer or with the destination event,

        and finds the withdrawal on the destination network. Returns an `origin
        → bridge → destination` graph, with

        some hops already traced on the destination network.


        **Request body (JSON).**

        - `tx_hash` (required): hash of the deposit transaction.

        - `chain`: network of the transaction; default `ethereum`.

        - `log_index` (integer ≥ 0, optional): only the deposit whose event is
        at that position in the receipt. Without
         it, every deposit in the transaction is resolved, up to 12; the rest are declared in `degraded_sources` and
         are requested with `log_index`.

        **Response.** Each crossing edge (`kind: "bridge"`) carries `dst_chain`,
        `protocol`, `dst_tx`, `crossings` and

        the link quality: `linkage` (`deterministic` if the same identifier
        appears on both sides; `probabilistic` if

        it is inferred from amount and time) and `confidence` (0 to 1). A
        transfer refunded at the origin is drawn as a

        `kind: "refund"` edge to whoever received the refund. Only a deposit
        emitted by the registered bridge contract

        on that network counts.


        **Non-200 responses.**

        - `404`: the receipt was read and contains no recognizable crossing, the
        transaction does not exist or
         `log_index` does not match a deposit; the text states the positions of the deposits.
        - `503 source_unavailable`, with no charge: the receipt of the deposit
        transaction could not be read.


        **Coverage.** If the deposit date, the destination verification or the
        trace on the other side fails, the

        response is `200` and declares it in `degraded_sources` and in the
        `coverage_gaps` of the edge or node. Up to 4

        recipients are traced on the destination network; the rest are declared.


        **Cost:** 25 credits base. Some operations charge less when they reuse a
        saved result; never more.
      operationId: stitch_route_v1_stitch_post
      parameters:
        - name: X-Case-Id
          in: header
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            title: X-Case-Id
          description: >-
            Active case, optional: the token of a case you can view. The query
            is recorded in that case and also uses its own labels. A case that
            does not exist, was deleted or is no longer shared with you returns
            `400 case_unavailable` and the query is not run, with no charge.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StitchRequest'
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Graph'
        '401':
          description: The API key is missing, invalid or revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '402':
          description: The monthly credits are exhausted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '422':
          description: >-
            The request does not have the expected shape; `detail` states which
            field to correct.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
        '429':
          description: >-
            The per-minute request limit was exceeded. Retry after the number of
            seconds in `Retry-After`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '503':
          description: >-
            `source_unavailable`: the data source could not read what was
            requested. No credits are charged. If an intermediate step fails,
            the response is 200 and declares it in `degraded_sources`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SourceUnavailable'
      security:
        - APIKeyHeader: []
        - BearerAuth: []
components:
  schemas:
    StitchRequest:
      properties:
        chain:
          type: string
          title: Chain
          default: ethereum
        tx_hash:
          type: string
          title: Tx Hash
        log_index:
          anyOf:
            - type: integer
              minimum: 0
            - type: 'null'
          title: Log Index
      type: object
      required:
        - tx_hash
      title: StitchRequest
      description: >-
        Resolver los cruces cross-chain de una tx de depósito: todos, o el de
        `log_index`.
    Graph:
      properties:
        seed:
          type: string
          title: Seed
        chain:
          type: string
          title: Chain
          default: ethereum
        hops:
          type: integer
          title: Hops
          default: 2
        source:
          type: string
          title: Source
          default: mock
        truncated:
          type: boolean
          title: Truncated
          default: false
        pending:
          type: integer
          title: Pending
          default: 0
        nodes:
          items:
            $ref: '#/components/schemas/GraphNode'
          type: array
          title: Nodes
        edges:
          items:
            $ref: '#/components/schemas/GraphEdge'
          type: array
          title: Edges
        exposure:
          items:
            $ref: '#/components/schemas/ExposureRow'
          type: array
          title: Exposure
        exposure_upstream:
          items:
            $ref: '#/components/schemas/ExposureRow'
          type: array
          title: Exposure Upstream
        exposure_basis:
          anyOf:
            - $ref: '#/components/schemas/ExposureBasis'
            - type: 'null'
        behavioral_alerts:
          items:
            $ref: '#/components/schemas/BehavioralAlert'
          type: array
          title: Behavioral Alerts
        degraded_sources:
          items:
            $ref: '#/components/schemas/SourceFailure'
          type: array
          title: Degraded Sources
        not_covered:
          anyOf:
            - items:
                type: string
              type: array
            - type: 'null'
          title: Not Covered
        offramps:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Offramps
        blind_spots:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Blind Spots
        loss_tx:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Loss Tx
        attack_stages:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Attack Stages
        coverage_schema:
          anyOf:
            - type: integer
            - type: 'null'
          title: Coverage Schema
          default: 1
      type: object
      required:
        - seed
      title: Graph
    Error:
      type: object
      title: Error
      description: >-
        Common shape of errors: a readable `detail` and, in many cases, an
        `error` with a stable code to recognize it without parsing the text.
      properties:
        detail:
          type: string
          description: What happened, in one sentence.
        error:
          type: string
          description: Stable error code, when there is one.
      required:
        - detail
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    SourceUnavailable:
      type: object
      title: SourceUnavailable
      description: >-
        The data source could not read what was requested. No credits are
        charged. Missing data does not mean the address is risk-free or has no
        activity.
      properties:
        error:
          type: string
          enum:
            - source_unavailable
        detail:
          type: string
          description: What failed, where, and whether a retry is advisable.
        source:
          type: string
          description: >-
            Source that could not respond, for example `etherscan` or
            `blockscout`.
        chain:
          type: string
        primitive:
          type: string
          description: blockgence read that did not complete.
        operation:
          type: string
          description: Specific query to the source.
        target:
          type: string
          description: What was queried (address or transaction), abbreviated.
        reason:
          type: string
          description: >-
            Stable reason, for example `rate_limited`, `timeout` or
            `upstream_error`.
        retryable:
          type: boolean
        http_status:
          type:
            - integer
            - 'null'
        retry_after:
          type:
            - integer
            - 'null'
          description: >-
            Seconds to wait before retrying; also sent in the `Retry-After`
            header.
        upstream_message:
          type:
            - string
            - 'null'
        source_fault:
          type: boolean
          description: >-
            Whether the failure came from the source or from a limit of the
            query itself.
        failure_cause:
          type: string
          description: Cause of the failure, in one sentence.
      required:
        - error
        - detail
        - source
        - reason
        - retryable
    GraphNode:
      properties:
        address:
          type: string
          title: Address
        chain:
          type: string
          title: Chain
          default: ethereum
        label:
          anyOf:
            - type: string
            - type: 'null'
          title: Label
        category:
          type: string
          title: Category
          default: unknown
        labels:
          items:
            $ref: '#/components/schemas/Label'
          type: array
          title: Labels
        label_contradictions:
          items:
            $ref: '#/components/schemas/LabelContradiction'
          type: array
          title: Label Contradictions
        risk:
          anyOf:
            - $ref: '#/components/schemas/RiskInfo'
            - type: 'null'
        risk_heuristic:
          anyOf:
            - $ref: '#/components/schemas/RiskInfo'
            - type: 'null'
        value_in:
          type: number
          title: Value In
          default: 0
        value_out:
          type: number
          title: Value Out
          default: 0
        is_seed:
          type: boolean
          title: Is Seed
          default: false
        depth:
          type: integer
          title: Depth
          default: 0
        in_degree_sample:
          type: integer
          title: In Degree Sample
          default: 0
        out_degree_sample:
          type: integer
          title: Out Degree Sample
          default: 0
        hidden_out:
          type: integer
          title: Hidden Out
          default: 0
        hidden_in:
          type: integer
          title: Hidden In
          default: 0
        reveal:
          anyOf:
            - $ref: '#/components/schemas/RevealBasis'
            - type: 'null'
        hub:
          type: boolean
          title: Hub
          default: false
        hub_note:
          anyOf:
            - type: string
            - type: 'null'
          title: Hub Note
        bridge_out:
          type: boolean
          title: Bridge Out
          default: false
        delegated_to:
          anyOf:
            - type: string
            - type: 'null'
          title: Delegated To
        delegation_note:
          anyOf:
            - type: string
            - type: 'null'
          title: Delegation Note
        smart_account:
          anyOf:
            - $ref: '#/components/schemas/SmartAccount'
            - type: 'null'
        malicious_flags:
          items:
            type: string
          type: array
          title: Malicious Flags
        funded_by:
          anyOf:
            - type: string
            - type: 'null'
          title: Funded By
        funded_by_label:
          anyOf:
            - type: string
            - type: 'null'
          title: Funded By Label
        funded_by_category:
          anyOf:
            - type: string
            - type: 'null'
          title: Funded By Category
        funded_by_privacy:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Funded By Privacy
        funded_crossing:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Funded Crossing
        funded_at:
          anyOf:
            - type: integer
            - type: 'null'
          title: Funded At
        funded_tx_hash:
          anyOf:
            - type: string
            - type: 'null'
          title: Funded Tx Hash
        funded_unpriced_from_exchange:
          anyOf:
            - items:
                additionalProperties: true
                type: object
              type: array
            - type: 'null'
          title: Funded Unpriced From Exchange
        funded_by_protocol:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Funded By Protocol
        funded_via:
          anyOf:
            - $ref: '#/components/schemas/SwapLeg'
            - type: 'null'
        not_funder:
          type: string
          title: Not Funder
          default: ''
        counterparties:
          items:
            $ref: '#/components/schemas/Counterparty'
          type: array
          title: Counterparties
        coverage_gaps:
          items:
            type: string
          type: array
          title: Coverage Gaps
        not_expanded:
          type: string
          title: Not Expanded
          default: ''
        pass_through:
          anyOf:
            - $ref: '#/components/schemas/PassThrough'
            - type: 'null'
        hub_overflow:
          anyOf:
            - $ref: '#/components/schemas/HubOverflow'
            - type: 'null'
        id:
          type: string
          title: Id
          description: >-
            Identidad del nodo en el grafo (`chain:address`, ver `node_id`).
            Viaja en la respuesta y

            es a lo que apuntan `GraphEdge.source_id`/`target_id`; la address
            sola no alcanza en un grafo

            multi-chain. Se deriva siempre: al validar un snapshot guardado, el
            `id` que traiga se ignora.
          readOnly: true
      type: object
      required:
        - address
        - id
      title: GraphNode
    GraphEdge:
      properties:
        source:
          type: string
          title: Source
        target:
          type: string
          title: Target
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
          default: 0
        value_usd:
          type: number
          title: Value Usd
          default: 0
        asset:
          type: string
          title: Asset
          default: ETH
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        token:
          type: string
          title: Token
          default: ''
        amount_sent:
          anyOf:
            - type: number
            - type: 'null'
          title: Amount Sent
        asset_sent:
          type: string
          title: Asset Sent
          default: ''
        amount_sent_raw:
          type: string
          title: Amount Sent Raw
          default: ''
        token_sent:
          type: string
          title: Token Sent
          default: ''
        amount_basis:
          type: string
          title: Amount Basis
          default: ''
        amount_rule:
          type: string
          title: Amount Rule
          default: ''
        tx_count:
          type: integer
          title: Tx Count
          default: 1
        tx_hash:
          anyOf:
            - type: string
            - type: 'null'
          title: Tx Hash
        last_ts:
          type: integer
          title: Last Ts
          default: 0
        first_ts:
          type: integer
          title: First Ts
          default: 0
        kind:
          type: string
          title: Kind
          default: native
        chain:
          type: string
          title: Chain
          default: ''
        dst_chain:
          type: string
          title: Dst Chain
          default: ''
        protocol:
          type: string
          title: Protocol
          default: ''
        linkage:
          type: string
          title: Linkage
          default: ''
        confidence:
          type: number
          title: Confidence
          default: 1
        dst_tx:
          anyOf:
            - type: string
            - type: 'null'
          title: Dst Tx
        mint_verifiable:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Mint Verifiable
        mint_verified:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Mint Verified
        asset_out:
          type: string
          title: Asset Out
          default: ''
        amount_out:
          anyOf:
            - type: number
            - type: 'null'
          title: Amount Out
          default: 0
        swaps:
          items:
            $ref: '#/components/schemas/SwapLeg'
          type: array
          title: Swaps
        refunds:
          items:
            $ref: '#/components/schemas/BridgeRefund'
          type: array
          title: Refunds
        crossings:
          items:
            $ref: '#/components/schemas/BridgeCrossing'
          type: array
          title: Crossings
        exit_chains:
          items:
            type: string
          type: array
          title: Exit Chains
        other_deposits:
          items:
            $ref: '#/components/schemas/OtherDeposit'
          type: array
          title: Other Deposits
        unresolved_crossings:
          items:
            $ref: '#/components/schemas/BridgeCrossing'
          type: array
          title: Unresolved Crossings
        demix_depositor:
          type: string
          title: Demix Depositor
          default: ''
        demix_pool:
          type: string
          title: Demix Pool
          default: ''
        candidates_read:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Candidates Read
        candidates_truncated:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Candidates Truncated
        discarded_candidates:
          items:
            additionalProperties: true
            type: object
          type: array
          title: Discarded Candidates
        discarded_total:
          anyOf:
            - type: integer
            - type: 'null'
          title: Discarded Total
        transfers:
          items:
            $ref: '#/components/schemas/EdgeTransfer'
          type: array
          title: Transfers
        coverage_gaps:
          items:
            type: string
          type: array
          title: Coverage Gaps
        usd_at_tx:
          anyOf:
            - type: number
            - type: 'null'
          title: Usd At Tx
        usd_at_tx_gap:
          type: string
          title: Usd At Tx Gap
          default: ''
        source_id:
          type: string
          title: Source Id
          description: El nodo de `source` (`GraphNode.id`).
          readOnly: true
        target_id:
          type: string
          title: Target Id
          description: >-
            El nodo de `target` (`GraphNode.id`): en la chain destino si la
            arista es un cruce.
          readOnly: true
      type: object
      required:
        - source
        - target
        - source_id
        - target_id
      title: GraphEdge
    ExposureRow:
      properties:
        category:
          type: string
          title: Category
        value:
          type: number
          title: Value
          default: 0
        value_usd:
          type: number
          title: Value Usd
          default: 0
        pct:
          anyOf:
            - type: number
            - type: 'null'
          title: Pct
          default: 0
        direct_usd:
          type: number
          title: Direct Usd
          default: 0
        pct_direct:
          anyOf:
            - type: number
            - type: 'null'
          title: Pct Direct
        upper_usd:
          anyOf:
            - type: number
            - type: 'null'
          title: Upper Usd
        nodes:
          type: integer
          title: Nodes
          default: 0
        unpriced:
          type: integer
          title: Unpriced
          default: 0
      type: object
      required:
        - category
      title: ExposureRow
      description: >-
        Exposición del sujeto a UNA categoría de entidad, en un sentido
        (`Graph.exposure` = aguas abajo,

        a dónde fue lo que salió del sujeto; `Graph.exposure_upstream` = aguas
        arriba, de dónde vino lo que

        le entró), en USD a precio de la fecha de cada tx
        (`Graph.exposure_basis`).


        Desde METHODOLOGY_VERSION 2026.09.24o (ver `scoring.exposure` y
        `backend/scoring/flows.py`):
         • `direct_usd` / `pct_direct`: lo que el sujeto le mandó DIRECTO a nodos de la categoría (o le
         llegó directo de ellos). Es exacto: son sus propias aristas.
         • `upper_usd` / `pct`: COTA SUPERIOR de lo del sujeto que pudo llegar a la categoría (o venir de
         ella) por cualquier camino del grafo: el flujo máximo con el USD de cada arista como capacidad.
         Ningún intermediario reenvía más de lo que recibió del sujeto, así que nunca pasa del 100%. No
         es una atribución: dice «como mucho». `pct` None = la parte no se puede acotar: un camino arranca
         en una arista del sujeto sin precio a la fecha. Si más adelante lo limita una arista con precio,
         `upper_usd` sí trae la cota en USD, pero puede superar lo que salió con precio y el % sería
         imposible. Sin ese límite, los dos
         son None.
         • `reached_usd`: lo que le llegó a esos nodos por el grafo en total (aguas arriba: lo que
         salió de ellos), que incluye fondos de terceros.
        Hasta 2026.09.24n `pct` era la fracción del volumen NATIVO que llegó a
        cada categoría, aguas arriba y

        aguas abajo mezclados (un USDC no contaba) y `value_usd` iba a precio
        actual.
    ExposureBasis:
      properties:
        price_basis:
          type: string
          title: Price Basis
          default: tx_time
        price_source:
          type: string
          title: Price Source
          default: defillama
        search_width_s:
          type: integer
          title: Search Width S
          default: 0
        subject_out_usd:
          type: number
          title: Subject Out Usd
          default: 0
        subject_out_edges:
          type: integer
          title: Subject Out Edges
          default: 0
        subject_out_unpriced:
          type: integer
          title: Subject Out Unpriced
          default: 0
        subject_in_usd:
          type: number
          title: Subject In Usd
          default: 0
        subject_in_edges:
          type: integer
          title: Subject In Edges
          default: 0
        subject_in_unpriced:
          type: integer
          title: Subject In Unpriced
          default: 0
        unpriced_edges:
          type: integer
          title: Unpriced Edges
          default: 0
      type: object
      title: ExposureBasis
      description: >-
        Base de los porcentajes de exposición del sujeto (`Graph.exposure*` y la
        razón «…% de lo que

        salió del sujeto…» de `risk.reasons`): cuánto salió y cuánto entró, con
        qué precio y qué quedó

        afuera. None en un grafo calculado antes de METHODOLOGY_VERSION
        2026.09.24o.
    BehavioralAlert:
      properties:
        name:
          type: string
          title: Name
        display_name:
          type: string
          title: Display Name
        definition:
          type: string
          title: Definition
        subject:
          type: string
          title: Subject
        subject_id:
          type: string
          title: Subject Id
          default: ''
        confidence:
          type: number
          title: Confidence
          default: 0
        severity:
          type: string
          title: Severity
          default: medium
        reasons:
          items:
            type: string
          type: array
          title: Reasons
        parameters:
          additionalProperties: true
          type: object
          title: Parameters
        evidence:
          additionalProperties: true
          type: object
          title: Evidence
      type: object
      required:
        - name
        - display_name
        - definition
        - subject
      title: BehavioralAlert
      description: >-
        Regla comportamental AML disparada sobre el grafo (structuring,
        layering, peel chain).


        Va SIEMPRE del lado heurístico (suma al `risk_heuristic`, nunca al
        `risk` defendible):

        son typologies del manual AML, no vínculos on-chain. La forma es
        glass-box —

        nombre canónico + regla operativa + parámetros usados + reasons con
        evidencia — así

        lo puede leer un compliance officer y defender un perito adverso
        (post-Sterlingov).
    SourceFailure:
      properties:
        source:
          type: string
          title: Source
        chain:
          type: string
          title: Chain
        primitive:
          type: string
          title: Primitive
        operation:
          type: string
          title: Operation
          default: ''
        target:
          type: string
          title: Target
          default: ''
        reason:
          type: string
          title: Reason
        retryable:
          type: boolean
          title: Retryable
          default: true
        http_status:
          anyOf:
            - type: integer
            - type: 'null'
          title: Http Status
        retry_after:
          anyOf:
            - type: integer
            - type: 'null'
          title: Retry After
        stage:
          type: string
          title: Stage
          default: ''
        effect:
          type: string
          title: Effect
          default: ''
        message:
          type: string
          title: Message
          default: ''
        upstream_message:
          type: string
          title: Upstream Message
          default: ''
      type: object
      required:
        - source
        - chain
        - primitive
        - reason
      title: SourceFailure
      description: >-
        Consulta a una fuente de datos que FALLÓ; no es «no hay datos».


        Glass-box de la cobertura (ver metodología `coverage.source-failures`):
        cada consulta termina

        en datos, en un vacío que la fuente afirmó o en una de estas. Viaja en
        `Graph.degraded_sources`

        (un salto que no se pudo leer mientras se expandía un rastreo) y en el
        `degraded_sources` de

        /demix y /probe. La falla de la consulta RAÍZ de un pedido no llega acá:
        sale como

        `503 source_unavailable` (ver `backend/providers/errors.py`).
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
        input:
          title: Input
        ctx:
          type: object
          title: Context
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
    Label:
      properties:
        address:
          type: string
          title: Address
        chain:
          type: string
          title: Chain
          default: ethereum
        label:
          type: string
          title: Label
        category:
          type: string
          title: Category
          default: unknown
        source:
          type: string
          title: Source
          default: ''
        confidence:
          type: number
          title: Confidence
          default: 0.5
        method:
          type: string
          title: Method
          default: heuristic
        added_by:
          type: string
          title: Added By
          default: seed
        service_type:
          anyOf:
            - type: string
              enum:
                - instant-exchanger
                - privacy-pool
                - deposit-address
            - type: 'null'
          title: Service Type
        conflicting_tags:
          items:
            $ref: '#/components/schemas/ConflictingTag'
          type: array
          title: Conflicting Tags
        sanctions_history:
          items:
            $ref: '#/components/schemas/SanctionsEvent'
          type: array
          title: Sanctions History
        chain_basis:
          anyOf:
            - $ref: '#/components/schemas/LabelChainBasis'
            - type: 'null'
        entity:
          anyOf:
            - $ref: '#/components/schemas/EntityRef'
            - type: 'null'
        observed_at:
          anyOf:
            - type: string
            - type: 'null'
          title: Observed At
        observed_basis:
          anyOf:
            - type: string
              enum:
                - source_row
                - source_snapshot
                - source_commit
                - measured
                - analyst
                - none
            - type: 'null'
          title: Observed Basis
        valid_until:
          anyOf:
            - type: string
            - type: 'null'
          title: Valid Until
        validity:
          anyOf:
            - type: string
              enum:
                - not_declared
                - ended
                - live
            - type: 'null'
          title: Validity
        license:
          anyOf:
            - $ref: '#/components/schemas/LabelLicense'
            - type: 'null'
      type: object
      required:
        - address
        - label
      title: Label
    LabelContradiction:
      properties:
        id:
          type: string
          title: Id
        chain:
          type: string
          title: Chain
        address:
          type: string
          title: Address
        claims:
          items:
            $ref: '#/components/schemas/LabelClaim'
          type: array
          title: Claims
        resolution:
          type: string
          title: Resolution
        review:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Review
      type: object
      required:
        - id
        - chain
        - address
        - claims
        - resolution
      title: LabelContradiction
      description: >-
        Dos o más fuentes dicen de la misma address, en la misma chain, cosas
        incompatibles (metodología

        `attribution.label-contradictions`). La clasificación sigue resolviendo
        sola (severidad, registros), pero esa

        resolución es PROVISIONAL: la contradicción va a la cola de revisión del
        analista y la evidencia muestra las dos.

        `review` es lo que dijo la cola (None = no se consultó, p. ej. en una
        reproducción).
    RiskInfo:
      properties:
        score:
          type: integer
          title: Score
          default: 0
        level:
          type: string
          title: Level
          default: low
        reasons:
          items:
            type: string
          type: array
          title: Reasons
      type: object
      title: RiskInfo
    RevealBasis:
      properties:
        since:
          type: integer
          title: Since
          default: 0
        until:
          type: integer
          title: Until
          default: 0
        include_tokens:
          type: boolean
          title: Include Tokens
          default: false
        read_more:
          type: integer
          title: Read More
          default: 0
      type: object
      title: RevealBasis
      description: >-
        Con qué lectura contó el rastreo el «+N» de un nodo (`hidden_out`,
        `hidden_in`), en los términos del pedido que

        la repite: POST /counterparties con estos `since`, `include_tokens` y
        `read_more` (y la ventana del rastreo) lee la

        address como la leyó su nodo, así lo revelado es lo que el «+N» contó.


        Hasta esa versión el front revelaba con `since` = la llegada más vieja
        de sus aristas entrantes (en el seed con

        padres y en los padres, distinta del piso del motor), siempre con tokens
        (el rastreo de la UI arranca sin) y con el

        presupuesto base aunque el nodo se hubiera releído con «leer más».
    SmartAccount:
      properties:
        kind:
          type: string
          enum:
            - safe
            - safe_proxy
            - erc1967_account
          title: Kind
        proxy_factory_version:
          anyOf:
            - type: string
            - type: 'null'
          title: Proxy Factory Version
        singleton:
          anyOf:
            - type: string
            - type: 'null'
          title: Singleton
        official_singleton:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Official Singleton
        version:
          anyOf:
            - type: string
            - type: 'null'
          title: Version
        singleton_contract:
          anyOf:
            - type: string
            - type: 'null'
          title: Singleton Contract
        source:
          anyOf:
            - type: string
            - type: 'null'
          title: Source
        family:
          anyOf:
            - type: string
            - type: 'null'
          title: Family
        implementation:
          anyOf:
            - type: string
            - type: 'null'
          title: Implementation
        implementation_contract:
          anyOf:
            - type: string
            - type: 'null'
          title: Implementation Contract
        note:
          type: string
          title: Note
          default: ''
      type: object
      required:
        - kind
      title: SmartAccount
      description: >-
        Tipo de cuenta reconocido por método. No es una entidad ni una

        categoría: no cambia el label, la categoría, el riesgo, si el nodo es
        terminal ni si el rastreo lo expande.


        `kind`: `safe` = runtime del proxy de Safe Y singleton oficial en la
        chain del nodo (slot 0, safe-deployments);

        `safe_proxy` = runtime del proxy de Safe con un singleton que no es
        oficial (`official_singleton: False`) o que no

        se pudo leer (`official_singleton: None`, `singleton: None`, y la falla
        en `degraded_sources`, stage

        `trace.smart_account`). `version` y `singleton_contract` son los del
        SINGLETON (un proxy de 1.3.0 puede delegar en

        1.4.1) y solo vienen con `kind: safe`.


        `erc1967_account`: proxy ERC-1967 cuyo slot de implementación apunta a
        una implementación oficial de

        Kernel, Nexus, Coinbase Smart Wallet o Alchemy Modular Account en la
        chain del nodo. Trae `family`,

        `implementation`, `implementation_contract` y `version` (los de la
        IMPLEMENTACIÓN); los campos de Safe van en None.

        Un proxy ERC-1967 que delega en otra cosa no se marca.
    SwapLeg:
      properties:
        tx_hash:
          type: string
          title: Tx Hash
        ts:
          type: integer
          title: Ts
          default: 0
        state:
          type: string
          title: State
          default: ''
        view:
          type: string
          title: View
          default: payer
        payer:
          type: string
          title: Payer
          default: ''
        receiver:
          type: string
          title: Receiver
          default: ''
        protocol:
          type: string
          title: Protocol
          default: ''
        amount_sent:
          anyOf:
            - type: number
            - type: 'null'
          title: Amount Sent
        asset_sent:
          type: string
          title: Asset Sent
          default: ''
        amount_sent_raw:
          type: string
          title: Amount Sent Raw
          default: ''
        token_sent:
          type: string
          title: Token Sent
          default: ''
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
        asset:
          type: string
          title: Asset
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        token:
          type: string
          title: Token
          default: ''
        payers:
          type: integer
          title: Payers
          default: 0
        undecoded:
          items:
            type: string
          type: array
          title: Undecoded
        confidence:
          type: number
          title: Confidence
          default: 1
        order_uid:
          type: string
          title: Order Uid
          default: ''
        order_state:
          type: string
          title: Order State
          default: ''
        settled_in:
          items:
            type: string
          type: array
          title: Settled In
        reasons:
          items:
            type: string
          type: array
          title: Reasons
      type: object
      required:
        - tx_hash
      title: SwapLeg
      description: >-
        UN swap del /trace: una tx en la que el ORIGEN de una arista (`payer`)
        pagó un swap, y a quién le llegó

        lo que salió (`swaps.follow`, desde METHODOLOGY_VERSION 2026.09.23o;
        metodología `swap.party-follow`).


        Se mira desde la parte, no desde la tx: `unswap` elige el que más pagó y
        el que más recibió de TODA la tx,

        y en una tx con varios pagadores (lotes de CoW, bundles de 4337,
        exploits) ése puede ser otro. Por eso el

        receptor sale de una regla que no adivina: si `payer` recibió otro
        activo en la tx, el receptor es él

        (`self`); si fue el único que pagó, el receptor de la tx (`followed`);
        si no, `ambiguous` y no se atribuye.


        `state`:
         followed = lo que salió le llegó a OTRA address (`receiver`): el pase dibuja la arista `swap` hasta ella
         y, si es nueva en el grafo, sigue rastreándola (ver `reasons`);
         self = le volvió al mismo `payer` en otro activo: el valor sigue en él;
         ambiguous = pagaron varias partes y `payer` no recibió nada: no se atribuye la salida;
         unresolved = hubo un swap que `payer` pagó pero no se sabe a quién le llegó (sin internas con la nativa
         en juego, o `unswap` sin receptor); la causa, en `reasons` y en `degraded_sources`;
         undecoded = la tx solo tiene swaps de DEX que blockgence no decodifica (`undecoded`): el valor cambió de
         activo acá y no se sigue. Alcance del dato, no falla de fuente;
         refunded = la orden no se liquidó y el contrato le devolvió la nativa a quien la
         mandó (OrderRefund con el mismo orderUid): no hubo swap;
         unsettled = (EthFlow de CoW) no se encontró la liquidación en lo leído: la orden sigue abierta, venció sin
         reembolso (la nativa sigue en el contrato) o la ventana leída no alcanzó (`order_state`).
        Una orden EthFlow (`order_uid` no vacío) une DOS txs: `tx_hash` es la
        del createOrder (donde el origen mandó la

        nativa) y `settled_in` las de la liquidación (Trade de la GPv2Settlement
        con el mismo orderUid), que el pase busca

        aparte. `order_state` ∈ filled | partially_filled | refunded | open |
        expired | not_found.

        Los montos: lo que pagó `payer` (el activo de más valor de los que puso;
        `token_sent` "" = la moneda nativa)

        y lo que le llegó a `receiver`. None = decimales desconocidos, o no se
        sabe (`unresolved`/`ambiguous`).


        Desde el 2026-09-24 hay legs mirados desde el que RECIBIÓ
        (`view="receiver"`, `swaps_back.follow_back`,

        metodología `swap.party-back`): van en la arista que ENTRA a un nodo del
        lado de atrás (el seed o un padre)

        desde el contrato que le pagó, y dicen si esa entrada es la salida de
        una conversión. Ahí:
         self = la pagó el propio nodo (`payer` == `receiver` == el destino de la arista): es su plata,
         convertida (swap, unwrap, liquidación de un router), y el contrato no es su fondeador;
         followed = el nodo no pagó: pagó el FIRMANTE de la tx (`payer`), único pagador, y la salida le llegó al
         nodo; el pase dibuja la arista del pago del firmante al contrato;
         unverified = hubo una conversión, pero el contrato que le pagó al nodo no es infraestructura verificada
         (router registrado en la chain, pool de una factory registrada, pool manager o Vault
         registrado, nativa envuelta registrada), lo pagado puede ser un token fantasma o lo recibido
         vale más de 1000 veces lo pagado: no se afirma y el contrato sigue como padre;
         ambiguous / unresolved = como arriba.
    Counterparty:
      properties:
        address:
          type: string
          title: Address
        chain:
          type: string
          title: Chain
          default: ''
        value_usd:
          type: number
          title: Value Usd
          default: 0
        tx_count:
          type: integer
          title: Tx Count
          default: 0
        direction:
          type: string
          title: Direction
          default: out
      type: object
      required:
        - address
      title: Counterparty
      description: >-
        Vecino de un nodo en el grafo, agregado: cuánto valor lo tocó y en qué

        dirección. Derivado de los edges por el servidor (antes lo hacía el
        front).
    PassThrough:
      properties:
        mode:
          type: string
          title: Mode
        source:
          type: string
          title: Source
          default: ''
        reason:
          type: string
          title: Reason
          default: ''
        txs:
          items:
            $ref: '#/components/schemas/PassThroughTx'
          type: array
          title: Txs
      type: object
      required:
        - mode
      title: PassThrough
      description: >-
        Por qué el /trace trató al nodo como infraestructura de paso (issue #4).
        `mode`: `cut` (no se expandió: sus

        salidas en otras txs son de otros usuarios; la continuación la dibuja el
        pase de swaps) o `same_tx` (se siguieron

        solo sus salidas de las txs de llegada, leídas de la tx). `source`:
        `registry` (router, manager o Vault registrado,

        nativa envuelta; sin red) o `tx` (lo prueban las txs de llegada, una por
        una en `txs`).
    HubOverflow:
      properties:
        in_usd:
          type: number
          title: In Usd
        out_usd:
          type: number
          title: Out Usd
        ratio:
          type: number
          title: Ratio
        ratio_limit:
          type: number
          title: Ratio Limit
        out_edges:
          type: integer
          title: Out Edges
          default: 0
        out_unpriced:
          type: integer
          title: Out Unpriced
          default: 0
        notable_out:
          type: integer
          title: Notable Out
          default: 0
        truncated:
          type: boolean
          title: Truncated
          default: false
        price_basis:
          type: string
          title: Price Basis
          default: tx_time
      type: object
      required:
        - in_usd
        - out_usd
        - ratio
        - ratio_limit
      title: HubOverflow
      description: >-
        Por qué el rastreo no siguió desde una cuenta sin label que reparte más
        de lo que le entró del rastro. Los montos van en USD de DefiLlama a la
        fecha de cada

        transferencia: `in_usd` lo que le llegó por las aristas del rastro;
        `out_usd` lo que suman las salidas posteriores que

        el fan-out iba a dibujar (`out_edges`), con precio. `ratio` = out/in; se
        corta cuando pasa de `ratio_limit`.

        `out_unpriced` = salidas elegidas sin precio a la fecha (no suman).
        `notable_out` = destinatarios notables (exchange,

        bridge, mixer…) entre sus salidas posteriores leídas: no se dibujan, se
        revelan a mano. `truncated` = su listado de

        transferencias quedó cortado por el tope de filas (otra señal de una
        cuenta de mucho volumen).
    BridgeRefund:
      properties:
        protocol:
          type: string
          title: Protocol
        deposit_tx:
          type: string
          title: Deposit Tx
        refund_tx:
          type: string
          title: Refund Tx
        join:
          type: string
          title: Join
        link_id:
          type: string
          title: Link Id
          default: ''
        intended_dst_chain:
          type: string
          title: Intended Dst Chain
          default: ''
        intended_recipient:
          type: string
          title: Intended Recipient
          default: ''
        token:
          type: string
          title: Token
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        deposit_amount_raw:
          type: string
          title: Deposit Amount Raw
          default: ''
        refund_block:
          type: integer
          title: Refund Block
          default: 0
        refund_ts:
          type: integer
          title: Refund Ts
          default: 0
        reasons:
          items:
            type: string
          type: array
          title: Reasons
      type: object
      required:
        - protocol
        - deposit_tx
        - refund_tx
        - join
      title: BridgeRefund
      description: >-
        Reembolso EN ORIGEN de un depósito en un bridge que no llegó a la chain
        destino.


        Hoy lo produce Celer cBridge V2 (bridge de liquidez): un envío que no se
        ejecuta vuelve con un

        `WithdrawDone` del contrato de ORIGEN cuyo `refid` es el `transferId`
        del `Send`. El vínculo

        entre las dos txs es determinístico (el mismo id en los dos eventos del
        mismo contrato).


        Viaja en `GraphEdge.refunds`. Lo normal es una arista `kind="refund"`
        (contrato del bridge →

        quien recibió el reembolso, en la chain de origen, `tx_hash` = la tx del
        reembolso). Si esa

        transferencia ya estaba en el grafo dentro de una arista directa que
        agrega otras txs, el

        reembolso se ANOTA ahí sin tocar su monto ni su `tx_count` (ver
        `crosschain.add_refund`).


        Los montos crudos van como texto decimal: superan 2^53 y un número JSON
        perdería precisión en

        JavaScript (y con ella la verificación del sello del paquete de
        evidencia).
    BridgeCrossing:
      properties:
        src_tx:
          type: string
          title: Src Tx
        src_ts:
          type: integer
          title: Src Ts
          default: 0
        src_log_index:
          anyOf:
            - type: integer
            - type: 'null'
          title: Src Log Index
        tx_deposits:
          type: integer
          title: Tx Deposits
          default: 0
        protocol:
          type: string
          title: Protocol
          default: ''
        linkage:
          type: string
          title: Linkage
          default: ''
        confidence:
          type: number
          title: Confidence
          default: 1
        dst_tx:
          anyOf:
            - type: string
            - type: 'null'
          title: Dst Tx
        dst_sender:
          type: string
          title: Dst Sender
          default: ''
        dst_asset_rule:
          type: string
          title: Dst Asset Rule
          default: ''
        mint_verifiable:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Mint Verifiable
        mint_verified:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Mint Verified
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
          default: 0
        asset:
          type: string
          title: Asset
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        token:
          type: string
          title: Token
          default: ''
        amount_sent:
          anyOf:
            - type: number
            - type: 'null'
          title: Amount Sent
        asset_sent:
          type: string
          title: Asset Sent
          default: ''
        amount_sent_raw:
          type: string
          title: Amount Sent Raw
          default: ''
        token_sent:
          type: string
          title: Token Sent
          default: ''
        amount_basis:
          type: string
          title: Amount Basis
          default: ''
        amount_rule:
          type: string
          title: Amount Rule
          default: ''
        attested:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Attested
        relay_state:
          type: string
          title: Relay State
          default: ''
        refund_state:
          type: string
          title: Refund State
          default: ''
        candidates_read:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Candidates Read
        discarded_candidates:
          items:
            additionalProperties: true
            type: object
          type: array
          title: Discarded Candidates
        discarded_total:
          anyOf:
            - type: integer
            - type: 'null'
          title: Discarded Total
        candidates_truncated:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Candidates Truncated
        self_bridge_assumed:
          type: boolean
          title: Self Bridge Assumed
          default: false
        confidence_measured:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Confidence Measured
        hook:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Hook
        mint_state:
          type: string
          title: Mint State
          default: ''
        fill_state:
          type: string
          title: Fill State
          default: ''
        delivery_state:
          type: string
          title: Delivery State
          default: ''
        dst_recipient_updated:
          type: string
          title: Dst Recipient Updated
          default: ''
        declared_recipient:
          type: string
          title: Declared Recipient
          default: ''
        forward_state:
          type: string
          title: Forward State
          default: ''
        forwarded_by:
          type: string
          title: Forwarded By
          default: ''
        forward_path:
          items:
            type: string
          type: array
          title: Forward Path
        forwards:
          items:
            $ref: '#/components/schemas/BridgeForward'
          type: array
          title: Forwards
        relay_id:
          type: string
          title: Relay Id
          default: ''
        relay_id_kind:
          type: string
          title: Relay Id Kind
          default: ''
        reasons:
          items:
            type: string
          type: array
          title: Reasons
      type: object
      required:
        - src_tx
      title: BridgeCrossing
      description: >-
        UN cruce de una arista `kind="bridge"`: un depósito en origen y lo que
        se sabe de su llegada.


        Una arista bridge del /trace SUMA los cruces con la misma clave
        (contrato que recibió el depósito,

        destinatario en la chain destino, activo que llegó; ver
        `crosschain._merge_crossing`). A nivel

        arista, `tx_hash`, `dst_tx` y `protocol` son los del primer cruce
        analizado, la `confidence` es la

        mínima y `amount_basis` la más débil: un resumen que no afirma de todos
        lo que vale solo para

        alguno. El detalle de CADA cruce va acá, uno por depósito y en el orden
        en que se analizaron (el

        primero es el de `tx_hash`): qué tx lo entregó en destino, cómo se
        vinculó y de dónde sale su monto.

        Toda arista bridge de /v1/trace y /v1/stitch lo trae, aunque sume un
        solo cruce.


        Hasta el 2026-09-23 (METHODOLOGY_VERSION 2026.09.23b) no existía, y el
        /trace descartaba el tramo de

        cada cruce: si el primero quedó intent-only y otro de la misma arista
        emparejó una entrega, la arista

        salía con `dst_tx` null, el paquete citaba solo intent-only y la entrega
        observada no aparecía en

        ningún lado; en una arista con 16 Send de Celer se publicaba un Relay de
        16. Una arista guardada

        antes viene con la lista vacía (el paquete de evidencia lo declara si
        sumaba varios cruces).


        Los montos siguen la convención de la arista
        (`bridges.bridge_edge_fields`): lo que LLEGÓ, del lado

        destino; lo que SALIÓ, del lado origen; y de dónde sale lo que llegó.


        Desde METHODOLOGY_VERSION 2026.09.23c cada cruce trae también el ESTADO
        de su verificación, lo que

        explica su confidence (`attested`, `relay_state`/`refund_state`,
        `self_bridge_assumed`, `hook`,

        `dst_recipient_updated`) y las `reasons` del resolver. Hasta ese día
        solo vivían en el tramo, que ni

        /v1/trace ni /v1/stitch publican, y la metodología los citaba como si
        salieran: un 0.9 de Celer no

        decía si el Relay estaba pendiente, ausente o sin leer, y el pago de un
        fill de Across a otra address

        no figuraba en ningún lado. Un cruce guardado antes los trae vacíos.


        Desde METHODOLOGY_VERSION 2026.09.23f el destino de la arista es quien
        COBRÓ, no el recipient que

        declara el depósito: si un fill de Across pagó a otra address, la
        arista, el nodo destino y el

        sub-rastreo van a ésa y el declarado queda en `declared_recipient`.
        Todos los cruces de una arista

        comparten su destino (es parte de la clave), así que
        `declared_recipient` puede diferir entre ellos.
    OtherDeposit:
      properties:
        src_tx:
          type: string
          title: Src Tx
        src_log_index:
          anyOf:
            - type: integer
            - type: 'null'
          title: Src Log Index
        protocol:
          type: string
          title: Protocol
          default: ''
        depositor:
          type: string
          title: Depositor
          default: ''
        dst_chain:
          type: string
          title: Dst Chain
          default: ''
        recipient:
          type: string
          title: Recipient
          default: ''
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
        asset:
          type: string
          title: Asset
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        token:
          type: string
          title: Token
          default: ''
        reason:
          type: string
          title: Reason
          default: ''
      type: object
      required:
        - src_tx
      title: OtherDeposit
      description: >-
        UN depósito en un bridge que está en una tx del /trace pero NO se dibujó
        como cruce de ESTE rastreo

        (METHODOLOGY_VERSION 2026.09.25c; metodología `bridge.tx-deposits`). Va
        en la arista que llevó a la tx.


        Una tx puede tener varios depósitos. Se dibujan los de quien puso los
        fondos según el grafo: el depositante

        del evento es un extremo de una arista del rastreo que lleva esa tx (el
        que mandó los fondos, o el contrato

        que los recibió y depositó por él). Los demás no son de este flujo: en
        un bundle ERC-4337 dos cuentas

        distintas cruzan en la misma tx, y dibujar el cruce de la otra le sumaba
        al sujeto un destino que no es

        suyo, su sub-rastreo y su riesgo. No se descartan en silencio: quedan
        acá, con lo que declara el evento.


        Los montos son los que SALIERON (chain de origen), como `amount_sent` de
        un cruce. `reason`:

        `other_depositor` = el evento nombra un depositante que no está en
        ninguna arista del rastreo con esa tx;

        `unknown_depositor` = el evento no nombra depositante (Hop, Synapse) y
        la tx tiene varios depósitos, así que

        no hay con qué atribuirlo; `unmatched_burn` = se llegó a la tx por una

        arista de QUEMA (hacia la Null Address) que no es la de este depósito
        —otro token u otro remitente—, así que no hay

        contrato del grafo desde el cual dibujarlo. Para dibujarlos, /v1/stitch
        con la tx (todos) o con `log_index` (uno).
    EdgeTransfer:
      properties:
        tx_hash:
          type: string
          title: Tx Hash
          default: ''
        ts:
          type: integer
          title: Ts
          default: 0
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
        asset:
          type: string
          title: Asset
          default: ''
        token:
          type: string
          title: Token
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        usd_at_tx:
          anyOf:
            - type: number
            - type: 'null'
          title: Usd At Tx
      type: object
      title: EdgeTransfer
      description: >-
        UNA transferencia de una arista que el engine agregó
        (`GraphEdge.transfers`): la arista junta todas las

        transferencias con el mismo (origen, destino, símbolo) y su `tx_hash` es
        solo la primera. Esto es cada una,

        tal como la dio la fuente, para que el analista vea qué suma la arista
        sin salir del panel.


        `value` None = los decimales del token no se obtuvieron (el exacto va en
        `amount_raw`). `token` es el contrato

        de ESA transferencia ("" = la nativa): dos contratos con el mismo
        símbolo caen en la misma arista y acá se

        distinguen. `usd_at_tx` es su monto al precio de DefiLlama a la fecha de
        su bloque, solo si la arista entera se

        valuó (`GraphEdge.usd_at_tx` no None); si no, None (el motivo está en
        `GraphEdge.usd_at_tx_gap`).
    ConflictingTag:
      properties:
        name:
          type: string
          title: Name
        slug:
          type: string
          title: Slug
          default: ''
        tag_type:
          type: string
          title: Tag Type
          default: ''
        category:
          type: string
          title: Category
          default: ''
        source:
          type: string
          title: Source
          default: blockscout
        applied:
          type: boolean
          title: Applied
          default: false
        reason:
          type: string
          title: Reason
          default: ''
      type: object
      required:
        - name
      title: ConflictingTag
      description: >-
        Tag de riesgo de un tercero que la clasificación NO aplicó a la
        `category`.


        Glass-box estructurado: antes estos tags viajaban solo como texto libre
        dentro de

        `Label.source` y el cliente no podía leerlos como dato. Caso típico: la
        hot wallet de

        FixedFloat trae los genéricos «Phish / Hack» y «Poisoning Address» junto
        al nombre de

        la entidad — el tag de identidad gana (`exchange`), pero el conflicto se
        muestra.

        NO mueve `category`, `risk.score` ni la recomendación: es contexto para
        ponderar.
    SanctionsEvent:
      properties:
        authority:
          type: string
          title: Authority
        list:
          type: string
          title: List
        programs:
          items:
            type: string
          type: array
          title: Programs
        action:
          type: string
          enum:
            - listed
            - delisted
          title: Action
        date:
          anyOf:
            - type: string
            - type: 'null'
          title: Date
        date_precision:
          type: string
          enum:
            - address
            - entity
            - unknown
          title: Date Precision
          default: unknown
        source_url:
          type: string
          title: Source Url
        entity:
          type: string
          title: Entity
          default: ''
        ref:
          type: string
          title: Ref
          default: ''
        as_of:
          anyOf:
            - type: string
            - type: 'null'
          title: As Of
        note:
          type: string
          title: Note
          default: ''
      type: object
      required:
        - authority
        - list
        - action
        - source_url
      title: SanctionsEvent
      description: >-
        Un hecho fechado de una lista de sanciones sobre una dirección: alta
        (`listed`) o baja

        (`delisted`), con la autoridad, la lista, los programas y la fuente que
        lo publica.


        Glass-box: hasta el 2026-09-18 el historial viajaba como texto dentro de
        `Label.source` y el

        front lo recuperaba con regex. `date_precision` dice QUÉ se fechó: OFAC
        publica en

        SDN_ADVANCED la fecha de alta de la ENTIDAD, no de cada dirección
        (Lazarus Group entró el

        2019-09-13 y la dirección de Ronin recién en la Recent Action del
        2022-04-14), así que esa fecha

        es `entity` y no se puede leer como «la dirección está designada desde
        ese día».


        Lo llenan solo las fuentes de sanciones: el seed de la lista OFAC
        vigente

        (`attribution/ofac_sdn.py`) y el registro de bajas
        (`attribution/sanctions.py`). Una label de

        usuario nunca lo trae (`labels._as_user_label` lo vacía).
    LabelChainBasis:
      properties:
        origin_chain:
          type: string
          title: Origin Chain
        applied_chain:
          type: string
          title: Applied Chain
        basis:
          type: string
          enum:
            - same_key
            - designation
            - not_applied
          title: Basis
        account_type:
          type: string
          title: Account Type
          default: ''
        key_chain:
          type: string
          title: Key Chain
          default: ''
        measured_block:
          anyOf:
            - type: integer
            - type: 'null'
          title: Measured Block
        measured_at:
          type: string
          title: Measured At
          default: ''
        note:
          type: string
          title: Note
          default: ''
      type: object
      required:
        - origin_chain
        - applied_chain
        - basis
      title: LabelChainBasis
      description: >-
        Por qué una label publicada para OTRA chain (`origin_chain` =
        `Label.chain`) aparece en la chain

        de la consulta (`applied_chain`). Lo pone el server al leer el índice
        (`labels.for_chain`); ninguna

        fuente ni cliente lo escribe. Sin este campo, la label es de la misma
        chain de la consulta (o de

        usuario, que vale en toda chain).
         • `same_key`: la address es una EOA medida (tiene clave), y la clave es la misma en toda chain
         EVM: la label se aplica acá como INFERENCIA declarada, con su categoría.
         • `designation`: la lista OFAC designa la address (y sus bajas la fechan): vale en toda chain EVM.
         • `not_applied`: contrato, cuenta sin prueba de clave o sin medir en su origen: en esta chain la
         misma address puede ser otra cosa, así que la label viaja como `context` (peso 0) y el nodo toma
         nombre y categoría de su propia chain.
    EntityRef:
      properties:
        id:
          type: string
          title: Id
        brand:
          type: string
          title: Brand
        kind:
          type: string
          title: Kind
          default: exchange
        countries:
          items:
            type: string
          type: array
          title: Countries
        registrations:
          items:
            $ref: '#/components/schemas/EntityRegistration'
          type: array
          title: Registrations
        basis:
          type: string
          enum:
            - label_name
            - registry_address
          title: Basis
          default: label_name
        note:
          type: string
          title: Note
          default: ''
      type: object
      required:
        - id
        - brand
      title: EntityRef
      description: >-
        La entidad regional a la que pertenece la MARCA de una label (ver el
        bloque de arriba).
    LabelLicense:
      properties:
        name:
          type: string
          title: Name
        spdx:
          type: string
          title: Spdx
          default: ''
        status:
          type: string
          enum:
            - ok
            - restricted
            - pending_review
            - not_licensed
          title: Status
        commercial_use:
          type: string
          title: Commercial Use
        packaged:
          type: boolean
          title: Packaged
          default: true
        url:
          type: string
          title: Url
          default: ''
        as_of:
          type: string
          title: As Of
          default: ''
      type: object
      required:
        - name
        - status
        - commercial_use
      title: LabelLicense
      description: >-
        La licencia de la FUENTE de una label (registro
        `attribution/provenance.py`, por `added_by`): qué licencia es,

        si permite el uso comercial y si el dato va en un entregable. None en la
        label = no consta.
    LabelClaim:
      properties:
        source:
          type: string
          title: Source
        source_text:
          type: string
          title: Source Text
          default: ''
        label:
          type: string
          title: Label
          default: ''
        category:
          type: string
          title: Category
        applied:
          type: boolean
          title: Applied
          default: true
      type: object
      required:
        - source
        - category
      title: LabelClaim
      description: >-
        Lo que UNA fuente afirma de una address: su `added_by`, el nombre y la
        categoría. `applied` = la clasificación la

        usó (label vigente); False = la citó sin aplicarla (label de contexto
        con el tag que no se aplicó).
    PassThroughTx:
      properties:
        tx_hash:
          type: string
          title: Tx Hash
        verdict:
          type: string
          title: Verdict
        detail:
          type: string
          title: Detail
          default: ''
        share:
          anyOf:
            - type: number
            - type: 'null'
          title: Share
        other_payers:
          items:
            additionalProperties: true
            type: object
          type: array
          title: Other Payers
        other_payers_total:
          anyOf:
            - type: integer
            - type: 'null'
          title: Other Payers Total
      type: object
      required:
        - tx_hash
        - verdict
      title: PassThroughTx
      description: >-
        Qué hizo un contrato de paso en UNA tx por la que le llegó el rastro
        (`detection/passthrough.py`).

        `verdict`: `pool` (un pool verificado por factory hizo el swap), `paso`
        (reenvió lo que recibió y el rastro fue

        su único pagador) o `paso_ambiguo` (reenvió, pero en la tx le pagaron
        otros: `share` = la parte del rastro en lo

        que le entró, en USD; None sin precio).
    BridgeForward:
      properties:
        to:
          type: string
          title: To
        token:
          type: string
          title: Token
          default: ''
        asset:
          type: string
          title: Asset
          default: ''
        amount_raw:
          type: string
          title: Amount Raw
          default: ''
        value:
          anyOf:
            - type: number
            - type: 'null'
          title: Value
      type: object
      required:
        - to
      title: BridgeForward
      description: >-
        UNA salida del receptor de la entrega de un cruce dentro de la tx de esa
        entrega (Across con `message`,

        METHODOLOGY_VERSION 2026.09.23g; ver `detection/forwarding.py`): a quién
        le mandó qué. Sumada por

        (destinatario, token). `token` "" = la moneda nativa de la chain
        destino. El crudo va como texto decimal

        (supera 2^53); `value` None = no se conocen los decimales del token.
    EntityRegistration:
      properties:
        country:
          type: string
          title: Country
        registry:
          type: string
          title: Registry
        registry_name:
          type: string
          title: Registry Name
          default: ''
        number:
          anyOf:
            - type: integer
            - type: 'null'
          title: Number
        legal_name:
          type: string
          title: Legal Name
          default: ''
        trade_name:
          type: string
          title: Trade Name
          default: ''
        tax_id:
          type: string
          title: Tax Id
          default: ''
        registered_at:
          type: string
          title: Registered At
          default: ''
        status:
          type: string
          enum:
            - listed
            - not_listed
          title: Status
          default: listed
        basis:
          items:
            type: string
          type: array
          title: Basis
        checked_at:
          type: string
          title: Checked At
          default: ''
        source_url:
          type: string
          title: Source Url
          default: ''
        review:
          type: string
          title: Review
          default: ''
      type: object
      required:
        - country
        - registry
      title: EntityRegistration
      description: >-
        Una inscripción de la marca en un registro público (hoy: Registro de
        PSAV de la CNV, Argentina).
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: Your API key in the `X-API-Key` header.
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        The same API key as `Authorization: Bearer <key>`, as an alternative to
        `X-API-Key`.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.