# graph.blockchain.ai API documentation Near-real-time GraphQL data API for the explicitly documented Solana blocks, transaction activity and enrichment, tokens, wallet holdings, token holders, DEX analytics, pool liquidity, quote simulations, metadata, and supported subscription fields. MCP and GraphQL also expose paper-trading tools for virtual wallet sessions priced by real simulations; these do not change on-chain wallets or submit swaps. It does not access wallet keys, forecast prices, inspect arbitrary Solana accounts, or access data outside the GraphQL schema. This single-document reference is rendered from `Schema/mcp-map.json` and `Schema/data-dictionary.json` for retrieval and RAG clients. The GraphQL schema endpoints remain the source of truth for exact field availability. - **Documentation map version:** `1` - **MCP server version:** `1.3.0` - **MCP release date:** `2026-10-16` ## Query Data Access This document is a reference and does not itself contain query result rows. The query API returns near-real-time indexed data and can lag source events slightly. GraphQL subscriptions stream provisional events as they arrive. GraphQL clients must send query documents as JSON POST requests: ```text https://graph.blockchain.ai/graphql ``` Browser and retrieval clients that cannot submit POST bodies should use the short, allowlisted read facade instead of putting GraphQL syntax in a URL: ```text https://graph.blockchain.ai/read/list_wallet_current_holdings?wallet=
&limit=100 ``` `/read/{operation}` accepts only documented query operations and typed query parameters, then executes the same GraphQL implementation with the operation's documented default selection. Arrays may be repeated or comma-separated. Input objects use flattened names such as `periodFrom`, `periodTo`, and `orderByField`. Eligible query examples include a short `/read` URL. Credential-bearing wallet-token retrieval is available through GraphQL/MCP POST only, not `/read`. API defaults are documented under each argument. Runnable example variables are fixtures resolved when this document is rendered; they do not change GraphQL defaults. A client UI may choose its own independent initial values. If neither MCP, `/read`, nor a successful GraphQL POST request returns rows, state that no result was obtained and do not substitute protocol mechanics or market assumptions for returned data. ## Runnable Example Variable Presets ### `previousUtcDay` UTC midnight at the start of the previous complete day. ### `startOfCurrentUtcDay` UTC midnight at the start of the current day. ### `now` Current UTC time when /doc.md is rendered. ## Service ### Primary Instruction > Use only the advertised MCP tools and GraphQL schema fields. Do not invent operations, fields, chains, wallet actions, trading actions, forecasts, or external data. Use data queries for on-chain information and simulation tools for isolated virtual paper trading; summarize or calculate only from returned results. This document contains no query result rows; the API itself returns near-real-time indexed data. GraphQL accepts POST. Browser-only clients may call allowlisted query operations through /read/{operation}. Select only fields needed for the answer. ### Endpoints | Key | Value | | --- | --- | | `graphqlEndpoint` | https://graph.blockchain.ai/graphql | | `graphqlMethod` | POST | | `readEndpoint` | https://graph.blockchain.ai/read | | `readEndpointTemplate` | https://graph.blockchain.ai/read/{operation}?argument=value | | `schemaEndpoint` | https://graph.blockchain.ai/graphql/schema | | `documentationEndpoint` | https://graph.blockchain.ai/doc.md | | `schemaSubsetEndpoints.token` | https://graph.blockchain.ai/graphql/schema/token | | `schemaSubsetEndpoints.block` | https://graph.blockchain.ai/graphql/schema/block | | `schemaSubsetEndpoints.pool` | https://graph.blockchain.ai/graphql/schema/pool | | `schemaSubsetEndpoints.dex` | https://graph.blockchain.ai/graphql/schema/dex | | `schemaSubsetEndpoints.wallet` | https://graph.blockchain.ai/graphql/schema/wallet | | `schemaSubsetEndpoints.cex` | https://graph.blockchain.ai/graphql/schema/cex | | `schemaSubsetEndpoints.swap` | https://graph.blockchain.ai/graphql/schema/swap | | `schemaSubsetEndpoints.simulation` | https://graph.blockchain.ai/graphql/schema/simulation | | `simulationDocumentationEndpoint` | https://graph.blockchain.ai/simulation.md | ### Unsupported Capabilities - No wallet key access, signing, real swaps, orders, transaction submission, or on-chain portfolio mutation. Indexed wallet holdings and token holder rows are read-only. Simulation tools operate only on isolated virtual balances, never on-chain wallets. - No price prediction, investment advice, risk scoring, or automated trading decisions. - No arbitrary Solana RPC method execution or historical backfill beyond fields exposed in /graphql/schema. find_hash always returns lightweight confirmation status and, with includeRpcInfo=true, can retain native results only from its fixed getTransaction, getSignatureStatuses, getAccountInfo, getBlock, and getSlot resolution flow; it is not a general RPC proxy. - No web browsing or third-party API calls through this MCP server. - No live streaming through request/response MCP tools; use GraphQL websocket subscriptions only in clients that support them. ## MCP Server Instructions 1. Send the Mcp-Session-Id returned by initialize on subsequent /mcp requests. GraphQL tool executions carrying the same session ID share a concurrency allowance even when the caller IP changes. With no single nonblank session ID, the allowance falls back to caller IP. Additional executions wait while that allowance is busy. Initialization and discovery calls that do not execute GraphQL do not consume it. 2. HTTP GraphQL responses expose X-Credits-Used: the sum of independent data lookup costs in the selected operation, or across all members of an accepted request, operation or variable batch. Each independent lookup costs 1; namespace containers, result fields and result rows do not add credits. Aliases count separately; GraphQL-merged fields count once. Fragments, skip/include directives and variable defaults are respected. The base cost is halved once when retrievedFromCache is true, including shared in-flight and hot-path results. Body creditCost retains fractions. X-Credits-Used is floor(sum of discounted costs), rounded once after summing: two cached 1-credit results give 1; one gives 0. Errors and metadata-only or entirely skipped operations have a minimum base cost of 1. Combined lookups remain supported. MCP and /read responses executing GraphQL expose the same header; discovery and instructions do not. Browser clients can read it through Access-Control-Expose-Headers. Finite batches execute concurrently but headers and the first result wait until all cache discounts are known. Ongoing subscription event costs remain in extensions.platform.creditCost. Costs are reported without credit debiting. 3. Every GraphQL result automatically includes extensions.platform with executionTime (measured server execution milliseconds), creditCost (summed independent lookup costs for this operation or variable set, halved once for retrievedFromCache, retaining fractions), and retrievedFromCache (true for a saved result or a matching in-flight result, false for fresh execution). Do not select platform as a schema field. Each response measures its own time, including waiting for a shared result. Timing includes GraphQL parsing, validation, resolvers, awaited data retrieval and preparation of a reusable result; it excludes execution-admission waiting, final response serialization, network/proxy transit and client processing. Each subscription event has its own execution time, excluding idle waiting for events. Errors retain the block; malformed HTTP envelopes measure parsing/error handling, and source errors before subscription-event execution report zero. Batched operations and variable sets each receive a block. MCP and /read GraphQL results carry the same metadata; MCP preserves it in full structuredContent and truncated text summaries. 4. Recent matching query results may be reused for 1.5 seconds after completion when an explicit supported time/slot range boundary is supplied, or 0.5 seconds otherwise (including omitted/null ranges and exact point lookups), with up to eight retained results per client IP. Single wallet activity/activityExt queries can also reuse matching results across IPs within these same freshness windows, except when selecting currentHoldings or hasCurrentState metadata. Cross-IP matches require identical range boundaries as well as fields, filters, ordering, pagination and all other parameters. Different credentials remain isolated. A matching query already executing is shared with its waiting retries. Within one IP, corresponding supported range boundaries may shift by at most one second or three slots from the original request; exact slot/time lookups and all other parameters must match exactly. Returned rows, counts, timestamps and range metadata remain those of the original query, so boundary rows may differ from a fresh evaluation of a nearby window. Hits do not extend retention or move the original comparison window. Check extensions.platform.retrievedFromCache to detect this reuse. Errors are not retained for later retries. Subscriptions and solana.swap session creation bypass this reuse. 5. This is a schema-bound Solana and CEX data server with isolated virtual paper-trading tools. Prefer the operation-specific tools for normal requests. get_instructions without a topic returns the server version, release date, and a short topic index; pass a topic for detailed instructions. Use graph://schema/full when exact GraphQL fields are needed. 6. When the user supplies an unidentified Solana transaction signature, account address, or numeric slot, call find_hash first. It combines exact indexed probes with bounded Solana RPC discovery and returns routing kinds plus machine-readable drilldowns. Specific token, pool, and reviewed-program roles take precedence over generic account and wallet fallbacks; do not infer unreturned specific roles. A syntactically valid input always receives at least one routing record, but a generic fallback record alone does not prove indexed coverage or on-chain existence. Read rpcInfo.confirmationStatus: indexed matches with a known slot report confirmed while newer than the shared cached finalized cluster head and finalized once covered; unresolved identifiers obtain status from RPC. Set includeRpcInfo=true only when the complete native type-specific payload is needed; transaction runtime logs remain inside the unfiltered rpcInfo.rpcResult at meta.logMessages. 7. The documentation contains no query result rows. Query and /read responses are near-real-time indexed snapshots and may lag source events slightly; GraphQL subscriptions stream provisional events as they arrive. Claim current Blockchain.ai values only after an MCP tool, /read operation, or GraphQL POST returned the relevant rows. Browser-only readers should use allowlisted /read/{operation} routes, not encode GraphQL syntax into GET URLs. 8. For block navigation, use list_blocks to discover recent indexed block summaries, get_block for one known slot, and list_block_transactions to discover indexed transaction signatures in that slot. Batch signatures through get_transaction_activity for indexed transaction flows, trades, and transfers, and through get_transactions for fee, compute, Jito-tip, or a flat program-interaction list. Block summaries are a public indexed view, not the canonical indexer's internal checkpoint dataset. Transaction counts and aggregates are indexed coverage, not guaranteed RPC-complete historical block contents; block hashes and heights are not currently exposed. 9. get_transaction_activity is the wallet-independent activity drilldown. It resolves transaction hashes through indexed transaction metadata and can return fee plus the sibling memos and notes arrays, then reads bounded program invocations, DEX trades, and token transfers as selected. Selecting flow requires all three activity kinds; without flow, top-level trade and transfer reads remain independently field-selected. In flow, each outer instruction is a root and stackHeight reconstructs CPI children; the standardized lowercase type identifies swap, lifecycle/token operation, transfer, or plain program_invocation activity. Transfers attach to exact instruction coordinates, while confidently matching trade perspectives annotate the invocation that performed the swap instead of becoming synthetic flow entries. Flow arrays are contextual placements of the same source facts exposed by top-level trades/transfers, so never add both representations. Ambiguous trade rows remain available in the top-level trades array and are not forced onto a flow node. Transfers are physical movement facts without a wallet-relative direction. Their intent field is the decoded movement mechanism, not a recipient-purpose inference; historical unreplayed rows use unknown. Trade rows can repeat one operation from multiple token perspectives. Transfer historicalPriceUsd/historicalValueUsd use the last retained fair close within 30 days at or before the block minute; currentPriceUsd/currentValueUsd use current indexed token prices. Technical Inner and UnresolvedInner trade layers are excluded unless includeInnerSwaps is true. programName is enriched from indexed and reviewed labels plus canonical built-ins. instructionName is the indexer-parsed name and remains null when unresolved; instructionDiscriminator preserves up to eight raw instruction-data bytes as lowercase hex and is not an ABI decode. 10. Use get_transactions to enrich any result containing txHash with indexed fee, compute-budget, Jito-tip, Token-2022 fee, Memo Program content, protocol event notes, activity-count, and ordered program-interaction details. Batch hashes rather than calling once per row; 25 to 100 hashes per request is recommended and 100 is the maximum. 11. Explorer links use explicit identifier pairs: txHash/txExplorerUrl, mint/mintExplorerUrl, poolAddress/poolExplorerUrl, programId/programExplorerUrl, blockSlot/blockExplorerUrl, and equivalent field-specific names for wallets, vaults, owners, authorities, and token accounts. Operations exposing links accept explorer, default to SOLSCAN, and currently support Solscan only. The browser Graph Explorer's None choice is client-side query shaping that omits the explorer argument and every selected explorer-URL field; NONE is not a GraphQL enum value and must not be sent by raw GraphQL or MCP clients. Generic explorerUrl fields are deprecated compatibility aliases where retained. 12. For get_transactions fees, totalFeeLamports is the authoritative Solana runtime network fee. Jito tips and Token-2022 transfer fees are separate movements. Use baseFeeLamports and prioritizationFeeLamports only when feeBreakdownStatus is exact; legacy or unresolved null splits mean unknown, not zero. 13. In get_transactions, fee.walletFacingDexSwapCount and fee.hasWalletFacingDexSwap describe wallet-facing dex_swaps source rows only. They are not general DEX-activity classifiers: a route-only MEV transaction can have zero/false while list_wallet_activity contains tradeLayer MEV/Inner rows for the same txHash. Keep wallet/DEX activity rows authoritative for that classification. dexSwapCount and isTrade are deprecated compatibility aliases. 14. For questions about what a wallet did, use list_wallet_activity as the primary history source. Activity selection alone never starts history recovery. Selected metadata.currentHoldings flow fields use the same recovery as standalone currentHoldings when allowRpcFallback=true. With allowRpcFallback=true, period queries may reuse previously recovered pre-index history. Both holdings entry points require selected flow fields, a balance gap, a verified user-wallet account, and pre-index existence. Account checks are internal and cached. Unknown coverage or eligibility starts no job. allowRpcFallback defaults to true; false requests indexed-only reads. source distinguishes INDEXED from RPC_BALANCE_DELTA. Use metadata.coverage and activityRecoveryIncomplete to interpret missing history. 15. When a question focuses on a particular wallet, follow walletInvestigationResponse: first report its first seen time and earliest observed funding transaction hash, funding wallet, asset, and amount; then present all available activity from first seen through the report time; always finish with current holdings. Discover first seen from metadata.firstTransferToWalletAt and the earliest indexed timestamp from metadata.coverage.indexedFromAt before querying history. Start at the later of those timestamps and set allowRpcFallback=false. Never query earlier dates, including overlapping windows or retries: a period before indexed coverage can trigger historical backfill. Treat first seen as an indexed observation, not account creation, and report unavailable funding evidence or incomplete coverage explicitly. 16. In wallet activity results, token transfers are authoritative for amounts that actually entered or left the queried wallet. Transfer intent describes the decoded movement mechanism, while direction describes its relationship to the queried wallet; intent does not infer the wallet's business purpose. Historical unreplayed and RPC balance-delta rows use unknown. Trade rows provide DEX, pool, side, price, and execution context, but the same swap may appear from both token perspectives or at multiple operationIndex values. operationIndex aliases opIndex for trades and instructionIndex for transfers. Do not sum trade volumeUsd rows to calculate wallet cash flow or P&L. Use transfer historicalValueUsd for event-time USD and currentValueUsd only for present-day mark-to-market; both are unsigned, so apply direction for external wallet flow. 17. Historical transfer valuation is not capped by the rolling candle-query cache. It performs a field-selected lookup against a separate full-retention local fair-close cache and falls back to remote token_fair_ohlcv_1m while that cache catches up or when a mint has no covered local price. historicalPriceSourceMinute exposes the actual retained minute used and can precede the block minute by up to 30 days. Historical fields are null when neither source has a fair price in that window; never substitute the current price for a missing historical value. 18. For one point-in-time token valuation, including timestamps older than tokenCandles retention, use get_token_price_usd_at. It applies the same full-retention fair-close path as transfer historical valuation and returns priceSourceMinute so a carried older price is explicit. It returns null price fields when no fair close exists within 30 days at or before the requested timestamp; it never substitutes current price or looks forward. The returned price uses the current Token-2022 UI multiplier by default, not the multiplier at the requested time; set adjustForUiMultiplier=false for source units. 19. For chart-ready historical OHLCV, use get_dex_token_candles with continuous true, which is the default. It carries the latest available close through missing buckets to the requested end, sets OHLC/VWAP to that close, sets all volume fields and sampleCount to zero, and returns newest first. The seed close may predate the requested window, but its source candle is not returned and it does not extend lookback. Set continuous false when only observed fair 1-minute rows are acceptable. 20. confirmedTokenChanges is a GraphQL websocket subscription for full token snapshots emitted after token_stats commits. Omit changeType or use ALL for every snapshot, PRICE for priceUsd/fairPriceUsd transitions, or GRADUATION for null-to-known graduationAt transitions. Live-only explicit mint filters can compare the first newer event with a cached token price; global and replay subscriptions require a prior streamed event, and fair-price-only first changes cannot be detected from that cache. Returned snapshot.supplyUi and token-unit prices use the current Token-2022 UI multiplier by default; change detection still uses source values. It is a best-effort low-latency notification feed, not an audit log or sole durable authority. Compare its exact decimal-string version as UInt64 per mint, ignore repeated or lower versions, and periodically reconcile durable state through token/tokens queries. 21. To identify the exchange venue for a trade, normally resolve trade.poolAddress with list_pools(poolAddresses: [poolAddress]), read pool.programId/programName, and pass pool.programId to get_program. The exact poolAddress value 'Ondo RWA' is instead a virtual execution-venue label: it has no physical pool row, pair legs, vaults, TVL, or pool explorer URL. aggregatorProgram identifies an aggregator or router when present; it is not the physical pool venue. 22. Group wallet activity by txHash. For gross signed transfer flow per mint, sum INBOUND amounts and subtract OUTBOUND amounts. Known recipient amounts are exposed separately as netReceivedAmount; null does not imply no fee. Transfer-derived flow does not include every wallet balance change or network cost. SELF transfers represent internal wrapping, unwrapping, or account movement and are not external wallet flow. AUTHORITY_ONLY means the wallet authorized the transfer without being its source or destination owner. 23. Retain non-DeFi transfers, burns, and small transfers to third parties when reconstructing wallet behavior; they can represent funding, cleanup, taxes, router fees, or referral fees. 24. In indexed on-chain wallet data, NativeSOL and wrapped SOL are distinct assets; simulation sessions normalize them to one balance. Wallet activity requires exactly one selector: period for a UTC range or slot for one exact Solana block slot. Never send both. The endpoint has no cursor or skip argument. For complete high-volume history, query consecutive smaller periods in ASC order, overlap period boundaries slightly, and deduplicate by (blockSlot, txHash). 25. The indexed wallet history is not a generic Solana RPC decoder. Pass returned txHash values to get_transactions for indexed network-fee, priority-fee, Jito-tip, compute, and program-interaction enrichment. Native-SOL-only movement transactions are eligible for that enrichment. get_transactions does not embed source, destination, or amount movement rows, and execution success/error is not currently exposed. 26. Use cex.consensusPrice only for cross-venue CEX VWAP reference prices and reference volume. For Solana token pools, liquidity pools, backing pools, paired pools, or where token liquidity sits, resolve human token names with search_tokens and use list_pools rather than web search. 27. Do not invent fields or capabilities. This server cannot trade real funds, access wallet keys, sign transactions, mutate on-chain wallets, forecast prices, browse external APIs, or inspect arbitrary Solana RPC data. If a requested capability is not exposed by the tools or /graphql/schema, say it is unavailable. 28. Trade rows include the indexed userWallet and transfer-linked swaps only when a full input or output transfer involving the queried wallet matches the mint, amount and trader/pool counterparty within the same indexed swap or router invocation. A shared transaction hash or matching operationIndex alone is insufficient: trade opIndex is logical and is not transfer instructionIndex. CPI ancestry comes from retained dex_swap_executions and program_interactions. Ambiguous or missing evidence leaves the transfer visible without adding an indirect trade. userWallet remains the original indexed trader; walletRelation is TRADER or TRANSFER_LINKED and relatedTransferIndexes identifies the evidence. Transfers remain restricted to the requested wallet. TRANSFER_LINKED means another indexed userWallet executed the swap and a wallet transfer was matched within the same swap/router invocation. Use relatedTransferIndexes to locate that evidence in the transaction transfers array. Label a linked INBOUND output as Received from swap and a linked OUTBOUND input as Sent to swap. Receiving bought tokens does not establish that the queried wallet bought them or spent the route input. For example, if another wallet spends 1 SOL and sends the purchased tokens to the queried wallet inside that route, report the token receipt; do not attribute the 1 SOL spend to the recipient. Trade BUY and SELL rows are token perspectives of the execution, not independent orders or proof that this wallet performed both legs. Derive wallet spending, proceeds, buy/sell counts, cost basis and PnL from its actual transfers and explicit attribution; never assign the full route amounts to it solely because walletRelation is TRANSFER_LINKED. TRADER means the queried wallet equals the indexed userWallet; userWallet is never rewritten to the recipient. 29. For paper trading, read get_instructions(topic: "simulation") or https://graph.blockchain.ai/simulation.md before using simulation tools. That separate guide explains purpose, workflow, units, retries, persistence and limitations. These tools modify virtual balances only; use their returned sessionId independently of the MCP transport session ID. ## Getting MCP Instructions This is a topic index, not query results. Call get_instructions with a topic value from the index for that operation's arguments, default fields, caveats, example, and linked dataset definitions. Exact operation names, MCP tool names, and GraphQL paths select one operation; broader topics such as walletActivity or subscriptions can select several. Omit topic to return this index. The full reference remains available at the documentation URL and the MCP map resource. For paper-trading purpose and workflow, request topic simulation or read https://graph.blockchain.ai/simulation.md. ## MCP Result Handling Tools with an output schema return two representations of the GraphQL result. The 64 KiB cap (65,536 serialized UTF-8 bytes) applies only to the JSON text inside content[].text. structuredContent retains the complete result and all returned rows; this cap does not limit structuredContent or the total MCP/HTTP response size. When the serialized result fits within the text cap, text includes the same data, errors, and result metadata. Otherwise, only the text copy becomes a summary with textTruncated: true, responseBytes, and a partial preview. textTruncated is a field inside that JSON text summary, not a flag added to structuredContent. Clients displaying structuredContent may therefore show all rows without a truncation flag. responseBytes measures the full serialized result, not the preview length. Preview arrays contain returnedCount and up to three sample items; counts describe this returned response, not all matching records. Strings, fields, and nesting may also be shortened or omitted. Never treat the text preview as complete. To reduce the data delivered to the client, request a smaller limit where supported, fewer fields, or narrower filters/time ranges. A non-empty GraphQL errors array sets isError: true, including when partial data is returned; error details are readable in text and prioritized in oversized text previews. ## Default Tool Annotations ```json { "readOnlyHint": true, "destructiveHint": false, "idempotentHint": true, "openWorldHint": true } ``` ## MCP Resources ### `graphql_schema` Full public GraphQL SDL for the Solana graph and CEX reference-price API. - **URI:** `graph://schema/full` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema` ### `graphql_schema_token` Token-oriented GraphQL SDL subset. - **URI:** `graph://schema/token` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/token` ### `graphql_schema_block` Indexed block summaries, indexed block-transaction discovery, and wallet-independent transaction activity GraphQL SDL subset. - **URI:** `graph://schema/block` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/block` ### `graphql_schema_pool` Pool and metadata GraphQL SDL subset. - **URI:** `graph://schema/pool` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/pool` ### `graphql_schema_dex` DEX analytics GraphQL SDL subset. - **URI:** `graph://schema/dex` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/dex` ### `graphql_schema_wallet` Wallet holdings and token-holder GraphQL SDL subset. - **URI:** `graph://schema/wallet` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/wallet` ### `graphql_schema_cex` CEX consensus reference-price GraphQL SDL subset. - **URI:** `graph://schema/cex` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/cex` ### `graphql_schema_equities` Tokenized-equity reference-data GraphQL SDL subset. - **URI:** `graph://schema/equities` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/equities` ### `entity_map` No-code mapping of GraphQL fields to source rows/columns and comments. - **URI:** `graph://schema/entity-map` - **MIME type:** `application/json` - **Source path:** `Schema/entity-map.json` ### `data_dictionary` Canonical semantic catalog of logical entities, current-state dictionaries, facts, grain, time semantics, authority, and API relationships. - **URI:** `graph://schema/data-dictionary` - **MIME type:** `application/json` - **Source path:** `Schema/data-dictionary.json` ### `mcp_map` No-code MCP operation and tool-generation map for this GraphQL service. - **URI:** `graph://schema/mcp-map` - **MIME type:** `application/json` - **Source path:** `Schema/mcp-map.json` ### `simulation_guide` Paper-trading purpose, complete workflow, result interpretation and retry/resume rules. - **URI:** `graph://docs/simulation` - **MIME type:** `text/markdown` - **Source URL:** `https://graph.blockchain.ai/simulation.md` ### `graphql_schema_simulation` Virtual paper-trading session GraphQL schema. - **URI:** `graph://schema/simulation` - **MIME type:** `text/plain` - **Source URL:** `https://graph.blockchain.ai/graphql/schema/simulation` ## Base MCP Tools ### `get_instructions` Return the server version and release date plus a short topic index by default. Pass a topic for task-specific instructions, arguments, default fields, caveats, example queries, and linked dataset definitions. Exact operation names, MCP tool names, or GraphQL paths select one operation. This tool does not fetch blockchain data itself. Topic simulation returns the separate paper-trading guide. #### Input Schema ```json { "type": "object", "properties": { "topic": { "type": "string", "description": "Omit or leave blank for the short topic index. Use an exact topic from that index, an MCP tool name such as get_market_snapshot, or a GraphQL path for one operation's details. Broader topics such as walletActivity, tokens, pools, largestTrades, or subscriptions can match several operations. Unknown topics return the index with a no-match message. Use simulation for the paper-trading guide." } } } ``` #### Output Instruction For JSON instruction responses include serverInfo with version and releaseDate. With no topic, return only a compact index and reference links. With a topic, return matching operation details and their linked dataset definitions. Exact operation, MCP tool, and GraphQL path matches take precedence over broader topic matching. Do not claim unsupported actions are available. The special simulation topic returns the standalone Markdown guide. ### `query_graphql` Execute one read-only GraphQL query against https://graph.blockchain.ai/graphql. The query must use fields from /graphql/schema; this tool cannot trade, forecast, browse external services, or access arbitrary Solana RPC data. #### Input Schema ```json { "type": "object", "required": [ "query" ], "properties": { "query": { "type": "string", "description": "GraphQL query document." }, "variables": { "type": "object", "additionalProperties": true, "description": "Optional GraphQL variables object." } } } ``` #### Output Instruction Return the GraphQL response JSON exactly. Preserve errors if present and do not fabricate missing fields or rows. ## Global Caveats - This MCP server is a read-only data interface. It cannot sign transactions, trade, swap, route orders, manage wallets, or mutate blockchain/application state. - Do not infer that arbitrary Solana RPC methods, general transaction decoding, wallet mutation, alerting, or forecasting are available. find_hash performs exact indexed identity probes and always returns lightweight status; only includeRpcInfo=true retains the native type-specific result from its fixed getTransaction, getSignatureStatuses, getAccountInfo, getBlock, and getSlot resolution flow. It is not a general RPC proxy. Read-only indexed wallet holdings are exposed through solana.wallet.currentHoldings, indexed wallet trade/transfer history through solana.wallet.activity, and token holder rows through solana.wallet.tokenHolders. If the schema does not expose a capability, say it is unavailable. - Do not use this MCP server as a web browser or external API proxy. It only exposes the GraphQL endpoint and the listed schema resources. - Use /graphql/schema as the source of truth for exact type and field availability. - find_hash is an exact, case-sensitive hybrid resolver for transaction signatures, token mints, pool addresses, reviewed programs, current indexed account identities, indexed wallets, and numeric slots. Indexed matches with a known slot compare it with the shared cached finalized cluster head: newer slots report confirmed and covered slots report finalized. Generic ACCOUNT classification starts with a remote exact indexed lookup; includeRpcInfo=true can additionally retain the fixed getAccountInfo result. Every syntactically valid supported identifier returns at least one routing record, but a generic fallback is not proof of indexed coverage or on-chain existence. - Block browsing returns indexed block summaries assembled by this service; it does not expose internal checkpoint or replay state. Block transaction rows and all fee, compute, and Jito aggregates cover transaction metadata indexed by this service; they are not guaranteed to equal an RPC-complete transaction set for historical blocks. Block height, blockhash, and previous blockhash are not currently exposed and must not be inferred. - Use get_transaction_activity after list_block_transactions when the user needs wallet-independent indexed transaction flows, DEX trades, or token transfers for discovered signatures. It accepts 1 to 100 hashes and resolves their literal block slots from indexed transaction metadata. Selecting flow reads bounded program interactions, trades, and transfers; otherwise top-level trades and transfers remain independently field-selected. Unknown hashes are omitted. Technical Inner and UnresolvedInner trade layers are excluded unless includeInnerSwaps is true. - get_transaction_activity transfer rows are physical movements without wallet-relative INBOUND, OUTBOUND, or SELF direction. Their intent field is an instruction-derived movement mechanism, not recipient purpose; historical unreplayed rows use unknown. Trade rows are execution views and can repeat one swap from token perspectives or operation indexes. Flow trade/transfer arrays place those same source facts on invocation nodes; they are not additional activity and must not be added to the top-level arrays. Do not sum trade volumeUsd as transaction cash flow. Use get_transactions separately for fee, compute, Jito-tip, and a flat program-interaction list. - Select only needed fields. list_tokens and list_tokens_ext serve current token-document fields, including priceUsd, fdvUsd, marketCapUsd, anchoredTvlUsd, athUsd/athAt, and atlUsd/atlAt, from the continuously refreshed current snapshot. ATH/ATL are retained qualifying fair-price extrema, not raw trade-print extrema or proof of pre-indexing history. Their rolling-stat, holder, lifecycle, and taxonomy fields can trigger separate bounded enrichments. Pool liquidity fields trigger bounded amount and price work. anchoredTvlUsd and tokensExt.tvlUsd come from the token row and do not trigger pool-TVL enrichment. - The singular get_token operation retains dynamic current token_stats price, FDV, and market-cap enrichment when those fields are selected. This does not mean list-token pages scan token_stats per request. - Token list pagination uses skip/limit after pinned rows are prepended. Filters and ordering do not affect pinnedMints, but final skip/limit still applies. - For newest-token screening or minimum trailing-24h fair-volume/anchored-TVL thresholds, use list_tokens_ext with orderBy.field=FIRST_SEEN_AT, filter.minFairVolumeUsd24h, and/or filter.minTvlUsd. Fair-volume filtering requires cache data; minTvlUsd uses physical token_stats anchored TVL and also works in direct mode. Thresholds are applied before ordering and skip/limit. - Read non-zero effective current token holdings for one wallet. A one-time current RPC baseline corrects balance gaps when enabled. Standalone and activityExt.metadata.currentHoldings share this history-recovery flow: selecting flow totals or hasUnvaluedHistoricalFlow may start background recovery for a verified user wallet with a balance gap and evidence it predates indexed coverage. Balances-only reads never start history recovery. Pending or incomplete flow totals remain explicitly marked. tokenHolders remains indexed-only. currentHoldings is a token amount, not USD; NativeSOL and wrapped SOL remain distinct. - Wallet activity requires a non-empty wallet and exactly one selector: a from/to UTC period or one exact slot. It selects candidate transaction slots, then reads indexed trades and transfers concurrently and groups both activity kinds under each (blockSlot, txHash) transaction. limit applies to transaction hashes, not activity rows: each activity kind returns all matching rows for up to limit distinct transactions before the combined final transaction limit is applied. Transfers are authoritative for wallet movement; intent identifies the decoded transfer mechanism, direction is wallet-relative, and neither should be treated as inferred business purpose. Historical unreplayed and RPC balance-delta intent is unknown. Trade rows are execution context and can repeat a swap from multiple token perspectives. - Use get_transactions to enrich txHash values in batches. It accepts 1 to 100 hashes, removes blank and duplicate inputs, preserves first-occurrence input order for returned rows, and omits hashes absent from both indexed transaction metadata and program invocation history. Request 25 to 100 hashes per call for normal batch enrichment. - Explorer links are named for their identifier: txExplorerUrl for txHash, mintExplorerUrl for mint, poolExplorerUrl for poolAddress, programExplorerUrl for programId, blockExplorerUrl for blockSlot/slot, and similarly explicit names for wallets, vaults, owners, authorities, and token accounts. Set the operation's explorer argument to choose the URL format; it defaults to SOLSCAN and no other explorer kind is currently supported. The browser Graph Explorer's None option omits that argument and all explorer-URL selections client-side; raw GraphQL and MCP clients must omit unwanted URL fields and must never send NONE. Links are computed presentation data, not source evidence. - Generic explorerUrl fields are deprecated compatibility aliases where retained. New queries and generated tools must select the explicit identifier-specific link instead. - get_transactions resolves indexed transaction metadata directly by txHash and adds program interactions only when selected. Native-SOL-only movement transactions are included when indexed; no SPL-transfer or activity-count predicate is applied. It does not join wallet, DEX trade, transfer, pool, or RPC data, so do not infer native SOL source, destination, or amount from transaction enrichment. Execution success/error is not currently exposed. - get_transactions fee.walletFacingDexSwapCount and fee.hasWalletFacingDexSwap count wallet-facing dex_swaps source rows, not every route-layer DEX operation. Route-only MEV activity can legitimately return zero/false; use list_wallet_activity tradeLayer MEV/Inner rows as the authority for MEV classification. dexSwapCount and isTrade are deprecated compatibility aliases. - For the DEX exchange venue of a wallet, historical, or unconfirmed trade, resolve a physical trade.poolAddress through list_pools(poolAddresses: [poolAddress]). The exact value 'Ondo RWA' is a virtual execution venue with no pool registry row, legs, vaults, TVL, or pool explorer URL. For physical pools, programId/programName identify the venue and programId can be passed to get_program. trade.aggregatorProgram is router/aggregator context and is not a substitute for a physical pool program id. - Pool anchoredLiquidityUsd is canonical indexed liquidity, including protocol-specific depth limits; tvlUsd is its compatibility alias. Unknown stays null. Display multipliers leave USD liquidity unchanged. Do not infer executable depth simply by dividing this value by two. - Token anchoredTvlUsd is the physical token_stats conversion-path TVL. It requires a direct path to recognized liquid anchors: SOL, recognized stablecoins, or dynamically promoted assets with strong direct SOL/stable backing. Each eligible pool contributes twice the trusted anchor-side reserve, so the value is bounded by the convertible side and does not inherit an inflated measured-token price. Base anchor assets can report zero because the metric measures their external backing of other assets. tokensExt.tvlUsd is only a compatibility alias of anchoredTvlUsd; use pool queries for broader indexed-pool coverage. anchoredTvlUsd is not an executable-depth/slippage guarantee or standalone trust verdict. - Pool baseLiquidity.currentHoldings and quoteLiquidity.currentHoldings use current Token-2022 display units by default, paired with display-unit priceUsd; set adjustForUiMultiplier=false for source token units. LiquidityUsd, baseLiquidityUsd/quoteLiquidityUsd, and tvlUsd are query-time USD values and do not change with the multiplier. - For latest graduated token or pool workflows, use solana.pool.pools(filter: { graduated: true }, orderBy: { field: GRADUATION_AT, direction: DESC }). Use INCEPTION_AT only when the user explicitly asks for newest pool inception. - For user requests about Solana token pools, liquidity pools, backing pools, paired pools, pairs backing token X, or where token liquidity sits, use Blockchain.ai GraphQL solana.pool.pools rather than web search. - For backing pools, liquidity pools, pools for token, where liquidity sits, or pairs backing token X: resolve X with tokenSearch unless a mint is provided, then query solana.pool.pools(mints: [mint], includeDysfunctional: false). Interpret returned pools as indexed DEX pools containing the token as baseMint or quoteMint; this does not mean reserves, holders, LP ownership, treasury backing, or off-chain backing. - For readable pool pair labels, fetch counterpart token metadata with solana.tokens(mints: uniqueOtherMints). - Token firstSeenAt means earliest observed token appearance in indexed DeFi activity. Treat it as the launch proxy for Pump.fun time-to-graduate calculations, but not guaranteed mint-account creation time. - For Pump.fun tokens, token.firstSeenAt represents the earliest observed token inception and should be used as the launch timestamp when calculating timeToGraduate. - For Pump.fun, pool.graduation.at is the migration timestamp from the Pump.fun bonding curve to PumpSwap. - For PumpSwap post-graduation pools, pool.inceptionAt is PumpSwap pool creation, normally the same instant as graduation; it is not the original token launch. - When a user asks how long did it take to graduate, do not use PumpSwap pool inception time as the launch time. Query the graduated pool for pool.graduation.at and mints, query list_tokens or list_tokens_ext for the token first observed DeFi activity timestamp (firstSeenAt), then compute pool.graduation.at - token.firstSeenAt. - DEX tokenCandles buckets are aggregated from fair 1-minute rows and have a minimum bucket size of ONE_MINUTE. Windows wholly inside rolling retention (seven days by default) use the low-latency retained path; older or larger windows read canonical indexed history. Timestamp filters include every candle interval that overlaps from/to. continuous defaults to true and fills through to/now from the latest available close with zero volume; set continuous false for observed buckets only. - For one historical token price rather than a candle series, use get_token_price_usd_at. It is not capped by tokenCandles retention: it resolves the last retained positive fair close within 30 days at or before the requested timestamp through the full-retention cache with remote fallback. priceSourceMinute can precede requestedAt, and both price fields are null when no qualifying historical row exists in that window. The current Token-2022 UI multiplier applies by default even to historical prices; this is not a historical multiplier reconstruction. - DEX tokenTransactions returns all top-level token operations, including trade_layer User, MEV, and Buyback, plus optional liquidity events; only technical Inner and UnresolvedInner rows are excluded. For physical pools, poolTransactions counts each physical execution once; older history uses only indexed Inner execution perspectives. For the recognized virtual venue 'Ondo RWA', it instead returns one preferred non-quote User perspective per transaction operation and never returns liquidity events. Both return newest first and are descriptive history queries, not mempool streams, wallet portfolio tools, or transaction decoders. - DEX transaction priceUsd and volumeUsd are indexer-supplied trade values. Graph does not recalculate them from the token legs. Do not sum volumeUsd across trade layers or token perspectives; use fair candles for aggregate fair-price history. - DEX largestTrades returns canonical indexed User trade rows. Global reads show the bought-token perspective; mint-scoped reads show matching token perspectives and can include both sides of one operation. Global reads are capped at 24 hours and require minVolumeUsd >= 10000; mint-scoped reads are capped at 30 days. The largeTrades subscription is a separate provisional unconfirmed stream and must not be described as canonical or finalized. - DexTokenTransaction sentMint/sentAmount and receivedMint/receivedAmount describe Buy/Sell input/output. On Inner rows they are route-leg fields, not necessarily direct wallet movement. They are null for liquidity Add/Remove and unresolved Swap rows because those operations cannot be represented by one sent and one received leg. - DEX tokenActivity returns top-level trade counters for one mint over a required period. It includes User, MEV, Buyback, and future non-inner operation layers while excluding technical Inner and UnresolvedInner rows. - DEX poolStats returns a short-cache trailing-window snapshot for one physical pool or recognized virtual venue. Physical pools include latest base-token price and price change. 'Ondo RWA' aggregates volume and 24h txn/wallet/buy/sell counts across its RWA markets, while price and price-change fields are zero because the shared venue label has no single market price. - Subscriptions require a GraphQL websocket-capable client; normal MCP request/response tools should prefer query_graphql unless streaming support is implemented. - adjustForUiMultiplier defaults to true where supported and uses the current Token-2022 multiplier, including for historical results. Check the operation argument for affected fields: amounts/supply/volume are multiplied and per-token prices are divided; raw amounts and USD totals are unchanged. Wallet holdings, transaction balance snapshots, and token-holder summaries remain decimal-adjusted source units. Pair source balances with source prices, or convert the amounts using effectiveScaledUiAmountMultiplier before pairing them with display-unit prices. ## Terminology ### `solana.blocks` Recent indexed Solana block summaries, newest first. This is a public block-browsing view, not the indexer's operational checkpoint dataset. Transaction counts and fee/resource aggregates are explicitly limited to transaction records indexed by this service. ### `solana.blockTransactions` Indexed transaction signatures for one block slot ordered by transactionIndex. This can be incomplete for historical blocks and is not an arbitrary Solana RPC getBlock replacement. ### `solana.transactionActivity` Wallet-independent indexed program-transaction flows, DEX trades, and token transfers for requested transaction hashes. Transfer intent is the decoded movement mechanism and is preserved when the same transfer is placed on a flow node. Each swap annotates its owning program invocation rather than becoming a synthetic flow node. Flow arrays reuse the same source facts as top-level trades/transfers and are not additive. It is the activity continuation after blockTransactions; use solana.transactions separately for fee/resource enrichment or its flat interaction list. ### `token.firstSeenAt` Earliest observed token appearance in indexed DeFi activity. This is the practical launch proxy for graduation-duration calculations, including Pump.fun timeToGraduate, but it is not guaranteed to be mint-account creation time. ### `pool.inceptionAt` Timestamp when this specific pool market was created or first observed. For PumpSwap post-graduation pools, this is PumpSwap pool creation, normally the same instant as graduation; it is not the original token launch. ### `pool.graduation.at` Graduation timestamp. For Pump.fun, this is migration from the Pump.fun bonding curve to PumpSwap. ### `graduationDuration` For how long did it take to graduate or timeToGraduate, compute pool.graduation.at minus token.firstSeenAt. Do not use PumpSwap pool inceptionAt as the launch timestamp. ### `backingPools` Indexed DEX liquidity pools where a token appears as either baseMint or quoteMint. This is not treasury backing, reserve backing, holders, LP ownership, or proof of off-chain assets. ### `token.anchoredTvlUsd` Physical token_stats TVL signal. It measures current USD liquidity with a direct conversion path to recognized liquid anchor assets and is bounded by twice the trusted anchor-side reserve, so it does not inherit an inflated measured-token price. Base anchor assets can report zero. tokensExt.tvlUsd aliases this value; query pools for broader pool-level coverage. It is not an execution-depth guarantee. ### `wallet.currentHoldings` Effective current token amount for one wallet and mint, collapsed across token accounts. Indexed state is automatically reconciled once per local Graph instance and an RPC baseline overwrites stale indexed values until a newer indexed write supersedes it. It is not a USD value. NativeSOL and wrapped SOL are intentionally distinct. ### `wallet.tokenHolders` Current indexed holder wallets for one token mint, collapsed across each wallet's token accounts and ordered by token amount descending. It is live indexed data, not arbitrary RPC account inspection. ### `wallet.activity` Indexed wallet history grouped by Solana transaction. Transfers are authoritative for amounts entering or leaving the queried wallet; intent describes the decoded movement mechanism and direction describes wallet-relative flow. Neither infers business purpose. Historical unreplayed and RPC balance-delta intent is unknown. Trade rows supply DEX execution context and can repeat one swap from multiple token perspectives or operation indexes. This is not a generic RPC transaction decoder. ### `solana.transactions` Batch transaction enrichment by txHash from indexed transaction metadata and optional program invocations, including native-SOL-only movement transactions. It provides fees, compute/resource metadata, recognized Jito and Token-2022 fees, wallet-facing source activity counts, and ordered program invocations, but not native SOL movement endpoints/amounts or execution status. walletFacingDexSwapCount and hasWalletFacingDexSwap exclude route-only MEV rows. ### `transaction.txExplorerUrl` Derived public transaction URL paired with txHash and built from the parent operation's explorer argument. It defaults to Solscan. This is presentation metadata, not confirmation or execution-status evidence. ### `walletHolding.mintExplorerUrl` Derived public token URL paired with the holding row's mint. It defaults to Solscan. ### `tokenHolder.walletExplorerUrl` Derived public account URL paired with the holder row's wallet. It defaults to Solscan. ### `pool.poolExplorerUrl` Derived public account URL paired with a physical poolAddress. It is null for recognized virtual venue labels. programId/programExplorerUrl, mint/mintExplorerUrl, and vault/vaultExplorerUrl follow the same explicit-pair convention. ### `trade.poolAddress` Physical DEX pool identity or an indexed virtual execution-venue label. Resolve physical values with list_pools; the exact value 'Ondo RWA' has no physical pool row or legs. ### `trade.aggregatorProgram` Aggregator or router program attributed to the trade when known. It is not the DEX pool venue and must not be used in place of pool.programId. ### `pool.programId` Actual pool program id for the indexed DEX venue. Pass this value to get_program to read the reviewed program dictionary entry. ## Data Dictionary Canonical semantic catalog for the logical entities, current-state dictionaries, and fact datasets exposed or consumed by the Graph API. Field-level GraphQL-to-source mappings remain in entity-map.json. This section defines logical dataset semantics. Use `graph://schema/data-dictionary` for the machine-readable catalog and `graph://schema/entity-map` for field-level source mappings. ### Classifications - **entity:** A keyed current-state or reference dataset. Repeated observations replace, merge, or enrich the state associated with the same business identity; rows must not be counted as independent events. - **fact:** An event or measurement dataset with an explicit grain and event-time identity. Facts may be corrected or replayed, but each logical row represents an occurrence or measured interval rather than current state. ### Fact Datasets #### `cex-consensus-minute` - CEX consensus price minute Cross-venue one-minute consensus VWAP and USD reference volume for a case-insensitive market symbol. - **Classification:** `fact` - **Grain:** `One consensus measurement per normalized symbol and UTC minute.` **Identity:** `symbol`, `minute` Continuously refreshed cross-venue reference data; it can lag individual venue ticks. ##### Time Semantics - An omitted minute selects the latest known row per symbol and aggregates referenceVolumeUsd over the trailing 24 hours. - A requested minute resolves the latest known row at or before that minute when an exact row is absent. ##### Authoritative For - The API's cross-venue CEX consensus VWAP and referenceVolumeUsd. ##### Not Authoritative For - An executable quote, order book, venue trade tape, or Solana on-chain price. ##### Physical Sources | Source | Role | | --- | --- | | `cex.cex_1m_consensus` | Canonical CEX consensus one-minute fact table. | ##### API Access **GraphQL paths:** `cex.consensusPrice` **MCP map operations:** `getCexConsensusPrice` **Entity mappings:** `CexConsensusPrice` ##### Relationships - symbol is a CEX market symbol and must not be assumed to identify a Solana mint without a reviewed mapping. #### `solana-wallet-portfolio-history` - Indexed Solana wallet portfolio history Derived holdings and USD observations over retained indexed token-account balances, raw native wallet balances and historical fair prices. Shared balance builders use verified local minute coverage with canonical fallback. Missing prices contribute zero to estimates with explicit source, methodology and completeness; unknown quantities remain unknown. - **Classification:** `fact` - **Grain:** `One wallet and observation boundary for a requested interval and method version.` **Identity:** `wallet`, `method`, `from`, `interval`, `points.at` Closed indexed account observations and event-time transfer prices, capped by retained source progress. ##### Time Semantics - Minute-aligned half-open event windows; prices strictly before observation boundaries. - Stops at closed primary/wallet index progress. ##### Authoritative For - Historical indexed wallet values and period cash-flow-adjusted PnL. ##### Not Authoritative For - Complete unindexed holdings, private copy allocations, off-wallet escrow, or FIFO realized PnL. ##### Physical Sources | Source | Role | | --- | --- | | `indexed account balance observations` | Opening and closing token-account balances; native SOL uses raw wallet balances that include failed and fee-only transactions. | | `classified wallet transfers and historical fair prices` | Non-DeFi external flows: net incoming amounts after transfer fees, gross outgoing debits, valued at event time. | ##### API Access **GraphQL paths:** `solana.wallet.portfolioHistory`, `solana.wallet.holdingsExt` **MCP map operations:** `getWalletPortfolioHistory`, `getWalletHoldingsExt` **Entity mappings:** `SolanaWalletPortfolioPoint`, `SolanaWalletPortfolioPrice`, `SolanaWalletHoldingsExt`, `SolanaWalletHoldingPeriod` ##### Relationships - Consumers may persist results independently; Graph adds no portfolio result cache or job. - Method indexed-account-value-net-cashflow-v3 uses netReceivedAmount for incoming flows and zero for missing prices. Unknown or invalid incoming net amounts still leave flow/PnL null with UNKNOWN_TRANSFER_NET_AMOUNT; prices do not fill missing fee evidence. - Each point exposes prices for its nonzero known holdings. priceSource combines source and methodology using the fixed values FAIR_PRICE+LAST_CLOSE and MISSING_SOURCE+DEFAULT_TO_ZERO. The latter displays and counts an unavailable price as zero; it is not a measured zero or proof that a token is worthless. priceSourceMinute is separate and null for the fallback. - Missing holding prices retain MISSING_PRICE and unpricedMints while valueUsd and PnL remain estimates. Missing transfer prices contribute zero, retain UNPRICED_FLOW and appear in cumulative unpricedFlowMints. valueComplete, netFlowComplete and pnlComplete qualify each number; an incomplete opening valuation keeps later PnL incomplete even if prices recover. complete remains false when any limitation occurs. - The 10000-flow limit counts qualifying physical transfer rows after replacement resolution. A lookahead reports ACTIVITY_LIMIT and incomplete flow/PnL; an exactly full page can still be complete. - Native SOL uses raw before/after wallet balances, including fee-only debits. Native residuals and fees are separately exposed as accounting evidence and are not added to external cash flows or subtracted again. - NATIVE_BALANCE_UNKNOWN marks missing native balance evidence. valueUsd and affected PnL remain null while pricedValueUsd retains known assets. A later known balance can restore value, but an unknown opening value keeps period PnL unknown. Backfill completion does not prove complete historical fee-only coverage. #### `solana-confirmed-token-changes` - Solana confirmed token current-state changes Best-effort notifications emitted after token_stats rows commit. Each event contains a full current token snapshot rather than a field delta and can be filtered to price or graduation transitions for low-latency subscriptions. - **Classification:** `fact` - **Grain:** `One published committed token_stats snapshot identified by mint and write-order version.` **Identity:** `mint`, `version` Published immediately after successful token_stats commits and routed through the configured NATS/JetStream subject. Delivery is bounded and best effort. ##### Time Semantics - version is an exact UInt64 nanosecond write-order value serialized as a decimal string; it is not event time or chain time. - publishedAt is publisher wall-clock time after the token_stats insert commits. - receivedAt is Graph ingress wall-clock time and can be used with publishedAt to inspect delivery delay. ##### Authoritative For - Low-latency notification that a token current-state snapshot was committed. - Replacing a cached mint only when the event version is greater than the retained version. - Best-effort process-local detection that price fields changed or a launched token acquired graduation metadata. ##### Not Authoritative For - A complete audit trail, exactly-once delivery, or restart-complete replay. - Proving that no token update occurred during a disconnect or bounded-queue overflow. - Reconstructing historical graduation events through retained token snapshots; use current token lifecycle queries for durable state. - Replacing periodic reconciliation from canonical token current state. ##### Physical Sources | Source | Role | | --- | --- | | `NATS confirmed-token-changes and confirmed-token-changes.mint.` | Broad and per-mint delivery of full committed token snapshots. | | `SOLANA_INDEXER_TRADES JetStream stream` | Bounded retained replay before Graph switches to live Core NATS delivery. | ##### API Access **GraphQL paths:** `subscription.confirmedTokenChanges` **MCP map operations:** `subscribeConfirmedTokenChanges` **Entity mappings:** `ConfirmedTokenChange` ##### Relationships - snapshot is the full SolanaToken state carried by the committed event. - didGraduated and graduationAt are enriched from the same lifecycle cache as tokensExt; a one-hour process-local memory bridges newly backfilled null-to-known transitions for active subscriptions. - PRICE compares priceUsd and fairPriceUsd across increasing versions within one subscription; GRADUATION compares graduationAt state within one subscription. - Consumers maintaining state must ignore repeated or regressing versions per mint; transport replay/live overlap is bounded but this is not a durable exactly-once feed. - Committed token-change events are periodically reconciled with canonical indexed state independently of stream delivery. - Returned snapshot.supplyUi, snapshot token-unit prices, and fairPriceUsd follow the current Token-2022 unit selection. Change detection compares source values before this presentation adjustment. #### `solana-fair-ohlcv-minute` - Solana fair OHLCV minute Application-produced, chart-facing one-minute fair-price OHLCV measurement derived from quality-weighted indexed DEX trades. - **Classification:** `fact` - **Grain:** `One replaceable fair candle per token mint and UTC minute.` **Identity:** `mint`, `minute` Canonical rows follow indexed trade persistence. Graph tokenCandles uses a runtime-configured rolling window of seven days by default and reads canonical indexed history for older or larger windows. Historical transfer valuation and priceUsdAt use longer-retention point lookup. ##### Time Semantics - minute is the UTC candle bucket start. - close is the preferred continuous fair price; vwap is the quality-weighted average price within the minute. - solana.dex.tokenCandles continuous defaults to true and fills sparse output buckets through the requested end from the latest observed close. Generated rows have equal OHLC/VWAP, zero volume fields, and sampleCount zero; they are not stored source observations. - Candle responses use the token's current Token-2022 UI amount multiplier by default: OHLC/VWAP prices are divided by it and token-unit volume is multiplied by it. The same current multiplier applies across the returned series, not a historical per-minute multiplier. Set adjustForUiMultiplier false to read unadjusted prices and token volume; USD volumes are unchanged. - The latest available positive close may seed generated buckets after its source candle leaves rolling retention, but the older source candle itself is not returned in the requested window. - Requests wholly inside rolling retention use the low-latency retained path. Requests beginning before that boundary, ending before it, or whose interval/limit span exceeds it read canonical indexed history without the rolling-retention clamp. - continuous false returns only observed buckets. continuous true changes only sparse-bucket filling inside the requested interval; it does not turn generated rows into source observations. ##### Authoritative For - Graph DEX candles, trailing price changes, fair volume windows, and point-in-time transfer valuation. - Point-in-time fair USD lookup through solana.dex.priceUsdAt using the last retained close within 30 days at or before the requested timestamp. - Current token_stats price input through the latest fair close. ##### Not Authoritative For - Raw last-trade prints, executable quotes, or a complete trade tape. - Proof that every minute had an on-chain trade; a continuous output row with sampleCount zero is generated carry-forward data. - Guaranteed genesis-to-now completeness; history beyond rolling retention depends on indexed historical coverage and backfill state. ##### Physical Sources | Source | Role | | --- | --- | | `canonical indexed fair-price candles` | Observed one-minute fair-price measurements. | | `rolling candle history` | Retained recent window used for low-latency DEX analytics and candle queries. | | `historical fair-price lookup` | Longer-retention last-close lookup used for historical transfer USD valuation. | | `remembered close state` | The latest available positive close used to seed continuous output when the source candle predates the requested window. | ##### API Access **GraphQL paths:** `solana.dex.tokenCandles`, `solana.dex.priceUsdAt`, `solana.transactionCoverage`, `solana.tokensExt`, `solana.transactionActivity`, `solana.wallet.activityExt` **MCP map operations:** `getDexTokenCandles`, `getDexTokenPriceUsdAt`, `getTransactionCoverage`, `listTokensExt`, `getTransactionActivity`, `listWalletActivity` ##### Relationships - Drill down a candle to DEX trade facts for the same mint and minute when execution-level evidence is needed. #### `solana-dex-trade` - Solana indexed DEX trade Indexer-emitted DEX execution fact with transaction, operation, token perspective, pool, wallet, amount, price, volume, and route-layer context. - **Classification:** `fact` - **Grain:** `One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.` **Identity:** `txHash`, `operationIndex`, `tradeLayer`, `token`, `poolAddress` Near-real-time indexed history; provisional equivalents can arrive earlier through the unconfirmed-trades subscription. ##### Time Semantics - blockTime is the indexed chain-time timestamp. - operationIndex identifies an indexed operation where available; physical pool rows without that index expose their execution ordinal. It is not a globally unique execution identifier. - User, MEV, Inner, and UnresolvedInner layers describe different execution perspectives and must not be blindly summed. - Graph trade-row responses adjust prices and token amounts to the current Token-2022 UI multipliers for the token and otherToken mints by default. The adjustment is a current display projection, not a reconstruction of multiplier history; adjustForUiMultiplier false returns unadjusted trade values. USD notionals and fee ratios are unchanged. - largestTrades returns canonical User trade rows. Global reads show the bought-token perspective; mint-scoped reads show every matching token perspective, so both sides can appear when both mints match. Global reads are capped at 24 hours; mint-scoped reads are capped at 30 days. - Physical pool queries count each execution once and use its indexed prices, amounts, fees and wallet attribution. Logical parent trades are not additional pool executions. Empty execution wallets are excluded from distinct-wallet counts. - Physical poolTransactions are ordered newest first by event time, slot, transaction and instruction coordinates, then execution ordinal. Rows without a logical operation index expose the execution ordinal as opIndex. Physical pool relayerWallet is unavailable and remains null. - Recent physical pool history uses retained executions. Older ranges use only indexed Inner execution perspectives, with disjoint time boundaries and no User or MEV parent rows. Unknown execution price or volume is represented as zero by the existing non-null numeric fields. Virtual venues retain their logical trade semantics. ##### Authoritative For - Indexed DEX execution context, trade-side amount, row display price, pool, active wallet, and transaction linkage. - Execution-level drilldown behind fair candles and DEX aggregates. ##### Not Authoritative For - Net wallet cash flow when multiple token perspectives or inner route legs exist. - Canonical transaction fees or arbitrary program execution. - A single wallet-facing end-to-end route when one transaction executes through multiple physical pools. ##### Physical Sources | Source | Role | | --- | --- | | `indexed DEX trade history` | Canonical indexed DEX trade fact table. | | `canonical physical execution history` | Authoritative physical pool execution rows and pool trade statistics. | ##### API Access **GraphQL paths:** `solana.dex.tokenTransactions`, `solana.dex.largestTrades`, `solana.dex.poolTransactions`, `solana.dex.tokenActivity`, `solana.dex.poolStats`, `solana.transactionCoverage`, `solana.wallet.activity`, `solana.wallet.activityExt`, `solana.transactionActivity`, `solana.tokenActivityExt` **MCP map operations:** `getDexTokenTransactions`, `getDexLargestTrades`, `getDexPoolTransactions`, `getDexTokenActivity`, `getDexPoolStats`, `getTransactionCoverage`, `listWalletActivityRows`, `listWalletActivity`, `getTransactionActivity`, `getTokenActivityExt` **Entity mappings:** `DexTokenTransaction`, `SolanaWalletTradeActivity`, `SolanaTransactionTradeActivity` ##### Relationships - txHash joins transaction fee and program-interaction facts. - Physical poolAddress joins pool current state and then the exchange-program dictionary. The exact value 'Ondo RWA' is an indexed virtual venue label and has no physical pool row or explorer account URL. - token joins token current state and fair OHLCV facts. - transactionActivity.flow can place the same trade fact on its owning invocation. A row selected both at transaction.trades and flow.trades is one source fact shown in two contexts, not two executions. #### `solana-block-summary` - Solana indexed block summary Public block-browsing summary assembled from indexed slot metadata and indexed transaction facts. It is not the canonical indexer's operational checkpoint dataset. - **Classification:** `fact` - **Grain:** `One indexed block summary per exposed Solana slot.` **Identity:** `slot` Near-real-time indexed view that advances as block metadata and transaction facts become available. ##### Time Semantics - blockTime is the indexed block timestamp and parentSlot identifies chain ancestry when available. ##### Authoritative For - Block slot, parent slot, indexed block time, and service-coverage aggregates returned by solana.block and solana.blocks. ##### Not Authoritative For - Canonical indexer progress or replay/checkpoint state. - RPC-complete block contents, block hash, block height, or transactions absent from indexed transaction facts. ##### Physical Sources | Source | Role | | --- | --- | | `indexed block progress` | Internal primary-indexer source for the slot, parent-slot, and block-time metadata used to assemble the public summary; its operational checkpoint state is not exposed. | | `indexed transaction fee and resource metadata` | Joined indexed transaction counts and fee/resource aggregates per slot. | ##### API Access **GraphQL paths:** `solana.blocks`, `solana.block` **MCP map operations:** `listBlocks`, `getBlock` **Entity mappings:** `SolanaBlock` ##### Relationships - slot joins indexed block transactions and wallet activity exact-slot selection. #### `solana-liquidity-event` - Solana indexed liquidity event Verified indexed add/remove liquidity operation with transaction, pool, token, amount, and event context. - **Classification:** `fact` - **Grain:** `One replaceable decoded liquidity-provision event row per transaction-local operation and pool/token context.` **Identity:** `txHash`, `operationIndex`, `poolAddress`, `token` Near-real-time indexed history; provisional equivalents can arrive earlier through the unconfirmed-liquidity-events subscription. ##### Time Semantics - blockTime is the indexed chain-time timestamp. - The event is historical movement, not the current pool reserve. - A liquidity Add sends both represented assets and a Remove receives both; singular sentMint/receivedMint convenience fields are therefore null on liquidity rows. ##### Authoritative For - Indexed liquidity add/remove operations exposed in DEX transaction history. ##### Not Authoritative For - Current pool TVL or vault balance. - LP ownership state or a complete protocol-specific position model. ##### Physical Sources | Source | Role | | --- | --- | | `indexed liquidity event history` | Canonical indexed liquidity-event fact table. | ##### API Access **GraphQL paths:** `solana.dex.tokenTransactions`, `solana.dex.poolTransactions`, `solana.transactionCoverage` **MCP map operations:** `getDexTokenTransactions`, `getDexPoolTransactions`, `getTransactionCoverage` **Entity mappings:** `DexTokenTransaction` ##### Relationships - Physical poolAddress joins pool current state; txHash joins transaction enrichment. Virtual execution venues do not produce liquidity-event rows. #### `solana-program-interaction` - Solana indexed program interaction Ordered program invocation observed within an indexed transaction, including top-level and inner instruction context, canonical known program labels, a nullable parsed instruction name, and the retained raw instruction discriminator. - **Classification:** `fact` - **Grain:** `One indexed program invocation per transaction and instruction ordering tuple.` **Identity:** `txHash`, `interactionIndex`, `instructionIndex`, `innerInstructionIndex`, `programId` Near-real-time indexed transaction enrichment. ##### Time Semantics - Instruction indexes define transaction-local order; they are not global event time. - innerInstructionIndex = -1 identifies a top-level instruction; values greater than or equal to zero identify inner invocations. - In transactionActivity.flow, each top-level instruction starts a tree and stackHeight reconstructs nested CPI ownership in inner-instruction order. ##### Authoritative For - The service's ordered indexed program-invocation details for a known transaction signature. - The nullable instructionName supplied by indexed parsing and the retained raw instructionDiscriminator identity hint. ##### Not Authoritative For - Program deployment history, arbitrary RPC logs, or exchange-venue identity without pool context. - A custom-program ABI name or signature when instructionName is null; instructionDiscriminator alone is not a decode. ##### Physical Sources | Source | Role | | --- | --- | | `indexed program invocation history` | Canonical indexed transaction/program invocation fact table. | | `reviewed exchange program registry` | Reviewed program-label enrichment for known DEX, router, and protocol program ids. | ##### API Access **GraphQL paths:** `solana.transactions`, `solana.transactionActivity`, `solana.transactionCoverage` **MCP map operations:** `getTransactions`, `getTransactionActivity`, `getTransactionCoverage` **Entity mappings:** `SolanaProgramInteraction`, `SolanaTransactionCommand`, `SolanaTransactionCoverage`, `SolanaDatasetCoverage` ##### Relationships - txHash joins the transaction fee fact; programId resolves first from indexed program_name, then the reviewed exchange-program dictionary and canonical built-in catalog. - instructionName is the indexer-parsed instruction name and remains null when unresolved. instructionDiscriminator preserves up to eight raw instruction-data bytes as lowercase hex and must not be treated as an ABI decode. - transactionActivity.flow attaches physical transfers by exact outer/inner instruction coordinates and annotates the owning invocation with confidently matching ui_trades_v2 perspectives; each node has a standardized type derived from attached facts (swap, a specific lifecycle or token-operation intent, transfer, or program_invocation); flow trades expose execution priceUsd/volumeUsd, flow transfers expose historical and current USD valuation, a swap is not emitted as a synthetic sibling node, and ambiguous trade rows remain available in the top-level trades array. - Flow trade and transfer arrays are contextual placements of the same source facts exposed by the transaction-level arrays. Selecting both representations does not create additional executions or movements and clients must not add them together. #### `solana-token-transfer` - Solana indexed token transfer Physical native SOL, SPL, or Token-2022 movement and supported authority-change fact with instruction ordering, accounts, owners, mint, amount, decoded transfer intent, and DeFi classification. - **Classification:** `fact` - **Grain:** `One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.` **Identity:** `txHash`, `transferIndex`, `instructionIndex`, `innerInstructionIndex`, `mint`, `sourceTokenAccount`, `destinationTokenAccount` Near-real-time indexed history. Historical valuation is field-selected and can remain null when no fair price exists at or before the event. ##### Time Semantics - blockTime is the indexed chain-time timestamp. - operationIndex aliases the transfer instruction index in GraphQL. - transferIntent is derived from decoded instruction evidence and describes the movement mechanism, not the recipient's business purpose; historical unreplayed rows use unknown. - Historical USD fields use the last retained fair close within 30 days at or before the event minute; current USD fields use token current state at query time. - Indexed transfer amount/rawAmount and USD valuations remain gross. transferFeeRawAmount preserves the recorded raw integer fee; transferFeeAmount and netReceivedAmount follow amount display units. netReceivedAmount subtracts the known fee in source decimals before UI conversion. Missing fees are unknown, not zero, and leave netReceivedAmount null. Historical and RPC balance-delta recovery rows can lack fee evidence. These fields do not alter portfolio-history cash flows. ##### Authoritative For - Actual indexed token amounts entering or leaving a wallet. - Source/destination accounts and owners for supported movement instructions. - Decoded transfer mechanisms such as checked or unchecked transfer, mint, burn, authority change, account lifecycle funding/refund, SOL wrapping/unwrapping, and nonce withdrawal. ##### Not Authoritative For - Network fees, tips, or arbitrary native SOL balance deltas not represented by a supported decoded movement. - The receiving wallet's business purpose or motivation. - A complete transaction decoder when owners or instructions were not indexed. - Absolute account holdings before or after a transaction; transactionActivity resolves those independently from wallet holding changes when retained. ##### Physical Sources | Source | Role | | --- | --- | | `indexed token transfer history` | Canonical indexed physical movement and supported authority-change fact table; transfer_intent carries the decoded mechanism. | ##### API Access **GraphQL paths:** `solana.wallet.activity`, `solana.wallet.activityExt`, `solana.transactionActivity`, `solana.transactionCoverage`, `solana.tokenActivityExt` **MCP map operations:** `listWalletActivityRows`, `listWalletActivity`, `getTransactionActivity`, `getTransactionCoverage`, `getTokenActivityExt` **Entity mappings:** `SolanaWalletTransferActivity`, `SolanaTransactionTransferActivity` ##### Relationships - txHash joins transaction fee/program facts and DEX execution context. - mint joins token current state and fair OHLCV for current and historical valuation. - transactionActivity.flow can place the same transfer fact on its exact invocation. A row selected both at transaction.transfers and flow.transfers is one source fact shown in two contexts and must not be double-counted. - Graph transfer amount is multiplied by the current Token-2022 UI multiplier by default; historicalPriceUsd and currentPriceUsd are divided by it. rawAmount and historical/current USD values are unchanged. This applies to top-level and flow transfers in transactionActivity and to transfers in wallet.activity and wallet.activityExt. Set adjustForUiMultiplier=false for decimal-adjusted source amounts and source prices; historical multiplier changes are not reconstructed. #### `solana-transaction-fee` - Solana indexed transaction fee Transaction-level indexed fee, compute, Jito-tip, Token-2022 fee, Memo Program instruction, protocol event note, activity-count, canonical ordering, and block linkage record. - **Classification:** `fact` - **Grain:** `One indexed transaction row per transaction signature.` **Identity:** `txHash` Near-real-time indexed transaction coverage, including eligible native-SOL-only movement transactions. Validated protocol events can also retain transactions without physical transfers. ##### Time Semantics - blockSlot, blockTime, and transactionIndex locate the transaction in canonical indexed order. - totalFeeLamports is authoritative for the runtime network fee; split components are usable only when feeBreakdownStatus is exact. - memos preserve top-level instructionIndex and innerInstructionIndex ordering; innerInstructionIndex = -1 identifies a top-level memo. - notes preserves emitting-operation coordinates i and optional j, and event Unix timestamp t. Historical transactions were not backfilled after migration 279; [] does not prove no event occurred. ##### Authoritative For - Indexed transaction discovery by block and transaction-level fee/resource enrichment. - Memo Program contents attached to movement-scoped indexed transaction fee rows. - Indexed protocol event notes preserved beside memos, currently PumpSwap BOOST buy-and-burn, initialization, and authority changes. ##### Not Authoritative For - Physical token or native SOL movement details. - DEX classification for route-only MEV rows. - RPC-complete historical block contents. - Memo-only transactions without a physical token or native-SOL movement, unless a validated protocol event also causes the transaction to be retained. - Complete historical protocol-event coverage, swap classification, or wallet attribution from notes. ##### Physical Sources | Source | Role | | --- | --- | | `indexed transaction fee and resource metadata` | Canonical indexed transaction-level fee, resource, and Memo Program fact table. | ##### API Access **GraphQL paths:** `solana.blocks`, `solana.block`, `solana.blockTransactions`, `solana.transactions`, `solana.transactionActivity`, `solana.transactionCoverage`, `solana.tokenActivityExt` **MCP map operations:** `listBlocks`, `getBlock`, `listBlockTransactions`, `getTransactions`, `getTransactionActivity`, `getTransactionCoverage`, `getTokenActivityExt` **Entity mappings:** `SolanaBlockTransaction`, `SolanaTransactionActivity`, `SolanaTransactionFee`, `SolanaTransactionMemo`, `SolanaTransactionCoverage`, `SolanaDatasetCoverage` ##### Relationships - txHash joins program interactions, DEX trades, token transfers, and wallet activity; solana.transactions and solana.transactionActivity expose fee details and ordered sibling memos and notes arrays from the same transaction_fees row. - blockSlot joins the indexed block-summary view. - Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution. #### `solana-live-token-candle-stream` - Solana live token candle stream Replaceable canonical fair-price candle updates for one token mint, delivered through GraphQL subscriptions after source persistence. - **Classification:** `fact` - **Grain:** `One emitted rolling candle snapshot per subscribed mint and active requested interval bucket.` **Identity:** `mint`, `bucketStart` Near-real-time subscription view backed by fair-candle notifications emitted after canonical candle persistence. ##### Time Semantics - A bucket can be emitted repeatedly as persisted source-minute versions change; a newer version replaces the same minute before wider interval aggregation. - Use canonical fair OHLCV minute facts for persisted historical candles. ##### Authoritative For - Low-latency rolling candle display for the subscribed token. ##### Not Authoritative For - Final immutable candle history or arbitrary historical lookback. ##### Physical Sources | Source | Role | | --- | --- | | `JetStream fair_candles.mint.` | Per-mint persisted fair-candle snapshot subject consumed by Graph subscriptions. | ##### API Access **GraphQL paths:** `subscription.tokenCandle` **MCP map operations:** `subscribeTokenCandle` ##### Relationships - Persisted history is read from the Solana fair OHLCV minute dataset. #### `solana-market-snapshot` - Solana market analytics snapshot Internally consistent per-minute market-wide dashboard metrics covering tracked-token counts, trailing fair DEX volume, the BlockchainAI100 index, and aggregate RSI. - **Classification:** `fact` - **Grain:** `One precomputed market snapshot per UTC minute; every headline metric in a returned snapshot shares the same asOf minute.` **Identity:** `asOf` Written once per minute from Graph's maintained token and fair-candle caches. Snapshot history grows from deployment and is not a genesis-to-now market record. ##### Time Semantics - asOf is the UTC minute for which every returned headline metric was computed. - volume24h is a trailing 24-hour fair-volume aggregate at asOf. - index rebalancing occurs daily at 00:00 UTC; rebalancedAt identifies the active constituent rebalance. - History fields are downsampled views ending at the same snapshot minute. ##### Authoritative For - Consistent dashboard headline metrics that must share one calculation minute. - The published BlockchainAI100 index level and its constituent count. - Precomputed FIVE_MINUTES/14 aggregate RSI history. ##### Not Authoritative For - Individual token valuation, executable market depth, or investment recommendations. - Arbitrary historical market reconstruction before retained snapshot history. - Filter-aware token counts; use marketAnalytics.tokenCount for those. ##### Physical Sources | Source | Role | | --- | --- | | `minute market snapshots` | Local per-minute snapshot read model for headline metrics and history. | | `market index constituents` | Local active index constituent and weight state. | | `current DEX token statistics and fair-price candles` | Maintained token-window and fair-candle inputs used to build volume, index, and RSI metrics. | ##### API Access **GraphQL paths:** `solana.marketAnalytics.snapshot`, `solana.marketAnalytics.tokenCount` **MCP map operations:** `getMarketSnapshot`, `getMarketTokenCount` ##### Relationships - The snapshot's universe is selected from current token state plus trailing fair-volume statistics. - marketAnalytics.tokenCount reuses current token filters but is a live count, not a row from market_snapshot_1m. #### `solana-pool-liquidity-stats` - Solana pool trailing liquidity and activity stats Query-time trailing-24h measurements combining event-derived liquidity-provider state with physical pool executions counted once. Recognized virtual venues expose logical trade metrics only. - **Classification:** `fact` - **Grain:** `One measured trailing-24h aggregate per requested normalized pool address and periodEnd.` **Identity:** `poolAddress`, `periodEnd` Computed on demand from retained facts and cached briefly per pool and selected field family. Dysfunctional and unknown pools skip historical scans and return zero-valued rows. The recognized 'Ondo RWA' virtual venue bypasses physical pool resolution for trade metrics. ##### Time Semantics - periodEnd is Graph wall-clock time when the briefly cached aggregate was measured. - Holder and liquidity changes compare event-derived net state at periodEnd with state at periodEnd minus 24 hours. - Trade counters and volume cover the trailing 24 hours and count each physical pool execution once, including executions without a logical operation index. Buy/sell direction uses the pool base mint. Wallet counts use non-empty execution-attributed wallets, not enclosing route initiators. ##### Authoritative For - Trailing pool liquidity-provider count and change derived from indexed add/remove events. - Trailing deduplicated pool operation, buy, sell, active-wallet, and visible USD volume metrics. ##### Not Authoritative For - Current vault balances, pool TVL, LP-token ownership, or executable swap depth. - A zero on an unknown or dysfunctional pool as proof that no on-chain activity exists. - Token holder count; baseTokenHolders counts net liquidity-provider wallets. - Physical liquidity for virtual venues. 'Ondo RWA' returns zero holder/liquidity fields because it has no indexed pool legs or liquidity-event state. ##### Physical Sources | Source | Role | | --- | --- | | `indexed liquidity event history` | Historical add/remove event source for net liquidity-provider state and 24h comparison. | | `canonical physical execution history` | Physical pool counts, direction, volume and attributed-wallet metrics; virtual venues retain logical trade history. | | `indexed pool identity and lifecycle state` | Current pool base-mint and dysfunctional-state context used before historical scans. | ##### API Access **GraphQL paths:** `solana.dex.poolLiquidityStats` **MCP map operations:** `getDexPoolLiquidityStats` ##### Relationships - Physical poolAddress joins pool current state for pair, vault, program, TVL, and lifecycle details. 'Ondo RWA' is a virtual trade venue and does not join pool current state. - Use transactionCoverage to inspect the independent retained floors of the underlying liquidity-event and DEX-trade facts. #### `solana-wallet-holding-change` - Solana transaction-boundary wallet holding change Retained token-account balances immediately before and after an indexed transaction. - **Classification:** `fact` - **Grain:** `One indexed balance-change row per block slot, transaction index, transaction hash, token account, mint, owner, authority, and DeFi classification.` **Identity:** `blockSlot`, `transactionIndex`, `txHash`, `tokenAccount`, `mint`, `wallet`, `authority`, `isDefiActivity` Near-real-time indexed history retained for three days. holdingsBefore and holdingsAfter are empty when the requested transaction is outside this retention or no holding change was indexed. ##### Time Semantics - blockSlot and transactionIndex locate the transaction in canonical indexed order. - preBalance and postBalance are transaction-boundary UI token-account balances. - NativeSOL fee-payer deltas are fee-neutralized; use transaction fee enrichment for network fees. ##### Authoritative For - Indexed token-account balances immediately before and after a retained transaction. - Account-level balance effects that cannot be reconstructed reliably from decoded transfer instructions alone. ##### Not Authoritative For - Network fees, priority fees, or Jito tips. - Permanent transaction history outside the three-day retention window. - Instruction-level attribution of balance movement; use token transfer and program-flow facts for execution context. ##### Physical Sources | Source | Role | | --- | --- | | `indexed wallet holding changes` | Canonical retained transaction-boundary pre/post token-account balance fact table. | ##### API Access **GraphQL paths:** `solana.transactionActivity` **MCP map operations:** `getTransactionActivity` **Entity mappings:** `SolanaTransactionHoldingActivity` ##### Relationships - txHash joins transaction fee, transfer, DEX execution, and program-flow facts. - tokenAccount and mint identify the exact balance-bearing account and asset. - holdingsBefore projects preBalance and holdingsAfter projects postBalance from the same retained source row. - holdingsBefore.amount and holdingsAfter.amount remain decimal-adjusted source balances; transactionActivity.adjustForUiMultiplier adjusts trade and transfer amounts, not these balance snapshots. #### `solana-unconfirmed-trade-stream` - Solana unconfirmed DEX trade stream Provisional low-latency DEX trade event delivered before canonical indexed history is necessarily available. - **Classification:** `fact` - **Grain:** `One provisional stream message per emitted trade event and token perspective.` **Identity:** `txHash`, `operationIndex`, `token`, `poolAddress` Real-time provisional stream; messages can precede canonical persistence and may later be corrected or absent from finalized history. ##### Time Semantics - receivedAt is Graph receipt time; blockTime is source chain time when available. - lookBehindSeconds replays a bounded recent stream window for a new subscriber, including multi-mint subscriptions through one ordered consumer with multiple filter subjects. - largeTrades selects one preferred mirrored token perspective per transaction signature, but remains provisional because it is derived from this stream. - Graph adjusts provisional trade prices and token amounts to current Token-2022 UI multipliers by default. Set adjustForUiMultiplier false for unadjusted values; USD notionals and fee ratios remain unchanged. ##### Authoritative For - Low-latency provisional trade notifications. ##### Not Authoritative For - Finalized canonical history, exactly-once delivery, or current token/pool state. ##### Physical Sources | Source | Role | | --- | --- | | `JetStream SOLANA_INDEXER_TRADES` | HA JetStream source for provisional unconfirmed-trades messages. | ##### API Access **GraphQL paths:** `subscription.unconfirmedTrades`, `subscription.largeTrades` **MCP map operations:** `subscribeUnconfirmedTrades`, `subscribeLargeTrades` ##### Relationships - Use indexed DEX trade facts for historical/canonical follow-up by txHash, mint, or pool. #### `solana-unconfirmed-liquidity-stream` - Solana unconfirmed liquidity event stream Provisional low-latency add/remove liquidity event delivered from JetStream before canonical history is necessarily available. - **Classification:** `fact` - **Grain:** `One provisional stream message per emitted liquidity operation and pool/token context.` **Identity:** `txHash`, `operationIndex`, `poolAddress`, `token` Real-time provisional stream; messages can precede canonical persistence. ##### Time Semantics - receivedAt is Graph receipt time; blockTime is source chain time when available. - lookBehindSeconds replays a bounded recent stream window for a new subscriber. ##### Authoritative For - Low-latency provisional liquidity add/remove notifications. ##### Not Authoritative For - Finalized liquidity history, current pool reserves, or LP position ownership. ##### Physical Sources | Source | Role | | --- | --- | | `JetStream unconfirmed-liquidity-events` | HA JetStream source for provisional liquidity messages. | ##### API Access **GraphQL paths:** `subscription.unconfirmedLiquidityEvents` **MCP map operations:** `subscribeUnconfirmedLiquidityEvents` ##### Relationships - Use indexed liquidity-event facts and pool current state for canonical follow-up. #### `solana-wallet-slot-index` - Solana wallet slot activity and native accounting Indexed wallet-slot activity with nullable native SOL residual and actual-payer network fees, including fee-only and failed activity when recorded. - **Classification:** `fact` - **Grain:** `One replacement observation per wallet address and block slot.` **Identity:** `wallet`, `blockSlot` Follows canonical indexed wallet-slot observations. Historical fee-only slots may be absent before native accounting was recorded. ##### Time Semantics - blockTime and blockSlot locate a complete indexed slot observation. Historical rows without native accounting retain null amounts. ##### Authoritative For - Indexed wallet-slot native residuals and actual-payer network fees when non-null. - Candidate slots for wallet activity and retained activity coverage. ##### Not Authoritative For - Transaction-level allocation of slot totals or complete historical fee-only coverage. - Classifying unexplained residuals as profit, deposits, withdrawals or account rent. - Aggregated native balances of every token account owned by a wallet. ##### Physical Sources | Source | Role | | --- | --- | | `canonical wallet-slot activity and native accounting` | Complete replacement slot observations derived from transaction native balances, represented movements and actual-payer fees. | ##### API Access **GraphQL paths:** `solana.wallet.activity`, `solana.wallet.activityExt`, `solana.wallet.activityExt.metadata.slotAccounting` **MCP map operations:** `listWalletActivityRows`, `listWalletActivity` **Entity mappings:** `SolanaWalletTransaction`, `SolanaWalletActivityExt`, `SolanaWalletActivityMetadata`, `SolanaDatasetCoverage`, `SolanaWalletSlotAccounting`, `SolanaWalletSlotAccountingEntry` ##### Relationships - One ordered page of distinct (blockSlot, txHash) keys is selected across wallet trades and transfers before both detail sources are read. The limit applies once to that shared transaction page; all matching wallet activities for selected keys are returned without independent source limits. - Trade rows include the indexed userWallet and transfer-linked swaps only when a full input or output transfer involving the queried wallet matches the mint, amount and trader/pool counterparty within the same indexed swap or router invocation. A shared transaction hash or matching operationIndex alone is insufficient: trade opIndex is logical and is not transfer instructionIndex. CPI ancestry comes from retained dex_swap_executions and program_interactions. Ambiguous or missing evidence leaves the transfer visible without adding an indirect trade. userWallet remains the original indexed trader; walletRelation is TRADER or TRANSFER_LINKED and relatedTransferIndexes identifies the evidence. Transfers remain restricted to the requested wallet. Transfer-linked trade rows are execution context, not proof that the queried wallet signed or paid for both swap legs. - networkFeeLamports is explanatory and already included in solResidualDeltaLamports. Never subtract both. Represented tips and token transfer fees are separate. - slotAccounting follows the parent period or exact slot and independently applies its limit and direction; mint filters and transaction pagination do not suppress fee-only slots. Each wallet-slot appears once. - complete qualifies returned indexed evidence only. Null is unknown, zero is measured zero, and an empty page does not prove zero fees. No RPC recovery is added. #### `solana-token-activity-summary` - Token activity over an indexed range Indexed full-window token activity with independently paged, chronologically ordered wallet and annotation arrays. No RPC or backfill. Amount strings are mint-decimal source units. - **Classification:** `fact` - **Grain:** `One result per distinct requested token and shared interval, with per-owner totals and per-transaction annotation groups. Results follow first-requested mint order; inactive mints retain a result with zero totals.` **Identity:** `mint`, `periodStart or fromSlot`, `periodEnd or toSlot` Canonical indexed history as observed at request time; concurrent indexing can advance between aggregate reads. ##### Time Semantics - UTC start inclusive and end exclusive; slot boundaries both inclusive. No selector uses the trailing 24 hours. - Event ordering is ascending slot, transaction index, outer instruction and inner instruction. Wallets use their first matching event. Whole-second UTC boundaries are required. ##### Authoritative For - Indexed gross physical token movement, minted and burned totals over the full selected interval. - Indexed top-level trader buy/sell amounts and whole-transaction fee totals for each token, with missing fee coverage exposed. A transaction involving multiple requested tokens appears once in each affected token's totals; whole-transaction fees must not be summed across tokens. ##### Not Authoritative For - Unique economic turnover: router and pool movements can move the same tokens repeatedly. - Human ownership, corrected historical trader attribution, or proof of chain-complete coverage. - Exact DEX fees from ratios; USD fee estimates are explicitly estimates. - Amounts actually credited after Token-2022 withholding; received is gross and fees are separate. ##### Physical Sources | Source | Role | | --- | --- | | `Canonical token transfer history` | Physical movements and mint/burn instruction evidence. | | `Canonical top-level DEX trade history` | Indexed per-token trader buy/sell perspectives. | | `Canonical transaction fees and annotations` | Deduplicated transaction costs, memos and protocol notes, including mint-referencing note-only activity. | | `Canonical physical execution history` | Known instruction ancestry for chronological wallet ordering. | ##### API Access **GraphQL paths:** `solana.tokenActivityExt` **MCP map operations:** `getTokenActivityExt` **Entity mappings:** `SolanaTokenActivityExt`, `SolanaTokenActivitySummary`, `SolanaTokenActivityWallet`, `SolanaTokenActivityDetails`, `SolanaTokenActivityFees`, `SolanaTokenActivityMemos`, `SolanaTokenActivityNotes` #### `solana-unsigned-swap-transactions` - Unsigned real-wallet swap transactions Automatically routed, wallet-bound unsigned swap transactions with current account/fund checks, account setup and atomic minimum-output verification. The caller signs and submits. - **Classification:** `fact` - **Grain:** `One independently prepared transaction for a wallet, input/output mint pair, exact input and build time.` **Identity:** `wallet`, `inputMint`, `outputMint`, `inputAmountRaw`, `blockhash`, `messageBase64` Every build validates current on-chain wallet state and obtains a fresh blockhash. Successful simulation is not a reserved fill. ##### Time Semantics - checkedSlot identifies the final confirmed simulation; builtAt is its completion time. - lastValidBlockHeight bounds the lifetime of the embedded blockhash. Rebuild after expiry. ##### Authoritative For - Unsigned transaction bytes and their required signer, enforced output floor and simulated net receipt. - Simulation-time network fees, token-account deposits/refunds, native SOL changes and explicitly capped burns encoded in the unsigned transaction. ##### Not Authoritative For - Actual execution, confirmation, future balances, private-key ownership or a global best-price guarantee. - Proving a remainder is unsellable, predicting future balances, or an itemized breakdown of every pool/protocol fee. ##### Physical Sources | Source | Role | | --- | --- | | `Confirmed Solana wallet, mint and token-account state` | Actual input funding, account ownership and account-creation requirements. | | `Supported pool identities and reviewed swap instructions` | Automatic bounded direct and two-hop route discovery. | | `Confirmed Solana transaction simulation and fee estimates` | Atomic full-input spending, net receipts, absence of borrowed bridge inventory and transaction lifetime. | ##### API Access **GraphQL paths:** `solana.swap.buildTransaction` **MCP map operations:** `buildSwapTransaction` **Entity mappings:** `BuiltSwapTransaction`, `SwapBuildLeg`, `SwapBuildInfo`, `SwapBuildFees`, `SwapBuildRent`, `SwapBuildRentChange`, `SwapBuildDustBurn` ##### Relationships - Separate from paper-trading sessions: real balances and wallet signing are required. - Receiving and intermediate token accounts are created in the returned transaction; no server-side signing or submission occurs. - Optional unwrapSol returns this route's SOL receipts or intermediate WSOL surplus as native SOL by closing an isolated temporary account. Existing WSOL inventory is not included in receipts. Simulated unwrapped amounts exclude the temporary rent refund. - Max uses the selected token account's raw balance without display-unit rounding; it does not consolidate accounts or spend the native SOL fee/rent reserve. - Optional input-account closure refunds its deposit after selling. A nonzero non-SOL remainder requires an explicit raw-unit burn cap; failed quotes and partial fills never authorize burns. - The info review block separates sold tokens, burned tokens, network fees, gross account deposits/refunds and native SOL changes. All amounts are predictions for the unsigned transaction, not executed receipts. ### Entity Datasets #### `solana-pool-swap-quotes` - Live route-aware Solana swap previews Best verified direct or atomic two-hop preview found by the shared simulation pricing path. - **Classification:** `entity` - **Grain:** `One latest route preview per explicit input/output pair, exact input budget and route options.` **Identity:** `inputMint`, `outputMint`, `amount`, `quote.routeIds` Sequential repeated searches with one-second success cadence and bounded error backoff. Exact-input evidence is reused for up to two seconds, constrained further by maximum age. Retained evidence is explicitly stale after expiry or failure. ##### Time Semantics - sequence and emittedAt describe stream delivery, not a new simulation. - quote.quotedAt and quote.simulationSlot preserve the actual simulation evidence on reuse and retained stale updates. - simulationCommitment identifies the selected bank commitment. rpcHeadSlot and rpcHeadObservedAt are a separate same-endpoint, same-commitment observation, shared for up to one second and nullable on diagnostic failure. - simulationStartedAt and simulationCompletedAt bracket the successful RPC attempt after admission. searchStartedAt and searchFinishedAt bracket the original route search including waits and final verification. All original evidence remains unchanged on reuse; older persisted fills may have null diagnostics. ##### Authoritative For - Simulated exact-input/output amounts and selected route evidence at the reported time and slot. ##### Not Authoritative For - Guaranteed execution, signed transactions, globally optimal routing, reserved liquidity or freshly verified results when stale is true. ##### Physical Sources | Source | Role | | --- | --- | | `Indexed pool market identities, vault holdings, recent swaps and user holders` | Candidate route discovery and simulation preparation. | | `Confirmed Solana account and transaction reads and swap simulation` | Validated instruction preparation and expected net output without signing or submitting. | ##### API Access **GraphQL paths:** `tokenQuotes`, `solana.simulation.quote` **MCP map operations:** `subscribeTokenQuotes`, `quoteSimulation` **Entity mappings:** `TokenRouteQuoteUpdate`, `SimulationFill`, `PoolSwapQuote`, `QuotePriceImpact` ##### Relationships - Uses the same shared pricing as virtual buy/sell. Session-bound streams execute on the owner and inherit fixed UI units. - Use solana.swap.buildTransaction for an unsigned real-wallet transaction; a preview alone is not executable. #### `solana-exchange-program` - Solana exchange program dictionary Reviewed mapping from an on-chain exchange program id to its display name and behavior attributes used by pool and trade interpretation, with optional public logos for metadata lookups. - **Classification:** `entity` - **Grain:** `One reviewed row per Solana program id.` **Identity:** `programId` Reviewed names and attributes update with reference metadata changes. Logo availability updates asynchronously from the last successful image publication. Before the first successful refresh or when disabled, logos are null; unavailable refreshes retain prior availability. ##### Time Semantics - This is reviewed reference metadata; it does not represent an invocation event or deployment history. ##### Authoritative For - Human-readable pool venue names and reviewed program behavior attributes. ##### Not Authoritative For - Aggregator or router identity inferred from a trade. - All programs invoked by a transaction. - Logo availability does not establish whether a program is known or reviewed. ##### Physical Sources | Source | Role | | --- | --- | | `reviewed exchange program registry` | Reviewed program metadata source. | | `operator-reviewed program image sources` | Optional published display images; metadata lookups expose a public URL for the last successfully refreshed publication. | ##### API Access **GraphQL paths:** `solana.metadata.program`, `solana.metadata.programs` **MCP map operations:** `getProgram`, `listPrograms`, `listPools` **Entity mappings:** `SolanaExchangeProgram` ##### Relationships - Resolve a trade venue through trade.poolAddress -> pool.programId -> this dictionary. - aggregatorProgram is router context and is not a substitute for pool.programId. #### `solana-hash-resolution` - Solana hash and slot resolution Hybrid explorer-style resolution of an exact transaction signature, Solana account address, or numeric block slot. The resolver combines indexed Graph sources with bounded Solana RPC discovery and returns lightweight routing records rather than complete objects. Specific token, pool, and reviewed-program roles take precedence over generic account and wallet fallbacks. - **Classification:** `entity` - **Grain:** `One routing record per resolved supported role for one exact input hash or slot; every syntactically valid input returns at least one routing record.` **Identity:** `hash`, `kind` Specific matches follow current Graph token and pool caches plus indexed remote block, transaction, account-identity, wallet-slot, and reviewed-program sources. Missing or incomplete indexed metadata can be supplemented at request time through configured Solana RPC endpoints. ##### Time Semantics - findHash is a current resolution operation and does not assert when an object first appeared. - slot is a precision-safe string obtained from indexed object context or bounded RPC discovery; it is null when neither path resolves a slot. - Every resolved known slot is evaluated against a cached maximum finalized cluster slot with a 300-millisecond refresh TTL. Indexed matches newer than that head report confirmed and covered slots report finalized; unresolved identifiers use bounded RPC discovery. Finality and confirmation status describe resolution time, not an immutable historical observation. ##### Authoritative For - Routing an exact hash or slot to supported GraphQL and MCP drill-down operations. - Returning the most specific supported indexed role while retaining multiple specific matches when independent sources genuinely overlap. - Reporting a resolved slot plus current finality/confirmation context for every routing match. - Reporting retained canonical account-identity evidence boundaries through transactionCoverage.accounts. - Returning the native type-specific RPC result when includeRpcInfo is true: parsed transaction execution data, parsed account state, or block metadata with signatures and rewards. ##### Not Authoritative For - Semantic interpretation of arbitrary fields inside rpcResult; clients must interpret the native Solana JSON-RPC shape identified by rpcMethod. - Complete block transaction bodies. Block resolution deliberately requests signatures and rewards rather than embedding every full transaction; resolve signatures individually for transaction logs and execution metadata. - Proving index coverage or positive on-chain existence from a generic fallback routing record alone. - Partial text, symbol, name, or case-insensitive token search. - Historical coverage guarantees for an identifier that did not resolve to a specific indexed role. ##### Physical Sources | Source | Role | | --- | --- | | `Graph token and pool current-state indexes` | Exact token-mint and pool-address matches. | | `indexed transaction metadata and program invocation history` | Exact indexed transaction-signature matches. | | `indexed wallet activity locator` | Exact indexed wallet-role matches. | | `indexed account identity state` | Bounded exact account lookup resolving account kind, lifecycle state, owner program, related token mint, first-created slot, and the latest canonical evidence slot. | | `reviewed exchange program registry` | Exact reviewed exchange-program matches. | | `indexed block progress` | Exact indexed numeric block-slot matches. | | `Solana JSON-RPC getSlot, getTransaction, getSignatureStatuses, getAccountInfo, and getBlock` | Request-time finality tracking; full parsed transaction results including runtime logs; signature-status fallback; full parsed account results; and block metadata with signatures and rewards. | ##### API Access **GraphQL paths:** `solana.findHash`, `solana.transactionCoverage` **MCP map operations:** `findHash`, `getTransactionCoverage` **Entity mappings:** `SolanaHashMatch`, `SolanaHashDrilldown`, `SolanaRpcInfo` ##### Relationships - Each match supplies machine-readable drilldowns naming the next GraphQL path, MCP tool, argument name, and whether the value must be wrapped in a list. - rpcInfo is returned for every match. Indexed matches with a known slot are compared with the shared cached finalized cluster head and report confirmed while newer than that head or finalized once covered; identifiers absent from indexed sources use bounded RPC discovery for their status. - includeRpcInfo controls whether the native rpcResult is retained. rpcResult remains complete and unfiltered regardless of sibling GraphQL field selections; transaction runtime logs remain in rpcResult.meta.logMessages. rpcMethod identifies the RPC status source or native result shape; indexed-only matches have no rpcMethod. - transactionCoverage.accounts measures the first and last retained non-zero latest_canonical_evidence_slot values through minmax-indexed range probes. Combined coverage intersects that range with fee and program-interaction coverage. - Account-like specific roles share one getAccountInfo request per resolver execution. Numeric block lookups use getBlock with transactionDetails=signatures and rewards=true to avoid embedding every full transaction in one routing response. - Failures in one indexed source are isolated so other probes and RPC fallback can still produce a routing record; a fallback result therefore does not prove every indexed source was healthy. - Generic ACCOUNT matches have an account explorer URL but no complete-object drilldown because Graph does not yet expose a first-class account-details query. #### `solana-pool-current` - Solana pool current state Current reconciled identity, vaults, exchange program, lifecycle, health, graduation, and token-unit liquidity for an indexed Solana liquidity pool market. Stored pool-leg order is returned by default; callers can opt into preferred quote-asset presentation. - **Classification:** `entity` - **Grain:** `One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.` **Identity:** `poolAddress`, `baseMint`, `quoteMint` Continuously refreshed current state. Pool liquidity amounts are cached in token units; USD valuation is hydrated from current token prices at query time. ##### Time Semantics - inceptionAt is the earliest observed pool inception time. - lastObservedAt is the latest indexed pool observation. - graduation.at records a detected launchpad migration event when present. - version is replacement order and must not be interpreted as a chain timestamp. ##### Authoritative For - Indexed pool identity, mint pair, vault addresses, program id, lifecycle, health, and graduation fields. - Current cached base/quote token-unit liquidity for Graph pool reads. ##### Not Authoritative For - LP ownership, treasury backing, off-chain reserves, or an executable swap quote. - A complete historical pool event log. - Generic proof that an arbitrary account is a pool. - Virtual execution venues carried only by trade facts. The exact trade poolAddress value 'Ondo RWA' has no physical pool row, vaults, or pair identity here. ##### Physical Sources | Source | Role | | --- | --- | | `canonical indexed pool current state` | Canonical remote slowly mutating pool current-state table. | | `low-latency current pool index` | Configurable local pool current-state cache used when graph caching is enabled. | | `current pool token amounts` | Configurable local current base/quote token-unit liquidity cache. | | `recognized quote-asset registry` | Exact-mint stable and SOL quote classification used only when preferQuoteAssets is true. | ##### API Access **GraphQL paths:** `solana.pool.pools` **MCP map operations:** `listPools`, `listTokensExt`, `listTokenLifecycle`, `getDexPoolStats`, `getDexPoolTransactions` **Entity mappings:** `SolanaPool` ##### Relationships - programId joins to the reviewed exchange-program dictionary. - baseMint and quoteMint join to token current state for labels and query-time USD prices. Stored order is the default; preferQuoteAssets can move one exact-mint stable or SOL leg to quote without changing pool identity. - A physical poolAddress joins DEX trade and liquidity-event facts. The virtual trade venue 'Ondo RWA' deliberately does not join this entity. #### `solana-token-current` - Solana token current state Current SPL or Token-2022 mint state, selected metadata, scaled-UI-amount and transfer-fee configuration, display price, retained qualifying fair-price ATH/ATL, supply-derived valuation, conversion-path anchored TVL, and observed lifecycle timestamps. - **Classification:** `entity` - **Grain:** `One latest logical row per token mint.` **Identity:** `mint` Near-real-time current state updated from confirmed token-change events and periodically reconciled with canonical indexed state to heal dropped, duplicated, or out-of-order notifications. ##### Time Semantics - firstSeenAt is the earliest indexed DeFi appearance and is a launch-time proxy, not guaranteed mint-creation time. - lastSeenAt is the latest indexed appearance used by the token profile. - priceSourceMinute identifies the fair-candle minute behind the current price when available. - athAt and atlAt identify the fair-price source minutes at which the retained qualifying extrema were observed. - scaledUiAmountNewMultiplierEffectiveAt identifies when a scheduled Token-2022 scaled-UI multiplier becomes effective, even when that timestamp is already past; effectiveScaledUiAmountMultiplier resolves the active value. Transfer-fee epochs identify schedule activation by Solana epoch rather than wall-clock time. - version is nanosecond write order for replacement and is not chain time. ##### Authoritative For - Current token metadata and mint state exposed by token, tokens, and tokensExt. - Current display price, supplyUi, fdvUsd, and marketCapUsd. By default, supplyUi is multiplied by the current Token-2022 UI multiplier, while token-unit prices and ATH/ATL are divided by it. supplyRaw and USD valuations are unchanged; adjustForUiMultiplier=false returns decimal-adjusted source amounts and source prices. - Current decoded Token-2022 scaled-UI-amount configuration and older/newer transfer-fee schedules when those mint extensions are present. - athUsd/athAt and atlUsd/atlAt as the highest and lowest positive qualifying fair-price extrema retained across indexed extrema coverage. - anchoredTvlUsd as the token TVL and convertibility signal, physically sourced from token_stats and bounded by recognized liquid anchor-side reserves. - The firstSeenAt launch proxy used in token lifecycle calculations. ##### Not Authoritative For - Exact token creation time or project creator identity. - Verified token origin: launchpad and graduation attribution are inferred from indexed pool relationships and firstSeenAt, not proof of the original token launch. - Historical minute prices or execution prices. - Raw last-trade highs/lows or proof of extrema before the indexed price-extrema coverage began. - Total liquidity of recognized base-anchor assets; their anchoredTvlUsd rows can report zero because the metric measures external backing. - Executable depth, slippage, or a standalone token trust verdict. - A precomputed net amount after transfer fees; clients must choose the applicable epoch schedule and apply Token-2022 fee rules. ##### Physical Sources | Source | Role | | --- | --- | | `canonical token current state` | Authoritative indexed token profile. anchoredTvlUsd is the token TVL source; ATH/ATL retain qualifying fair-price extrema. | | `low-latency token index` | Serves token profiles, lists, autocomplete, filters, and ordering from the latest reconciled state. | | `reviewed business token listings` | Business categories, tags, search aliases and optional profile enrichment matched by normalized network and exact mint. Display aliases and enabled nonblank logo overrides share a five-minute in-memory snapshot; original image metadata is preserved. Native taxonomy is unioned across active available mappings; ordinary tokens are not restricted by RWA preference. | ##### API Access **GraphQL paths:** `solana.token`, `solana.tokenSearch`, `solana.tokens`, `solana.tokensExt`, `solana.wallet.activityExt` **MCP map operations:** `getToken`, `searchTokensAutocomplete`, `listTokens`, `listTokensExt`, `listTokenLifecycle`, `getMarketTokenCount`, `getTransactionActivity`, `listWalletActivity` ##### Relationships - mint joins to fair OHLCV, DEX trades, transfers, holder state, and either side of a pool. - tokensExt enriches this entity with separate DEX-window, holder-stat, and lifecycle datasets; its legacy tvlUsd field aliases anchoredTvlUsd. - Graduation attribution uses the mints common to the predecessor and destination pools after NativeSOL/WSOL normalization. One common mint is selected directly. With two common mints, the later firstSeenAt wins; one missing age is treated as youngest, two missing ages leave attribution unknown, and equal known ages use ascending mint order. Current launchpad pools use the same age rule on their two mints. Mint suffixes and pairing-asset allowlists are not used. - Lifecycle attribution is reevaluated when a new pool revision is observed. graduationAt is the latest migration time attributed by this rule; missing attribution does not prove a token never graduated. - confirmed-token-changes accelerates this current state but is not authoritative by itself; periodic canonical reconciliation is required. - Token-2022 mint extension descriptors, including TokenMetadata presence but not its full key-value payload, are selectable as token2022ExtensionsJson on token, tokens, and tokensExt; there is no metadataExtensions GraphQL field. #### `solana-token-holder-stats-current` - Solana token holder statistics current state Compact mint-level current holder count, total holdings, all-holder top ten with cached scalar classifications, and on-curve user-only top ten derived from wallet current state. - **Classification:** `entity` - **Grain:** `One current aggregate row per token mint.` **Identity:** `mint` Incrementally refreshed current aggregate; may lag underlying wallet rows during catch-up. ##### Time Semantics - updatedAt is reducer write time. - version is nanosecond replacement order and is not chain event time. ##### Authoritative For - Current indexed holder count, total holdings, compact all-holder top ten, and compact on-curve user-only top ten exposed by tokensExt. ##### Not Authoritative For - A complete holder list; use wallet.tokenHolders. - Historical holder counts or balances. ##### Physical Sources | Source | Role | | --- | --- | | `canonical token holder summary` | Canonical compact aggregate-state source. top_holders ranks total balances; top_oncurve_holders ranks only USER-classified amounts. | | `low-latency token holder summary` | Mint-keyed current state used by tokensExt, token-search ranking, and compatible tokenHolders top-ten reads, including both bounded top-holder arrays and scalar top-holder classifications. | ##### API Access **GraphQL paths:** `solana.tokensExt` **MCP map operations:** `listTokensExt`, `listTokenLifecycle` **Entity mappings:** `SolanaTokenTopHolder` ##### Relationships - mint links holder summaries to token current state; scalar top-holder types are retained with the summary, while detailed mixed classification components come from wallet holding current state. - A wallet can appear in topUserHolders with less than its topHolders amount when part of its balance is held in an AMM vault. - totalHoldings and top-holder amounts remain decimal-adjusted source units even when the parent tokensExt query returns display-unit supplyUi and prices. #### `solana-token-account-holding-current` - Solana token-account holding current state Exact current indexed SPL token-account balance before wallet-level aggregation. Graph uses it to refresh pool vault balances. - **Classification:** `entity` - **Grain:** `One latest row per token account and mint.` **Identity:** `tokenAccount`, `mint` Continuously reduced current state and copied into bounded graph pool-liquidity caches. ##### Time Semantics - lastObservedAt is the latest source observation used for the account balance. - updatedAt is reducer write time and is suitable for cache polling. - version is nanosecond write order, not source time. ##### Authoritative For - Indexed SPL vault balances when the exact token-account address and mint are known. ##### Not Authoritative For - Wallet-level balances across multiple token accounts. - Arbitrary native SOL balances unless the indexer models that side explicitly. ##### Physical Sources | Source | Role | | --- | --- | | `canonical token-account current holdings` | Canonical exact token-account current-state source. | | `low-latency pool vault holdings` | Configurable bounded graph cache for accounts referenced by indexed pools. | ##### API Access **GraphQL paths:** `solana.pool.pools` **MCP map operations:** `listPools`, `listTokensExt` ##### Relationships - Pool baseVault/quoteVault plus mint identify the account rows used for base/quote liquidity amounts. #### `solana-wallet-holding-current` - Solana wallet token holding current state Current indexed token balance, owner/account classification breakdown, and cumulative movement state for one wallet owner and mint. When server-side wallet RPC resolution is enabled, wallet-keyed GraphQL reads can automatically overlay an instance-local RPC baseline when indexed state has a pre-index gap; mint-wide holder reads remain indexed only. NativeSOL and wrapped SOL remain distinct assets. - **Classification:** `entity` - **Grain:** `One current aggregate row per holder wallet and mint.` **Identity:** `wallet`, `mint` Near-real-time current indexed state. When enabled, a one-time current RPC balance comparison can correct pre-index balance gaps. Current balances do not prove complete lifetime flows. Standalone currentHoldings and activityExt.metadata.currentHoldings use the same historical reconstruction flow when flow fields are requested and verified pre-index wallet evidence exists. ##### Time Semantics - firstTransferToWalletAt and lastTransferToWalletAt are indexed transfer boundaries. - holdingsByType is version-aligned with currentHoldings. New rows split the balance into at most one AMM-vault component and one USER, PROGRAM, or UNKNOWN component; legacy empty classification state means the complete balance is UNKNOWN. Graph derives holderType as the sole component type or MIXED when multiple distinct positive component types are present, and persists that scalar for cached top-holder reads. - updatedAt is reducer write time. - version is nanosecond write order, not chain event time. ##### Authoritative For - Current effective wallet token balances after automatic local resolution for wallet-keyed reads. - Current holder rows for a token, their classified balance components, and cumulative indexed DeFi movement counters. ##### Not Authoritative For - Complete wallet transaction history. - Proof that a USER-classified on-curve wallet belongs to one human or is not automated. - Exact SPL pool-vault account balances. - Network fees, rent, or complete unindexed activity semantics. RPC-recovered activity exposes wallet-owned balance deltas only. ##### Physical Sources | Source | Role | | --- | --- | | `canonical wallet holder current state` | Canonical wallet/mint aggregate-state read model with a mint/holder projection and version-aligned holdings_by_type classification. | ##### API Access **GraphQL paths:** `solana.wallet.currentHoldings`, `solana.wallet.tokenHolders`, `solana.wallet.activityExt` **MCP map operations:** `listWalletCurrentHoldings`, `listTokenHolders` **Entity mappings:** `SolanaWalletHolding`, `SolanaTokenHolder`, `SolanaWalletActivityMetadata`, `SolanaWalletActivityExt` ##### Relationships - wallet and mint current state is reduced from retained wallet-minute balance deltas; holdingsByType components sum to currentHoldings, while holderType summarizes the component set and is MIXED when necessary. Compact top-holder arrays persist the same scalar classification in the local holder-stats cache. - Use wallet activity facts to explain movements and this entity to reconcile the current result. Flow totals are best-effort indexed aggregates until eligible holdings-triggered recovery completes and reconciles against the saved current-balance observation. Recovered totals replace indexed aggregates only for holdings no newer than that observation; newer indexed totals remain explicitly partial. Known gaps or missing historical valuations are marked by hasUnvaluedHistoricalFlow. Activity selection alone never starts recovery; nested currentHoldings flow selections use the same recovery as standalone holdings. - Graph removes negative tokenHolders rows after aggregate-state merge and removes exact-zero rows by default; includeZero restores exact-zero rows. Its default sub-cent dust filter is a query presentation rule driven by the local current-token price cache, not a mutation or classification of canonical holder state; includeDust restores positive dust rows. - Wallet and token-holder balances and cumulative token-flow amounts remain decimal-adjusted source units. The activity unit toggle does not adjust metadata.currentHoldings. Pair these balances with source prices, or multiply the amounts by the current effectiveScaledUiAmountMultiplier before using display-unit prices. #### `tokenized-equity-reference` - Tokenized equity reference Preferred Solana RWA listings curated in Hero Business, optionally enriched with FMP underlying quotes and fundamentals. - **Classification:** `entity` - **Grain:** `One current preferred listing per Solana mint.` **Identity:** `mint` A normal view reads the latest committed Business sync on each database query; consumer caches can delay visibility. FMP quotes retain vendor timestamps; enrichment failure returns listings with null market fields. ##### Time Semantics - underlyingQuoteAt is the vendor event time; sharesOutstandingAsOf is the vendor share-count date. This dataset is current state, not history. ##### Authoritative For - Hero Business owns eligibility, display aliases, logo override selection, native categories/tags and shares per token. A true override_image flag gives a nonblank listing logo_url display priority. FMP owns underlying market observations. ##### Not Authoritative For - On-chain token execution price, order-book liquidity, brokerage availability, or an executable quote. ##### Physical Sources | Source | Role | | --- | --- | | `reviewed business token listings` | Shared Business-to-network projection used by ordinary token enrichment and RWA listings. Categories, tags and search aliases are unioned across active available mappings. The selected record retains its complete custom_fields JSON for internal use; Graph explicitly projects supported public fields. RWA consumers select is_preferred_rwa. | | `equities.fmp_underlying_latest` | Optional ticker-keyed enrichment over FMP current aggregate states. No registry membership dependency. | ##### API Access **GraphQL paths:** `equities.tokenizedEquities` **MCP map operations:** `getTokenizedEquities` **Entity mappings:** `TokenizedEquity` ##### Relationships - mint can be resolved through Solana token current state for on-chain profile and DEX context. - RWA eligibility uses the same mint/category matching as ordinary tokens, with explicit blockchain_ai_preferred=true and the RWA Token category. Categories and tags remain arrays; display groups are consumer presentation rules. #### `trader-profile` - Trader profiles Current trader profiles in the Trader or Influencer category with at least one valid configured wallet. - **Classification:** `entity` - **Grain:** `One current profile per trader ID.` **Identity:** `Trader.id` Graph refreshes the normalized directory after five minutes, retains a stale snapshot for up to 30 minutes on refresh failure, and backs off retries for 30 seconds. Source replication freshness is independent. ##### Time Semantics - updatedAt is the Business profile update time, not the first trade or proof of wallet age. ##### Authoritative For - Business profile identity and configured wallet associations. ##### Not Authoritative For - Wallet ownership verification, ROI, copy-trading participation, or non-Solana wallet analytics. ##### Physical Sources | Source | Role | | --- | --- | | `Business profile directory` | Latest normalized trader identity, labels, public social profiles, and configured wallet associations. | ##### API Access **GraphQL paths:** `traders` **MCP map operations:** `listTraders` **Entity mappings:** `Trader` ##### Relationships - Configured Solana addresses can be queried through solana.wallet.activityExt and currentHoldings. #### `simulation-session` - Virtual paper-trading session Isolated virtual balances and ordered operation results priced from real swap simulations. Usage and limitations are documented at https://graph.blockchain.ai/simulation.md. - **Classification:** `entity` - **Grain:** `One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.` **Identity:** `sessionId` ##### Authoritative For - Virtual session balances and recorded operation results. ##### Not Authoritative For - On-chain holdings, actual transaction execution, historical backtests or future returns. ##### Physical Sources | Source | Role | | --- | --- | | `Virtual simulation ledger` | Persisted balances, reservations and operation results. | | `Verified Solana swap simulations` | Direct or atomic two-hop fill evidence; no transaction submission. | ##### API Access **GraphQL paths:** `solana.simulation.start`, `solana.simulation.seed`, `solana.simulation.quote`, `solana.simulation.buy`, `solana.simulation.sell`, `solana.simulation.status`, `solana.simulation.holdings`, `solana.simulation.destroy`, `solana.simulation.getWalletToken` **MCP map operations:** `startSimulation`, `fundSimulation`, `quoteSimulation`, `buySimulation`, `sellSimulation`, `getSimulation`, `getSimulationHoldings`, `destroySimulation`, `getSimulationWalletToken` ## Workflows ### `latestGraduatedToken` Find the latest graduated pool/token, fetch current token metadata, and optionally inspect post-graduation candles. #### Use When - The user asks for the latest graduated token. - The user asks how long a Pump.fun token took to graduate. - The user wants post-graduation price or volume behavior. #### Steps ##### 1. Latest graduated pool - **Tool:** `list_pools` Read pool.graduation.at plus baseMint and quoteMint. Do not treat this pool's inceptionAt as token launch time. ###### Arguments ```json { "filter": { "graduated": true }, "orderBy": { "field": "GRADUATION_AT", "direction": "DESC" }, "limit": 1 } ``` ##### 2. Current metadata - **Tool:** `get_token` Use token.firstSeenAt as the practical launch timestamp for Pump.fun graduation-duration calculations. ###### Arguments ```json { "mint": "baseMint" } ``` ##### 3. Post-graduation performance - **Tool:** `get_dex_token_candles` Candles are cache-retention-bound. Keep continuous true for chart-ready buckets filled from cached 1-minute fair price rows. ###### Arguments ```json { "mint": "baseMint", "from": "graduation.at" } ``` #### Calculations - timeToGraduate = pool.graduation.at - token.firstSeenAt - Do not compute timeToGraduate from PumpSwap pool inceptionAt. ### `resolveTradeVenue` Resolve the actual DEX exchange program for an indexed trade without confusing it with an aggregator or router. #### Use When - The user asks which exchange, DEX, venue, launchpad, AMM, or pool program executed a trade. - A wallet activity, historical transaction, or unconfirmed trade row has poolAddress. - The user asks for reviewed behavior attributes of the exchange program. #### Steps ##### 1. Retain pool identity - **Tool:** `list_wallet_activity` Read poolAddress from the trade. For token/pool history use get_dex_token_transactions or get_dex_pool_transactions instead. aggregatorProgram is optional router context and does not identify the pool venue. ##### 2. Resolve venue program - **Tool:** `list_pools` Read programId and programName from the matching pool row. ###### Arguments ```json { "poolAddresses": [ "trade.poolAddress" ], "limit": 1 } ``` ##### 3. Read reviewed program attributes - **Tool:** `get_program` Use the pool programId, never trade.aggregatorProgram, as the dictionary key for the venue. ###### Arguments ```json { "programId": "pool.programId" } ``` ### `walletHoldingsResponse` Answer a wallet-holdings request with a concise activity-date summary followed by a logo-enriched holdings table. #### Use When - The user asks what a Solana wallet currently holds, owns, or has in its portfolio. - The user asks for wallet token balances with readable token identity or logos. #### Steps ##### 1. Read effective holdings - **Tool:** `list_wallet_current_holdings` Retain mint, currentHoldings, firstTransferToWalletAt, and lastTransferToWalletAt. These timestamps are indexed transfer observations, not proof of account creation. ##### 2. Enrich token presentation - **Tool:** `list_tokens` Batch unique mints in groups of at most 100 and set limit to the batch size. Read mint, tokenSymbol, tokenName, and logoUrl, then join by mint because list_tokens does not preserve input order. ###### Arguments ```json { "mints": [ "holding.mint" ], "limit": 100 } ``` ##### 3. Compose the answer Start with a short description of the latest observed activity dates, then render the holdings table. Keep NativeSOL and wrapped SOL separate. #### Suggested Response Template - Open with one or two sentences naming the wallet's most recent lastTransferToWalletAt and, when available, the observed span from the earliest firstTransferToWalletAt to the latest lastTransferToWalletAt. Describe these as indexed transfer activity dates, not wallet creation dates. - Then render a Markdown table with columns Logo | Token | Mint | Amount | First activity | Last activity. Use tokenSymbol and tokenName from list_tokens for Token. Render a non-null logoUrl as ![symbol](logoUrl); leave the Logo cell empty when no logo is returned and never invent one. - Present the returned holdings in descending currentHoldings order unless the user requests another order. If results were limited or token metadata required multiple batches, state that clearly. ### `walletActivityResponse` Answer a wallet-activity request with transaction activity first and the wallet's current logo-enriched holdings at the end. #### Use When - The user asks what a Solana wallet did during a period or at a slot. - The user asks for wallet trades, transfers, buys, sells, funding, exits, or transaction history. #### Steps ##### 1. Read activity and current holdings - **Tool:** `list_wallet_activity` Use activity for the selected period or slot. metadata.currentHoldings is interval-independent current state and must not be filtered to the requested activity window. ##### 2. Enrich holding presentation - **Tool:** `list_tokens` Batch unique holding mints in groups of at most 100. Read mint, tokenSymbol, tokenName, and logoUrl and join by mint. Do not call list_wallet_current_holdings again when metadata.currentHoldings was returned. ###### Arguments ```json { "mints": [ "metadata.currentHoldings.mint" ], "limit": 100 } ``` ##### 3. Compose activity then holdings Summarize activity grouped by txHash without double-counting trade perspectives. Finish with the same summary and holdings table defined by walletHoldingsResponse. #### Suggested Response Template - Activity: briefly identify the requested period or slot and retained coverage, then present transactions in API order grouped by txHash. Describe trades as execution context and transfers as authoritative wallet-relative movement; do not sum duplicate trade perspectives. Separate direct TRADER activity from TRANSFER_LINKED context. Label linked incoming output Received from swap and linked outgoing input Sent to swap; do not count another trader's swap as a wallet-funded purchase or sale without supporting wallet transfers. - Current holdings: always finish the response with a Current holdings section using metadata.currentHoldings and the walletHoldingsResponse format. Include the short last-activity-date summary and the Markdown table Logo | Token | Mint | Amount | First activity | Last activity. - Use list_tokens to add tokenSymbol, tokenName, and logoUrl for each holding mint. Render only returned logos and state when currentLimit or metadata batching made the holdings list incomplete. ### `walletInvestigationResponse` Answer a question focused on one wallet with first seen and funding evidence, all available activity since first seen, and current holdings last. #### Use When - The question focuses on a particular Solana wallet, including its history, funding, behavior, or an investigation of that wallet. #### Steps ##### 1. Discover first seen before reading history - **Tool:** `query_graphql` Supply the wallet and a short current UTC period with from < to in variables. Select only metadata.firstTransferToWalletAt and metadata.coverage: metadata is independent of the required selector, and omitting activity avoids reading history. Report firstTransferToWalletAt as first seen, and compute historyStart = max(firstTransferToWalletAt, coverage.indexedFromAt). This is the inclusive lower bound for every subsequent history query. Do not infer wallet first seen from only its remaining non-zero holdings, from a token's firstSeenAt, or from service coverage. If first seen or indexedFromAt is null, report the missing boundary and do not run history queries until both are known; do not guess an earlier date or scan backward. ###### Arguments ```json { "query": "query WalletFirstSeen($wallet: String!, $period: SolanaWalletActivityPeriodInput!) { solana { wallet { activityExt(wallet: $wallet, period: $period, allowRpcFallback: false) { metadata { firstTransferToWalletAt coverage { indexedFromAt indexedThroughAt } } } } } }" } ``` ##### 2. Read all activity within indexed coverage - **Tool:** `list_wallet_activity` Freeze the report time and cover the available interval from historyStart to that time with allowRpcFallback=false. Never query activity before the earliest indexed timestamp or wallet first seen; keep this focused report within retained indexed coverage. When a result reaches the transaction limit, subdivide its period and continue until all available transactions are covered; overlap boundaries slightly and deduplicate by (blockSlot, txHash), keeping every period.from at or after historyStart, including overlap. Retain transfers, trades, burns, non-DeFi activity, and small third-party movements. Read metadata.coverage and identify coverage gaps or unresolved truncation instead of claiming complete history. Do not request backfill or pre-index recovery to fill gaps; every retry stays at or after historyStart with allowRpcFallback=false. If first seen predates indexedFromAt, state that the earlier activity and original funding cannot be established from retained indexed history. ###### Arguments ```json { "wallet": "queried wallet", "period": { "from": "max(metadata.firstTransferToWalletAt, metadata.coverage.indexedFromAt)", "to": "report time in UTC" }, "allowRpcFallback": false, "direction": "ASC", "limit": 10000 } ``` ##### 3. Identify the earliest observed funding Inspect the earliest external INBOUND transfers in chronological activity. Report blockTime, txHash/txExplorerUrl, the funding wallet from sourceOwner/sourceOwnerExplorerUrl, and the exact amount with mint or asset name. For NativeSOL, sourceAccount may identify the sender when sourceOwner is absent; for token transfers, do not label a token account or authority as the funding wallet. Keep NativeSOL and wrapped SOL separate. Use actual transfer evidence, not trade notional, current balances, SELF movement, or AUTHORITY_ONLY rows. If the initial transaction has multiple funding transfers, list each funder and amount. Describe this as earliest observed funding; missing counterparties, balance-delta-only evidence, or incomplete coverage do not establish the original funder. Do not search earlier dates to fill missing evidence. ##### 4. Finish with current holdings - **Tool:** `list_tokens` Use interval-independent metadata.currentHoldings from the latest activity response and follow walletHoldingsResponse. Page with currentSkip/currentLimit when needed without extending the history interval, and batch unique mints through list_tokens in groups of at most 100 with limit equal to the batch size. Join token labels and logos by mint. If either history boundary was unavailable and no activity query ran, use query_graphql to select only currentHoldings { mint mintExplorerUrl currentHoldings firstTransferToWalletAt lastTransferToWalletAt } under solana.wallet.currentHoldings(wallet: ...); omit flow fields and hasUnvaluedHistoricalFlow so this focused report does not trigger history recovery. #### Suggested Response Template - First seen: name the wallet and metadata.firstTransferToWalletAt in UTC, labelled as its earliest indexed transfer observation rather than account creation. State unavailable when no timestamp was returned. - Funding: show the earliest observed funding time, linked transaction hash, linked funding wallet, asset, and exact transferred amount. List multiple initial funders separately and state any missing evidence. - Activity since first seen: present all available indexed transactions chronologically from max(first seen, indexedFromAt) through the stated report time, grouped by txHash. Keep transfers authoritative for wallet movement and avoid double-counting trade perspectives. State any gap between first seen and indexed coverage; never query earlier dates or trigger backfill. - Current holdings: always finish with the current wallet balances using walletHoldingsResponse, including the short activity-date summary and Logo | Token | Mint | Amount | First activity | Last activity table. These balances are current state, independent of the history interval. ### `enrichTransactions` Batch-enrich transaction hashes returned by wallet, DEX, pool-graduation, or other indexed queries with transaction-level fee/resource and program-interaction context. #### Use When - A prior tool returned one or more txHash values and the user asks about fees, compute use, Jito tips, Token-2022 fees, activity counts, or invoked programs. - The user provides transaction signatures directly. - A forensic workflow needs transaction-level context without duplicating DEX trades or transfer rows under the transaction object. #### Steps ##### 1. Collect transaction hashes Collect unique txHash values from the prior result while retaining first-occurrence order. ##### 2. Batch transaction enrichment - **Tool:** `get_transactions` Send 25 to 100 hashes per request when possible. The hard maximum is 100. ###### Arguments ```json { "transactionHashes": [ "txHash1", "txHash2" ] } ``` ##### 3. Compose specialized context Keep wallet transfers authoritative for wallet movement and DEX rows authoritative for trade execution. Use get_transactions only for transaction-level fee/resource/program context. ## Reasoning Patterns ### `timeToGraduate` - Time to graduate Estimate how long a token took to graduate from launch/inception to the recorded graduation event. #### Pattern 1. Find the graduated pool with list_pools(filter.graduated=true) or a known pool/mint. 2. Read pool.graduation.at and the relevant token mint. 3. Fetch token metadata with get_token or list_tokens/list_tokens_ext. 4. Compute pool.graduation.at - token.firstSeenAt. #### Canonical Formula ```text timeToGraduate = pool.graduation.at - token.firstSeenAt ``` #### Notes - For Pump.fun tokens, token.firstSeenAt is the launch proxy. - Do not use PumpSwap pool.inceptionAt as token launch time. ### `currentHealth` - Current health Summarize current market state using primitive current-token and pool/liquidity data plus short recent price context. #### Pattern 1. Fetch current metadata and market fields with get_token or list_tokens_ext. 2. Select token.anchoredTvlUsd as the current conversion-path TVL signal. tokensExt.tvlUsd is only a compatibility alias of the same value. 3. When broader pool coverage is needed, call list_pools for the mint and assess the returned pool tvlUsd values; this is especially important for recognized base-anchor assets that can report token anchoredTvlUsd as zero. 4. Fetch recent candles with get_dex_token_candles for short windows when price trajectory is needed. 5. Compare token anchored TVL, explicit pool TVL when relevant, market cap, and recent candle shape without inventing external risk scores. #### Canonical Formula ```text tokenHealthInputs = token.anchoredTvlUsd + marketCapUsd + recent candles; broaderPoolCoverage = sum or inspect list_pools[].tvlUsd ``` #### Notes - anchoredTvlUsd is preferred for non-base-token TVL assessments because a recognized liquid conversion side bounds it. - tokensExt.tvlUsd aliases anchoredTvlUsd; pool.tvlUsd is normalized indexed DEX pool liquidity. - marketCapUsd and price fields are current token_stats enrichment when selected. ### `postGraduationPerformance` - Post-graduation performance Inspect token price and volume behavior after graduation. #### Pattern 1. Find graduation timestamp from pool.graduation.at. 2. Fetch candles with get_dex_token_candles(mint=tokenMint, from=pool.graduation.at). 3. Use candle close/high/low/vwap and volume fields to describe post-graduation movement. #### Canonical Formula ```text postGraduationWindow = candles where bucket >= pool.graduation.at ``` #### Notes - Candles are bounded by local cache retention. - Use token.firstSeenAt only for launch duration, not for post-graduation start. ### `momentum` - Momentum Estimate recent directional activity from short-window candles and fair-quality volume primitives. #### Pattern 1. Fetch recent candles with get_dex_token_candles. 2. Use tokensExt for supported rolling fair-volume windows and price-change fields. 3. Combine recent candle direction with fairVolume/volume fields; do not infer predictive certainty. #### Canonical Formula ```text momentumInputs = recent candles + fair volume ``` #### Notes - Use fair volume when the task needs cleaner DEX activity than raw visible volume. - This is descriptive analytics, not price prediction. ### `tradeVenueResolution` - Resolve a trade's exchange venue Identify the DEX program that owns the pool used by an indexed trade and optionally read its reviewed behavior attributes. #### Pattern 1. Read poolAddress from the wallet activity, historical transaction, or unconfirmed trade row. 2. Call list_pools(poolAddresses: [poolAddress], limit: 1). 3. Use pool.programName as the resolved venue label and pool.programId as the canonical venue program id. 4. Call get_program(programId=pool.programId) when reviewed program behavior attributes are needed. #### Canonical Formula ```text trade venue = list_pools(poolAddresses: [trade.poolAddress])[0].programId/programName ``` #### Notes - aggregatorProgram identifies an aggregator or router when known; it is not the pool exchange venue. - Do not pass aggregatorProgram to get_program as a substitute for pool.programId. ### `recentDexTransactions` - Recent DEX transactions and activity Inspect executed DEX trades, optional liquidity events, and simple activity counters for one token or pool. #### Pattern 1. Use solana.dex.tokenTransactions(mint, filter, skip, limit) for top-level User, MEV, and Buyback operations plus optional liquidity events for a token. Technical Inner and UnresolvedInner route rows are excluded. 2. Use solana.dex.poolTransactions(poolAddress, filter, skip, limit) for deduplicated venue traffic. Physical pools count each execution once from the pool base token perspective; older history uses only indexed Inner execution perspectives. The virtual 'Ondo RWA' venue uses one preferred non-quote User perspective per transaction operation. 3. Use solana.dex.tokenActivity(mint, period) for top-level User, MEV, and Buyback operation count, buy/sell counts, or active wallet count over a required period. 4. Use solana.dex.poolStats(poolAddress) for a compact current venue snapshot. Physical pools provide latest price, price changes, volume, and activity counts. 'Ondo RWA' provides venue-wide volume and activity counts but zero price fields because it spans many token markets. 5. Batch returned txHash values through get_transactions when transaction fees, compute usage, Jito tips, Token-2022 fees, activity counts, or ordered program interactions are needed. 6. When the user asks which exchange executed a trade, resolve a physical poolAddress with list_pools and use programId/programName. Do not call list_pools for the exact virtual venue label 'Ondo RWA'. 7. Use tokenCandles for OHLCV chart buckets; use transaction rows when the user asks for individual trades. #### Preferred Fields - `timeUnixSeconds` - `kind` - `priceUsd` - `volumeUsd` - `baseTokenAmount` - `quoteTokenAmount` - `maker` - `txHash` - `txExplorerUrl` - `poolAddress` - `otherToken` - `otherTokenSymbol` - `operationIndex` - `tradeLayer` - `aggregatorProgram` - `relayerWallet` - `gatewayFees` - `ammFees` - `compoundFees` - `baselinePriceUsd` - `potentialSlippage` - `poolPriceConfidence` #### Notes - Transactions are indexed historical rows newest first, not websocket live subscriptions. - DexTokenTransactionsFilterInput.sinceUnixSeconds defaults to a 24 hour lookback if omitted. - includeLiquidityEvents defaults to true; minVolumeUsd applies to trades only. - tokenActivity requires an explicit period. - poolStats is cached briefly and uses the same deduplication semantics as poolTransactions, including the separate 'Ondo RWA' virtual-venue path. - priceUsd and volumeUsd are indexer-supplied row values; Graph does not recalculate them from the legs. - A physical trade poolAddress resolves through list_pools. 'Ondo RWA' is a virtual venue label with no physical pool row. aggregatorProgram is router context rather than a physical venue id. - gatewayFees and ammFees are nullable attributed fee ratios. compoundFees is always their compatibility sum, treating a missing component as zero. ### `transactionEnrichment` - Enrich transaction hashes Add transaction-level fee, compute, tip, activity-count, and program-invocation context to txHash values returned by specialized data tools. #### Pattern 1. Collect txHash values from list_wallet_activity, get_dex_token_transactions, get_dex_pool_transactions, pool graduation metadata, or direct user input. 2. Deduplicate hashes while retaining first occurrence and call get_transactions in batches of 25 to 100, never more than 100. 3. Select fee for fee/resource/Jito/Token-2022 details and programInteractions for ordered top-level and inner program invocations. 4. Join the returned rows back by txHash; hashes absent from both transaction source tables are omitted rather than returned as null. #### Canonical Formula ```text specialized rows by txHash + get_transactions(unique txHash batch) ``` #### Notes - get_transactions preserves first-occurrence input order after deduplication. - It does not duplicate DEX trades, transfers, wallet activity, or pool rows. - Native-SOL-only movement transactions are eligible for fee/program enrichment, but this operation does not return their source, destination, or transferred lamports. - Execution success/error is not currently available from its source tables. ### `freshGraduates` - Fresh graduates List recently graduated pools/tokens in newest-graduation order. #### Pattern 1. Call list_pools with filter.graduated=true. 2. Order by GRADUATION_AT DESC. 3. Use returned baseMint/quoteMint to fetch token metadata with get_token or list_tokens_ext. #### Canonical Formula ```text freshGraduates = list_pools(filter.graduated=true, orderBy=GRADUATION_AT DESC) ``` #### Notes - Use INCEPTION_AT only when the user explicitly asks for newest pool creation. - For time-to-graduate, join the token firstSeenAt after finding graduation.at. ### `backingPools` - Backing or liquidity pools for a token Find indexed DEX pools where a token's liquidity sits or where the token is paired with another mint. #### Use When - The user asks for backing pools, liquidity pools, pools for token X, paired pools, where token liquidity sits, or pairs backing token X. - The user provides a human token name or symbol and wants pools. - The user provides a mint and wants pools directly. #### Pattern 1. If the user provides a mint, use it directly. 2. If the user provides a human token name or symbol, call tokenSearch(query) and pick the best symbol/name match before querying pools. 3. Call solana.pool.pools(mints: [tokenMint], includeDysfunctional: false). 4. Interpret returned rows as indexed DEX pools where tokenMint is either baseMint or quoteMint. 5. Build uniqueOtherMints from each pool's opposite side and call solana.tokens(mints: uniqueOtherMints) for readable counterpart token symbols/names. #### Preferred Fields - `poolAddress` - `programId` - `programName` - `baseMint` - `quoteMint` - `tvlUsd` - `baseLiquidity { currentHoldings priceUsd liquidityUsd }` - `quoteLiquidity { currentHoldings priceUsd liquidityUsd }` - `inceptionAt` - `lastObservedAt` - `isDysfunctional` #### Canonical Formula ```text backingPools(tokenMint) = solana.pool.pools(mints: [tokenMint], includeDysfunctional: false) ``` #### Notes - Backing pools means indexed DEX pools containing the token. It does not mean reserves, holders, LP ownership, treasury backing, or off-chain backing. - Use Blockchain.ai GraphQL pool.pools rather than web search for Solana token pool/liquidity/backing-pool requests. - Fetch counterpart token metadata with solana.tokens(mints: uniqueOtherMints) for readable pair labels. ## Query Operations ### `build_swap_transaction` - **Map operation:** `buildSwapTransaction` - **Title:** `Build unsigned swap transaction` - **Kind:** `query` - **GraphQL path:** `solana.swap.buildTransaction` Automatically find a direct, split or two-hop swap for a real wallet, check funds/accounts and return an unsigned transaction with account setup and minimum output. The wallet signs and submits. **Data dictionary:** `solana-unsigned-swap-transactions` (fact; One independently prepared transaction for a wallet, input/output mint pair, exact input and build time.) #### Arguments ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Real system wallet address; sole fee payer and signer. ##### `inputMint` - **GraphQL type:** `String!` - **Required:** `true` Token to spend; SOL and NativeSOL aliases are accepted. ##### `outputMint` - **GraphQL type:** `String!` - **Required:** `true` Token to receive. Matching inputMint requests an atomic two-hop round trip through different pools. Optional routeHint constrains or prioritizes a pool. ##### `inputAmount` - **GraphQL type:** `Decimal` - **Required:** `false` Positive input, at most 1 billion, in selected units. Supply exactly one of inputAmount, inputAmountRaw or maxInput: true. ##### `minOutputAmount` - **GraphQL type:** `Decimal` - **Required:** `false` Optional positive final-output floor in selected units. Replaces the slippage-derived final floor; rounds upward to a source base unit. An unmet floor returns an error without a transaction. ##### `slippageBps` - **GraphQL type:** `Int!` - **Default:** `100` Tolerance, 0-9900 basis points; 100 = 1%, 9900 = 99%. Sets the final floor when minOutputAmount is omitted. Fixed-input two-hop fallback routes also use it for their intermediate buffer. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean!` - **Default:** `true` Defaults true. Apply on-chain scaled UI units to inputAmount, minOutputAmount and displayed outputs; raw integer amounts always use source base units. ##### `priorityFeeLamports` - **GraphQL type:** `Long!` - **Default:** `0` Priority fee cap, 0-1000000 lamports. Defaults to 0 (no priority fee), excluding base fee and deposits. ##### `unwrapSol` - **GraphQL type:** `Boolean!` - **Default:** `false` Return route SOL output or intermediate WSOL remainder as native SOL using an isolated temporary account. Existing accounts are preserved unless closeInputAccount is also requested. ##### `maxInput` - **GraphQL type:** `Boolean!` - **Default:** `false` Sell the selected token account's full raw balance without UI rounding. Without inputTokenAccount selects the largest spendable account, preferring the ATA on ties. Does not consolidate accounts; SOL Max uses existing WSOL only, never native SOL needed for fees/rent. ##### `inputAmountRaw` - **GraphQL type:** `String` - **Required:** `false` Positive UInt64 input in source base units as an integer string. Independent of UI multipliers; mutually exclusive with inputAmount and maxInput. ##### `inputTokenAccount` - **GraphQL type:** `String` - **Required:** `false` Optional owned, initialized, unfrozen input token account. Must already fund the input; explicit accounts are not topped up with native SOL. Otherwise selected automatically. ##### `closeInputAccount` - **GraphQL type:** `Boolean!` - **Default:** `false` Close the selected input account after successful selling and refund its deposit. Non-SOL remainder must be zero or within maxDustBurnAmountRaw. Input WSOL remainder returns as native SOL, never burns. ##### `maxDustBurnAmountRaw` - **GraphQL type:** `String` - **Required:** `false` Optional UInt64 cap in source base units; default zero disables burning. Requires closeInputAccount for a positive cap. Burn only a fixed remainder after a successful full-input swap, never after a failed quote or partial fill. Does not prove a remainder is unsellable. ##### `routeHint` - **GraphQL type:** `RouteHintInput` - **Required:** `false` Optional {poolAddress, mode}. REQUIRE (default) must include the pool or fail; PREFER investigates it first but permits a better route. Discovers counterpart pools automatically within a bounded direct/two-hop search. ##### `maxQuoteAgeMilliseconds` - **GraphQL type:** `Int` - **Required:** `false` - **Minimum:** `1` - **Maximum:** `10000` Optional maximum simulation age at response selection, 1-10000 ms. Original slot/time remain unchanged on reuse; network delivery adds time. Omitted: previews reuse for 2 seconds and accept verified results up to 10 seconds old; builds always run a fresh final simulation. #### Default Selection ```graphql wallet inputMint outputMint inputAmount inputAmountRaw expectedOutputAmount minimumOutputAmount minimumOutputAmountRaw simulatedOutputAmount slippageBps adjustForUiMultiplier inputUiMultiplier outputUiMultiplier transactionBase64 messageBase64 transactionVersion blockhash lastValidBlockHeight checkedSlot builtAt networkFeeLamports priorityFeeLamports wrappedSolFundingLamports unwrapSol unwrappedSolLamports closedTokenAccounts closedTokenAccountExplorerUrls additionalSolDebitLamports requiredSigners createdTokenAccounts intermediateMint intermediateRemainderRaw searchLimited routeKind minimumOutputScope route { poolAddress programId inputMint outputMint inputAmountRaw minimumOutputAmountRaw pathIndex stepIndex inputShareBps usesPreviousOutput } info { inputTokenAccount inputTokenAccountExplorerUrl inputAccountBalanceRaw maxInput inputAccountRemainderRaw fees { baseNetworkFeeLamports priorityFeeLamports totalNetworkFeeLamports } rent { depositedLamports refundedLamports netDepositLamports accounts { account accountExplorerUrl depositedLamports refundedLamports } } dustBurns { mint mintExplorerUrl tokenAccount tokenAccountExplorerUrl amountRaw amount capRaw } wrappedSolFundingLamports unwrappedSolLamports otherSolDebitLamports walletSolChangeLamports } routeHintUsed reused quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. ##### `minimumOutputAmount` Minimum net amount the wallet must receive after token transfer fees, in the selected display/source units. Slippage is applied to the net simulated output. #### Caveats - No session or pool choice is required. The bounded search considers direct markets and two-hop paths through SOL, USDC and up to two additional anchors. searchLimited is true; this is best among successfully validated candidates, not a global optimum. - Matching input/output mints, including SOL aliases, request an atomic round trip through two different pools. The response remains two_hop with minimumOutputScope leg and protected fixed inputs in one transaction. Output amounts are gross returns, not profit or total wallet balances; compare against input and account for fees/rent separately. No automatic profit floor: provide minOutputAmount when required. Existing intermediate inventory cannot fund the return leg. unwrapSol isolates only the returned SOL. Closing an input account that also receives the return is rejected with SWAP_INPUT_ACCOUNT_NOT_CLOSABLE; use a separate output account via SOL unwrapping or leave it open. - The wallet signs and submits transactionBase64. Respect transactionVersion (legacy or v1), requiredSigners and lastValidBlockHeight. messageBase64 is the signing message, not a submit-ready transaction. Never replace the blockhash; rebuild after expiry. - Receiving/intermediate account creation and any native SOL wrapping shortfall are included. Missing input accounts, frozen/wrong-owner accounts, insufficient tokens or SOL, unsupported layouts and failed simulations return SWAP_* errors without a transaction. Split input accounts are not consolidated. SOL output remains WSOL by default. With unwrapSol true, only this route's SOL output or intermediate WSOL remainder is returned as native SOL and the temporary account rent is refunded. Existing WSOL accounts/balances remain unchanged except explicitly requested input spending and optional closeInputAccount cleanup. No extra signature is required. - On failure preserve errors[].extensions: traceId, requestId, stage, reason, retryable, elapsedMs, failedAt and request (normalized after validation; submitted values if validation failed). RPC failures additionally identify rpcMethod, rpcEndpoint (primary/fallback), upstreamStatus or rpcCode; minContextSlot and rpcContextSlot explain slot lag when available. poolAddress identifies a candidate when known. Display the error message and retain this self-contained report instead of replacing it with HTTP status or a generic error. No endpoint credentials or raw exception stacks are exposed. Stop automatic retries when retryable is false. Retry transient failures with backoff only; never treat a failed build as executable. - Temporary read and preparation failures receive bounded recovery inside the request: at most two retries per failed stage invocation and six across the build, within its original deadline. SWAP_TEMPLATE_UNAVAILABLE means no usable pool instruction template was obtained: reason template_not_ready with retryable true for temporary missing evidence/cooldown, or unsupported_route with retryable false for unsupported instructions. No transaction is returned if recovery fails. Invalid inputs, insufficient funds, unsupported routes and rejected simulations are not automatically retried. Honor retryable and avoid immediate client retry loops. - unwrappedSolLamports reports native SOL returned from route receipts or explicitly closed input WSOL, excluding deposit refunds. closedTokenAccounts lists both temporary accounts and the explicitly closed input account. Only newly created accounts also appear in createdTokenAccounts. intermediateRemainderRaw still reports surplus returned as native SOL. additionalSolDebitLamports is signed net deposits after refunds plus other SOL debits; a refund can make it negative. unwrapSol alone never closes input accounts. - minOutputAmount, when supplied, replaces the slippage-derived final floor. Otherwise slippageBps sets the final floor against the selected atomic quote. Reviewed composed two-hop routes consume the preceding leg actual receipt, with no intermediate buffer or remainder; usesPreviousOutput marks that leg and its inputAmountRaw is a final-simulation observation. Other adapters retain buffered fixed-input fallback routes. Final simulation proves that existing intermediate holdings were not consumed and the final floor was met. - routeKind distinguishes direct, split and two_hop. pathIndex/stepIndex identify parallel paths and sequential legs. Split inputShareBps sums to 10000. When minimumOutputScope is route, the top-level minimumOutputAmountRaw protects combined output and leg minima are zero. Reviewed composed layouts cover PumpSwap, Raydium CPMM/CLMM, Orca Whirlpool, PancakeSwap, Meteora DLMM, DAMM V2, HumidiFi, BisonFi and Tessera. Unrecognized layouts retain protected native fallbacks. Splits are bounded two-pool direct comparisons and must beat the best measured direct quote. No JIT selection or split two-hop search. - networkFeeLamports includes priorityFeeLamports. additionalSolDebitLamports includes account deposits and other simulated SOL debits beyond wrapping and network fee. - Eligible adapters: PumpSwap, Raydium CPMM/CLMM, Orca Whirlpool, PancakeSwap, Meteora DLMM, DAMM V2, HumidiFi, BisonFi and Tessera. HumidiFi, BisonFi and Tessera use on-chain minimum-output wrappers; composed routes use fixed pool selection, without JIT or an off-chain quote API. Other quote-only routes and transfer-fee output/intermediate mints are excluded until their net minimum-output constraint is supported. No unconstrained fallback. - adjustForUiMultiplier defaults true and applies current on-chain scaled multipliers to inputAmount, minOutputAmount and displayed outputs. Raw integer fields always use source base units; displayed input can round down, while an explicit minimum rounds up so its floor is never weakened. Interest-bearing display conversion is unsupported; use source units instead. - No signatures, private keys or on-chain submissions are handled by Graph. A successful final simulation can still expire or fail after market/account state changes. - Review info before signing: network fees include priority fees; rent deposits and refunds are separate gross amounts with per-account detail, including temporary accounts. Token/pool fees are reflected in swap receipts but are not itemized as network fees. Other SOL debits are reported separately rather than assumed to be rent. - Burning is disabled unless a positive maxDustBurnAmountRaw cap and closeInputAccount are explicitly supplied. The exact fixed burn is listed in info.dustBurns and excluded from inputAmountRaw. Larger remainders, insufficient close authority and withheld account transfer fees produce errors. Partial fills, failed quotes and balance changes cannot turn into a burn fallback. A burn decreases supply and is irreversible if the caller signs and submits. - Exactly one amount selector is required: inputAmount, inputAmountRaw, or maxInput true. Existing inputAmount calls remain valid. Raw/Max avoid display rounding and preserve full UInt64 balances. Max reads one current token account, not a wallet-wide sum or a native SOL maximum. - Transfer-fee output or intermediate mints require a reviewed net-output adapter: Raydium CPMM, Raydium CLMM or Orca Whirlpool. Other adapters remain excluded for those legs. Expected, simulated and minimum outputs are net receipts; do not subtract token transfer fees again. #### Example ```graphql query BuildSwap($wallet: String!, $minOutputAmount: Decimal) { solana { swap { buildTransaction(wallet: $wallet, inputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", outputMint: "So11111111111111111111111111111111111111112", inputAmount: 1, minOutputAmount: $minOutputAmount, adjustForUiMultiplier: true) { transactionBase64 transactionVersion blockhash lastValidBlockHeight minimumOutputAmount requiredSigners } } } } ``` Variables: ```json { "wallet": "REPLACE_WITH_FUNDED_WALLET" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/build_swap_transaction?wallet=REPLACE_WITH_FUNDED_WALLET) ### `get_market_snapshot` - **Map operation:** `getMarketSnapshot` - **Title:** `Get the Solana market snapshot` - **Kind:** `query` - **GraphQL path:** `solana.marketAnalytics.snapshot` Read one internally consistent per-minute market snapshot for dashboard headline metrics. All returned metrics share the same asOf minute; prefer this operation over assembling global counts, trailing volume, the BlockchainAI100 index, and aggregate RSI from separate token pages. **Data dictionary:** `solana-market-snapshot` (fact; One precomputed market snapshot per UTC minute; every headline metric in a returned snapshot shares the same asOf minute.) **Related topics:** `market analytics`, `market snapshot`, `tokens tracked`, `24h volume`, `BlockchainAI100`, `aggregate RSI`, `dashboard metrics` #### Use When - A dashboard needs market-wide headline cards or sparklines with one shared timestamp. - The user asks for total tracked tokens, global trailing fair volume, the BlockchainAI100 index, or market-wide RSI. - The client needs a consistent snapshot rather than separately timed token-list aggregates. #### Default Selection ```graphql asOf universe { constituentCount minFairVolumeUsd24h minTvlUsd } tokensTracked { value new24h } volume24h { valueUsd changePercent } index { name value change24hPercent baseValue baseAt rebalancedAt constituentCount } rsi { interval periods average overboughtCount oversoldCount } ``` #### Caveats - All metrics share asOf and are intended to be consumed together. - History fields are downsampled and capped at 1000 points; request them explicitly when needed. - Only FIVE_MINUTES RSI with 14 periods has precomputed history. Other RSI combinations are computed live and return an empty history series. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for one market snapshot.", "additionalProperties": true } ``` #### Example ```graphql query MarketSnapshot { solana { marketAnalytics { snapshot { asOf universe { constituentCount minFairVolumeUsd24h minTvlUsd } tokensTracked { value new24h history { at value } } volume24h { valueUsd changePercent history { at valueUsd } } index { name value change24hPercent constituentCount history { at value } } rsi { interval periods average overboughtCount oversoldCount history { at average } } } } } } ``` Variables: ```json {} ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_market_snapshot) ### `get_market_token_count` - **Map operation:** `getMarketTokenCount` - **Title:** `Count filtered Solana tokens` - **Kind:** `query` - **GraphQL path:** `solana.marketAnalytics.tokenCount` Count distinct token mints matching the same current-state filters as tokensExt and report how many were first seen inside a trailing window. This is a live filter-aware count with no history; ordering, skip, and limit do not apply. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.), `solana-market-snapshot` (fact; One precomputed market snapshot per UTC minute; every headline metric in a returned snapshot shares the same asOf minute.) **Related topics:** `market analytics`, `token count`, `pagination total`, `new tokens`, `filtered count` #### Use When - A token list needs a total row count for its current filter. - The user asks how many matching tokens are new within a trailing number of hours. - A dashboard card needs a filter-aware count rather than the unfiltered snapshot.tokensTracked metric. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional direct mint scope. ##### `filter` - **GraphQL type:** `SolanaTokenFilterInput` Optional current token filter using the same fields and semantics as list_tokens_ext. ##### `windowHours` - **GraphQL type:** `Int` - **Default:** `24` Trailing hours used for newCount. ##### `removeLogicalDuplicates` - **GraphQL type:** `Boolean` - **Default:** `false` When true, collapse logical clone rows using the same policy as list_tokens_ext. #### Default Selection ```graphql total newCount windowHours ``` #### Caveats - newCount uses firstSeenAt >= now - windowHours. - This operation has no ordering, pagination, or historical series. - Use get_market_snapshot for the unfiltered tracked-token metric and its history. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for a filter-aware token count.", "additionalProperties": true } ``` #### Example ```graphql query MarketTokenCount($filter: SolanaTokenFilterInput, $windowHours: Int, $removeLogicalDuplicates: Boolean) { solana { marketAnalytics { tokenCount(filter: $filter, windowHours: $windowHours, removeLogicalDuplicates: $removeLogicalDuplicates) { total newCount windowHours } } } } ``` Variables: ```json { "filter": { "notEmptySymbol": true, "minPriceUsd": 1e-06 }, "windowHours": 24, "removeLogicalDuplicates": true } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_market_token_count?filterNotEmptySymbol=true&filterMinPriceUsd=1e-06&windowHours=24&removeLogicalDuplicates=true) ### `find_hash` - **Map operation:** `findHash` - **Title:** `Resolve a Solana hash or slot` - **Kind:** `query` - **GraphQL path:** `solana.findHash` Resolve one exact Solana transaction signature, account address, or numeric block slot through indexed Graph sources and bounded Solana RPC discovery. Specific token, pool, and reviewed-program roles take precedence over generic account and wallet fallbacks. Every syntactically valid input returns at least one routing record with confirmation status plus suggested GraphQL and MCP drilldowns. With includeRpcInfo=true, rpcResult retains the complete, unfiltered native type-specific RPC result. **Data dictionary:** `solana-hash-resolution` (entity; One routing record per resolved supported role for one exact input hash or slot; every syntactically valid input returns at least one routing record.) **Related topics:** `hash`, `findHash`, `identifier`, `what is this address`, `transaction signature`, `mint address`, `pool address`, `wallet address`, `account address`, `program address`, `block slot`, `RPC finality`, `on-chain existence` #### Use When - The user provides a Solana hash/address without identifying whether it is a transaction, token, pool, program, account, or wallet. - The user provides a numeric slot and wants a block routing record or its indexed transactions. - A client needs explorer-style routing from one exact value to the appropriate operation-specific tool. - The user needs current confirmation or finality for an exact identifier; these lightweight fields are always returned. Set includeRpcInfo to true only for the complete native transaction, account, or block result. #### Arguments ##### `hash` - **GraphQL type:** `String!` - **Required:** `true` Exact Base58 Solana transaction signature or account-like hash, or a non-negative decimal block slot. Surrounding whitespace is trimmed. Base58 matching is case-sensitive. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build the typed explorerUrl for each match. Currently SOLSCAN is the only supported value. ##### `includeRpcInfo` - **GraphQL type:** `Boolean` - **Default:** `false` Whether to retain the complete, unfiltered native type-specific RPC result in rpcInfo. Transactions use parsed getTransaction and keep runtime logs at rpcResult.meta.logMessages; account-like objects use parsed getAccountInfo; slots use getBlock with signatures and rewards. Defaults to false. Lightweight rpcInfo status is always returned: indexed matches with a known slot compare it with the shared cached finalized cluster head, while unresolved identifiers use bounded RPC discovery. #### Default Selection ```graphql hash kind label slot explorerUrl drilldowns { graphqlPath mcpTool argumentName argumentIsList } rpcInfo { slot isFinalized confirmationStatus rpcMethod rpcResult } ``` #### MCP Note Call find_hash before guessing the role of an unidentified Solana value. Use returned specific kinds and drilldowns, and inspect rpcInfo.confirmationStatus. Indexed matches with a known slot compare it with the shared cached finalized cluster head; fallback TRANSACTION, BLOCK, or ACCOUNT routing alone does not prove indexed coverage or existence. Set includeRpcInfo=true only when the complete native rpcResult is needed; transaction logs are inside rpcResult.meta.logMessages. #### Caveats - Matching is exact and Base58 case-sensitive. Use search_tokens for symbol, name, description, partial mint, ellipsis, or case-insensitive token discovery. - Specific TOKEN, POOL, and PROGRAM matches suppress generic ACCOUNT and WALLET fallbacks. Independent specific matches are preserved. - Generic ACCOUNT matching uses a bounded exact query against remote account_identity_current_state. Its label summarizes merged account kind, lifecycle state, owner program, or related token mint. With includeRpcInfo=true, rpcResult also contains the parsed getAccountInfo result when RPC serves it. - Every syntactically valid transaction signature, account address, or non-negative numeric slot returns at least one routing record. A generic fallback kind or label is not proof that the identifier was indexed or exists on-chain. - rpcInfo confirmationStatus is returned for every match. Indexed matches with a known slot compare it with the shared cached finalized cluster head: newer slots report confirmed and covered slots report finalized. When indexed resolution fails, bounded RPC supplies current status. - includeRpcInfo controls only whether native rpcResult is retained. It does not control lightweight status or whether unresolved identifiers require bounded RPC discovery. rpcResult remains complete and unfiltered regardless of sibling GraphQL field selections; transaction logs remain at rpcResult.meta.logMessages. - rpcInfo.rpcMethod identifies rpcResult's native Solana JSON-RPC shape. For getTransaction this includes the parsed message plus execution metadata such as fee, balances, token balances, inner instructions, logs, rewards, return data, and compute usage when supplied by the RPC provider. - Numeric slots use getBlock with transactionDetails=signatures and rewards=true. This returns block metadata, transaction signatures, and rewards without embedding every full transaction; resolve individual signatures to obtain logs and full execution metadata. - Account-like specific matches share one getAccountInfo request within a find_hash execution, even when the same address resolves to multiple supported roles. - A specific indexed or RPC-discovered match is positive routing evidence at resolution time. A generic fallback remains only a syntactic routing record and must not be treated as proof of on-chain existence. - RPC finality checks reuse a singleton maximum-finalized-slot value for 300 milliseconds, matching the advancing finalized head without issuing one getSlot request per find_hash call. - Individual indexed-source failures and timeouts are isolated and logged so other probes and RPC fallback can still return a routing record. A returned fallback does not prove all indexed sources were healthy. - Wallet matching uses the account registry's wallet classification when present and uses wallet_slot_index_v2 for indexed wallet evidence. A generic ACCOUNT match has no object drilldown until an account-details query exists. - Use get_transactions and get_transaction_activity for normalized indexed transaction fields. rpcResult is the native RPC representation and is intentionally not normalized into those Graph entities. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope containing one or more routing interpretations for a syntactically valid hash or slot.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "findHash": { "type": [ "array", "null" ], "minItems": 1, "items": { "type": "object", "additionalProperties": false, "properties": { "hash": { "type": "string", "description": "Trimmed exact input value." }, "kind": { "type": "string", "description": "Resolved routing kind. A generic ACCOUNT fallback is possible when no specific role resolves.", "enum": [ "TRANSACTION", "TOKEN", "POOL", "PROGRAM", "ACCOUNT", "WALLET", "BLOCK" ] }, "label": { "type": [ "string", "null" ], "description": "Short resolved display label." }, "explorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "drilldowns": { "type": "array", "items": { "type": "object", "additionalProperties": false, "properties": { "graphqlPath": { "type": "string" }, "mcpTool": { "type": [ "string", "null" ] }, "argumentName": { "type": "string" }, "argumentIsList": { "type": "boolean" } }, "required": [ "graphqlPath", "mcpTool", "argumentName", "argumentIsList" ] } }, "slot": { "type": [ "string", "null" ], "description": "Precision-safe resolved block slot from indexed context or bounded RPC recovery; null when unknown." }, "rpcInfo": { "type": [ "object", "null" ], "additionalProperties": false, "description": "Current confirmation status for every match. Indexed matches with a known slot are confirmed while newer than the shared cached finalized cluster head and finalized once covered. The complete native rpcResult is retained only when includeRpcInfo is true.", "properties": { "slot": { "type": [ "string", "null" ], "description": "Precision-safe resolved block slot, or null when unknown." }, "isFinalized": { "type": "boolean", "description": "Whether the resolved object or slot is currently treated as finalized." }, "confirmationStatus": { "type": [ "string", "null" ] }, "rpcMethod": { "type": [ "string", "null" ], "description": "RPC method used to resolve a non-indexed object or produce rpcResult; null for an indexed-only resolution." }, "rpcResult": { "type": [ "object", "array", "string", "number", "boolean", "null" ], "description": "Complete, unfiltered native JSON-RPC result. Its shape does not depend on sibling GraphQL field selections; interpret it according to rpcMethod. Transaction logs remain at meta.logMessages." } }, "required": [ "slot", "isFinalized", "confirmationStatus", "rpcMethod", "rpcResult" ] } }, "required": [ "hash", "kind", "label", "slot", "explorerUrl", "drilldowns", "rpcInfo" ] } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query FindHash($hash: String!, $includeRpcInfo: Boolean = false, $explorer: SolanaExplorerKind = SOLSCAN) { solana { findHash(hash: $hash, includeRpcInfo: $includeRpcInfo, explorer: $explorer) { hash kind label slot explorerUrl drilldowns { graphqlPath mcpTool argumentName argumentIsList } rpcInfo { slot isFinalized confirmationStatus rpcMethod rpcResult } } } } ``` - **Expected minimum rows:** `1` Variables: ```json { "hash": "So11111111111111111111111111111111111111112", "includeRpcInfo": true, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/find_hash?hash=So11111111111111111111111111111111111111112&includeRpcInfo=true&explorer=SOLSCAN) ### `get_token` - **Map operation:** `getToken` - **Title:** `Get a Solana token` - **Kind:** `query` - **GraphQL path:** `solana.token` Read one current-state token_stats-backed Solana token row by mint. Select token2022ExtensionsJson for mint-extension descriptors, including TokenMetadata presence; there is no metadataExtensions field. Token-unit prices and supplyUi use the current Token-2022 UI multiplier by default. Missing description and websiteUrl values fall back to the matching Hero token profile. anchoredTvlUsd is the physical recognized-anchor conversion-path TVL signal; query listPools for broader pool-level coverage. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.) **Related topics:** `graduation`, `graduated`, `how long did it take to graduate`, `token launch`, `token inception`, `firstSeenAt` #### Use When - The user provides one mint and wants token identity, metadata, price, or socials. - The user asks for token details rather than autocomplete or ranking. - The user asks how long a token took to graduate and you already know the token mint; use firstSeenAt as the token first observed DeFi activity timestamp. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Solana mint address. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Multiply supplyUi by the current Token-2022 UI multiplier and divide priceUsd, athUsd, and atlUsd by it. Defaults to true; false returns decimal-adjusted source amounts and source prices. supplyRaw and USD valuations are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit mint, program, and authority URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl tokenSymbol tokenName description priceUsd fdvUsd marketCapUsd anchoredTvlUsd athUsd athAt atlUsd atlAt logoUrl imageUrlResolved websiteUrl twitterUrl telegramUrl discordUrl externalUrl firstSeenAt lastSeenAt status version ``` #### Field Notes ##### `firstSeenAt` Timestamp when the token was first observed in indexed DeFi activity, usually initial pool creation. This is the practical launch/inception timestamp for graduation-duration calculations, not necessarily mint-account creation time. ##### `anchoredTvlUsd` Physical token_stats TVL signal. Eligible pools contribute twice the trusted recognized-anchor reserve, bounding the value by the convertible side rather than the measured token price. Base anchor assets can report zero. Not an executable-depth guarantee or standalone trust verdict. ##### `athUsd` Highest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage, divided by the current Token-2022 UI multiplier by default; athAt is its fair-price source minute. It is not a raw last-trade high. ##### `atlUsd` Lowest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage, divided by the current Token-2022 UI multiplier by default; atlAt is its fair-price source minute. It is not a raw last-trade low. ##### `supplyRaw` Raw on-chain mint supply in smallest token units as a precision-safe decimal string; it is not circulating supply. ##### `supplyUi` supplyRaw divided by 10^decimals and multiplied by the current effective Token-2022 UI multiplier by default, returned as a decimal string. Set adjustForUiMultiplier=false to omit the multiplier. This is mint supply, not circulating supply. ##### `scaledUiAmountMultiplier` Stored prior Token-2022 ScaledUiAmount multiplier. It may be superseded by the scheduled value after its effective timestamp. ##### `effectiveScaledUiAmountMultiplier` Token-2022 display multiplier effective now, after applying any scheduled activation time. It multiplies supplyUi and divides token-unit prices by default. ##### `token2022ExtensionsJson` JSON string containing mint-account Token-2022 extension descriptors, including TokenMetadata presence when present. It is not the full TokenMetadata key-value payload. Select this field explicitly on token, tokens, or tokensExt; there is no metadataExtensions GraphQL field. ##### `scaledUiAmountNewMultiplier` Scheduled Token-2022 ScaledUiAmount multiplier, which may already be effective; scaledUiAmountNewMultiplierEffectiveAt is its activation timestamp. ##### `transferFeeConfigPresent` True means the Token-2022 TransferFeeConfig extension is present, false means a validated mint lacks it, and null means unresolved. A zero rate still reports true. ##### `transferFeeConfigSlot` Precision-safe slot of the latest applied transfer-fee configuration observation. ##### `transferFeeOlderBasisPoints` Older transfer-fee schedule in basis points; use transferFeeOlderEpoch and transferFeeOlderMaximumFeeRaw with it. ##### `transferFeeNewerBasisPoints` Scheduled transfer-fee rate in basis points, applicable from transferFeeNewerEpoch and capped by transferFeeNewerMaximumFeeRaw. Raw caps and epochs are precision-safe strings. ##### `transferFeeWithheldAmountRaw` Fees held by the mint at the last account snapshot, in raw token units. It excludes fees still held in token accounts and is not continuously refreshed by config events. ##### `priceUsd` Latest fair price divided by the current Token-2022 UI multiplier by default. priceSourceMinute identifies the fair-candle minute that supplied it; adjustForUiMultiplier=false returns source units. ##### `fdvUsd` Fully diluted valuation derived from current price and mint supply. ##### `marketCapUsd` Current indexer estimate from available price and supply/profile inputs; it is not an independently audited circulating-supply value. ##### `metadataSource` Indexer label for the source that supplied the selected name, symbol, and metadata URI. ##### `sourceSlot` Precision-safe indexer source slot associated with the token observation. ##### `rpcContextSlot` Precision-safe RPC context slot from the latest mint-account refresh; it is diagnostic and not the row replacement version. ##### `status` Machine-readable current mint/profile decode status; decodeError contains the retained failure detail when present. ##### `imageUrlResolved` Selected display image after original and cached-image resolution. Prefer logoUrl or imageUrlResolved over server-side imageCachedPath. ##### `aliases` Aliases associated with the Solana mint. ##### `categories` Categories associated with the Solana mint; category ids are omitted. ##### `tags` Tags associated with the Solana mint; tag ids are omitted. #### Example ```graphql query Token($mint: String!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { token(mint: $mint, explorer: $explorer) { mint mintExplorerUrl tokenSymbol tokenName priceUsd marketCapUsd anchoredTvlUsd athUsd athAt atlUsd atlAt logoUrl description websiteUrl twitterUrl firstSeenAt lastSeenAt version } } } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_token?mint=So11111111111111111111111111111111111111112&explorer=SOLSCAN) ### `search_tokens` - **Map operation:** `searchTokensAutocomplete` - **Title:** `Search Solana tokens` - **Kind:** `query` - **GraphQL path:** `solana.tokenSearch` Read grouped token autocomplete matches by symbol, name, description, or mint-like input. A WSOL query is treated exactly as a SOL query, including the returned normalized query and every result bucket; no synthetic result is injected. Text candidates exclude tokens not observed during the last 30 days, while exact and shortened mint resolution remains available for older tokens. This is a search/index lookup, not semantic research, token verification, or investment ranking. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.) **Related topics:** `token resolution`, `human token name`, `token symbol`, `backing pools`, `liquidity pools`, `pools for token`, `paired pools`, `where liquidity sits` #### Use When - The user asks to search tokens by text. - The user provides a full, shortened, spaced, ellipsis, or compact concatenated prefix+suffix mint and wants the matching token. - The user needs autocomplete buckets. - The user asks for backing pools, liquidity pools, paired pools, or where token liquidity sits using a human token name or symbol; resolve the token mint here before calling solana.pool.pools(mints: [mint]). #### Arguments ##### `query` - **GraphQL type:** `String!` - **Required:** `true` Search text or mint-like input. Matching is case-insensitive for text, rewrites WSOL to SOL before searching, and supports exact, near-full, prefix...suffix, prefix…suffix, and concatenated prefix+suffix mint forms. ##### `limit` - **GraphQL type:** `Int` Compatibility shortcut maximum rows per bucket. Omit for no explicit bucket limits. ##### `symbolPrefixLimit` - **GraphQL type:** `Int` Maximum symbol-prefix matches. ##### `symbolOrNameContainsLimit` - **GraphQL type:** `Int` Maximum symbol contains/name prefix-or-contains matches. ##### `fuzzyLimit` - **GraphQL type:** `Int` Maximum fuzzy matches. ##### `removeLogicalDuplicates` - **GraphQL type:** `Boolean` - **Default:** `true` When true, definitive same-symbol, same-image clones are removed after bounded candidates and the top-ranked token universe are merged and holder-aware ranking is applied; a secondary same-symbol token-name-prefix pass follows. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Divide token match priceUsd, athUsd, and atlUsd by the current Token-2022 UI multiplier. False returns source prices; ranking is unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl for each token match. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql query symbolPrefixMatches { mint mintExplorerUrl tokenSymbol tokenName priceUsd marketCapUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField matchPosition } symbolOrNameContainsMatches { mint mintExplorerUrl tokenSymbol tokenName priceUsd marketCapUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField matchPosition } fuzzyMatches { mint mintExplorerUrl tokenSymbol tokenName descriptionSnippet priceUsd marketCapUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField matchPosition } ``` #### Ranking Notes - Buckets are returned separately; do not merge them unless the user asks. - Symbol-prefix bucket is the highest-priority bucket, then symbol/name contains, then fuzzy. - Text-search candidates require lastSeenAt within the previous 30 days. Exact full and shortened mint resolution, including ellipsis-separated and compact concatenated prefix+suffix forms, is not subject to this freshness cutoff. - Within each bucket, exact mint and lexical relevance sort first; remaining quality ranking is calculated on bounded candidates as (anchoredTvlUsd / 1000) * min(2000, holderCount)^e, where e is 2 for tokens with an assigned category and 1.1 otherwise. Volume and market cap do not affect candidate selection or ordering. - Bounded lexical candidates are merged with the top-ranked token universe before the holder-aware score and optional same-symbol image/name clone removal are applied. - fairVolume5mUsd is populated only when selected and is informational, not a search-ranking input. For broader pool-level liquidity, resolve the mint through listPools. #### Example ```graphql query TokenAutocomplete($query: String!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { tokenSearch(query: $query, symbolPrefixLimit: 5, symbolOrNameContainsLimit: 5, fuzzyLimit: 5, removeLogicalDuplicates: true, explorer: $explorer) { query symbolPrefixMatches { mint mintExplorerUrl tokenSymbol tokenName priceUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField } symbolOrNameContainsMatches { mint mintExplorerUrl tokenSymbol tokenName priceUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField } fuzzyMatches { mint mintExplorerUrl tokenSymbol tokenName descriptionSnippet priceUsd athUsd athAt atlUsd atlAt fairVolume5mUsd logoUrl tokenAgeSeconds matchField } } } } ``` Variables: ```json { "query": "sol", "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/search_tokens?query=sol&explorer=SOLSCAN) ### `list_tokens` - **Map operation:** `listTokens` - **Title:** `List Solana tokens` - **Kind:** `query` - **GraphQL path:** `solana.tokens` Read current-state token_stats-backed Solana token rows by mints, filters, ordering, and pagination. Select token2022ExtensionsJson for mint-extension descriptors, including TokenMetadata presence; there is no metadataExtensions field. Token-unit prices and supplyUi use the current Token-2022 UI multiplier by default. anchoredTvlUsd is the physical recognized-anchor conversion-path TVL signal; query listPools for broader pool-level coverage. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.) **Related topics:** `graduation`, `graduated`, `how long did it take to graduate`, `token launch`, `token inception`, `firstSeenAt` #### Use When - The user asks for a page of token profiles without DEX window statistics. - The user needs direct mint lookup for many mints. - The user wants current price, market cap, metadata, or socials for token rows. - The user asks how long it took to graduate; use firstSeenAt from this query as token first observed DeFi activity time, then subtract from pool.graduation.at. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional direct mint list, capped at 100 unique mints. Normal pagination still applies: limit defaults to 25, so set it high enough for the requested set. Without orderBy, rows are mint-ascending rather than input-ordered; reorder client-side by mint when positional alignment is required. ##### `pinnedMints` - **GraphQL type:** `[String!]` Mints to prepend before ordered results. Filters and ordering do not affect pinned rows; final skip/limit still applies. ##### `filter` - **GraphQL type:** `SolanaTokenFilterInput` ###### Input Fields ```json { "mints": "[String!]", "symbols": "[String!]", "categories": "[String!]; exact case-insensitive match; matches any requested category", "tags": "[String!]; exact case-insensitive match; matches any requested tag", "notEmptySymbol": "Boolean, defaults true", "minMarketCapUsd": "Float", "minPriceUsd": "Float", "didGraduated": "Boolean; when true returns only mints with inferred graduation attribution; false is treated the same as omitted" } ``` ##### `orderBy` - **GraphQL type:** `SolanaTokenOrderInput` ###### Input Fields ```json { "field": [ "MARKET_CAP_USD", "ANCHORED_TVL_USD", "PRICE_USD", "TOKEN_SYMBOL", "TOKEN_NAME", "MINT" ], "direction": [ "ASC", "DESC" ] } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `25` - **Maximum:** `100` ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Multiply supplyUi by the current Token-2022 UI multiplier and divide priceUsd, athUsd, and atlUsd by it. Defaults to true; false returns decimal-adjusted source amounts and source prices. supplyRaw and USD valuations are unchanged. The toggle does not change the units used for price filters or ordering. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit mint, program, and authority URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl tokenSymbol tokenName priceUsd fdvUsd marketCapUsd anchoredTvlUsd athUsd athAt atlUsd atlAt logoUrl description websiteUrl twitterUrl firstSeenAt lastSeenAt ``` #### Field Notes ##### `firstSeenAt` Timestamp when the token was first observed in indexed DeFi activity, usually initial pool creation. Use this as practical launch/inception time for graduation-duration calculations. ##### `anchoredTvlUsd` Preferred non-base-token TVL signal copied from token_stats and bounded by the trusted recognized-anchor conversion side. Base anchor assets can report zero; use broader pool data for their own liquidity. ##### `athUsd` Highest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage; athAt is its fair-price source minute. It is not a raw last-trade high. ##### `atlUsd` Lowest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage; atlAt is its fair-price source minute. It is not a raw last-trade low. ##### `supplyRaw` Raw on-chain mint supply in smallest token units as a precision-safe decimal string; not circulating supply. ##### `supplyUi` supplyRaw divided by 10^decimals and multiplied by the current effective Token-2022 UI multiplier by default, returned as a decimal string. Set adjustForUiMultiplier=false to omit the multiplier. This is mint supply, not circulating supply. ##### `scaledUiAmountMultiplier` Stored prior Token-2022 display multiplier, possibly superseded by the scheduled value. ##### `effectiveScaledUiAmountMultiplier` Token-2022 display multiplier effective now, after applying any scheduled activation time. It multiplies supplyUi and divides token-unit prices by default. ##### `token2022ExtensionsJson` Select this field to read Token-2022 mint extension descriptors, including TokenMetadata presence. It does not include the full TokenMetadata key-value payload; no metadataExtensions field exists. ##### `scaledUiAmountNewMultiplier` Scheduled display multiplier, possibly already effective; scaledUiAmountNewMultiplierEffectiveAt is its activation timestamp. ##### `transferFeeConfigPresent` Nullable extension-presence state: true includes zero-rate configs, false is validated absence, null is unresolved. ##### `transferFeeOlderBasisPoints` Older Token-2022 fee schedule; epoch and maximum-fee fields are precision-safe raw-unit strings. ##### `transferFeeNewerBasisPoints` Scheduled Token-2022 fee rate effective from transferFeeNewerEpoch and capped by transferFeeNewerMaximumFeeRaw. ##### `transferFeeWithheldAmountRaw` Mint-held fees at the last account snapshot, not token-account withheld fees or a continuously refreshed balance. ##### `priceSourceMinute` Fair-candle minute that supplied priceUsd; it can precede the token row write. ##### `fdvUsd` Fully diluted valuation derived from current price and mint supply. ##### `marketCapUsd` Current indexer estimate from available price and supply/profile inputs; not audited circulating market cap. ##### `sourceSlot` Indexer source slot; rpcContextSlot is the separate RPC refresh context slot and version is nanosecond write order. ##### `metadataPayloadStatus` Machine-readable off-chain metadata fetch/decode status; metadataPayloadError contains retained detail. ##### `aliases` Aliases associated with the Solana mint. ##### `categories` Categories associated with the Solana mint; category ids are omitted. ##### `tags` Tags associated with the Solana mint; tag ids are omitted. #### Caveats - A mints list does not override pagination. Omitting limit returns at most the default 25 rows, even when more mints were requested; the maximum limit is 100. - Without orderBy, results are mint-ascending and do not preserve mints input order. Join or reorder returned rows by mint client-side. #### Example ```graphql query Tokens($filter: SolanaTokenFilterInput, $orderBy: SolanaTokenOrderInput, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { tokens(filter: $filter, orderBy: $orderBy, limit: $limit, explorer: $explorer) { mint mintExplorerUrl tokenSymbol tokenName token2022ExtensionsJson priceUsd marketCapUsd anchoredTvlUsd athUsd athAt atlUsd atlAt logoUrl firstSeenAt lastSeenAt } } } ``` Variables: ```json { "filter": { "notEmptySymbol": true, "minPriceUsd": 1e-06 }, "orderBy": { "field": "MARKET_CAP_USD", "direction": "DESC" }, "limit": 25, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_tokens?filterNotEmptySymbol=true&filterMinPriceUsd=1e-06&orderByField=MARKET_CAP_USD&orderByDirection=DESC&limit=25&explorer=SOLSCAN) ### `list_tokens_ext` - **Map operation:** `listTokensExt` - **Title:** `List extended Solana tokens` - **Kind:** `query` - **GraphQL path:** `solana.tokensExt` Read and screen token rows using current token fields, physical token_stats conversion-path anchored TVL, trailing 5m/1h/6h/24h DEX windows, holder stats including a user-only top-holder ranking, earliest observed DeFi appearance, and minimum 24h fair-volume/anchored-TVL thresholds. Select token2022ExtensionsJson for mint-extension descriptors, including TokenMetadata presence; there is no metadataExtensions field. Token-unit prices and supplyUi use the current Token-2022 UI multiplier by default. tvlUsd is a compatibility alias of anchoredTvlUsd. This is historical/current data, not prediction or trading advice. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.), `solana-pool-current` (entity; One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.), `solana-token-account-holding-current` (entity; One latest row per token account and mint.), `solana-token-holder-stats-current` (entity; One current aggregate row per token mint.), `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.) **Related topics:** `graduation`, `graduated`, `how long did it take to graduate`, `token launch`, `token inception`, `firstSeenAt`, `newest tokens`, `token screening`, `minimum liquidity`, `minimum TVL`, `minimum 24h volume`, `user holders`, `top user holders`, `price stats`, `volume stats` #### Use When - The user asks for trending tokens, recent volume, price change, or TVL-ranked tokens. Use ANCHORED_TVL_USD; TVL_USD is a compatibility sort alias. - The user asks for newest or oldest tokens ordered by first observed DeFi appearance. - The user asks to screen tokens by minimum trailing-24h fair volume or minimum normalized DEX TVL. - The user needs the compact top ten ranked only by on-curve USER-classified holdings. - The user wants token list rows enriched with DEX window stats. - The user asks how long it took to graduate and also needs DEX windows around the token; use firstSeenAt from this query as token first observed DeFi activity time, then subtract from pool.graduation.at. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional direct mint list. ##### `pinnedMints` - **GraphQL type:** `[String!]` Mints to prepend before ordered results. Filters and ordering do not affect pinned rows; final skip/limit still applies. ##### `filter` - **GraphQL type:** `SolanaTokenFilterInput` ###### Input Fields ```json { "mints": "[String!]", "symbols": "[String!]", "categories": "[String!]; exact case-insensitive match; matches any requested category", "tags": "[String!]; exact case-insensitive match; matches any requested tag", "notEmptySymbol": "Boolean, defaults true", "minMarketCapUsd": "Float", "minPriceUsd": "Float", "minFairVolumeUsd24h": "Float; requires local cache", "minTvlUsd": "Float; compatibility name for the physical token_stats anchored-TVL threshold; works with or without local cache", "didGraduated": "Boolean; when true returns only mints with inferred graduation attribution; false is treated the same as omitted" } ``` ##### `orderBy` - **GraphQL type:** `SolanaTokenExtOrderInput` - **Default:** `{"field":"FIRST_SEEN_AT","direction":"DESC"}` Optional ordering. Omit for newest tokens first (FIRST_SEEN_AT DESC). Pass an empty object to disable explicit ordering. ###### Input Fields ```json { "field": [ "MARKET_CAP_USD", "ANCHORED_TVL_USD", "PRICE_USD", "TOKEN_SYMBOL", "TOKEN_NAME", "MINT", "TVL_USD", "GRADUATION_AT", "FIRST_SEEN_AT", "FAIR_VOLUME_USD_5M", "FAIR_VOLUME_USD_1H", "FAIR_VOLUME_USD_6H", "FAIR_VOLUME_USD_24H", "PRICE_CHANGE_5M_PERCENT", "PRICE_CHANGE_1H_PERCENT", "PRICE_CHANGE_6H_PERCENT", "PRICE_CHANGE_24H_PERCENT", "TRENDING_1H", "TRENDING_6H", "TRENDING_24H" ], "direction": [ "ASC", "DESC" ] } ``` ##### `removeLogicalDuplicates` - **GraphQL type:** `Boolean` - **Default:** `false` When true, collapse logical duplicate/clone tokens (same symbol and near-identical name), keeping the highest-ranked row per logical token. Always applied for TRENDING_* ordering. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `25` - **Maximum:** `100` ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Multiply supplyUi by the current Token-2022 UI multiplier and divide priceUsd, athUsd, and atlUsd by it. Defaults to true; false returns decimal-adjusted source amounts and source prices. supplyRaw and USD valuations are unchanged. The toggle does not change the units used for price filters or ordering. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit mint, program, authority, and top-holder wallet URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl tokenSymbol tokenName firstSeenAt priceUsd marketCapUsd fdvUsd anchoredTvlUsd athUsd athAt atlUsd atlAt tvlUsd launchpad didGraduated graduationAt logoUrl priceChange5mPercent volume5mUsd priceChange1hPercent volume1hUsd priceChange6hPercent volume6hUsd priceChange24hPercent volume24hUsd ``` #### Field Notes ##### `firstSeenAt` Timestamp when the token was first observed in indexed DeFi activity, usually initial pool creation. This is not necessarily mint-account creation time. ##### `anchoredTvlUsd` Physical token_stats TVL signal. Eligible pools contribute twice the trusted recognized-anchor reserve, bounding the value by the convertible side rather than the measured token price. Base anchor assets can report zero. Not an executable-depth guarantee. ##### `athUsd` Highest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage; athAt is its fair-price source minute. It is not a raw last-trade high. ##### `atlUsd` Lowest positive qualifying fair USD price retained by token_stats across indexed price-extrema coverage; atlAt is its fair-price source minute. It is not a raw last-trade low. ##### `tvlUsd` Compatibility alias of anchoredTvlUsd. New clients should select anchoredTvlUsd explicitly. ##### `supplyRaw` Raw on-chain mint supply in smallest token units as a precision-safe decimal string; not circulating supply. ##### `scaledUiAmountMultiplier` Stored prior Token-2022 display multiplier, possibly superseded by the scheduled value. ##### `effectiveScaledUiAmountMultiplier` Token-2022 display multiplier effective now, after applying any scheduled activation time. It multiplies supplyUi and divides token-unit prices by default. ##### `scaledUiAmountNewMultiplier` Scheduled display multiplier, possibly already effective; scaledUiAmountNewMultiplierEffectiveAt is its activation timestamp. ##### `transferFeeConfigPresent` Nullable extension-presence state: true includes zero-rate configs, false is validated absence, null is unresolved. ##### `transferFeeOlderBasisPoints` Older Token-2022 fee schedule; epoch and maximum-fee fields are precision-safe raw-unit strings. ##### `transferFeeNewerBasisPoints` Scheduled Token-2022 fee rate effective from transferFeeNewerEpoch and capped by transferFeeNewerMaximumFeeRaw. ##### `transferFeeWithheldAmountRaw` Mint-held fees at the last account snapshot, not token-account withheld fees or a continuously refreshed balance. ##### `priceSourceMinute` Fair-candle minute that supplied priceUsd; it can precede the token row write. ##### `fdvUsd` Fully diluted valuation derived from current price and mint supply. ##### `marketCapUsd` Current indexer estimate from available price and supply/profile inputs; not audited circulating market cap. ##### `fairVolume24hUsd` Quality-weighted effective USD activity eligible to influence fair price, not raw trade-row notional. ##### `minuteCount24h` Retained one-minute fair-candle rows contributing to the 24h aggregate; not transaction count. ##### `sourceSlot` Indexer source slot; rpcContextSlot is the separate RPC refresh context slot and version is nanosecond write order. ##### `aliases` Aliases associated with the Solana mint. ##### `categories` Categories associated with the Solana mint; category ids are omitted. ##### `tags` Tags associated with the Solana mint; tag ids are omitted. ##### `holderCount` Current holder count from the token holder stats cache. ##### `totalHoldings` Current total token holdings as a decimal string in decimal-adjusted source units. The Token-2022 UI multiplier is not applied to holder-summary amounts. ##### `topHolders` Deprecated compact all-holder top ten ranked by complete current balance. Each row includes holderType from the holder-stats cache. ##### `topUserHolders` Compact top ten ranked only by each wallet's on-curve USER-classified amount. Program, AMM-vault, and unknown amounts are excluded from holdings; each row still includes the cached holder-level type, so a mixed wallet can be MIXED and have a smaller amount here than in topHolders. ##### `didGraduated` True when indexed pool migration metadata is attributed to this mint by the lifecycle selection rule; not proof of original token launch. ##### `graduationAt` Latest indexed migration timestamp attributed to this mint by the lifecycle selection rule. ##### `launchpad` Reviewed launchpad program inferred from indexed pool relationships; not proof of original token launch. ##### `supplyUi` supplyRaw divided by 10^decimals and multiplied by the current effective Token-2022 UI multiplier by default, returned as a decimal string. Set adjustForUiMultiplier=false to omit the multiplier. This is mint supply, not circulating supply. #### Caveats - Omitting orderBy defaults to FIRST_SEEN_AT DESC. Pass orderBy: {} when intentionally requesting no explicit ordering. - anchoredTvlUsd is physical token_stats conversion-path TVL, bounded by recognized liquid anchor-side reserves so it does not inherit the measured token's own price. - tvlUsd is a compatibility alias of anchoredTvlUsd. New clients should select anchoredTvlUsd and use listPools when they need broader pool-level liquidity coverage. - For trending questions use orderBy.field TRENDING_1H, TRENDING_6H, or TRENDING_24H rather than raw fair-volume ordering. Each bakes in its own eligibility gate (anchored TVL > $2k plus a window fair-volume floor) and ranks by a volume-surge score weighted by price direction, so send an empty filter. - TRENDING_* ordering always collapses logical duplicate/clone tokens; pass removeLogicalDuplicates: true to get the same collapsing for non-trending ordering. - TVL_USD is a compatibility alias for ANCHORED_TVL_USD. Both sort the physical token_stats anchored TVL through the same token index. - FIRST_SEEN_AT orders by the earliest observed indexed DeFi appearance, used as a launch proxy rather than guaranteed mint-account creation time. - minFairVolumeUsd24h filters against the current cached trailing-24h fair-volume snapshot and requires cache-enabled tokensExt. minTvlUsd filters physical token_stats anchored TVL and works with or without the local cache. - Minimum fair-volume and TVL filters are applied to the normal result set before ordering and skip/limit. pinnedMints remain intentionally outside filters and ordering, then participate in final skip/limit. - Sorting by GRADUATION_AT uses cached pool graduation metadata and returns graduated tokens first. - Filtering with filter.didGraduated uses the same local pool graduation cache. Use filter: { didGraduated: true } for graduated tokens; false is treated the same as omitted. - Selecting tvlUsd does not trigger separate enrichment; it aliases anchoredTvlUsd from the token row. - For Token-2022 mint extension descriptors select token2022ExtensionsJson explicitly. It reports TokenMetadata presence but not its full key-value payload; metadataExtensions is not a GraphQL field. - Selecting holderCount, totalHoldings, topHolders, or topUserHolders triggers a bounded current holder-summary lookup; omit those fields when not needed. Both compact holder arrays expose holderType. topUserHolders excludes PROGRAM, AMM_VAULT, and UNKNOWN amounts from holdings, although a wallet's holderType can still be MIXED. Use wallet.tokenHolders with holdingsByType for detailed current holder rows. - Selecting didGraduated, graduationAt, or launchpad triggers local pool-lifecycle enrichment; omit those fields when not needed. - For graduation-duration questions, firstSeenAt is the token first observed DeFi activity time, usually initial pool creation. Do not use a PumpSwap pool inceptionAt as the token launch time. #### Example ```graphql query TokensExt($filter: SolanaTokenFilterInput, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { tokensExt(filter: $filter, limit: $limit, explorer: $explorer) { mint mintExplorerUrl tokenSymbol tokenName token2022ExtensionsJson firstSeenAt priceUsd marketCapUsd anchoredTvlUsd athUsd athAt atlUsd atlAt tvlUsd launchpad didGraduated graduationAt priceChange5mPercent volume5mUsd priceChange1hPercent volume1hUsd priceChange24hPercent volume24hUsd logoUrl } } } ``` Variables: ```json { "filter": { "notEmptySymbol": true, "minPriceUsd": 1e-06, "didGraduated": true }, "limit": 25, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_tokens_ext?filterNotEmptySymbol=true&filterMinPriceUsd=1e-06&filterDidGraduated=true&limit=25&explorer=SOLSCAN) ### `list_token_lifecycle` - **Map operation:** `listTokenLifecycle` - **Title:** `List Solana token lifecycle` - **Kind:** `query` - **GraphQL path:** `solana.tokensExt` Read token lifecycle dimensions from tokensExt: firstSeenAt launch proxy, launchpad, didGraduated, holder count, and total holdings. Use wallet.tokenHolders for current holder wallets. This is current indexed data, not prediction or trading advice. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.), `solana-pool-current` (entity; One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.), `solana-token-holder-stats-current` (entity; One current aggregate row per token mint.) **Related topics:** `launchpad`, `brewing`, `bonding curve`, `graduation`, `graduated`, `didGraduated`, `holderCount`, `totalHoldings`, `token lifecycle`, `how long did it take to graduate` #### Use When - The user asks on which launchpad a token is brewing or from which launchpad it graduated. - The user asks whether a token graduated from a bonding curve. - The user asks for holder count or total holdings alongside token lifecycle data. - The user needs launch proxy plus graduation status in one token result. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional direct mint list. ##### `pinnedMints` - **GraphQL type:** `[String!]` Mints to prepend before ordered results. Filters and ordering do not affect pinned rows; final skip/limit still applies. ##### `filter` - **GraphQL type:** `SolanaTokenFilterInput` ###### Input Fields ```json { "mints": "[String!]", "symbols": "[String!]", "notEmptySymbol": "Boolean, defaults true", "minMarketCapUsd": "Float", "minPriceUsd": "Float", "minFairVolumeUsd24h": "Float; tokensExt only; requires local cache", "minTvlUsd": "Float; tokensExt only; compatibility name for physical token_stats anchored TVL; works with or without local cache", "didGraduated": "Boolean; when true returns only mints with inferred graduation attribution; false is treated the same as omitted" } ``` ##### `orderBy` - **GraphQL type:** `SolanaTokenExtOrderInput` - **Default:** `{"field":"FIRST_SEEN_AT","direction":"DESC"}` Optional ordering. Omit for newest tokens first (FIRST_SEEN_AT DESC). Pass an empty object to disable explicit ordering. ###### Input Fields ```json { "field": [ "MARKET_CAP_USD", "ANCHORED_TVL_USD", "PRICE_USD", "TOKEN_SYMBOL", "TOKEN_NAME", "MINT", "TVL_USD", "GRADUATION_AT", "FIRST_SEEN_AT", "FAIR_VOLUME_USD_5M", "FAIR_VOLUME_USD_1H", "FAIR_VOLUME_USD_6H", "FAIR_VOLUME_USD_24H", "PRICE_CHANGE_5M_PERCENT", "PRICE_CHANGE_1H_PERCENT", "PRICE_CHANGE_6H_PERCENT", "PRICE_CHANGE_24H_PERCENT", "TRENDING_1H", "TRENDING_6H", "TRENDING_24H" ], "direction": [ "ASC", "DESC" ] } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `25` - **Maximum:** `100` ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Multiply supplyUi by the current Token-2022 UI multiplier and divide priceUsd, athUsd, and atlUsd by it. Defaults to true; false returns decimal-adjusted source amounts and source prices. supplyRaw and USD valuations are unchanged. The toggle does not change the units used for price filters or ordering. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit mint, program, authority, and top-holder wallet URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl tokenSymbol tokenName firstSeenAt lastSeenAt launchpad didGraduated graduationAt holderCount totalHoldings priceUsd marketCapUsd athUsd athAt atlUsd atlAt tvlUsd logoUrl ``` #### Field Notes ##### `launchpad` Reviewed launchpad program inferred from indexed pool relationships; not proof of original token launch. ##### `didGraduated` True when indexed pool migration metadata is attributed to this mint by the lifecycle selection rule; not proof of original token launch. ##### `graduationAt` Latest indexed migration timestamp attributed to this mint by the lifecycle selection rule. ##### `holderCount` Current holder count from the token holder stats cache. ##### `totalHoldings` Current total token holdings as a decimal string in decimal-adjusted source units. The Token-2022 UI multiplier is not applied to holder-summary amounts. ##### `firstSeenAt` Earliest observed token appearance in indexed DeFi activity; use as launch proxy for Pump.fun time-to-graduate calculations. ##### `supplyUi` supplyRaw divided by 10^decimals and multiplied by the current effective Token-2022 UI multiplier by default, returned as a decimal string. Set adjustForUiMultiplier=false to omit the multiplier. This is mint supply, not circulating supply. #### Caveats - Omitting orderBy defaults to FIRST_SEEN_AT DESC. Pass orderBy: {} when intentionally requesting no explicit ordering. - launchpad, didGraduated, and graduationAt use inferred lifecycle attribution. See the linked token-current dataset for common-mint selection, first-seen age, missing-age and tie rules, and freshness limitations. - filter.didGraduated applies before skip/limit when true and uses the same local pool graduation cache; false is treated the same as omitted. - holderCount and totalHoldings come from the current mint-keyed holder summary. - totalHoldings is a decimal string to preserve precision. Use wallet.tokenHolders for current holder wallets. - For time-to-graduate, compute pool.graduation.at from list_pools minus firstSeenAt from this result. #### Example ```graphql query TokenLifecycle($mints: [String!], $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { tokensExt(mints: $mints, limit: $limit, explorer: $explorer) { mint mintExplorerUrl tokenSymbol tokenName firstSeenAt launchpad didGraduated graduationAt holderCount totalHoldings priceUsd marketCapUsd athUsd athAt atlUsd atlAt tvlUsd logoUrl } } } ``` Variables: ```json { "mints": [ "4vPnDrhBuyHxmuvdTdGtc4ZntwJ9ZoayLde7VURzpump" ], "limit": 10, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_token_lifecycle?mints=4vPnDrhBuyHxmuvdTdGtc4ZntwJ9ZoayLde7VURzpump&limit=10&explorer=SOLSCAN) ### `list_blocks` - **Map operation:** `listBlocks` - **Title:** `List recent Solana blocks` - **Kind:** `query` - **GraphQL path:** `solana.blocks` Browse recent indexed Solana block summaries, newest first. Each row includes indexed parent slot, block time, and fee/resource aggregates over transaction records indexed by this service. **Data dictionary:** `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-block-summary` (fact; One indexed block summary per exposed Solana slot.) **Related topics:** `block`, `blocks`, `recent blocks`, `block explorer`, `block fees`, `block compute`, `Jito tips` #### Use When - The user wants to browse recent Solana blocks without already knowing a slot. - The user wants indexed fee, priority-fee, compute-unit, or Jito-tip totals by recent block. - The client needs a recent-block navigation feed before drilling into one slot. #### Arguments ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` - **Minimum:** `0` Number of indexed block summaries to skip in newest-first order. ##### `limit` - **GraphQL type:** `Int` - **Default:** `25` - **Minimum:** `1` - **Maximum:** `1000` Maximum block rows to return. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build blockExplorerUrl for each slot. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql slot blockExplorerUrl parentSlot blockTime indexedTransactionCount indexedTotalFeeLamports indexedBaseFeeLamports indexedPrioritizationFeeLamports indexedComputeUnitsConsumed indexedJitoTipLamports ``` #### Field Notes ##### `slot` Precision-safe indexed Solana slot string and input for get_block or list_block_transactions. ##### `parentSlot` Indexed parent slot included in the block summary. ##### `indexedTransactionCount` Count of deduplicated indexed transaction fee records, not an RPC-complete transaction count. ##### `indexedTotalFeeLamports` Null when any indexed transaction lacks a resolved total fee. ##### `indexedBaseFeeLamports` Null when any indexed transaction has an unresolved fee split. ##### `indexedPrioritizationFeeLamports` Null when any indexed transaction has an unresolved fee split. ##### `indexedComputeUnitsConsumed` Null when any indexed transaction lacks compute-unit metadata. ##### `indexedJitoTipLamports` Sum of recognized Jito tips over indexed transactions. #### MCP Note Use list_blocks for recent block navigation. Pass a returned slot to get_block for one row or list_block_transactions to discover indexed transaction signatures, then batch those signatures through get_transactions for transaction-level enrichment. #### Caveats - Rows are public indexed block summaries. Internal checkpoint, replay, skipped-slot, and dead-letter state is not exposed by this operation. - indexedTransactionCount and all aggregate fields cover transaction metadata indexed by this service. They are not guaranteed to equal an RPC-complete historical block. - Block height, blockhash, and previous blockhash are not persisted by the current warehouse schema and are not exposed. - Results are always ordered by slot descending. Use skip and limit for pagination. #### Output Schema ```json { "type": "object", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "blocks": { "type": [ "array", "null" ], "items": { "type": "object", "additionalProperties": true, "properties": { "slot": { "type": "string" }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "parentSlot": { "type": "string" }, "blockTime": { "type": "string", "format": "date-time" }, "indexedTransactionCount": { "type": "integer" }, "indexedTotalFeeLamports": { "type": [ "string", "null" ] }, "indexedBaseFeeLamports": { "type": [ "string", "null" ] }, "indexedPrioritizationFeeLamports": { "type": [ "string", "null" ] }, "indexedComputeUnitsConsumed": { "type": [ "string", "null" ] }, "indexedJitoTipLamports": { "type": "string" } } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query RecentBlocks($skip: Int, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { blocks(skip: $skip, limit: $limit, explorer: $explorer) { slot blockExplorerUrl parentSlot blockTime indexedTransactionCount indexedTotalFeeLamports indexedBaseFeeLamports indexedPrioritizationFeeLamports indexedComputeUnitsConsumed indexedJitoTipLamports } } } ``` Variables: ```json { "skip": 0, "limit": 25, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_blocks?skip=0&limit=25&explorer=SOLSCAN) ### `get_block` - **Map operation:** `getBlock` - **Title:** `Get one Solana block` - **Kind:** `query` - **GraphQL path:** `solana.block` Get one indexed Solana block summary by slot with aggregates over transaction records indexed by this service. **Data dictionary:** `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-block-summary` (fact; One indexed block summary per exposed Solana slot.) **Related topics:** `block`, `block details`, `slot`, `block fees`, `block compute`, `Jito tips` #### Use When - The user already knows a Solana slot and wants its indexed block summary. - A transaction result supplied blockSlot and the user wants block-level context. #### Arguments ##### `slot` - **GraphQL type:** `Long!` - **Required:** `true` - **Minimum:** `0` Indexed Solana block slot. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build blockExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql slot blockExplorerUrl parentSlot blockTime indexedTransactionCount indexedTotalFeeLamports indexedBaseFeeLamports indexedPrioritizationFeeLamports indexedComputeUnitsConsumed indexedJitoTipLamports ``` #### MCP Note Use get_block when the slot is known. Use list_block_transactions with the same slot to discover indexed signatures; do not infer transactions that were not returned. #### Caveats - Returns null when no indexed block summary is available for the slot. The result does not expose internal checkpoint or replay state. - Transaction count and aggregate fields cover indexed transaction metadata only and can be incomplete for historical blocks. - Block height, blockhash, and previous blockhash are not currently available. #### Output Schema ```json { "type": "object", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "block": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "slot": { "type": "string" }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "parentSlot": { "type": "string" }, "blockTime": { "type": "string", "format": "date-time" }, "indexedTransactionCount": { "type": "integer" }, "indexedTotalFeeLamports": { "type": [ "string", "null" ] }, "indexedBaseFeeLamports": { "type": [ "string", "null" ] }, "indexedPrioritizationFeeLamports": { "type": [ "string", "null" ] }, "indexedComputeUnitsConsumed": { "type": [ "string", "null" ] }, "indexedJitoTipLamports": { "type": "string" } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query Block($slot: Long!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { block(slot: $slot, explorer: $explorer) { slot blockExplorerUrl parentSlot blockTime indexedTransactionCount indexedTotalFeeLamports indexedBaseFeeLamports indexedPrioritizationFeeLamports indexedComputeUnitsConsumed indexedJitoTipLamports } } } ``` Variables: ```json { "slot": 440459448, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_block?slot=440459448&explorer=SOLSCAN) ### `list_block_transactions` - **Map operation:** `listBlockTransactions` - **Title:** `List indexed transactions in a Solana block` - **Kind:** `query` - **GraphQL path:** `solana.blockTransactions` List transaction signatures indexed for one Solana block, ordered by transactionIndex, with skip/limit pagination. **Data dictionary:** `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.) **Related topics:** `block`, `blocks`, `block transactions`, `transaction discovery`, `slot`, `transactionIndex`, `txHash` #### Use When - The user wants to discover indexed transaction signatures within a known block slot. - A block summary should be expanded into transaction rows for later get_transaction_activity or get_transactions enrichment. #### Arguments ##### `slot` - **GraphQL type:** `Long!` - **Required:** `true` - **Minimum:** `0` Indexed Solana block slot. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` - **Minimum:** `0` Number of indexed transactions to skip in transactionIndex order. ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Minimum:** `1` - **Maximum:** `10000` Maximum indexed transaction rows to return. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build txExplorerUrl and blockExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql txHash txExplorerUrl blockSlot blockExplorerUrl transactionIndex ``` #### Field Notes ##### `txHash` Transaction signature and input to get_transaction_activity and get_transactions. ##### `txExplorerUrl` Derived public transaction URL paired with txHash for the selected explorer. Defaults to Solscan. ##### `blockExplorerUrl` Derived public block URL paired with blockSlot for the selected explorer. Defaults to Solscan. ##### `transactionIndex` Zero-based indexed position of this transaction within the block. #### Drilldowns ```json [ { "sourceResultPath": "data.solana.blockTransactions[].txHash", "targetOperation": "getTransactionActivity", "targetArgument": "transactionHashes" }, { "sourceResultPath": "data.solana.blockTransactions[].txHash", "targetOperation": "getTransactions", "targetArgument": "transactionHashes" } ] ``` #### MCP Note Use list_block_transactions to discover indexed signatures for a known slot. Paginate with skip/limit, then batch txHash values through get_transaction_activity for transaction flows/trades/transfers and get_transactions for fee/program context. Do not present the result as an RPC-complete block transaction list. #### Caveats - This operation returns only transaction records indexed by this service for the requested block slot. - Historical results can omit block transactions absent from indexed transaction metadata. Empty output does not prove that the block had no transactions. - Rows are ordered by indexed transactionIndex ascending. Exact duplicate signatures are collapsed before pagination. - Use get_transaction_activity with returned hashes for wallet-independent indexed DEX trades and token transfers. - Use get_transactions in batches of 25 to 100 returned hashes for fee/resource/program details. #### Output Schema ```json { "type": "object", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "blockTransactions": { "type": [ "array", "null" ], "items": { "type": "object", "additionalProperties": true, "properties": { "txHash": { "type": "string" }, "txExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "blockSlot": { "type": [ "string", "null" ] }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "transactionIndex": { "type": "integer" } } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query BlockTransactions($slot: Long!, $skip: Int, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { blockTransactions(slot: $slot, skip: $skip, limit: $limit, explorer: $explorer) { txHash txExplorerUrl blockSlot blockExplorerUrl transactionIndex } } } ``` Variables: ```json { "slot": 440459448, "skip": 0, "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_block_transactions?slot=440459448&skip=0&limit=100&explorer=SOLSCAN) ### `get_transaction_activity` - **Map operation:** `getTransactionActivity` - **Title:** `Get Solana transaction activity` - **Kind:** `query` - **GraphQL path:** `solana.transactionActivity` Batch-fetch wallet-independent indexed transaction fees, Memo Program instructions, and protocol event notes, program flow, DEX trades, physical token transfers, and retained transaction-boundary token-account balances for known transaction signatures. fee includes network fee, compute, Jito-tip, Token-2022 fee, and activity-count details, while memos is an ordered sibling array and is empty when no memo was indexed. holdingsBefore and holdingsAfter project exact pre/post balances from wallet holding changes while retained. Every flow node has a standardized lowercase type describing its attached activity: swap, a specific lifecycle or token-operation intent, transfer, or program_invocation. Matching swap rows annotate the owning invocation rather than becoming synthetic sibling nodes. Flow trade/transfer arrays reuse the same facts as top-level arrays and are not additive. instructionName is nullable and only present when indexed parsing resolved it; instructionDiscriminator preserves the retained raw prefix without claiming an ABI decode. This is the activity continuation after list_block_transactions. Use get_transactions separately only when a flat programInteractions list is preferable. Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.), `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.), `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-token-transfer` (fact; One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.), `solana-wallet-holding-change` (fact; One indexed balance-change row per block slot, transaction index, transaction hash, token account, mint, owner, authority, and DeFi classification.), `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-program-interaction` (fact; One indexed program invocation per transaction and instruction ordering tuple.) **Related topics:** `transaction activity`, `transactionActivity`, `block transactions`, `txHash`, `trades`, `transfers`, `holdings before`, `holdings after`, `flow`, `program interaction flow`, `inner swaps`, `operation index`, `fees`, `memos`, `notes`, `protocol events`, `PumpSwap BOOST` #### Use When - The user wants a transaction flow, DEX trades, or token transfers for signatures discovered through list_block_transactions. - The user supplies transaction signatures and needs indexed activity without first choosing a wallet, token, or pool. - A block explorer needs to expand transaction rows into DEX execution and token movement details. - The user needs fees, compute usage, Jito tips, Token-2022 fees, or Memo Program content alongside transaction trades and transfers. - The user needs indexed protocol event notes, including PumpSwap BOOST events, beside Memo Program content. #### Arguments ##### `transactionHashes` - **GraphQL type:** `[String!]!` - **Required:** `true` One to 100 Solana transaction signatures. Blank values are removed and exact duplicates are collapsed while retaining first occurrence. Unknown hashes are omitted. ##### `includeInnerSwaps` - **GraphQL type:** `Boolean` - **Default:** `false` Include technical Inner and UnresolvedInner route rows. Keep false for normal transaction activity; enable only for route-level diagnostics. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust DEX trade prices and amounts plus transfer token amounts and per-token prices to current Token-2022 UI multipliers. False returns source units; raw amounts and USD notionals are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, block, token, pool, wallet, program, owner, authority, and token-account URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql txHash txExplorerUrl blockSlot blockExplorerUrl transactionIndex fee { feePayer feePayerExplorerUrl totalFeeLamports baseFeeLamports prioritizationFeeLamports feeBreakdownStatus signatureCount computeUnitsConsumed costUnits loadedAccountsDataSize computeUnitLimit computeUnitPriceMicroLamports requestedHeapFrameBytes requestedLoadedAccountsDataSizeLimit jitoTipLamports jitoTipTransferIndices jitoTipAccounts jitoTipAccountExplorerUrls jitoTipAmountsLamports token2022FeeTransferIndices token2022FeeMints token2022FeeMintExplorerUrls token2022FeeRawAmounts token2022FeeDecimals token2022FeeAmounts tokenTransferCount tokenMintCount tokenBurnCount walletFacingDexSwapCount hasWalletFacingDexSwap } memos { instructionIndex innerInstructionIndex content } notes trades { token tokenExplorerUrl side priceUsd amount volumeUsd otherToken otherTokenExplorerUrl otherTokenAmount poolAddress poolExplorerUrl userWallet userWalletExplorerUrl aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees operationIndex tradeLayer baselinePriceUsd potentialSlippage poolPriceConfidence } transfers { transferIndex operationIndex instructionIndex innerInstructionIndex tokenProgramId tokenProgramExplorerUrl transferType intent authority authorityExplorerUrl sourceOwner sourceOwnerExplorerUrl destinationOwner destinationOwnerExplorerUrl mint mintExplorerUrl sourceAccount sourceAccountExplorerUrl destinationAccount destinationAccountExplorerUrl rawAmount decimals amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd isDefiActivity } holdingsBefore { wallet walletExplorerUrl authority authorityExplorerUrl tokenAccount tokenAccountExplorerUrl mint mintExplorerUrl amount } holdingsAfter { wallet walletExplorerUrl authority authorityExplorerUrl tokenAccount tokenAccountExplorerUrl mint mintExplorerUrl amount } flow { type interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator instructionDataLength accountCount isSwap trades { operationIndex tradeLayer token side priceUsd amount volumeUsd otherToken otherTokenAmount poolAddress userWallet aggregatorProgram gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } transfers { transferIndex instructionIndex innerInstructionIndex intent mint amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd sourceOwner destinationOwner sourceAccount destinationAccount } children { type interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator isSwap trades { operationIndex tradeLayer token side priceUsd amount volumeUsd otherToken otherTokenAmount poolAddress userWallet aggregatorProgram gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } transfers { transferIndex instructionIndex innerInstructionIndex intent mint amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd sourceOwner destinationOwner sourceAccount destinationAccount } } } ``` #### Field Notes ##### `txExplorerUrl` Derived public transaction URL paired with txHash. Defaults to Solscan. ##### `blockExplorerUrl` Derived public block URL paired with blockSlot. Defaults to Solscan. ##### `fee` Canonical fee/resource detail projected by the same keyed lookup used to establish the activity header; selecting it does not add another backend request. ##### `memos` Sibling array beside fee containing Memo Program instructions in transaction order. It is empty when no memo was indexed; innerInstructionIndex is -1 for a top-level memo. ##### `notes` Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution. ##### `trades.operationIndex` Logical operation index for the indexed trade view. ##### `flow` Program invocation roots ordered by outer instructionIndex. Traverse children for CPI execution order; type summarizes what each invocation represents, while the nested facts retain detail. Nested trade and transfer arrays reuse transaction-level source facts and are not additive. ##### `flow.type` Standardized lowercase node purpose. swap takes precedence when trade rows are attached; specific lifecycle or token-operation transfer intents are preserved; other movements are transfer; invocations without attached activity are program_invocation. ##### `flow.trades.operationIndex` Rows sharing operationIndex are alternate indexed perspectives of one logical swap attached to this invocation. ##### `flow.transfers` Physical transfers emitted at the node's exact outer/inner instruction coordinate; these are contextual placements of top-level source facts, and transfers remain authoritative for moved amounts. ##### `flow.transfers.intent` Instruction-derived movement mechanism copied from the same top-level transfer source fact; it is not a business-purpose inference. ##### `transfers.operationIndex` Alias of the transfer outer instructionIndex. ##### `transfers.transferIndex` Physical token-transfer ordering index within the transaction. ##### `transfers.intent` Instruction-derived movement mechanism. Historical unreplayed rows use unknown; do not infer recipient purpose from it. ##### `transfers.historicalPriceUsd` Last retained fair close at or before the block minute from the local historical cache or its remote fallback; NativeSOL is priced through wrapped SOL. ##### `transfers.historicalValueUsd` Unsigned transfer amount times historicalPriceUsd. Null means unavailable, not zero. ##### `transfers.currentValueUsd` Unsigned transfer amount marked using the local current-token cache, with remote token_stats fallback for missing rows; do not use as event-time value. ##### `transfers.isDefiActivity` Indexer classification of whether the physical transfer belongs to DeFi activity; it is not a wallet direction. ##### `holdingsBefore` Token-account UI balances immediately before transaction execution from retained wallet_holdings_changes.pre_balance. ##### `holdingsAfter` Token-account UI balances immediately after transaction execution from retained wallet_holdings_changes.post_balance. ##### `flow.trades.priceUsd` Indexer-supplied execution price for the trade perspective attached to this invocation. ##### `flow.trades.volumeUsd` Indexer-supplied operation notional. Do not sum mirrored perspectives sharing operationIndex. ##### `flow.transfers.historicalValueUsd` Unsigned transfer amount valued at the retained fair price at or before the transaction minute. ##### `flow.transfers.currentValueUsd` Unsigned transfer amount valued using the current token price; it is not historical transaction value. ##### `flow.instructionName` Indexer-parsed instruction name when known; null means unresolved and must not be inferred from isSwap. ##### `flow.instructionDiscriminator` Retained lowercase hex prefix of up to eight raw instruction-data bytes; an identity hint, not an ABI decode. ##### `notes.e` Event code: pb = PumpSwap BoostBuyAndBurnEvent, pi = InitBoostEvent, pa = SetBoostAuthorityEvent. Future codes are preserved. ##### `notes.i` Zero-based outer instruction index of the emitting operation. ##### `notes.j` Zero-based inner instruction index of the emitting operation; omitted for outer calls. ##### `notes.t` Event timestamp in Unix seconds, not the transaction block timestamp. ##### `notes.m` Base mint (pb, pi). ##### `notes.c` Bonding curve address (pb, pi). ##### `notes.p` Pool address (pb, pi); pool metadata supplies the quote mint and decimals. ##### `notes.a` Authority for pb; admin for pa. Not necessarily a trader or fee payer. ##### `notes.qr` quote_amount_in_requested in raw quote units (pb). ##### `notes.qu` quote_amount_in_used in raw quote units (pb). ##### `notes.b` base_amount_burned in raw base units (pb). ##### `notes.vq` virtual_quote_reserves, a signed i128 in raw quote units (pb, pi). ##### `notes.rq` real_quote_reserves_after in raw quote units (pb, pi). ##### `notes.rb` base_reserves_after in raw base units (pb). ##### `notes.v` boost_vault_remaining in raw quote units (pb). ##### `notes.o` Old BOOST authority (pa). ##### `notes.n` New BOOST authority (pa). #### Drilldowns ```json [ { "sourceOperation": "listBlockTransactions", "sourceResultPath": "data.solana.blockTransactions[].txHash", "targetArgument": "transactionHashes" }, { "sourceResultPath": "data.solana.transactionActivity[].txHash", "targetOperation": "getTransactions", "targetArgument": "transactionHashes" } ] ``` #### MCP Note Indexed block drilldown is slot -> list_block_transactions -> get_transaction_activity. Select fee for transaction fee/resource details and the sibling memos array for Memo Program content without a separate operation. Prefer flow when reconstructing execution: type identifies the standardized purpose of each real invocation, transfers attach to exact invocation coordinates, and trade rows annotate the invocation that performed the swap. gatewayFees and ammFees preserve unknown attribution as null; compoundFees is their non-null compatibility sum with missing components treated as zero. holdingsBefore and holdingsAfter are independent transaction-boundary account balances retained for three days; they are not duplicate transfer facts. instructionName remains null when unresolved; instructionDiscriminator is only a raw identity hint. Batch the same hashes through get_transactions only when a flat programInteractions list is preferable. #### Caveats - Accepts at most 100 non-blank transaction hashes, removes exact duplicates, and returns rows in retained first-occurrence input order. - The operation resolves transaction headers from indexed transaction metadata. Unknown hashes are omitted; an indexed transaction with no matching activity returns its selected fee plus empty trades, transfers, holdingsBefore, holdingsAfter, and flow arrays. - The reads are bounded by resolved literal block slots and transaction hashes. Selecting fee, memos, or notes widens the existing transaction header lookup instead of issuing another query. Selecting flow requires the bounded program-interaction, trade, and transfer facts used to compose the tree. Selecting holdingsBefore or holdingsAfter adds one parallel bounded holding-change read; unselected fee, trade, transfer, holding, and flow paths remain skipped. - Every flow node is a persisted program interaction. Its lowercase type is swap when trades are attached; otherwise it preserves specific lifecycle or token-operation intents, uses transfer for other attached movements, and program_invocation when no activity fact is attached. Each outer instruction starts one root and stackHeight assigns nested CPI children. Transfers attach by exact instructionIndex plus innerInstructionIndex. Trade perspectives sharing operationIndex are attributed from matching mint, amount, wallet/pool endpoint, and invocation ancestry; no synthetic swap node is inserted. If that evidence is ambiguous, the rows remain only in top-level trades. - instructionName is null when the indexer did not resolve a name. instructionDiscriminator is the retained lowercase hex prefix of up to eight raw instruction-data bytes and is not an ABI decode. - GraphQL flow-tree selections have finite depth. The generated tool's default selection returns roots and one child level; use an explicit fields selection or query_graphql when deeper CPI nesting is required. - Technical Inner and UnresolvedInner trade layers are excluded by default. Set includeInnerSwaps=true only for route-level diagnostics. - Trade rows can repeat one swap from multiple token perspectives or operation indexes. Flow trade/transfer arrays are contextual placements of the same source facts exposed by the top-level arrays; selecting both representations does not create extra activity and clients must not add them together. Do not sum volumeUsd as transaction-level cash flow. - Transfer rows are physical movement facts but have no wallet-relative INBOUND, OUTBOUND, or SELF direction because this operation has no wallet argument. intent is the instruction-derived movement mechanism, not the receiving wallet's purpose; historical unreplayed rows use unknown. - holdingsBefore and holdingsAfter project pre_balance and post_balance from retained wallet_holdings_changes rows for the same transaction and token account. They include zero balances for account creation, closure, or complete disposal. The source is retained for three days, so empty arrays can mean the transaction is outside holding-change retention rather than that no balance changed. - Historical transfer valuation reads the full-retention local fair-close cache first and falls back to remote fair OHLCV while cache coverage catches up or on a local miss. It uses the last close within 30 days at or before the block minute without looking ahead; fields are null when neither source has a retained fair price in that window. - historicalValueUsd and currentValueUsd are unsigned amount valuations. This wallet-independent operation does not assign a cash-flow sign. - fee includes network fee, compute, Jito-tip, Token-2022 fee, and activity-count details. memos is a separate ordered array on the transaction activity row. Use get_transactions with the same hash batch only when a flat programInteractions list is preferable to transactionActivity.flow. - Migration 279 added notes with default []. Existing historical transactions were not backfilled. Validated protocol events can retain a transaction and its program interactions even without physical transfers. Notes alone do not classify swaps, establish wallet identity, or prove complete protocol-event coverage. - Transfer amount/rawAmount and USD values retain gross semantics. transferFeeAmount and netReceivedAmount use the same UI multiplier as amount; transferFeeRawAmount is unchanged. Missing fees, including historical and RPC recovery rows, do not imply zero and leave netReceivedAmount null. Explicit zero fees preserve the gross amount. Portfolio-history incoming flows use netReceivedAmount; these activity USD fields remain gross. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for wallet-independent indexed transaction activity.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "transactionActivity": { "type": [ "array", "null" ], "description": "Indexed transaction activity in first-occurrence input order. Hashes absent from indexed transaction metadata are omitted.", "items": { "type": "object", "additionalProperties": true, "properties": { "txHash": { "type": "string", "description": "Solana transaction signature." }, "txExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public transaction URL paired with txHash." }, "blockSlot": { "type": "string", "description": "Precision-safe Solana block slot." }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public block URL paired with blockSlot." }, "transactionIndex": { "type": "integer", "description": "Indexed transaction position within the block." }, "fee": { "type": [ "object", "null" ], "description": "Canonical fee/resource record selected through the activity header lookup. Memo Program instructions are exposed by the sibling memos array.", "additionalProperties": true, "properties": { "feePayer": { "type": "string" }, "feePayerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "totalFeeLamports": { "type": [ "string", "null" ], "description": "Authoritative Solana runtime network fee, excluding separate Jito-tip transfers and Token-2022 transfer fees." }, "baseFeeLamports": { "type": [ "string", "null" ] }, "prioritizationFeeLamports": { "type": [ "string", "null" ] }, "feeBreakdownStatus": { "type": "string" }, "signatureCount": { "type": "integer" }, "computeUnitsConsumed": { "type": [ "string", "null" ] }, "costUnits": { "type": [ "string", "null" ] }, "loadedAccountsDataSize": { "type": [ "string", "null" ] }, "computeUnitLimit": { "type": [ "integer", "null" ] }, "computeUnitPriceMicroLamports": { "type": [ "string", "null" ] }, "requestedHeapFrameBytes": { "type": [ "integer", "null" ] }, "requestedLoadedAccountsDataSizeLimit": { "type": [ "integer", "null" ] }, "jitoTipLamports": { "type": "string" }, "jitoTipTransferIndices": { "type": "array", "items": { "type": "integer" } }, "jitoTipAccounts": { "type": "array", "items": { "type": "string" } }, "jitoTipAccountExplorerUrls": { "type": "array", "items": { "type": [ "string", "null" ], "format": "uri" } }, "jitoTipAmountsLamports": { "type": "array", "items": { "type": "string" } }, "token2022FeeTransferIndices": { "type": "array", "items": { "type": "integer" } }, "token2022FeeMints": { "type": "array", "items": { "type": "string" } }, "token2022FeeMintExplorerUrls": { "type": "array", "items": { "type": [ "string", "null" ], "format": "uri" } }, "token2022FeeRawAmounts": { "type": "array", "items": { "type": "string" } }, "token2022FeeDecimals": { "type": "array", "items": { "type": "integer" } }, "token2022FeeAmounts": { "type": "array", "items": { "type": "string" } }, "tokenTransferCount": { "type": "integer" }, "tokenMintCount": { "type": "integer" }, "tokenBurnCount": { "type": "integer" }, "walletFacingDexSwapCount": { "type": "integer" }, "hasWalletFacingDexSwap": { "type": "boolean" } } }, "memos": { "type": "array", "description": "Memo Program instructions attached to the transaction, ordered by top-level and inner-instruction coordinates. Empty when no memo was indexed.", "items": { "type": "object", "additionalProperties": false, "properties": { "instructionIndex": { "type": "integer", "description": "Zero-based top-level instruction index containing the memo." }, "innerInstructionIndex": { "type": "integer", "description": "Zero-based inner-instruction index, or -1 for a top-level memo." }, "content": { "type": "string", "description": "UTF-8 memo content retained by the indexer." } }, "required": [ "instructionIndex", "innerInstructionIndex", "content" ] } }, "notes": { "type": "array", "description": "Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution.", "items": { "type": "object", "additionalProperties": true, "properties": { "e": { "type": "string", "description": "Event code: pb = PumpSwap BoostBuyAndBurnEvent, pi = InitBoostEvent, pa = SetBoostAuthorityEvent. Future codes are preserved." }, "i": { "type": "integer", "description": "Zero-based outer instruction index of the emitting operation." }, "j": { "type": "integer", "description": "Zero-based inner instruction index of the emitting operation; omitted for outer calls." }, "t": { "type": "integer", "description": "Event timestamp in Unix seconds, not the transaction block timestamp." }, "m": { "type": "string", "description": "Base mint (pb, pi)." }, "c": { "type": "string", "description": "Bonding curve address (pb, pi)." }, "p": { "type": "string", "description": "Pool address (pb, pi); pool metadata supplies the quote mint and decimals." }, "a": { "type": "string", "description": "Authority for pb; admin for pa. Not necessarily a trader or fee payer." }, "qr": { "type": "string", "description": "quote_amount_in_requested in raw quote units (pb)." }, "qu": { "type": "string", "description": "quote_amount_in_used in raw quote units (pb)." }, "b": { "type": "string", "description": "base_amount_burned in raw base units (pb)." }, "vq": { "type": "string", "description": "virtual_quote_reserves, a signed i128 in raw quote units (pb, pi)." }, "rq": { "type": "string", "description": "real_quote_reserves_after in raw quote units (pb, pi)." }, "rb": { "type": "string", "description": "base_reserves_after in raw base units (pb)." }, "v": { "type": "string", "description": "boost_vault_remaining in raw quote units (pb)." }, "o": { "type": "string", "description": "Old BOOST authority (pa)." }, "n": { "type": "string", "description": "New BOOST authority (pa)." } } } }, "trades": { "type": "array", "description": "Indexed DEX execution views. One operation can appear from multiple token perspectives; do not sum volumeUsd as transaction cash flow.", "items": { "type": "object", "additionalProperties": true, "properties": { "token": { "type": "string" }, "tokenExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "side": { "type": "string", "enum": [ "UNKNOWN", "BUY", "SELL" ] }, "priceUsd": { "type": "number" }, "amount": { "type": "number" }, "volumeUsd": { "type": "number" }, "otherToken": { "type": "string" }, "otherTokenExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "otherTokenAmount": { "type": "number" }, "poolAddress": { "type": [ "string", "null" ] }, "poolExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "userWallet": { "type": "string" }, "userWalletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "aggregatorProgram": { "type": [ "string", "null" ] }, "aggregatorProgramExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "relayerWallet": { "type": [ "string", "null" ] }, "relayerWalletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "gatewayFees": { "type": [ "number", "null" ], "description": "Attributed gateway or aggregator fee ratio, or null when unknown." }, "ammFees": { "type": [ "number", "null" ], "description": "Attributed AMM fee ratio, or null when unknown." }, "compoundFees": { "type": "number", "description": "Compatibility total of gatewayFees and ammFees, treating missing components as zero." }, "operationIndex": { "type": "integer" }, "tradeLayer": { "type": "string" }, "baselinePriceUsd": { "type": [ "number", "null" ] }, "potentialSlippage": { "type": "number" }, "poolPriceConfidence": { "type": "number" } } } }, "transfers": { "type": "array", "description": "Indexed physical token movements. No wallet-relative direction is inferred.", "items": { "type": "object", "additionalProperties": true, "properties": { "transferIndex": { "type": "integer" }, "operationIndex": { "type": "integer", "description": "Alias of instructionIndex for common activity ordering." }, "instructionIndex": { "type": "integer" }, "innerInstructionIndex": { "type": "integer" }, "tokenProgramId": { "type": "string" }, "tokenProgramExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "transferType": { "type": "string" }, "intent": { "type": "string", "description": "Instruction-derived transfer mechanism. This is not a recipient-purpose inference; historical unreplayed rows use unknown." }, "authority": { "type": "string" }, "authorityExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "sourceOwner": { "type": "string" }, "sourceOwnerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "destinationOwner": { "type": "string" }, "destinationOwnerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "mint": { "type": "string" }, "mintExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "sourceAccount": { "type": "string" }, "sourceAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "destinationAccount": { "type": "string" }, "destinationAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "rawAmount": { "type": "string" }, "decimals": { "type": "integer" }, "amount": { "type": "number", "description": "Gross indexed transfer amount before transfer fees, in current Token-2022 display units by default. rawAmount stays in source integer units. netReceivedAmount describes the recipient amount; neither is a signed wallet balance delta. RPC balance-delta recovery rows retain their existing balance-change amount and have null fee/net fields." }, "historicalPriceUsd": { "type": [ "number", "null" ], "description": "Last retained fair close at or before the transaction block minute." }, "historicalPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time", "description": "Fair OHLCV minute that supplied historicalPriceUsd." }, "historicalValueUsd": { "type": [ "number", "null" ], "description": "Unsigned amount multiplied by historicalPriceUsd." }, "currentPriceUsd": { "type": [ "number", "null" ], "description": "Current token_stats price at query time." }, "currentPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time", "description": "Fair-price source minute associated with currentPriceUsd." }, "currentValueUsd": { "type": [ "number", "null" ], "description": "Unsigned amount multiplied by currentPriceUsd; not historical transaction value." }, "transferFeeRawAmount": { "type": [ "string", "null" ], "description": "Recorded transfer fee withheld in this mint, as a precision-safe raw integer string. Null means no exact fee was recorded, not zero. Separate from network, priority and AMM fees. Unchanged by UI multipliers." }, "transferFeeAmount": { "type": [ "number", "null" ], "description": "Recorded transfer fee withheld in this mint, in the same units as amount. Uses the current Token-2022 UI multiplier by default. Null means no exact fee was recorded, not zero." }, "netReceivedAmount": { "type": [ "number", "null" ], "description": "Recipient amount after the recorded transfer fee, in the same units as amount. Calculated from source decimals before UI adjustment. Null when the fee is unknown or outside zero through gross amount. Explicit zero fees return the gross amount. This is not a signed wallet balance delta; existing USD values still use gross amount." } } } }, "holdingsBefore": { "type": "array", "description": "Indexed token-account balances immediately before transaction execution. Empty when no retained balance change is retained or the transaction is outside the three-day source retention.", "items": { "type": "object", "additionalProperties": true, "properties": { "wallet": { "type": "string", "description": "Indexed token-account owner wallet; empty when owner resolution was unavailable." }, "walletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "authority": { "type": "string", "description": "Indexed authority associated with this account-level holding change; empty when unavailable." }, "authorityExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "tokenAccount": { "type": "string", "description": "Token account whose pre-transaction balance is represented." }, "tokenAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "mint": { "type": "string" }, "mintExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "amount": { "type": "number", "description": "UI token-account balance immediately before execution." } } } }, "holdingsAfter": { "type": "array", "description": "Indexed token-account balances immediately after transaction execution. Empty when no retained balance change exists or the transaction is outside the three-day source retention.", "items": { "type": "object", "additionalProperties": true, "properties": { "wallet": { "type": "string", "description": "Indexed token-account owner wallet; empty when owner resolution was unavailable." }, "walletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "authority": { "type": "string", "description": "Indexed authority associated with this account-level holding change; empty when unavailable." }, "authorityExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "tokenAccount": { "type": "string", "description": "Token account whose post-transaction balance is represented." }, "tokenAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "mint": { "type": "string" }, "mintExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "amount": { "type": "number", "description": "UI token-account balance immediately after execution." } } } }, "flow": { "type": "array", "description": "Program-interaction flow roots. Each node has a standardized lowercase type derived from its attached activity. Children follow CPI stack ownership; transfers attach to exact instruction coordinates and trade rows annotate the invocation that performed the swap. Nested arrays reuse transaction-level source facts and are not additive with top-level trades/transfers.", "items": { "type": "object", "additionalProperties": true, "properties": { "type": { "type": "string", "enum": [ "program_invocation", "swap", "transfer", "account_creation", "account_closure", "wrap_sol", "unwrap_sol", "nonce_withdrawal", "mint", "burn", "authority_change" ], "description": "Standardized purpose derived from the activity attached to this flow node." }, "interactionIndex": { "type": "integer" }, "instructionIndex": { "type": "integer" }, "innerInstructionIndex": { "type": "integer" }, "stackHeight": { "type": [ "integer", "null" ] }, "programId": { "type": "string" }, "programExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "programName": { "type": "string", "description": "Canonical built-in or reviewed program label when known." }, "isSwap": { "type": "boolean" }, "trades": { "type": "array", "description": "Trade perspectives attributed to this invocation. Equal operationIndex values describe one logical swap.", "items": { "type": "object", "additionalProperties": true, "properties": { "operationIndex": { "type": "integer" }, "tradeLayer": { "type": "string" }, "token": { "type": "string" }, "side": { "type": "string", "enum": [ "UNKNOWN", "BUY", "SELL" ] }, "priceUsd": { "type": "number" }, "amount": { "type": "number" }, "volumeUsd": { "type": "number" }, "otherToken": { "type": "string" }, "otherTokenAmount": { "type": "number" }, "poolAddress": { "type": [ "string", "null" ] }, "userWallet": { "type": "string" }, "aggregatorProgram": { "type": [ "string", "null" ] } } } }, "transfers": { "type": "array", "description": "Transfers emitted by this exact instruction coordinate.", "items": { "type": "object", "additionalProperties": true, "properties": { "transferIndex": { "type": "integer" }, "instructionIndex": { "type": "integer" }, "innerInstructionIndex": { "type": "integer" }, "intent": { "type": "string", "description": "Instruction-derived transfer mechanism for this contextual placement of the source transfer fact." }, "mint": { "type": "string" }, "amount": { "type": "number", "description": "Gross indexed transfer amount before transfer fees, in current Token-2022 display units by default. rawAmount stays in source integer units. netReceivedAmount describes the recipient amount; neither is a signed wallet balance delta. RPC balance-delta recovery rows retain their existing balance-change amount and have null fee/net fields." }, "historicalPriceUsd": { "type": [ "number", "null" ] }, "historicalPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time" }, "historicalValueUsd": { "type": [ "number", "null" ] }, "currentPriceUsd": { "type": [ "number", "null" ] }, "currentPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time" }, "currentValueUsd": { "type": [ "number", "null" ] }, "sourceOwner": { "type": "string" }, "destinationOwner": { "type": "string" }, "sourceAccount": { "type": "string" }, "destinationAccount": { "type": "string" }, "transferFeeRawAmount": { "type": [ "string", "null" ], "description": "Recorded transfer fee withheld in this mint, as a precision-safe raw integer string. Null means no exact fee was recorded, not zero. Separate from network, priority and AMM fees. Unchanged by UI multipliers." }, "transferFeeAmount": { "type": [ "number", "null" ], "description": "Recorded transfer fee withheld in this mint, in the same units as amount. Uses the current Token-2022 UI multiplier by default. Null means no exact fee was recorded, not zero." }, "netReceivedAmount": { "type": [ "number", "null" ], "description": "Recipient amount after the recorded transfer fee, in the same units as amount. Calculated from source decimals before UI adjustment. Null when the fee is unknown or outside zero through gross amount. Explicit zero fees return the gross amount. This is not a signed wallet balance delta; existing USD values still use gross amount." } } } }, "children": { "type": "array", "description": "Nested CPI program invocations in inner-instruction order.", "items": { "type": "object", "additionalProperties": true, "properties": { "type": { "type": "string", "enum": [ "program_invocation", "swap", "transfer", "account_creation", "account_closure", "wrap_sol", "unwrap_sol", "nonce_withdrawal", "mint", "burn", "authority_change" ], "description": "Standardized purpose derived from the activity attached to this child flow node." }, "interactionIndex": { "type": "integer" }, "instructionIndex": { "type": "integer" }, "innerInstructionIndex": { "type": "integer", "description": "Inner instruction index; -1 identifies a top-level invocation." }, "stackHeight": { "type": [ "integer", "null" ] }, "programId": { "type": "string" }, "programExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "programName": { "type": "string", "description": "Canonical built-in or reviewed program label when known." }, "isSwap": { "type": "boolean" }, "trades": { "type": "array", "description": "Trade perspectives attributed to this child invocation. These reuse transaction-level source facts; equal operationIndex values describe one logical swap.", "items": { "type": "object", "additionalProperties": true, "properties": { "operationIndex": { "type": "integer" }, "tradeLayer": { "type": "string" }, "token": { "type": "string" }, "side": { "type": "string", "enum": [ "UNKNOWN", "BUY", "SELL" ] }, "priceUsd": { "type": "number" }, "amount": { "type": "number" }, "volumeUsd": { "type": "number" }, "otherToken": { "type": "string" }, "otherTokenAmount": { "type": "number" }, "poolAddress": { "type": [ "string", "null" ] }, "userWallet": { "type": "string" }, "aggregatorProgram": { "type": [ "string", "null" ] }, "gatewayFees": { "type": [ "number", "null" ] }, "ammFees": { "type": [ "number", "null" ] }, "compoundFees": { "type": "number" }, "baselinePriceUsd": { "type": [ "number", "null" ] }, "potentialSlippage": { "type": "number" }, "poolPriceConfidence": { "type": "number" } } } }, "transfers": { "type": "array", "description": "Transfers placed on this exact child invocation. These reuse transaction-level source facts and include selectable historical/current USD valuation.", "items": { "type": "object", "additionalProperties": true, "properties": { "transferIndex": { "type": "integer" }, "instructionIndex": { "type": "integer" }, "innerInstructionIndex": { "type": "integer" }, "intent": { "type": "string", "description": "Instruction-derived transfer mechanism for this contextual placement of the source transfer fact." }, "mint": { "type": "string" }, "amount": { "type": "number", "description": "Gross indexed transfer amount before transfer fees, in current Token-2022 display units by default. rawAmount stays in source integer units. netReceivedAmount describes the recipient amount; neither is a signed wallet balance delta. RPC balance-delta recovery rows retain their existing balance-change amount and have null fee/net fields." }, "historicalPriceUsd": { "type": [ "number", "null" ] }, "historicalPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time" }, "historicalValueUsd": { "type": [ "number", "null" ] }, "currentPriceUsd": { "type": [ "number", "null" ] }, "currentPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time" }, "currentValueUsd": { "type": [ "number", "null" ] }, "sourceOwner": { "type": "string" }, "destinationOwner": { "type": "string" }, "sourceAccount": { "type": "string" }, "destinationAccount": { "type": "string" }, "transferFeeRawAmount": { "type": [ "string", "null" ], "description": "Recorded transfer fee withheld in this mint, as a precision-safe raw integer string. Null means no exact fee was recorded, not zero. Separate from network, priority and AMM fees. Unchanged by UI multipliers." }, "transferFeeAmount": { "type": [ "number", "null" ], "description": "Recorded transfer fee withheld in this mint, in the same units as amount. Uses the current Token-2022 UI multiplier by default. Null means no exact fee was recorded, not zero." }, "netReceivedAmount": { "type": [ "number", "null" ], "description": "Recipient amount after the recorded transfer fee, in the same units as amount. Calculated from source decimals before UI adjustment. Null when the fee is unknown or outside zero through gross amount. Explicit zero fees return the gross amount. This is not a signed wallet balance delta; existing USD values still use gross amount." } } } }, "instructionName": { "type": [ "string", "null" ], "description": "Instruction name supplied by indexed parsing when known; null means the instruction was not resolved." } } } }, "instructionName": { "type": [ "string", "null" ], "description": "Instruction name supplied by indexed parsing when known; null means the instruction was not resolved." } } } } } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query TransactionActivity($transactionHashes: [String!]!, $includeInnerSwaps: Boolean, $explorer: SolanaExplorerKind = SOLSCAN) { solana { transactionActivity(transactionHashes: $transactionHashes, includeInnerSwaps: $includeInnerSwaps, explorer: $explorer) { txHash txExplorerUrl blockSlot blockExplorerUrl transactionIndex fee { feePayer totalFeeLamports baseFeeLamports prioritizationFeeLamports feeBreakdownStatus computeUnitsConsumed jitoTipLamports } memos { instructionIndex innerInstructionIndex content } notes holdingsBefore { wallet walletExplorerUrl authority authorityExplorerUrl tokenAccount tokenAccountExplorerUrl mint mintExplorerUrl amount } holdingsAfter { wallet walletExplorerUrl authority authorityExplorerUrl tokenAccount tokenAccountExplorerUrl mint mintExplorerUrl amount } flow { type interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator instructionDataLength accountCount isSwap trades { operationIndex tradeLayer token side priceUsd amount volumeUsd otherToken otherTokenAmount poolAddress userWallet aggregatorProgram gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } transfers { transferIndex instructionIndex innerInstructionIndex intent mint amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd sourceOwner destinationOwner sourceAccount destinationAccount } children { type interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator isSwap trades { operationIndex tradeLayer token side priceUsd amount volumeUsd otherToken otherTokenAmount poolAddress userWallet aggregatorProgram gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } transfers { transferIndex instructionIndex innerInstructionIndex intent mint amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd sourceOwner destinationOwner sourceAccount destinationAccount } } } } } } ``` - **Expected minimum rows:** `1` Variables: ```json { "transactionHashes": [ "37hoJKk9qdT8C7oKQ4tR2sxJuQQwAcZ1HaxQkQhhej2JWRPZRud2bRM3UpJ35cWj2NoH8GsXuAbBZYoYDVhYuTnc" ], "includeInnerSwaps": true, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_transaction_activity?transactionHashes=37hoJKk9qdT8C7oKQ4tR2sxJuQQwAcZ1HaxQkQhhej2JWRPZRud2bRM3UpJ35cWj2NoH8GsXuAbBZYoYDVhYuTnc&includeInnerSwaps=true&explorer=SOLSCAN) ### `get_transactions` - **Map operation:** `getTransactions` - **Title:** `Get Solana transaction enrichment` - **Kind:** `query` - **GraphQL path:** `solana.transactions` Batch-enrich known Solana transaction signatures, including native-SOL-only movement transactions, with indexed fee, compute-budget, Jito-tip, Token-2022 fee, activity-count, and ordered program-interaction details. Use this after any wallet, DEX, pool-graduation, or other result that returns txHash. This focused transaction-level query does not duplicate DEX trades, transfer rows, wallet activity, pool rows, or arbitrary RPC decoding. Program interactions include known program labels, nullable parsed instructionName, and the retained raw instructionDiscriminator. Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution. **Data dictionary:** `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-program-interaction` (fact; One indexed program invocation per transaction and instruction ordering tuple.) **Related topics:** `transaction`, `transactions`, `transaction enrichment`, `transaction details`, `txHash`, `tx hash`, `signature`, `fees`, `priority fee`, `compute units`, `Jito tip`, `Token-2022 fee`, `program interactions`, `program invocations`, `instruction details`, `native SOL`, `SOL transfer`, `system transfer`, `notes`, `protocol events`, `PumpSwap BOOST` #### Use When - A prior Blockchain.ai result contains txHash and the user asks for transaction-level details. - The user supplies one or more Solana transaction signatures directly. - The user asks about network fees, priority fees, compute consumption, Jito tips, Token-2022 transfer fees, activity counts, or invoked programs for known transactions. - The user supplies a native SOL-only movement transaction signature and needs its indexed fee or program invocations. - A wallet or DEX analysis needs transaction context without re-querying or duplicating its specialized trade and transfer rows. - The user needs indexed protocol event notes, including PumpSwap BOOST events, beside Memo Program content. #### Arguments ##### `transactionHashes` - **GraphQL type:** `[String!]!` - **Required:** `true` One to 100 Solana transaction signatures. Batch 25 to 100 hashes per request when possible. Blank values are removed and duplicate values are collapsed by exact signature while retaining first occurrence. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, block, fee-payer, fee-mint, and program URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql txHash txExplorerUrl blockSlot blockExplorerUrl blockTime transactionIndex fee { feePayer feePayerExplorerUrl totalFeeLamports baseFeeLamports prioritizationFeeLamports feeBreakdownStatus signatureCount computeUnitsConsumed costUnits loadedAccountsDataSize computeUnitLimit computeUnitPriceMicroLamports requestedHeapFrameBytes requestedLoadedAccountsDataSizeLimit jitoTipLamports jitoTipTransferIndices jitoTipAccounts jitoTipAccountExplorerUrls jitoTipAmountsLamports token2022FeeTransferIndices token2022FeeMints token2022FeeMintExplorerUrls token2022FeeRawAmounts token2022FeeDecimals token2022FeeAmounts tokenTransferCount tokenMintCount tokenBurnCount walletFacingDexSwapCount hasWalletFacingDexSwap } memos { instructionIndex innerInstructionIndex content } notes programInteractions { interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator instructionDataLength accountCount } ``` #### Field Notes ##### `fee` Transaction-level fee, compute/resource, Jito-tip, Token-2022 fee, and indexed activity-count context. Native-SOL-only movement transactions are eligible; Memo Program instructions are exposed by the sibling memos array. ##### `memos` Ordered indexed Memo Program instructions. innerInstructionIndex is -1 for a top-level memo; content is the retained UTF-8 payload. ##### `notes` Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution. ##### `programInteractions` Ordered top-level and inner instruction context. instructionName is null when unresolved; instructionDiscriminator is a raw prefix identity hint, not an ABI decode. Select it only when invocation details are needed. ##### `tokenTransferCount` Indexed physical transfer count. Despite the legacy field name, it includes native SOL transfers as well as SPL token transfers. ##### `walletFacingDexSwapCount` Count of wallet-facing dex_swaps records. It excludes route-only MEV/Inner activity rows. ##### `hasWalletFacingDexSwap` Whether a wallet-facing dex_swaps record exists. Use list_wallet_activity tradeLayer for MEV classification; false does not prove that the transaction had no DEX route activity. ##### `dexSwapCount` Deprecated compatibility alias for walletFacingDexSwapCount. ##### `isTrade` Deprecated compatibility alias for hasWalletFacingDexSwap. ##### `totalFeeLamports` Authoritative Solana runtime network fee. It excludes recognized Jito-tip transfers and Token-2022 transfer fees. ##### `baseFeeLamports` Non-priority network-fee remainder, valid only when feeBreakdownStatus is exact. ##### `prioritizationFeeLamports` Requested prioritization fee computed from the explicit or runtime-inferred effective compute-unit limit, valid only when feeBreakdownStatus is exact. ##### `computeUnitLimit` Effective limit used for the split. New rows may infer the Solana runtime default; legacy unresolved rows may be null. ##### `jitoTipLamports` Recognized Jito tip transfer, separate from totalFeeLamports. ##### `feeBreakdownStatus` Explains whether baseFeeLamports and prioritizationFeeLamports are exact. Legacy or unresolved null splits are unknown and must not be converted to zero. ##### `txHash` Join key back to list_wallet_activity, get_dex_token_transactions, get_dex_pool_transactions, pool graduation metadata, or another specialized result. ##### `txExplorerUrl` Derived public transaction URL paired with txHash. Defaults to Solscan. ##### `blockExplorerUrl` Derived public block URL paired with blockSlot. Defaults to Solscan. ##### `notes.e` Event code: pb = PumpSwap BoostBuyAndBurnEvent, pi = InitBoostEvent, pa = SetBoostAuthorityEvent. Future codes are preserved. ##### `notes.i` Zero-based outer instruction index of the emitting operation. ##### `notes.j` Zero-based inner instruction index of the emitting operation; omitted for outer calls. ##### `notes.t` Event timestamp in Unix seconds, not the transaction block timestamp. ##### `notes.m` Base mint (pb, pi). ##### `notes.c` Bonding curve address (pb, pi). ##### `notes.p` Pool address (pb, pi); pool metadata supplies the quote mint and decimals. ##### `notes.a` Authority for pb; admin for pa. Not necessarily a trader or fee payer. ##### `notes.qr` quote_amount_in_requested in raw quote units (pb). ##### `notes.qu` quote_amount_in_used in raw quote units (pb). ##### `notes.b` base_amount_burned in raw base units (pb). ##### `notes.vq` virtual_quote_reserves, a signed i128 in raw quote units (pb, pi). ##### `notes.rq` real_quote_reserves_after in raw quote units (pb, pi). ##### `notes.rb` base_reserves_after in raw base units (pb). ##### `notes.v` boost_vault_remaining in raw quote units (pb). ##### `notes.o` Old BOOST authority (pa). ##### `notes.n` New BOOST authority (pa). #### MCP Note Use get_transactions to enrich any result containing txHash. Batch 25 to 100 unique hashes per request, join results back by txHash, preserve the specialized source as the authority for trades/transfers, and treat omitted hashes as not indexed in either transaction source table. #### Caveats - The hard maximum is 100 transaction hashes per request. Batch 25 to 100 hashes for normal enrichment instead of issuing one request per row. - Whitespace-only values are removed. Exact duplicate signatures are deduplicated and the first occurrence controls output position. - Returned rows preserve normalized first-occurrence input order. A hash absent from both indexed transaction metadata and program invocation history is omitted, not returned as null. - fee is null when only program interactions were indexed for a hash. programInteractions is empty when absent or when the field was not selected. - The fee read is keyed by txHash. Program invocations are added separately and concurrently only when programInteractions is selected. Native-SOL-only movement transactions are not excluded by an SPL-transfer or activity-count predicate. No wallet, DEX trade, transfer, pool, or RPC enrichment is performed. - Execution success, execution error, and error code are not available in the current transaction source tables and must not be inferred. - Native-SOL-only transactions can return fee and program-interaction enrichment, but this query does not expose solTransfers. Do not infer movement source, destination, or amount from fees or program names. - fee.walletFacingDexSwapCount and fee.hasWalletFacingDexSwap describe wallet-facing dex_swaps records only. Route-only MEV transactions represented by list_wallet_activity tradeLayer MEV/Inner rows can legitimately return zero and false. fee.dexSwapCount and fee.isTrade are deprecated aliases. - totalFeeLamports is the authoritative runtime network fee. Jito tips and Token-2022 transfer fees are separate movements and must not be added into or subtracted from the base/prioritization split. - Use baseFeeLamports and prioritizationFeeLamports only when feeBreakdownStatus is exact. Older or not-yet-reindexed rows can retain compute_unit_limit_missing or another unresolved status even after newer rows use runtime-inferred compute-unit defaults. - memos preserves every indexed Memo Program instruction as a sibling array beside fee. Top-level memos use innerInstructionIndex -1. A memo-only transaction without indexed token or native-SOL movement may be absent from transaction metadata. - Use specialized wallet/DEX tools for actual wallet movement and trade rows; use get_transactions only for transaction-level enrichment. - Migration 279 added notes with default []. Existing historical transactions were not backfilled. Validated protocol events can retain a transaction and its program interactions even without physical transfers. Notes alone do not classify swaps, establish wallet identity, or prove complete protocol-event coverage. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for batch Solana transaction enrichment.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "transactions": { "type": [ "array", "null" ], "description": "Indexed transactions in first-occurrence input order after exact-signature deduplication. Unknown hashes are omitted rather than represented by null rows.", "items": { "type": "object", "additionalProperties": true, "properties": { "txHash": { "type": "string", "description": "Solana transaction signature and join key back to the originating result." }, "txExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public transaction URL paired with txHash." }, "blockSlot": { "type": "string", "description": "Solana block slot represented as a precision-safe string." }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public block URL paired with blockSlot." }, "blockTime": { "type": "string", "format": "date-time", "description": "Indexed block timestamp in UTC." }, "transactionIndex": { "type": "integer", "description": "Zero-based transaction position within the block." }, "fee": { "type": [ "object", "null" ], "description": "Fee/resource record. Null when this hash exists only in indexed program invocation history.", "additionalProperties": true, "properties": { "feePayer": { "type": "string" }, "feePayerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "totalFeeLamports": { "type": [ "string", "null" ], "description": "Authoritative network fee charged by the Solana runtime, excluding separate Jito-tip transfers and Token-2022 transfer fees." }, "baseFeeLamports": { "type": [ "string", "null" ], "description": "Non-priority network-fee remainder when feeBreakdownStatus is exact." }, "prioritizationFeeLamports": { "type": [ "string", "null" ], "description": "Requested prioritization fee when feeBreakdownStatus is exact, using the explicit or runtime-inferred effective compute-unit limit." }, "feeBreakdownStatus": { "type": "string", "description": "Resolution status for the base/priority split. Legacy or unresolved rows can keep both split fields null; null means unknown, not zero." }, "signatureCount": { "type": "integer" }, "computeUnitsConsumed": { "type": [ "string", "null" ], "description": "Consumed compute units as a precision-safe integer string." }, "costUnits": { "type": [ "string", "null" ], "description": "Runtime cost units as a precision-safe integer string." }, "loadedAccountsDataSize": { "type": [ "string", "null" ], "description": "Loaded-account data size as a precision-safe integer string." }, "computeUnitLimit": { "type": [ "integer", "null" ], "description": "Effective compute-unit limit used for fee splitting. New rows can contain a runtime-inferred default; legacy unresolved rows can be null." }, "computeUnitPriceMicroLamports": { "type": [ "string", "null" ], "description": "Requested compute-unit price in micro-lamports." }, "requestedHeapFrameBytes": { "type": [ "integer", "null" ] }, "requestedLoadedAccountsDataSizeLimit": { "type": [ "integer", "null" ] }, "jitoTipLamports": { "type": "string", "description": "Total recognized Jito tip transfer in lamports. This is separate from totalFeeLamports." }, "jitoTipTransferIndices": { "type": "array", "items": { "type": "integer" } }, "jitoTipAccounts": { "type": "array", "items": { "type": "string" } }, "jitoTipAccountExplorerUrls": { "type": "array", "items": { "type": [ "string", "null" ], "format": "uri" }, "description": "Positionally aligned with jitoTipAccounts." }, "jitoTipAmountsLamports": { "type": "array", "items": { "type": "string" } }, "token2022FeeTransferIndices": { "type": "array", "items": { "type": "integer" } }, "token2022FeeMints": { "type": "array", "items": { "type": "string" } }, "token2022FeeMintExplorerUrls": { "type": "array", "items": { "type": [ "string", "null" ], "format": "uri" }, "description": "Positionally aligned with token2022FeeMints." }, "token2022FeeRawAmounts": { "type": "array", "items": { "type": "string" } }, "token2022FeeDecimals": { "type": "array", "items": { "type": "integer" } }, "token2022FeeAmounts": { "type": "array", "items": { "type": "string" } }, "tokenTransferCount": { "type": "integer", "description": "Indexed physical transfer count. Despite the legacy name, includes native SOL transfers as well as SPL token transfers." }, "tokenMintCount": { "type": "integer" }, "tokenBurnCount": { "type": "integer" }, "walletFacingDexSwapCount": { "type": "integer", "description": "Count of wallet-facing dex_swaps records. Route-only MEV activity represented by wallet activity MEV/Inner rows is excluded." }, "hasWalletFacingDexSwap": { "type": "boolean", "description": "True when at least one wallet-facing dex_swaps record was indexed. This is not a general DEX-activity flag and can be false for route-only MEV transactions." }, "dexSwapCount": { "type": "integer", "description": "Deprecated compatibility alias for walletFacingDexSwapCount." }, "isTrade": { "type": "boolean", "description": "Deprecated compatibility alias for hasWalletFacingDexSwap." } } }, "memos": { "type": "array", "description": "Memo Program instructions attached to the transaction, ordered by top-level and inner-instruction coordinates. Empty when no memo was indexed.", "items": { "type": "object", "additionalProperties": false, "properties": { "instructionIndex": { "type": "integer", "description": "Zero-based top-level instruction index containing the memo." }, "innerInstructionIndex": { "type": "integer", "description": "Zero-based inner-instruction index, or -1 for a top-level memo." }, "content": { "type": "string", "description": "UTF-8 memo content retained by the indexer." } }, "required": [ "instructionIndex", "innerInstructionIndex", "content" ] } }, "notes": { "type": "array", "description": "Indexed protocol event notes from transaction_fees.notes, decoded to a JSON array with compact keys and original ordering. Select notes without subfields (GraphQL Any scalar). Amounts and reserves remain raw integer decimal strings; no UI multiplier or USD conversion is applied. Empty when no notes were indexed. Historical transactions were not backfilled, so [] does not prove no event occurred. Notes are separate from Memo Program content and do not imply a swap or wallet attribution.", "items": { "type": "object", "additionalProperties": true, "properties": { "e": { "type": "string", "description": "Event code: pb = PumpSwap BoostBuyAndBurnEvent, pi = InitBoostEvent, pa = SetBoostAuthorityEvent. Future codes are preserved." }, "i": { "type": "integer", "description": "Zero-based outer instruction index of the emitting operation." }, "j": { "type": "integer", "description": "Zero-based inner instruction index of the emitting operation; omitted for outer calls." }, "t": { "type": "integer", "description": "Event timestamp in Unix seconds, not the transaction block timestamp." }, "m": { "type": "string", "description": "Base mint (pb, pi)." }, "c": { "type": "string", "description": "Bonding curve address (pb, pi)." }, "p": { "type": "string", "description": "Pool address (pb, pi); pool metadata supplies the quote mint and decimals." }, "a": { "type": "string", "description": "Authority for pb; admin for pa. Not necessarily a trader or fee payer." }, "qr": { "type": "string", "description": "quote_amount_in_requested in raw quote units (pb)." }, "qu": { "type": "string", "description": "quote_amount_in_used in raw quote units (pb)." }, "b": { "type": "string", "description": "base_amount_burned in raw base units (pb)." }, "vq": { "type": "string", "description": "virtual_quote_reserves, a signed i128 in raw quote units (pb, pi)." }, "rq": { "type": "string", "description": "real_quote_reserves_after in raw quote units (pb, pi)." }, "rb": { "type": "string", "description": "base_reserves_after in raw base units (pb)." }, "v": { "type": "string", "description": "boost_vault_remaining in raw quote units (pb)." }, "o": { "type": "string", "description": "Old BOOST authority (pa)." }, "n": { "type": "string", "description": "New BOOST authority (pa)." } } } }, "programInteractions": { "type": "array", "description": "Top-level and inner program invocations ordered by interactionIndex. This field triggers the second direct indexed-table read only when selected.", "items": { "type": "object", "additionalProperties": true, "properties": { "interactionIndex": { "type": "integer", "description": "Stable invocation order within the transaction." }, "instructionIndex": { "type": "integer", "description": "Outer instruction index." }, "innerInstructionIndex": { "type": "integer", "description": "Inner instruction index, or -1 for a top-level instruction." }, "stackHeight": { "type": [ "integer", "null" ] }, "programId": { "type": "string" }, "programExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "programName": { "type": "string", "description": "Canonical built-in or reviewed program label when known." }, "instructionDataLength": { "type": "integer" }, "accountCount": { "type": "integer" }, "instructionName": { "type": [ "string", "null" ], "description": "Instruction name supplied by indexed parsing when known; null means the instruction was not resolved." }, "instructionDiscriminator": { "type": [ "string", "null" ], "description": "Up to eight raw instruction-data bytes as lowercase hex. This is an identity hint, not an ABI decode; null when no raw discriminator was retained." } } } } } } } } } } }, "errors": { "type": "array", "description": "GraphQL errors. Do not fabricate transaction rows when this field is present.", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query Transactions($transactionHashes: [String!]!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { transactions(transactionHashes: $transactionHashes, explorer: $explorer) { txHash txExplorerUrl blockSlot blockExplorerUrl blockTime transactionIndex fee { feePayer feePayerExplorerUrl totalFeeLamports baseFeeLamports prioritizationFeeLamports feeBreakdownStatus computeUnitsConsumed computeUnitLimit computeUnitPriceMicroLamports jitoTipLamports jitoTipAccounts jitoTipAccountExplorerUrls token2022FeeMints token2022FeeMintExplorerUrls tokenTransferCount walletFacingDexSwapCount hasWalletFacingDexSwap } memos { instructionIndex innerInstructionIndex content } notes programInteractions { interactionIndex instructionIndex innerInstructionIndex stackHeight programId programExplorerUrl programName instructionName instructionDiscriminator } } } } ``` - **Expected minimum rows:** `1` Variables: ```json { "transactionHashes": [ "3EwYcNejQYJzaHopan1Sg27RFPRKgbeGXaeb7U3UuDzG46bqjYN6Jouv5YaYW1hv8qAxie3BAwsv5fWf8hUpiYz6" ], "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_transactions?transactionHashes=3EwYcNejQYJzaHopan1Sg27RFPRKgbeGXaeb7U3UuDzG46bqjYN6Jouv5YaYW1hv8qAxie3BAwsv5fWf8hUpiYz6&explorer=SOLSCAN) ### `get_transaction_coverage` - **Map operation:** `getTransactionCoverage` - **Title:** `Get Solana indexed coverage` - **Kind:** `query` - **GraphQL path:** `solana.transactionCoverage` Measure independent retained coverage for transaction fees/resources, ordered program interactions, canonical account evidence, DEX trades, liquidity events, physical token transfers, and fair candles. Use this single coverage operation before interpreting empty historical results. Combined is the conservative overlap of fees, program interactions, and account evidence only. Select only the datasets needed. Each returned measuredAt describes that dataset's measurement; their measurement times can differ. Failed measurements briefly back off before retrying. **Data dictionary:** `solana-hash-resolution` (entity; One routing record per resolved supported role for one exact input hash or slot; every syntactically valid input returns at least one routing record.), `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.), `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-liquidity-event` (fact; One replaceable decoded liquidity-provision event row per transaction-local operation and pool/token context.), `solana-token-transfer` (fact; One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.), `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-program-interaction` (fact; One indexed program invocation per transaction and instruction ordering tuple.) **Related topics:** `transaction coverage`, `fee coverage`, `program interaction coverage`, `account coverage`, `account identity coverage`, `DEX coverage`, `trade coverage`, `liquidity coverage`, `transfer coverage`, `candle coverage`, `coverageStartsAt`, `retention`, `old transaction` #### Use When - An old transaction signature returned no get_transactions row and the user needs to know whether it predates retained enrichment coverage. - The user asks when any indexed transaction, DEX, liquidity, transfer, or candle dataset coverage starts. - A client needs current retained boundaries before batching historical signatures or fact queries. - A DEX, liquidity, transfer, or candle query returned no rows and the client needs to distinguish no matching activity from a period outside retained coverage. #### Default Selection ```graphql fees { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } programInteractions { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } accounts { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } combined { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } trades { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } liquidityEvents { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } tokenTransfers { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } fairCandles { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } ``` #### Caveats - Coverage is measured from retained indexed rows and cached briefly; it can move as backfills and retention advance. - An empty historical result before the relevant dataset's indexedFromAt can mean the request predates retained coverage. Inside coverage, no row means no indexed match was found in that source. - accounts measures retained canonical evidence in account_identity_current_state. It does not claim that every account touched by every Solana transaction was classified. - combined intersects only fees, programInteractions, and accounts. DEX trades, liquidity events, token transfers, and fair candles have independent ranges and are not folded into combined. - When isComplete is false, the reported start is not an authoritative source floor because the local coverage view is unavailable or still backfilling. - This operation reports service index coverage, not canonical Solana network history or RPC completeness. #### Output Schema ```json { "type": "object", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "transactionCoverage": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "fees": { "$ref": "#/$defs/coverage" }, "programInteractions": { "$ref": "#/$defs/coverage" }, "accounts": { "$ref": "#/$defs/coverage" }, "combined": { "$ref": "#/$defs/coverage" }, "trades": { "$ref": "#/$defs/coverage" }, "liquidityEvents": { "$ref": "#/$defs/coverage" }, "tokenTransfers": { "$ref": "#/$defs/coverage" }, "fairCandles": { "$ref": "#/$defs/coverage" } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } }, "$defs": { "coverage": { "type": "object", "additionalProperties": true, "properties": { "dataset": { "type": "string" }, "indexedFromSlot": { "type": [ "string", "null" ] }, "indexedFromAt": { "type": [ "string", "null" ], "format": "date-time" }, "indexedThroughSlot": { "type": [ "string", "null" ] }, "indexedThroughAt": { "type": [ "string", "null" ], "format": "date-time" }, "measuredAt": { "type": "string", "format": "date-time" }, "isComplete": { "type": "boolean" } } } } } ``` #### Example ```graphql query TransactionCoverage { solana { transactionCoverage { fees { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } programInteractions { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } accounts { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } combined { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } trades { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } liquidityEvents { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } tokenTransfers { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } fairCandles { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt isComplete } } } } ``` Variables: ```json {} ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_transaction_coverage) ### `get_token_price_usd_at` - **Map operation:** `getDexTokenPriceUsdAt` - **Title:** `Get a historical Solana token USD price` - **Kind:** `query` - **GraphQL path:** `solana.dex.priceUsdAt` Resolve one token's point-in-time fair USD price from the last retained positive fair close within 30 days at or before a requested timestamp. The current Token-2022 UI multiplier applies by default; set adjustForUiMultiplier=false for source units. This uses the full-retention historical-price cache with canonical remote fallback and is not capped by the rolling tokenCandles window. **Data dictionary:** `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.) **Related topics:** `priceUsdAt`, `historical price`, `point-in-time price`, `transfer value`, `historical USD value`, `price at timestamp` #### Use When - The user asks what one Solana token was worth at a specific historical timestamp. - A historical transfer or transaction needs event-time USD valuation and no historicalPriceUsd field was selected or available on that row. - The requested timestamp is older than tokenCandles rolling retention and only a point value, not a candle series, is required. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Exact Solana token mint whose historical fair price should be resolved. ##### `at` - **GraphQL type:** `DateTime!` - **Required:** `true` UTC valuation timestamp. Resolution is ASOF backward: the last retained positive fair close at or before this time is used. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Divide the historical source price by the token's current Token-2022 UI multiplier. False returns the unadjusted historical price; this is not a historical multiplier reconstruction. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl requestedAt priceUsd priceSourceMinute ``` #### MCP Note Use this for event-time valuation outside tokenCandles retention. Preserve requestedAt and priceSourceMinute in the answer so stale carry-back is visible. #### Caveats - Resolution uses the last retained fair close within 30 days at or before at; it never looks forward and never substitutes the current token_stats price. - priceSourceMinute can be earlier than requestedAt for sparse tokens. Judge whether that gap is acceptable for the analysis. - priceUsd and priceSourceMinute are null when neither the full-retention local cache nor the canonical remote fair-price source has a positive finite close within 30 days at or before at. - This returns one point, not OHLCV, volume, or a continuous series. Use get_dex_token_candles for retained chart buckets. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for one point-in-time fair token price.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "dex": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "priceUsdAt": { "type": [ "object", "null" ], "additionalProperties": false, "properties": { "mint": { "type": "string" }, "mintExplorerUrl": { "type": [ "string", "null" ] }, "requestedAt": { "type": "string", "format": "date-time" }, "priceUsd": { "type": [ "number", "null" ] }, "priceSourceMinute": { "type": [ "string", "null" ], "format": "date-time" } }, "required": [ "mint", "mintExplorerUrl", "requestedAt", "priceUsd", "priceSourceMinute" ] } } } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query TokenPriceUsdAt($mint: String!, $at: DateTime!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { priceUsdAt(mint: $mint, at: $at, explorer: $explorer) { mint mintExplorerUrl requestedAt priceUsd priceSourceMinute } } } } ``` ##### Relative Variable Presets ```json { "at": "previousUtcDay" } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "explorer": "SOLSCAN", "at": "2026-10-24T00:00:00Z" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_token_price_usd_at?mint=So11111111111111111111111111111111111111112&explorer=SOLSCAN&at=2026-10-24T00%3A00%3A00Z) ### `get_dex_token_candles` - **Map operation:** `getDexTokenCandles` - **Title:** `Get Solana token candles` - **Kind:** `query` - **GraphQL path:** `solana.dex.tokenCandles` Read historical DEX fair-price OHLCV candles for one token mint, always ordered newest first. Prices and token volume are adjusted to the current Token-2022 UI amount multiplier by default; set adjustForUiMultiplier false for unadjusted values. Windows wholly inside rolling retention use the low-latency retained path. A window beginning before that boundary, ending before it, or implied by interval and limit to exceed it reads canonical indexed history without the rolling-retention clamp. Rolling retention defaults to seven days; older availability follows indexed historical coverage. continuous true fills through the requested end from the latest available close, while false returns observed buckets only. This is not a live stream, forecast, or TradingView adapter. **Data dictionary:** `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.) **Related topics:** `graduation`, `graduated`, `graduation candles`, `candles around graduation`, `price chart`, `continuous candles`, `gap-filled candles`, `sparse candles`, `how long did it take to graduate` #### Use When - The user asks for OHLCV candles, charts, VWAP, or historical price series for one token. - The user provides one mint and a time range. - The user asks for candle/price-chart context around token launch or graduation after pool/token timestamps are known. - Use continuous true for a bucket-by-bucket chart without time gaps; use false for data-quality analysis that must distinguish observed buckets from generated carry-forward buckets. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Exact Solana token mint whose fair-price candles should be returned. ##### `interval` - **GraphQL type:** `DexCandleInterval` - **Default:** `ONE_MINUTE` Server-side bucket size. Minimum bucket size is ONE_MINUTE. ###### Accepted Values ```json [ "ONE_MINUTE", "FIVE_MINUTE", "FIFTEEN_MINUTE", "ONE_HOUR", "FOUR_HOUR", "ONE_DAY" ] ``` ##### `from` - **GraphQL type:** `DateTime` Optional inclusive timestamp filter start. A candle is eligible when its interval overlaps from/to. A value before rolling retention reads canonical indexed history instead of clamping it. In continuous mode the carry-forward seed is the latest available close before the first requested bucket. ##### `to` - **GraphQL type:** `DateTime` Optional exclusive timestamp filter end. A candle is eligible when its interval overlaps from/to. Defaults to now and is clamped to now; the final overlapping bucket can therefore be incomplete and change as more source minutes arrive. ##### `continuous` - **GraphQL type:** `Boolean` - **Default:** `true` When true, return every bucket in sequence through to or now inside the requested window. Missing buckets copy the latest available close into open/high/low/close/vwap and set volume, volumeUsd, fairVolumeUsd, and sampleCount to zero. When false, return only buckets backed by observed 1-minute rows and skip the prior-close seed lookup. ##### `limit` - **GraphQL type:** `Int` - **Default:** `1000` - **Maximum:** `5000` Maximum returned candles. In continuous mode this bounds the trailing consecutive bucket window. In sparse mode it returns the latest observed buckets in the requested window. Results are ordered by bucketStart descending. A limit/interval span larger than rolling retention reads canonical indexed history. Ignored when disableLimit is true. ##### `disableLimit` - **GraphQL type:** `Boolean` - **Default:** `false` Set true to return every matching candle in the explicit date window without the 5000-row cap. An explicit from timestamp is required; to is optional and defaults to now. limit is ignored when this flag is true. Older windows can be expensive historical reads. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Apply the token's current Token-2022 UI amount multiplier to OHLC/VWAP and token volume. Set false to return unadjusted source values. USD volumes are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl for each candle. ###### Accepted Values ```json [ "SOLSCAN" ] ``` #### Default Selection ```graphql mint mintExplorerUrl bucketStart timeUnixSeconds open high low close vwap volume volumeUsd fairVolumeUsd sampleCount ``` #### Field Notes ##### `mintExplorerUrl` Public token URL for mint using the selected explorer. ##### `bucketStart` UTC start of the output bucket. Results are always ordered descending by this field. ##### `timeUnixSeconds` Unix-seconds representation of bucketStart. ##### `open/high/low/close/vwap` Aggregated fair-price values for observed buckets, divided by the current Token-2022 UI multiplier by default. In a generated continuous bucket all five values equal the carried prior close. ##### `volume` Aggregated token volume for observed rows, multiplied by the current Token-2022 UI multiplier by default; zero for a generated continuous bucket. ##### `volumeUsd/fairVolumeUsd` Aggregated source USD volume measures; both are zero for a generated continuous bucket. ##### `sampleCount` Number of observed fair 1-minute rows contributing to the bucket, not a trade count. Zero identifies a generated continuous bucket. #### MCP Note Keep ranges inside seven days for the low-latency retained path. Older or larger candle windows read canonical indexed history and may cost more. continuous=true fills through the requested end from the latest available close; use get_token_price_usd_at when one older point-in-time fair price is sufficient. #### Caveats - Request/response MCP tool: returns a finite historical candle list, not live streaming updates. - Rolling candle retention is runtime-configured and defaults to seven days. Older or larger requests read canonical indexed history; returned history is limited by its actual coverage, not by the rolling week. - A local-overload remote-source fallback also preserves availability for an in-retention request. That overload route keeps the requested bounded interval, while an out-of-retention route intentionally reads older primary history. - from/to are overlap filters: a candle is returned when its bucket interval overlaps the requested timestamp filter. - Without disableLimit, limit defaults to 1000 and is capped at 5000. Set disableLimit true only with an explicit from timestamp to return the complete date window; to may be omitted and defaults to now. Invalid unlimited requests return BAD_USER_INPUT. Large unlimited historical windows can be expensive primary queries. - Every response is sorted by bucketStart descending, including continuous carry-forward rows and sparse observed-only rows. - With continuous true, empty buckets through the requested end are filled from the latest observed close and have zero volume. Generated rows are chart continuity, not evidence of a trade or source observation. continuous does not change the requested range or source coverage. - The latest available close may predate the returned window and seed its leading gaps, but that older source candle is not itself returned. If no earlier close is available, leading gaps remain absent until an observed bucket establishes one. - With continuous false, no synthetic buckets are returned and gaps in bucketStart are expected. - sampleCount counts source 1-minute OHLCV rows in the bucket, not individual trades. The last bucket can be partial when to is omitted or falls inside it. - UI multiplier adjustment applies the currently known multiplier uniformly across historical candles; it does not reconstruct multiplier changes at each candle's event time. #### Example ```graphql query TokenCandles($mint: String!, $interval: DexCandleInterval, $from: DateTime, $to: DateTime, $continuous: Boolean, $limit: Int, $disableLimit: Boolean, $adjustForUiMultiplier: Boolean, $explorer: SolanaExplorerKind) { solana { dex { tokenCandles(mint: $mint, interval: $interval, from: $from, to: $to, continuous: $continuous, limit: $limit, disableLimit: $disableLimit, adjustForUiMultiplier: $adjustForUiMultiplier, explorer: $explorer) { mint mintExplorerUrl bucketStart timeUnixSeconds open high low close vwap volumeUsd fairVolumeUsd sampleCount } } } } ``` - **Expected minimum rows:** `1` ##### Relative Variable Presets ```json { "from": "startOfCurrentUtcDay" } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "interval": "FIVE_MINUTE", "continuous": true, "limit": 288, "explorer": "SOLSCAN", "from": "2026-10-25T00:00:00Z" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_token_candles?mint=So11111111111111111111111111111111111111112&interval=FIVE_MINUTE&continuous=true&limit=288&explorer=SOLSCAN&from=2026-10-25T00%3A00%3A00Z) ### `get_dex_token_transactions` - **Map operation:** `getDexTokenTransactions` - **Title:** `List Solana token transactions` - **Kind:** `query` - **GraphQL path:** `solana.dex.tokenTransactions` Read historical top-level DEX operations and optional liquidity add/remove events for one token mint, newest first. User, MEV, and Buyback layers are included; only technical Inner and UnresolvedInner rows are excluded. Resolve physical poolAddress values with list_pools for venue metadata. The exact value 'Ondo RWA' is a virtual venue with no pool row, legs, vaults, TVL, or pool explorer URL. Batch returned txHash values through get_transactions for transaction-level enrichment. This is indexed history, not a live stream, arbitrary transaction decoder, wallet portfolio lookup, or external explorer search. **Data dictionary:** `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-liquidity-event` (fact; One replaceable decoded liquidity-provision event row per transaction-local operation and pool/token context.) **Related topics:** `transactions`, `token transactions`, `recent trades`, `buys`, `sells`, `makers`, `tx hash`, `liquidity events`, `adds`, `removes`, `token activity`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue`, `dex program` #### Use When - The user asks for recent transactions, trades, buys, sells, makers, transaction hashes, or liquidity add/remove events for one token mint. - The user wants rows rather than candle buckets or aggregate stats. - The user asks which pools or counterpart tokens recent token activity used. - The user asks which exchange or DEX venue executed a token trade and needs poolAddress for venue resolution. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Solana token mint to use as the row perspective. ##### `filter` - **GraphQL type:** `DexTokenTransactionsFilterInput` ###### Input Fields ```json { "sinceUnixSeconds": "Long", "minVolumeUsd": "Float", "includeLiquidityEvents": "Boolean", "wallet": "String" } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Maximum:** `10000` ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, token, pool, maker-wallet, aggregator-program, and relayer-wallet URLs. Currently SOLSCAN is the only supported value. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust trade prices, baselines, and token amounts to current Token-2022 UI multipliers. False returns unadjusted values; USD notionals and fees are unchanged. #### Default Selection ```graphql mint mintExplorerUrl timeUnixSeconds kind priceUsd volumeUsd baseTokenAmount quoteTokenAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl otherTokenSymbol opIndex operationIndex sentMint sentAmount receivedMint receivedAmount tradeLayer aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence ``` #### MCP Note Use get_dex_token_transactions for top-level token-perspective User, MEV, and Buyback operations plus optional liquidity rows. Do not sum volumeUsd across token perspectives. Batch txHash values through get_transactions only when transaction fee, compute, tip, activity-count, or program-interaction context is needed. #### Caveats - Rows are newest first. - Trade rows are top-level operations: trade_layer User, MEV, Buyback, and any future non-inner layer. Technical Inner and UnresolvedInner rows are excluded. - priceUsd and volumeUsd are indexer-supplied ui_trades_v2 values; Graph does not recalculate them from baseTokenAmount and quoteTokenAmount. - sinceUnixSeconds defaults to a 24 hour lookback if omitted. - includeLiquidityEvents defaults to true; priceUsd and volumeUsd are zero for liquidity events. - sentMint/sentAmount and receivedMint/receivedAmount describe Buy/Sell input/output. They are null for liquidity and unresolved Swap rows; use mint/baseTokenAmount plus otherToken/quoteTokenAmount for those two-asset operations. - minVolumeUsd applies to trades only. - To resolve the exchange venue, call list_pools(poolAddresses: [row.poolAddress], limit: 1), read programId/programName, and optionally call get_program with programId. - Pass returned txHash values to get_transactions in batches when transaction-level fee/resource/program details are needed. - For readable metadata about the queried mint or otherToken values, call solana.tokens separately. - gatewayFees and ammFees preserve unknown attribution as null. compoundFees is their non-null compatibility sum, treating a missing component as zero. #### Structured Result Metadata ```json { "collectionPath": "data.solana.dex.tokenTransactions", "limitArgument": "limit", "countProperty": "rowCount", "selectorArguments": [ "mint" ] } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for top-level token DEX operations, including User, MEV, and Buyback layers.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true }, "errors": { "type": "array", "description": "GraphQL errors. Do not fabricate transaction rows when present.", "items": { "type": "object", "additionalProperties": true } }, "metadata": { "type": "object", "additionalProperties": true } } } ``` #### Example ```graphql query TokenTransactions($mint: String!, $filter: DexTokenTransactionsFilterInput, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { tokenTransactions(mint: $mint, filter: $filter, limit: $limit, explorer: $explorer) { mint mintExplorerUrl timeUnixSeconds kind priceUsd volumeUsd baseTokenAmount quoteTokenAmount sentMint sentAmount receivedMint receivedAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl otherTokenSymbol operationIndex tradeLayer aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } } } } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "filter": { "minVolumeUsd": 100, "includeLiquidityEvents": true }, "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_token_transactions?mint=So11111111111111111111111111111111111111112&filterMinVolumeUsd=100&filterIncludeLiquidityEvents=true&limit=100&explorer=SOLSCAN) ### `get_dex_pool_transactions` - **Map operation:** `getDexPoolTransactions` - **Title:** `List Solana pool transactions` - **Kind:** `query` - **GraphQL path:** `solana.dex.poolTransactions` Read historical pool executions and optional liquidity events, newest first. Physical trades count each execution once from the pool base-token perspective; older history uses only indexed Inner perspectives. maker and wallet filters use the row's attributed wallet. opIndex falls back to execution ordinal when unavailable. The 'Ondo RWA' virtual venue retains one preferred non-quote User perspective per operation and has no physical liquidity events or pool account. Batch txHash values through get_transactions for transaction enrichment. **Data dictionary:** `solana-pool-current` (entity; One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.), `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-liquidity-event` (fact; One replaceable decoded liquidity-provision event row per transaction-local operation and pool/token context.) **Related topics:** `pool transactions`, `pool trades`, `pool buys`, `pool sells`, `liquidity events`, `pool activity`, `tx hash`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue`, `dex program` #### Use When - The user provides a pool address and asks for recent trades or liquidity events in that pool. - The user asks for individual pool transactions rather than pool metadata or pool TVL. - The user already found a pool with solana.pool.pools and wants its transaction rows. - The user asks which exchange or DEX program owns the pool used by these trades. #### Arguments ##### `poolAddress` - **GraphQL type:** `String!` - **Required:** `true` Physical pool address or the exact recognized virtual execution-venue identifier 'Ondo RWA'. ##### `filter` - **GraphQL type:** `DexTokenTransactionsFilterInput` ###### Input Fields ```json { "sinceUnixSeconds": "Long", "minVolumeUsd": "Float", "includeLiquidityEvents": "Boolean", "wallet": "String" } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Maximum:** `10000` ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, token, pool, maker-wallet, aggregator-program, and relayer-wallet URLs. Currently SOLSCAN is the only supported value. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust trade prices, baselines, and token amounts to current Token-2022 UI multipliers. False returns unadjusted values; USD notionals and fees are unchanged. #### Default Selection ```graphql mint mintExplorerUrl timeUnixSeconds kind priceUsd volumeUsd baseTokenAmount quoteTokenAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl otherTokenSymbol opIndex operationIndex sentMint sentAmount receivedMint receivedAmount tradeLayer aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence ``` #### MCP Note Use get_dex_pool_transactions for deduplicated physical-pool or recognized virtual-venue traffic. 'Ondo RWA' is virtual and cannot be resolved to pool legs or liquidity. Batch txHash values through get_transactions only when transaction-level context is needed. #### Caveats - Rows are newest first. Physical pool rows use the pool base token as perspective; 'Ondo RWA' rows use a preferred non-quote token perspective selected independently for each transaction operation. - Physical trade coverage counts each execution once and excludes all User, MEV, and Buyback parent rows. The recognized 'Ondo RWA' virtual venue instead deduplicates User token perspectives by txHash and operationIndex. - priceUsd and volumeUsd are indexer-supplied ui_trades_v2 values; Graph does not recalculate them from baseTokenAmount and quoteTokenAmount. - sinceUnixSeconds defaults to a 24 hour lookback if omitted. - includeLiquidityEvents defaults to true; priceUsd and volumeUsd are zero for physical liquidity events. Virtual venues have no liquidity events, so this flag has no effect for 'Ondo RWA'. - sentMint/sentAmount and receivedMint/receivedAmount describe Buy/Sell route-leg input/output on Inner rows. They are null for liquidity rows. - Use solana.pool.pools first if the user gave a token mint/name rather than a pool address. - For a physical exchange venue, call list_pools(poolAddresses: [poolAddress], limit: 1), read programId/programName, and optionally call get_program. Do not call list_pools for 'Ondo RWA'; it is deliberately not a physical pool. - Pass returned txHash values to get_transactions in batches when transaction-level fee/resource/program details are needed. - gatewayFees and ammFees preserve unknown attribution as null. compoundFees is their non-null compatibility sum, treating a missing component as zero. #### Structured Result Metadata ```json { "collectionPath": "data.solana.dex.poolTransactions", "limitArgument": "limit", "countProperty": "rowCount", "selectorArguments": [ "poolAddress" ] } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for deduplicated pool DEX operations.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true }, "errors": { "type": "array", "description": "GraphQL errors. Do not fabricate transaction rows when present.", "items": { "type": "object", "additionalProperties": true } }, "metadata": { "type": "object", "additionalProperties": true } } } ``` #### Example ```graphql query PoolTransactions($poolAddress: String!, $filter: DexTokenTransactionsFilterInput, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { poolTransactions(poolAddress: $poolAddress, filter: $filter, limit: $limit, explorer: $explorer) { mint mintExplorerUrl timeUnixSeconds kind priceUsd volumeUsd baseTokenAmount quoteTokenAmount sentMint sentAmount receivedMint receivedAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl otherTokenSymbol operationIndex tradeLayer aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees baselinePriceUsd potentialSlippage poolPriceConfidence } } } } ``` - **Expected minimum rows:** `1` Variables: ```json { "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2", "filter": { "includeLiquidityEvents": true }, "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_pool_transactions?poolAddress=58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2&filterIncludeLiquidityEvents=true&limit=100&explorer=SOLSCAN) ### `get_dex_largest_trades` - **Map operation:** `getDexLargestTrades` - **Title:** `List largest Solana DEX trades` - **Kind:** `query` - **GraphQL path:** `solana.dex.largestTrades` Read canonical indexed large User trades, newest first. Global reads show the bought-token perspective; mint-scoped reads show matching token perspectives without deduplication. Global reads are limited to 24 hours and require minVolumeUsd of at least 10000; mint-scoped reads may cover up to 30 days and may use a lower positive threshold. **Data dictionary:** `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.) **Related topics:** `largest trades`, `large swaps`, `whale trades`, `high volume trades`, `top trades`, `sent asset`, `received asset` #### Use When - The user asks for recent large or whale-sized Solana DEX swaps. - The user wants wallet-facing large swaps rather than physical pool legs inside a route. - The user wants to scope large trades to one or more token mints. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional token mints matched against each User row's token. Both perspectives can appear when both sides match. Omit for the protected global bought-token feed. ##### `sinceUnixSeconds` - **GraphQL type:** `Long` Inclusive Unix timestamp. Defaults to 24 hours ago. Global reads are capped at 24 hours; mint-scoped reads are capped at 30 days. ##### `minVolumeUsd` - **GraphQL type:** `Float` - **Default:** `10000` - **Minimum:** `0` Minimum indexer-supplied USD notional. Global reads require at least 10000; lower positive values are accepted only with a mint scope. ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Maximum:** `500` ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build transaction URLs. Currently SOLSCAN is the only supported value. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust trade prices, baselines, and token amounts to current Token-2022 UI multipliers. False returns unadjusted values; USD notionals and fees are unchanged. #### Default Selection ```graphql mint timeUnixSeconds kind priceUsd volumeUsd baseTokenAmount quoteTokenAmount sentMint sentAmount receivedMint receivedAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl tradeLayer aggregatorProgram relayerWallet gatewayFees ammFees compoundFees ``` #### MCP Note Use get_dex_largest_trades for finite canonical history. Use the GraphQL largeTrades subscription only when a websocket-capable client explicitly needs provisional live events. #### Caveats - This is canonical indexed history, unlike subscription.largeTrades, which is provisional. - Global reads select the Buy perspective. Mint-scoped reads return each matching User token perspective without deduplication; one transaction can contain multiple operations. - Global requests are deliberately limited to 24 hours and minVolumeUsd >= 10000 to protect service capacity. Mint-scoped requests are limited to 30 days. - volumeUsd is indexer supplied. Do not infer current executable liquidity from it. - Use get_transactions with returned txHash values for fee, compute, tip, and program-interaction enrichment. #### Structured Result Metadata ```json { "collectionPath": "data.solana.dex.largestTrades", "limitArgument": "limit", "countProperty": "rowCount", "selectorArguments": [ "mints" ] } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for canonical large User trades.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true }, "errors": { "type": "array", "description": "GraphQL errors. Do not fabricate trade rows when present.", "items": { "type": "object", "additionalProperties": true } }, "metadata": { "type": "object", "additionalProperties": true } } } ``` #### Example ```graphql query LargestTrades($mints: [String!], $sinceUnixSeconds: Long, $minVolumeUsd: Float, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { largestTrades(mints: $mints, sinceUnixSeconds: $sinceUnixSeconds, minVolumeUsd: $minVolumeUsd, limit: $limit, explorer: $explorer) { mint timeUnixSeconds kind priceUsd volumeUsd sentMint sentAmount receivedMint receivedAmount maker txHash txExplorerUrl poolAddress gatewayFees ammFees compoundFees tradeLayer } } } } ``` Variables: ```json { "mints": [ "So11111111111111111111111111111111111111112" ], "minVolumeUsd": 10000, "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_largest_trades?mints=So11111111111111111111111111111111111111112&minVolumeUsd=10000&limit=100&explorer=SOLSCAN) ### `get_dex_token_activity` - **Map operation:** `getDexTokenActivity` - **Title:** `Get Solana token activity` - **Kind:** `query` - **GraphQL path:** `solana.dex.tokenActivity` Read top-level trade activity counters for one token mint over a required period: operation count, distinct active wallets, buy count, and sell count. User, MEV, and Buyback layers are included; technical Inner and UnresolvedInner rows are excluded. This is aggregate indexed DEX activity, not a wallet holder count or live stream. **Data dictionary:** `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.) **Related topics:** `activity`, `transaction count`, `txn count`, `active wallets`, `buy count`, `sell count`, `trade counters`, `token activity` #### Use When - The user asks how many trades, buys, sells, or active wallets a token had in a period. - The user wants counters rather than individual transaction rows. - The user asks for activity around launch or graduation after the mint and period are known. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Solana token mint. ##### `period` - **GraphQL type:** `DexPeriodInput!` - **Required:** `true` ###### Input Fields ```json { "from": "DateTime!", "to": "DateTime!" } ``` ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl periodStart periodEnd txnCount activeWalletCount buyCount sellCount ``` #### Caveats - period is required. - activeWalletCount is distinct wallets that traded in indexed DEX trade rows; it is not holder count. - txnCount counts top-level trade operations in the period, including User, MEV, and Buyback layers. Technical Inner and UnresolvedInner rows are excluded. #### Example ```graphql query TokenActivity($mint: String!, $period: DexPeriodInput!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { tokenActivity(mint: $mint, period: $period, explorer: $explorer) { mint mintExplorerUrl periodStart periodEnd txnCount activeWalletCount buyCount sellCount } } } } ``` ##### Relative Variable Presets ```json { "period.from": "previousUtcDay", "period.to": "startOfCurrentUtcDay" } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "period": { "from": "2026-10-24T00:00:00Z", "to": "2026-10-25T00:00:00Z" }, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_token_activity?mint=So11111111111111111111111111111111111111112&periodFrom=2026-10-24T00%3A00%3A00Z&periodTo=2026-10-25T00%3A00%3A00Z&explorer=SOLSCAN) ### `get_dex_pool_stats` - **Map operation:** `getDexPoolStats` - **Title:** `Get Solana pool statistics` - **Kind:** `query` - **GraphQL path:** `solana.dex.poolStats` Read a compact deduplicated trailing-window snapshot for one physical pool or recognized virtual venue. Physical pools return latest base-token price in current Token-2022 display units by default, price changes, indexed USD volume, and 24h activity counts. The exact 'Ondo RWA' venue aggregates volume and activity across its RWA markets but returns zero price fields because the shared venue has no single market price. This is a briefly cached aggregate, not pool TVL or liquidity holdings. Physical pool trade totals count executions once; distinct-wallet counts exclude unknown execution wallets and do not add enclosing route initiators. **Data dictionary:** `solana-pool-current` (entity; One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.), `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.) **Related topics:** `pool stats`, `pool activity`, `pool volume`, `pool price change`, `pool txn count`, `pool active wallets`, `pool buys`, `pool sells` #### Use When - The user provides a pool address and asks for current pool trading stats or activity summary. - The user wants pool-level trailing volume, price change, transaction count, active wallets, buy count, or sell count. - The user wants a compact pool snapshot rather than individual poolTransactions rows. #### Arguments ##### `poolAddress` - **GraphQL type:** `String!` - **Required:** `true` Physical pool address or the exact recognized virtual execution-venue identifier 'Ondo RWA'. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Divide the physical pool's base-token priceUsd by its current Token-2022 UI multiplier. False returns the source price; USD volume is unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build poolExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql poolAddress poolExplorerUrl periodEnd priceUsd volumeUsd5m volumeUsd1h volumeUsd6h volumeUsd24h priceChange5mPercent priceChange1hPercent priceChange6hPercent priceChange24hPercent txnCount24h activeWalletCount24h buyCount24h sellCount24h ``` #### Caveats - Physical rows are aggregated from the pool base-token perspective over a 24 hour lookback. 'Ondo RWA' is aggregated across all venue RWA markets. - Physical coverage counts each execution once and excludes all User, MEV, and Buyback parent rows. The recognized virtual venue instead deduplicates User token perspectives by txHash and operationIndex. - priceUsd and volume fields are based on indexer-supplied ui_trades_v2 row values; Graph does not recalculate them from trade legs. - The response is cached briefly in the API process; default cache is 15 seconds unless POOL_STATS_CACHE_SECONDS overrides it. - Use poolTransactions when the user asks for individual trades or transaction hashes. - Use solana.pool.pools when the user asks for physical pool identity, TVL, side liquidity, inception, graduation, or mints. 'Ondo RWA' has no corresponding pool row. #### Example ```graphql query PoolStats($poolAddress: String!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { poolStats(poolAddress: $poolAddress, explorer: $explorer) { poolAddress poolExplorerUrl periodEnd priceUsd volumeUsd5m volumeUsd1h volumeUsd6h volumeUsd24h priceChange5mPercent priceChange1hPercent priceChange6hPercent priceChange24hPercent txnCount24h activeWalletCount24h buyCount24h sellCount24h } } } } ``` Variables: ```json { "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2", "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_pool_stats?poolAddress=58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2&explorer=SOLSCAN) ### `get_dex_pool_liquidity_stats` - **Map operation:** `getDexPoolLiquidityStats` - **Title:** `Get liquidity and activity stats for pools` - **Kind:** `query` - **GraphQL path:** `solana.dex.poolLiquidityStats` Batch trailing-24h liquidity-provider and deduplicated trade metrics for explicit physical pool addresses. The recognized virtual venue 'Ondo RWA' returns venue-wide trade metrics but zero liquidity-provider fields because it has no vaults or liquidity events. Dysfunctional and unknown pools preserve input cardinality and return zero-valued stats. Physical pool trade totals count executions once; distinct-wallet counts exclude unknown execution wallets and do not add enclosing route initiators. **Data dictionary:** `solana-pool-liquidity-stats` (fact; One measured trailing-24h aggregate per requested normalized pool address and periodEnd.) **Related topics:** `pool liquidity stats`, `liquidity providers`, `pool holder change`, `pool liquidity change`, `pool transaction count`, `pool active wallets` #### Use When - The user has pool addresses and needs comparable trailing-24h liquidity-provider and trading activity metrics. - A pool list needs holder change, liquidity change, transaction count, volume, or active-wallet columns. - The client needs one batched operation rather than calling poolStats once per pool. #### Arguments ##### `poolAddresses` - **GraphQL type:** `[String!]!` - **Required:** `true` Physical pool addresses or the exact recognized virtual venue 'Ondo RWA'. Duplicates and blanks are removed; output follows normalized first-occurrence input order. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build poolExplorerUrl. #### Default Selection ```graphql poolAddress poolExplorerUrl periodEnd baseTokenHolders holdersChange24hPercent liquidityChange24hPercent txnCount24h buyCount24h sellCount24h volumeUsd24h activeWalletCount24h ``` #### Caveats - baseTokenHolders counts wallets with positive net add-minus-remove base-token liquidity; it is not the token holder count. - Liquidity and holder percentages compare current net event-derived state with the state at the trailing-24h boundary. - Physical trade metrics use the same deduplicated base-token predicate as poolTransactions. 'Ondo RWA' uses its virtual-venue User-operation deduplication. - For 'Ondo RWA', baseTokenHolders, holdersChange24hPercent, and liquidityChange24hPercent are zero because no physical pool legs or liquidity events exist; transaction, buy/sell, volume, and active-wallet fields are populated. - Dysfunctional and unknown pools return zero stats and are not proof of zero on-chain liquidity. - Use list_pools for current physical vault balances, pair identity, TVL, program, or lifecycle fields. It intentionally returns no row for 'Ondo RWA'. #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for batched pool liquidity and activity stats.", "additionalProperties": true } ``` #### Example ```graphql query PoolLiquidityStats($poolAddresses: [String!]!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { dex { poolLiquidityStats(poolAddresses: $poolAddresses, explorer: $explorer) { poolAddress poolExplorerUrl periodEnd baseTokenHolders holdersChange24hPercent liquidityChange24hPercent txnCount24h buyCount24h sellCount24h volumeUsd24h activeWalletCount24h } } } } ``` Variables: ```json { "poolAddresses": [ "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2" ], "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_dex_pool_liquidity_stats?poolAddresses=58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2&explorer=SOLSCAN) ### `list_pools` - **Map operation:** `listPools` - **Title:** `List Solana pools` - **Kind:** `query` - **GraphQL path:** `solana.pool.pools` Read Solana pool market rows by address, participant mint selection, graduation filters, lifecycle windows, and ordering. One mint matches either pool side, two mints match that exact canonical pair, and 3-100 mints match pools containing any supplied mint. Stored pool-leg order is returned by default. Set preferQuoteAssets=true to present an exact-mint known stablecoin, wrapped SOL, or NativeSOL as quote when only one side qualifies. For trade venue resolution, query by trade.poolAddress and read programId/programName; pass programId to get_program for reviewed exchange attributes. For backing pools, liquidity pools, paired pools, or where token liquidity sits, query solana.pool.pools(mints: [tokenMint]) and interpret results as indexed DEX pools where the token is baseMint or quoteMint. It cannot route swaps, inspect arbitrary pool programs, prove reserves, report holders, report LP ownership, or describe treasury/off-chain backing. **Data dictionary:** `solana-pool-current` (entity; One latest logical row per pool address and canonical stored mint pair; preferQuoteAssets can reverse the returned base/quote presentation without changing pool identity.), `solana-exchange-program` (entity; One reviewed row per Solana program id.), `solana-token-account-holding-current` (entity; One latest row per token account and mint.) **Related topics:** `graduation`, `graduated`, `graduated pools`, `recent graduated pools`, `how long did it take to graduate`, `PumpSwap`, `backing pools`, `liquidity pools`, `pools for token`, `paired pools`, `pairs backing token`, `where liquidity sits`, `pool pairs`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue`, `dex program` #### Use When - The user asks for liquidity pools for a token or mint pair. - The user asks for backing pools, paired pools, pools backing token X, or where token liquidity sits. - The user asks for recent graduated pools. - The user asks for pool liquidity, vaults, program metadata, or normalized pool TVL. - The user asks when a pool graduated or asks how long a token took to graduate. - The user has a human token name or symbol that was resolved to a mint with tokenSearch. - The user has a trade poolAddress and asks which exchange or DEX venue executed it. #### Arguments ##### `poolAddresses` - **GraphQL type:** `[String!]` Optional pool addresses. Omit poolAddresses, mints, and filter to page all pools. ##### `mints` - **GraphQL type:** `[String!]` Optional participant mints, capped at 100 distinct values. One mint matches either side, two mints match that exact canonical pair, and 3-100 mints match pools containing any supplied mint. For backing pools or pools for token X, pass the resolved token mint as a one-element array. ##### `filter` - **GraphQL type:** `SolanaPoolFilterInput` ###### Input Fields ```json { "graduated": "Boolean", "inceptionFrom": "DateTime", "inceptionTo": "DateTime", "graduationFrom": "DateTime", "graduationTo": "DateTime" } ``` ##### `orderBy` - **GraphQL type:** `SolanaPoolOrderInput` ###### Input Fields ```json { "field": [ "INCEPTION_AT", "GRADUATION_AT", "POOL_ADDRESS", "BASE_MINT", "QUOTE_MINT" ], "direction": [ "ASC", "DESC" ] } ``` ##### `includeDysfunctional` - **GraphQL type:** `Boolean` - **Default:** `false` ##### `preferQuoteAssets` - **GraphQL type:** `Boolean` - **Default:** `false` When true, use exact mint identifiers to present a known stablecoin, wrapped SOL, or NativeSOL as the quote leg when exactly one side qualifies. The complete mint, vault, liquidity, and graduation leg is swapped. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `10` - **Maximum:** `10000` ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust each pool leg's priceUsd and currentHoldings to current Token-2022 display units. False returns source units; USD liquidity and TVL are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit pool, program, mint, vault, and graduation transaction URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql poolAddress poolExplorerUrl programId programExplorerUrl programName baseMint baseMintExplorerUrl quoteMint quoteMintExplorerUrl baseVault baseVaultExplorerUrl quoteVault quoteVaultExplorerUrl inceptionSlot inceptionBlockExplorerUrl blockSlot blockExplorerUrl lastObservedSlot lastObservedBlockExplorerUrl tvlUsd baseLiquidity { mint mintExplorerUrl vault vaultExplorerUrl currentHoldings priceUsd liquidityUsd } quoteLiquidity { mint mintExplorerUrl vault vaultExplorerUrl currentHoldings priceUsd liquidityUsd } inceptionAt lastObservedAt isDysfunctional graduation { at slot blockExplorerUrl txHash txExplorerUrl fromPoolAddress fromPoolExplorerUrl fromProgramId fromProgramExplorerUrl fromBaseMint fromBaseMintExplorerUrl fromQuoteMint fromQuoteMintExplorerUrl } ``` #### MCP Note Use list_pools for pool identity, liquidity, lifecycle, and venue metadata. If a returned graduation object includes txHash, call get_transactions only when transaction-level fee, compute, tip, activity-count, or program-interaction context is needed. #### Caveats - Pool leg orientation is opt-in. By default, canonical stored base/quote order is retained. With preferQuoteAssets=true, exact mint identifiers are used, never tokenSymbol or tokenName: if exactly one leg is in dict_known_stablecoins or is wrapped SOL/NativeSOL, that complete leg is returned as quote; if both or neither qualify, stored order is retained. - anchoredLiquidityUsd is canonical indexed pool liquidity; tvlUsd is its compatibility alias. Selecting only these totals does not load holdings or token prices. Per-leg liquidityUsd uses canonical reserves and current token prices. - baseLiquidity.currentHoldings and quoteLiquidity.currentHoldings are paired with display-unit priceUsd by default; set adjustForUiMultiplier=false for source token units. Per-leg liquidityUsd stays in USD; anchoredLiquidityUsd and tvlUsd retain the canonical indexed USD value. - tvlUsd aliases anchoredLiquidityUsd and stays null when canonical liquidity is unknown. baseLiquidityUsd and quoteLiquidityUsd are aliases of baseLiquidity.liquidityUsd and quoteLiquidity.liquidityUsd for side-level inspection. - Backing pools means indexed DEX liquidity pools where the requested token is baseMint or quoteMint. It does not mean reserves, holders, LP ownership, treasury backing, or off-chain backing. - For a human token name/symbol like chatoshi, first resolve with tokenSearch(query), pick the best symbol/name match, then call pools(mints: [resolvedMint], includeDysfunctional: false). - For readable pair labels, collect the opposite-side mints from baseMint/quoteMint and call solana.tokens(mints: uniqueOtherMints) to fetch counterpart tokenSymbol/tokenName. - For trade venue resolution, query poolAddresses: [trade.poolAddress]. programId is the canonical pool venue program id, programName is its resolved dictionary label, and get_program(programId) returns reviewed attributes. - Do not use a trade's aggregatorProgram as the pool venue; it identifies router/aggregator context when present. - For Solana token pools, liquidity pools, backing pools, paired pools, or where token liquidity sits, use this GraphQL operation rather than web search. - Use includeDysfunctional: true only when investigating stale or invalid pool identities. - For how long did it take to graduate, use graduation.at from this pool result as the graduation timestamp, then query list_tokens/list_tokens_ext for the graduated token mint and subtract token.firstSeenAt. Do not use PumpSwap pool inceptionAt as token launch time. - When graduation.txHash is selected, pass returned signatures to get_transactions in batches for transaction-level fee/resource/program enrichment. - graduation.txExplorerUrl is paired with graduation.txHash. Pool, program, mint, vault, and block-slot links use their own explicit *ExplorerUrl fields. #### Example ```graphql query RecentGraduatedPools($filter: SolanaPoolFilterInput, $orderBy: SolanaPoolOrderInput, $preferQuoteAssets: Boolean = false, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { pool { pools(filter: $filter, orderBy: $orderBy, preferQuoteAssets: $preferQuoteAssets, limit: $limit, explorer: $explorer) { poolAddress poolExplorerUrl programId programExplorerUrl programName baseMint baseMintExplorerUrl quoteMint quoteMintExplorerUrl inceptionSlot inceptionBlockExplorerUrl inceptionAt blockSlot blockExplorerUrl lastObservedSlot lastObservedBlockExplorerUrl graduation { at slot blockExplorerUrl txHash txExplorerUrl fromPoolAddress fromPoolExplorerUrl } tvlUsd isDysfunctional } } } } ``` Variables: ```json { "filter": { "graduated": true }, "orderBy": { "field": "GRADUATION_AT", "direction": "DESC" }, "preferQuoteAssets": false, "limit": 50, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_pools?filterGraduated=true&orderByField=GRADUATION_AT&orderByDirection=DESC&preferQuoteAssets=false&limit=50&explorer=SOLSCAN) ### `get_program` - **Map operation:** `getProgram` - **Title:** `Get a Solana program` - **Kind:** `query` - **GraphQL path:** `solana.metadata.program` Read metadata for one known Solana exchange program id from the reviewed program dictionary. For a physical pool trade, resolve trade.poolAddress with list_pools and pass the returned pool.programId here. The virtual 'Ondo RWA' venue has no physical pool program row. Do not substitute trade.aggregatorProgram, which identifies router context rather than the physical pool venue. **Data dictionary:** `solana-exchange-program` (entity; One reviewed row per Solana program id.) **Related topics:** `metadata`, `program dictionary`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue`, `dex program`, `pool program`, `aggregator vs exchange` #### Use When - The user asks for reviewed behavior attributes of a known exchange program id. - list_pools returned programId for a trade pool and the user asks which DEX or exchange executed it. - The user needs to distinguish the pool venue program from an aggregator or router program. #### Arguments ##### `programId` - **GraphQL type:** `String!` - **Required:** `true` Pool venue program id, normally read from list_pools.programId. Do not pass trade.aggregatorProgram as a substitute. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build programExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql programId programExplorerUrl name logoUrl known expectedTokenAccounts usesNativeSol nativeSolVaultIsPoolAddress allowsMultiVaultPoolIdentity allowsOneSidedLiquidityProvision usesSharedVaultAccounts ``` #### Caveats - This dictionary describes reviewed pool exchange programs; it does not infer a venue directly from a transaction signature. - For a physical pool trade, resolve poolAddress through list_pools first and use the returned programId. The virtual 'Ondo RWA' label does not resolve this way. - aggregatorProgram is router/aggregator context and is not interchangeable with pool.programId. - logoUrl is nullable before an image publication is available or when disabled. Unavailable refreshes retain prior logo availability, and image read failures do not remove program metadata. Image publications do not add entries to the unfiltered program registry. #### Example ```graphql query Program($programId: String!, $explorer: SolanaExplorerKind = SOLSCAN) { solana { metadata { program(programId: $programId, explorer: $explorer) { programId programExplorerUrl name logoUrl known expectedTokenAccounts usesNativeSol nativeSolVaultIsPoolAddress allowsMultiVaultPoolIdentity allowsOneSidedLiquidityProvision usesSharedVaultAccounts } } } } ``` Variables: ```json { "programId": "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA", "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_program?programId=pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA&explorer=SOLSCAN) ### `list_programs` - **Map operation:** `listPrograms` - **Title:** `List Solana programs` - **Kind:** `query` - **GraphQL path:** `solana.metadata.programs` Read known Solana exchange programs with reviewed behavior attributes from the metadata dictionary. Use pool.programId values returned by list_pools as lookup keys; trade.aggregatorProgram is not the pool venue. **Data dictionary:** `solana-exchange-program` (entity; One reviewed row per Solana program id.) **Related topics:** `metadata`, `program dictionary`, `exchange programs`, `dex programs`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue` #### Arguments ##### `programIds` - **GraphQL type:** `[String!]` Optional program ids. Omit to page through known exchange programs. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` ##### `limit` - **GraphQL type:** `Int` - **Default:** `50` - **Maximum:** `500` ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build programExplorerUrl for each program. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql programId programExplorerUrl name logoUrl known expectedTokenAccounts usesNativeSol nativeSolVaultIsPoolAddress allowsMultiVaultPoolIdentity allowsOneSidedLiquidityProvision usesSharedVaultAccounts ``` #### Caveats - For trade venue resolution, get the pool programId from list_pools(poolAddresses: [trade.poolAddress]); do not use aggregatorProgram as a substitute. - logoUrl is nullable before an image publication is available or when disabled. Unavailable refreshes retain prior logo availability, and image read failures do not remove program metadata. Image publications do not add entries to the unfiltered program registry. #### Example ```graphql query Programs($limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { metadata { programs(limit: $limit, explorer: $explorer) { programId programExplorerUrl name logoUrl known usesNativeSol nativeSolVaultIsPoolAddress allowsOneSidedLiquidityProvision } } } } ``` Variables: ```json { "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_programs?limit=100&explorer=SOLSCAN) ### `getWalletHoldingsExt` - **Title:** `Browse historical wallet holdings` - **Kind:** `query` - **GraphQL path:** `solana.wallet.holdingsExt` Read historical source-unit wallet holdings as time buckets and/or a whole-period summary. Account breakdown, indexed DeFi flows, historical prices and cash-flow-adjusted performance are optional. No RPC recovery. Local minute-cache coverage falls back to canonical data. **Data dictionary:** `solana-wallet-portfolio-history` (fact; One wallet and observation boundary for a requested interval and method version.) **Related topics:** `historical holdings`, `portfolio balances`, `minute holdings`, `wallet performance` #### Use When - Browse holdings over time or obtain opening/closing balances and flow summaries without loading transactions. #### Arguments ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Solana wallet address. ##### `period` - **GraphQL type:** `SolanaWalletActivityPeriodInput` - **Required:** `false` Inclusive opening and exclusive event-end UTC minute boundaries, up to 90 days. Omitted: trailing UTC day. ###### Input Fields ```json { "from": "DateTime!", "to": "DateTime!" } ``` ##### `interval` - **GraphQL type:** `WalletHoldingsInterval` - **Default:** `ONE_HOUR` ONE_MINUTE, FIVE_MINUTES, FIFTEEN_MINUTES, ONE_HOUR, FOUR_HOURS or ONE_DAY. At most 2000 buckets; summary-only reads are independent of this bucket limit. #### Default Selection ```graphql wallet from to interval asOf complete issues coverage { indexedFromAt indexedThroughAt isComplete } summary { from to tokens { mint openingAmount closingAmount changeAmount } } ``` #### Caveats - Amounts use source units. NativeSOL and wrapped SOL remain distinct. Unknown balances are null, never silently zero. - Select buckets for the series and summary for whole-period totals. Selecting only summary skips series generation. tokens.accounts is optional. - DeFi flow amounts are indexed acquisition/disposal totals, not external cash flows, profit or cost basis. Stored USD notionals may contain zero for missing source prices. - Prices use FAIR_PRICE+LAST_CLOSE or MISSING_SOURCE+DEFAULT_TO_ZERO. Numeric valuation estimates can be incomplete; inspect completeness flags. - Selecting performance.netFlowUsd or pnlUsd reads classified transfers with the existing 10000-row limit and net incoming amounts. ACTIVITY_LIMIT makes dependent totals null. No trade-detail query is needed. - Portfolio performance is closing value minus opening value minus net external flows; it is not FIFO realized PnL. Fees already present in balances are not deducted again. - Only indexed accounts are represented. Check asOf, coverage, complete and issues. Native SOL observations currently use the canonical wallet-slot source. - At most 10000 nonzero opening accounts, 50000 grouped changes, 100000 carried account states and 20000 price points. A shorter period or coarser interval reduces observations but does not reduce the opening account count. #### Output Schema ```json { "type": "object", "additionalProperties": true } ``` #### Example ```graphql query WalletHoldings($wallet: String!, $period: SolanaWalletActivityPeriodInput) { solana { wallet { holdingsExt(wallet: $wallet, period: $period, interval: ONE_HOUR) { wallet asOf complete issues buckets { from to tokens { mint openingAmount closingAmount changeAmount } } summary { tokens { mint openingAmount closingAmount changeAmount defiFlows { inflowsTokenAmount outflowsTokenAmount inflowsUsd outflowsUsd } } } } } } } ``` Variables: ```json { "wallet": "GkQwqX1pBMVAdaPDLukmKTkb8QdFf99vsGFy9k1J7vG6" } ``` ### `get_wallet_portfolio_history` - **Map operation:** `getWalletPortfolioHistory` - **Title:** `Get indexed wallet portfolio history` - **Kind:** `query` - **GraphQL path:** `solana.wallet.portfolioHistory` Calculate indexed-account USD value and cash-flow-adjusted PnL on demand, reusing the shared holdings balance builders and verified minute cache. Missing prices count as zero with explicit completeness flags and optional per-mint priceSource combining source and methodology. Incoming flows use net received amounts after transfer fees; outgoing flows use gross debits. Unknown balances or transfer amounts remain null. No RPC recovery is started. Not complete on-chain wealth or FIFO realised PnL. **Data dictionary:** `solana-wallet-portfolio-history` (fact; One wallet and observation boundary for a requested interval and method version.) **Related topics:** `portfolio chart`, `wallet value history`, `cash-flow-adjusted PnL` #### Use When - The user needs a historical USD value series for one Solana wallet. #### Arguments ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Solana wallet address. ##### `period` - **GraphQL type:** `SolanaWalletActivityPeriodInput!` - **Required:** `true` Whole-minute UTC boundaries, maximum 90 days. Opening is inclusive; events at the end are excluded. ###### Input Fields ```json { "from": "DateTime!", "to": "DateTime!" } ``` ##### `interval` - **GraphQL type:** `WalletPortfolioInterval` - **Default:** `ONE_HOUR` FIVE_MINUTES, ONE_HOUR or ONE_DAY. Maximum 1000 points and 20000 price lookups. #### Default Selection ```graphql wallet method from to interval asOf complete issues coverage { indexedFromAt indexedThroughAt isComplete } points { at valueUsd pricedValueUsd netFlowUsd pnlUsd valueComplete netFlowComplete pnlComplete unpricedMints unpricedFlowMints } ``` #### Caveats - Complete refers to available indexed evidence only; never-observed accounts, private copy allocations and off-wallet escrow are excluded. - The opening account limit is 10000 nonzero balances. Zero balances do not consume it; tiny nonzero balances still count. Time paging cannot reduce that count. Series are bounded at 100000 mint-observation states and 20000 price lookups. An observed empty wallet remains distinct from an unknown wallet, and subsequent funding or reopening is included. - Missing holding and transfer prices contribute zero with MISSING_PRICE or UNPRICED_FLOW. Check valueComplete, netFlowComplete and pnlComplete on every point; numeric estimates may be incomplete. Unknown balances, incoming net amounts and truncated flows still leave dependent totals null. - Select points.prices { mint mintExplorerUrl priceUsd priceSource priceSourceMinute } for each nonzero known holding. priceSource has two fixed combined source/method values: FAIR_PRICE+LAST_CLOSE and MISSING_SOURCE+DEFAULT_TO_ZERO. The latter means unavailable, not worthless. Source timestamps remain separate. No additional source reads are needed for this selection. - unpricedMints describes this boundary; unpricedFlowMints is cumulative since from. An incomplete opening valuation keeps pnlComplete=false after current prices recover. pricedValueUsd preserves the known subtotal even when native balance evidence is missing. - The source watermark caps the returned period. Missing tail points are not fabricated. - Net flows and PnL are relative to period.from; cached adjacent windows must be rebased and their shared boundary deduplicated. - Method indexed-account-value-net-cashflow-v3 uses net incoming flows, raw native SOL balances including fee-only debits, and labelled zero substitution for missing prices. Include method in persisted-result keys; earlier methods kept totals null for missing prices. - More than 10000 qualifying transfer rows reports ACTIVITY_LIMIT and null flow/PnL. An exactly full page is complete when no lookahead row exists. - UNKNOWN_TRANSFER_NET_AMOUNT means an incoming net amount is missing or invalid. Historical missing fees are not assumed zero. A zero net receipt needs no price. - NATIVE_BALANCE_UNKNOWN means raw native SOL balance evidence is missing. The complete value and affected PnL stay null; pricedValueUsd is only the known subtotal. Historical repairs can change these observations, so refresh cached affected windows. - Native residuals and network fees are exposed separately under activityExt.metadata.slotAccounting; they are not automatically treated as external cash flows or deducted twice. #### Output Schema ```json { "type": "object", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query WalletPortfolioHistory($wallet: String!, $period: SolanaWalletActivityPeriodInput!) { solana { wallet { portfolioHistory(wallet: $wallet, period: $period, interval: ONE_HOUR) { wallet method from to interval asOf complete issues coverage { indexedFromAt indexedThroughAt isComplete } points { at valueUsd pricedValueUsd netFlowUsd pnlUsd valueComplete netFlowComplete pnlComplete unpricedMints unpricedFlowMints prices { mint mintExplorerUrl priceUsd priceSource priceSourceMinute } } } } } } ``` Variables: ```json { "wallet": "GkQwqX1pBMVAdaPDLukmKTkb8QdFf99vsGFy9k1J7vG6", "period": { "from": "2026-09-25T00:00:00Z", "to": "2026-09-26T00:00:00Z" } } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_wallet_portfolio_history?wallet=GkQwqX1pBMVAdaPDLukmKTkb8QdFf99vsGFy9k1J7vG6&periodFrom=2026-09-25T00%3A00%3A00Z&periodTo=2026-09-26T00%3A00%3A00Z) ### `list_wallet_activity_rows` - **Map operation:** `listWalletActivityRows` - **Title:** `List selector-bound Solana wallet activity rows` - **Kind:** `query` - **GraphQL path:** `solana.wallet.activity` Read only the indexed wallet activity transaction array for exactly one UTC period or exact slot. Distinguish walletRelation TRADER from TRANSFER_LINKED: linked rows preserve another indexed trader. Describe a linked incoming output as Received from swap; it does not prove the queried wallet paid for a purchase. Use relatedTransferIndexes and transfer direction to establish wallet spending and receipts. This is the lean compatibility form of list_wallet_activity; prefer list_wallet_activity when current holdings, wallet existence hints, retained coverage, or asynchronous pre-index recovery status are needed. **Data dictionary:** `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-token-transfer` (fact; One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.), `solana-wallet-slot-index` (fact; One replacement observation per wallet address and block slot.) **Related topics:** `wallet activity rows`, `lean wallet history`, `wallet transaction array` #### Use When - The caller explicitly needs only selector-bound indexed activity and does not need current wallet metadata or coverage. - A latency-sensitive client already knows the requested period is inside retained indexed coverage. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional activity token mints (maximum 100). Select transactions matching a wallet transfer mint or direct wallet trade token/otherToken before applying limit. Return all wallet activity in matching transactions, including other tokens. Omitted or empty means all tokens. NativeSOL and wrapped SOL are distinct. Does not filter current holdings or coverage; recovered activity matches its available balance-delta mints. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Required non-empty Solana wallet owner or authority address. ##### `period` - **GraphQL type:** `SolanaWalletActivityPeriodInput` Inclusive/exclusive UTC range. Specify period or slot, never both. ###### Input Fields ```json { "from": "DateTime!", "to": "DateTime!" } ``` ##### `slot` - **GraphQL type:** `Long` Exact Solana slot. Specify slot or period, never both. ##### `direction` - **GraphQL type:** `SortDirection` - **Default:** `DESC` ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Minimum:** `1` - **Maximum:** `10000` Maximum grouped transaction hashes, not activity rows. ##### `includeInnerSwaps` - **GraphQL type:** `Boolean` - **Default:** `false` Include technical Inner and UnresolvedInner route-leg trade rows. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust indexed trade prices and amounts plus transfer token amounts and per-token prices to current Token-2022 UI multipliers. False returns source units; raw amounts and USD notionals are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` #### Default Selection ```graphql source blockSlot blockExplorerUrl blockTime txHash txExplorerUrl trades { userWallet walletRelation relatedTransferIndexes token tokenExplorerUrl side priceUsd amount volumeUsd otherToken otherTokenExplorerUrl poolAddress poolExplorerUrl aggregatorProgram aggregatorProgramExplorerUrl gatewayFees ammFees compoundFees operationIndex tradeLayer } transfers { transferIndex operationIndex transferType intent mint mintExplorerUrl sourceOwner sourceOwnerExplorerUrl destinationOwner destinationOwnerExplorerUrl amount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd isDefiActivity direction } ``` #### Caveats - wallet is required and exactly one of period or slot must be supplied. - This operation omits current holdings, wallet existence hints, retained coverage, and RPC recovery orchestration. Prefer list_wallet_activity for normal agent workflows. - The limit applies to grouped transaction hashes. Page complete high-volume history through overlapping adjacent periods in ASC order and deduplicate by blockSlot plus txHash. - One ordered page of distinct (blockSlot, txHash) keys is selected across wallet trades and transfers before both detail sources are read. The limit applies once to that shared transaction page; all matching wallet activities for selected keys are returned without independent source limits. - Trade rows include the indexed userWallet and transfer-linked swaps only when a full input or output transfer involving the queried wallet matches the mint, amount and trader/pool counterparty within the same indexed swap or router invocation. A shared transaction hash or matching operationIndex alone is insufficient: trade opIndex is logical and is not transfer instructionIndex. CPI ancestry comes from retained dex_swap_executions and program_interactions. Ambiguous or missing evidence leaves the transfer visible without adding an indirect trade. userWallet remains the original indexed trader; walletRelation is TRADER or TRANSFER_LINKED and relatedTransferIndexes identifies the evidence. Transfers remain restricted to the requested wallet. TRANSFER_LINKED means another indexed userWallet executed the swap and a wallet transfer was matched within the same swap/router invocation. Use relatedTransferIndexes to locate that evidence in the transaction transfers array. Label a linked INBOUND output as Received from swap and a linked OUTBOUND input as Sent to swap. Receiving bought tokens does not establish that the queried wallet bought them or spent the route input. For example, if another wallet spends 1 SOL and sends the purchased tokens to the queried wallet inside that route, report the token receipt; do not attribute the 1 SOL spend to the recipient. Trade BUY and SELL rows are token perspectives of the execution, not independent orders or proof that this wallet performed both legs. Derive wallet spending, proceeds, buy/sell counts, cost basis and PnL from its actual transfers and explicit attribution; never assign the full route amounts to it solely because walletRelation is TRANSFER_LINKED. TRADER means the queried wallet equals the indexed userWallet; userWallet is never rewritten to the recipient. #### Input Schema Constraints ```json { "oneOf": [ { "required": [ "period" ], "not": { "required": [ "slot" ] } }, { "required": [ "slot" ], "not": { "required": [ "period" ] } } ] } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for selector-bound wallet activity rows.", "additionalProperties": true } ``` #### Example ```graphql query WalletActivityRows($wallet: String!, $period: SolanaWalletActivityPeriodInput!, $direction: SortDirection, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { wallet { activity(wallet: $wallet, period: $period, direction: $direction, limit: $limit, explorer: $explorer) { source blockSlot blockTime txHash txExplorerUrl trades { userWallet walletRelation relatedTransferIndexes token side amount volumeUsd poolAddress gatewayFees ammFees compoundFees operationIndex tradeLayer } transfers { transferIndex operationIndex intent mint amount direction historicalValueUsd } } } } } ``` ##### Relative Variable Presets ```json { "period.from": "previousUtcDay", "period.to": "startOfCurrentUtcDay" } ``` Variables: ```json { "wallet": "9cHTsW8JM52sSLwabFxMbwztVtzDjrQTggPRHKugMuYe", "period": { "from": "2026-10-24T00:00:00Z", "to": "2026-10-25T00:00:00Z" }, "direction": "DESC", "limit": 100, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_wallet_activity_rows?wallet=9cHTsW8JM52sSLwabFxMbwztVtzDjrQTggPRHKugMuYe&periodFrom=2026-10-24T00%3A00%3A00Z&periodTo=2026-10-25T00%3A00%3A00Z&direction=DESC&limit=100&explorer=SOLSCAN) ### `list_wallet_activity` - **Map operation:** `listWalletActivity` - **Title:** `List Solana wallet activity` - **Kind:** `query` - **GraphQL path:** `solana.wallet.activityExt` Primary history tool for questions about what a Solana wallet did, including buys, sells, transfers, burns, funding paths, exits, fees, and suspicious activity. Distinguish walletRelation TRADER from TRANSFER_LINKED: linked rows preserve another indexed trader. Describe a linked incoming output as Received from swap; it does not prove the queried wallet paid for a purchase. Use relatedTransferIndexes and transfer direction to establish wallet spending and receipts. Query either a UTC time period or one exact Solana slot. Transfer intent identifies the decoded movement mechanism; direction separately describes the movement relative to the queried wallet. metadata.currentHoldings is effective current state. Suggested response: for a question focused on a particular wallet, use walletInvestigationResponse: first seen time, earliest observed funding transaction hash, funding wallet and amount, then all available activity since first seen; start at max(first seen, metadata.coverage.indexedFromAt), set allowRpcFallback=false to prevent backfill, never query earlier dates, and always finish with current holdings using the walletHoldingsResponse format. Discover first seen and indexed coverage with a metadata-only read before querying history; batch holding mints through list_tokens to add token labels and logos. Activity selection alone never starts history recovery. Selected metadata.currentHoldings flow fields use the same recovery as standalone currentHoldings when allowRpcFallback=true. With allowRpcFallback=true, period queries may reuse previously recovered pre-index history. Both holdings entry points require selected flow fields, a balance gap, a verified user-wallet account, and pre-index existence. Account checks are internal and cached. Unknown coverage or eligibility starts no job. allowRpcFallback defaults to true; false reads indexed data only. Batch returned txHash values through get_transactions for indexed fee/resource enrichment. Resolve physical trade.poolAddress values with list_pools; 'Ondo RWA' is a virtual venue and has no physical pool row. **Data dictionary:** `solana-token-current` (entity; One latest logical row per token mint.), `solana-fair-ohlcv-minute` (fact; One replaceable fair candle per token mint and UTC minute.), `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-token-transfer` (fact; One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.), `solana-wallet-slot-index` (fact; One replacement observation per wallet address and block slot.) **Related topics:** `wallet activity`, `wallet transactions`, `wallet trades`, `wallet transfers`, `transaction history`, `tradeVenue`, `exchangeVenue`, `trade venue`, `exchange venue`, `dex program` #### Use When - The user provides a Solana wallet and asks for its indexed or automatically recovered trades, transfers, or transaction history. - The user needs trade and transfer activities grouped under the same transaction signature. - The user asks for wallet activity ordered through a bounded time period or from one exact block slot. - The user asks which exchange or DEX venue executed one of the wallet's trades. #### Suggested Response Template - For a question focused on this wallet, use walletInvestigationResponse: open with its first seen time (metadata.firstTransferToWalletAt), then the earliest observed funding transaction hash, funding wallet, asset, and amount from INBOUND transfer evidence. Discover first seen and metadata.coverage.indexedFromAt with a metadata-only query_graphql read before querying activity; do not derive first seen from remaining holdings. If either boundary is unknown, report the limitation instead of running history queries. If first seen or funding evidence is unavailable, state that instead of inventing it or scanning backward. - For that wallet-focused report, read all available indexed activity from max(first seen, metadata.coverage.indexedFromAt) through the report time in ASC order with allowRpcFallback=false. Never query before the earliest indexed timestamp or first seen, even for overlapping windows or retries, to keep the report inside retained indexed coverage. Do not request historical recovery. Split periods that reach the transaction limit and deduplicate by (blockSlot, txHash); disclose any gap from first seen to indexed coverage and other incomplete coverage. Always finish with current holdings. - Activity: identify the requested period or slot and coverage, then summarize returned transactions in API order grouped by txHash. Keep transfers authoritative for wallet-relative movement and do not double-count repeated trade perspectives. Separate direct TRADER activity from TRANSFER_LINKED context. Label linked incoming output Received from swap and linked outgoing input Sent to swap; do not count another trader's swap as a wallet-funded purchase or sale without supporting wallet transfers. - Current holdings: always place this section at the end. Use metadata.currentHoldings, which is independent from the activity selector, and follow the list_wallet_current_holdings response template. - Batch metadata.currentHoldings mints through list_tokens in groups of at most 100 with limit set to the batch size. Join by mint and render a Markdown table with Logo | Token | Mint | Amount | First activity | Last activity. Use only returned logoUrl values. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional activity token mints (maximum 100). Select transactions matching a wallet transfer mint or direct wallet trade token/otherToken before applying limit. Return all wallet activity in matching transactions, including other tokens. Omitted or empty means all tokens. NativeSOL and wrapped SOL are distinct. Does not filter current holdings or coverage; recovered activity matches its available balance-delta mints. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Base58 Solana wallet owner or authority address whose indexed activity should be returned. ##### `period` - **GraphQL type:** `SolanaWalletActivityPeriodInput` UTC activity window. The start is inclusive and the end is exclusive. Specify period or slot, but not both. ###### Input Fields ```json { "from": "DateTime!", "to": "DateTime!" } ``` ##### `slot` - **GraphQL type:** `Long` - **Minimum:** `0` Exact Solana block slot to inspect. Specify slot or period, but not both. ##### `includeInnerSwaps` - **GraphQL type:** `Boolean` - **Default:** `false` When true, include technical Inner and UnresolvedInner route-leg trade rows. Defaults to false; User, MEV, and Buyback rows remain available without it. ##### `direction` - **GraphQL type:** `SortDirection` - **Default:** `DESC` Transaction ordering. Use ASC when reconstructing positions, balances, or P&L chronologically. Use DESC for latest activity. ###### Accepted Values ```json [ "ASC", "DESC" ] ``` ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Minimum:** `1` - **Maximum:** `10000` Maximum grouped transactions returned after merging trade and transfer sources. All matching activities for every selected transaction are returned. There is no cursor or skip argument; for complete high-volume history, query consecutive smaller periods in ASC order, overlap boundaries slightly, and deduplicate by blockSlot plus txHash. ##### `currentSkip` - **GraphQL type:** `Int` - **Default:** `0` - **Minimum:** `0` Number of interval-independent current holding rows to skip. ##### `currentLimit` - **GraphQL type:** `Int` - **Default:** `10000` - **Minimum:** `1` - **Maximum:** `10000` Maximum interval-independent current holding rows to return in metadata.currentHoldings. ##### `allowRpcFallback` - **GraphQL type:** `Boolean` - **Default:** `true` Allow configured current RPC wallet resolution, recovery triggered by selected metadata.currentHoldings flow fields, and reuse of recovered pre-index history. Set false to return indexed activity and indexed current holdings only. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust activity trade and transfer token amounts and per-token prices to current Token-2022 display units. Defaults to true; false returns decimal-adjusted source amounts and source prices. Raw amounts and USD values are unchanged. metadata.currentHoldings remains in source units in either mode. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, block, token, pool, wallet, program, owner, authority, and token-account URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql metadata { activityRecoveryIncomplete wallet walletExplorerUrl hasCurrentState firstTransferToWalletAt lastTransferToWalletAt updatedAt version coverage { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt } currentHoldings { mint mintExplorerUrl currentHoldings firstTransferToWalletAt lastTransferToWalletAt updatedAt version } } activity { source blockSlot blockExplorerUrl blockTime txHash txExplorerUrl trades { walletRelation relatedTransferIndexes token tokenExplorerUrl side priceUsd amount volumeUsd otherToken otherTokenExplorerUrl poolAddress poolExplorerUrl userWallet userWalletExplorerUrl aggregatorProgram aggregatorProgramExplorerUrl relayerWallet relayerWalletExplorerUrl gatewayFees ammFees compoundFees operationIndex tradeLayer } transfers { transferIndex operationIndex tokenProgramId tokenProgramExplorerUrl transferType intent authority authorityExplorerUrl mint mintExplorerUrl sourceOwner sourceOwnerExplorerUrl destinationOwner destinationOwnerExplorerUrl sourceAccount sourceAccountExplorerUrl destinationAccount destinationAccountExplorerUrl amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd isDefiActivity direction } } ``` #### MCP Note For one known Solana block, call list_wallet_activity with wallet and slot only. For a range, call it with wallet and period only. Never send both selectors. metadata remains interval-independent and metadata.coverage explains the retained wallet-history boundary. allowRpcFallback defaults to true; set it false only when indexed-only results are required. Activity reads reuse recovered history. Selecting metadata.currentHoldings flow fields with allowRpcFallback=true can also trigger the same recovery as standalone currentHoldings, independently of the activity period or slot. Inspect metadata.activityRecoveryIncomplete and do not treat missing history as proof that no older on-chain activity exists. Recovered balance-delta rows may lack current valuations. Use transfer intent for the decoded movement mechanism and direction for wallet-relative flow. Use historicalValueUsd for event-time value and currentValueUsd only for current mark-to-market. Batch returned txHash values through get_transactions for fee/resource/program enrichment. Optional metadata.slotAccounting is selector-bound native accounting; currentHoldings remains interval-independent. It is omitted from the default selection to avoid unused reads. #### Caveats - The query reads wallet_slot_index_v2 using the local canonical timestamp lookup, then reads trade and transfer transaction keys. Missing timestamp coverage returns SLOT_TIME_CONVERSION_UNAVAILABLE; there is no v1 fallback. - metadata is independent from period or slot. It reads token_holders_current_v2 remotely by wallet and can remain populated when activity is empty. - metadata.firstTransferToWalletAt is the earliest indexed transfer boundary in current state, not proof of the wallet account's on-chain creation time. - Activity-only selections never create history jobs. Selected metadata.currentHoldings flow fields use the same recovery path as standalone currentHoldings, including eligibility, reconciliation, and job reuse. This holdings recovery is independent of the activity period or slot. - For a period extending before indexed coverage, allowRpcFallback=true reuses existing recovered history if available. Covered periods and exact-slot reads remain indexed-only for activity. - Account validation and creation/existence probes run only for selected currentHoldings flow fields, whether standalone or nested here. allowRpcFallback=false prevents nested recovery and account probes. - Reused recovered history is filtered to [period.from, min(period.to, indexedFromAt)). Unavailable or partial history leaves activityRecoveryIncomplete true; it does not create a job. No account-data fields are exposed in metadata. - allowRpcFallback defaults to true. Set it false when an indexed-only response is required; no RPC wallet resolution or historical recovery is then requested. - metadata.activityRecoveryIncomplete is true when a requested pre-index period lacks complete recovered history. Retrying helps only while a holdings-triggered job is progressing. False does not assert complete pre-index history when allowRpcFallback=false. - Nested metadata.currentHoldings shares lifetime flow recovery with standalone currentHoldings. Selecting any defiInflowsTokenAmount, defiOutflowsTokenAmount, defiInflowsUsd, defiOutflowsUsd, or hasUnvaluedHistoricalFlow can trigger recovery after eligibility checks. These fields are omitted from the default list_wallet_activity selection; add them to request flow recovery. Balances-only holdings never start history jobs. Until recovery completes and reconciles, indexed flow totals remain flagged as incomplete. - wallet must be non-empty, and exactly one of period or slot must be supplied. Supplying both or neither returns BAD_USER_INPUT. - A returned transaction can contain trades, transfers, or both. - includeInnerSwaps defaults to false and excludes trade_layer Inner and UnresolvedInner rows. Set it true for technical route-leg evidence; User, MEV, and Buyback rows are not filtered by this flag. - operationIndex aliases trade opIndex or transfer instructionIndex; these are different coordinate systems and cannot establish an association. Use walletRelation and relatedTransferIndexes for proven transfer-linked swaps. - Transfer activity matches source_owner, destination_owner, or authority. direction explains how the transfer relates to the queried wallet; intent independently describes the decoded movement mechanism. Historical unreplayed and RPC balance-delta rows use unknown. - Use transfer directions and amounts for transfer-derived wallet flow; amount is gross and netReceivedAmount is the known recipient amount after transfer fees. Summed trade volumeUsd can duplicate swap perspectives. Neither transfer flow alone nor net receipts are a complete wallet balance ledger. - Transfer historical-price fields read the full-retention local fair-close cache first and fall back to remote fair OHLCV on cache misses. currentPriceUsd/currentValueUsd read the locally cached current token_stats projection in one mint batch and fall back to remote token_stats only for missing rows. - To identify the exchange venue for a trade, call list_pools(poolAddresses: [trade.poolAddress], limit: 1), read programId/programName, and optionally call get_program with programId. - aggregatorProgram identifies an aggregator or router when known; it is not the pool exchange venue and must not be passed to get_program in place of pool.programId. - There is no cursor or skip argument. For complete high-volume history, query consecutive smaller periods in ASC order, overlap period boundaries slightly, and deduplicate by (blockSlot, txHash). - This wallet query does not expose network fees, priority fees, tips, compute, or program interactions. Batch returned txHash values through get_transactions for those indexed transaction-level fields. - Neither wallet activity nor get_transactions is an arbitrary RPC decoder. Native-SOL-only movement transactions are eligible for get_transactions enrichment, but it does not embed native SOL movement source/destination/amount fields. Execution status/error is not currently exposed. - The unit toggle applies to activity trades and transfers, including recovered activity, but not to metadata.currentHoldings or its lifetime token-flow totals. Use consistent units when reconciling activity with holdings. - One ordered page of distinct (blockSlot, txHash) keys is selected across wallet trades and transfers before both detail sources are read. The limit applies once to that shared transaction page; all matching wallet activities for selected keys are returned without independent source limits. - Trade rows include the indexed userWallet and transfer-linked swaps only when a full input or output transfer involving the queried wallet matches the mint, amount and trader/pool counterparty within the same indexed swap or router invocation. A shared transaction hash or matching operationIndex alone is insufficient: trade opIndex is logical and is not transfer instructionIndex. CPI ancestry comes from retained dex_swap_executions and program_interactions. Ambiguous or missing evidence leaves the transfer visible without adding an indirect trade. userWallet remains the original indexed trader; walletRelation is TRADER or TRANSFER_LINKED and relatedTransferIndexes identifies the evidence. Transfers remain restricted to the requested wallet. TRANSFER_LINKED means another indexed userWallet executed the swap and a wallet transfer was matched within the same swap/router invocation. Use relatedTransferIndexes to locate that evidence in the transaction transfers array. Label a linked INBOUND output as Received from swap and a linked OUTBOUND input as Sent to swap. Receiving bought tokens does not establish that the queried wallet bought them or spent the route input. For example, if another wallet spends 1 SOL and sends the purchased tokens to the queried wallet inside that route, report the token receipt; do not attribute the 1 SOL spend to the recipient. Trade BUY and SELL rows are token perspectives of the execution, not independent orders or proof that this wallet performed both legs. Derive wallet spending, proceeds, buy/sell counts, cost basis and PnL from its actual transfers and explicit attribution; never assign the full route amounts to it solely because walletRelation is TRANSFER_LINKED. TRADER means the queried wallet equals the indexed userWallet; userWallet is never rewritten to the recipient. - Transfer amount/rawAmount and USD values retain gross semantics. transferFeeAmount and netReceivedAmount use the same UI multiplier as amount; transferFeeRawAmount is unchanged. Missing fees, including historical and RPC recovery rows, do not imply zero and leave netReceivedAmount null. Explicit zero fees preserve the gross amount. Portfolio-history incoming flows use netReceivedAmount; these activity USD fields remain gross. - Select metadata.slotAccounting { complete hasMore issues slots { blockSlot blockExplorerUrl blockTime solResidualDeltaLamports networkFeeLamports complete } } for native accounting. This optional field follows period or slot and independently uses direction/limit. Mint filters and transaction pagination do not apply; fee-only slots can appear while activity is empty. - Amounts are exact raw-lamport strings. networkFeeLamports is already included in solResidualDeltaLamports; never subtract both. Null means unknown. Page completeness applies to returned indexed slots, not complete historical fee-only coverage. Empty evidence is incomplete. #### Structured Result Metadata ```json { "collectionPath": "data.solana.wallet.activityExt.activity", "limitArgument": "limit", "countProperty": "transactionCount", "selectorArguments": [ "period", "slot" ] } ``` #### Input Schema Constraints ```json { "oneOf": [ { "required": [ "period" ], "not": { "required": [ "slot" ] } }, { "required": [ "slot" ], "not": { "required": [ "period" ] } } ] } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for indexed wallet activity.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "solana": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "wallet": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "activityExt": { "type": [ "object", "null" ], "description": "Extended result with interval-independent current metadata and selector-bound activity.", "additionalProperties": true, "properties": { "metadata": { "type": "object", "additionalProperties": true, "properties": { "wallet": { "type": "string" }, "walletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "hasCurrentState": { "type": "boolean" }, "firstTransferToWalletAt": { "type": [ "string", "null" ], "format": "date-time" }, "lastTransferToWalletAt": { "type": [ "string", "null" ], "format": "date-time" }, "updatedAt": { "type": [ "string", "null" ], "format": "date-time" }, "version": { "type": [ "string", "null" ] }, "activityRecoveryIncomplete": { "type": "boolean", "description": "True when requested historical RPC recovery is unavailable, pending, truncated, or otherwise incomplete." }, "currentHoldings": { "type": "array", "description": "Non-zero effective holdings merged from indexed state and an instance-local RPC baseline when required, independent from the activity selector.", "items": { "type": "object", "additionalProperties": true } }, "coverage": { "type": "object", "additionalProperties": true, "properties": { "dataset": { "type": "string" }, "indexedFromSlot": { "type": [ "string", "null" ] }, "indexedFromAt": { "type": [ "string", "null" ], "format": "date-time" }, "indexedThroughSlot": { "type": [ "string", "null" ] }, "indexedThroughAt": { "type": [ "string", "null" ], "format": "date-time" }, "measuredAt": { "type": "string", "format": "date-time" } } } } }, "activity": { "type": [ "array", "null" ], "description": "Transactions ordered as requested. source is INDEXED for normal rows and RPC_BALANCE_DELTA for automatically recovered wallet balance changes in the requested slice before indexed coverage.", "items": { "type": "object", "additionalProperties": true, "properties": { "source": { "type": "string", "enum": [ "INDEXED", "RPC_BALANCE_DELTA" ], "description": "Origin and semantic fidelity of this transaction. RPC balance-delta rows do not provide indexed DEX trade or instruction attribution." }, "blockSlot": { "type": "string", "description": "Solana slot containing the transaction, represented as a string to preserve UInt64 precision." }, "blockTime": { "type": "string", "format": "date-time", "description": "Indexed transaction time in UTC." }, "txHash": { "type": "string", "description": "Solana transaction signature. Use this as the transaction identity when grouping or deduplicating activity." }, "txExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public transaction URL paired with txHash." }, "blockExplorerUrl": { "type": [ "string", "null" ], "format": "uri", "description": "Derived public block URL paired with blockSlot." }, "trades": { "type": "array", "description": "DEX execution views associated with the transaction. Do not sum these rows as wallet cash flow or P&L because one swap may be represented from both token perspectives or at multiple opIndex values.", "items": { "type": "object", "additionalProperties": true, "properties": { "token": { "type": "string", "description": "Mint used as this trade row's token perspective." }, "tokenExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "side": { "type": "string", "enum": [ "UNKNOWN", "BUY", "SELL" ], "description": "BUY or SELL relative to token, not necessarily the transaction's only economic perspective." }, "priceUsd": { "type": "number", "description": "Indexed execution price for token in USD." }, "amount": { "type": "number", "description": "Trade amount in token units for this row's token perspective." }, "volumeUsd": { "type": "number", "description": "USD execution context for this trade view. Do not sum trade volumeUsd rows to derive wallet cash flow." }, "otherToken": { "type": "string", "description": "Counterpart mint for this trade view." }, "otherTokenExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "otherTokenAmount": { "type": "number", "description": "Counterpart token amount for this trade view." }, "poolAddress": { "type": [ "string", "null" ], "description": "Physical pool address or indexed virtual venue label. Resolve physical values with list_pools; the exact value 'Ondo RWA' has no physical pool row or legs." }, "poolExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "userWallet": { "type": "string", "description": "Original indexed trader. A transfer-linked swap may have a different trader from the requested wallet." }, "userWalletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "aggregatorProgram": { "type": [ "string", "null" ], "description": "Aggregator or router program when identified. This is not a physical DEX venue id. Resolve physical poolAddress values with list_pools; 'Ondo RWA' is virtual and has no pool program row." }, "aggregatorProgramExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "relayerWallet": { "type": [ "string", "null" ], "description": "Relayer wallet when identified." }, "relayerWalletExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "gatewayFees": { "type": [ "number", "null" ], "description": "Attributed gateway or aggregator fee ratio, or null when unknown." }, "ammFees": { "type": [ "number", "null" ], "description": "Attributed AMM fee ratio, or null when unknown." }, "compoundFees": { "type": "number", "description": "Compatibility total of gatewayFees and ammFees, treating missing components as zero." }, "opIndex": { "type": "integer", "description": "Operation index inside the transaction. Multiple trade perspectives can share or span operation indexes." }, "operationIndex": { "type": "integer", "description": "Common logical operation index. For trade rows this is the ui_trades_v2 op_index value." }, "tradeLayer": { "type": "string", "description": "Indexer trade-layer classification." }, "baselinePriceUsd": { "type": [ "number", "null" ], "description": "Reference baseline price in USD when available." }, "potentialSlippage": { "type": "number", "description": "Indexed potential-slippage estimate." }, "poolPriceConfidence": { "type": "number", "description": "Indexed pool-price confidence value." }, "walletRelation": { "type": "string", "enum": [ "TRADER", "TRANSFER_LINKED" ], "description": "TRADER: the requested wallet is the indexed userWallet. TRANSFER_LINKED: another trader executed a swap linked to this wallet through a transfer in the same invocation. Receiving its output does not establish a purchase paid for by this wallet; label it Received from swap." }, "relatedTransferIndexes": { "type": "array", "items": { "type": "integer" }, "description": "transferIndex values identifying evidence rows in this transaction's transfers array, not array positions. They prove the same-invocation association. Inspect their direction and mint to distinguish Received from swap from Sent to swap. Empty for direct trader rows." } } } }, "transfers": { "type": "array", "description": "Token movements involving or authorized by the queried wallet. These rows are authoritative for amounts entering or leaving the wallet; retain non-DeFi, burn, fee, and small third-party rows when reconstructing behavior.", "items": { "type": "object", "additionalProperties": true, "properties": { "transactionIndex": { "type": "integer", "description": "Transaction index within the Solana block." }, "transferIndex": { "type": "integer", "description": "Stable transfer ordering within the transaction." }, "instructionIndex": { "type": "integer", "description": "Outer instruction index associated with the transfer." }, "operationIndex": { "type": "integer", "description": "Common logical operation index. For transfer rows this is the outer instructionIndex value." }, "innerInstructionIndex": { "type": "integer", "description": "Inner instruction index associated with the transfer." }, "tokenProgramId": { "type": "string", "description": "Token program that executed the transfer." }, "tokenProgramExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "transferType": { "type": "string", "description": "Indexed transfer classification, including ordinary transfers or burns." }, "intent": { "type": "string", "description": "Instruction-derived transfer mechanism from token_transfers.transfer_intent. It is independent from wallet-relative direction and does not infer business purpose. Historical unreplayed and RPC balance-delta rows use unknown." }, "authority": { "type": "string", "description": "Authority that authorized the transfer when indexed." }, "authorityExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "sourceOwner": { "type": "string", "description": "Owner of the source token account." }, "sourceOwnerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "destinationOwner": { "type": "string", "description": "Owner of the destination token account." }, "destinationOwnerExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "mint": { "type": "string", "description": "Transferred token mint. NativeSOL and wrapped SOL are distinct assets." }, "mintExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "sourceAccount": { "type": "string", "description": "Source token account." }, "sourceAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "destinationAccount": { "type": "string", "description": "Destination token account." }, "destinationAccountExplorerUrl": { "type": [ "string", "null" ], "format": "uri" }, "rawAmount": { "type": "string", "description": "Exact raw integer token amount represented as a string." }, "decimals": { "type": "integer", "description": "Mint decimals used to derive amount." }, "amount": { "type": "number", "description": "Gross indexed transfer amount before transfer fees, in current Token-2022 display units by default. rawAmount stays in source integer units. netReceivedAmount describes the recipient amount; neither is a signed wallet balance delta. RPC balance-delta recovery rows retain their existing balance-change amount and have null fee/net fields." }, "historicalPriceUsd": { "type": [ "number", "null" ], "description": "Last retained fair close at or before the transaction block minute, read from the local historical cache with remote fallback." }, "historicalPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time", "description": "Fair OHLCV minute that supplied historicalPriceUsd." }, "historicalValueUsd": { "type": [ "number", "null" ], "description": "Unsigned amount multiplied by historicalPriceUsd. Apply direction for signed external wallet flow." }, "currentPriceUsd": { "type": [ "number", "null" ], "description": "Current token_stats price at query time." }, "currentPriceSourceMinute": { "type": [ "string", "null" ], "format": "date-time", "description": "Fair-price source minute associated with currentPriceUsd." }, "currentValueUsd": { "type": [ "number", "null" ], "description": "Unsigned amount multiplied by currentPriceUsd; this is present-day mark-to-market, not event-time value." }, "isDefiActivity": { "type": "boolean", "description": "Indexer DeFi classification. False does not mean irrelevant; the transfer may be funding, cleanup, tax, router fee, referral fee, or another wallet movement." }, "direction": { "type": "string", "enum": [ "INBOUND", "OUTBOUND", "SELF", "AUTHORITY_ONLY" ], "description": "Relation to the queried wallet. INBOUND adds external wallet flow, OUTBOUND subtracts it, SELF is internal account or wrapping movement, and AUTHORITY_ONLY means the wallet authorized but did not own either endpoint." }, "transferFeeRawAmount": { "type": [ "string", "null" ], "description": "Recorded transfer fee withheld in this mint, as a precision-safe raw integer string. Null means no exact fee was recorded, not zero. Separate from network, priority and AMM fees. Unchanged by UI multipliers." }, "transferFeeAmount": { "type": [ "number", "null" ], "description": "Recorded transfer fee withheld in this mint, in the same units as amount. Uses the current Token-2022 UI multiplier by default. Null means no exact fee was recorded, not zero." }, "netReceivedAmount": { "type": [ "number", "null" ], "description": "Recipient amount after the recorded transfer fee, in the same units as amount. Calculated from source decimals before UI adjustment. Null when the fee is unknown or outside zero through gross amount. Explicit zero fees return the gross amount. This is not a signed wallet balance delta; existing USD values still use gross amount." } } } } } } } } } } } } } } }, "metadata": { "type": "object", "description": "MCP execution metadata for deciding whether wallet activity should be queried in smaller windows.", "additionalProperties": false, "properties": { "serverVersion": { "type": "string", "description": "Version advertised by this MCP server." }, "transactionCount": { "type": "integer", "minimum": 0, "description": "Number of distinct transaction groups returned in data.solana.wallet.activityExt.activity." }, "limitReached": { "type": "boolean", "description": "True when transactionCount equals the effective request limit. This signals possible truncation and is not proof that additional transactions exist." }, "selector": { "type": "object", "description": "Selector used for this result: either a UTC period or one exact Solana slot.", "additionalProperties": true, "properties": { "type": { "type": "string", "enum": [ "period", "slot" ] }, "from": { "type": "string", "format": "date-time" }, "to": { "type": "string", "format": "date-time" }, "slot": { "type": "integer", "minimum": 0 } }, "required": [ "type" ] } }, "required": [ "serverVersion", "transactionCount", "limitReached", "selector" ] }, "errors": { "type": "array", "description": "GraphQL errors. Do not fabricate activity when this field is present.", "items": { "type": "object", "additionalProperties": true } } } } ``` #### Example ```graphql query WalletActivity($wallet: String!, $period: SolanaWalletActivityPeriodInput!, $includeInnerSwaps: Boolean, $direction: SortDirection, $limit: Int, $currentLimit: Int, $allowRpcFallback: Boolean = true, $explorer: SolanaExplorerKind = SOLSCAN) { solana { wallet { activityExt(wallet: $wallet, period: $period, includeInnerSwaps: $includeInnerSwaps, direction: $direction, limit: $limit, currentLimit: $currentLimit, allowRpcFallback: $allowRpcFallback, explorer: $explorer) { metadata { activityRecoveryIncomplete wallet walletExplorerUrl hasCurrentState firstTransferToWalletAt lastTransferToWalletAt updatedAt version coverage { dataset indexedFromSlot indexedFromAt indexedThroughSlot indexedThroughAt measuredAt } currentHoldings { mint mintExplorerUrl currentHoldings firstTransferToWalletAt lastTransferToWalletAt updatedAt version } } activity { source blockSlot blockExplorerUrl blockTime txHash txExplorerUrl trades { userWallet walletRelation relatedTransferIndexes token tokenExplorerUrl side priceUsd amount volumeUsd otherToken otherTokenExplorerUrl poolAddress poolExplorerUrl aggregatorProgram aggregatorProgramExplorerUrl gatewayFees ammFees compoundFees operationIndex tradeLayer } transfers { transferIndex operationIndex transferType intent mint mintExplorerUrl sourceOwner sourceOwnerExplorerUrl destinationOwner destinationOwnerExplorerUrl amount transferFeeRawAmount transferFeeAmount netReceivedAmount historicalPriceUsd historicalPriceSourceMinute historicalValueUsd currentPriceUsd currentPriceSourceMinute currentValueUsd isDefiActivity direction } } } } } } ``` Variables: ```json { "wallet": "CsVdJ8WH8Q9eHSTRpwtwN3TYApm24QnLKYUMNxJ3DaED", "period": { "from": "2026-08-03T00:00:00Z", "to": "2026-08-04T00:00:00Z" }, "includeInnerSwaps": false, "direction": "DESC", "limit": 100, "currentLimit": 10000, "allowRpcFallback": true, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_wallet_activity?wallet=CsVdJ8WH8Q9eHSTRpwtwN3TYApm24QnLKYUMNxJ3DaED&periodFrom=2026-08-03T00%3A00%3A00Z&periodTo=2026-08-04T00%3A00%3A00Z&includeInnerSwaps=false&direction=DESC&limit=100¤tLimit=10000&allowRpcFallback=true&explorer=SOLSCAN) ### `list_wallet_current_holdings` - **Map operation:** `listWalletCurrentHoldings` - **Title:** `List Solana wallet holdings` - **Kind:** `query` - **GraphQL path:** `solana.wallet.currentHoldings` Read non-zero effective current token holdings for one wallet. A one-time current RPC baseline corrects balance gaps when enabled. Standalone and activityExt.metadata.currentHoldings share this history-recovery flow: selecting flow totals or hasUnvaluedHistoricalFlow may start background recovery for a verified user wallet with a balance gap and evidence it predates indexed coverage. Balances-only reads never start history recovery. Pending or incomplete flow totals remain explicitly marked. Suggested response: describe observed activity dates, then provide a holdings table including token logos; batch mints through list_tokens for tokenSymbol, tokenName, and logoUrl. **Data dictionary:** `solana-wallet-holding-current` (entity; One current aggregate row per holder wallet and mint.) **Related topics:** `wallet holdings`, `wallet portfolio`, `token balances`, `current balances`, `tokens owned by wallet` #### Use When - The user provides a Solana wallet and asks which tokens it currently holds. - The user asks for effective current token amounts for a wallet. - The user asks for first or last observed transfer timestamps or indexed DeFi inflow/outflow totals for wallet holdings. #### Suggested Response Template - Open with one or two sentences naming the wallet's most recent lastTransferToWalletAt and, when available, the observed range from the earliest firstTransferToWalletAt to the latest lastTransferToWalletAt. These are indexed transfer observations, not wallet creation dates. - Batch unique holding mints through list_tokens in groups of at most 100, set limit to the batch size, and join returned tokenSymbol, tokenName, and logoUrl by mint. - Render a Markdown table with columns Logo | Token | Mint | Amount | First activity | Last activity. Render a non-null logoUrl as ![symbol](logoUrl); leave the cell empty when no logo is returned and never invent one. #### Arguments ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Solana wallet address. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` Number of holdings to skip. ##### `limit` - **GraphQL type:** `Int` - **Default:** `10000` - **Maximum:** `10000` Maximum holdings to return. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl from each holding mint. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl currentHoldings firstTransferToWalletAt lastTransferToWalletAt defiInflowsTokenAmount defiOutflowsTokenAmount defiInflowsUsd defiOutflowsUsd hasUnvaluedHistoricalFlow updatedAt version ``` #### Caveats - currentHoldings is a token amount, not a USD value. - Rows collapse all wallet token accounts into one effective row per mint. - NativeSOL and wrapped SOL are intentionally separate holdings. - History recovery is triggered by currentHoldings flow selections, either standalone or nested under activityExt.metadata with allowRpcFallback=true. Selecting defiInflowsTokenAmount, defiOutflowsTokenAmount, defiInflowsUsd, defiOutflowsUsd, or hasUnvaluedHistoricalFlow can start it. The default standalone MCP selection includes these fields. Balances-only holdings and activity-only selections never start history recovery. - Start conditions: server wallet RPC is enabled, a saved current-balance comparison found a gap, the returned holdings page is non-empty, indexed start time and slot are known, and a cached or bounded check verifies a normal user wallet that existed before indexing. Programs and non-wallet accounts are excluded. Known creation within indexed coverage or inconclusive evidence starts no job. - Recovery covers lifetime history through the saved balance observation and reconciles against the complete saved balance set, independent of pagination. Current holdings has no requested-period argument. Account checks stay internal and cached; no account data is added to activity metadata. - Existing matching jobs are reused. Pending or retryable jobs continue, completed results are reused, and stopped or terminal jobs remain stopped. Unknown or incomplete history keeps indexed totals and sets hasUnvaluedHistoricalFlow. Completed recovered totals never replace newer indexed flow totals; those remain explicitly partial. - version is reducer write order in Unix nanoseconds, represented as a string; it is not chain event time. - The query reads current indexed holdings on every request. Only the one-time wallet classification, RPC baseline, and recovered activity are stored by the receiving Graph instance; canonical indexed history is never modified. - A BEFORE_INDEXED baseline wins until a strictly newer indexed reducer version is available for that mint. An INDEXED decision avoids future current-balance RPC reads on that local instance. - This operation cannot access private keys, sign transactions, mutate a wallet, or inspect arbitrary RPC accounts. #### Example ```graphql query WalletCurrentHoldings($wallet: String!, $skip: Int, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { solana { wallet { currentHoldings(wallet: $wallet, skip: $skip, limit: $limit, explorer: $explorer) { mint mintExplorerUrl currentHoldings firstTransferToWalletAt lastTransferToWalletAt defiInflowsTokenAmount defiOutflowsTokenAmount defiInflowsUsd defiOutflowsUsd hasUnvaluedHistoricalFlow updatedAt version } } } } ``` Variables: ```json { "wallet": "CsVdJ8WH8Q9eHSTRpwtwN3TYApm24QnLKYUMNxJ3DaED", "skip": 0, "limit": 10000, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_wallet_current_holdings?wallet=CsVdJ8WH8Q9eHSTRpwtwN3TYApm24QnLKYUMNxJ3DaED&skip=0&limit=10000&explorer=SOLSCAN) ### `list_token_holders` - **Map operation:** `listTokenHolders` - **Title:** `List Solana token holders` - **Kind:** `query` - **GraphQL path:** `solana.wallet.tokenHolders` List current indexed holder-wallet rows for one Solana token, ordered by current token amount or combined DeFi activity. holderType is a scalar summary and returns MIXED when the balance has multiple classification components; holdingsByType preserves their individual amounts. Zero balances are omitted by default and can be enabled explicitly; sub-cent positive balances are omitted by default when the cached token price is above one cent. This is indexed holder state, not arbitrary RPC account inspection. **Data dictionary:** `solana-wallet-holding-current` (entity; One current aggregate row per holder wallet and mint.) **Related topics:** `token holders`, `holder wallets`, `wallets holding token`, `largest holders`, `user holders`, `program holders`, `vault holders`, `holder classification`, `holder list` #### Use When - The user provides a Solana token mint and asks which wallets currently hold it. - The user asks for more than the cached top-10 holders exposed by tokensExt. - The user asks for current token amounts or indexed transfer timestamps for holders of one mint. - The user needs to distinguish user-controlled amounts from program or AMM-vault holdings. #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Solana token mint. NativeSOL and wrapped SOL are intentionally distinct. ##### `orderBy` - **GraphQL type:** `SolanaTokenHolderOrderInput` Optional ordering. Defaults to CURRENT_HOLDINGS DESC. DeFi activity fields combine indexed inflows plus outflows. ###### Input Fields ```json { "field": [ "CURRENT_HOLDINGS", "DEFI_ACTIVITY_TOKEN_AMOUNT", "DEFI_ACTIVITY_USD" ], "direction": [ "ASC", "DESC" ] } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` Number of balance-sorted holder rows to skip. ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Maximum:** `10000` Maximum holder rows to return. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build walletExplorerUrl from each holder wallet. Currently SOLSCAN is the only supported value. ##### `includeDust` - **GraphQL type:** `Boolean` - **Default:** `false` When true, include positive balances worth less than one cent. ##### `includeZero` - **GraphQL type:** `Boolean` - **Default:** `false` When true, include holders whose merged current balance is exactly zero. Negative balances remain excluded. #### Default Selection ```graphql wallet walletExplorerUrl currentHoldings holderType ``` #### Caveats - currentHoldings is a token amount, not a USD value. - Rows collapse all indexed token accounts owned by one wallet into one row. - holderType is a scalar summary cached with the compact top-holder row and derived from holdingsByType on detailed reads: it is the sole positive component type, MIXED for multiple distinct positive component types, and UNKNOWN for legacy unclassified state. Use holdingsByType for the amount assigned to each component. - holdingsByType is version-aligned with currentHoldings and its positive components sum to currentHoldings. MIXED is never emitted for an individual component. - USER means an on-curve user-controlled wallet component; it does not prove one human owner. Legacy rows with no classification are returned as one UNKNOWN component equal to currentHoldings. - Zero current holdings are excluded by default after merging the latest holder state; includeZero: true includes exact zeros but never negative balances. By default, Graph also omits positive balances worth less than $0.01 only when its local current token cache has a unit price above $0.01. Unknown or lower unit prices do not activate the dust threshold; includeDust: true disables it. - DEFI_ACTIVITY_TOKEN_AMOUNT is defiInflowsTokenAmount plus defiOutflowsTokenAmount; DEFI_ACTIVITY_USD is defiInflowsUsd plus defiOutflowsUsd. - When ordering by DeFi activity, currentHoldings descending is the secondary order before wallet-address tie-breaking. - Use skip and limit to page high-cardinality tokens; the default is 100 and the cap is 10000. - For currentHoldings DESC with skip 0, limit at most 10, and includeZero false, Graph serves wallet, currentHoldings, and holderType directly from the holder-stats cache. holdingsByType, timestamps, and DeFi-flow fields use cached wallet identities to restrict the live detail merge. includeZero true, wider pages, and DeFi-activity ordering merge the complete mint projection. - Balance and dust predicates are applied only after aggregate-state merge. Filtering physical state rows first could resurrect an older positive balance after a newer zero update. - Use this detailed query instead of the deprecated tokensExt.topHolders summary. Use tokensExt.topUserHolders when only the compact USER-ranked top ten is required. #### Example ```graphql query TokenHolders($mint: String!, $orderBy: SolanaTokenHolderOrderInput, $skip: Int, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN, $includeDust: Boolean! = false, $includeZero: Boolean! = false) { solana { wallet { tokenHolders(mint: $mint, orderBy: $orderBy, skip: $skip, limit: $limit, explorer: $explorer, includeDust: $includeDust, includeZero: $includeZero) { wallet walletExplorerUrl currentHoldings holderType } } } } ``` Variables: ```json { "mint": "So11111111111111111111111111111111111111112", "orderBy": { "field": "DEFI_ACTIVITY_USD", "direction": "DESC" }, "skip": 0, "limit": 100, "explorer": "SOLSCAN", "includeDust": false, "includeZero": false } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_token_holders?mint=So11111111111111111111111111111111111111112&orderByField=DEFI_ACTIVITY_USD&orderByDirection=DESC&skip=0&limit=100&explorer=SOLSCAN&includeDust=false&includeZero=false) ### `get_cex_consensus_price` - **Map operation:** `getCexConsensusPrice` - **Title:** `Get CEX consensus price` - **Kind:** `query` - **GraphQL path:** `cex.consensusPrice` Read cross-venue one-minute CEX consensus VWAP reference prices. This is historical/current reference data, not an order book, executable quote, trade route, prediction, or exchange API. **Data dictionary:** `cex-consensus-minute` (fact; One consensus measurement per normalized symbol and UTC minute.) **Related topics:** `cex price`, `consensus price`, `reference price`, `centralized exchange vwap`, `cex volume` #### Use When - The user asks for a CEX reference VWAP for a base-asset symbol. - The user asks for cross-venue consensus prices at or before a UTC minute. - The user asks to page the latest CEX reference-price snapshot across symbols. #### Arguments ##### `minute` - **GraphQL type:** `DateTime` Optional UTC minute. Seconds are truncated. If that minute is absent, the query resolves to the latest available minute at or before it. ##### `symbol` - **GraphQL type:** `String` Optional CEX base-asset symbol. Matching is case-insensitive and normalized to uppercase. ##### `orderBy` - **GraphQL type:** `CexConsensusPriceOrderInput` Optional consensus-VWAP price or USD reference-volume ordering. Omit for symbol order. ###### Input Fields ```json { "field": [ "PRICE", "REFERENCE_VOLUME_USD" ], "direction": [ "ASC", "DESC" ] } ``` ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` Number of matching symbols to skip. ##### `limit` - **GraphQL type:** `Int` - **Default:** `100` - **Maximum:** `10000` Maximum rows to return. #### Default Selection ```graphql minute symbol vwap referenceVolumeUsd ``` #### Caveats - vwap is a CEX consensus reference price in the configured reference quote asset; it is not an executable quote. - With minute, referenceVolumeUsd is the USD source volume for the resolved one-minute observation. - Without minute, referenceVolumeUsd is summed over the trailing 24 hours while vwap remains the latest resolved price. - With neither minute nor symbol, the result is a paginated latest consensus snapshot across symbols. - Symbol matching is case-insensitive but exact after uppercase normalization; this is not token-name or Solana-mint search. #### Example ```graphql query CexConsensusPrices($symbol: String, $minute: DateTime, $orderBy: CexConsensusPriceOrderInput, $skip: Int, $limit: Int) { cex { consensusPrice(symbol: $symbol, minute: $minute, orderBy: $orderBy, skip: $skip, limit: $limit) { minute symbol vwap referenceVolumeUsd } } } ``` Variables: ```json { "symbol": "btc", "orderBy": { "field": "PRICE", "direction": "DESC" }, "skip": 0, "limit": 100 } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_cex_consensus_price?symbol=btc&orderByField=PRICE&orderByDirection=DESC&skip=0&limit=100) ### `get_tokenized_equities` - **Map operation:** `getTokenizedEquities` - **Title:** `List tokenized equities` - **Kind:** `query` - **GraphQL path:** `equities.tokenizedEquities` Read preferred Solana RWA listings from Hero Business with optional FMP underlying quotes and share counts. Missing market coverage does not remove listings. **Data dictionary:** `tokenized-equity-reference` (entity; One current preferred listing per Solana mint.) **Related topics:** `tokenized stocks`, `xstocks`, `stock price`, `shares outstanding`, `stock market cap`, `tokenized equity` #### Use When - The user asks which Solana mints are tokenized stocks or ETFs. - The user asks for the underlying stock price behind a tokenized share such as NVDAx. - The user asks for shares outstanding so a stock market cap can be derived from a token price. - The user asks whether a tokenized stock is trading at a premium or discount to its underlying. #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional Solana mint addresses to restrict the result to. ##### `tickers` - **GraphQL type:** `[String!]` Optional vendor tickers of the underlying securities to restrict the result to. ##### `quotedOnly` - **GraphQL type:** `Boolean` - **Default:** `false` Return only mints that currently have underlying quote coverage. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` Number of matching mints to skip. ##### `limit` - **GraphQL type:** `Int` - **Default:** `200` - **Maximum:** `2000` Maximum rows to return. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl for each tokenized equity. Currently SOLSCAN is the only supported value. ##### `categories` - **GraphQL type:** `[String!]` Optional native Business categories; matches any supplied name, case-insensitively. ##### `tags` - **GraphQL type:** `[String!]` Optional native Business tags; matches any supplied name, case-insensitively. #### Default Selection ```graphql mint mintExplorerUrl fmpTicker tokenSymbol companyName categories tags issuer sharesPerToken underlyingPriceUsd underlyingChangePercent marketState underlyingQuoteAt sharesOutstanding sharesOutstandingAsOf ``` #### Caveats - Categories and tags preserve native Business names. Filters use OR within each list and AND between lists, matching the ordinary Solana token filters. - Display aliases override native symbol/name; fmpTicker remains the independent vendor lookup key. sharesPerToken is null when unknown. - underlyingPriceUsd is the price of the listed security from the market-data vendor, not the on-chain price of the token; use the Solana token queries for the token price. - Quote and fundamentals fields are null when a registered mint has no vendor coverage. Null means unknown and must never be rendered as 0. - fmpTicker is null for mints whose underlying has not been confirmed, including pre-IPO tokens with no listed security. - Implied stock market cap is token price multiplied by sharesOutstanding divided by sharesPerToken; it is only as fresh as sharesOutstandingAsOf. - marketState reflects the listing venue session at the quote time and reports CLOSED when the last quote is older than the configured staleness threshold. - Quotes may be delayed depending on the vendor plan; compare underlyingQuoteAt against now before presenting a price as live. #### Example ```graphql query TokenizedEquities($mints: [String!], $tickers: [String!], $tags: [String!], $categories: [String!], $quotedOnly: Boolean, $skip: Int, $limit: Int, $explorer: SolanaExplorerKind = SOLSCAN) { equities { tokenizedEquities(mints: $mints, tickers: $tickers, tags: $tags, categories: $categories, quotedOnly: $quotedOnly, skip: $skip, limit: $limit, explorer: $explorer) { mint mintExplorerUrl fmpTicker tokenSymbol companyName categories tags sharesPerToken underlyingPriceUsd underlyingChangePercent marketState underlyingQuoteAt sharesOutstanding sharesOutstandingAsOf } } } ``` Variables: ```json { "tickers": [ "NVDA" ], "quotedOnly": true, "skip": 0, "limit": 200, "explorer": "SOLSCAN" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_tokenized_equities?tickers=NVDA"edOnly=true&skip=0&limit=200&explorer=SOLSCAN) ### `list_traders` - **Map operation:** `listTraders` - **Title:** `List trader profiles` - **Kind:** `query` - **GraphQL path:** `traders` List current trader profiles that have at least one valid configured wallet address. Filter by exact profile ID, profile text, configured network, or Hero Business profile validation status before pagination. Results are ordered by directory rank ascending with null ranks last, then display name and profile ID. **Data dictionary:** `trader-profile` (entity; One current profile per trader ID.) **Related topics:** `traders`, `trader profiles`, `influencers`, `social profiles`, `known wallets`, `copy trading` #### Use When - The user asks for known trader or influencer profiles and their configured wallets. - A client needs to find a trader by name, alias, social handle, or wallet address. - A client needs a paginated directory filtered to profiles with a wallet on a specific network. #### Arguments ##### `id` - **GraphQL type:** `String` Optional exact trader profile ID. ##### `search` - **GraphQL type:** `String` Optional case-insensitive profile, alias, and social search. Wallet addresses are also searched; Solana wallet matching remains case-sensitive. ##### `network` - **GraphQL type:** `String` Optional configured wallet network such as SOL. Matching profiles retain wallets from every configured network. ##### `isValidated` - **GraphQL type:** `Boolean` Hero Business profile validation: true for validated, false for unvalidated (including null source values); omit or null for all profiles. ##### `skip` - **GraphQL type:** `Int` - **Default:** `0` - **Minimum:** `0` Number of matching profiles to skip after filtering and ordering. ##### `limit` - **GraphQL type:** `Int` - **Default:** `24` - **Minimum:** `1` - **Maximum:** `100` Maximum profiles to return. #### Default Selection ```graphql totalCount asOf stale items { id displayName title description extendedDescription bio aliases imageUrl rank isValidated updatedAt categories { id name } tags { id name } countries { id name } languages { id name } wallets { network address label } socialMedia { platform handle url verified followerCount } } ``` #### MCP Note Use list_traders for profile discovery and configured wallet associations. Treat wallet associations as directory claims rather than ownership proof. Use Solana wallet operations separately for on-chain activity and holdings. #### Caveats - Configured wallet associations are directory metadata and do not prove wallet ownership. - Directory rank is not measured trading performance, profitability, or copy-trading suitability. - Network filtering tests profile membership but does not remove other configured wallets from returned profiles. - stale=true means the last successful snapshot is being retained after a refresh failure; asOf identifies when that snapshot was loaded. #### Structured Result Metadata ```json { "collectionPath": "data.traders.items", "limitArgument": "limit", "countProperty": "totalCount" } ``` #### Output Schema ```json { "type": "object", "description": "GraphQL response envelope for a trader profile page.", "additionalProperties": true, "properties": { "data": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "traders": { "type": [ "object", "null" ], "additionalProperties": true, "properties": { "items": { "type": "array", "items": { "type": "object", "additionalProperties": true, "properties": { "id": { "type": "string" }, "displayName": { "type": "string" }, "title": { "type": [ "string", "null" ] }, "description": { "type": [ "string", "null" ] }, "extendedDescription": { "type": [ "string", "null" ] }, "bio": { "type": [ "string", "null" ] }, "aliases": { "type": "array", "items": { "type": "string" } }, "imageUrl": { "type": [ "string", "null" ], "format": "uri" }, "rank": { "type": [ "integer", "null" ] }, "updatedAt": { "type": [ "string", "null" ], "format": "date-time" }, "categories": { "$ref": "#/$defs/labels" }, "tags": { "$ref": "#/$defs/labels" }, "countries": { "$ref": "#/$defs/labels" }, "languages": { "$ref": "#/$defs/labels" }, "wallets": { "type": "array", "items": { "type": "object", "additionalProperties": false, "properties": { "network": { "type": "string" }, "address": { "type": "string" }, "label": { "type": [ "string", "null" ] } }, "required": [ "network", "address", "label" ] } }, "socialMedia": { "type": "array", "items": { "type": "object", "additionalProperties": false, "properties": { "platform": { "type": "string" }, "handle": { "type": [ "string", "null" ] }, "url": { "type": [ "string", "null" ], "format": "uri" }, "verified": { "type": "boolean" }, "followerCount": { "type": [ "integer", "null" ] } }, "required": [ "platform", "handle", "url", "verified", "followerCount" ] } }, "isValidated": { "type": "boolean", "description": "Hero Business profile validation status. Null or missing source values count as unvalidated. Independent of social verification and wallet ownership." } } } }, "totalCount": { "type": "integer", "minimum": 0 }, "asOf": { "type": [ "string", "null" ], "format": "date-time" }, "stale": { "type": "boolean" } } } } }, "errors": { "type": "array", "items": { "type": "object", "additionalProperties": true } } }, "$defs": { "labels": { "type": "array", "items": { "type": "object", "additionalProperties": false, "properties": { "id": { "type": [ "string", "null" ] }, "name": { "type": "string" } }, "required": [ "id", "name" ] } } } } ``` #### Example ```graphql query Traders($search: String, $network: String, $isValidated: Boolean, $skip: Int, $limit: Int) { traders(search: $search, network: $network, isValidated: $isValidated, skip: $skip, limit: $limit) { totalCount asOf stale items { id displayName title description bio aliases imageUrl rank isValidated updatedAt categories { id name } tags { id name } wallets { network address label } socialMedia { platform handle url verified followerCount } } } } ``` Variables: ```json { "network": "SOL", "skip": 0, "limit": 24 } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/list_traders?network=SOL&skip=0&limit=24) ### `get_token_activity_ext` - **Map operation:** `getTokenActivityExt` - **Title:** `Get token activity summaries` - **Kind:** `query` - **GraphQL path:** `solana.tokenActivityExt` Summarize 1 to 100 token mints over a shared exact slot, inclusive slot range or UTC period (default trailing day). Return one result per distinct mint in first-requested order, including inactive mints with zero totals. Each result contains moved/minted/burned amounts, owner sent/received/swappedIn/swappedOut totals, transaction fees, and memos/notes grouped by hash. Wallet and annotation arrays follow chronological execution order. **Data dictionary:** `solana-dex-trade` (fact; One token-perspective trade row per transaction hash, logical operation index, trade layer, and pool context; one swap can produce multiple related rows.), `solana-token-transfer` (fact; One decoded physical token movement or supported authority-change row per transaction hash and transferIndex, carrying its outer and inner instruction coordinates.), `solana-transaction-fee` (fact; One indexed transaction row per transaction signature.), `solana-token-activity-summary` (fact; One result per distinct requested token and shared interval, with per-owner totals and per-transaction annotation groups. Results follow first-requested mint order; inactive mints retain a result with zero totals.) #### Arguments ##### `mints` - **GraphQL type:** `[String!]!` - **Required:** `true` From 1 to 100 exact Solana token mints. Duplicate mints are collapsed after trimming, preserving first-requested order. The input limit applies before deduplication. ##### `period` - **GraphQL type:** `TokenActivityPeriodInput` UTC period; mutually exclusive with slot and slots. Omit all selectors for the trailing day. ###### Input Fields ```json { "from": "DateTime; inclusive whole UTC second; defaults to one day before to", "to": "DateTime; exclusive whole UTC second; defaults to now" } ``` ##### `slot` - **GraphQL type:** `Long` Exact Solana slot; mutually exclusive with period and slots. ##### `slots` - **GraphQL type:** `TokenActivitySlotRangeInput` Inclusive slot range; mutually exclusive with period and slot. ###### Input Fields ```json { "from": "Long!; inclusive", "to": "Long!; inclusive" } ``` ##### `walletSkip` - **GraphQL type:** `Int` - **Default:** `0` Number of chronologically ordered wallet rows to skip independently for each token; does not change summary or fee totals. ##### `walletLimit` - **GraphQL type:** `Int` - **Default:** `1000` - **Maximum:** `10000` Page size from 1 to 10000 per token. Inspect each token's corresponding has-more flag. Annotation pages count the combined set of that token's transactions with memos or notes. ##### `annotationSkip` - **GraphQL type:** `Int` - **Default:** `0` Number of chronologically ordered annotation rows to skip independently for each token; does not change summary or fee totals. ##### `annotationLimit` - **GraphQL type:** `Int` - **Default:** `1000` - **Maximum:** `10000` Page size from 1 to 10000 per token. Inspect each token's corresponding has-more flag. Annotation pages count the combined set of that token's transactions with memos or notes. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer for explicit identifier links. #### Default Selection ```graphql mint mintExplorerUrl periodStart periodEnd fromSlot toSlot summary { transactionCount transferCount swapCount changedHands minted burned swappedIn swappedOut unresolvedOwnerTransferCount } wallets { wallet walletExplorerUrl firstBlockTime firstBlockSlot firstTransactionIndex firstInstructionIndex firstInnerInstructionIndex sent received swappedIn swappedOut minted burned } hasMoreWallets details { fees { transactionCount missingTransactionCount totalFeeLamports baseFeeLamports prioritizationFeeLamports jitoTipLamports token2022FeeAmount estimatedGatewayFeesUsd estimatedAmmFeesUsd unknownGatewayFeeSwapCount unknownAmmFeeSwapCount } memos { txHash txExplorerUrl blockSlot blockTime transactionIndex memos { instructionIndex innerInstructionIndex content } } notes { txHash txExplorerUrl blockSlot blockTime transactionIndex notes } hasMoreAnnotations } ``` #### Example ```graphql query TokenActivity { solana { tokenActivityExt(mints: ["G6autZruJLEzYKRh84qTsbVhrTvLEbjBYdHnBQH1zitp", "So11111111111111111111111111111111111111112"], slot: 452278088) { mint mintExplorerUrl periodStart periodEnd fromSlot toSlot summary { transactionCount transferCount swapCount changedHands minted burned swappedIn swappedOut unresolvedOwnerTransferCount } wallets { wallet walletExplorerUrl firstBlockTime firstBlockSlot firstTransactionIndex firstInstructionIndex firstInnerInstructionIndex sent received swappedIn swappedOut minted burned } hasMoreWallets details { fees { transactionCount missingTransactionCount totalFeeLamports baseFeeLamports prioritizationFeeLamports jitoTipLamports token2022FeeAmount estimatedGatewayFeesUsd estimatedAmmFeesUsd unknownGatewayFeeSwapCount unknownAmmFeeSwapCount } memos { txHash txExplorerUrl blockSlot blockTime transactionIndex memos { instructionIndex innerInstructionIndex content } } notes { txHash txExplorerUrl blockSlot blockTime transactionIndex notes } hasMoreAnnotations } } } } ``` Variables: ```json {} ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_token_activity_ext) ### `quote_simulation` - **Map operation:** `quoteSimulation` - **Title:** `Quote simulation` - **Kind:** `query` - **GraphQL path:** `solana.simulation.quote` Preview a direct or atomic two-hop swap for an exact input budget; does not change balances. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `solana-pool-swap-quotes` (entity; One latest route preview per explicit input/output pair, exact input budget and route options.), `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `inputMint` - **GraphQL type:** `String!` - **Required:** `true` Token to spend; NativeSOL aliases wrapped SOL. ##### `outputMint` - **GraphQL type:** `String!` - **Required:** `true` Token to receive; NativeSOL aliases wrapped SOL. ##### `amount` - **GraphQL type:** `Decimal!` - **Required:** `true` Exact positive decimal string in the session units. Input budget, never desired output or automatic USD conversion. ##### `routeHint` - **GraphQL type:** `RouteHintInput` - **Required:** `false` Optional {poolAddress, mode}. REQUIRE (default) must include the pool or fail; PREFER investigates it in parallel with normal routes but permits a better route. Discovers counterpart pools automatically within a bounded direct/two-hop search. ##### `maxQuoteAgeMilliseconds` - **GraphQL type:** `Int` - **Required:** `false` - **Minimum:** `1` - **Maximum:** `10000` Optional maximum simulation age at response selection, 1-10000 ms. Original slot/time remain unchanged on reuse; network delivery adds time. Omitted: previews reuse for 2 seconds and accept verified results up to 10 seconds old; builds always run a fresh final simulation. #### Default Selection ```graphql inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql query quoteSimulation($sessionId: String!, $inputMint: String!, $outputMint: String!, $amount: Decimal!) { solana { simulation { quote(sessionId: $sessionId, inputMint: $inputMint, outputMint: $outputMint, amount: $amount) { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds simulationSlot quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "inputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "outputMint": "NativeSOL", "amount": 10 } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/quote_simulation?sessionId=SESSION_ID&inputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&outputMint=NativeSOL&amount=10) ### `get_simulation` - **Map operation:** `getSimulation` - **Title:** `Get simulation` - **Kind:** `query` - **GraphQL path:** `solana.simulation.status` Read or resume a virtual session, balances and operation results with full fill evidence. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. #### Default Selection ```graphql id pollUrl status createdAt expiresAt version adjustForUiMultiplier requireWalletToken amountUnit pollAfterMilliseconds holdings { wallet mint amount reserved available } operations { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql query getSimulation($sessionId: String!) { solana { simulation { status(sessionId: $sessionId) { id pollUrl status createdAt expiresAt version adjustForUiMultiplier amountUnit pollAfterMilliseconds holdings { wallet mint amount reserved available } operations { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds simulationSlot quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } } } } } ``` Variables: ```json { "sessionId": "SESSION_ID" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_simulation?sessionId=SESSION_ID) ### `get_simulation_holdings` - **Map operation:** `getSimulationHoldings` - **Title:** `Get simulation holdings` - **Kind:** `query` - **GraphQL path:** `solana.simulation.holdings` Read one virtual wallet: total, reserved and available balances, sorted by mint. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Valid Solana address identifying the virtual wallet; no key or real funds needed. #### Default Selection ```graphql wallet mint amount reserved available ``` #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql query getSimulationHoldings($sessionId: String!, $wallet: String!) { solana { simulation { holdings(sessionId: $sessionId, wallet: $wallet) { wallet mint amount reserved available } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "wallet": "WALLET_ADDRESS" } ``` Browser-safe execution: [Execute this operation through the read facade](https://graph.blockchain.ai/read/get_simulation_holdings?sessionId=SESSION_ID&wallet=WALLET_ADDRESS) ### `get_simulation_wallet_token` - **Map operation:** `getSimulationWalletToken` - **Title:** `Get simulation wallet token` - **Kind:** `query` - **GraphQL path:** `solana.simulation.getWalletToken` Retrieve a stable wallet-specific trading token using adminToken. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Valid Solana address identifying the virtual wallet; no key or real funds needed. ##### `adminToken` - **GraphQL type:** `String!` - **Required:** `true` Secret returned once by start_simulation. Required for funding, deletion and wallet-token retrieval. #### Default Selection ```graphql sessionId wallet walletToken ``` #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql query getSimulationWalletToken($sessionId: String!, $wallet: String!, $adminToken: String!) { solana { simulation { getWalletToken(sessionId: $sessionId, wallet: $wallet, adminToken: $adminToken) { sessionId wallet walletToken } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "wallet": "WALLET_ADDRESS", "adminToken": "ADMIN_TOKEN" } ``` ## Subscription Operations ### `subscribeUnconfirmedTrades` - **Kind:** `subscription` - **GraphQL path:** `unconfirmedTrades` GraphQL websocket subscription for live provisional Solana DEX trades from the unconfirmed-trades stream. It is not exposed as a request/response MCP tool. **Data dictionary:** `solana-unconfirmed-trade-stream` (fact; One provisional stream message per emitted trade event and token perspective.) #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional token mint list. When provided, reads dedicated mint subjects like unconfirmed-trades.mint.. ##### `lookBehindSeconds` - **GraphQL type:** `Int` Optional retained-message replay window; 0 or omitted means live only. Positive values perform a bounded finite replay through one ephemeral ordered JetStream consumer whose filter subjects include every requested mint, delete it, and continue through live Core NATS. Message and duration caps apply across the combined replay. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust provisional trade prices, baselines, and token amounts to current Token-2022 UI multipliers. False returns unadjusted source values; USD notionals and fees are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, block, token, pool, wallet, and program URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql streamSource streamCommitment providerCreatedAtUnixMilliseconds sourceReceivedAtUnixMilliseconds payloadReadyAtUnixMilliseconds receivedAt blockSlot blockExplorerUrl blockTime token tokenExplorerUrl side priceUsd amount volumeUsd poolAddress poolExplorerUrl aggregatorProgram aggregatorProgramExplorerUrl txHash txExplorerUrl gatewayFees ammFees compoundFees tradeLayer ``` #### MCP Note Expose as an MCP streaming tool only if the MCP transport/client supports streaming. Otherwise return instructions for the GraphQL subscription. Resolve physical poolAddress values through list_pools; 'Ondo RWA' is a virtual label with no pool row. After indexing, batch txHash values through get_transactions for transaction-level enrichment. #### Caveats - Events are provisional and may not be confirmed on-chain. - Resolve physical poolAddress values through list_pools to identify pool.programId/programName, then use get_program. Do not resolve the exact virtual venue label 'Ondo RWA' as an account. - aggregatorProgram is router/aggregator context and is not the pool venue program id. - A provisional txHash can be absent from get_transactions until or unless its indexed transaction records arrive. ### `subscribeLargeTrades` - **Kind:** `subscription` - **GraphQL path:** `largeTrades` GraphQL websocket subscription for provisional top-level large swaps derived from the unconfirmed-trades stream. It emits one preferred token perspective per transaction signature but does not imply canonical persistence or finality. It is not exposed as a request/response MCP tool. **Data dictionary:** `solana-unconfirmed-trade-stream` (fact; One provisional stream message per emitted trade event and token perspective.) #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional token mints matched against either end-to-end asset. Quote-mint filters read the broad source subject so the mirrored non-quote perspective is not lost. ##### `minVolumeUsd` - **GraphQL type:** `Float` - **Default:** `10000` Minimum provisional indexer-supplied USD notional. ##### `lookBehindSeconds` - **GraphQL type:** `Int` Optional bounded retained-message replay window. Multiple mint subjects are replayed by one ordered consumer with shared message and duration limits before live Core NATS continues. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Adjust provisional trade prices, baselines, and token amounts to current Token-2022 UI multipliers. False returns unadjusted source values; USD notionals and fees are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build transaction URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint timeUnixSeconds kind priceUsd volumeUsd sentMint sentAmount receivedMint receivedAmount maker makerExplorerUrl txHash txExplorerUrl poolAddress poolExplorerUrl otherToken otherTokenExplorerUrl tradeLayer aggregatorProgram relayerWallet gatewayFees ammFees compoundFees ``` #### MCP Note Expose as an MCP streaming tool only if the transport supports subscriptions. Otherwise direct callers to the GraphQL websocket subscription and use get_dex_largest_trades for canonical finite history. #### Caveats - Events are provisional and may be corrected or absent from canonical indexed history. - Deduplication is intentionally transaction-oriented: only one preferred top-level perspective is emitted per txHash. - Quote-mint filters use the broad source stream and apply mint matching after both mirrored perspectives can arrive. - Use get_dex_largest_trades for canonical historical follow-up. ### `subscribeUnconfirmedLiquidityEvents` - **Kind:** `subscription` - **GraphQL path:** `unconfirmedLiquidityEvents` GraphQL websocket subscription for live provisional Solana DEX liquidity add and remove events from the unconfirmed-liquidity-events subject. It is not exposed as a request/response MCP tool. **Data dictionary:** `solana-unconfirmed-liquidity-stream` (fact; One provisional stream message per emitted liquidity operation and pool/token context.) #### Arguments ##### `lookBehindSeconds` - **GraphQL type:** `Int` Optional retained-message replay window; 0 or omitted means live only. Positive values perform a bounded finite replay through an ephemeral ordered JetStream consumer, delete it, and continue through live Core NATS. Server message and duration caps prioritize fresh delivery over a large backlog. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build explicit transaction, block, wallet, pool, and token URLs. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql streamSource streamCommitment providerCreatedAtUnixMilliseconds sourceReceivedAtUnixMilliseconds payloadReadyAtUnixMilliseconds receivedAt blockSlot blockExplorerUrl blockTime transactionIndex txHash txExplorerUrl instructionIndex innerInstructionIndex userWallet userWalletExplorerUrl poolAddress poolExplorerUrl action tokenA tokenAExplorerUrl amountA tokenB tokenBExplorerUrl amountB eventSource ``` #### MCP Note Expose as an MCP streaming tool only if the MCP transport/client supports streaming. Otherwise return instructions for the GraphQL subscription. After indexing, batch txHash values through get_transactions for transaction-level enrichment. #### Caveats - Events are provisional and may not be confirmed on-chain. - Deduplicate by blockSlot, txHash, poolAddress, action, instructionIndex, innerInstructionIndex, tokenA, tokenB, amountA, and amountB. - Replay and live delivery use the dedicated GraphQL subscription connection pool; token-image object-store credentials are not used. - A provisional txHash can be absent from get_transactions until or unless its indexed transaction records arrive. ### `subscribeConfirmedTokenChanges` - **Kind:** `subscription` - **GraphQL path:** `confirmedTokenChanges` GraphQL websocket subscription for full current token snapshots emitted after committed token_stats writes. Returned snapshot.supplyUi and token-unit prices use the current Token-2022 UI multiplier by default, while change detection uses source values. It can emit all snapshots, only price transitions, or only newly detected graduations. Consumers maintaining state must ignore repeated or regressing exact versions per mint. This is best-effort delivery and is not exposed as a request/response MCP tool. **Data dictionary:** `solana-confirmed-token-changes` (fact; One published committed token_stats snapshot identified by mint and write-order version.) #### Arguments ##### `mints` - **GraphQL type:** `[String!]` Optional token mint list. When supplied, dedicated confirmed-token-changes.mint. subjects are used instead of the broad subject. ##### `lookBehindSeconds` - **GraphQL type:** `Int` Optional bounded retained replay window; 0 or omitted means live only. Replay is recovery assistance and does not make the stream complete or exactly once. ##### `changeType` - **GraphQL type:** `ConfirmedTokenChangeType` - **Default:** `ALL` ALL emits every committed snapshot. PRICE emits price changes; a live-only explicit-mint subscription can compare its first newer event with the cached token price. Global and replay subscriptions need a prior streamed event. GRADUATION emits only a detected graduationAt transition. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Multiply snapshot.supplyUi by the current Token-2022 UI multiplier and divide snapshot.priceUsd, snapshot.athUsd, snapshot.atlUsd, and fairPriceUsd by it. Defaults to true; false returns source amounts and prices. Raw supply, USD valuations, and change detection are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl. Currently SOLSCAN is the only supported value. #### Default Selection ```graphql mint mintExplorerUrl version publishedAt publishedAtUnixMilliseconds receivedAt isClosed fairPriceUsd fetchedAt didGraduated graduationAt isPriceChange isGraduationChange snapshot { mint tokenSymbol tokenName priceUsd marketCapUsd fdvUsd anchoredTvlUsd athUsd athAt atlUsd atlAt logoUrl firstSeenAt lastSeenAt status version } ``` #### MCP Note Expose as an MCP streaming tool only if the transport supports subscriptions. Otherwise use get_token/list_tokens for current state. Never describe this feed as complete history or exactly-once CDC. #### Caveats - Each event is a full current snapshot rather than a field delta. - version is exact UInt64 nanosecond write order serialized as a string; it is not a chain timestamp. - Global and replay PRICE subscriptions first establish a per-mint streamed baseline. A live-only explicit-mint subscription can emit its first event when its version is newer than the cached token row and priceUsd differs; fairPriceUsd has no cached baseline. GRADUATION does not replay old graduations already present in lifecycle state. - Graduation enrichment reads the same cached lifecycle state as tokensExt, then checks a process-local one-hour memory of newly backfilled non-pairing mints while the tracked value remains null. - The upstream transport uses bounded queues and can lose notifications across overload or process failure. Durable consumers must reconcile from canonical token queries. - Bookkeeping-only writes can produce events whose business fields did not visibly change. ### `subscribeTokenCandle` - **Kind:** `subscription` - **GraphQL path:** `tokenCandle` GraphQL websocket subscription for replaceable canonical DEX fair-price OHLCV snapshots emitted after source persistence. Prices and token volume are adjusted to the current Token-2022 UI amount multiplier by default; set adjustForUiMultiplier false for unadjusted values. It is not exposed as a request/response MCP tool. **Data dictionary:** `solana-live-token-candle-stream` (fact; One emitted rolling candle snapshot per subscribed mint and active requested interval bucket.) #### Arguments ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` ##### `interval` - **GraphQL type:** `DexCandleInterval` - **Default:** `ONE_MINUTE` ###### Accepted Values ```json [ "ONE_MINUTE", "FIVE_MINUTE", "FIFTEEN_MINUTE", "ONE_HOUR", "FOUR_HOUR", "ONE_DAY" ] ``` ##### `lookBehindSeconds` - **GraphQL type:** `Int` Optional retained fair-candle notification replay window; 0 or omitted means live only. Positive values initialize the candle through a bounded finite ordered-consumer replay, delete that consumer, and continue through live Core NATS. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean` - **Default:** `true` Apply the token's current Token-2022 UI amount multiplier to OHLC/VWAP and token volume. Set false for unadjusted source values. USD volumes are unchanged. ##### `explorer` - **GraphQL type:** `SolanaExplorerKind` - **Default:** `SOLSCAN` Explorer used to build mintExplorerUrl for each candle. ###### Accepted Values ```json [ "SOLSCAN" ] ``` #### Default Selection ```graphql mint mintExplorerUrl bucketStart timeUnixSeconds open high low close vwap volume volumeUsd fairVolumeUsd sampleCount ``` #### MCP Note Expose as an MCP streaming tool only if the MCP transport/client supports streaming. Otherwise use solana.dex.tokenCandles for request/response workflows. #### Caveats - A source minute can be published repeatedly as newer persisted versions arrive. Graph replaces that minute before aggregating wider intervals, so repeated notifications are not additive volume. - The active interval bucket is mutable. Use solana.dex.tokenCandles for retained historical reads. ### `subscribeTokenQuotes` - **Kind:** `subscription` - **GraphQL path:** `tokenQuotes` GraphQL WebSocket stream of repeated simulation.quote-style previews: best validated direct or atomic two-hop route found in a bounded search. Does not change balances. Not exposed as a request/response MCP tool. **Data dictionary:** `solana-pool-swap-quotes` (entity; One latest route preview per explicit input/output pair, exact input budget and route options.) #### Arguments ##### `inputMint` - **GraphQL type:** `String!` Asset to spend; NativeSOL is normalized to wrapped SOL. ##### `outputMint` - **GraphQL type:** `String!` Different asset to receive. ##### `amount` - **GraphQL type:** `Decimal!` Positive input budget, at most 1 billion, in displayed units by default. ##### `sessionId` - **GraphQL type:** `String` Optional simulation session; pins pricing to its owner and inherits fixed unit settings. ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean!` - **Default:** `true` Defaults to true for standalone subscriptions; session setting overrides. ##### `routeHint` - **GraphQL type:** `RouteHintInput` Optional poolAddress and mode REQUIRE/PREFER; identical semantics to simulation.quote. ##### `maxQuoteAgeMilliseconds` - **GraphQL type:** `Int` Optional maximum accepted age 1-10000 ms; cached results retain original timestamps. #### Default Selection ```graphql inputMint outputMint amount sequence emittedAt status stale errorCode error retryAfterMilliseconds quote { inputMint outputMint requestedInputAmount inputAmount unspentInputAmount outputAmount adjustForUiMultiplier mode routeIds pools intermediateMint intermediateRemainder searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt resultSource reused routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason quotes { routeId poolAddress programName inputMint outputMint inputAmount quoteAmount simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt reused } } ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. #### MCP Note Use graphql-transport-ws for streaming. Request/response MCP clients can call quote_simulation / solana.simulation.quote repeatedly with a sessionId. #### Caveats - Same route-aware pricing as solana.simulation.quote and virtual buy/sell: direct routes and atomic two-hop routes, including poolless venues where supported. Bounded search, not a global best-price guarantee. - One sequential search per subscription; identical source inputs, route hints and age limits share in-flight work and best matching evidence up to two seconds old. Success waits one second before the next attempt; failures back off 1, 2, 4 then 8 seconds. Stop/disconnect releases this consumer. - pending precedes the first result. quote retains the last successful SimulationFill during refreshing/stale/unavailable updates, with unchanged quotedAt and simulationSlot. stale is true after refresh failure or when retained evidence exceeds maxQuoteAgeMilliseconds (two seconds by default). Retained stale estimates are not newly verified fills. - With sessionId all searches run on the owner encoded in the ID and keep the session alive; owner failure never starts competing pricing elsewhere. Without sessionId no virtual session or wallet is needed. Amounts are displayed units by default; session settings override adjustForUiMultiplier. - Invalid inputs and missing/destroyed sessions terminate the subscription. Transient failures are sanitized in errorCode/error and retried while consumed. No signing, submission, reservations or balance changes. #### Example ```graphql subscription { tokenQuotes(inputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", outputMint: "So11111111111111111111111111111111111111112", amount: 1) { status stale errorCode quote { inputAmount outputAmount mode routeIds simulationSlot quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt resultSource } } } ``` ## Mutation Operations ### `start_simulation` - **Map operation:** `startSimulation` - **Title:** `Start simulation` - **Kind:** `mutation` - **GraphQL path:** `solana.simulation.start` Create an empty paper-trading session; returns its ID, poll URL and one-time admin token. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `adjustForUiMultiplier` - **GraphQL type:** `Boolean!` - **Required:** `false` - **Default:** `true` Fixed session units: displayed token units when true, source units when false. ##### `requireWalletToken` - **GraphQL type:** `Boolean!` - **Required:** `false` - **Default:** `false` Fixed session policy: require a walletToken for buy/sell, including retries. Defaults to false. #### Default Selection ```graphql id pollUrl status adjustForUiMultiplier requireWalletToken adminToken ``` #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql mutation startSimulation($adjustForUiMultiplier: Boolean!, $requireWalletToken: Boolean!) { solana { simulation { start(adjustForUiMultiplier: $adjustForUiMultiplier, requireWalletToken: $requireWalletToken) { id pollUrl status adjustForUiMultiplier requireWalletToken adminToken } } } } ``` Variables: ```json { "adjustForUiMultiplier": true, "requireWalletToken": true } ``` ### `fund_simulation` - **Map operation:** `fundSimulation` - **Title:** `Fund simulation` - **Kind:** `mutation` - **GraphQL path:** `solana.simulation.seed` Add virtual tokens to a session wallet. Requires adminToken and a retry-safe requestId. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `adminToken` - **GraphQL type:** `String!` - **Required:** `true` Secret returned once by start_simulation. Required for funding, deletion and wallet-token retrieval. ##### `requestId` - **GraphQL type:** `String!` - **Required:** `true` New lowercase UUID per intended operation. Retry lost responses with the same ID and identical arguments. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Valid Solana address identifying the virtual wallet; no key or real funds needed. ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Token mint; NativeSOL aliases wrapped SOL. ##### `amount` - **GraphQL type:** `Decimal!` - **Required:** `true` Exact positive decimal string in the session units. Input budget, never desired output or automatic USD conversion. #### Default Selection ```graphql id pollUrl operationId status adjustForUiMultiplier requireWalletToken operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } ``` #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql mutation fundSimulation($sessionId: String!, $adminToken: String!, $requestId: String!, $wallet: String!, $mint: String!, $amount: Decimal!) { solana { simulation { seed(sessionId: $sessionId, adminToken: $adminToken, requestId: $requestId, wallet: $wallet, mint: $mint, amount: $amount) { id pollUrl operationId status adjustForUiMultiplier operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds simulationSlot quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "adminToken": "ADMIN_TOKEN", "requestId": "NEW_LOWERCASE_UUID", "wallet": "WALLET_ADDRESS", "mint": "NativeSOL", "amount": 10 } ``` ### `buy_simulation` - **Map operation:** `buySimulation` - **Title:** `Buy simulation` - **Kind:** `mutation` - **GraphQL path:** `solana.simulation.buy` Buy virtual tokens using amount of paymentMint. Optional routeHint and maxQuoteAgeMilliseconds constrain the fill. Returns a receipt; poll get_simulation until complete. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `requestId` - **GraphQL type:** `String!` - **Required:** `true` New lowercase UUID per intended operation. Retry lost responses with the same ID and identical arguments. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Valid Solana address identifying the virtual wallet; no key or real funds needed. ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Token mint; NativeSOL aliases wrapped SOL. ##### `paymentMint` - **GraphQL type:** `String!` - **Required:** `true` Token to spend; amount is a budget of this token. ##### `amount` - **GraphQL type:** `Decimal!` - **Required:** `true` Exact positive decimal string in the session units. Input budget, never desired output or automatic USD conversion. ##### `minimumOutput` - **GraphQL type:** `Decimal!` - **Required:** `false` - **Default:** `0` Minimum destination-token amount as an exact decimal string; zero sets no minimum. ##### `walletToken` - **GraphQL type:** `String` - **Required:** `false` Token from get_simulation_wallet_token for this session and wallet. Required by protected sessions; an invalid supplied token always returns 403. ##### `routeHint` - **GraphQL type:** `RouteHintInput` - **Required:** `false` Optional pool constraint: {poolAddress, mode: REQUIRE or PREFER}. REQUIRE is the default and fails the operation without changing balances if the pool cannot be used. Resend the preview hint; retain it on identical requestId retries. ##### `maxQuoteAgeMilliseconds` - **GraphQL type:** `Int` - **Required:** `false` Optional maximum simulation age at virtual balance commit, from 1 to 10000 milliseconds. Includes reused evidence. Part of requestId retry identity; replay returns the original operation even after its quote ages. #### Default Selection ```graphql id pollUrl operationId status adjustForUiMultiplier requireWalletToken operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql mutation buySimulation($sessionId: String!, $requestId: String!, $wallet: String!, $mint: String!, $paymentMint: String!, $amount: Decimal!, $minimumOutput: Decimal!, $walletToken: String, $routeHint: RouteHintInput, $maxQuoteAgeMilliseconds: Int) { solana { simulation { buy(sessionId: $sessionId, requestId: $requestId, wallet: $wallet, mint: $mint, paymentMint: $paymentMint, amount: $amount, minimumOutput: $minimumOutput, walletToken: $walletToken, routeHint: $routeHint, maxQuoteAgeMilliseconds: $maxQuoteAgeMilliseconds) { id pollUrl operationId status adjustForUiMultiplier operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds simulationSlot quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "requestId": "NEW_LOWERCASE_UUID", "wallet": "WALLET_ADDRESS", "mint": "NativeSOL", "paymentMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": 10, "minimumOutput": 0, "walletToken": "WALLET_TOKEN" } ``` ### `sell_simulation` - **Map operation:** `sellSimulation` - **Title:** `Sell simulation` - **Kind:** `mutation` - **GraphQL path:** `solana.simulation.sell` Sell amount of mint into destinationMint. Optional routeHint and maxQuoteAgeMilliseconds constrain the fill. Returns a receipt; poll get_simulation until complete. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `requestId` - **GraphQL type:** `String!` - **Required:** `true` New lowercase UUID per intended operation. Retry lost responses with the same ID and identical arguments. ##### `wallet` - **GraphQL type:** `String!` - **Required:** `true` Valid Solana address identifying the virtual wallet; no key or real funds needed. ##### `mint` - **GraphQL type:** `String!` - **Required:** `true` Token mint; NativeSOL aliases wrapped SOL. ##### `destinationMint` - **GraphQL type:** `String!` - **Required:** `true` Token to receive from this virtual sale. ##### `amount` - **GraphQL type:** `Decimal!` - **Required:** `true` Exact positive decimal string in the session units. Input budget, never desired output or automatic USD conversion. ##### `minimumOutput` - **GraphQL type:** `Decimal!` - **Required:** `false` - **Default:** `0` Minimum destination-token amount as an exact decimal string; zero sets no minimum. ##### `walletToken` - **GraphQL type:** `String` - **Required:** `false` Token from get_simulation_wallet_token for this session and wallet. Required by protected sessions; an invalid supplied token always returns 403. ##### `routeHint` - **GraphQL type:** `RouteHintInput` - **Required:** `false` Optional pool constraint: {poolAddress, mode: REQUIRE or PREFER}. REQUIRE is the default and fails the operation without changing balances if the pool cannot be used. Resend the preview hint; retain it on identical requestId retries. ##### `maxQuoteAgeMilliseconds` - **GraphQL type:** `Int` - **Required:** `false` Optional maximum simulation age at virtual balance commit, from 1 to 10000 milliseconds. Includes reused evidence. Part of requestId retry identity; replay returns the original operation even after its quote ages. #### Default Selection ```graphql id pollUrl operationId status adjustForUiMultiplier requireWalletToken operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds searchStartedAt searchFinishedAt simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt quotedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } ``` #### Field Notes ##### `simulationCommitment` Commitment used for the successful simulation, currently confirmed. Null for older evidence. ##### `rpcHeadSlot` getSlot observation from the same RPC endpoint and commitment, shared for up to one second. May precede the simulation; null if unavailable. This is not an independent network-wide head. ##### `rpcHeadObservedAt` Original UTC observation time of rpcHeadSlot, unchanged on reuse. ##### `simulationStartedAt` UTC send time of the successful simulation RPC attempt after admission, excluding earlier failed attempts and sizing probes. Preserved on reuse. ##### `simulationCompletedAt` UTC receive/parse time of that successful RPC response; equals quotedAt. Preserved on reuse; not an on-chain block timestamp. ##### `searchStartedAt` Start of the original route search, before discovery and including preparation, queue waits and final verification. Builders start after wallet/funding validation. Null for older evidence or a pool quote without a route search. ##### `searchFinishedAt` Completion of the original route search after final selection. Reused results retain the original search times, not the current request times. #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql mutation sellSimulation($sessionId: String!, $requestId: String!, $wallet: String!, $mint: String!, $destinationMint: String!, $amount: Decimal!, $minimumOutput: Decimal!, $walletToken: String, $routeHint: RouteHintInput, $maxQuoteAgeMilliseconds: Int) { solana { simulation { sell(sessionId: $sessionId, requestId: $requestId, wallet: $wallet, mint: $mint, destinationMint: $destinationMint, amount: $amount, minimumOutput: $minimumOutput, walletToken: $walletToken, routeHint: $routeHint, maxQuoteAgeMilliseconds: $maxQuoteAgeMilliseconds) { id pollUrl operationId status adjustForUiMultiplier operation { id kind wallet mint otherMint amount status createdAt completedAt errorCode error fill { routeHintUsed hintEvaluated hintOutcome hintOutputAmount hintRouteIds hintSimulationSlot hintQuotedAt hintFailureReason reused inputMint outputMint inputAmount outputAmount requestedInputAmount unspentInputAmount pools routeIds simulationSlot quotedAt simulationCommitment rpcHeadSlot rpcHeadObservedAt simulationStartedAt simulationCompletedAt searchStartedAt searchFinishedAt intermediateMint intermediateRemainder adjustForUiMultiplier mode resultSource quotes { routeId routeKind poolAddress poolExplorerUrl programId programName programExplorerUrl inputMint outputMint inputAmount quoteMint quoteAmount inputValueUsd outputValueUsd inputUiMultiplier outputUiMultiplier impact { percent method status explanation splitInput } simulationSlot simulationBlockExplorerUrl quotedAt snapshotCheckedAt reused status error } } } } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "requestId": "NEW_LOWERCASE_UUID", "wallet": "WALLET_ADDRESS", "mint": "NativeSOL", "destinationMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": 10, "minimumOutput": 0, "walletToken": "WALLET_TOKEN" } ``` ### `destroy_simulation` - **Map operation:** `destroySimulation` - **Title:** `Destroy simulation` - **Kind:** `mutation` - **GraphQL path:** `solana.simulation.destroy` Delete a virtual session and cancel pending trades. Requires adminToken; deletion prevents restoration. Guide: https://graph.blockchain.ai/simulation.md (get_instructions topic simulation). **Data dictionary:** `simulation-session` (entity; One current virtual ledger per session ID, containing wallet/mint balances and operation IDs.) #### Arguments ##### `sessionId` - **GraphQL type:** `String!` - **Required:** `true` Simulation ID returned by start_simulation; not the MCP transport session ID. ##### `adminToken` - **GraphQL type:** `String!` - **Required:** `true` Secret returned once by start_simulation. Required for funding, deletion and wallet-token retrieval. #### Default Selection ```graphql id pollUrl status ``` #### Output Schema ```json { "type": "object", "properties": { "data": { "type": [ "object", "null" ] }, "errors": { "type": "array", "items": { "type": "object" } }, "extensions": { "type": "object" } }, "additionalProperties": true } ``` #### Example ```graphql mutation destroySimulation($sessionId: String!, $adminToken: String!) { solana { simulation { destroy(sessionId: $sessionId, adminToken: $adminToken) { id pollUrl status } } } } ``` Variables: ```json { "sessionId": "SESSION_ID", "adminToken": "ADMIN_TOKEN" } ``` ## Tool Generation Policy ### Recommended Generated Tools - `get_instructions` - `query_graphql` - `get_market_snapshot` - `get_market_token_count` - `find_hash` - `get_token` - `search_tokens` - `list_tokens` - `list_tokens_ext` - `list_token_lifecycle` - `list_blocks` - `get_block` - `list_block_transactions` - `get_transaction_activity` - `get_transactions` - `get_transaction_coverage` - `get_dex_token_candles` - `get_token_price_usd_at` - `get_dex_token_transactions` - `get_dex_largest_trades` - `get_dex_pool_transactions` - `get_dex_token_activity` - `get_dex_pool_stats` - `get_dex_pool_liquidity_stats` - `list_pools` - `get_program` - `list_programs` - `list_wallet_activity_rows` - `list_wallet_activity` - `list_wallet_current_holdings` - `list_token_holders` - `get_tokenized_equities` - `get_cex_consensus_price` - `get_token_activity_ext` - `build_swap_transaction` - `start_simulation` - `fund_simulation` - `quote_simulation` - `buy_simulation` - `sell_simulation` - `get_simulation` - `get_simulation_holdings` - `destroy_simulation` ### Deferred Streaming Tools - `subscribe_unconfirmed_trades` - `subscribe_large_trades` - `subscribe_unconfirmed_liquidity_events` - `subscribe_confirmed_token_changes` - `subscribe_token_candle` - `subscribe_token_quotes` ### Generation Rules 1. Generate operation-specific tools from their declared query or mutation kind. query_graphql remains query-only; virtual writes use the named simulation tools. 2. Use operation.defaultSelection; accept custom fields only when allowCustomSelection is not false. 3. When blockTransactions or another operation returns txHash and indexed transaction flows, trades, or transfers are needed without a wallet, token, or pool filter, batch unique hashes through get_transaction_activity rather than issuing one request per row. 4. When another operation returns txHash and fee/resource/program context is needed, batch unique hashes through get_transactions rather than issuing one request per row. 5. Validate enum names against this map or /graphql/schema before executing. 6. Never invent fields that are not in /graphql/schema. 7. Never claim this MCP server can trade real funds, sign, submit swaps, manage on-chain wallets, forecast prices, browse external APIs, or inspect arbitrary Solana accounts. 8. For unsupported tasks, explain that the capability is not exposed by this MCP server and point to /graphql/schema for available data. 9. Prefer variables over string interpolation for user-provided values. 10. Return GraphQL errors verbatim with the failed operation name. 11. For simulation tools, keep toolDescription concise and refer clients to the separate simulation guide; preserve each operation annotations including readOnlyHint, idempotentHint and destructiveHint.