The dendritic network
Names & TLDs
Every service on the dendritic network already has an address: its public key,
written as <56 characters>.key.axon. The registry adds human names on top,
like example.axon, owned on-chain, pointing at one or more of those
identities, and governed so the namespace stays clean.
1. What a name is
A name is a network-local alias for an AXON service identity. The registry is a
smart contract, AxonTLD: example.axon or, under an admitted
TLD, example.com maps to the overlay identity (the hashed public key) of
the service it names. That identity is the address. It is not an IPv4 or IPv6
address, and the service's IP stays hidden either way.
Registering example.com here gives no ownership or
control of the public-DNS example.com. Inside the dendritic network, on
nodes that resolve .com, it resolves to the AXON identity you set; on the
internet it means nothing.
.axon is the network's own root and always enabled. key.axon
and everything under it is reserved for self-certifying addresses, which never touch
the registry.
2. Register and own a name
- You register a second-level name (
example.axon,example.com) under an enabled TLD. First come, first served. - Ownership is on-chain: the wallet that registers the name owns it. There is no expiry and no renewal.
- Registering can set the first AXON destination at the same time, or none (a zero key).
- Names are ASCII letters, digits and hyphens: 1–63 bytes per label, 253 in total,
case-folded. Unicode is rejected; convert IDNA to
xn--yourself. - Only the owner can change records, transfer or release a name. The contract's administrator cannot seize names or edit anyone's records.
releasegives a name up and clears its records.
Names are guessable (the registry keys on a hash of the name), and registration is a public transaction. See resolution and trust.
Everything on this page can be done from your slip: sign in with your wallet to register names and subdomains, choose which hidden-service addresses a name leads to and which is primary, edit its DNS records, transfer or release it, and propose and vote on new TLDs. The site builds each transaction and your wallet signs it; the site never holds a key. The cheat-sheet does the same from a terminal.
3. Destinations and records
A name holds up to 32 typed records, each with a stable ID and a TTL (0–604800 seconds, a caching hint, not an expiry):
| Type | Payload | Used for |
|---|---|---|
AXON = 0 | 32-byte Ed25519 public key | An overlay destination. The only type the node's proxy dials. |
A = 1 | IPv4, 4 bytes | Stored metadata, and DNS bridge data. Never a clearnet destination for the proxy. |
AAAA = 2 | IPv6, 16 bytes | As A. |
MX = 3 | uint16 priority + hostname | Stored only; no mail delivery is implemented. |
DNS = 4 | uint16 RR type + wire RDATA (≤ 4096 bytes) | Any DNS record, served by the DNS bridge. |
Several destinations, one primary. The first AXON record becomes the
primary; setPrimary picks another. The proxy tries up to four AXON
destinations, primary first, and stops at the first that connects. A failed AXON
connection never falls back to the open internet.
4. Subdomains and transfers
- Subdomains are created by the owner of the immediate parent: the
owner of
example.comregistersapi.example.com. Nobody else can squat under your name. A child inherits its parent's owner. - Transfers take two steps. The owner calls
transfer(name, recipient)and the recipient callsacceptTransfer(name). Until then the owner can cancel or replace the proposal. Records survive the transfer, and the old owner loses all control. - Delegating a subtree is the same two-step transfer on the child. From then on it has its own controller, independent of later parent transfers.
- Releasing a name invalidates everything under it.
5. Fees
Changing the registry costs a small per-change protocol fee, paid in the chain's native currency, plus ordinary gas. Reads are free.
| Action | Fee |
|---|---|
register | Registration fee (includes the optional first AXON record) |
setRecord, setKey, removeRecord, setPrimary | One record fee per call |
setRecords (atomic batch of 1–32) | Record fee × entries |
transfer | Transfer fee per proposal |
release, acceptTransfer, cancelTransfer | None (gas only) |
The exact amount is required: read fees() right before sending, because an
over- or under-payment reverts. Fees accrue to the address that deployed the contract,
which alone can withdraw them.
6. TLD governance
Which TLDs exist is not one person's decision, so the namespace can't be flooded with junk roots:
- ICANN root-zone TLDs (
com,net,org, …): the administrator marks the TLD as being in the IANA root zone (markIcann, a publicly checkable fact) and then enables it (setSuffix). - Any new or custom TLD must be admitted by a token-holder
vote. Anyone proposes it (
proposeSuffix), vote-token holders vote (voteSuffix, weighted by their balance, one vote per address), and after the voting period anyone executes it (executeSuffix). It is admitted if the "for" votes meet the quorum and outnumber "against". .axonis grandfathered: enabled from the start.- The administrator can always disable a TLD, which blocks new registrations only. Existing names keep resolving and can still be changed, transferred and released. Admitting a TLD confers no authority over names under it.
A node resolves an extra TLD only if it is enabled on chain and listed in that
node's axon.name_suffixes.
7. Command cheat-sheet
These use Foundry's cast. It's an operator reference, not a script to run
blindly: REGISTRY, RPC_URL, ACCOUNT,
KEY (0x + 64 hex digits), RECIPIENT and each fee are yours to
set. Fee units are wei.
Register, records, transfer, withdraw
# Registration includes initial key. Use bytes32 zero to register without destinations.
cast send "$REGISTRY" 'register(string,bytes32)' example.com "$KEY" --value "$REGISTRATION_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Add another AXON key (ID 0); receipt RecordChanged event supplies its stable ID.
cast send "$REGISTRY" 'setRecord(string,uint64,uint8,uint32,bytes)' example.com 0 0 300 "$SECOND_KEY" --value "$RECORD_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Update record 2 to IPv4 192.0.2.1, or use kind 2 + 16 bytes for IPv6.
cast send "$REGISTRY" 'setRecord(string,uint64,uint8,uint32,bytes)' example.com 2 1 300 0xc0000201 --value "$RECORD_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
# MX priority 10 + mail.example.com (ASCII bytes)
cast send "$REGISTRY" 'setRecord(string,uint64,uint8,uint32,bytes)' example.com 0 3 300 0x000a6d61696c2e6578616d706c652e636f6d --value "$RECORD_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
cast send "$REGISTRY" 'setPrimary(string,uint64)' example.com 1 --value "$RECORD_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
cast send "$REGISTRY" 'removeRecord(string,uint64)' example.com 2 --value "$RECORD_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Atomic batch: BATCH is [(id,kind,ttl,0xdata),...], TOTAL_FEE = recordFee * entry count.
cast send "$REGISTRY" 'setRecords(string,(uint64,uint8,uint32,bytes)[])' example.com "$BATCH" --value "$TOTAL_FEE" --rpc-url "$RPC_URL" --account "$ACCOUNT"
cast send "$REGISTRY" 'transfer(string,address)' example.com "$RECIPIENT" --value "$TRANSFER_FEE_WEI" --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Recipient's account:
cast send "$REGISTRY" 'acceptTransfer(string)' example.com --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Current owner's account:
cast send "$REGISTRY" 'release(string)' example.com --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Original deployer's account, independent of current administrator:
cast send "$REGISTRY" 'withdraw(address)' "$RECIPIENT" --rpc-url "$RPC_URL" --account "$ACCOUNT"
NODE=$(cast call "$REGISTRY" 'nodeOf(string)(bytes32)' example.com --rpc-url "$RPC_URL")
cast call "$REGISTRY" 'resolve(bytes32)(bytes32,address,uint64)' "$NODE" --rpc-url "$RPC_URL"
cast call "$REGISTRY" 'lookupAxon(bytes32)(address,bytes32[32],uint256)' "$NODE" --rpc-url "$RPC_URL"
cast call "$REGISTRY" 'recordsPage(bytes32,uint256,uint256)((uint64,uint8,uint32,bytes)[])' "$NODE" 0 32 --rpc-url "$RPC_URL"
Propose and vote on a TLD
# Enable an ICANN TLD: mark it (admin asserts it is in the IANA root zone), then enable.
cast send "$REGISTRY" 'markIcann(string,bool)' com true --rpc-url "$RPC_URL" --account "$ACCOUNT"
cast send "$REGISTRY" 'setSuffix(string,bool)' com true --rpc-url "$RPC_URL" --account "$ACCOUNT"
# Admit a NETWORK-NATIVE (non-ICANN) TLD by DAO vote (voteToken holders decide):
PID=$(cast send "$REGISTRY" 'proposeSuffix(string)' hack --rpc-url "$RPC_URL" --account "$ACCOUNT" --json | jq -r .logs[0].topics[1])
cast send "$REGISTRY" 'voteSuffix(uint256,bool)' "$PID" true --rpc-url "$RPC_URL" --account "$ACCOUNT" # weight = your vote-token balance
# after VOTING_PERIOD_SECONDS, anyone finalises; approval (quorum met, for > against) enables it:
cast send "$REGISTRY" 'executeSuffix(uint256)' "$PID" --rpc-url "$RPC_URL" --account "$ACCOUNT"
cast call "$REGISTRY" 'proposalInfo(uint256)(string,uint64,bool,uint256,uint256)' "$PID" --rpc-url "$RPC_URL"
# The admin can always DISABLE any suffix (blocks new registrations only):
cast send "$REGISTRY" 'setSuffix(string,bool)' hack false --rpc-url "$RPC_URL" --account "$ACCOUNT"
The full reference, including deployment, is contracts/tld/README.md in the
node's source.
8. Resolution and trust
- Your RPC. Resolution is a plain
eth_callto the Ethereum JSON-RPC your node is configured with. No storage proof or chain header is verified, so a lying RPC can substitute a destination or claim a name doesn't exist. Use one you trust, or run your own. - It sees your lookups. The RPC learns which names you resolve, and when.
- Registration is public, forever. The registering wallet, the name
and the key it points at are all on-chain. Naming a service publishes its identity
key, though not its IP. If a service must stay hidden, don't name it: share its
.key.axonaddress instead.
.key.axon addresses bypass the registry entirely: they are dialled
directly, whatever the registry says.
9. Authoritative DNS bridge Optional · advanced
The registry can also be served as real DNS, so existing DNS tools can read dendritic
names. axon-dns reads the registry at one finalized block, validates each
zone, and hands it to ISC BIND 9, which answers queries over UDP and TCP with
BIND-managed DNSSEC.
AxonTLD -> finalized eth_call snapshot -> validated zone -> BIND -> DNS clients
- It is authoritative-only (no recursion). Dynamic updates are refused, because record changes have to go through the contract and its ownership rules. The publisher needs no wallet.
DNS-type records carry any record BIND supports (A, AAAA, MX, TXT, CNAME, SRV, CAA, TLSA, HTTPS, …);axon-dns encode -rr '…'builds the payload for you.- The example compose file binds
127.0.0.1:1053; test withdig @127.0.0.1 -p 1053 api.example.com A. - It does not verify blockchain proofs: it trusts its RPC like the node does. DNSSEC authenticates the server's zone, not that the zone matches the chain.
- Browsers will not find this namespace through public DNS; point your own resolver at it.
Setup, record encoding, subdomains, DNSSEC and secondaries are covered in
packaging/authoritative-dns/README.md in the node's source.