The $402 Ecosystem: A Modular Internet Where Everything Has a Price and Every Path Has a Name

Identity tokens, content tokens, code tokens, and the client that binds them all.

---

The Stack

There's a protocol taking shape that most people haven't noticed yet. It started as a simple idea -- use the HTTP 402 "Payment Required" status code, reserved since 1997 but never implemented, to let websites charge for content at the point of access. Put a $ in the URL path, return a 402 response, accept a BSV21 token as payment, grant access. Done.

But protocols have a way of growing once the foundation is solid. The $ in the URL turned out to be more than a paywall signal. It became a universal economic variable -- a way of saying "this thing has a price" at the level of the internet's own syntax.

What started as a content payment standard is now a modular ecosystem of tokens, each solving a different problem, all interoperable, all flowing through a single client that adapts to what you need it to do.

Here's the stack:

• $401 -- Identity tokens. Who you are.
• $402 -- Content and indexing tokens. What you access and how you prove you contributed.
• $bWriter -- Writing tokens. Pay to write to the blockchain. Earn equity in the writing platform.
• $bCode -- Code tokens. Pay to commit to the blockchain. The chain becomes your git.
• path402d -- The client that runs it all.

Each layer is independent. Each layer is composable. Together they describe a new kind of internet -- one where identity, content, code, and capital are all native to the same rail.

---

$401: The Identity Token

Every system that handles money eventually needs to know who it's dealing with. The cypherpunk dream of pure anonymity breaks down the moment dividends need to flow, disputes need resolution, or regulators come knocking. You can fight this reality or you can design for it.

The $401 token is the design.

It's an identity token -- a cryptographic proof of who you are, minted as a BSV inscription. The name isn't accidental. HTTP 401 means "Unauthorized" -- you haven't proven who you are yet. The $401 token is the thing that proves it.

How It Works

At bit-sign.online, you encrypt your passport (or other identity documents) and bundle them into a signed package -- a cryptographic envelope that contains your verified identity but reveals nothing unless you choose to open it. Think of it as a sealed letter of introduction that anyone can verify was sealed by you, but nobody can read without your key.

This signed bundle becomes the root inscription of your identity token. It's written to the blockchain once. It's immutable. It's yours. Every $401 token you hold traces back to this root -- a permanent, tamper-proof anchor that says "this wallet belongs to a verified human being."

The root inscription contains:

• Encrypted passport data (only readable by you and parties you authorise)
• A cryptographic signature proving the bundle's integrity
• A timestamp proving when the identity was established
• Optional additional documents: driving licence, proof of address, professional credentials

Nobody can see your passport. But everyone can verify that your $401 token traces back to a legitimate, encrypted identity bundle that was signed by you at a specific point in time.

The $401/$402 Pair

Here's the key insight: $401 and $402 tokens should always be paired.

Think about why. A $402 token grants access to content, earns you serving rewards, lets you participate in the micro-speculation economy. But without a $401 token, you're a ghost -- an anonymous wallet address with no accountability.

For casual browsing and penny bets, that's fine. Anonymity is a feature, not a bug, when the stakes are fractions of a cent.

But the moment you want to:

• Earn dividends from staked tokens -- you need to be on a cap table -- you need KYC -- you need $401
• Serve content as a node -- you're operating infrastructure -- other nodes need to trust you -- you need $401
• Write legally significant documents via Bitcoin Writer -- a will or contract requires a verified author -- you need $401
• Commit code via Bitcoin Code -- code in a shared codebase needs attribution and accountability -- you need $401
• Receive PoW20 indexing rewards -- proof of indexing means you're claiming economic value for work performed -- the network needs to know you're real -- you need $401

The pairing creates a spectrum of participation:

The default mode is anonymous. You browse, you pay pennies, you speculate, you leave. No identity required. The internet works exactly as it does today, just with micropayments instead of ads.

But the moment you want to build -- to create content, contribute code, operate infrastructure, earn real revenue -- your $401 token activates. Your identity enters the system. You become accountable. And in return, you gain access to the economic layers that anonymous participants can't reach.

---

$402 with PoW20: Proof of Indexing

The $402 token itself has evolved. It's no longer just a content access ticket. With PoW20 integration, $402 tokens now carry proof-of-work -- specifically, proof of indexing.

