Skip to content

Truncated lists

Display truncation is reported by truncated and omitted. Connection pagination uses has_next_page and cursors; a response without truncated can still have more pages.

For query_events, continue while has_next_page is true, even when events is empty. scan reports a read-budget stop, and scan.next_call.repeat_with continues the same query with its filters, order and network unchanged.

summarize_address_flows, find_funding_sources, get_transaction and decode_ptb list the rows that fit a fixed size budget and compute every total, count and verdict over all rows first. Flagged rows always stay: bridge exits, lookalikes, labelled and non-wallet addresses, capabilities, the sender’s own changes, subjects tied to one another.

omitted names each list that lost rows with the count, the USD value of the priced ones and how many are unpriced, the largest row left out by USD (or the first, where rows carry no value), and next_call is the call that returns them, usually the same call with detail: "full".

Follow a complete { tool, args } call with its arguments unchanged. It carries args.network when its chain differs from the server default, including mainnet on a server whose default is testnet. A repeat_with object is instead a patch: merge it into the original arguments, retaining their network and filters, rather than calling the tool with the patch alone.

With the local store on, omitted.result.uri is the stored full result, sui://results/{id}, which pages any list as an MCP resource; see Optional local store. Its original arguments and complete follow-up calls keep the saved chain, even when the server default has changed since the result was stored.

list_nfts leaves raw Move contents to detail: "full" and counts them. get_nft_sales with include_sales lists the newest sales that fit, while its totals cover every sale. A get_transaction event list too long for the budget folds events that differ only in amounts into one row, and says so under omitted.folded.

list_objects_by_type also caps displayed rows separately from its object walk. omitted.next_call requests detail: "full" for rows already counted by sums; full-view row_offset pages scan current state again. If the walk stops, complete: false and stop_reason qualify its sums and owner counts. next_call resumes at the object cursor when one is available, but the next call’s totals are separate. other_defining_packages means even a fully walked module filter leaves types from other defining versions to query.

get_validators defaults to detail: "summary": name, address, stake, commission, voting power and at-risk status, sorted over the whole set before the list is capped. At-risk validators stay even beyond the summary budget or an explicit limit. active_validator_count and total_stake describe the whole set; validator_count counts only the rows shown. omitted.fields names the dropped fields and omitted.lists.validators counts any dropped rows. Follow omitted.next_call for full rows on the same network, in the same order, without a limit. detail: "full" has no size cap; an explicit limit still applies. An address lookup always returns the single validator’s details.

list_owned_objects and list_dynamic_fields return next_call only when their cursor advances. If the provider says more rows exist but returns the same cursor, the response identifies those rows as unreachable; repeating that cursor cannot retrieve them.

find_funding_source includes paid_in only on a continuation to preserve the established-funder stop at the previous hop. Omit it when investigating an address on its own. screen_address pages bridge digests five per call. For summarize_address_flows and analyze_attack_tx, an object follow-up offset indexes the deep-dive tool’s full object list, including objects excluded from the summary’s valuation. analyze_attack_tx accepts state_read_multiplier up to 1000; a scan still capped there reports incomplete state.

resolve_protocol_packages uses version_offset to page the combined lineage newest first, eight versions by default. Its activity result covers only the versions probed in that segment. analyze_package uses a zero-based older-version version_offset; bytecode_scan.version_gates.next_call advances it by the max_versions_compared segment size. Findings cover that segment’s older versions, with the newest version repeated as the comparison reference. capabilities.next_call carries capability_cursor through publish pages, authority structs, registry probes and witness checks. Capability rows cover the current segment; mint-authority conclusions require the last segment.

trace_object_history returns owner_change_next_call with owner_change_cursor for unresolved checkpoint ranges and their owners at both ends. The resumed search examines only those ranges. analyze_multisig allows 20 history reads per call and provides a continuation: an empty page whose cursor advanced is not the end. decompile_module returns an error when a module cannot be read, rather than presenting missing source. get_package_dependency_graph lists failed dependencies under unexpanded.

The DeepBook fills indexer has no cursor, so deepbook_trades cannot exhaust all fills at one timestamp. get_nft_sales can still exceed its maximum max_pages within a busy hours window; narrow the window to read more.

query_transactions fills a page to limit across several reads when the service returns short pages. Continue while has_next_page is true, even when transactions is empty. scan reports a read-budget stop, and scan.next_call.repeat_with continues the same query with its filters, order and network unchanged.

With all_versions: true, rows wait until the next rows or exhaustion of every version stream establish their global order. The tool stops reading once that ordered page is full; it refills only streams whose unknown frontier prevents filling the page. The cursor retains progress through empty reads as well as transactions already returned.

aggregate_events scans oldest first, stopping at either max_events or max_reads. Empty reads count against max_reads across every module segment. At a budget stop, truncated is true and scan.stop_reason is event_budget or read_budget. Continue with scan.next_call.repeat_with on aggregate_events, keeping the same filters and network. The opaque cursor records the module segment and scan boundary, including empty reads; it does not identify a covered checkpoint range.

Each call ranks a disjoint event slice. A resumed ranking remains truncated even when has_next_page becomes false, because it excludes earlier slices. Per-key event counts and value_sum add only when every group was retained in every slice (scan.groups_complete); values retain each slice’s rounding. Top-N rankings, distinct_keys, distribution and group_pnl are not additive. One transaction’s events can span slices, so adding slice P&L can count that transaction more than once.

An all-missing value_field in a partial or resumed slice is counted under each group’s missing_value_count; the scan can still continue. The tool rejects a field absent from every event only after reading the complete window in one call.

For example, a stopped call can return:

{
"truncated": true,
"has_next_page": true,
"scan": {
"reads": 3,
"stop_reason": "read_budget",
"next_call": {
"tool": "aggregate_events",
"repeat_with": { "cursor": "opaque-next-cursor" }
}
}
}

screen_address reads every balance-change page of each transaction in its window. If a continuation cannot be read, the window lists the digest in incomplete_transactions. That transaction contributes no balance-dependent exposure paths, and the summary states that screening is incomplete.

A bridge exit identified by its calls or events can still be reported. Its sent amount is null when any transaction in the exit group has incomplete balance changes, and the group names those digests in incomplete_transactions.