◆API reference

The node's JSON-RPC, documented

Every method the Solieum node serves, grouped the way an explorer uses them: chain, blocks, transactions, accounts, tokens, settlement, bridge, forced inclusion, search. The explorer is built on nothing else, so anything a page shows, this API returns. There is no public endpoint yet, and the reference says so before it says anything else.

Solana-shaped, not Solana

Method names match Solana's where the meaning genuinely matches, and where the node answers differently the difference is stated under the method: a transaction that would fail is refused before it gets a signature, account reads return no data, the latest blockhash comes back as a value rather than an envelope.

What a response can be trusted for

What the node says about the L2 is what it executed; what it says about Solana it read from two independent providers under byte-for-byte quorum. A block carries its own verdict on whether the dispute game could defend it, and only finalized is Solana's word.

Operator methods are not public

Five methods act with the node's keys or exist for the embedded test chain. The gateway that fronts a public deployment refuses them by name, and the reference lists them so nobody has to infer the boundary from an absence.

The node serves one HTTP endpoint. POST / is JSON-RPC 2.0; GET / and every other GET path serve the explorer, which is built entirely on the methods below, so anything a page shows, this API returns. Every explorer page ends with a raw-JSON panel that prints the exact response it was built from; when this document and that panel disagree, the panel is right and this document has fallen behind.

Written 2026-09-12 against the node as it runs on the gamma devnet chain (commit 1eeb4a8 and later). Method names match Solana's where the meaning genuinely matches. This is not a drop-in Solana RPC: where the node answers a Solana-shaped question differently, the difference is stated under the method rather than left for a wallet to discover. Reconciled with the code on 2026-09-26 (main 6631ba4): each correction below names the rpc.rs / explore.rs function that emits the field, and the machine-readable spec at the end is the authority when the two drift.

Endpoint

Public endpointNone yet. The gamma chain's node runs on the operator's machine and binds 127.0.0.1:8895. The server move (solieum-testnet/gamma/MOVE-TO-SERVER.md) puts it behind https://rpc.devnet.solieum.com; until that is live, every "public endpoint" claim is false and the site says so.
Local formhttp://127.0.0.1:8895 — RPC and explorer on the same port. Chain id 7790, solieum-testnet-gamma, genesis HURAAxUvSnGsSmLqiqx9i39XZBtBbY6JhnXeLWMPbnEp.
TransportPOST /, body {"jsonrpc":"2.0","id":1,"method":"…","params":[…]}. Positional params only. One request per body: batches are refused by the gateway and never reach the node.
Content typeapplication/json works. From a browser on another origin send text/plain: the node answers no OPTIONS preflight, and a plain-text POST needs none. The gateway in front of a public deployment answers preflights, so that workaround is for the bare node.
ErrorsJSON-RPC errors: -32700 the body is not JSON (rpc.rs handle), -32601 unknown method (the fallthrough arm of explore.rs dispatch), -32602 bad params, -32603 the node's lock could not be taken (lock_node_tracked), -32000 a refusal with the node's own reason, -32003 a transaction rejected at sendTransaction or simulateTransaction — the decode error, a signature that does not verify, or the program's error and logs (those two arms of rpc.rs dispatch), -32004 not found, -32005 a withdrawal proof build refused for now — retry (getWithdrawalProof, proveWithdrawal). A transaction that would fail is refused at sendTransaction with -32003, the program's error and logs — no signature, no fee, no record (ADR-0014).
Rate limits, keysNo API keys. A public deployment sits behind the bridge gateway (bridge/gateway/server.mjs: 40 requests burst, 4 a second per IP, 16 KB bodies) and a Cloudflare rule; the bare node has neither.
Node limitsThe node's own, on every path of its HTTP port (rpc.rs, since 2026-10-13), for when it is reached without the gateway: at most 128 connections at once, a further one answered HTTP 503 with Retry-After: 1 and a JSON-RPC error -32000 "connection limit reached: …" (its request read for at most 500 ms first); the request, line, headers and body, must arrive within 10 s of the connection, as a whole, or the connection is closed unanswered; the answer must drain within 30 s of its first byte, as a whole; a request head over 64 KiB is answered 431 with -32600; a body over 1 MiB is refused by its Content-Length, unread, with -32600 "Invalid request: a body of N bytes; at most 1048576" (on /solana as before). One request per connection (Connection: close). No rate limit per client: that is the gateway's.
ConsistencyEvery read is served from the node's own state under one lock, so a page of results is one moment of the chain, not a mix. Explorer reads replay state from an in-memory index and are cheap to make expensive, which is what the rate limit is for.

A first call:

curl -s http://127.0.0.1:8895 -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","id":1,"method":"getChainInfo","params":[]}'
{"jsonrpc":"2.0","id":1,"result":{"network":"solieum-testnet-gamma","chainId":7790,
 "genesisHash":"HURAAxUvSnGsSmLqiqx9i39XZBtBbY6JhnXeLWMPbnEp","slot":268,"blocks":269,
 "sequencer":"5QbQp2gFWL7CEHxuFY6JL85QfmLRpPq21DeDxsp1y2jR","sequencerMatchesGenesis":true,
 "l1":{…},"admission":{"executedAtAdmission":true,…},"programs":[]}}

What every response can be trusted for

The node is a rollup: what it says about the L2 is what it executed, and what it says about Solana is what it read from two independent RPC providers under byte-for-byte quorum (ADR-0013 D1). Three things the API states explicitly rather than implying:

  • defence on a block: whether the dispute game could defend that root — every step witnessed, or which steps are opaque. A block with an opaque step executed correctly and cannot be defended in a dispute.
  • Settlement state on a block or transaction: ordered, executed, published, root committed under bond, finalized. Only finalized is Solana's word; everything before it is the sequencer's.
  • Registered programs are files the operator loaded at startup, not on-chain accounts. sha256 and bytes are the node's statement about the file, not a proof, and the program set is not committed to the chain.

Chain