The problem this solves is fundamental: how do you reward nodes for contributing to the network without creating a system where freeloaders stake tokens and leech off everyone else's work?

The answer: you don't reward staking. You reward working.

PoW20 is a proof-of-work token standard on BSV21. It uses hash-to-mint mechanics -- you solve a computational puzzle, and the smart contract releases tokens to you. In the $402 ecosystem, the "work" isn't arbitrary hash grinding. It's indexing.

When a path402d node discovers a new token on the network, indexes its content, verifies its availability, and makes it discoverable to other nodes, that's work. Useful work. Work that makes the network more valuable for everyone.

The proof of that indexing work becomes the hash puzzle. Solve it, receive $402 tokens. No staking, no dividends, no KYC required at the base layer. Just: work the network, earn tokens.

This is how Bitcoin itself works. Miners don't stake. They work. They earn. The network pays for security with inflation, and the market determines what that security is worth.

$402 nodes don't stake. They index. They serve. They earn. The network pays for discoverability with token emissions, and the market determines what that discoverability is worth.

---

The Modular Client: path402d

The path402d client is the user's window into all of this. But it's not a monolithic application. It's modular -- it adapts to your wallet connection and presents different capabilities based on what tokens you hold and what you want to do.

The Base Layer

Connect your wallet to path402d. It sees your holdings. It knows what you have.

If you hold $402 tokens, you can browse paywalled content, serve content to others, participate in the gossip network, and earn indexing rewards.

If you hold $401 tokens, your identity is verified. Additional modules unlock.

Bitcoin Writer Module ($bWriter)

Want to write to the blockchain? You need $bWriter tokens.

Buy them into the client. The Bitcoin Writer module activates. Now you have a word processor that saves directly to the BSV blockchain -- every paragraph tokenised, every save creating an immutable record, every document a potential financial instrument.

