2026-09-22 01:10:05 +02:00
<!doctype html>
< html lang = "en" >
< head >
< meta charset = "utf-8" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
< title > Docs — Sirius.X< / title >
< meta name = "description" content = "How BCNR works: the TLD registry, name registration, records, resolver, and how to verify anything against the Bitcoin Cash chain." >
< link rel = "icon" href = "../assets/favicon.svg" type = "image/svg+xml" >
< link rel = "mask-icon" href = "../assets/favicon.svg" color = "#d6ff3d" >
< meta property = "og:type" content = "website" >
< meta property = "og:site_name" content = "Sirius.X" >
< meta property = "og:title" content = "Sirius.X docs — how BCNR works" >
< meta property = "og:description" content = "The TLD registry, name registration, records, resolver, mainnet pricing, and how to verify anything against the chain." >
< meta property = "og:url" content = "https://silentmode.st/sirius-x/docs/" >
< meta property = "og:image" content = "https://silentmode.st/sirius-x/brand/banner.svg" >
< meta name = "twitter:card" content = "summary" >
< link rel = "preconnect" href = "https://fonts.googleapis.com" >
< link rel = "preconnect" href = "https://fonts.gstatic.com" crossorigin >
< link href = "https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,300;9..144,400;9..144,500;9..144,600;9..144,700&family=DM+Sans:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&family=Ubuntu:wght@400;500;700&display=swap" rel = "stylesheet" >
< style >
:root{
--bg:#050810; --panel:#141a24; --panel2:#0a0f1c; --line:rgba(255,255,255,.06);
--ink:#f1f4fa; --mut:#b8c2d4; --dim:#6a7488; --acid:#d6ff3d;
--ok:#4fd1a5; --warn:#ffc75f;
}
*{box-sizing:border-box}
html{scroll-behavior:smooth}
body{margin:0;background:radial-gradient(ellipse 1200px 600px at 50% -5%,#131a2a 0%,transparent 60%),radial-gradient(ellipse 900px 500px at 100% 100%,#0a0f1c 0%,transparent 55%),radial-gradient(ellipse 900px 500px at 0% 100%,#0c1424 0%,transparent 55%),var(--bg);
color:var(--ink);font:16px/1.65 system-ui,-apple-system,Segoe UI,Roboto,sans-serif;min-height:100vh}
a{color:var(--acid)}
.wrap{max-width:900px;margin:0 auto;padding:0 1.2rem}
.topnav{position:sticky;top:0;z-index:20;display:flex;gap:2px;align-items:center;flex-wrap:wrap;
padding:10px 1.2rem;background:rgba(11,14,20,.82);backdrop-filter:blur(10px)}
.topnav .brand{font-weight:600;color:var(--ink);text-decoration:none;margin-right:14px;font-size:15px;letter-spacing:.2px}
.topnav .brand .g{color:var(--acid)}
.topnav a{color:var(--mut);text-decoration:none;padding:6px 12px;border-radius:8px;font-size:14px}
.topnav a:hover{color:var(--ink);background:var(--panel)}
.topnav a.here{color:var(--acid);background:rgba(214,255,61,.08)}
.topnav a.portal{margin-left:auto;background:rgba(214,255,61,.10);color:var(--acid);font-weight:500}
.topnav a.portal:hover{background:rgba(214,255,61,.18)}
/* Adaptive side nav — same shape as index.html and Theseus.X */
:root{--sn-w:200px}
.sidenav{position:fixed;top:56px;left:0;bottom:0;width:var(--sn-w);z-index:15;
background:transparent;padding:32px 12px 22px 18px;
overflow-y:auto;pointer-events:none;transition:width .15s ease}
.sidenav a{display:flex;align-items:center;gap:14px;color:var(--mut);text-decoration:none;
padding:9px 12px;border-radius:10px;
font-size:14.5px;font-weight:500;opacity:.35;pointer-events:auto;
transition:opacity .12s,color .12s,background .12s,backdrop-filter .12s}
.sidenav a .ic{flex:none;width:22px;font-size:18px;line-height:1;text-align:center;
display:none;justify-content:center;align-items:center}
.sidenav a .lb{flex:1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.sidenav a:hover{opacity:1;color:var(--ink);background:rgba(11,14,20,.72);backdrop-filter:blur(8px)}
.sidenav a.active{opacity:.85;color:var(--acid)}
.sidenav a.active:hover{opacity:1}
section{scroll-margin-top:70px}
@media (max-width:1180px){
:root{--sn-w:64px}
.sidenav{padding:22px 6px}
.sidenav a{justify-content:center;padding:12px 4px;gap:0}
.sidenav a .ic{display:inline-flex}
.sidenav a .lb{display:none}
}
@media (max-width:720px){
:root{--sn-w:0}
body{padding-bottom:64px}
.sidenav{top:auto;bottom:0;left:0;right:0;width:100%;height:auto;
padding:4px;flex-direction:row;background:rgba(11,14,20,.52);
display:flex;justify-content:space-around;overflow-x:auto;
/* Hide the horizontal scrollbar chrome — the icons still scroll if
they overflow, they just don't paint a green Windows scroll rail
underneath the mobile nav. */
scrollbar-width:none;-ms-overflow-style:none}
.sidenav::-webkit-scrollbar{display:none;width:0;height:0}
.sidenav a{flex:1;min-width:44px;padding:8px 4px;justify-content:center;gap:0;opacity:.5;font-size:15px}
.sidenav a .ic{display:inline-flex}
.sidenav a .lb{display:none}
}
header.hero{text-align:center;padding:4rem 1.2rem 1rem}
.mark{font-size:52px;line-height:1}
h1{font-size:clamp(1.8rem,4.8vw,2.5rem);margin:.4rem 0 .3rem}
h1 .g{color:var(--acid)}
.tag{color:var(--mut);font-size:1.05rem;max-width:660px;margin:0 auto}
/* Single-column content — the section index lives in the left .sidenav
rail (fixed, sticky, always visible) so an inline TOC would just
duplicate it. Cap width for readability. */
.doc-grid{max-width:820px;margin:1.5rem 0 0}
.toc{position:sticky;top:60px;align-self:start;background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:14px 16px;font-size:14px}
.toc h4{margin:0 0 8px;color:var(--mut);font-size:12px;text-transform:uppercase;letter-spacing:.6px;font-weight:600}
.toc a{display:block;padding:5px 8px;border-radius:6px;color:var(--mut);text-decoration:none;font-size:13.5px}
.toc a:hover{background:var(--panel2);color:var(--ink)}
section{padding:1.6rem 0 2.4rem;border-top:1px solid var(--line);margin-top:1rem}
section:first-of-type{border-top:none;margin-top:0}
h2{font-size:1.35rem;margin:0 0 .5rem}
h3{font-size:1.05rem;margin:1.4rem 0 .35rem}
.lede{color:var(--mut);margin:0 0 1rem;max-width:720px}
ol.steps{counter-reset:s;list-style:none;padding:0;margin:1.2rem 0 0;display:grid;gap:10px}
/* Previously this list used display:grid on each < li > with two columns.
That put every direct child in column 2, but bare text nodes between
inline elements (b, code) became anonymous grid items placed by
autoflow — they landed in the 30px counter column and each word
wrapped one-per-line. Padding + absolute counter puts the number in
the same visual spot without touching how inline content flows. */
ol.steps li{counter-increment:s;position:relative;
background:var(--panel2);border:1px solid var(--line);border-radius:12px;
padding:13px 16px 13px 54px}
ol.steps li::before{content:counter(s);position:absolute;left:16px;top:13px;
display:grid;place-items:center;width:24px;height:24px;border-radius:50%;
background:rgba(214,255,61,.14);color:var(--acid);font-size:12.5px;font-weight:700}
ol.steps b{color:var(--ink)} ol.steps span{color:var(--mut);font-size:14px}
.note{background:var(--panel);border:1px solid var(--line);border-left:3px solid var(--acid);
border-radius:10px;padding:14px 18px;color:var(--mut);font-size:14px;margin-top:1.2rem}
.note.warn{border-left-color:var(--warn)}
.note b{color:var(--ink)}
code,.mono{background:#0e131b;border:1px solid var(--line);border-radius:6px;padding:1px 6px;font-family:ui-monospace,monospace;font-size:13px;word-break:break-all}
pre{background:#0e131b;border:1px solid var(--line);border-radius:10px;padding:12px 14px;overflow-x:auto;
font-family:ui-monospace,monospace;font-size:13px;color:var(--ink);margin:1rem 0}
table.pricing{width:100%;border-collapse:collapse;margin-top:1rem;font-size:14px}
table.pricing th,table.pricing td{padding:8px 12px;text-align:left;border-bottom:1px solid var(--line)}
table.pricing th{color:var(--mut);font-weight:500;font-size:12.5px;text-transform:uppercase;letter-spacing:.4px}
table.pricing td.price{font-family:ui-monospace,monospace;color:var(--acid);font-weight:600}
.verify dt{color:var(--mut);font-size:12.5px;text-transform:uppercase;letter-spacing:.3px;margin-top:10px}
.verify dt:first-of-type{margin-top:0}
.verify dd{margin:2px 0 0;font-family:ui-monospace,monospace;font-size:12.5px;word-break:break-all;color:var(--ink)}
footer{border-top:1px solid var(--line);padding:2rem 0 3rem;color:var(--dim);font-size:13px;text-align:center;margin-top:2.5rem}
/* Deviant-family fonts + Fraunces/Ubuntu reader toggle. */
h1,h2,h3{font-family:'Fraunces',Georgia,serif;font-feature-settings:"ss01","ss02"}
code,.mono{font-family:'JetBrains Mono',ui-monospace,monospace}
body{font-family:'DM Sans','Inter',system-ui,sans-serif !important;font-feature-settings:"ss01","ss02"}
html[data-font-cmp="ubuntu"] body,html[data-font-cmp="ubuntu"] h1,html[data-font-cmp="ubuntu"] h2,html[data-font-cmp="ubuntu"] h3,html[data-font-cmp="ubuntu"] p,html[data-font-cmp="ubuntu"] a,html[data-font-cmp="ubuntu"] button,html[data-font-cmp="ubuntu"] span,html[data-font-cmp="ubuntu"] div,html[data-font-cmp="ubuntu"] label,html[data-font-cmp="ubuntu"] input,html[data-font-cmp="ubuntu"] li{font-family:'Ubuntu',system-ui,sans-serif !important}
html[data-font-cmp="ubuntu"] code,html[data-font-cmp="ubuntu"] .mono{font-family:'JetBrains Mono',ui-monospace,monospace !important}
.font-picker{display:inline-flex;align-items:center;gap:2px;padding:2px;margin:0 10px;background:rgba(255,255,255,.04);border:1px solid rgba(255,255,255,.08);border-radius:999px;font-family:'JetBrains Mono',monospace;font-size:10px;letter-spacing:.12em;text-transform:uppercase}
.font-picker button{background:transparent;border:none;color:var(--dim);padding:4px 10px;border-radius:999px;cursor:pointer;font-family:inherit;font-size:inherit;letter-spacing:inherit;text-transform:inherit}
.font-picker button:hover{color:var(--ink)}
.font-picker button.active{background:var(--acid);color:var(--bg);font-weight:600}
< / style >
< script type = "importmap" >
{ "imports": { "@bitauth/libauth": "https://silentmode.st/js/libauth.js?v=20260920usd" } }
< / script >
< script src = "../js/i18n.js?v=20260921c" > < / script >
< / head >
< body >
< nav class = "topnav" >
site-sirius-x: only paint .X acid; keep Sirius white
Brand button was wrapping the whole "Sirius.X" label in <span class="g">,
so the entire name rendered acid green. Consistency across the ecosystem
is Sirius (ink) + .X (acid), like Theseus.X and Hephaestus.X. Split the
span across every page (index, tld, portal, admin, brand, docs, market,
storage, theseus/) so only the .X tail carries the acid tint.
2026-09-22 01:28:25 +02:00
< a class = "brand" href = "../" > < svg width = "18" height = "18" viewBox = "0 0 64 64" style = "vertical-align:-4px;margin-right:6px" aria-hidden = "true" > < rect width = "64" height = "64" rx = "12" fill = "#0b0e14" / > < path d = "M32 4 L36.4 27.6 L60 32 L36.4 36.4 L32 60 L27.6 36.4 L4 32 L27.6 27.6 Z" fill = "#d6ff3d" / > < / svg > Sirius< span class = "g" > .X< / span > < / a >
2026-09-22 01:10:05 +02:00
< a href = "../tld.html" > 🌐 TLD< / a >
< a href = "../market/" > 🛒 Market< / a >
< a href = "../theseus/" > < svg width = "14" height = "14" viewBox = "0 0 64 64" style = "vertical-align:-2px;margin-right:4px" aria-hidden = "true" > < rect width = "64" height = "64" rx = "12" fill = "#0b0e14" / > < path d = "M32 6 L38 32 L26 32 Z" fill = "#e04e4e" / > < path d = "M38 32 L32 58 L26 32 Z" fill = "#d6ff3d" / > < path d = "M6 32 L32 27 L58 32 L32 37 Z" fill = "#d6ff3d" opacity = ".55" / > < circle cx = "32" cy = "32" r = "3" fill = "#0b0e14" / > < / svg > Theseus< span class = "g" > .X< / span > < / a >
< a href = "../portal.html" class = "portal" > 🔑 Sign in< / a >
< / nav >
< aside class = "sidenav" aria-label = "On this page" >
< a href = "#tld-registry" title = "The TLD registry" > < span class = "ic" aria-hidden = "true" > 🌐< / span > < span class = "lb" > TLD registry< / span > < / a >
< a href = "#register-name" title = "Register a name" > < span class = "ic" aria-hidden = "true" > ✏️< / span > < span class = "lb" > Register a name< / span > < / a >
< a href = "#private-tlds" title = "Private & co-sign TLDs" > < span class = "ic" aria-hidden = "true" > 🔒< / span > < span class = "lb" > Private TLDs< / span > < / a >
< a href = "#market" title = "Buying & selling names" > < span class = "ic" aria-hidden = "true" > 🛒< / span > < span class = "lb" > Market< / span > < / a >
< a href = "#records" title = "Records & hosting" > < span class = "ic" aria-hidden = "true" > 📋< / span > < span class = "lb" > Records< / span > < / a >
< a href = "#signed-records" title = "Signed off-chain records" > < span class = "ic" aria-hidden = "true" > 🔐< / span > < span class = "lb" > Signed records< / span > < / a >
< a href = "#host" title = "Host your name" > < span class = "ic" aria-hidden = "true" > 🏠< / span > < span class = "lb" > Host your name< / span > < / a >
< a href = "#resolver" title = "Resolver / gateway" > < span class = "ic" aria-hidden = "true" > 🧭< / span > < span class = "lb" > Resolver< / span > < / a >
< a href = "#pricing" title = "Pricing (mainnet)" > < span class = "ic" aria-hidden = "true" > 💰< / span > < span class = "lb" > Pricing< / span > < / a >
< a href = "#tracker" title = "Tracker & mirrors" > < span class = "ic" aria-hidden = "true" > 📡< / span > < span class = "lb" > Tracker< / span > < / a >
< a href = "#verify" title = "Verify anything" > < span class = "ic" aria-hidden = "true" > ✅< / span > < span class = "lb" > Verify< / span > < / a >
< a href = "#runbook" title = "Operator runbook" > < span class = "ic" aria-hidden = "true" > 🛠️< / span > < span class = "lb" > Runbook< / span > < / a >
< / aside >
< header class = "hero" >
< div class = "mark" > 📚< / div >
< h1 > Sirius.X < span class = "g" > docs< / span > < / h1 >
< p class = "tag" > How the pieces fit together: the TLD registry, name registration, records that
tell the resolver where a site lives, the resolver itself, and how anyone can verify anything
against the chain.< / p >
< / header >
< div class = "wrap" >
< div class = "doc-grid" >
< div >
< section id = "tld-registry" >
< h2 > The TLD registry< / h2 >
< p class = "lede" > Every BCNR name lives under a < b > top-level domain< / b > whose certificate is
itself a first-class token on the Bitcoin Cash chain — an NFT with the TLD label as its
commitment, paying dust to a dedicated TLD-registry beacon. That certificate is the
on-chain proof the TLD exists, and once enforcement ships, it is what makes any
second-level name under it valid to conforming resolvers.< / p >
< p class = "lede" > Fourteen public TLDs on chipnet today (2026-08-29):
< code > bch p2p bit nav test x asm neo gt sc sia dex cex nt< / code > . The current list and
per-TLD categories are at
< a href = "https://silentmode.st/tlds/" > silentmode.st/tlds/< / a > .< / p >
< div class = "note" > < b > Why per-TLD certs, not a single list.< / b > Without a registry, anyone
could quietly declare a TLD against the same beacon by minting a name under it. That
leaves resolvers in silent disagreement. Per-TLD certificates make the TLD set itself
something the chain records, so every resolver sees the same list — and TLDs become
ownable assets that can carry policy, fees, and governance of their own.< / div >
< / section >
< section id = "register-name" >
< h2 > Register a name — end to end< / h2 >
< p class = "lede" > The buyer's certificate mints straight to a wallet they control, in one
transaction that also publishes the initial records and pays the beacon. Nobody
including the operator can take the name back — the covenant work in progress adds an
expiry / reclaim clock but does not change who controls the key.< / p >
< ol class = "steps" >
< li > < b > Search a label across every TLD.< / b >
< span > The registrar fans out to every TLD in the registry in parallel and shows
available / taken per row. Available names appear first.< / span > < / li >
< li > < b > Create or connect a wallet.< / b >
< span > Built-in browser wallet (PBKDF2 → AES-GCM in localStorage) or WizardConnect to
Cashonize / Paytaca — both mint to the buyer's own key.< / span > < / li >
< li > < b > Confirm the price.< / b >
< span > Miner fee + beacon dust + certificate dust + service fee. Chipnet placeholder
is 10,000 sat; real pricing is a mainnet decision.< / span > < / li >
< li > < b > The certificate lands in your wallet.< / b >
< span > The name resolves the moment the transaction confirms. Records can be set or
changed later — only your key can sign a UPD.< / span > < / li >
< / ol >
< / section >
< section id = "private-tlds" >
< h2 > Private & co-sign TLDs< / h2 >
< p class = "lede" > A TLD owner decides who may register names under it, and the decision is
enforced by every resolver, not just by the shop. Three switches live in the TLD's
on-chain records (a < code > TUPD< / code > signed by the owner's key):< / p >
< table class = "pricing" >
< tr > < th > Record< / th > < th > Who can register< / th > < th > How it is enforced< / th > < / tr >
< tr > < td > < code > hidden: 1< / code > (switched off)< / td >
< td > Only the owner, from the dashboard. Off the public list.< / td >
< td > Co-sign rule (below).< / td > < / tr >
< tr > < td > < code > policy: "cosign"< / code > < / td >
< td > Anyone, but every registration needs the owner's approval.< / td >
< td > Co-sign rule (below).< / td > < / tr >
< tr > < td > < code > policy: "frozen"< / code > < / td >
< td > Nobody, owner included.< / td >
< td > Resolvers drop every new registration.< / td > < / tr >
< / table >
< h3 style = "margin-top:1.4rem" > The co-sign rule< / h3 >
< p > A registration under a < code > cosign< / code > or < code > hidden< / code > TLD is only recognised
when the same transaction also < b > carries the TLD's own certificate< / b > — the TLD NFT
goes in as an input and comes back out to its owner. Only the owner's key can spend that
NFT, so its presence is a signature nobody can forge, and nothing is consumed: the
certificate returns in the same transaction. Every conforming client (gateway, Theseus,
Ariadne desktop and mobile) applies the rule when it builds its index, judging each
registration against the TLD policy < b > in force at that block< / b > , so switching a TLD
off later never invalidates names registered while it was open.< / p >
< ol class = "steps" >
< li > < b > Owner registering under a private TLD.< / b >
< span > Open the TLD in the dashboard, type a label, register. The certificate is added
from your own wallet; you pay only the platform share of the name price.< / span > < / li >
< li > < b > Anyone registering under a co-sign TLD.< / b >
< span > The normal register flow builds the full transaction with the owner's certificate
as its last input, you sign your part, and the request waits in the gateway's approval
queue (< code > POST /api/cosign< / code > ). Nothing leaves your wallet until the owner
acts; requests expire after 7 days.< / span > < / li >
< li > < b > Owner approving.< / b >
< span > Dashboard → the TLD → < b > Pending approvals< / b > . Approve signs the certificate
input and broadcasts; Decline removes the request. The wallet refuses to sign any
request that would not return the certificate to you.< / span > < / li >
< / ol >
< div class = "note" > < b > Why not a covenant?< / b > A covenant-gated mint is the mainnet plan for
fee enforcement; the co-sign rule needs no new script, works today with plain P2PKH
certificates, and gives the owner a human veto rather than a formula.< / div >
< / section >
< section id = "market" >
< h2 > Buying & selling names< / h2 >
< p class = "lede" > Any name can be sold to anyone, in < b > one transaction, with no escrow< / b > .
The seller is paid exactly when the certificate moves — or not at all.< / p >
< ol class = "steps" >
< li > < b > Seller lists.< / b >
< span > Dashboard → the name → < b > Sell< / b > , set a price. Your wallet signs a partial
transaction — your certificate as input 0, the price to you as output 0 — with
< code > SIGHASH_SINGLE | ANYONECANPAY< / code > . That signature says "whoever completes this
pays me this much"; it constrains nothing else. The gateway stores it and shows it on
the < a href = "../market/" > market< / a > after checking the signature, the on-chain
owner and that the certificate is still unspent.< / span > < / li >
< li > < b > Buyer completes.< / b >
< span > Verify the offer locally, add your coins, add the certificate output to your own
token address plus a registry update so every resolver learns the new owner, sign your
inputs, broadcast. The seller's signature is already in place.< / span > < / li >
< li > < b > Seller cancels.< / b >
< span > Cancelling removes the offer from the market and moves the certificate once (a
no-op update, a few cents), so the signed offer can never be completed afterwards.< / span > < / li >
< / ol >
< div class = "note" > < b > Trust model.< / b > The gateway is a bulletin board. A forged or stale
listing fails the buyer's local check or the broadcast; a buyer can never pay without
receiving the certificate in the same transaction, and a seller can never lose the
certificate without being paid. Endpoints: < code > GET /api/market< / code > ,
< code > GET /api/market/< name> < / code > , < code > POST /api/market< / code > (a signed listing),
< code > DELETE /api/market/< name> < / code > (owner-signed
< code > BNS-MARKET1
< name>
< ts> < / code > ).< / div >
< / section >
< section id = "records" >
< h2 > Records & hosting< / h2 >
< p class = "lede" > A registered name carries a small JSON records object. Every record is
optional and multiple can coexist. Priority order the gateway uses:
< code > h< / code > (inline HTML) → < code > s3< / code > (Sia bucket key) → < code > ip< / code >
(host header served by an IP) → < code > u< / code > (redirect).< / p >
< table class = "pricing" >
< thead > < tr > < th > Record< / th > < th > Meaning< / th > < th > Typical use< / th > < / tr > < / thead >
< tbody >
< tr > < td > < code > h< / code > < / td > < td > Inline HTML in the OP_RETURN payload itself< / td > < td > Tiny sites, a profile, a link hub< / td > < / tr >
< tr > < td > < code > s3< / code > < / td > < td > A Sia bucket key (with auto-index for directory-style)< / td > < td > Multi-file sites, permanent hosting< / td > < / tr >
< tr > < td > < code > ip< / code > < / td > < td > An IPv4 address + optional < code > tls< / code > fingerprint< / td > < td > Your own server, apps behind an IP< / td > < / tr >
< tr > < td > < code > u< / code > < / td > < td > Redirect URL< / td > < td > Short-form redirects to any web host< / td > < / tr >
< tr > < td > < code > tls< / code > < / td > < td > SHA-256 fingerprint of the leaf cert served at < code > ip< / code > < / td > < td > Chain-pinned TLS trust, no OS root store needed< / td > < / tr >
< tr > < td > < code > np< / code > , < code > nr< / code > < / td > < td > Nostr pubkey + relay list< / td > < td > Hermes / NIP-17 messaging bound to the name< / td > < / tr >
< tr > < td > < code > el< / code > < / td > < td > Space-separated electrum server list< / td > < td > On-chain-updatable resolver bootstrap< / td > < / tr >
< / tbody >
< / table >
< p class = "lede" style = "margin-top:1rem" > Subdomains inherit from their parent with a slight
priority tweak: for a subdomain query, < code > ip< / code > beats < code > s3< / code >
(Host-header semantics). Full rule is in < code > Argus/src/lib/record-picker.js< / code > .< / p >
< / section >
< section id = "signed-records" >
< h2 > Free edits — signed off-chain records< / h2 >
< p class = "lede" > The on-chain records above (< code > h< / code > , < code > s3< / code > , < code > ip< / code > , < code > u< / code > ,
< code > tls< / code > , < code > np< / code > , < code > el< / code > ) cost a chain transaction to change and are capped
at 200 bytes of OP_RETURN. For DNS-style records (A / AAAA / MX / TXT / CNAME / NS) and any records
you edit often, Sirius.X uses a companion mechanism: a < b > signed off-chain manifest< / b > that costs
nothing per change and has no size cap.< / p >
< p class = "lede" style = "margin-top:1rem" > < b > The chain says who owns the name. A signed blob says what
the records are. Resolvers verify both.< / b > No third party is trusted for records: the manifest is
signed by the same key that holds the on-chain NFT certificate, so an operator (or Sia farmer, or
anyone else in the middle) can't rewrite records without breaking the signature.< / p >
< table class = "pricing" style = "margin-top:1.2rem" >
< thead > < tr > < th > Concern< / th > < th > Where it lives< / th > < th > Cost per change< / th > < / tr > < / thead >
< tbody >
< tr > < td > Who owns the name< / td > < td > Bitcoin Cash chain (NFT certificate)< / td > < td > 1 tx to transfer< / td > < / tr >
< tr > < td > Where the site lives< / td > < td > Chain record: < code > s3< / code > , < code > ip< / code > , < code > u< / code > , < code > h< / code > < / td > < td > 1 tx per change< / td > < / tr >
< tr > < td > DNS records, meta, TXT churn, etc.< / td > < td > Sia at < code > < s3-bucket> /_records.json< / code > < / td > < td > < b style = "color:var(--acid)" > free< / b > < / td > < / tr >
< / tbody >
< / table >
< h3 style = "margin-top:1.4rem" > How the manifest is verified< / h3 >
< ol class = "steps" style = "counter-reset:s" >
< li > < b > Resolver reads< / b > the name's chain record, follows < code > records.s3< / code > to the Sia bucket,
fetches < code > _records.json< / code > .< / li >
< li > < b > Signature check< / b > — recovers the signing pubkey from the manifest's < code > sig< / code > field,
derives the CashAddress, compares to the current NFT-holder address from the chain. Mismatch = reject.< / li >
< li > < b > Replay check< / b > — the manifest carries a monotonic < code > seq< / code > number. Resolvers cache the
highest seen and reject anything less-or-equal. An old signed blob can't be re-served.< / li >
< li > < b > Fall-back< / b > — if the manifest is missing, invalid, or its signature doesn't match, the resolver
silently falls back to the on-chain records. Signed records never override a name; they extend it.< / li >
< / ol >
< h3 style = "margin-top:1.4rem" > The manifest shape< / h3 >
< pre style = "background:#0e131b;border:1px solid var(--line);border-radius:10px;padding:14px 16px;overflow-x:auto;font-family:ui-monospace,monospace;font-size:12.5px;line-height:1.6;color:var(--ink);white-space:pre;margin-top:.6rem" > {
"v": 1,
"name": "bitcoin.cash",
"seq": 42,
"updated_at": "2026-09-15T00:00:00Z",
"dns": {
"A": ["1.2.3.4"],
"AAAA": ["2001:db8::1"],
"MX": [{"pref": 10, "host": "mail.example.com"}],
"TXT": ["v=spf1 include:_spf.silentmode.st -all"],
"CNAME": null,
"NS": []
},
"sig": "< BCH message signature over sha256(canonical bytes)> "
}< / pre >
< p class = "lede" style = "margin-top:.8rem" > Canonicalisation: sorted keys, no whitespace, < code > null< / code >
fields omitted. The signable bytes are the manifest with the < code > sig< / code > field removed. Full
spec: < a href = "./DESIGN-signed-records-manifest.md" > < code > DESIGN-signed-records-manifest.md< / code > < / a >
— signable byte order, seq-monotonicity rules, threat model, v2 roadmap.< / p >
< h3 style = "margin-top:1.4rem" > Endpoints< / h3 >
< table class = "pricing" >
< thead > < tr > < th > Method< / th > < th > Path< / th > < th > Effect< / th > < / tr > < / thead >
< tbody >
< tr > < td > < b > GET< / b > < / td > < td > < code > /api/records/< name> < / code > < / td > < td > Fetches the raw signed manifest from the name's Sia bucket. Public, cacheable.< / td > < / tr >
< tr > < td > < b > POST< / b > < / td > < td > < code > /api/records/< name> < / code > < / td > < td > Accepts a signed manifest, verifies against the on-chain owner + seq monotonicity, uploads to Sia.< / td > < / tr >
< tr > < td > < b > GET< / b > < / td > < td > < code > /api/dns/< name> < / code > < / td > < td > < b > Resolver read.< / b > Fetches the manifest, verifies the signature against the on-chain owner and rejects rollback of the seq, then returns < em > only< / em > the verified < code > dns< / code > block. Callers can trust the response without doing their own signature or chain lookups. 30-second cache hint.< / td > < / tr >
< / tbody >
< / table >
< p class = "lede" style = "margin-top:.8rem" > The distinction between < code > /api/records/< name> < / code >
and < code > /api/dns/< name> < / code > is deliberate: the former is transparent (raw manifest as
uploaded, including the signature so clients can re-verify), the latter is opinionated (only the
verified DNS records, with the gateway having done the sig + seq work). Bridges and shims should
use < code > /api/dns/< / code > ; wallets and tools that want to see the full signed blob should use
< code > /api/records/< / code > .< / p >
< p class = "lede" style = "margin-top:.8rem" > A name needs < code > records.s3< / code > set on chain first —
without a storage pointer, the manifest has nowhere to live. Portal and CLI both refuse to
publish a manifest until < code > s3< / code > is present.< / p >
< div class = "note" style = "margin-top:1.2rem" >
< b > Threat model at a glance.< / b > Operator tampers → sig check fails, resolver falls back to chain
records. Replay of an old blob → seq check fails. Owner's key compromised → same as chain-side
compromise; move the name to a new key. Sia object deleted → name still resolves via chain
records, DNS records disappear until republished. Hostile gateway can refuse writes but cannot
forge them; users can PUT directly to Sia with their own credentials to bypass.
< / div >
< / section >
< section id = "host" >
< h2 > Host your name< / h2 >
< p class = "lede" > The end-to-end recipe for putting a static site under a BCNR name. Chipnet
today, mainnet later — the shape is the same. Three ways to host, most people combine
two of them (Sia + VPS mirror) so the site keeps serving if either mirror goes down.< / p >
< h3 > Pattern A — Sia only< / h3 >
< p class = "lede" > Simplest. Site lives on the Sia storage network, name's < code > s3< / code > record
points at the bucket key, gateways (navigate.st, silentmode.st, any BCNR-aware browser)
fetch it on demand. Same pattern < code > silentmode.bch< / code > uses.< / p >
< pre > # From a checkout with sia-s3.json credentials:
node Argus/src/lib/sia-upload.js ./my-site bns/myname/
# Set the chain record (once). Note the trailing slash — enables auto-index
# so /myname/ serves myname/index.html and /myname/about/ serves .../about/index.html.
node Argus/src/update.js myname.x '{"s3":"bns/myname/"}'< / pre >
< p class = "lede" > Bucket-path convention: < code > bns/< label> /< / code > (no TLD; the label is
unique enough within our Sia namespace and keeps game.x + game.bch from colliding). Files
update by re-running sia-upload; the chain record only changes when the bucket path does.< / p >
< h3 > Pattern B — Your own server (VPS + < code > ip< / code > )< / h3 >
< p class = "lede" > Point the name at an IP; every request goes directly to your box. Add a
< code > tls< / code > record with the SHA-256 of the leaf certificate so browsers verify the
connection against the chain instead of the OS trust store.< / p >
< pre > # On your VPS: nginx serves your site over TLS. Then, on chain:
node Argus/src/update.js myname.x '{"ip":"1.2.3.4","tls":"< sha256-of-leaf-cert> "}'< / pre >
< h3 > Pattern C — Dual host (Sia primary, VPS mirror)< / h3 >
< p class = "lede" > What Sirius.X itself uses. Sia is the chain-authoritative source (survives
if the VPS is down); the VPS serves the same content on < code > silentmode.st/< path> < / code >
for users without a BCNR resolver installed. On the VPS side, extend the nginx vhost
serving < code > silentmode.st< / code > with a new < code > location< / code > block that aliases
straight from disk:< / p >
< pre > location /myname-x/ {
alias /opt/silent-mode/site-myname-x/;
index index.html;
try_files $uri $uri/ =404;
}< / pre >
< p class = "lede" > Then rsync / scp your site tree to < code > silentmode:/opt/silent-mode/site-myname-x/< / code >
and reload nginx. This gives you two URLs for the same content:
< code > https://silentmode.st/myname-x/< / code > (VPS-direct) and the chain-authoritative
< code > https://myname.x/< / code > via any BCNR resolver.< / p >
< h3 > The dual-host recipe, end to end< / h3 >
< p class = "lede" > This is the exact sequence Sirius.X itself uses on every publish. The
chain record stays constant; only file contents change, so no per-publish UPD is
needed.< / p >
< ol class = "steps" >
< li > < b > Edit locally.< / b >
< span > Site source lives at < code > site-myname-x/< / code > in your working repo. Any
static generator works (or plain HTML) — the deploy is content-agnostic.< / span > < / li >
< li > < b > Push VPS mirror (fast path).< / b >
< span > Serves at < code > silentmode.st/myname-x/< / code > within seconds. Users without a
BCNR resolver hit this route.
< pre > scp -r site-myname-x/* silentmode:/opt/silent-mode/site-myname-x/< / pre > < / span > < / li >
< li > < b > Push Sia mirror (durable copy).< / b >
< span > Serves at < code > sirius.x/< / code > via any BCNR gateway. Survives VPS outage.
< pre > node Argus/src/lib/sia-upload.js site-myname-x/ bns/myname/< / pre > < / span > < / li >
< li > < b > Verify both.< / b >
< span > < code > curl -so /dev/null -w "%{http_code}\n" https://silentmode.st/myname-x/< / code >
and < code > curl -so /dev/null -w "%{http_code}\n" https://silentmode.st/bns/myname.x/< / code >
— both should return 200.< / span > < / li >
< / ol >
< h3 > Auto-backup: one command, both mirrors< / h3 >
< p class = "lede" > Wrap the two commands into a script so every publish reaches both mirrors
without extra thought. This is exactly what a two-liner deploy hook looks like:< / p >
< pre > # scripts/deploy-myname-x.sh
#!/usr/bin/env bash
set -eu
SRC="$(dirname "$0")/../site-myname-x"
VPS_DEST="silentmode:/opt/silent-mode/site-myname-x/"
SIA_BUCKET="bns/myname/"
echo "→ VPS mirror"
scp -qr "$SRC"/. "$VPS_DEST"
echo "→ Sia mirror"
node "$(dirname "$0")/../Argus/src/lib/sia-upload.js" "$SRC" "$SIA_BUCKET"
echo "✓ deployed; verifying"
for url in "https://silentmode.st/myname-x/" "https://silentmode.st/bns/myname.x/"; do
code=$(curl -so /dev/null -w '%{http_code}' "$url")
printf ' %s → %s\n' "$url" "$code"
done< / pre >
< p class = "lede" > Wire it into git: < code > chmod +x scripts/deploy-myname-x.sh< / code > , add a
< code > .git/hooks/post-commit< / code > that runs it if the site subtree changed, or invoke
manually. Sia uploads that fail (network hiccup, quota) leave the VPS mirror ahead until
the next run — same failure mode as any staged deploy.< / p >
< h3 > Automate the reverse — VPS → Sia periodic backup< / h3 >
< p class = "lede" > If your primary publish path is straight-to-VPS (nginx-direct, no Sia
step per publish), a cron job can pull the VPS state and push to Sia on a schedule:< / p >
< pre > # /etc/cron.d/sirius-x-sia-backup (on the operator's VPS)
17 * * * * root cd /opt/silent-mode & & node Argus/src/lib/sia-upload.js \
/opt/silent-mode/site-myname-x/ bns/myname/ > /var/log/sia-backup.log 2> & 1< / pre >
< p class = "lede" > Runs hourly at :17 (offset from the top of the hour so it doesn't collide
with everyone else's cron traffic). The tradeoff: up to an hour of drift between VPS
and Sia after a publish — usually fine, since the chain record still resolves
correctly either way and BCNR gateways cache Sia content.< / p >
< div class = "note" > < b > Which mirror is authoritative?< / b > The one your chain record points
at. If < code > s3< / code > is set, gateways fetch from Sia; the VPS mirror is just a
convenience URL. If only < code > ip< / code > is set, gateways fetch from the VPS; Sia is
just backup. If BOTH are set, gateways pick per the priority in the "Records" section
(subdomain-aware; see < code > record-picker.js< / code > ). Set both for durability, but be
deliberate about which is primary.< / div >
< h3 > Verify records changed correctly< / h3 >
< pre > node --input-type=module -e "
import { loadWallet } from './Argus/src/lib/wallet.js';
import { resolveName } from './Argus/src/lib/bns.js';
const w = await loadWallet('main');
console.log(await resolveName(w.provider, 'myname.x'));
process.exit(0);"< / pre >
< div class = "note" > < b > Credentials.< / b > Sia upload needs < code > Argus/sia-s3.json< / code > . VPS
deploy needs SSH to the operator's box. Neither is in the repo — a session that isn't
run by the operator will need those handed over out-of-band. Full command reference is in
< a href = "INSTRUCTIONS.md" > INSTRUCTIONS.md< / a > , especially §5 (Sia storage) and §6
(deploy).< / div >
< / section >
< section id = "resolver" >
< h2 > Resolver / gateway< / h2 >
< p class = "lede" > Three paths, same chain data. Anyone can pick.< / p >
< ol class = "steps" >
< li > < b > Local — Ariadne Resolver.< / b >
< span > A system-wide resolver that intercepts BCNR TLDs and answers them from the
chain. Any browser you already use starts opening < code > .bch< / code > URLs directly.
Installs a local root CA for TLS.
< a href = "../theseus/" > Download →< / a > < / span > < / li >
< li > < b > In-browser — Theseus Navigator.< / b >
< span > A Chromium build with the resolver baked in, plus an on-chain TLS trust anchor.
No OS trust-store install; nothing modified globally.
< a href = "../theseus/" > Download →< / a > < / span > < / li >
< li > < b > Public gateway — navigate.st.< / b >
< span > For anyone without the resolver installed:
< code > https://navigate.st/bns/< name> /< / code > proxies through a hosted resolver.
Same content, fewer guarantees — trust the gateway to fetch honestly, or run one of
the first two.< / span > < / li >
< / ol >
< / section >
< section id = "pricing" >
< h2 > Pricing (mainnet)< / h2 >
< p class = "lede" > On mainnet the covenant enforces USD-denominated floors, tiered by TLD
label length. This is what keeps someone from land-grabbing every ICANN TLD in one
afternoon. TLD registration is < b > one-time< / b > — a TLD is closer to a domain purchase
than a lease.< / p >
< table class = "pricing" >
< thead > < tr > < th > Label length< / th > < th > Floor (USD)< / th > < th > Notes< / th > < / tr > < / thead >
< tbody >
< tr > < td > 1 char< / td > < td class = "price" > 100,000< / td > < td > Effectively unique; ENS-like scarcity< / td > < / tr >
< tr > < td > 2 char< / td > < td class = "price" > 50,000< / td > < td > The < code > .ai< / code > / < code > .io< / code > tier< / td > < / tr >
< tr > < td > 3 char< / td > < td class = "price" > 15,000< / td > < td > Order of magnitude below ICANN's $185k application floor< / td > < / tr >
< tr > < td > 4 char< / td > < td class = "price" > 5,000< / td > < td > Floor for short but reasonable TLDs< / td > < / tr >
< tr > < td > 5– < / td > < td class = "price" > 1,000< / td > < td > Bulk-registerable but not spam< / td > < / tr >
< tr > < td > 9+ char< / td > < td class = "price" > 250< / td > < td > Descriptive TLDs, low economic gravity< / td > < / tr >
< / tbody >
< / table >
< p class = "lede" style = "margin-top:1rem" > On < b > name registration under a TLD< / b > , the TLD's
owner collects a share (< code > fee_bps< / code > , default 5%, cap 50%). Chain-enforced when
the TLD's policy is < code > covenant< / code > ; honour-system otherwise. Name registration is
yearly and priced separately.< / p >
< p class = "lede" style = "margin-top:1rem" > The TLD owner also sets what names under it < b > sell for< / b > and whether the TLD is < b > on or off< / b > , straight from the portal: a < code > price< / code > record (flat USD per name, replaces the length tiers for every buyer) and a < code > hidden< / code > record (< code > 1< / code > makes it a < b > private TLD< / b > : off the public list, nobody but the owner can register names under it — the owner still can from the portal, paying only the platform share — until it is switched back on). Both ride the same signed < code > TUPD< / code > , so every client reads them from the chain; the owner keeps 90% of each sale.< / p >
< / section >
< section id = "tracker" >
< h2 > Tracker & mirrors< / h2 >
< p class = "lede" > A tracker publishes signed snapshots of the TLD registry to Sia and Nostr so
downstream clients don't have to walk the chain themselves. The chain is authoritative;
the tracker is speed. Every snapshot carries a < b > root< / b > hash anyone can recompute
locally — a lying mirror is caught by any recipient who bothers to check.< / p >
< p class = "lede" > A conforming client falls through: (1) fetch snapshot from a mirror,
(2) verify < code > root< / code > , (3) if suspicious, walk the beacon and rebuild. All three
yield the same list for any given block height.< / p >
< / section >
< section id = "verify" >
< h2 > Verify anything< / h2 >
< p class = "lede" > You do not have to trust that sirius.x, silentmode.st, or navigate.st are
serving honest content. Every name's certificate is on chain; every record is a signed
on-chain payload; every host is checkable independently.< / p >
< h3 > Confirm a specific name on chain< / h3 >
< pre > node --input-type=module -e "
import { loadWallet } from './Argus/src/lib/wallet.js';
import { resolveName } from './Argus/src/lib/bns.js';
const w = await loadWallet('main');
console.log(await resolveName(w.provider, 'sirius.x'));
process.exit(0);"< / pre >
< h3 > Fetch the operator-signed TLD snapshot from Nostr< / h3 >
< dl class = "verify" >
< dt > Kind / d-tag< / dt >
< dd > 30078 / bns-tld-list< / dd >
< dt > Pubkey (x-only, hex)< / dt >
< dd > f2c925194c531c7c398017e35b2396df64a61a613aa5fadebdf1f4990f2267f4< / dd >
< dt > Relays< / dt >
< dd > wss://nos.lol · wss://relay.damus.io< / dd >
< / dl >
< h3 > Reach any site via more than one route< / h3 >
< p class = "lede" > Same content should be served from at least two independent paths:< / p >
< ul style = "color:var(--mut);font-size:14px;margin:.6rem 0 0;padding-left:1.2rem" >
< li > Direct BCNR: < code > https://< name> /< / code > (requires local resolver + CA)< / li >
< li > Public gateway: < code > https://navigate.st/bns/< name> /< / code > < / li >
< li > silentmode.st mirror: < code > https://silentmode.st/bns/< name> /< / code > < / li >
< li > Direct from Sia (content-addressed) via the name's < code > s3< / code > record< / li >
< / ul >
< / section >
< section id = "runbook" >
< h2 > Operator runbook< / h2 >
< p class = "lede" > These docs describe < i > what< / i > . The < i > how< / i > — exact bash commands to
register TLDs, mint names, update records, and deploy — is
< code > INSTRUCTIONS.md< / code > . Three ways to read it, in order of "how much do I already
have installed":< / p >
< ol class = "steps" >
< li > < b > Just read it in the browser< / b >
< span > Served straight from the docs directory:
< a href = "INSTRUCTIONS.md" > /sirius-x/docs/INSTRUCTIONS.md< / a > . Plain text; every
browser renders it.< / span > < / li >
< li > < b > Clone the git remote< / b >
< span > < code > git clone https://silentmode.st/sirius-x/repo/silent-mode.git< / code > — dumb-HTTP,
no auth. Get the whole tree, browse offline, run the scripts.< / span > < / li >
< li > < b > Browse the Forgejo mirror< / b >
< span > Repo lives at
< a href = "https://code.silentmode.st/silentmode/sirius" > code.silentmode.st/silentmode/sirius< / a >
on the Silent Mode Hephaestus forge. Rendered runbook:
< a href = "https://code.silentmode.st/silentmode/sirius/src/branch/master/docs/INSTRUCTIONS.md" > docs/INSTRUCTIONS.md< / a > .
Clone: < code > git clone https://code.silentmode.st/silentmode/sirius.git< / code > — public,
no auth.< / span > < / li >
< / ol >
< p class = "lede" > The runbook covers CLI name registration, TLD-registry seeding, record
updates, Sia upload, VPS deploy, tests, and the historically-costly gotchas.< / p >
< / section >
< / div >
< / div >
< / div >
< footer id = "site-footer" > < / footer >
< script src = "../js/session.js?v=20260917dash" > < / script >
< script src = "../js/pin-escrow.js?v=20260909pin" > < / script >
< script src = "../js/pricing.js?v=20260920bits" > < / script >
< script defer src = "../js/site-footer.js?v=20260917market" > < / script >
< script defer src = "../js/theme.js?v=20260921mob" > < / script >
< script defer src = "../js/profile-menu.js?v=20260921mob" > < / script >
< script >
// Sidenav scroll-spy: highlight the section currently in view.
// Uses scroll-position tracking so short sections at the end of the page
// still activate their link when the reader scrolls to them.
(() => {
const links = document.querySelectorAll(".sidenav a[href^='#']");
if (!links.length) return;
const entries = [];
links.forEach((a) => { const el = document.querySelector(a.getAttribute("href")); if (el) entries.push({ el, link: a }); });
if (!entries.length) return;
const setActive = (link) => { links.forEach((l) => l.classList.remove("active")); link.classList.add("active"); };
const update = () => {
const doc = document.documentElement;
const scrollBottom = window.scrollY + window.innerHeight;
if (scrollBottom >= (doc.scrollHeight - 4)) { setActive(entries[entries.length - 1].link); return; }
const line = window.scrollY + window.innerHeight * 0.35;
let active = entries[0].link;
for (const e of entries) {
if (e.el.getBoundingClientRect().top + window.scrollY < = line) active = e.link;
else break;
}
setActive(active);
};
window.addEventListener("scroll", update, { passive: true });
window.addEventListener("resize", update);
update();
})();
< / script >
< / body >
< / html >