MethodParamsReturns
getChainInfo—network, chainId, genesisHash (the real identity), slot, blocks, sequencer (the key that signs receipts — verify against this one), sequencerDeclaredInGenesis, sequencerMatchesGenesis, l1 (settlement, DA and inbox program ids), admission (executed at admission or not, what a refusal means, and since ac07bd2 the two limits a public endpoint sets: payerRate as {max, windowSecs} or null when off, and computeCeiling in compute units per transaction or null when off; and feeSchedule, null unless the node runs --fee-schedule FILL[:MARGIN_BPS[:FLOOR]], else {targetFill, marginBps, floor, payloadBytes, price, flatFee, surcharge, recipient, enforced, exempt, note}: price is the cost of settling a block of targetFill transactions shared evenly plus the margin, never below the floor; a transaction pays flatFee as the chain's fee and surcharge as a plain system transfer to recipient (the sequencer) inside the same transaction, and when enforced one that carries less is refused at admission and charged nothing; withdrawals, transactions the recipient pays, and forced entries are never asked; not consensus — the surcharge is an ordinary transfer that replays without the schedule; the price can only fall while the node runs, so read it before signing; on GET /info too), blockTimeMs (the clock a block is made on when there is work, --block-time in milliseconds; null from a node that did not start with run), siblings ([{ name, url }], the other chains this operator runs, run --sibling NAME=URL; empty when none were named), programs (registered program ids), nativeCoin (null on a rollup chain, whose native balance is SOL bridged in through the portal; on a chain whose genesis names its own native coin, its name, ticker, decimals, the reserved id that names it, and feeBurnBps, the share of every fee destroyed), and flatFee (what one transaction costs here, in base units: a chain may name its own in genesis, where it is part of the genesis hash, and a chain that names none charges the binary's 5,000 — read the fee from here rather than assuming it), build (since d6d31a7: the first sixteen hex digits of the SHA-256 of the executable this node runs — the name the rollout script and the release gate give a build) and startedAt (when this process started serving, unix ms: a restart shows as a new value even when nobody saw the node down); both are on GET /info too and null on a node that predates them. All of the above is the getChainInfo arm of rpc.rs dispatch. indexedFrom is not on getChainInfo: it is emitted by GET /info only (rpc.rs handle, where the /info body is built separately) — the first block whose transactions this node indexed, 1 after a replay from genesis, N+1 when it was opened from a checkpoint written at block N with --checkpoint-every N (off by default); blocks below it are still served by getBlock, headers, receipts and payload, but have no transaction records in getTransaction or the address and block detail views.
getGenesisHash—The genesis hash as a string. The chain id is a convenience; this is the identity.
getSlot—The head block number.
getBlockHeight—The head block number, the same as getSlot: one block per slot, no skipped slots. A bare number, as Solana's.
getStats—Front-page counts: transactions, dropped, fees, compute units, accounts, per-block series over the last minute, ten minutes and hour, and finalization: the next root's countdown as the finalizer last measured it — nextRoot, slotsRemaining and windowSlots, secondsRemaining and windowSecs converted at msPerSlot (the cluster's observed slot time, 400 ms on the embedded L1), and the finalizer's note; the slot fields are null on a chain whose window counts seconds, and the whole object is null when no root is waiting on its window. Since 1cb47c6 (2026-09-24) rpc is the node's own timing of its answers, measured from each JSON-RPC request's parse to its answer: lastMinute (requests), p50Ms, p90Ms, maxMs, byMethod (the eight busiest, and since 240850e any other whose worst answer reached 3 s, so a stall's method is named however little it was called; each with count, p50Ms, maxMs), and since 529189c minutes, the sixty wall-clock minutes ending now, oldest first, each {t, count, avgMs, maxMs} with count 0 and nulls where nothing was answered, so a chart has a fixed timeline. It measures waiting, which nothing else here does: a maxMs at or over 3,000 is a stall by the rule node/measure-rpc.mjs uses. lockHolds lists every hold of the node's lock of half a second or more in the last hour, newest first, {at, ms, site} with the call site that took it (file:line); a hold of two seconds or more is also written to stderr. A slow answer from a method that reads nothing but the node waited behind one of these. Since 2026-09-30 pendingJournal is what the pending-admission journal (ADR-0024, pending.jsonl in the datadir) holds as the answer is made, read from the file rather than from memory: entries (its non-blank lines, one per admission journaled since the last seal) and bytes. It equals pending except after a restart that skipped entries the log had already sealed, until the next seal. The node creates the file empty when it opens its datadir, after restoring what the file held, so on such a build it exists from the start, even on a chain that has neither admitted nor sealed since. null on a node without a datadir; absent on a node that predates it; when the file cannot be read, entries and bytes are null and error says why, naming the file and not the datadir. Since K59h (2026-11-03) the file is read, and rpc copied and summarised, before the node is locked for the answer (rpc.rs stats_rpc), so neither waits on nor holds up the block producer; an admission or a seal between the two can show as pendingJournal.entries differing from pending by it. The timing window looks back through at most the newest 10,000 index records (STATS_WINDOW_EXAMINED) for its 200 samples, so on a node that ordered few of its records itself samples can be below 200 where it once walked the whole index. Since K59i (2026-11-03) the whole-index figures (transactions, dropped, forcedNoops, fees, topPrograms, tps, activeAccounts.h24, last24h) are kept as running totals and window sums, folded in as records and blocks are appended (explore.rs StatsFold), so the first call after a block no longer walks every record and instruction under the node lock; the answer is unchanged, pinned against the walk by a test. A window that would reach back further than a day and an hour before the newest block (a wall clock that far behind) is answered by the walk, as before. supplyLamports is still summed over the store.
getTimeSeries[{ range: secs, bucket: "minute" | "hour" | "day" }]Buckets over the range: series[] of t, txs, dropped, noops, deposits, depositLamports, fees, cu, blocks, activeAccounts, newAccounts, supply, burned, tps, settlementMsMedian, inclusionMsMedian, receiptMicrosMedian; totals, step, start, now. Bucket defaults to hours inside two days and days beyond; minute (60 s buckets, what the home page's last-hour chart asks for) is accepted too, and range is clamped to 1 h..400 d (the getTimeSeries arm of explore.rs dispatch, time_series_json). Since K59b only seven (range, step) pairs are answered, each kept per block and 10 s clock bucket: 1 h, 6 h and 12 h of minutes; 1 d of hours; 7 d, 30 d and 400 d of days. Any other request (never under one step) is snapped to the smallest of those ranges at least as long at the step asked for, else to the smallest one long enough at the nearest step: 5 h of hours answers as 1 d of hours, 2 d of hours as 7 d of days, a day of minutes as 1 d of hours. step and start say what was answered (series_pair).
getPrograms—Every program an executed instruction has invoked, all-time, plus every registered one even if never called: programId, name, invocations, transactions, firstSlot, lastSlot, executable, builtin (the system or compute-budget program), registered, committed (ADR-0019: the genesis names this id and these exact bytes, so the chain stands behind the hash rather than the operator alone), bytes, sha256, loader, and source (null, or the manifest beside the file: name, version, license, files, instructions, check); at the top registeredCount and committedCount (the getPrograms arm of explore.rs dispatch).
getProgramSource[programId]A registered program's source manifest, the <file>.source.json the operator put beside it: found, manifest, name, version, license, repository, commit, path, build, recorded, notes, tags, declaredSha256, declaredBytes, loadedSha256, loadedBytes, check (the node's comparison of the loaded hash with the declared one), committed (ADR-0019), files[] (path, bytes, lines — never the contents), interface[] (the instructions as declared), interfaceNote, and verifiedSource: false — the node's statement, never a badge. found: false with a reason when no manifest sits beside the file or the program is not loaded (the getProgramSource arm of explore.rs dispatch, provenance.rs ProgramSource::summary_json).
getProgramSourceFile[programId, path]One file of that manifest: path, bytes, lines, contents. -32004 when the program has no manifest or the manifest has no such file (the getProgramSourceFile arm of explore.rs dispatch).
getProgramAttestations[programId]Wallet-signed statements that the signer rebuilt the program's declared source and got its hash, each verified again when served; the program page's verified mark reads this. Read-only.
submitProgramAttestation[signedAttestation]Stores a signed attestation when its signature verifies and, on a node started with --attesters, when the signer is listed; one file per program and signer, 256 kB per program, each refusal naming the cap it hit. Needs --attestations DIR. It writes to the node's disk, so the gateway forwards it only when started with ATTEST=1. Returns the program's attestation state.
getTokenInfoStatus[mint]A token's review state: accepting, reviewRequired, admins, the pending record if one waits, and the lastReview. Read-only.
submitTokenInfo[signedTokenInfo]A token-info record signed by the mint's current authority on this chain (anything else is refused by name). On a node with --admins it waits in the registry's pending area and the served record is unchanged until an admin approves; without admins it is published at once. Needs --token-info DIR; capped at 64 kB. Writes to the node's disk, so a public gateway forwards it only when started with SUBMIT=1.
getVerificationQueue—The admin console's view: chain (the genesis hash a review must name), admins, reviewRequired, tokenInfo[] (pending records with the signed submission, decided ones with their review) and attestations[] for every program this node runs, each with status — pending, approved, rejected, or not required without --admins. Forwarded by the admin console (gateway ADMIN=1), not by the public gateway.
reviewVerification[signedReview]An admin's decision: kind (tokenInfo or attestation), chain, target (mint or program), submitter, submission (the signature of the exact submission decided), decision (approve or reject), reason, reviewedAt, reviewer, signed by the reviewer under the domain solieum-verification-review-v1\n over the same canonical JSON as attestations. Refused unless the reviewer is on the node's --admins list (wallets that can sign: the node refuses at startup a key off the ed25519 curve, such as a token metadata account or any PDA), chain is this node's genesis hash, and the submission is still the one stored; the same decision sent twice is applied once; a rejection needs a reason and frees a rejected attestation's slot. An approved attestation counts toward the check mark; an approved record goes into the token-info registry under the admin's name. Never forwarded by the public gateway — only the separate admin console (gateway ADMIN=1, bound to 127.0.0.1) or solieum-node review sends it.

Blocks

MethodParamsReturns
getBlock[slot]One block: slot, blockHash, parentHash, blockTime, stateRoot, batchHash, txRoot (ADR-0021 D6: the binary Merkle root over the block's wire transactions), transactionCount, droppedCount, transactions (the hashes), and defence (rpc.rs block_json).
getBlocks[limit = 20, max 200]The newest N blocks, newest first, same shape. Since K59h (2026-11-03) one call renders at most 4,096 transaction hashes (GET_BLOCKS_MAX_TXS, one full block): blocks are added newest first while their hashes fit, and the newest block is answered whatever it holds, so past the bound the list is shorter than limit (page with getBlocksPage, or read one block with getBlock). An answer within the bound is unchanged, byte for byte.
getBlockDetail[slot]The explorer's block page: the block, its transactions with status and fee, its ordering receipts, the accounts and programs it touched, its settlement state on Solana (batch, root account, commitment signature, finalization, and the challenge window as windowSlots and windowSecs, converted as getSettlement.window_secs), defence, and sequencer: the key that signed this block's ordering receipts (with sequencerIsCurrent, whether that is the key the node signs with now), null when no receipt is held for the block, because a block does not say who ordered it except through its receipts. Beside it, sequencers lists every key that signed a receipt in the block (sequencer is null when that is not exactly one) and sequencerSource is receipts or none (the getBlockDetail arm of explore.rs dispatch). Since K59i (2026-11-03) the page is made under the node lock and its receipts (at most 200, MAX_BLOCK_RECEIPTS, with receiptsTotal and receiptsTruncated) are verified after it is released, as getReceipts' are (rpc.rs block_detail_rpc); the answer is unchanged, and each receipt is still re-verified on every read.
getBlocksPage[before?, limit = 25, max 100]Blocks newest first with a cursor: head, blocks, nextBefore. Each block row (and getBlockDetail.settlement) carries resettled: true for a block whose root was posted again after a restart of this node — its settle wait spans the outage, so the settlement-time medians in getStats.timing leave it out (resettledSamples); this is how to tell which blocks those are. Each row also carries settleSignature, the L1 transaction that committed the root, kept in this node's timing log so it survives restarts (null on an embedded L1, which has no public transaction, and for a block this node did not commit or committed before 2026-09-22's build); the blocks page opens it on Solana Explorer and Solscan; and rootAccount, the root's account on the settlement program for every settled block, which the page opens instead when no transaction is on record.
getBlockPayload[batchHash]The published bytes for a batch, compressed exactly as posted to Solana, so a verifier can re-derive the block from them.

Transactions

MethodParamsReturns
sendTransaction[txBase64, { encoding: "base64" }]Executes the wire transaction at admission, at the exact position it will occupy. Success returns the signature of a transaction that will land in the next block. Failure returns the program's own error and logs, and nothing else happens: no fee, no position, no receipt. A node with admission limits set also refuses, as a JSON-RPC error and before anything executes, a payer over its rate (message starting rate limited: … try again in N s) or a transaction over the compute ceiling (refused: this transaction used N compute units and this node admits at most M); neither charges or orders anything, and getChainInfo.admission says which limits are on. On a chain whose portal has a SOL payout cap (getBridge.limits.payoutCap), a withdrawal above it is refused the same way, since the portal would pay it in no window (withdrawal refused: N lamports is more than the portal's payout cap of M lamports per window, K50; the cap as the node last read it, at most 60 s old). A string is a Solana wire transaction, in base64 (the default) or base58; transactions above Solana's 1,232-byte limit are refused, as the decode error. When the block being filled is full the refusal starts the block being filled is full and the same transaction is taken by the next block. The object form is a testing shape.
simulateTransaction[txBase64, { sigVerify: false }]The same execution, committing nothing. sigVerify defaults to false, as Solana's does. Carries exact: true: the sequencer running the simulation is the sequencer that will execute it. Node-only; the public gateway on 8897 refuses it (not in ALLOW, bridge/gateway/server.mjs).
getLatestBlockhash—blockhash, lastValidBlockHeight. Returns the value directly, not Solana's { context, value } envelope; web3.js's Connection asserts the envelope and fails, so call it raw.
isBlockhashValid[blockhash]Whether a blockhash is still inside the replay window.
getSignatureStatuses[[signature, …]]{ value: [...] } with no context beside it: value[] of slot, confirmations, confirmationStatus, err; a transaction refused at execution answers confirmed with err set to { dropped: <the reason>, feeCharged } — the drop and the fee outcome are inside err, not beside it; one seen but not yet in a block answers processed with null slot and confirmations; an unknown signature is null in its slot of value. At most 256 signatures a request (/solana's cap), checked before the node is locked: more is -32602 "Too many inputs provided; max 256" (the getSignatureStatuses arm of rpc.rs dispatch).
getTransaction[signature | hash]Locate a transaction by either identity — the 64-byte signature a wallet holds or the 32-byte hash the block index uses: hash, signature, slot, blockTime, and for a dropped one dropped, reason, feeCharged.
getTransactionDetail[signature | hash]The explorer's transaction page: status (success, failed, noop, pending), err with the reason, fee and fee payer, compute units, recent blockhash, every account with its pre/post balance and role, each instruction parsed, program logs, the ordering receipt re-verified on read, settlement (where the block stands on Solana, as on getBlockDetail), timing, and forcedIndex: the forced-inclusion inbox entry the transaction came from, or null. The record says, when the node knows: a transaction it admitted itself (a wallet's, or an entry it drained), a deposit, or an executed forced record, whose bytes name the entry. Only a record rebuilt by replay on a chain below the binding version, where a forced transaction is published as the same kind-1 record as a wallet's, is matched against the inbox's payloads, a cluster read on a settling node, taken before the node is locked (240850e; until then it was taken under the lock for every transaction, and a provider slow to answer held every other request behind one page: 10.1 s on gamma, 2026-09-25; 91 s with the provider timing out, 2026-09-26). That page alone waits for it.
getRecentTransactions[limit = 25, max 200, before?]Indexed transactions newest first: total, transactions, nextBefore. Each row carries signature, slot, blockTime, feePayer, signers, instructions (count), programs (each with its type, Token program instructions named by tag), value (lamports the system program transferred, not rent), tokens (each mint touched with name, symbol, logo, kind, action, amount and amountUi), fee, status and, when failed, err.
getPending[limit = 50, max 500]Admitted, ordered under a receipt, waiting for the next block.
getDropped[limit = 20, max 500]Transactions ordered, published and refused at execution — forced entries, since ADR-0014 nothing else can fail in a block — with slot, signature, reason, feeCharged.

