Memory should
carry proof.

Bittensor Relics is an experimental, non-EVM protocol for creating permanent digital artifacts from native Subtensor transactions. A creator signs one atomic transaction that spends testnet TAO, buys a selected subnet's alpha, burns the acquired alpha stake, and inscribes a bounded message or image. The exact media bytes live inside finalized chain history. The transaction position becomes the artifact's identity; emitted runtime events become its economic receipt; deterministic protocol rules produce its number, owner, transfers, collections, and marketplace state.

The protocol separates two kinds of truth that collectible systems often blur. Subtensor proves execution: who signed, what ran, which bytes were included, how much TAO was committed, how much alpha was actually burned, and where the transaction finalized. Relics interprets that evidence: whether the transaction qualifies, which ordinal number it receives, and how later signed actions change its protocol state. The second layer is not native NFT state, and it is not hidden. It is a published state machine designed to be replayed from genesis by independent implementations.

The long-term proposal turns that interpretation and retrieval work into a Bittensor commodity. Miners independently replay finalized history, preserve verifiable artifact data, and serve proofs. Validators challenge their answers and reward correctness, freshness, availability, and historical coverage. The objective is not to abolish indexers. It is to make indexing explicit, reproducible, competitive, and measurable.

This paper distinguishes verified behavior from proposed architecture. Mainnet minting is disabled. The subnet is not registered. No miner emissions are live. The public marketplace does not settle purchases. Relics remains testnet software until the implementation, replay infrastructure, incentive system, and settlement guarantees survive independent review.

Ownership can be on-chain while the object is elsewhere.

Many Ethereum and Solana collectibles put token ownership on-chain while a metadata field points to the image. That image may live on a project server, a cloud bucket, a CDN, IPFS, Arweave, or directly on-chain. Decentralized storage and fully on-chain art are real exceptions, so the honest argument is not that every NFT is stored on Amazon. The problem is that media permanence is optional, dependencies differ from collection to collection, and buyers often cannot see which promises are enforced by a chain and which depend on continued hosting.

Ordinals moved the artifact into Bitcoin history.

Ordinals demonstrated a powerful alternative: carry the media itself in transaction data. The artifact can then be reconstructed from the chain rather than resolved through a mutable URL. But inscription discovery, numbering, sat tracking, ownership interpretation, and collection views are computed by indexer software. The index is open and reproducible, yet ordinary users still rely on a small group of hosted services to deliver its answers.

Permanence and interpretation are separate problems.

Putting bytes on-chain solves the media-location problem. It does not make search, numbering, state reconstruction, archival access, or marketplace views appear by magic. Relics begins with that distinction. The chain holds the evidence; deterministic software interprets it; a proposed subnet makes the quality of that interpretation a competitive service. A miner may accelerate access, but it cannot alter the finalized transaction, manufacture a burn, move an artifact without a valid owner signature, or consume a number with an invalid mint.

Relics links three facts that normally live apart: an exact artifact, an irreversible economic sacrifice, and a reproducible ownership history. Each accepted mint must preserve all three. The design follows six invariants.

1. One signature, one atomic outcome. The burn and inscription both finalize or neither does.
2. Chain evidence outranks interface claims. Quotes, wallet popups, databases, and miner responses are never canonical.
3. Exact bytes outrank URLs. An image Relic commits the WebP itself, not a promise to host it.
4. Finality precedes existence. A submitted or best-chain transaction is not a Relic.
5. Every derived answer is replayable. Given the same finalized history and protocol version, honest implementations must produce the same accepted set and state.
6. Failure is explicit. Unsupported runtimes, missing databases, divergent replays, stale quotes, and validator disagreement stop the system instead of being presented as certainty.

These invariants define the boundary of the claim. Relics does not add an NFT pallet to Subtensor. It does not attach metadata to alpha tokens. It does not require Solidity, an EVM contract, a custodial wallet, or a private database to create the underlying evidence. “Mint,” “owner,” and “transfer” refer to the Relics protocol's deterministic interpretation of signed Subtensor calls.

A Relic is the canonical protocol object derived from one qualifying finalized extrinsic. Its identity is the event in history, not merely the image hash. Every accepted object records the chain genesis, block number and hash, extrinsic index and hash, signer AccountId32, subnet number and registration generation, registered routing hotkey, TAO committed, actual alpha burned, execution limit, paid fee, original payload, and content hashes.