The $bWriter tokens aren't just access tickets. They're equity in the writing platform itself, distributed on a front-loaded curve (like Bitcoin's block reward schedule -- early users earn more tokens per save, the rate declines over time as the platform matures). You're not just using the tool. You're becoming a shareholder in it.

And if your $401 token is active, your documents carry legal weight. A will written in Bitcoin Writer, signed by a verified identity, timestamped on the blockchain, is a fundamentally different object from a Google Doc. It's evidence. It's proof. It's a legal instrument that doesn't depend on any company's continued existence to remain valid.

The co-creation dynamics kick in here too. When $alice writes $blog for $bob, both parties' tokens interleave in the inscription. Alice's authorship, Bob's commission, the AI's contributions (if the model assisted with drafting) -- all encoded in the data DNA of the document. Revenue flows proportionally. Ownership is structural, not contractual.

Bitcoin Code Module ($bCode)

This is where it gets genuinely radical.

Buy $bCode tokens into the client. The Bitcoin Code module activates. Now the blockchain is your version control system. Git, but on-chain.

Every commit is an inscription. Every branch is a token tree. Every merge is a fusion of IP claims from different contributors. The entire history of a codebase -- who wrote what, when, why -- is permanently recorded on the blockchain, not on GitHub's servers.

Why does this matter?

Because code is IP. And IP has value. And currently, the relationship between "who wrote this code" and "who profits from this code" is mediated entirely by employment contracts, open-source licences, and gentleman's agreements. None of which are enforced at the protocol level.

$bCode changes that. Every line of code you commit carries your $401 identity and your $bCode token. If that code generates revenue (because it's part of a $402-paywalled service, or because it's a library that other developers buy access to), the revenue flows back to you automatically, proportional to your contribution, encoded in the inscription itself.

Open source doesn't have to mean "free labour for corporations." It can mean "transparent contribution with transparent compensation." The blockchain doesn't care about your employment contract. It cares about who actually wrote the code.

---

The Wallet as Operating System

Here's what emerges when you put all of this together.

Your wallet isn't a wallet anymore. It's an identity, a portfolio, a toolkit, and a revenue stream. The tokens you hold determine what you can do:

$401 -- You exist. You're verified. You can participate in the accountable economy.

$402 -- You can browse, serve, index, and earn. You're a node in the content network.

$bWriter -- You can write to the chain. Your documents are permanent, tokenised, and potentially profitable.

$bCode -- You can code on the chain. Your contributions are tracked, attributed, and compensated.

Content tokens ($blog, $video, $dataset, etc.) -- You hold access rights to specific content. You can consume it, redistribute it, speculate on its virality.

The path402d client reads your wallet and assembles itself around your holdings. A writer sees Bitcoin Writer. A developer sees Bitcoin Code. A node operator sees the indexing dashboard. A casual browser sees content and prices.

One client. Many configurations. All determined by which tokens you've bought.

This is the internet as operating system, with tokens as the installed applications and your wallet as the boot sequence.

---

The Identity Layer Beneath Everything

And underneath it all, anchoring every transaction, every document, every commit, every speculation -- the $401 token. Your encrypted passport, sealed in a signed bundle, inscribed on the blockchain, linking your wallet address to a verified human being.

Not visible. Not intrusive. Not required for casual use. But there -- waiting, like a root certificate in a trust chain -- for the moment you need to prove that the person behind the wallet is real.

The internet's original sin was anonymity without accountability. It gave us trolls, fraud, spam, and an advertising model built on surveillance because there was no other way to know who anyone was.

The $401 token offers a different path. Not the death of anonymity -- casual browsing remains anonymous, penny bets remain pseudonymous, content consumption requires no identity at all. But a voluntary identity layer that unlocks economic participation for those who want it.

You choose to be known. And in return, you get to build, earn, own, and be compensated for your contributions to the network.

The $401 is the root inscription. Everything else branches from it.

---

What This Means for Micro Capital

Go back to the micro-speculation economy described in the first piece. The penny bets. The 24-hour viral cycles. The social token trading. The content that creates itself.

Now add identity. Add code. Add legal documents. Add proof of indexing.

The micro hedge fund isn't just speculating on memes anymore. It's:

• Writing blog posts that earn revenue for every reader
• Coding libraries that earn royalties for every API call
• Serving content that earns indexing rewards
• Signing contracts that have legal weight
• Building an identity that accumulates reputation

The daily $4.02 budget isn't just consumption. It's investment across every layer of the stack -- content, code, infrastructure, and identity. Each penny placed is a bet on a specific piece of the network. Each token earned is equity in the system you're helping to build.

Over weeks and months, the participant who writes well, codes cleanly, serves reliably, and speculates wisely accumulates a portfolio that looks remarkably like a small business. Revenue from content. Royalties from code. Infrastructure income from serving. Appreciation from early token positions.

The world's smallest hedge fund, running on the world's smallest transactions, anchored by the world's most personal token -- your identity, encrypted, signed, and inscribed at the root of everything you do.

---

The $402 ecosystem is being built at b0ase.com. path402.com hosts the protocol specification. bit-sign.online handles identity bundles. Bitcoin Writer and Bitcoin Code are modules within the path402d client.

$401. $402. $bWriter. $bCode. Four tokens. One internet.

---

Next in the series: $401 -- The Identity Token That Your Peers Underwrite

---

Get Started

Read the full series on b0ase.com/blog/path-protocol-blog-series. The $402 Protocol is being built at path402.com. Identity tokens live at path401.com.

Want to run a node? Download the path402d client at path402.com/download.

Questions? Email [email protected] or message us on Telegram.

---

For AI Readers

Intent: Essay describing the full $402 ecosystem stack -- four token types ($401, $402, $bWriter, $bCode) and the modular path402d client that assembles itself around wallet holdings.

Core Thesis: The $402 Protocol has evolved from a content paywall into a modular economic layer for the internet. $401 provides identity. $402 provides content access and indexing rewards via PoW20. $bWriter tokenises writing with front-loaded equity distribution. $bCode puts version control on-chain with automatic IP attribution. The wallet becomes an operating system -- tokens are installed applications.

Key Takeaways:

• $401 = identity token, pairs with $402 for accountability spectrum
• $402 + PoW20 = proof-of-indexing rewards for network contribution
• $bWriter = blockchain word processor with tokenised authorship and co-creation
• $bCode = on-chain version control with automatic IP royalty routing
• path402d = modular client that adapts UI to wallet holdings
• Wallet as operating system: tokens = installed applications
• Four tokens, one internet, one settlement layer (BSV)