Accounts

MethodParamsReturns
getBalance[pubkey]Lamports, as a bare number, not Solana's { context, value } envelope.
getMinimumBalanceForRentExemption[space]Lamports that make space bytes rent-exempt, (space + 128) × 6,960, from the runtime's own rent rule. A bare number, as Solana's; what spl-token, wallets and CRADLE's builder ask before creating an account.
getAccountInfo[pubkey]lamports, owner, executable, dataLen, nonce, returned directly rather than in Solana's { context, value } envelope; null for no account. No account data: this returns metadata only. Token balances come from the token methods below, a program's bytes from getPrograms.
getAddressDetail[pubkey]The explorer's account page: the account, its labels (sequencer, program, bridge roles), what funded it and when, transaction and transfer counts, first and last seen, balance history, its data as base64, and what Solana holds at the same address (l1: its roles there, and lamports, read for an address this chain does not hold or one with a role on Solana). On a node settling to a cluster, l1.lamports comes from the page cache since 240850e, as getSettlement's figures do: read live the first time an address is asked for, served as read while under 2 s old, and once older served with one refresh started behind it; a failed read is not kept. It read live on every view before, 20.8 s for the sequencer's page on gamma while the provider throttled.
getSignaturesForAddress[pubkey, { limit = 25, before? }]Transaction history newest first: address, total, transactions (each with change for this address), nextCursor.
getTransfersForAddress[pubkey, { limit = 25, before? }]Lamport movements the address took part in, from parsed instructions: address, transfers[] of from, to, lamports (the amount — the key is lamports, not amount), direction (in, out, self), toL1 (a withdrawal through the L2 bridge program), signature, hash, slot, blockTime, instruction, programName, cursor; a bridge credit is a row with fromL1: true, the L1 depositor as from and programName Bridge portal (L1 deposit); nextCursor (transfers_for_address, from the getTransfersForAddress arm of explore.rs dispatch). One call examines at most 50,000 of the address's records (MAX_RECORDS_EXAMINED, since K59b): a call that stops there answers with the rows it found, possibly fewer than limit or none, and a nextCursor to pass as before; only a null nextCursor means the history is exhausted.
getTopAccounts[limit = 50, max 500]Supply and the richest accounts: count, supplyLamports, genesisLamports, burnedLamports, keptLamports, sequencerLamports, accounts[] with rank, address, lamports, share, labels, txCount.

Tokens and NFTs

The chain executes whatever token program the operator registered at startup; nothing here is Solieum's own. On a chain with no token program registered — gamma today — these methods return honest empties (programs: 0, and getTokens says a mint cannot exist here). A token transfer is a witnessed step class the dispute game can execute; InitializeMint, InitializeAccount and MintTo are opaque, so a token moves under proof and is created under trust. Amounts travel as strings in the token's own unit, divided exactly on the node.

