{"id":879279,"date":"2026-07-29T08:17:38","date_gmt":"2026-07-29T08:17:38","guid":{"rendered":"https:\/\/gridnet.org\/wpp\/?p=879279"},"modified":"2026-07-29T08:24:28","modified_gmt":"2026-07-29T08:24:28","slug":"the-second-tier","status":"publish","type":"post","link":"https:\/\/gridnet.org\/wpp\/index.php\/2026\/07\/29\/the-second-tier\/","title":{"rendered":"The Second Tier"},"content":{"rendered":"
\n
GRIDNET Magazine<\/span><\/p>\n

The Second Tier:
\nA Content Delivery Network That Pays Its Neighbours<\/span><\/h1>\n

A GRIDNET OS Field Dispatch<\/p>\n

Two tiers of storage, one economy — the crypto-incentivized content-delivery network we are building into the operating system.<\/p>\n

By the Wizards
\nJuly 2026
\n25 min read<\/div>\n<\/header>\n
\n

⚠ Early Research & Development — Read this first<\/p>\n

Everything described in this article is at an active, early research and development stage<\/b>. GRIDNET OS Tier 2 storage is being designed, prototyped, tested and stress-tested in the open — and whether we ultimately manage to pull off everything laid out here is yet to be seen<\/b>. What follows is a field dispatch from the middle of a difficult problem, not a shipped product.<\/p>\n

We publish daily — often hourly — updates on our Discord #live-development<\/a> channel as the work moves. Come watch us push, fail, learn, and try again.<\/p>\n<\/div>\n

\n

📄 Peer-reviewed foundation<\/p>\n

Every data-exchange incentivization mechanic described and referenced in this article — the token pools, the off-chain Transmission Tokens, the depth-delta settlement, and the Sybil-proof<\/b> construction that makes them safe against a lone operator pretending to be many — has been published in a peer-reviewed research paper.<\/p>\n

📄 “SPIDE: sybil-proof, incentivized data exchange”<\/b>
    Cluster Computing<\/em>, a prestigious scientific journal by Springer.
    Available for download at link.springer.com\/article\/10.1007\/s10586-021-03411-3<\/a><\/p>\n<\/div>\n

\"A
A decentralized content delivery network — every node holds a fragment; every fragment is paid for as it flows.<\/figcaption><\/figure>\n

I. The strange quiet cost of storing something<\/h2>\n

For most of the digital age, storage has felt like the least interesting problem a computer could have. You buy a bigger drive; you rent a bigger bucket. When your files matter enough, you pay a company that promises never to lose them, and mostly, they don’t.<\/p>\n

But the “mostly” hides a lot. The company is a single point of failure and a single point of censorship. Its bill grows with your success. Its terms of service change without your consent. And when it decides your file offends someone — a copyright holder, a regulator, an angry executive — it is gone.<\/p>\n

The Web3 answer to that problem, IPFS, took a genuinely important step: content-addressed files, no central bucket, anyone can help host. But IPFS solved the addressing<\/em> problem, not the economics<\/em>. Nodes host files because they choose to, not because they are paid to. Retrieval is best-effort. Popular files spread; the rest disappear into the archives that nobody wants to keep.<\/p>\n

We think the missing ingredient is the same one that has always driven every real distributed system: an honest, tight-loop economic incentive for storing and for delivering bytes, all the way down to the shard<\/strong>.<\/p>\n

That is what GRIDNET OS’s Tier 2 storage layer is. And because we are already building the operating system, the game world, the wallet, the file manager, the media player, the mobile app — we get to wire the incentive through all of them, natively, with the user never seeing the pipes.<\/p>\n

\"Two
Two tiers, one file — Tier 1 keeps the metadata, ACL, and reward schedule replicated on every node; Tier 2 spreads the payload across a market of participating peers.<\/figcaption><\/figure>\n
\n

II. Two tiers, not one<\/h2>\n

The clean insight is that not every byte is equal.<\/p>\n

Some bytes need to be permanently, immutably true<\/strong> — a file’s identity, its owner, who is allowed to read it, and what its author will pay to keep it stored. These bytes live on Tier 1, our Merkle Patricia Trie state-trie, replicated in full on every node, secured by the same Proof-of-Work consensus that carries every other on-chain fact. Tier 1 is expensive by design, because it is the register everybody agrees on.<\/p>\n

Other bytes are the payload<\/em> — the actual movie, the actual album, the actual training dataset. Those are large<\/em>. Making every node keep a copy of every one of them is uneconomical and, honestly, unnecessary. What we need is for enough<\/em> nodes to keep enough<\/em> copies that the payload is reliably retrievable, and for a market to decide who those nodes are, based on who is willing to pay what for storing what.<\/p>\n

That market is Tier 2.<\/p>\n

Every file gets a shortcut on Tier 1<\/strong> — a small metadata record that points at the payload, states the access-control list, and posts the reward schedule the owner is willing to pay per gigabyte per day. That record is replicated everywhere. The payload itself is broken into shards and scattered across whichever peers — Core operators, browser tabs, phones — choose to hold it, for the reward the owner offers.<\/p>\n

The shortcut is small and immutable. The payload is huge and distributed. The two anchor each other.<\/p>\n

\n

III. On the shoulders of a protocol that already works<\/h2>\n

We could have invented a new peer-to-peer transport for Tier 2. We chose not to.<\/p>\n

BitTorrent has been carrying enormous shard flows across the open internet for over two decades. It is battle-tested, understood, and, importantly, it was designed with protocol extensions in mind<\/strong> — a formal extension-message mechanism that lets a torrent-savvy stack negotiate features with its peers without breaking anyone. GRIDNET’s Tier 2 is a well-documented extension of the torrent protocol. Peers that speak our extension can trade shards and<\/em> trade transmission tokens. Peers that don’t, don’t.<\/p>\n

We wired the extension in both<\/em> directions: the C++ layer inside GRIDNET Core<\/strong>, so operator nodes speak it natively; and the JavaScript layer inside the browser sub-system of GRIDNET OS<\/strong>, so any dApp running in a Chrome tab is a first-class Tier 2 peer. The transport rides our existing QUIC channel (CConversation<\/code>), not a new port — a discipline we adopted because we already do enough NAT-traversal for one operating system.<\/p>\n

The result is a shard economy that runs from a data-centre server to a rooftop mining rig to a laptop in a cafe to a phone in a coat pocket, all speaking the same language.<\/p>\n

\n

IV. Payments per shard — and only per shard<\/h2>\n

An economy is only as honest as its accounting. If storing files earned some vague reputation score, or if downloading files invoked “credits” that lived only inside a company’s ledger, you would not be reading this article. You would be reading about another crypto-flavoured product launch.<\/p>\n

Our answer is a construction we call State-Less State Channels<\/strong>, and it is the exact mechanism we published as SPIDE: sybil-proof, incentivized data exchange<\/a><\/em> in the peer-reviewed journal Cluster Computing<\/em>. In plain terms: you open a channel by locking a small amount of GNC in a token pool, and from that moment on, every action in the channel produces a signed micropayment off-chain<\/em>, cryptographically bound to the specific piece of data it is paying for. Each token carries a depth<\/em> — the running total — and the seller only ever needs to hold on to the deepest<\/em> token they receive from you. The channel could carry a thousand shard payments, and at the end of the day, one on-chain settlement transaction cashes out the full accumulated amount.<\/p>\n

The rail is spam-proof: the chain does not see individual shard payments. It is honest: the token is signed against the shard’s own hash, so a payment can only ever be for that data<\/em> and no other. And it is efficient: transferring the deepest token to the chain releases only the delta above the previous settlement, so intermediate tokens never need to be broadcast.<\/p>\n

\"Off-chain
Off-chain tokens flow with the shards; only the deepest one is ever settled on chain. A thousand shard payments collapse to one settlement transaction.<\/figcaption><\/figure>\n

The critical detail, and one of the properties we are proudest of: the dApp asking for the file has zero payment plumbing in it<\/strong>. It calls openStreamA<\/code> for a movie, and payments happen. The token pool comes from user settings authored in the Wallet, which is where money lives, not in the Media Player, which is where movies play. Any dApp can override, but no dApp has to know.<\/p>\n

\n

V. Two directions of the same economy<\/h2>\n

Once you have that rail, a lovely symmetry appears.<\/p>\n

There are two things a decentralized storage system needs to pay for. First, delivery<\/strong> — when someone downloads a file, they need to compensate the peer who served them the bytes. Second, storage<\/strong> — the file’s owner needs to compensate the peers who are holding onto the payload for them over time.<\/p>\n

Most designs solve one and ignore the other. IPFS solved neither. Filecoin bolted storage-payments on but bifurcated the two economies into separate contract systems. We ended up with a nicer answer almost by accident: the same rail carries both directions<\/strong>.<\/p>\n

For delivery<\/strong>, the recipient pays as bytes arrive. Each shard requested from a peer travels with (or is followed by) a signed Transmission Token that binds a payment to that piece’s hash. The seller only accepts the shard-request if a token accompanies it.<\/p>\n

For storage<\/strong>, the file’s owner periodically asks each peer holding the file to prove they still have it — a random challenged shard, answered with a Merkle proof<\/strong> against the shard hashes committed on Tier 1. If the proof verifies, a Transmission Token flows in reward. Same rail, same signature scheme, same depth-delta settlement. Just a different question being asked at a different rhythm.<\/p>\n

Two economies, one construction. And because the same tokens can flow either way, both work with zero net new complexity in the payment layer<\/strong> — only the moment of payment differs. The Sybil-resistance of the mechanism — how a lone operator cannot pretend to be many, and how many operators cannot collude cheaply — is proven in the same peer-reviewed paper<\/a>.<\/p>\n

\"One
One incentivization rail — two directions. Delivery pays as bytes flow. Storage pays after a Merkle proof of possession. Same tokens, same channel, same settlement.<\/figcaption><\/figure>\n
\n

VI. Your browser tab is a peer<\/h2>\n

Traditional peer-to-peer networks live and die by their servers. Even torrents get most of their bandwidth from the small handful of dedicated seeders keeping the file alive long after the swarm has moved on. If you have ever tried to download a five-year-old documentary from a torrent index, you already know how honest that architecture is with itself.<\/p>\n

GRIDNET Tier 2 has no distinction between “server” and “client”. It has one class of participant: a peer<\/strong>. A GRIDNET Core node running twenty-four hours a day in a rack somewhere is a peer. A Chrome tab that a user just opened to watch a movie is a peer. A phone in a coat pocket, on 4G, running the mobile app, is a peer.<\/p>\n

Which is another way of saying: your browser tab both buys and sells<\/strong>.<\/p>\n

When you stream a video from GRIDNET OS, your browser is downloading shards and paying for them — buying. But those shards are then held in the browser’s local storage, and other<\/em> browsers in the mesh can request them from you, at which point your browser is delivering shards and being paid for them — selling. A hover over your File Manager taskbar widget shows the running earnings against the running spend. A shiny button in the Wallet lets you cash the earnings out on-chain when they are worth the settlement cost.<\/p>\n

\"Every
Every device is a peer — from a rack in a data centre to a phone in a coat pocket. Each buys and sells in the same market.<\/figcaption><\/figure>\n

Your phone can be a milk-cow. Your laptop, quietly, while you sleep, can host a movie the neighbourhood is streaming and be paid in GNC for every shard it delivers. Your browser, while you are watching one movie, can be seeding a hundred others. A user does not need to be a network engineer to become a piece of internet infrastructure.<\/strong><\/p>\n

\"No
No server, no client — one class of participant. Every device buys the shards it wants and sells the ones it holds, on the same protocol.<\/figcaption><\/figure>\n
\n

VII. Files as assets — an autonomous portfolio<\/h2>\n

Once storage is a market and delivery is a market, the files themselves become financial objects. A movie is not just a movie; it is a demand signal<\/em>. A rare technical paper is not just a paper; it is a yield opportunity<\/em>.<\/p>\n

We took that observation to its natural conclusion: both Core nodes and browser sub-system nodes autonomously manage their local storage as a portfolio<\/strong>.<\/p>\n

Each side of the OS runs the same loop. It scans the on-chain reward schedules and the market’s advertised popularity. It compares against your local storage budget — a two-dial affair you set in the Wallet: how much of your disk goes to Tier 2, and what percentage of that<\/em> helps deliver other people’s<\/em> files versus holds yours<\/em>. It prefetches the shards that combine high recent yield<\/em> with your risk tolerance<\/em>, and it evicts the shards whose yield has fallen below your configured minimum. All of it happens without the user ever opening a spreadsheet.<\/p>\n

The File Manager surfaces the results. Hover the Wallet taskbar widget and see current spend and current earnings, both in fresh GNC and both to three decimal places. Hover the File Manager taskbar widget and see per-transfer rows, per-file spend, contract health, and the ranked list of files earning you the most. Cash out from the Wallet when the settlement math works in your favour. Repeat.<\/p>\n

\"Files
Files as an autonomous portfolio — both Core nodes and browser instances scan demand, pre-fetch popular shards, and evict low-yield ones. Your disk becomes a book of positions that manages itself.<\/figcaption><\/figure>\n
\"The
The autonomous portfolio loop — scan, pre-fetch, earn, evict. Both browser and Core run the same loop against a bounded local budget.<\/figcaption><\/figure>\n

There are hazards, and we would rather stare at them directly than pretend they are not there. Popularity is attacker-controllable<\/strong> — a coordinated group could pump a file’s apparent demand to trick honest nodes into prefetching it. Speculative prefetching must never destroy the user’s own irreplaceable data<\/strong> — an evictor must know the difference between “content held speculatively” and “content the user is the sole seed of”. Raising a browser’s storage budget raises eviction pressure on the origin bucket<\/strong>, which is where the wallet lives — so any budget increase now requires an explicit destructive-action confirmation. We treat these as engineering problems, not deal-breakers. But they are why “autonomous” here comes with an operator allow-list and a cap.<\/p>\n

\n

VIII. Ultra-fast global file search<\/h2>\n

A storage layer only works if you can find<\/em> things in it. The old way was for each dApp to walk the network end-to-end whenever a user typed a query. That does not scale; it made global search a hopeless UI.<\/p>\n

The new way: Core keeps an ultra-fast indexed cache of file metadata<\/strong>, covering both tiers in one queryable surface. When you type a query — anywhere — a small BER-encoded record called a CFileDesc<\/code> streams from Core over websocket, gets deserialized in a web worker (so nothing blocks the UI), lands on CVMContext<\/code>, and reaches whatever dApp asked. CFileDesc<\/code> is deliberately download-sufficient<\/em> — it carries the object identity, piece geometry, Tier-1 anchor path, media class, encryption state, and the reward schedule — so a search result can start a transfer with no second round trip<\/strong>.<\/p>\n

The user experience that falls out of this is where the machinery becomes worth showing off.<\/p>\n

In the File Manager.<\/strong> Global file search bar at the top; results appear as you type; tap one and the correct dApp launches. A movie plays. A PDF opens in a viewer. A .gpp<\/code> script boots into the Terminal. Extension-aware, no user configuration needed.<\/p>\n

In the Magic Button.<\/strong> Hold your finger on it for two seconds on mobile mode — a search panel animates in. Each keystroke, results with extended metadata. Tap a result to open the appropriate dApp. Copy the corresponding GLink<\/a><\/strong> to share with a friend, who clicks it and lands on the exact same file the moment their browser bootstraps. (If GLinks are new to you, we wrote a dedicated piece on how they work: One Link to Launch Them All — Deep-Linking for GRIDNET OS<\/a>.)<\/p>\n

In the Media Player.<\/strong> Type a movie title. The player finds the file on Tier 2, opens a paying stream, plays from partial pieces while the rest continue to arrive. Subtitles are supported in multiple formats. Your browser continues to seed the shards it has already downloaded to other browsers requesting them in the same instant.<\/p>\n

\"One
One keystroke to a searchable universe — Core keeps the index; a compact CFileDesc travels via websocket through a web worker and lands on CVMContext. No dApp ever walks the network.<\/figcaption><\/figure>\n

The pipeline is the same one the Blockchain Explorer already uses for transactions and blocks. Building it that way was a discipline — we resisted inventing a parallel one — and now searching a file is architecturally the same as searching a transaction. It just returns a CFileDesc<\/code> instead of a CTransactionDesc<\/code>.<\/p>\n

\n

IX. All of it, wired end to end<\/h2>\n

There is a temptation, when building storage, to stop at the storage. Ship the primitive, let dApp authors figure out the surface. We resisted it. GRIDNET Tier 2 is not a library; it is an operating-system facility, and we have wired the facility all the way through the OS.<\/p>\n