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.
Endpoint
| Public endpoint | None 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 form | http://127.0.0.1:8895 — RPC and explorer on the same port. Chain id 7790, solieum-testnet-gamma, genesis HURAAxUvSnGsSmLqiqx9i39XZBtBbY6JhnXeLWMPbnEp. |
| Transport | POST /, 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 type | application/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. |
| Errors | JSON-RPC errors: -32601 unknown method, -32602 bad params, -32000 a refusal with the node's own reason, -32004 not found. A transaction that would fail is refused at sendTransaction with the program's error and logs — no signature, no fee, no record (ADR-0014). |
| Rate limits, keys | No 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. |
| Consistency | Every 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:
defenceon 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.
sha256andbytesare the node's statement about the file, not a proof, and the program set is not committed to the chain.
Chain
| Method | Params | Returns |
|---|---|---|
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), indexedFrom (since 2e13128: 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), 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). |
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. |
getTimeSeries | [{ range: secs, bucket: "hour" | "day" }] | Buckets over the range: transactions, dropped, fees, compute units, blocks, active and new accounts, bridge deposits, settlement-time medians, cumulative supply. Bucket defaults to hours inside two days and days beyond. |
getPrograms | — | Every program an executed instruction has invoked, all-time, plus every registered one even if never called: programId, name, invocations, transactions, firstSlot, lastSlot, registered, bytes, sha256, loader; registeredCount. |
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
| Method | Params | Returns |
|---|---|---|
getBlock | [slot] | One block: slot, blockHash, parentHash, blockTime, stateRoot, batchHash, transactionCount, droppedCount, transactions, and defence. |
getBlocks | [limit = 20, max 200] | The newest N blocks, newest first, same shape. |
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. |
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
| Method | Params | Returns |
|---|---|---|
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. A string is a Solana wire transaction; 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. |
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, dropped: true and feeCharged. |
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. |
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
| Method | Params | Returns |
|---|---|---|
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. |
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: from, to, amount, direction, the L1 depositor when the source was a bridge credit. |
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.
| Method | Params | Returns |
|---|---|---|
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. |
getTokenDetail | [mint] | The token page: the mint as above plus holderList[] (tokenAccount, owner, amount, amountUi, share, state, delegate) largest first, the last 25 transactions that touched the mint, dataLen. found: false with a reason for a non-mint. |
getTokenAccountsByOwner | [owner] | A wallet's token balances: accounts[] of tokenAccount, mint, kind, program, amount, amountUi, decimals, state. |
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. |
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. A plain Transfer names no mint; it is resolved from the token account, and reads null if that account has since been closed. |
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
| Method | Params | Returns |
|---|---|---|
getSettlement | [recent = 10, max 100] | L1 mode, head_number, head root, batches sealed, finalized_head, unfinalized, 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), economics, blockCost, feePolicy. 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. |
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. |
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. 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. |
Bridge and withdrawals
| Method | Params | Returns |
|---|---|---|
getBridge | — | The bridge as this chain sees it: portal, relay, vault and vaultLamports, deposits credited (with each entry's rent), withdrawals with the portal's provenAt and paid, totals (bridgedIn, committedOut, paidOut), 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. |
getDeposits | — | The inbox entries that are bridge deposits: entry, seq, depositor, recipient, lamports, credited, entryAddress, entryRent; plus the portal and relay addresses. |
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. The list a fast-exit provider polls. |
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. |
Forced inclusion
| Method | Params | Returns |
|---|---|---|
getForcedQueue | — | The L1 inbox as recorded: entries with index, address, bytes, deadline, secondsRemaining, included, overdue; consumedUpTo, queued, program, queue, and quorum — whether the two readers agreed. An overdue entry means the chain has faulted on a censorship deadline (ADR-0004). |
getForcedEntry | [index] | One entry with its decoded bytes (parses, feePayer, instructions, recentBlockhash) and the record it became once consumed. |
Search
| Method | Params | Returns |
|---|---|---|
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.
| Method | Why it is not public |
|---|---|
submitForced | Enqueues 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. |
submitDeposit | Embedded L1 only: deposits as the embedded proposer. On a cluster a depositor calls the portal from their own wallet. |
proveWithdrawal, finalizeWithdrawal | Embedded L1 only. On a cluster the bridge does both from the wallet (withdraw-l1 --prove, --finalize). |
warpClock | Embedded L1 only; refused on a cluster 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. GET /info returns getChainInfo as JSON without a POST.
Where this differs from Solana's RPC, on purpose
sendTransactionexecutes before it answers. A transaction that would fail never gets a signature.getBalance,getAccountInfo,getLatestBlockhashandgetSignatureStatusesanswer without Solana's{ context, value }envelope (getSignatureStatuseshasvaluebut nocontext), so@solana/web3.js'sConnectionrefuses those replies withStructError: At path: context. Call them as plain JSON-RPC, or wrap the reply before handing it to Solana tooling.getAccountInforeturns no data bytes, onlydataLen. Read tokens through the token methods.getMinimumBalanceForRentExemptionandgetBlockHeightanswer as Solana's do, bare numbers; rent is(space + 128) × 6,960lamports,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.priorityFeeis always 0 andfeeModelisflat. - On a chain whose genesis names its own native coin (
getChainInfo.nativeCoin), the flat fee is paid in that coin:feeBurnBpsof 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 asfeeBurnedandfeesBurned, andgetTopAccountsasburnedLamports. - Finality has one meaning: Solana's, after the challenge window. A
confirmedstatus is the sequencer's word and is revocable until the root finalizes.
Generated from the node's own reference, revision 1d6abde of 2026-09-22. 4,214 words.