Explorer events and coverage

Use the event archive to build explorers, show history or refresh cached data. Events describe past changes. Read current payment instructions before sending a payment.

Public event archive

GET /v1/events?limit=100
GET /v1/events?cursor={opaque-cursor}&limit=100
GET /v1/coverage

/v1/events returns events, nextCursor, hasMore, truncated and coverage. Results are ordered newest first. limit is 1–100 and defaults to 100.

Optional filter	Value
`contractId`	Valid C contract address
`subject`	Subject string, at most 128 characters
`namespace`	Canonical lowercase namespace label

Continue with nextCursor and the same filters. Invalid filters return 400 bad_filter; invalid pagination returns 400 bad_cursor or 400 bad_pagination.

Read coverage

Coverage is the indexer’s report about the contracts it tracks. Its key fields are:

Field	Meaning
`source`	`"indexed"`
`processedLedger`, `headLedger`	Last processed ledger and observed chain head
`processedAt`, `asOf`	Time associated with that progress observation
`fresh`	Whether the progress observation is recent enough
`completeThroughObservedHead`	Whether processing reached the observed head
`complete`	No recorded gaps, fresh progress and processing through the observed head

gapCount counts recorded gaps. gaps includes each gap’s contract, ledger range and reason. contracts lists tracked contracts and their start ledgers. These arrays are capped at 100; inspect gapsTruncated and contractsTruncated. The current freshness threshold is 120 seconds, exposed as freshnessThresholdMs. A reported head alone does not prove it was processed. Coverage describes the stated indexing scope and is not an independent proof against omissions. See status semantics.

History versus live instructions

GET /v1/names/{namespace}/{label}/history?limit=100

Returns name, indexed issuedAt and issuedLedger, an events timeline and pagination/coverage fields. Events include action, ledger, txHash, eventId, contractId, detail, at and ingestedAt. at is chain time; ingestedAt is processing time. Older rows can have unknown chain or issuance metadata. Results are newest first. Continue with the cursor for the same name. An unknown indexed name returns 404 name_not_found. A bounded SDK history() call does not replace paginating this archive. Hosted webhooks also have a separate supported event list; a raw contract event is not automatically a webhook event.

Versioned contract events

Topics appear in the exact order shown below. Nodes are BytesN<32>, generations are u64, and named data structs use Soroban map encoding.

Namespace and name lifecycle

Contract	Topics	Data
Registry	`ns_v1`, namespace node	`NamespaceAllocated`
Registrar	`name_v1`, name node, generation	`NameChange`
Registrar	`xfer_v1`, name node, generation	`TransferChange`

struct NamespaceAllocated {
    label: Bytes,
    owner: Address,
    resolver: Option<Address>,
    method: Symbol,
}
struct NameChange {
    label: Bytes,
    action: Symbol,
    holder: Address,
    address: Address,
    expires_at: u64,
}
struct TransferChange {
    label: Bytes,
    action: Symbol,
    holder: Address,
    to: Option<Address>,
    proposal_expires: Option<u64>,
    expires_at: u64,
}

NamespaceAllocated.method is allocate or reserved. Its plaintext label supports namespace discovery. NameChange.action is issue, reclaim, transfer, renew or address. TransferChange.action is propose or cancel. A cancellation carries to=None and proposal_expires=None; cancellation can be idempotent.

Payment and profile changes

Resolver topics	Data
`addr_v1`, name node, generation	`Address`
`text_v1`, name node, generation	Text key `Symbol`
`pay_v1`, name node, generation	Complete direct `Payment { address, memo }`
`pay_v2`, name node, generation	`PaymentDestination::Muxed(MuxedPayment { account, id })`

text_v1 identifies a changed key and contains no historical text value. Re-read current text through Lookup; reconstructing an old value requires historical state access. Direct G/C payment writes emit pay_v1; M writes emit pay_v2, preserving the exact routing ID separately from its G account. They do not also emit address/text companion events. An address update to a configured memo-free payment emits the complete updated payment. An unconfigured address-only write emits addr_v1.

Native username claims

Registrar topics	Data
`claimcfg`	Complete `ClaimConfig`
`reserved`, name node	`(label: Bytes, reserved: bool, policy_version: u64)`
`claim_v1`, namespace node, holder	`(request_id: BytesN<32>, ClaimReceipt)`