An image Relic additionally records media type, byte length, dimensions, SHA-256 digest, and exact WebP bytes. A title, inscription, purpose, collection label, and content-policy attestation describe the creator's intent. They do not prove copyright, originality, legality, market value, or the identity of a depicted person.

Duplicate media is allowed. Two creators can inscribe the same bytes, just as two transactions can contain the same message. Their content hashes match, but their signers, economic receipts, positions, canonical IDs, and ordinal numbers do not. Indexers disclose matching hashes and can identify the earliest accepted instance. Scarcity belongs to the historical object and its proof, not to a false promise that bytes cannot be copied.

The forge makes the protocol accessible from a website while keeping authority in the wallet and chain. A user connects an injected SS58 wallet such as TAOStats Wallet. The extension exposes public accounts and signs the chosen transaction. The site never creates the account, asks for a seed phrase, sees a private key, or holds funds.

1. Select an alpha economy. The forge reads active non-root subnets from a pinned testnet genesis and shows the subnet number, current registration generation, identity, and owner hotkey.
2. Choose a TAO commitment. Version 1 is TAO-targeted. The runtime quote estimates the alpha acquired after pool fee, slippage, and price impact.
3. Compose the artifact. The creator supplies a name, optional inscription, purpose, and optional collection label.
4. Prepare media locally. PNG, JPEG, or WebP input is cropped and compressed in the browser into a bounded passive WebP. The reference forge does not upload the source image to cloud storage.
5. Accept the covenant. The creator attests to the br-safe-1 content policy, whose identifier is committed in the manifest.
6. Refresh the proof inputs. Before signing, the forge reloads the finalized subnet generation, route hotkey, quote, price limit, estimated fee, genesis, image size, and balance.
7. Sign once. The wallet displays the exact atomic call and returns a signed extrinsic. The site broadcasts it without taking custody.
8. Wait for finality. The receipt is created only after the finalized block is located and all scoped calls and events pass protocol verification.

Miners are not a per-mint job queue. The chain processes the signed transaction directly. Indexing follows finality and may lag, but no miner has permission to “approve” a valid mint. In the proposed subnet, miners earn emissions for continuously reconstructing and serving correct history; the creator does not sign a separate miner escrow.

A version 1 image or text mint contains exactly two calls in exactly this order:

Utility.batch_all([
  SubtensorModule.add_stake_burn(
    subnet_owner_hotkey,
    netuid,
    tao_amount,
    Some(maximum_ending_spot_price)
  ),
  System.remark_with_event(relic_payload)
])

batch_all is the atomic boundary. If Buy & Burn fails, the remark rolls back. If the remark fails, the economic action rolls back. A non-atomic batch, extra inner call, reversed order, wrong subnet generation, or mismatched route hotkey does not qualify. This is how the protocol prevents an inscription without its burn and a burn without its promised inscription.

The temporary stake routes through the selected subnet's registered owner hotkey, read from the same finalized snapshot as the quote. This allows a coldkey-only wallet to participate without creating a personal hotkey. The purchased alpha is burned immediately; no acquired stake remains for the user or route hotkey.

The verifier scopes events to the extrinsic and requires successful atomic execution plus the matching stake-burn, alpha-burn, remark, and fee evidence. The canonical quantity is the emitted AlphaBurned amount. The current runtime can report the nominal stake-burn result one alpha-rao above the actual burn because the burn is capped to the available post-purchase alpha. Protocol v1 permits only that one-unit boundary and rejects a larger mismatch.

The transaction's finalized block position orders the mint. A wallet confirmation or transaction hash alone cannot create an artifact. Forked, failed, interrupted, unsupported, or merely included transactions are excluded.

Text-only Relics use strict UTF-8 JSON. Image Relics use the compact BRI1 binary envelope so exact media does not pay the expansion cost of base64:

4 bytes   ASCII magic "BRI1"
4 bytes   big-endian unsigned manifest length
N bytes   canonical UTF-8 JSON manifest
remainder exact WebP image bytes

