XPlorer following the chain as its own read-only node
height 23717 of 23717 on the network. 9 peer(s) connected, 77 in its peer directory; 1013 block(s) followed and 842 pulled in by sync since this follower started. Caught up: this follower holds every block any peer has claimed, so every panel below is the whole chain. Genesis 1cf8655125cc1bbb…, producers genesis.
What this follower is, locally
Following 7 seed(s) — their addresses are not published here, for the reason the peer table gives. Its store is held under its own Cerberus lease — no other node’s store is opened, touched or stopped.
API documentation
There are two programmable surfaces here and they are not the same thing. This explorer has a JSON mirror: every page you can read is also a JSON document, which is the cheapest way to pull public chain state out of a node. A node has a JSON-RPC door, which is how a wallet, an indexer or a contract deployer talks to the chain, and it is the only one of the two that can submit anything.
Both tables below are rendered from the catalogues the running code dispatches on, not written out beside them. A method the node stops serving leaves this page in the same commit it leaves the code.
The explorer’s JSON mirror
- How
- Put
/apiin front of any path on this surface./api/blocks?limit=25answers the page at/blocks?limit=25as JSON, and/apion its own is the index, the provenance and this route table. - Methods
- GET and HEAD. There is no write on this surface and no body is ever read, so this mirror cannot submit a transaction. Use the node’s door for that.
- Numbers
- Every amount, height and nonce is a decimal string, not a JSON number. A value past 2^53 loses its last digits as a number, and a balance that is wrong in its last three digits is worse than one that is obviously a string.
- Unknown is not zero
- A value the node could not measure arrives as an object carrying
status: unknownand a reason, never as0. Any client reading these documents has to handle that case; it is the whole honesty contract of this surface, expressed in the type. - Bounds
- A list is a page.
limitis clamped to 100 whatever you ask for,offsetpast the end answers the last rows rather than nothing, and a request URL longer than 2,048 characters is refused rather than truncated. - Caching
no-storeon every chain answer, because a height is wrong the moment it is cached. The stylesheet, the script, the marks and the faces are cacheable and say so.- Polling
/headis deliberately the cheapest answer on the surface — height, finality line, mempool depth, head age, last gap — and it is the route this page’s own live figures poll. Do not poll a folded panel when this one carries the figure you want.
Every route the mirror answers, which is every route this surface answers:
| Path | What it answers |
|---|---|
/ | chain head, ledger index, latest blocks and transactions |
/search?q= | resolves a height, a block hash, a transaction id, an address, a domain, a wNFT id or a proposal id |
/blocks | blocks, newest first |
/block/{height|hash} | one block and all 20 kinds of record it carries: transactions, domain allocations, domain registrations, contract records, bridge collateral, governance, identity (wnft), domain burns, domains given up, lapsed domains burned, domain sales, wstr wraps, spending delegations, hostless spaces (oort), str.talk (occultation), validator bonds (fenrir), account key rotations (hamskipti), anonymous attestations (zk13), bridge vetoes (vitni), attestor suspensions (fjotur) |
/block/{height|hash}/{kind} | one kind of record from one block, paged on its own; transactions are paged on the block page, and /block/{height|hash}/transactions redirects there |
/txs | sealed transactions, newest first |
/pending | the mempool: transactions no block carries yet |
/tx/{id} | one transaction, sealed or pending |
/address/{address} | balances across all seven ledgers, domain standing, nonce and history |
/contracts | deployed contracts |
/contracts/templates | the Daedalus template catalogue: drafts a deployer starts from, not deployed contracts. Each with its bytecode digest under the compiler in force, whether it matches the published vector, and its measured gas |
/contracts/templates/zk13-token/configure?name=&symbol=&owner=&cap= | the token wizard: a GET form that turns a token name, a ticker, an owner wallet, a supply and a feature set into ready-to-deploy ZK13 source, its manifest and the exact commands to reproduce, dry-run and deploy it. It generates; it never deploys |
/contracts/templates/{name}?deployer=&salt= | one template: source, ABI, bytecode digest, measured gas, the constants to edit, the commands to deploy it, and — for a deployer and salt you name — the address a deployment would land at. Read from the build; it asks the chain nothing |
/contract/{address} | code, ABI, storage, events, calls, and verification by construction |
/contract/{address}/read?fn=&arg= | calls one of the contract's view functions and shows what it answered. A read: it commits nothing and reaches no node |
/identity | STR.domains and wNFTs |
/domain/{domain} | one STR.domain, its wNFT, its slaves, and the burn record if the name has ever been burned |
/wnft/{id} | one wNFT: entries, versions, master and slave relations |
/organisations | proved master domains that have opened departments, and how many each holds |
/organisation/{domain} | one organisation: its departments, which may be PAID, and its delegates, which may SIGN — counted apart |
/validators | the Einherjar roll: who may seal at the head, what each has sealed, what each has bonded under Fenrir, and every admission, eviction, suspension and restoration with the reason recorded on it |
/delegations | every live Gefjon spending authority: who may move whose money, the cap, what is left in the current window, and the height it expires at |
/supply | supply, circulating and locked across every value ledger, the identity ledger apart, the $TR peg and the STR/CCOS parity |
/spaces | hostless spaces (Oort): every space counted by visibility, public ones listed. No content and no link to any: the chain holds a manifest root and nothing else |
/space/{id} | one hostless space: owner, visibility, price, manifest root and history. Readers are listed for a public space and deliberately not assembled for a private or dedicated one |
/talk | STR.talk (Occultation): the published inbox-key directory, and a census of threads that is counts only — no participant, sender or reader is indexed here |
/talk/{domain} | where a sender is entitled to seal a message to one domain, as the chain holds it |
/governance | parameters in force, pools, proposals |
/proposal/{id} | one proposal, its ballots and its timelock |
/bridge | reserves, mints, redemptions and whether the peg reconciles |
/network | height, finality line, validators, supply per ledger, state roots |
/nodes | how many seats the network has and how much of it is signing, what each STARW class may be, how Praeco finds them, every node this process knows of through Praeco — counted exactly (known, declaring they validate, followers, in session, quarantined), each with its role named for its evidence (a seat only where its own network address is on the roll; otherwise what the node declares, since a network identity is not a seat key and the seat count is unknown with that reason), in a page of at most 500 rows — and, labelled apart as a local view, the peers in session with this process. Identities only: no peer address, port, rendezvous point or seed is published |
/praeco | the Praeco directory on a page of its own: every node this explorer has heard of, counted by every STARW class, every role and every capability — a type nobody runs is listed at zero — and an arrivals feed of the newest 100, newest first by when THIS explorer’s directory first admitted the node’s signed record, with its class, role, capabilities, when it was last refreshed and whether it is in session. First heard is an observation since this process began listening, never a registration on the chain: a restart makes every node new, the directory is capped by class and evicts when full, and a record is forgotten when it expires. The seats the chain admitted are on /validators. Kept live by /praeco.js while the tab is visible; whole without it. Identities only: no peer address, port, rendezvous point or seed is published |
/api/praeco | the /praeco view as JSON, and the route its page polls: the counts by class, role and capability, at most 100 arrivals, the directory capacity and whether it is full, when this explorer began listening, and the moment the directory was walked. One walk serves every caller for 5 s, so polling it costs the node at most one walk per window however many tabs ask, and the answer has a fixed maximum size |
/consensus | the Tyr roll, whose slot it is, which seats have actually sealed, attestations and the finality line |
/throughput | how fast this chain has actually gone: the observed gap between blocks against the nominal slot, transactions per block and per second, blocks that carried nothing, and what a block weighs against the block ceiling — every figure counted over a named window of blocks this node holds, and no peak or projected figure anywhere |
/statistics | activity day by day over a rolling window of UTC days anchored on the newest block this node holds: transactions, records, active and new addresses per day, the distribution of gaps between blocks, an hour-of-day map of when the chain was quiet, the seats that sealed the most, and the supply split at the head. Read from a fixed-size model, with the window and every ceiling stated |
/compliance | a disclosure aid for institutions and MiCA-style reporting, read from chain state: per native ledger the supply, cap, circulating and locked split, the issuance rule as the token definition states it and where the supply was assigned at genesis; deployed ZK13 contract tokens by their own view functions; every genesis account with its balance and newest movements; holder concentration (top 1, 10 and 100, Gini, fewest holders over half); seats, producers seen, the finality line and the measured block interval; the published canon; and a sustainability indicator that says it is not measured. Not legal advice and not an authorisation of any kind |
/api/compliance/{assets|accounts|concentration|contract-tokens}.csv | the tables of /compliance as CSV: amounts in minor units with the precision beside them, an unmeasured value as an empty cell and never a zero, and every text cell quoted with formula characters defused. Built from the same reading as the page |
/accounts/new | addresses by first appearance in a sealed transaction, newest first, with the block and transaction each first appeared in. A wallet that has been created and never used is not on the chain and cannot be listed |
/cryptography | every primitive in force, what it protects, and which are carried by this build and unused by this chain |
/ledgers | the eleven ledgers |
/ledger/{id} | one ledger, shown in the terms that ledger counts in |
/api-docs | both programmable surfaces: this explorer's JSON mirror with its bounds, and the node's JSON-RPC method catalogue — each rendered from the array the running code dispatches on rather than written out beside it |
/status | what the node serving this page has actually verified — height, the finality line, the head's age and the mempool — off the cheapest read on the surface, with the caveat that one node's reading is not the network's. No uptime figure, because a node cannot measure one |
/about | what this chain is made of and who holds the rights to it. The operating entity is not named anywhere in this software and is marked as a gap rather than guessed |
/brand-assets | the marks and typefaces this node serves, with the byte length and digest of each measured from the bytes themselves, and how the lockup may be set |
/contact | the one address published in this software, and the ones that are not set |
/terms | what this surface does with a visitor, measured from the policy it sends and the one value it stores. It publishes no terms of service: the drafted documents are blocked on 27 items only the owner can supply |
/bug-bounty | where to report a security finding, and what is in scope. No funded programme exists and the page promises no reward |
/knowledge-base | the questions this chain gets asked, answered by the pages that measure themselves, plus how to read an unknown, a finality line and a bounded page |
/what-is-a-block-explorer | what an explorer is, the four questions it answers, the five things it cannot do, and how to tell an honest one from a confident one |
/advertise | none is offered or carried. Why this surface’s content security policy refuses a third-party ad tag outright, and what a first-party placement could honestly be |
/eaas | the four ways this explorer can be pointed at a chain without a key and without stopping a node. The software is in the build; a hosted service is not |
/multichain-api | one interface served identically by every chain built from this software, and the plain statement that no hosted endpoint answers for several chains at once |
/priority-support | what a node operator can actually use today. No support contract exists and no response time is promised |
/sourcescan | a cross-chain identity and analytics product the owner has described and this software does not contain. Marked not built, on the page and in this field |
/ecosystem | a signpost to the other SourceLess products — identity, wallet, messaging, AI and platform — each a jump to its own origin. It carries no chain data and verifies no product’s state |
/hex | buy STR with ETH or BNB: the live STR price in USD (a time-weighted average, never the spot price), the sale's limits read from the contract, a review step that prints the whole payout address, and a delivery tracker. The payment is signed in the reader's own wallet; this surface signs nothing |
/hex/name | register a name with ETH or BNB: personal or business, its USD price with the launch countdown, the STR the payment buys and the part of it the chain locks when the buyer claims the name with their own key |
/hex/token | create a token: what the ZK13 token wizard does and a link into it, with the owner filled in when a wallet hands over its address, and the three honest steps to deploy: a proved STR.domain, a dry run, then strblk wallet deploy against a producing seat with your own key. The browser never deploys |
/hex/business | the HEX business catalogue: a free token, the Business Suite and a large fork, with prices that are indicative and set by the owner, what a fork does not get, and the address to request an order. Informational only: no form, no payment, and nothing a reader does here is collected |
/hex/fork | business forks (Vanaheim): whether to fork or tokenise, the four stages from a rehearsal to a chain on delivered seats, a rehearsal command builder that runs in the tab and sends nothing, the one measured run and what it was measured on, what a fork does not get, what the genesis fixes, and how to order one |
/buy | the sale’s address before it was named HEX: a permanent redirect (308) to /hex that keeps the query, so a link a wallet made earlier opens the same page with the same fields filled |
/buy/name | the name sale’s address before it was named HEX: a permanent redirect (308) to /hex/name that keeps the query, the name and the class included |
/forks | business forks (Vanaheim): whether to fork or tokenise, the four stages from a rehearsal to a chain on production keys, what a fork runs, the one measured run and what it was measured on, what a fork does not get and what the genesis fixes for ever |
/forks/rehearse | the rehearsal command builder: a chain name, a chain id, a seat count and a treasury become the scripts/fork.mjs command that starts that rehearsal, with its owner domain, data root and Althing bar. It runs in the tab, refuses the chain ids of the realms in the register by name, and sends nothing |
/forks/contracts | every contract template as a draft for a fork, grouped by what a business uses it for, with what is the same on a fork (bytecode, measured gas, the address formula) and what is not (state, which never migrates) |
/forks/docs | the operator documentation for a business fork on one page: every flag and command of scripts/fork.mjs, the endpoints, the two key paths, the governance arithmetic, what the genesis fixes, contracts on a fork, what to check before value, and every refusal an operator may meet |
/forks/stack | what a fork runs beside its seats, each part with its status in this build and the commands to run it against a fork: the three node classes (Pulsar, Quasar, Supernova), Praeco discovery, hostless storage, smart contracts, STR.talk, the sign-in door, eSIM access (not built) and an explorer for the fork |
/forks/ideas | ideas for forks drawn from how other chain families launch a chain of your own, each with where it comes from, what it would mean for a SourceLess fork, and what exists today: built, part built or an idea |
/forks/contracts/{name}?c.<constant>=&deployer=&salt= | one template as a draft for a fork: a GET form that sets the constants its header marks for editing, checked against their types, compiles the result with the compiler in force and shows its digest, whether any catalogue example is left (a deployment refuses while one is), and where a deployment by the named deployer would land; then the steps to deploy it to a fork. It signs nothing and reaches no node |
/forks/contracts/{name}.ares?c.<constant>= | the same draft as a file to download, as plain text, or a 400 naming the values that were refused |
/forks/realms | the realm register a fork is checked against: each realm’s chain id, mode, key provenance and pinned genesis hash, whether the chain this explorer reads is one of them or a fork of its own, and the registered partners with the chain ids held for them |
/forks/pending | the register of business fork slots, a hundred to a page (`?page=1` to `8`): every slot with the chain id held for it, its status (pending, in progress or deployed) and its partner, with a button to the registered partners |
/forks/partners | the registered partners: each with its slot, its chain id, its status, the steps done and its genesis hash once it has one |
/forks/partners/{partner} | one registered partner: who the fork is for, its slot and chain id, where it stands on the path to a genesis, and a rehearsal command with the held chain id |
/timestamps | GodCypher timestamps: each earthquake of magnitude 5 or more that at least two of five observatories (USGS, EMSC, GFZ GEOFON, INGV, GeoNet) locate independently, as a timestamp of its latitude, longitude, origin time and magnitude, read against the national time labs, digested, sealed, countersigned by GodCypher against a USGS earthquake window and with its raw evidence sealed to three parties. With the atomic watch, a world view and the list, newest first. Anchoring is not live yet, so every anchor reads pending. The old /prints addresses answer 308 to these |
/timestamps/godcypher | how a GodCypher timestamp works: the three-party envelope, the Urdarbrunn counter-validator and every outcome it reports, how the layers bound a timestamp in time, and what runs today against what is a library |
/timestamps/{id} | one GodCypher timestamp: its timestamp line, each observatory’s own report and event id, the time-lab readings when it was made, its digest, its seal, its GodCypher countersign and sealed evidence, its anchor status and how to check it yourself |
/hex/exchanges | STR on exchanges, when the operator names any (--hex-exchanges; a 404 otherwise): per exchange its name, pair, market id, page, integration contract if any, and the STR allocated to its liquidity with the account it is drawn from and its value in USD at this explorer’s market reference; per account its live STR from the chain and whether it covers every allocation drawn from it; and the total allocated, in STR and USD. Every USD figure is unknown with the reason until the reference has one. The cards are on /hex, without the coverage. Nothing is read from the exchanges |
/api/sale/{config|price|quote|delivery} | the sale service, asked by this server on the reader’s behalf: the chains and contracts the sale runs on, the STR price in USD with its source and age, a signed price quote for one wallet account, and the delivery state of one payment. Every answer is re-checked field by field before it is served; when no sale service is configured the config answers 200 with open false and no chains and the other routes 503, except that with --market-rpc-bsc the price route answers an hour-averaged market reference that carries no sale price, and with --market-rpc-eth beside it Chainlink ETH/USD as well |
/head | the handful of figures that change while a page is open — height, head, finality line, mempool depth and the last observed interval. The route the front page polls, and deliberately the cheapest answer here: no roll read, no state root, no window fold |
/de/{page} | every page above in German, under the /de prefix: the chrome and the pages are German, and a page not yet translated says so in German above its English text. Text the chain, the node or a legal document carries stays English, marked as English. Links stay in German; the JSON mirror, the assets, the files and the private payment-proof desk are not localised and answer 404 under /de |
/health | liveness, deliberately thin |
The node’s JSON-RPC door
One POST endpoint speaking JSON-RPC 2.0, served by a node rather than by this page. Whether a given node publishes that door at all, and to whom, is the operator’s decision: this explorer does not proxy it and does not hold a credential for it, and the public download surface for this chain deliberately publishes no shared RPC endpoint. Run a node and you have your own.
The catalogue below is 76 method(s), grouped by what answering one costs. A method that is not in this list does not exist: the door refuses an unknown method by name and tells the caller which names it has.
Reads — 44 methods
Answered from state the node already holds. Cheap, idempotent, and the whole of what an explorer or an indexer needs.
| Method | Parameters | What it answers |
|---|---|---|
getStatus | {} | chain id, height, head hash, pending count, and whether a write submitted here reaches the network |
submissionReach | {} | whether a record submitted here leaves this node, and when it does not, why not |
parameters | {} | the consensus parameters actually in force, governed values included |
genesis | {} | the genesis hash, the genesis chain id, and the two chain bindings a signature must carry |
blockByHeight | { height } | one block, whole, by its height. null past the head, because polling for the next block is not an error |
refusedRecords | {} | records this node considered and did not seal, each with the reason - the answer to 'it was accepted and nothing happened' |
attestationRetention | { height } | what the attestation set for a height IS, not merely how long it is - the answer to "the array was empty and nothing told me whether nobody signed or this node stopped holding them" |
blockByHash | { hashHex } | one block, whole, by its hash |
blockRange | { fromHeight, count? } | a bounded run of blocks from a height, for an indexer catching up; `count` defaults to 20 and the answer carries `nextHeight`, which is where to ask from next |
addressHistory | { address, depth? } | transfers touching an address, newest first, so a wallet can show what it RECEIVED and not only what it sent; scans at most the recent-block window and the answer carries `reachedGenesis`, true when that window covered the whole chain |
transactionProof | { txId } | a merkle proof that a transaction is in a block, with the header root to check it against |
balances | { address } | all seven ledgers for one address, with the rule each imposes, plus the settled and next nonce |
nonce | { address } | the settled nonce, the nonce the next signature must carry, and how many are in flight |
delegations | { master?, delegate? } | live Gefjon spending authorities, with how much of each cap this window has left |
transaction | { txId } | queued, settled, final, diverged, abandoned or honestly unknown. `unknown` is not `rejected` |
domainHolder | { domain } | who holds an STR.domain, allocated or proved, or nothing |
domainOf | { address } | the proved STR.domain an address holds, or nothing. The inverse of domainHolder, and the only way to learn a name the CHAIN derived rather than one a wallet claimed |
findDomain | { domain, address?, suggest? } | the whole standing of a name: available, booked, held, in burn cooldown, or barred to `address`. A `null` from domainHolder cannot tell those apart |
wnft | { wnftId } | a wNFT as the chain holds it: entries, versions, slaves and the lock |
wnftSequence | { wnftId } | the next sequence number an identity record must carry |
wnftAttribute | { wnftId, key } | the active value of a PUBLIC attribute. A private entry is a commitment and is never opened here |
contractNonce | { caller } | the next call nonce a contract authorization must sign over, queued records included |
contractCatalog | { address } | the callable ABI of a deployed contract |
contractEvents | { address, after?, limit? } | a page of the event feed of a deployed contract, oldest first, after the sequence cursor `after`. Paged and clamped: at most 256 events and 1 MiB of rows, and the answer says which cap it hit (`clamped`), how many events this node retains and has dropped, whether more remain and the cursor to ask from next. An event too large to fit a page alone comes back with its args withheld and their size stated |
contractStorage | { address, after?, limit? } | a page of a contract's storage slots in key byte order, after the key cursor `after`. Paged and clamped: at most 512 slots and 1 MiB of rows, and the answer says which cap it hit (`clamped`), how many slots the contract holds, whether more remain and the cursor to ask from next. A value too large to fit a page alone comes back withheld with its size stated |
governanceState | {} | the parameters in force and the assembly that decides them |
validatorRoll | {} | who may seal a block, at the height of the head, with every admission, eviction and suspension that got it there |
organisation | { domain } | an organisation and its departments: who holds it, who may sign for it, and where each department is paid. A department is NOT a signer |
collateralReserves | {} | reserves held against minted $TR, so a holder can check the peg themselves |
bridgeAttestors | {} | the keys this chain's genesis authorises to mint $TR. An empty list is a real answer |
accountAuthority | { address } | where an account authority is now, and the rotation index the next rotation of it must carry |
space | { spaceId } | one hostless space as this chain holds it: creator, visibility, price and the manifest root its content commits to. Public chain state, so no signature is asked for |
spaceList | { limit?, after? } | the hostless spaces this chain holds, in chain order, one page at a time: at most 64 rows, and `next` is the cursor to pass as `after` for the following page (null on the last). Says nothing about content: the chain never sees a chunk |
spacesFor | { reader, limit?, after? } | the spaces that name one reader — { kind: address|domain, id } — as their creator or on a grant, from the registry index rather than a scan, paged like spaceList. Each row says the role, any lapse height and whether the grant has lapsed. Public chain state, so no signature is asked for |
spaceRecords | { spaceId } | the creator-signed Oort records that built a space — create, grants, revokes and rotations. A light reader replays them itself to derive the anchored root from the creator's signature rather than this node's word. Public chain state, not a block body |
spaceHolders | { spaceId } | which nodes this node believes are holding a space, from its own Arecibo index, whether it is announcing the space itself, and the own id of this node (what a key request names as its audience) |
occultationInbox | { domain } | a participant's published inbox key — the hybrid KEM public key a sender seals to — as this chain holds it, or null. Public chain state |
occultationThread | { threadId, reader? } | a thread as this chain holds it: its head, its current key epoch, its opener, its current participants and every member it has ever had. The head is what a new post must name. With reader, also this chain's verdict on whether that domain may read the current epoch. Null for a thread this chain has never seen |
occultationTranscript | { threadId, from?, limit? } | a page of a thread's transcript index: each post's position, sender, epoch, commitment, the head it extended, the height it landed at, and every reader who has signed a receipt for it. Commitments only — the chain holds no message body, so neither does this. Paged and clamped; the answer says what it clamped to and whether more remain |
occultationPost | { threadId, commitmentHex } | one post as this chain holds it and the readers who signed for it — did the message land, where in the thread, at what height, and who acknowledged it. A receipt says a reader who MAY read was willing to sign for the message; it is not proof of delivery, which no chain can see |
occultationMayRead | { threadId, reader, epoch } | whether this chain says a domain may read a thread at a given key epoch, and the reason either way. Asked about an epoch and not about the present, because a message belongs to the epoch it was written under |
occultationNonce | { address } | the highest Occultation nonce a signer has SETTLED, or null for one that has never signed here. Settled, not pending: a client producing several records before the next block counts up locally from this |
occultationRekey | { threadId, epoch } | the wrap commitment per participant that the open (epoch 0) or rekey record of a thread epoch carried, and the height and block it landed in, from a NODE-LOCAL index of the blocks this node holds. Not chain state and in no state root: a miss says whether it is authoritative (complete) or only this node not knowing (pruned, catching up). A reader checks a delivered wrap against this before keeping its key |
courierStatus | {} | whether this node runs a Talaria courier for STR.talk, the reason when it does not, how full it is in counts only, and every bound it holds itself to. Off by default; never on a validator seat |
Compute — 2 methods
The node does bounded work to answer. Still a read — nothing is committed, nothing is kept — but it is not free, so do not poll one.
| Method | Parameters | What it answers |
|---|---|---|
succinctCheckpoint | {} | this node's Urd checkpoint — the constant-size recursive proof folded over its whole chain, so a light client that folded the chain itself can compare its own proof against this node's at the same height in one 32-byte comparison. Priced as compute: the fold recomputes a hash per block, and a node still folding its history refuses with how far it has got |
simulateCall | { address, functionName, caller, args?, trace? } | runs a call against current state and commits nothing. Gas-bounded. Not a promise: state may move before a queued call is sealed. Set trace:true for a node-local developer-mode per-step VM trace |
Writes — 30 methods
A signed record is offered to the network. The answer says whether it was accepted for relay, which is not the same as settled: watch for it in a block.
| Method | Parameters | What it answers |
|---|---|---|
submitTransaction | { record } | a signed transfer. Announced to the network when this node has a runtime |
allocateDomain | { record } | a signed STR.domain claim. Announced. An allocated domain may RECEIVE and nothing more; submitRegistration is what admits a transaction |
submitRegistration | { record } | a signed STR.domain proof, which locks 1000 STR. Announced. Takes a proof, never a key |
submitWnft | { record } | an identity record: a new version, a hide, a burn, a slave. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitGovernance | { record } | a proposal, a ballot or an execution. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitCollateral | { record } | a bridge mint or redemption, signed by a genesis attestor. Does NOT gossip |
submitCollateralVeto | { record } | holds a pending bridge mint that ONE declared attestor says is fraudulent, signed by that attestor. Announced to the network when this node has a runtime, unlike every other record submission here, because the challenge window is 600 blocks and a veto waiting for this node slot may arrive after the mint has credited. Holds indefinitely and does not reverse; governance is the only release |
submitAttestorSuspension | { record } | fetters a bridge attestor whose key a quorum believes is compromised. Announced, for the veto reason. From the next block the signature stops counting toward a mint quorum. The threshold is counted against the DECLARED set and never the active one, so a suspension can only make minting harder |
submitDomainBurn | { record } | a signed burn: the one path back out of the 1000 STR lock. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitDomainRelinquish | { record } | a signed relinquish: gives a name up and starts a 30-day lapse clock. Refunds nothing and frees nothing yet. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitDomainLapseBurn | { record } | a signed lapse burn: destroys a relinquished name after its 30 days. The refund goes to the FORMER HOLDER, never to the executor. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitWnftTransfer | { record } | a domain sale, signed by BOTH parties over identical bytes. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitGefjon | { record } | a spending delegation: a grant or revocation signed by the master, or a spend signed by the delegate. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitFenrir | { record } | a validator bond record - Fenrir: a bond posted, its unbonding begun, or its withdrawal taken. Signed by the key that SEALS BLOCKS, because that is the key an ejection names, and a bond signed by any other key is refused at this door. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
submitWrapRecord | { record } | a signed WSTR wrap or unwrap. Queued on THIS node and NOT gossiped from this door: Kvasir carries the kind between peers, but this method writes to the local chain queue, so it waits for the slot of THIS node - up to one full rotation of the validator roll. See submissionReach |
submitKeyRotation | { record } | an account key rotation: signed by BOTH the retiring key and the new one over identical bytes. Moves the STR.domain, the lock and every balance to the new address and retires the old one. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, because a holder rotating off an exposed key is racing whoever holds it. Checked at this door for shape, size and both signatures before it is announced. See submissionReach |
deployContract | { source: { name, source, compilerVersion? }, deployer, salt?, authorization? } | queues a deployment and returns the address it will have. Nothing executes here. `compilerVersion`, when given, is checked BY NAME against the compiler this node runs and the rule version in force, and a mismatch is refused rather than compiled - the address is derived from the bytecode THIS node builds, so a foreign compiler is a different address on every node that runs one |
callContract | { address, functionName, caller, args?, authorization? } | queues a call for the next block. Returns a receipt, not a result — use simulateCall for that |
submitOortRecord | { record } | a signed Oort record — create, grant, revoke or rotate. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, so a space does not wait for the one seat a public endpoint happens to front. Checked at this door for shape, size, Styx and the creator signature against this chain before it is announced. See submissionReach |
spaceAnnounce | { request, beacon } | a creator-signed beacon, so this node announces it is holding the space. Refused unless the request is signed by the space's creator and the chain says the space is public |
spacePublish | { request, manifest, chunk } | one sealed 256 KiB chunk into this node's store, for it to serve. Refused unless the request is signed by the space's creator. No key crosses this door and this node cannot read what it serves |
spaceFetch | { request } | asks the holders Arecibo named for a whole space epoch, on behalf of a reader the chain says may read it. Returns a verdict, not the content |
spaceManifest | { request, epoch? } | what this node holds of a space and which chunks are still missing. Priced as a write: it costs a signature verification |
spaceChunk | { request, epoch, index } | one sealed chunk and its Merkle proof, to a reader the chain says may read it. Ciphertext only — the space key is never here, in either direction |
spaceDeliverEnvelope | { envelope } | a Perihelion key envelope: the space key wrapped to ONE reader's KEM public key and signed by the space's creator, kept on this holder for that reader to fetch. Refused unless the signature is the creator's on this chain and the chain admits the reader. This node cannot open it, and a validator seat keeps none |
spaceEnvelope | { request } | the key envelope this holder keeps for the reader who signed a KEY request naming this holder as its audience (its node id, from spaceHolders), or null and why. Refused on a validator seat, and to a reader the chain does not admit. Only the reader's own KEM secret opens it. Priced as a write: it costs a signature verification |
submitOccultationRecord | { record } | a signed Occultation record — an inbox key published, a thread opened, re-keyed, posted to or acknowledged — queued for a block. The chain holds no plaintext: only the commitment. Announced to the network when this node has a runtime: it is gossiped over Kvasir and sealed by whichever node leads next, rather than waiting for the slot of THIS node. Checked at this door for shape, size and signature before it is announced. See submissionReach |
courierDeposit | { parcel } | one parcel sealed to a recipient's published Occultation inbox key, held until collected or expired. Anonymous, judged on shape and bounds only - the courier holds no key and cannot read it - and metered per client. Refused for a domain whose inbox key on this chain is not the one the parcel was sealed to |
courierFetch | { request } | a page of the signer's parcels, oldest first, to a fetch request signed by the account this chain says holds the domain. Sealed bytes only. Priced as a write: it costs a signature verification |
courierAck | { request } | forgets parcels the recipient has safely stored, to an acknowledgement signed by the holder of the domain. Ids addressed to anybody else are ignored |
Read on
- Knowledge base — which document to read before writing a client
- Multichain API — what is and is not offered across several chains
- Explorer as a Service — running this surface against a chain of your own
- Network status — what the node answering these calls has verified