Configuration and reservation changes are separate from issuance. A receipt records an operation’s historical result; it does not prove current ownership. Replaying a receipt emits no new claim event. See native claim event and storage types.

Older companion events

Where a versioned event accompanies an older layout, the older event immediately precedes it in the same invocation. Archive both, but apply the state change only once in your derived records. Keep exact event IDs. Deduplicating only by transaction, action and subject can discard legitimate changes when one transaction contains several events.

Routing and governance events

Registry routing events include dep_reg, att_reg, dep_res, set_res, reg_upg, res_upg and locked. Re-read namespace metadata when these change the selected contracts or their provenance. Registry namespace transfers use prop_tr, acc_tr and canc_tr. They are distinct from Registrar name transfers. Primary elections use set_pri and clr_pri. Lookup upgrade events are upg_prop with (wasm_hash, execute_after), upg_exec with the exact hash, and upg_canc with the canceled hash. Lookup’s current upgrade delay is zero, so a proposal can execute immediately without advance notice to watchers. Allocator emits upg_prop with (wasm_hash, eta), upg_exec with the executed hash and upg_cxl with (). These events are unchanged for its hash-bound execution and cancellation methods. The cancel event contains no hash, so retain proposal and transaction context. See Allocator upgrade flow.

Namespace objection events

Allocators with ruling_version() == 1 add these events:

Topics	Data	Meaning
`obj_case`	`(label: Bytes, case_id: BytesN<32>)`	A new standing objection received its exact case ID
`obj_rule`	`(label: Bytes, case_id: BytesN<32>, uphold: bool)`	Governance ruled on that case

Existing objected and resolved events remain unchanged. The new events accompany the same transitions; do not count them as a second objection or settlement. uphold = true rejects the namespace claim; false dismisses the objection. Use objection_decision(case_id) to read the saved parties, evidence and optional explanation. Timeout, withdrawal and stuck cancellation emit their existing events and do not invent a governance ruling. Retain known case IDs for history and upkeep; event availability is limited by your RPC provider. See namespace objection methods.

Fee events

These Allocator events describe namespace claim fees:

Topics	Data
`fee_cfg`	Claim fee policy
`fee_paid`, key	Label, claimant, token, amount
`fee_done`, key	Label, token, recipient, receipt
`fee_cred`	Payee and credited amount
`fee_pull`	Payee and delivered credit amount
`fee_sweep`	Recipient and surplus amount

The key is SHA256(label), not the recursive namespace node. Receipt outcomes describe settlement entitlements; check transfer and credit state for delivery. Keep earlier events because a new claim can replace a terminal per-label receipt.

Muxed display-name elections

Universal Lookup emits set_mrev / clr_mrev for namespace elections and set_mpri / clr_mpri for cross-namespace elections. Payloads retain the base G account and exact u64 routing ID. A set event also contains the versioned name, routing and generation snapshot. See the exact event and storage shapes. Keep these M identities separate from G/C reverse keys and from transaction memos. An election event does not prove the election is still valid. Recheck it through reverse_muxed or primary_name_muxed.

Durable indexing

For an independent archive:

Track Registry, Allocator, discovered Registrar/Resolver contracts, Primary and Lookup from their confirmed deployment ledgers.
Preserve the event ID, emitting contract, transaction hash, ledger, chain timestamp and raw topics/data. Store ingestion time separately.
Retain historical contract IDs after routing changes and drain all RPC cursor pages within your provider’s limits.
Record gaps when older events are unavailable.

On reissue, update the generation, built-in address, expiry and current issuance fields. Do not infer permanent ownership from zero expiry or replace an unknown historical timestamp with ingestion time. RPC retention is finite. Empty pages can still advance the cursor. Older allocation events can lack plaintext labels and may require independently verified discovery data. See Stellar getEvents.

​Public event archive

​Read coverage

​History versus live instructions

​Versioned contract events

​Namespace and name lifecycle

​Payment and profile changes

​Native username claims

​Older companion events

​Routing and governance events

​Namespace objection events

​Fee events

​Muxed display-name elections

​Durable indexing