The manifest commits protocol version, operation, subnet and generation, name, purpose, policy, media type, encoding, SHA-256 content hash, byte length, width, height, and optional inscription or collection label. The verifier checks the envelope boundaries, canonical fields, declared length and digest, image header, dimensions, and total size.

The constraint is part of the medium. Permanent bytes impose archival cost on infrastructure that stores historical blocks. Relics therefore supports small, deliberately compressed artifacts rather than presenting Subtensor as unlimited file hosting. Thumbnails and caches may be served by Vercel, Hippius, a CDN, or miners, but those copies are replaceable. A valid copy must hash to the exact bytes committed in the finalized transaction.

“On-chain” means the envelope is included in finalized historical block data. It does not mean every public RPC endpoint retains every old block indefinitely. Reliable access still requires archival nodes and replicated serving. The proposed subnet improves retrieval and makes incorrect responses punishable; the block position and digest make every response auditable.

Version 1 performs Buy & Burn. The creator does not contribute alpha already held in the wallet. They choose TAO input; the runtime buys alpha from one selected subnet pool and immediately burns the acquired stake. Alpha output varies with pool state, fees, price impact, and transaction ordering. Only the finalized AlphaBurned event proves the amount attached to the Relic.

The forge computes a maximum acceptable ending spot price from a fresh finalized quote. Protocol v1 uses a 2% tolerance, rounded upward, and disallows partial execution. If the swap would cross that boundary, the atomic transaction fails instead of accepting hidden slippage or retrying as an unrestricted market order.

The valid claim is both narrower and more useful: every accepted mint proves real TAO demand against a selected subnet pool and the exact amount of alpha relinquished by the creator. It creates a public cultural receipt tied to that alpha economy. Communities may value those receipts, and repeated use may generate pool activity and fees, but market outcomes remain uncertain.

A collection can express a rule such as “burn at least 1,000 SCORE alpha and follow this visual brief.” Today the creator chooses TAO, so the final alpha amount cannot be guaranteed in advance. The forge must show an estimate; the finalized event decides whether a threshold was met. A future exact-alpha mode would require a separately specified transaction path with equally strict price protection.

Identity and numbering

The canonical identifier is br1:<full-genesis>:<block>:<extrinsic-index>. Display numbers are assigned by sorting accepted mints by block and extrinsic position from the protocol activation block. Invalid candidates consume no number. Replaying the same finalized range must produce the same IDs, numbers, hashes, and owners.

Subnet numbers can be reused after deregistration. Relics therefore identifies an alpha economy by (netuid, NetworkRegisteredAt[netuid]), not by a display name or netuid alone. A Relic remains tied to the generation that existed when it was created.

Ownership and transfer

The mint signer is the initial protocol owner. A transfer is a later finalized standalone remark_with_event signed by the current owner. It identifies the artifact, recipient AccountId32, genesis, protocol domain, and exact next nonce. The indexer accepts it only when the signer owns the artifact and the nonce is sequential. A transfer changes Relics protocol state; it does not move a native runtime asset.

Ownership is therefore verifiable without giving the marketplace custody. Any implementation can replay mint and transfer events in final order. Invalid signatures, skipped or reused nonces, wrong genesis values, and transfers by former owners are rejected.

Purposes and collections

A Relic purpose distinguishes a personal artifact, collection entry, subnet milestone, or community message. In v1, collection labels are creator-declared metadata, useful for discovery but not proof of official membership. A later authority layer can define a collection declaration signed by the subnet owner or delegated curator, including generation, eligible window, burn threshold, required imagery or text, supply cap, and curator key policy. Indexers can then evaluate membership from chain evidence rather than a website's allowlist.

Relics does not “solve the indexer problem” by denying that an index exists. It solves for a more precise target: no single indexer should be able to invent canonical history without being contradicted by public evidence and independent replay.

1. Read only finalized blocks from the configured genesis and frozen activation height.
2. Decode metadata for the active supported runtime specification.
3. Inspect successful extrinsics in block order.
4. Require the exact atomic call shape and subnet-generation identity.
5. Parse strict bounded payloads; reject unknown versions, malformed JSON, unsafe numeric forms, and envelope mismatches.
6. Match only events emitted by that extrinsic and treat actual runtime values as authoritative.
7. Insert accepted mints, then apply valid transfers and listings in finalized order.
8. Publish the indexed finalized head, rejection reasons, state commitments, and replay audit results.