MethodParamsReturns
getTokenPrograms—The token programs registered on this chain: programId, name, bytes, sha256, loader, mints, tokenAccounts, invocations; metadataProgram if Metaplex Token Metadata is registered; registered; and a note stating the proof boundary.
getTokens[limit = 100, max 500, kind?]Every mint, most held first: mint, program, programName, kind (nft for decimals 0 and supply 1, else fungible), decimals, supply, supplyUi, mintAuthority, freezeAuthority, holders, tokenAccounts, txCount, firstSlot, lastSlot, metadata (name, symbol, uri and creators when the metadata program is registered and the account exists; otherwise found: false with the reason). kind = "nft" or "fungible" filters. Totals: count, nfts, fungible, tokenAccounts, programs. Any other kind string is refused with -32602 (since K59). The sorted list is made once per block for each of the three kinds and kept; a call answers with its first limit rows, and a token-info registry reload makes a new list (tokens_kept, from the getTokens arm of explore.rs dispatch).
getTokenDetail[mint]The token page: the mint as above plus holderList[] (tokenAccount, owner, amount, amountUi, share, state, delegate, delegatedAmount) largest first (ties by address), at most 1,000 rows since K59c (MAX_HOLDER_LIST): the largest, then holderListTotal (how many token accounts the mint has, the list's length uncapped; the same count as tokenAccounts) and holderListTruncated (true when rows were left out). Before K59c every account was listed. The last 25 transactions that touched the mint, dataLen. found: false with a reason for a non-mint.
getTokenAccountsByOwner[owner, {after}?]A wallet's token balances: accounts[] of tokenAccount, mint, kind, program, amount, amountUi, decimals, state. Since K59h (2026-11-03) a page of at most 1,000 accounts (TOKEN_ACCOUNTS_BY_OWNER_MAX), in the owner's token-account order (by key bytes): anyone can open token accounts owned by any wallet, so the list was anybody's to grow. total is how many token accounts the owner has, truncated whether this page stopped short of them, and nextAfter the last account shown when it did (else null); pass it as {"after": nextAfter} at params[1] for the next page. An after that is not a base58 pubkey is -32602.
getTokenAccount[pubkey]What a token-program-owned account is: kind: "account" with mint, owner, amount, amountUi, tokenKind; kind: "mint"; or kind: "other". null for an account the token program does not own.
getCollections—NFTs grouped by the collection their Metaplex metadata names: collections[] of key, name, symbol, uri (from the collection mint's own metadata when it has one), items, verified (memberships the collection authority signed), holders, firstSlot, lastSlot, collectionMintExists; nftsWithMetadata, nftsWithoutCollection, metadataProgram. Empty, with the reason, where no metadata program is registered.
getCollectionDetail[collectionMint]One collection: the fields above plus itemList[] (mint, name, symbol, uri, verified, owner, firstSlot, lastSlot) and activity[], the members' token movements newest first in getTokenTransfers' shape. No floor, volume or listings: no marketplace exists on this chain. Since K59g itemList holds at most 1,000 rows (MAX_COLLECTION_ITEMS, as many as getTokenDetail's holderList), with itemListTotal (every member, the list's length uncapped; the same count as items) and itemListTruncated (true when rows were left out): membership is what a member's own metadata claims, which an unverified mint claims for free. Within the cap the list is every member in mint order, as before; cut, the verified members come first, then the unverified, each in mint order. activity is the listed members' moves, and its walk examines at most 50,000 records (MAX_RECORDS_EXAMINED); a walk stopped there answers what it found and activityTruncated: true (absent otherwise) (collections_json, from the getCollectionDetail arm of explore.rs dispatch).
getTokenTransfers[{ mint?, owner?, tokenAccount?, limit = 25, max 200, before? }]Token movements newest first — Solscan's transfers tab, and an NFT's activity: transfers[] of kind (transfer, mint, burn), mint, source, sourceOwner, destination, destinationOwner, authority, amount, amountUi, decimals, signature, slot, blockTime, status; nextBefore for the next page. Filter by a mint (every account holding it, plus mints and burns), a wallet (its token accounts) or one token account. With both mint and owner, a move is kept when it touches one of that owner's token accounts of that mint; since K59g, a deliberate change: before, every token account of the mint passed the owner test, so { mint, owner } answered about every move of the mint. A plain Transfer names no mint; it is resolved from the token account, and reads null if that account has since been closed. One call examines at most 50,000 records (MAX_RECORDS_EXAMINED, since K59): a call that stops there answers with the moves it found, possibly fewer than limit or none, and a nextBefore to pass as before; only a null nextBefore means every watched record was examined (token_transfers, from the getTokenTransfers arm of explore.rs dispatch).
getTokenActivity[{ mint, limit = 50, max 200, before? }]Every token-program instruction that touched the mint or one of its accounts, newest first, named by tag the way the program's own unpack reads it — Solscan's activities: the value moves the transfers list shows and everything around them that moves no value (accounts opened and closed, approvals and revokes, freezes, authority changes). events[] of kind, tag, instruction, mintResolved, accounts[] (role, address, owner), amount and amountUi for the value-bearing kinds, signature, hash, slot, blockTime, status, err; records (indexed records in the mint's history), nextBefore (the getTokenActivity arm of explore.rs dispatch, token_events).
getNftActivity[{ limit = 50, max 200, before? }]Every token move on an NFT-shaped mint, chain-wide, newest first, each in getTokenTransfers' row shape plus collection (the key the member's metadata names, or null) and index; nextBefore, nftMints. No price or marketplace columns: this chain has no source for them (nft_activity, from the getNftActivity arm of explore.rs dispatch). Since K59g a move's mint is looked up in the token scan and nftMints is counted once per block, rather than a set of every NFT mint built per call; the answers are the same. One call examines at most 50,000 records (MAX_RECORDS_EXAMINED, since K59b): a call that stops there answers with the events it found, possibly fewer than limit or none, and a nextBefore to pass as before; only a null nextBefore means every record was examined.
getTokenSeries[mint, { range: secs, bucket: "hour" | "day" }]The mint's movement over time from the index: series[] of t, transfers, mints, burns, volume, volumeUi, active; totals (the same sums plus activeAccounts and holdersNow), range, bucket (seconds), decimals, note. Holders are reported as they stand now — the index keeps no balance history, so no holder curve is drawn (the getTokenSeries arm of explore.rs dispatch). Bounded since K59g: at most 1,440 buckets (MAX_SERIES_BUCKETS, getTimeSeries' own cap: sixty days of hours; every day bucket up to the 400-day range fits), the range cut to bucket × 1,440 past it as getTimeSeries cuts its own (range says what was served: hours over 400 days were 9,600 buckets); and at most 50,000 records examined (MAX_RECORDS_EXAMINED), newest first. A series stopped there counts the newest records and says so with truncated: true, recordsExamined and countedFrom (the timestamp of the oldest record counted: records at or before it may be missing, so buckets up to it are partial); those fields are absent otherwise. A series is not paged: active counts distinct accounts, which two pages cannot be added into. holdersNow comes from the scan's per-mint tally.
getTokenInfo[mint]The signed token-info record for a mint from the operator's registry (--token-info DIR): the payload as the issuer submitted it (name, symbol, logo, …) plus found: true, signatureVerified, authority (current when the signer still holds the mint authority, stale when it does not, unknown when the mint has none), verifiedAt, verifiedBy, file, source, signature; found: false with a reason (and the registry path when the mint simply has no record). The same record rides as info on every mint of getTokens and getTokenDetail (explore.rs token_info_json, provenance.rs TokenInfo::json). Node-only; the public gateway on 8897 refuses it (not in ALLOW, bridge/gateway/server.mjs).

What Solscan's token and NFT API has that this one does not

Stated so nobody infers it from an absence. Solscan serves prices, market caps, trading volume, DeFi activities, staking and NFT collection or marketplace data. None of that exists on a Solieum devnet chain: there is no market, no DEX, no staking and no marketplace, and the node reports nothing it did not execute. A token's name, symbol, image and creators appear only when the Metaplex metadata program is registered on the chain and the mint has a metadata account; a collection is a metadata concept and appears with it — getCollections groups members by the collection their metadata names, and says whether the collection's authority verified each membership or the member merely claims it. Everything else on this page — supply, holders, balances, transfers, mint and burn history — is on-chain fact the node serves today.

Settlement and receipts

MethodParamsReturns
getSettlement[recent = 10, max 100]L1 mode, head_number, head root, batches sealed, finalized_head, unfinalized, max_unfinalized (2026-10-26: the cap on unfinalized as the chain record holds it, read from the settlement program's chain account, never from the node's flags: the program takes no root at it, TooManyPending 6009, until the oldest finalizes. Written once, at the chain's first start, by run --max-unfinalized N or the default 4096; the program has no setter. On a cluster read through the page cache like the head; null when the chain account was not read; absent on a node that predates it), min_challenger_bond (2026-11-11: the least bond, in lamports, the chain record lets a challenge post, ADR-0055 §1.13, read from the same chain account by the decoder the node's own challenge uses; written by initialize and, on a commitment-v11 chain, never changed after it; null when the chain account was not read; absent on a node that predates it), window_slots and window_secs (the window in seconds, converted by the node at the rate its finalizer waits by: the cluster's observed slot time, 400 ms on the embedded L1, and not converted at all on a chain whose window counts seconds; null when the chain account was not read), recent finalizations, why the finalizer last stopped, dispute_authority and disputes_enforceable, open disputes, payer_status (balance, floor, runway in blocks, alarm), alarms (bridge, L1 read, reader count, bond: why a bond is smaller than what it secures, null unless the node runs --fee-policy enforce and its last bond check found one short, and settleConflict: a record L1 holds under the number of the block being settled that is not that block's — a root that differs from the node's own block in any field the block fixes, a sealed DA batch holding other bytes, or one closed for its rent and so not comparable — in which case the block is not settled, nothing is sent over the record and settlement stops there until an operator resolves it, null otherwise and cleared once a block settles; fenceBlind (K52): why the node signs no new receipt and drains nothing — its last DA feed reading was refused, or, on a chain that settles to a cluster, the newest reading the readers agreed on began more than 20 s ago (FENCE_READING_MAX_AGE_MS, 2026-10-19: the feed is read off the producer thread), in the same words either way; it lifts by itself at the next reading young enough; inboxStale (2026-10-19): the L1 reader has not read the forced-inclusion queue for a minute (it reads every 2 s, or every block time if longer), so deposits and forced transactions wait while blocks of L2 transactions go on; null while it reads, on an embedded chain, and while fenceBlind is raised; raised includes all of them), economics, blockCost, feePolicy, feeSchedule (as admission.feeSchedule in getChainInfo; null without --fee-schedule) and bondAdequacy (null until a node under --fee-policy enforce has run its five-minute bond check: valueAtRisk — what the bridge can release in one challenge window, the vault or under the portal's payout cap the cap times the cap windows in windowSecs, never more than the vault, null when it could not be read — sequencerBond against sequencerRequired (the value at risk; a bond counts only when it backs this chain and is not slashed), proposerBond against proposerRequired (what a challenge over longestTraceSteps, the longest trace still disputable, costs the challenger), proposerBondBpsOfValueAtRisk as disclosure, adequate, alarm; reported only, it never stops the node). economics carries, beside the running totals, surcharges (the transfers paying transactions carried to the sequencer, counted only on a node with a schedule), subsidy (what the payer covered, summed over blocks: each block's sunk cost less its fees and surcharges, never below zero) and lastBlockSubsidy; coversCost is still judged at the flat fee alone. blockCost prices a representative 226-byte block with the rents this node has SEEN come back (2026-09-30): rootRentReclaimable / batchRentReclaimable are true once a close it sent landed or its closer found a record already closed (never assumed from the program set), rentReclaimable is either of them (it used to mean both, and was hard-coded false), closeFees is one close transaction per returned rent (each close pays its own signature, so sunk counts it and float is net of it; outlay is unchanged), and breakEvenTxs is sunk over the chain's fee, rounded up — at 5,080 lamports per byte 705 with no reclaim, 452 with the batch's, 3 with both. closerNote leads with the roots the closer steps over for good because the settlement program cannot load them (shorter than the 314-byte layout: gamma's 274-byte pre-D6 roots 1-292), which it never sends. window_units says which clock the window counts (seconds since the ADR-0016 amendment of 2026-09-22, slots on a chain that has not moved); window_secs is the record's own figure on a seconds chain and a conversion at the finalizer's observed slot rate on a slot chain; window_slots is 0 on a chain created in seconds; slot_stamped_through is the last root that keeps the slot rule after a migration. On a cluster, da_poster is the DA feed's poster and da_poster_is_payer says whether it is this node's payer: the feed refuses every post from any other key, so false means the next block will stall. On a cluster the chain account, the payer and the vault are read for this method through a page cache (e13d7d5, 2026-09-24): a report is served from the last checked read, refreshed behind it once older than two seconds, and — since 983426e — never waits on the cluster past the very first read; readsAgeMs (f8fbaa9) says how old that read is, null on a chain that reads in-process. It is the page cache's age and nothing else: on a node nobody reads it is the time since the last report, while the reader threads go on (found 2026-10-29, solieum-testnet/drills/records/2026-10-29-post-cut-soak-window.md: 91 s on both cluster chains at 40 reads a minute). l1ReaderAgeMs (2026-10-29) is the readers' own freshness: ms since the L1 reader threads' newest readings, the older of the DA feed reading the readers agreed on (every 5 s, FENCE_FEED_READ_MS) and the inbox snapshot (every 2 s, INBOX_READ_EVERY_MS), each from when its call began — the figure fenceBlind's age rule and inboxStale judge; null in-process and until every reader has taken its first reading; absent on a node that predates it. The settler and the finalizer never read through the cache. l1Requests (69be996) is how hard this node leans on each provider: one row per reader host, lastMinute and total reads reserved at its pacer — the number to hold under the provider's budget, which for the public devnet tier answered 429 with Retry-After 10 s past 50 calls per method per 10 s per IP on 2026-09-24, silently honoured by the client as a flat ten-second wait. Empty on an embedded chain. Each recent row's tokens lists the mints its block's transactions named, once each (explore.rs block_tokens_json); since K59h (2026-11-03) one call reads at most 8,192 index records for them (SETTLEMENT_TOKEN_RECORDS, two full blocks), a block whole or not at all, in row order, and a row whose block would take the call past that has tokens: null (not read for this answer, as against [], none moved). The first row's block is always read.
getBatchDetail[seq | batchHash]One DA batch: batchSeq, batchHash, block, stateRoot, payloadBytes, compressedBytes, chunks, rootSubmitted, signature, batchAccount, attempts, its transactions and settlement state.
getSequencerReceipts[limit = 20, max 500]The raw ordering commitments: orderHash, chain, batch, position, l2Slot, sequencer, signature. Anyone can check these against a published block; a mismatch is provable equivocation. chain follows the same rule as on getReceipts below: the genesis hash for a receipt signed since 2026-09-13, the all-zero hash for one signed before. Node-only; the public gateway on 8897 refuses it (not in ALLOW, bridge/gateway/server.mjs) — getReceipts is the forwarded list.
getReceipts[limit = 50, max 500]The same, newest first, each re-verified against the signing key: total, receipts. This is the list a page should show. Since K59h (2026-11-03) the receipts are copied under the node lock and verified after it is released (rpc.rs receipts_rpc); the answer is unchanged. Each receipt carries chain, the base58 genesis hash of the chain the promise was made on, inside the signed bytes (ADR-0012, closed on 2026-09-13): a receipt signed before that names no chain and shows the all-zero hash (32 ones), verified under the original 53-byte layout; one signed since always names its chain, 85 signed bytes. The receipt in a transaction's detail carries the same field.
getReceipt[orderHash]One receipt re-verified, with the block and position it was honoured at.
getSequencerBond[pubkey?]The bond posted under the shared bond program for a sequencer key (default: this chain's): amount, slashed, unbond state, the PDA; from Solana, read under quorum. Since 2026-09-13 a bond names the chain it backs: chain is this chain's genesis hash, backsThisChain is true, false, or null when there is no bond or it predates the field, and note reads BONDED ELSEWHERE when the bond found on the cluster backs another chain. Inside bond: chain, the chain it backs (null for a bond written before the field), and layout, chain-bound or predates-chain, the latter naming the migration. Against devnet's bond program every bond still reads as predates-chain until that program is upgraded and the bonds migrated.

getSettlement.root_budget (2026-10-26, ADR-0036 option D, run --root-budget-reserve N; snake_case beside max_unfinalized): the producer's hold against the cap that max_unfinalized reports. null on a node started without the flag (the default) and absent on one that predates it. On, a non-empty block is sealed only while unfinalized + queued + reserve <= max_unfinalized, the chain record as the producer last judged by it (on a cluster the same page cache this method is served from, so up to a few seconds old; queued is the blocks produced and not yet committed on L1, a settle window in flight included). Admission goes on and every receipt is signed through a hold; only the seal waits, so under load transactions merge into fewer, larger blocks and settlement never stops at the cap. Fields: reserve, unfinalized, max_unfinalized, queued, holding, held_since_ms, held_block and held_txs (null when not holding), holds and held_txs_total since start, and alarm: why the hold is NOT applied when it is not (the record unread or its read refused, or a reserve not below the record's cap), in which case blocks are produced as if the budget were off and alarms.rootBudget carries the same text, counted in alarms.raised. A block carrying a forced entry or a deposit within 60 s of its L1 deadline (ADR-0004, ADR-0029), or one at 3,072 records or 2,000,000 published bytes, is sealed regardless. "Confirmed" (the root on L1) is slower under load than 100 ms blocks would make it if the cap allowed them, never faster; the range root (ADR-0036 option A) is the real fix. DEPLOYMENT.md §4.4a.

Bridge and withdrawals

MethodParamsReturns
getBridge—The bridge as this chain sees it: portal, relay, vault and vaultLamports, deposits credited (with each entry's rent; the 50 newest, newest first), withdrawals with the portal's provenAt and paid (the 50 newest, newest first: by the block that carried the leaf, then the transaction's place in it; until 2026-10-11 this listed the 50 largest ids instead, a hash's order, so a new withdrawal could be missing), totals (bridgedIn, committedOut, paidOut: every withdrawal L1 has paid, by the node's own record of payouts as its drains read them, plus any listed row this call reads as paid that the record does not hold yet; a payout outside the 50 listed joins at the node's next drain; until 2026-10-13 paidOut summed the listed rows alone, so past 50 withdrawals it left older payouts out), fees, queue, windowSlots and windowSecs (converted as getSettlement.window_secs), and solvency: payable (vault less its rent floor), paidOut, outstanding, margin, covered — the admission guard's own snapshot from the node's last drain and the figures it refuses against (ADR-0013 D2), so right after a payout totals.paidOut and vaultLamports, read on the call, can lead them by one drain; all five read null until the node's first drain after a start, meaning not-read rather than zero, and ledgerFault names the fault when L1 records more paid than was committed. Also on the response: inboxProgram, queue (the forced-inclusion program and its queue account), settlementProgram, l2BridgeProgram (the reserved L2 program a withdrawal is addressed to), finalizedHead, head, windowUnits, and limits (ADR-0013 D5: initialized: true with asset, windowSecs, depositCap, payoutCap, largeThreshold, largeDelaySecs, windowStart, depositedThisWindow, paidThisWindow when the portal carries a limits record; initialized: false with a note otherwise — an absent record means unlimited on every axis). configured: false with a note on a chain that names no portal (explore.rs bridge_view and bridge_json).
getDeposits—The inbox entries that are bridge deposits (the portal's relay submitted them), each with where it stands: deposits[] of entry, entryAddress, seq, depositor, recipient, lamports, deadline, then four facts reported apart and one state derived from them (see "How a deposit is credited" below). marked: the entry's included flag on L1. refunded: whether the portal holds a refund record for the entry; null when that record was not read (the newest 100 deposits' records are read, and a refused read reads null for all of them), which is not "not refunded". credited: true only when a block of this chain credits the entry, by a kind-3 record naming its index, with that block in creditedInBlock (null otherwise); it is the chain's own record, never L1's mark. consumed: the entry's index is below the chain's watermark (getForcedQueue.consumedUpTo). state is the first of these five that holds, and the strings are stable: credited; refunded on L1, not credited (a refund record was read; the chain has not credited the deposit and will not); consumed without credit (consumed, not credited, no refund record seen; the chain will not credit it); marked, awaiting credit (marked on L1, not yet consumed); queued (unmarked, not consumed). Until 2026-10-05 credited was the entry's included flag on L1, which is also set on a deposit still awaiting its credit, and on a refunded one that was marked afterwards and is never credited. Plus configured, portal, relay, total. On a cluster marked and refunded are read through the page cache (the entries' age is getForcedQueue.readsAgeMs), so they can trail credited and consumed, which are the node's own. No entryRent here: an entry's rent is read on getBridge's deposit rows only (rpc.rs deposits_json). configured: false with a note on a chain that names no portal.
getWithdrawal[id]A withdrawal initiated on the L2: amount, recipient, the block whose tree holds its leaf, rootFinal, status (waiting, provable, proven, paid, by the same rule as getBridge's rows), and what the portal records once proven.
getWithdrawals[recipient?, sinceBlock = 0]Every withdrawal leaf this chain carries, newest block first, optionally filtered by recipient and start block: id, amount, recipient, sender, block — L2 state only, no portal read (the getWithdrawals arm of rpc.rs dispatch). The list a fast-exit provider polls. Node-only; the public gateway on 8897 refuses it (not in ALLOW, bridge/gateway/server.mjs), so a provider polls the node directly.
getWithdrawalProof[id, block = head]The proof bytes the portal's prove_withdrawal takes, built from the state tree at block by root-verified replay: id, block, stateRoot, amount, recipient, proof, proofBytes. Ask for the block whose root is final on Solana (getSettlement.finalized_head), not the newest. The tree is built with the node unlocked, one block at a time, and kept for 120 s; a request the kept tree serves is answered from it and never refused. Otherwise, while another block's tree is being built the answer is -32005 "a withdrawal proof for block N is being built; retry", given before the head's state is copied (rpc.rs proof_plan); and a build for a block below the head starts at most once per PROOF_REPLAY_GAP (2 s): a second one within it is -32005 "a withdrawal proof below the head was started N ms ago; such builds start at most once every 2000 ms; retry", while a request for the head is never held back by the gap (ProofCache::resolve). withdraw-l1 --prove retries -32005, matched by code, up to 10 attempts 2 s apart; any other error ends it at once. A rebuilt root that is not the one the block committed is -32000 (no proof is given), and a request that waited on a build for its block that failed is -32000 "the withdrawal proof build for block N failed; retry".
getDepositLedgerProof[index, block = head]ADR-0050, from commitment 11: inbox entry index's deposit-ledger leaf in the state at block and the sparse proof at its key: index, block, stateRoot, outcome ("credited", "passed", or null for an empty key), proof, proofBytes, note. No version writes passed (ADR-0051 retired it; the outcome stays reserved), so the answer is credited or null; the portal's refund_uncredited takes the entry's PASSED consumed leaf instead (getConsumedProof). Built through the same cache as getWithdrawalProof, with its -32005 refusals; a chain below commitment 11 is -32004 before anything is built (rpc.rs deposit_ledger_proof_rpc).
getConsumedProof[index, block = the block that consumed it]ADR-0051, from commitment 11: inbox index index's consumed leaf in block's step tree and its sparse proof under that block's transactions_root: index, block, transactionsRoot (hex), member, leaf (disposition "passed" / "credited" / "executed", dispositionCode, payloadHash, recordPosition, firstStep, null when the record contributed no step; null for an absence proof), proof (hex), proofBytes, note. What bind_entry_step / bind_deposit_step, a challenger's refute_consumption and the portal's refund_uncredited (a PASSED leaf under a final root) present. Built under the node lock from the steps it recorded; a chain below commitment 11 is -32004 before anything is built, as is an index no block this node holds consumed (rpc.rs consumed_proof_rpc).

How a deposit is credited

A deposit is an inbox entry the portal's relay submitted. The node credits it on the L2 only once L1 shows two things, read in this order: the entry is marked included, and the portal holds no refund record for it. The node sends the mark itself, before the credit. So "marked on L1" does not mean "credited", and the prefix L1 shows marked is not what the chain has consumed.

A deposit that is still unmarked 300 seconds before its deadline, or that the portal has refunded, is consumed without credit: the block carries a kind-2 record of its payload, nothing is minted, and the node never marks it. The portal's refund_deposit pays an unmarked deposit back to its depositor once the entry's deadline has passed.

getDeposits says where each deposit stands, from four facts it reports apart (marked, refunded, credited, consumed) and the state they add up to. getForcedQueue reports the chain's watermark (consumedUpTo) beside L1's marked prefix (markedUpTo).

On an embedded L1 the whole rule can be driven in a test: refundDeposit sends the portal's refund_deposit, warpClock crosses the deadline, and run --embedded-queue-sequencer makes L1 refuse the node's marks (see "The embedded L1's testing methods" below).

Forced inclusion

MethodParamsReturns
getForcedQueue—The L1 inbox as recorded, and how far this chain has consumed it: entries with index, address, bytes, deadline, secondsRemaining, included (L1's mark on the entry), consumed (the entry is below the chain's watermark: a block of this chain has taken it), overdue (past its deadline with neither); consumedUpTo, the chain's own forced-inclusion watermark, which is what each batch declares; markedUpTo, the prefix L1 shows marked included; queued, the entries neither marked nor consumed; program, queue, configured. The two prefixes differ in both directions: a deposit is marked before the chain consumes it, so markedUpTo can be ahead; an entry whose mark L1 has not accepted, or a deposit consumed without credit (never marked), is consumed and unmarked, so it can be behind. Until 2026-10-05 consumedUpTo was the marked prefix, and queued and overdue counted every unmarked entry, consumed or not. There is no quorum field: rpc.rs forced_queue_json emits none — a reader set that disagreed is refused as a whole and reported as getSettlement.alarms.l1Read. secondsRemaining and overdue are read against the node's clock: the wall clock on a cluster, and on an embedded L1 the clock warpClock moves, which is the clock its entries are stamped by (until 2026-10-05 the wall clock there too). An overdue entry means the chain has faulted on a censorship deadline (ADR-0004). configured: false with a note when no forced-inclusion program is wired. Since b49141a readsAgeMs: how old the cluster read the entries came from is — the inbox page cache, served as read while under 2 s old and refreshed behind the page once older, as getSettlement.readsAgeMs — null on a chain that reads in-process, absent on a node that predates it; getDeposits and getForcedEntry read the same cache.
getForcedEntry[index]One entry with its decoded bytes (parses, feePayer, instructions, recentBlockhash), included, consumed and overdue as on getForcedQueue, deposit (the entry as getDeposits lists it, with its state, when the portal's relay submitted it; null for any other entry) and transaction, the record it became once consumed: for a credited deposit the credit's own record, for a deposit consumed without credit a no-op record.
MethodParamsReturns
resolve[query]What a string is, decided server-side where every index lives: { kind: "block" | "tx" | "address" | "token" | "batch" | "receipt" | "unknown", key }. Accepts a slot number, a base58 address, a signature, a block, batch or state-root hash, a mint, or a name such as "sequencer" or "system program".

Operator and testing methods — not public

These act with the node's own keys or exist for the embedded test L1. The gateway refuses them by name (NEVER in bridge/gateway/server.mjs), and a public deployment must not expose the bare node.

MethodWhy it is not public
submitForcedEnqueues a forced-inclusion entry paid by the node's payer, and every entry is an obligation the sequencer must include or fault its chain. A real submitter sends the same instruction to the inbox program from their own wallet; getForcedQueue names the program and the queue account.
submitDepositEmbedded L1 only: deposits as the embedded proposer. On a cluster a depositor calls the portal from their own wallet.
proveWithdrawal, finalizeWithdrawalEmbedded L1 only. On a cluster the bridge does both from the wallet (withdraw-l1 --prove, --finalize). proveWithdrawal is refused before any proof tree is planned when the node cannot send the proof — -32000 "settlement is not wired", "no portal is loaded on the embedded L1", or, on a cluster, "use solieum-node withdraw --prove against a cluster" — or when the head holds no such id (-32004 "withdrawal ID is not in block N's state"), so such a request builds nothing (rpc.rs prove_withdrawal_rpc). Otherwise its tree is built as getWithdrawalProof's, with the same -32005 refusals.
warpClockEmbedded L1 only; refused on a cluster by name.
refundDepositEmbedded L1 only; refused on a cluster by name. There a depositor sends the portal's refund_deposit from their own wallet, and the node never does.

The embedded L1's testing methods

Each runs the real program in-process, as the embedded proposer, at the node's one clock.

  • One clock. warpClock [seconds] moves the node's clock forward, and the embedded L1 reads that clock. submitDeposit and submitForced stamp an entry by it, so an entry made after a warp gets its deadline from the warped clock, and getForcedQueue and getForcedEntry read secondsRemaining and overdue against it. Until 2026-10-05 those four read the wall clock on an embedded chain: a deposit made after a warp of 3,050 s was born 550 s from its deadline as the node judged it, and was never marked or credited.
  • refundDeposit [index] sends the portal's refund_deposit for that inbox entry. It pays when the program does: the entry is the relay's, is not marked included, and its deadline has passed on the node's clock. The answer is entry, refunded: true, lamports (what left the vault), depositor, deadline, now, vaultBefore, vaultAfter, depositorL1Before, depositorL1After, refundRecord and refundRecordRent. The depositor of an embedded deposit is the embedded proposer, which also sends the refund and pays the record's rent, so its balance rises by the deposit less that rent. A refusal is the program's own, as error -32000: refund_deposit refused by the portal: DeadlineNotPassed (6021) [entry 0, marked false, deadline …, L1 time …]: …. A marked entry is DepositIncluded (6020), before or after its deadline. An entry the relay did not submit is NotADeposit (6019). A second refund is refused when the refund record is created, which is a system-program error with no name of the portal's, so the message says the refund record … already exists.
  • A queue that obliges another key. run --settle DIR --embedded-queue-sequencer PUBKEY starts an embedded L1 whose inbox queue names PUBKEY as its sequencer, while the node still signs with the embedded proposer. Every mark_included the node sends is then refused (NotTheSequencer, 6012) and raised as getSettlement.alarms.inboxMark, naming both keys. A forced transaction is consumed once and stays unmarked. A deposit is not credited, is consumed without credit 300 seconds before its deadline, and refundDeposit pays it after the deadline. The flag belongs to one start, because the embedded L1 is made anew at every start. Without it the queue obliges the node's own key, as before. A cluster backend refuses the flag by name.

The explorer's routes

GET on any path serves the explorer, which routes on the path: /block/<slot>, /tx/<signature-or-hash>, /address/<pubkey>, /token/<mint>, /collection/<mint>, /program/<id> (a program's page: kind, the loaded file's hash, the source the repository declares it was built from and whether the hash matches that build), /batch/<seq-or-hash>, /forced/<index>, /receipt/<order-hash>; the lists /blocks, /txs, /accounts, /programs, /tokens, /nfts, /collections, /token-programs, /settlement, /receipts, /bridge, /forced, /stats, /pending, /dropped; /heartbeat (the live panel as its own page) and /fleet (this node and every sibling it was started with, run --sibling NAME=URL, one row each from each node's own getChainInfo, getSettlement and getStats: build, same or different from this node's, where it settles, heads, alarms, L1 reads per minute, the cluster read's age and the last minute's answer times; siblings re-read every 15 s while the page is open). GET /info returns a chain summary as JSON without a POST (rpc.rs handle, a body built separately from the getChainInfo arm): service, network, chainId, genesisHash, slot, build, startedAt and admission as getChainInfo reports them, plus indexedFrom (see getChainInfo above — it is here only) and methods. methods is rpc.rs INFO_METHODS: the 61 methods POST / answers other than the operator methods and the admin console's getVerificationQueue (69 in all). A unit test (rpc.rs info_methods_tests) reads the dispatcher's arms from the source and fails when a method is in neither INFO_METHODS nor its not-advertised list, so a new method cannot be left off silently. It names methods only; openrpc.json (next section) is the authority on what each takes and returns, and openrpc-check.mjs notes any public method the list leaves out.

POST /solana: Solana's shapes

The same port answers a second JSON-RPC surface on the path /solana (src/solana_compat.rs), for wallets, @solana/web3.js and Solana's Rust client: every answer is in the shape Solana's JSON-RPC documents (1.18), built from the same node state / reads. / does not change; the explorer, the gateway and the scripts keep their shapes there.

curl -s http://127.0.0.1:8895/solana -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","id":1,"method":"getBalance","params":["<pubkey>",{"commitment":"confirmed"}]}'
# {"id":1,"jsonrpc":"2.0","result":{"context":{"apiVersion":"1.18.26","slot":312},"value":1000000000}}
const connection = new Connection("http://127.0.0.1:8895/solana", "confirmed");

@solana/web3.js 1.x's default send-and-confirm flow works against a node started with --ws-port (the HTTP port + 1), on a chain that settles: connection.sendTransaction(tx, signers) then connection.confirmTransaction(sig, "confirmed"), or sendAndConfirmTransaction(connection, tx, signers). Until 2026-10-10 neither half did (the quickstart record, solieum-testnet/drills/records/2026-10-10-sdk-quickstart-clean-container.md, F5 and F6):

  • sendTransaction(tx, signers) signs over getLatestBlockhash("finalized"). That used to name the last final block, refused with no L1 (-32004) and, with one, expired once the head was 150 blocks past it. getLatestBlockhash now names the head's hash at every level (the commitment table below says why), so it sends.
  • confirmTransaction reads no status until its signatureSubscribe is open on the websocket. run --ws-port N serves it (next section). A node run without it still makes confirmTransaction throw TransactionExpiredTimeoutError (30 s with 1.99.0) whatever became of the transaction; poll getSignatureStatuses there.
  • On a chain with no L1, confirmed never arrives (the commitment table): confirm at processed, or poll.
  • processed arrives at admission, not at the next block: the sequencer's signed receipt is the processed status (Preconfirmation below), so sendAndConfirmTransaction(connection, tx, signers, { commitment: "processed" }) returns in the milliseconds the send takes, whatever the block time.

The websocket: run --ws-port N

TransportA websocket on 127.0.0.1:N (src/solana_pubsub.rs), any path. Off unless --ws-port names a port. web3.js connects to the HTTP port + 1 (--port 8899 --ws-port 8900) unless its Connection is given a wsEndpoint. Not a default because on a fleet run on consecutive ports the HTTP port + 1 is the next node's. Publicly reachable through the deploy kit: Caddy hands a GET /solana websocket upgrade to the /solana proxy (solieum-testnet/deploy/kit/caddy/Caddyfile, @solana_ws), which carries it, its frames unread, to the node's --ws-port (solieum-testnet/deploy/kit/gateway/solana-proxy.mjs, its upgrade handler; NODE_WS_PORT=0 turns that off), and the kit's unit runs each node with --ws-port ${WS_PORT} (solieum-testnet/deploy/kit/systemd/solieum-node@.service). The proxy's caps sit inside the node's (Limits, below): an upgrade takes a token from the client IP's request bucket, at most 48 connections in all (WS_MAX, refused above the node's 64) and 4 per client IP (WS_PER_IP), each closed after 120 s with no traffic (WS_IDLE_SECS). The bridge gateway (bridge/gateway/server.mjs) does not forward it.
ServedsignatureSubscribe [signature, {commitment, enableReceivedNotification}] → a subscription id; signatureUnsubscribe [id] → true. Everything else (slotSubscribe, accountSubscribe, …) is -32601 Method not found: web3.js's confirmTransaction needs only the first two (its expiry check polls getBlockHeight over HTTP). A request without an id (web3.js's five-second ping) gets no answer; a batch of at most 64 requests is answered in order, and a longer one is refused whole, -32600 "Invalid request: a batch of N requests; at most 64", nothing run.
NotificationsSolana's: {"jsonrpc":"2.0","method":"signatureNotification","params":{"result":{"context":{"slot":S},"value":{"err":null}},"subscription":ID}}, sent once the transaction reaches the commitment subscribed at (the level getSignatureStatuses reports, default finalized), S its block and err the TransactionError of a dropped transaction. At processed that is its admission under the sequencer's signed receipt, before its block exists: S is then the block it lands in, err null (Preconfirmation below). A subscription opened after the send, as web3.js's confirmTransaction opens one, is looked at as soon as it is open and notified in that first look; one opened before the send waits for the next 400 ms look. A transaction admitted with the gate off, or a forced entry, is notified at its block. The subscription then ends, as on Solana: unsubscribing it afterwards is -32602 "Invalid subscription id.". A transaction already at the level when subscribed is notified at once, however old: every block the node holds is in its transaction index. Solana notifies only a transaction still in its status cache (the last 300 slots) and never an older one; here a client waiting for finalized (48 h on a settling chain) is closed at the 10-minute lifetime below, subscribes again, and must still be told. With enableReceivedNotification, "receivedSignature" comes first, once the node holds the transaction.
LimitsAt most 64 connections (a further one is answered HTTP 503 before the handshake, its request read for at most 500 ms in all), 256 subscriptions on one connection (a further one is -32603 "Internal Error: Subscription refused. … subscription limit reached"), opened at most 64 at once and then one each 250 ms (a further one is -32603 "Internal Error: Subscription refused. Subscription rate limit reached …; retry in N ms", and opens nothing), 64 KiB messages, read at most 128 at once and then one each 25 ms (a client sending faster waits, its messages unread in its socket; nothing is refused), a signature of at most 88 characters (a longer one is -32602 "Invalid Request: Invalid signature provided", refused before it is decoded), a handshake finished within 10 s of the connection, as a whole, and writes drained within 10 s (each write call). A connection with no subscription open and no message for 30 s is closed (code 1000), and every connection 10 minutes after it opened, whatever it holds (code 1001), however its client trickles its bytes (each message read is given 100 ms as a whole): web3.js reconnects after any close but 1000 and subscribes again, and pings every 5 s, so it is never idle. Each connection looks every 400 ms while it holds a subscription, and reads the node (under its lock) only when something a subscription waits on may have moved since its last look: a block, an admission, a drop, a root committed or finalized (a counter the node moves under its lock and the connection reads without it), or, on a cluster, the settlement record itself; a new subscription is always read. Such a read is one index lookup per subscription still waiting to land, its key hashed once at subscribe, however long the chain, and for one at processed a lookup in the admitted signatures and, once admitted, a pass over the pending queue the next block empties.

The JSON-RPC surface

TransportPOST /solana (or /solana/), JSON-RPC 2.0. Batches work here (an array of requests, answered in order), of at most 100 requests since K59h (2026-11-03, solana_compat::MAX_BATCH): a longer one is refused whole, one -32600 "Invalid request: a batch of N requests; at most 100" with id: null, nothing run. Agave sets no such limit; the node is reachable without the gateway, and a 1 MiB body of [1,1,…] asked for some 500,000 answers. OPTIONS /solana answers a browser's CORS preflight (Access-Control-Allow-Origin: *, any header). GET /solana still serves the explorer. Bodies over 1 MiB are refused. The RPC gateway itself forwards POST / only; the deploy kit serves this path publicly through its own /solana proxy beside it (solieum-testnet/deploy/kit/gateway/solana-proxy.mjs, routed by kit/caddy/Caddyfile's @solana matcher): an allowlist of the methods below (batches refused there), 16 KB bodies, a per-IP rate and a tighter one, with an in-flight cap, for the heavy methods, and the websocket upgrade on the same path. Subscriptions are on the websocket port (above), not here.
ServedgetAccountInfo, getBalance, getBlockHeight, getBlockTime, getClusterNodes, getFeeForMessage, getGenesisHash, getHealth, getIdentity, getLatestBlockhash, getMinimumBalanceForRentExemption, getMultipleAccounts, getProgramAccounts, getRecentPrioritizationFees, getSignatureStatuses, getSignaturesForAddress, getSlot, getSlotLeader, getSlotLeaders, getTokenAccountBalance, getTokenAccountsByOwner, getTokenSupply, getVersion, isBlockhashValid, sendTransaction, simulateTransaction.
RefusedEverything else is -32601 Method not found, never a guessed value: getBlock, getEpochInfo, getTokenAccountsByDelegate, getTokenLargestAccounts, and every /-only method (getChainInfo, getSettlement, …). getTransaction is refused with -32601 too, with a message that says why and where: its meta needs inner instructions, token balances and return data the node does not record, and balances in the message's account order, which the explorer's record does not keep; POST / answers getTransaction (where the transaction landed) and getTransactionDetail (accounts, balances, instructions, logs) in the node's own shapes.
The wallet readsWhat a wallet on a custom endpoint (Backpack, Solflare; Phantom's localhost network) and @solana/web3.js 1.x ask beside the transfer, each with one honest answer on a chain with one sequencer and a flat fee, read from the node's own reader for the value, none a reading of a level and none needing the payer key. getRecentPrioritizationFees [[account, …]] → [{"slot":N,"prioritizationFee":0}, …], one entry per block in the blockhash window (the 150 newest, the slots isBlockhashValid takes; Solana's cache spans the same number), every entry 0: the fee is flat (getChainInfo.flatFee, what getFeeForMessage quotes) and a SetComputeUnitPrice instruction buys nothing, so no landed transaction paid a per-compute-unit price in any block, for any account. The accounts are checked as Solana checks them (at most 128, MAX_TX_ACCOUNT_LOCKS, "Too many inputs provided; max 128"; each a pubkey) and change nothing. A wallet that takes the median, the maximum or the newest of the list prices its priority fee at 0 instead of a default it would pay for nothing. getSlotLeader [{commitment, minContextSlot}] → the sequencer's key as a bare string, and getSlotLeaders [startSlot, limit] → limit copies of it (at most 5,000, MAX_GET_SLOT_LEADERS, "Invalid limit; max 5000"; any range, there being no epoch boundary): one node produces every block, so it leads every slot. The key is the identity this node signs under, getChainInfo.sequencer on /, the one a receipt is checked against. getIdentity → {"identity": <that key>}. getClusterNodes → one node, Solana's 1.18 RpcContactInfo with every field present: pubkey that key, version "1.18.26" (what getVersion answers as), and gossip, tvu, tpu, tpuQuic, tpuForwards, tpuForwardsQuic, tpuVote, serveRepair, rpc, pubsub, featureSet, shredVersion all null: the node does not know the address it is reached at (a gateway stands in front of it), and null is what Solana answers for a port a node does not serve. getBlockTime [slot] → the block's own timestamp, unix seconds (Block::timestamp, /'s blockTime), for any block held, no commitment (Solana's takes none); a slot past the head is Solana's -32004 "Block not available for slot N", one below the first block a node opened from a checkpoint holds its -32001 "Block N cleaned up …"; no slot in between is skipped, so there is no -32007.
Envelopes{"context":{"slot":N,"apiVersion":"1.18.26"},"value":…} on every method Solana wraps; getSlot, getBlockHeight, getBlockTime, getGenesisHash, getHealth, getIdentity, getVersion, getMinimumBalanceForRentExemption, getRecentPrioritizationFees, getSignaturesForAddress, getSlotLeader, getSlotLeaders, getClusterNodes and sendTransaction answer bare, as Solana's do, and getProgramAccounts answers bare unless asked withContext: true. context.slot is the L2 slot the answer was read at.
AccountsEncoded by Solana's own encoder (solana-account-decoder): base64 → ["<base64>","base64"], base58, base64+zstd (what Solana's Rust client asks for), jsonParsed (SPL token accounts with their mint's decimals; anything without a parser falls back to base64, as on Solana), and the legacy default binary when no encoding is named. owner, lamports, executable, rentEpoch (as stored) and space are always present; dataSlice works (a base58 slice of a large account is the slice, where 1.18's encoder puts the text error: data too large for bs58 encoding); base58 over 128 bytes and a sliced jsonParsed are refused with Solana's -32600. A zero-lamport account is null, as a bank reports it, and is never listed. getAccountInfo and getMultipleAccounts clone what they read under the node lock and encode it after the lock is released (since K59); a key repeated in getMultipleAccounts is answered at each place, as on Solana. The default is the legacy binary on every account method, getProgramAccounts and getTokenAccountsByOwner included, so a 165-byte token account needs an encoding (as on Solana).
getProgramAccounts[programId, {encoding, dataSlice, filters, withContext, commitment, minContextSlot}] → [{"pubkey":…,"account":<account>}], in pubkey order, or that list as the envelope's value with withContext: true. A program with no accounts here, one this chain never ran included, is [], as a cluster answers it. filters are Solana's own type, checked and matched by its own code (solana_client::rpc_filter): {"memcmp":{"offset":n,"bytes":…}} with bytes base58 (the default), "encoding":"base64", or a raw byte array; {"dataSize":n}; "tokenAccountState". Its limits, as Solana's RPC enforces them: at most 4 filters (MAX_GET_PROGRAM_ACCOUNT_FILTERS, "Too many filters provided; max 4"), and a memcmp compares at most 128 bytes, sent as at most 175 base58 or 172 base64 characters ("Invalid param: DataTooLarge"), both -32602. On spl-token or Token-2022 a query shaped like Solana's by-owner or by-mint index lookup (a 32-byte memcmp at byte 32 or 0, plus dataSize 165, the Token-2022 type byte 2 at 165, or tokenAccountState) also gets the account-state filter Solana adds on that path, so the same accounts are listed; with jsonParsed on a token program, an account that does not parse is left out, as there. Matches are cloned under the node lock and encoded after it is released. Ours, not Solana's (K59): at most 10,000 matches (MAX_SCAN_ACCOUNTS; past it -32602 "Too many accounts: more than 10000 match; narrow the query with filters (max 10000)"), and at most 40,000 of the program's accounts visited to find them (MAX_SCAN_VISITS; past it -32602 "Too many accounts to scan: more than 40000 owned by this program for this query; filter token accounts by owner or mint (max 40000 scanned)"), refused rather than answered in part. A token lookup by owner or by mint (a 32-byte memcmp at byte 32 or 0 with dataSize 165 or tokenAccountState, including the shape above once the account-state filter is added; a type-byte memcmp at 165 by itself does not count, since a 355-byte Multisig can pass it) is not held to the visit cap: at the head its candidates are the owner's or mint's token accounts in the explorer's token scan (kept per block and stepped), each re-read and re-checked, so it visits those rather than every account the token program owns. On classic spl-token with tokenAccountState and no dataSize 165, the program's records that are neither mint nor token account (Multisigs, other sizes) are candidates too: that filter passes a longer record with type byte 2, which classic spl-token files by exact size as neither. At processed it reads the projection's owner index.
Token methodsgetTokenAccountsByOwner [owner, {"mint":…} | {"programId":…}, {encoding, dataSlice, commitment, minContextSlot}] → the envelope around [{"pubkey":…,"account":…}]: initialized or frozen accounts of that owner, under that mint or token program; jsonParsed is the parsed token account with its mint's decimals, the same parse getAccountInfo gives. At the head it visits only the owner's token accounts (the explorer's token scan, see getProgramAccounts), with the same 10,000-match cap. getTokenAccountBalance [account, {commitment}] and getTokenSupply [mint, {commitment}] → the envelope around Solana's UiTokenAmount, {"amount":"1250000","decimals":6,"uiAmount":1.25,"uiAmountString":"1.25"}. Solana's refusals, all -32602 in its words: "Invalid param: could not find account", "… not a Token account", "… not a Token mint", "… mint could not be unpacked" (supply), "… could not find mint", "… Token mint could not be unpacked", "… unrecognized Token program id" (by owner). The native mint (So111…112) is spl-token's with 9 decimals whether or not its account exists here, as Solana's RPC names it.
getVersion{"solana-core":"1.18.26","solieum-node":"0.1.0"}: the Solana release whose RPC this answers as and whose runtime crates the node pins (a test holds the two together), plus what is actually answering. No feature-set: the node runs no Solana feature set to name, and the field is optional in both clients.
getHealth"ok" whenever the node answers: Solana's "within reach of the cluster's tip", and the sequencer is the tip. Whether it is producing and settling is solieum-node status.

Commitment. Solana's levels say how far a block is from being reversed; each maps to a stage this node already reports:

LevelHereWhere the node reports it
processedadmitted under the sequencer's signed receipt (a preconfirmation, below), or in a block this node produced: the sequencer's word only, revocable only by a sequencer that breaks its own receiptgetSequencerReceipts, and getSlot, on /
confirmedthe block's root is committed on L1: its batch is on Solana, so its transactions and their order no longer depend on the sequencer; the root is still challengeablegetSettlement.head_number, or this node's own record of the commit
finalizedthe block's root is final on L1: the challenge window passed with no challenge standing. Nothing about the block can be reversed any more; it is what a withdrawal proves against. On gamma that is 48 h after the commit, not Solana's ~13 sgetSettlement.finalized_head, or this node's own record of finalizing it
  • The default is Solana's: finalized. A client that names no commitment gets finalized answers or a refusal, so give the Connection one ("confirmed").
  • A chain with no L1 wired has processed only; the other two are refused with -32004 naming why. On an embedded L1 the levels are what the in-process programs accepted, which nobody outside can check (getSettlement.verifiable).
  • Account state at processed includes what was admitted; at confirmed and finalized it is held at the head only. getBalance, getAccountInfo, getMultipleAccounts, getProgramAccounts, getTokenAccountsByOwner, getTokenAccountBalance, getTokenSupply and simulateTransaction at processed read the block being filled (Preconfirmation below). At confirmed or finalized they answer only when the head has reached the level; otherwise -32004, naming the head's level, rather than newer state under an older label or a replay of the log under the node lock. With confirmed that is only the seconds between a block and its settlement; with finalized, any chain that produced a block in the last window.
  • getSlot and getBlockHeight answer at every level, computed from the blocks held: at processed the head, one below the block an admitted transaction lands in.
  • A blockhash is not a reading of a level. getLatestBlockhash names the head's hash at every level, finalized and a chain with no L1 included, with lastValidBlockHeight the head + 150 and context.slot the head: the same answer as /. isBlockhashValid and getFeeForMessage say whether admission would take the hash now (one of the 150 newest blocks), whatever level is named. Why: a blockhash only bounds how long a signed transaction can be replayed. Admission, derivation (ADR-0021) and the committed blockhash ring all check that it is one of the 150 newest blocks at the transaction's position, never the level of that block, and with one sequencer, append-only blocks and a failover that requires the standby's log to be the primary's, there is no fork for a more-committed hash to survive. Solana's finalized blockhash is ~32 slots behind its tip, inside the window; here finalized is 48 hours behind and its hash long expired, so answering it made web3.js's sendTransaction fail (until 2026-10-10 it did). The window is still 150 blocks. What a less-committed hash risks is liveness only: had a block been lost before its batch was published, a transaction signed over its hash could not land and would expire at its lastValidBlockHeight; it could never land twice.
  • getSignatureStatuses reports each status's own level, confirmations null once finalized, status {"Ok":null} / {"Err":…}, and context.slot the head. A transaction admitted but not yet in a block is processed at the block it lands in (Preconfirmation below), unless the gate did not execute it (--no-admission-check, a forced entry): then null until its block. Every transaction the node holds is found, looked up in its transaction index, so searchTransactionHistory is accepted and changes nothing; Solana's default reads only its status cache (the last 300 slots), and only that flag reaches further back. getSignaturesForAddress takes confirmed or finalized only, as Solana's does. One call examines at most 50,000 entries of the address's history under the node lock (MAX_RECORDS_EXAMINED, the explorer's bound, since K59): a walk that ends within it answers as before. Stopped there with rows found, the page is the rows found (fewer than limit; pass the last as before to go on); with none found it is refused, -32602 "Too many records examined: the 50000 newest entries in range of this address's history hold no signature (max 50000 examined)", rather than answered [], which reads as the end of the history. Only an address whose history is almost all unsigned records (deposits, settlement entries) can reach it.
  • minContextSlot is honoured everywhere Solana takes it, with its -32016; getTokenAccountBalance, getTokenSupply and getMinimumBalanceForRentExemption take a bare {commitment}, as Solana's do.

Preconfirmation (processed). sendTransaction returns once the gate has executed the transaction at the position it will hold (ADR-0014) and the sequencer has signed a receipt for that position (ADR-0012, a v2 receipt naming the chain) and journaled it (ADR-0024). From that answer on:

getSignatureStatuses{"slot": head + 1, "confirmations": 0, "err": null, "status": {"Ok": null}, "confirmationStatus": "processed"}. The slot is the block the transaction lands in, known rather than estimated: the next block takes every pending admission, and it is the head + 1. err is the admission run's, always null (a transaction that would fail is refused, free, and never admitted). context.slot stays the head, so the status's slot is one past it until the block exists.
Account stateAt processed, the state the admitted transactions leave, in their order: the gate's own projection of the block being filled, the store the next submission is executed against and simulateTransaction runs on, with context.slot the head + 1. Served only while that projection is exactly what the block will commit; while a forced entry or a deposit credit is queued into the open block, after a restart, or with the gate off, a processed read is the head's (context.slot the head) until the block seals.
WebsocketsignatureSubscribe at processed is notified at admission, context.slot the head + 1.
Not preconfirmedA transaction admitted with --no-admission-check, and a forced-inclusion entry: neither is executed at admission, so each reads null until its block says what it did.
What can revoke itOnly the sequencer breaking its own receipt. Nothing in the node drops an admitted transaction: the hash is checked once, at admission, and the transaction lands in the head's successor; a held block keeps it; a restart restores it from the journal (a journal that disagrees refuses to start). A node started without its journal no longer holds it (its status reads null) and would sign that position again, which is equivocation, slashable on L1 (slash_equivocation). A published batch that leaves out a receipted transaction is not yet slashable on L1 (K17); the receipt (getSequencerReceipts on /) is the evidence. A gated transaction that fails in its block anyway is a determinism divergence the node reports loudly, and its status then reads the block's err.
confirmed, finalizedUnchanged: the block's root committed on L1, then final there past the challenge window.

Admission checks that the fee payer can cover the fee from its balance at the head before it executes anything (Node::submit_wire), so an account whose only funds arrived at processed is refused InsufficientFundsForFee until the block that credits it seals; one that held the fee already can spend them at once, since the gate runs against the projection.

Transactions. Legacy wire transactions only; a v0 transaction or message is refused with -32602, and so are transactions above Solana's 1,232-byte limit. The default encoding is Solana's, base58; web3.js and the Rust client send base64. sendTransaction admits through the same path as / (ADR-0014): with the gate on it executes the transaction at the position it will hold before returning the signature, so skipPreflight, preflightCommitment and maxRetries are accepted and change nothing. A refusal is Solana's -32002 with data an RpcSimulateTransactionResult whose err is the TransactionError the node's reason names and whose logs are the program's: BlockhashNotFound, AlreadyProcessed, InsufficientFundsForFee, InstructionError [i, …] (the runtime's own error: {"Custom":n}, a named variant, or UnsupportedProgramId for a program this chain does not run). A bad signature is -32003. A refusal no TransactionError describes (the per-payer rate, the compute ceiling, the launch scope, a braked intake) is -32002 "Transaction refused at admission: <reason>" with err null. A withdrawal the bridge rule refuses, and any failure the node cannot name, reads as InstructionError [0, "GenericError"], with the reason in the message and on /. simulateTransaction runs against the block being filled when one is open (Solana's working bank; context.slot is its number), the head otherwise, and only at processed while a block is open; it checks the blockhash unless replaceRecentBlockhash; unitsConsumed is the runtime's count on success and null on failure; returnData, accounts and innerInstructions are not captured, so the first is null and asking for the other two is refused. A dropped transaction's status carries the same mapping as its err.

Where this differs from Solana's RPC, on purpose

  • sendTransaction executes before it answers. A transaction that would fail never gets a signature.
  • getBalance, getAccountInfo, getLatestBlockhash and getSignatureStatuses answer without Solana's { context, value } envelope (getSignatureStatuses has value but no context), so @solana/web3.js's Connection refuses those replies with StructError: At path: context. Call them as plain JSON-RPC, or point Solana tooling at POST /solana (the section above), which answers them in Solana's shapes.
  • getAccountInfo returns no data bytes, only dataLen. Read tokens through the token methods.
  • getMinimumBalanceForRentExemption and getBlockHeight answer as Solana's do, bare numbers; rent is (space + 128) × 6,960 lamports, Rent::default().
  • Fees are flat at the amount the chain names (getChainInfo.flatFee; 5,000 unless its genesis says otherwise), paid in SOL; there is no priority market. priorityFee is always 0 and feeModel is flat.
  • On a chain whose genesis names its own native coin (getChainInfo.nativeCoin), the flat fee is paid in that coin: feeBurnBps of it is destroyed and the rest is paid to the sequencer, as two fee steps. The transaction and block detail views report the destroyed part as feeBurned and feesBurned, and getTopAccounts as burnedLamports.
  • Finality has one meaning: Solana's, after the challenge window. A confirmed status on / is the sequencer's word and is revocable until the root finalizes. On /solana the same transaction reads processed until its root is committed on L1, and only then confirmed (the commitment table above), so on a chain with no L1 it never reads confirmed there.

Machine-readable spec

protocol/onchain/node/openrpc.json is an OpenRPC 1.3 document of everything the dispatcher handles, derived from src/rpc.rs and src/explore.rs on 2026-09-26: for each public method its positional params, a result schema whose every property is a key the node emits (required is what the builder always emits, nullable ones carry null in their type, the mode-dependent shapes of getSettlement, getBridge, getSequencerBond, getTransactionDetail and the rest are oneOf branches), the error codes and messages as the code produces them, and one example taken from a real answer of the local test chain (http://127.0.0.1:8899, build 896334af; arrays cut to three entries). A method this chain can only refuse — getWithdrawal on a chain with no withdrawals, getForcedEntry with an empty inbox, the two submits on a node started without --attestations / --token-info — carries that real refusal as x-example-error instead of a result. x-exposure says what the public gateway does with each method (public, node-only, gateway-opt-in, admin-console); the operator and testing methods of the section above are listed under x-operator-methods, not omitted, so the check below can refuse an arm that is in neither list. GET /info is described under x-http-get-info.

The check that keeps it honest:

node protocol/onchain/node/openrpc-check.mjs                              # spec vs the dispatcher, examples vs schemas
node protocol/onchain/node/openrpc-check.mjs --live http://127.0.0.1:8899 # also every public method against a running node

Offline it reads the body of fn dispatch( in each of the two files, takes every "name" => arm at the dispatcher's own indentation as a handled method, and fails if that set and the spec's (methods ∪ x-operator-methods) differ in either direction; it then validates every example against its schema. With --live it calls each public method with its example params and fails on a missing required property, a wrong type, or an unexpected error; a property the spec does not name is a warning (--strict makes it a failure). It needs nothing but node.

The rule: a new RPC method is not done until it is in openrpc.json. The offline check runs against the tree and refuses a dispatcher arm the spec does not name, so a method added to dispatch without its entry turns the check red; a result that gains a field should gain it in the spec too, or every --live run will warn about it. The check also prints, as notes rather than failures, the public methods this document does not mention and the ones GET /info's methods list (rpc.rs INFO_METHODS) leaves out.

Generated from the node's own reference, revision a95e1509 of 2026-11-13. 14,984 words.

Building something the base layer can't hold?

Tell us the workload. If Solieum is the wrong answer for it, we would rather say so early than have you find out at launch.