The reference indexer is deliberately fail-closed. An unknown runtime version pauses ingestion. A missing database returns INDEXER_UNAVAILABLE, not an empty collection. Reprocessing a block is idempotent. A rollback removes all derived state at and after the affected height before replay. Media served from a cache is checked against its on-chain digest.

PostgreSQL makes the state searchable but has no authority. A primary worker and an independently configured replay worker must be able to stop at the same finalized block and produce identical canonical datasets. Divergence is a protocol alarm, not a result to average away.

The proposed Relics subnet turns deterministic reconstruction and historical availability into measurable work. It is not needed for a transaction to finalize and does not sit between a creator and Subtensor. Its purpose is to prevent one hosted index from becoming the practical authority over discovery, numbering, ownership, and media retrieval.

Miner work

Each miner follows finalized Subtensor history, independently applies the protocol, maintains canonical state, preserves supported historical media, and answers proof queries. Responses include the indexed finalized head, artifact record, ownership chain, source block position, content digest, and state commitment. Good service requires correctness, freshness, latency, availability, and enough historical coverage to answer adversarial queries—not merely copying the latest answer from another miner.

Validator work

Validators derive or sample ground truth from finalized blocks and challenge miners across recent and historical ranges. Tests include valid mints, malformed near-mints, runtime boundaries, media bytes, ordinal neighbors, ownership transitions, collection conditions, and deliberately stale heads. Scores reward exact proofs and useful service. Incorrect, unavailable, selectively incomplete, or stale responses lose weight.

Consensus at the gateway

The dapp queries multiple independent miners or validator-backed gateways. It accepts an answer only when a configured quorum agrees on the same finalized head and canonical result. Disagreement is shown as uncertainty and triggers direct chain verification. Consensus is not a vote that can override history; it is evidence that independent replicas reached the same deterministic answer.

Bittensor emissions—not a per-user escrow—would compensate miners and validators according to subnet weights and consensus. Registration alone does not guarantee emissions, honest participants, or sustainability. The commodity must prove more valuable than an ordinary replicated service at its true storage, verification, and egress cost before subnet registration is justified.

Relics is most compelling when the economic action and cultural object belong to the same community. A subnet can define a collection around its own milestones and alpha economy: a 10,000 SCORE burn paired with a founder portrait, a limited anniversary series, a visual record of a major release, or a community message whose cost demonstrates conviction.

Collection rules should be specific enough to verify and open enough to invite creativity. An authority declaration could require a minimum actual alpha burn, a subnet generation, time window, purpose, image dimensions, edition limit, and visual theme. It could prohibit weapons-focused imagery, sexual or exploitative material, graphic violence, hate, and illegal content. Creators remain free to interpret the theme; indexers determine only whether objective conditions and the declared authority chain are satisfied.

Not every important Relic needs a collection. A subnet owner can permanently inscribe a launch image, upgrade announcement, research result, or message to the community with a meaningful burn. The result functions as a timestamped receipt: exact bytes, signer, subnet economy, finalized position, and sacrifice preserved together. The owner can later transfer that protocol object, list it, or retain it as part of the subnet's public history.

Discovery and settlement are intentionally separate. A listing is a signed off-chain order containing the artifact ID, current ownership nonce, seller, price, expiry, genesis, and protocol domain. Anyone may relay it. The marketplace displays it only after independently confirming current ownership and signature validity. A transfer, cancellation, expiry, or nonce change invalidates the listing.

This discovery model is implemented. Paid settlement is not. The required safety property is simple to state and difficult to achieve without an EVM contract: a buyer must not lose TAO unless the same enforced operation gives the buyer canonical protocol ownership. Two unrelated signatures do not satisfy that property. A server-held escrow does not make it trustless. Until a native non-EVM settlement path can enforce payment and transfer together, the public interface remains read-only for purchases.

The future market may support direct transfers, fixed-price orders, bids, and collection views, but no feature is worth weakening the ownership rules. Wallets sign exact payloads; relayers never control artifacts; indexes verify the seller at the current nonce; and settlement stays disabled whenever ownership, price, finality, or execution cannot be bound into one loss-safe outcome.

Permanent media creates responsibilities that a deletable cloud application can postpone. The forge requires the br-safe-1 covenant: no sexual or exploitative content, graphic violence, weapons-focused imagery, hate, or illegal material. That attestation is signed into the manifest. It is evidence of the creator's declaration, not proof that the declaration is true.

Interfaces, miners, validators, curators, and marketplaces may refuse to ingest, cache, score, or display noncompliant material. They cannot erase bytes already finalized in historical chain data. No upload filter is perfect, so the protocol does not promise universal moderation or removal. It combines bounded passive media, an explicit signed policy, refusal rights, and transparent limits.

The principal technical defenses are a pinned genesis, finalized-only reads, exact call-shape validation, event-scoped accounting, runtime-version gates, bounded parsing, content hashing, domain-separated signatures, sequential ownership nonces, no custodial keys, price limits, no partial fills, independent replay, and fail-closed APIs.

Expected failures include wallet rejection, insufficient test TAO, stale quotes, price movement, subnet deregistration, disabled alpha, RPC outages, finality delays, runtime upgrades, database lag, miner disagreement, and policy refusal. A safe failure never broadens a signature, silently increases slippage, invents an artifact, displays stale state as final, or retries an economic transaction without renewed user approval.

The founding testnet Relic

The first independently verified Bittensor Relics image mint finalized on testnet at block 7,698,721, extrinsic index 6. Named Shizzy, it carries an 8,698-byte 256×256 WebP inside the transaction, commits 1 test TAO, and records an actual burn of 1,035.580333229 subnet-one alpha. The transaction fee was 0.001743874 test TAO.

The nominal stake-burn event exceeded the actual alpha-burn event by one alpha-rao. That result exposed an overly strict early verifier and led to the narrow rounding rule described above. The corrected implementation preserves the actual AlphaBurned value as canonical. Download the complete evidence JSON and verify it independently against the finalized block.

The founding object exists in finalized testnet history, but the public explorer remains empty until deployed workers replay from the activation block. The API reports INDEXER_UNAVAILABLE while its database is absent. That is the intended failure mode.

1. Freeze and independently review one protocol and source release candidate.
2. Complete deterministic builds, dependency review, runtime-compatibility tests, and adversarial transaction fixtures.
3. Provision separate primary and replay databases; ingest from block 7,698,720; and require byte-identical state at a shared finalized checkpoint.
4. Publish proof APIs and verify every Explore, wallet, media, transfer, rejection, and collection view against chain evidence.
5. Exercise real testnet transfers and listing invalidation while paid settlement remains disabled.
6. Operate archival and RPC redundancy; rehearse runtime upgrades, rollbacks, stalled finality, and corrupt-cache recovery.
7. Run a limited public testnet beta with monitoring, published incidents, and explicit experimental warnings.
8. Specify miner queries, validator challenges, commitments, scoring, anti-copying tests, bandwidth budgets, and gateway quorum behavior.
9. Demonstrate that independent miners add verifiable availability and correctness beyond conventional replication before registering a subnet.
10. Review marketplace settlement and mainnet activation as separate approval gates. Neither is implied by a successful testnet subnet.

More subnet capacity may create room for specialized proof services, but it does not guarantee cheap registration, emissions, security, or demand. Relics should register only when its commodity, validation process, operating runway, and adversarial model work without privileged trust. The experiment succeeds by making its evidence stronger, not by making its claims larger.

Bittensor Relics does not ask users to trust a website that an image exists, an indexer that a number is real, or a marketplace that a burn occurred. It places the smallest essential artifact and economic receipt in one finalized native transaction, then defines every useful derived answer as deterministic, replayable state.

The chain secures the evidence. The protocol gives that evidence meaning. Independent indexers reconstruct it. A future subnet can reward the miners who preserve and serve it and the validators who catch dishonest or incomplete answers. No layer is described as more powerful than it is.

That is the Bittensor-native opportunity: not another token whose image may outlive its host, and not another invisible database treated as truth, but a cultural object whose bytes, cost, provenance, and ownership history can all be challenged against public evidence.

The Relic is the art.
The burn is the proof.
The network verifies the memory.