Beginning Work on EarthBucks 2.0

Work has begun on EarthBucks 2.0.

The first step is not a shiny button or a dramatic launch video. It is the unglamorous part that has to work before anything else can work: consensus code for real server-side mines.

I have started the foundational engineering work for the next major version of EarthBucks: the version that finally implements the peer-to-peer mine network, adds a Bitcoin Cash wallet, and enables atomic swaps between EBX and BCH.

That combination is the practical path to making EarthBucks more useful, more liquid, and more real.

What EarthBucks 2.0 Means

I first wrote about the plan for EarthBucks 2.0 last year. The core idea remains the same: EarthBucks needs the peer-to-peer network that was always part of the original design.

But I want to be more precise about what that means now.

EarthBucks 2.0 has three major goals:

1. Build the real peer-to-peer mine network.
2. Add a Bitcoin Cash wallet.
3. Enable atomic swaps between EarthBucks and Bitcoin Cash.

The peer-to-peer network is the foundation. The Bitcoin Cash wallet and atomic swaps are what give EarthBucks a practical path to market value. Bitcoin Cash is useful, liquid electronic cash today. If EBX can be swapped with BCH in a self-custodial way, then EBX can have real price discovery without waiting for a centralized exchange.

That is EarthBucks 2.0 in one sentence: build the real network, connect it to liquid electronic cash, and let EBX find a market.

The Mine Network

EarthBucks is not Bitcoin, and the network is not designed like Bitcoin.

On Bitcoin, nodes relay transactions and blocks over a custom peer-to-peer protocol. Miners produce blocks, and full nodes validate them.

On EarthBucks, the core network consists of mines. A mine is closer to a Bitcoin full node than to a Bitcoin miner. A mine validates transactions, maintains the working chain state, creates blocks, connects to other mines, and operates as a professional web service at a domain name.

I explained the distinction in “Mines vs. Miners”. Anybody can be a miner by performing proof-of-work calculations. Not anybody can operate a mine. Mines are permissioned, known, and accountable.

For EarthBucks 2.0, all initial mines will be operated by Astrohacker. The first deployment will probably be a small number of mines, such as:

• mine1.earthbucks.com
• mine2.earthbucks.com
• mine3.earthbucks.com

After that, I expect to grow to 7 or 9 mines, and possibly more later. Third party mine operation can come later, under rules. The first goal is to make the software work correctly with mines operated by the company.

Each mine will have its own domain name. Each mine will talk to every other mine. The mine network will be permissioned at first because this is not an anonymous hobbyist network. It is the settlement layer for electronic cash.

This is the network architecture I described in “Anticipated Network Architecture of EarthBucks”. The details will evolve, but the main idea has not changed: mines are the core of the network, and domain names are part of the security model.

Blocks Are Not Relayed Like Bitcoin

There is an important detail about EarthBucks that is easy to miss: mines do not normally need to send full blocks to each other.

Ordinary transactions are sent once. Mines synchronize transactions and Merkle state continuously. By the time a block is found, every mine should already have the ordinary transactions and the working Merkle tree.

That means the mined result can be propagated as the new header and the mint transaction. The other mines already have the rest.

Full block validation is still useful. It is needed for initial sync, repair, fixtures, and tests. But full-block relay is not the normal fast path. The normal path is continuous transaction and Merkle synchronization, followed by a small mined announcement.

That difference matters. It is one of the ways EarthBucks can be more efficient than a Bitcoin-style network while still validating everything.

Bitcoin Cash and Atomic Swaps

The peer-to-peer mine network is necessary, but it is not sufficient.

EarthBucks also needs liquidity. It needs a way for EBX to have a real market value.

The most practical first step is Bitcoin Cash. Bitcoin Cash already exists. It has users, wallets, exchanges, and a market price. It is also philosophically close to EarthBucks: electronic cash with low fees.

For EarthBucks 2.0, I plan to add a Bitcoin Cash wallet and support atomic swaps between EBX and BCH. The goal is self-custodial exchange. Users should be able to trade without trusting a centralized exchange to custody funds.

The details are not all settled. The Bitcoin Cash wallet, swap protocol, order discovery, user interface, and liquidity model all need real engineering. But the direction is clear: EBX should be swappable with BCH, and that gives EBX a route to price discovery.

That is how EarthBucks can become real internet money instead of a technically interesting chain waiting for a market.

What We Have Done So Far

The first visible work on EarthBucks 2.0 is not a new wallet screen. It is a large Rust implementation of the EarthBucks library.

The original EarthBucks library is written in TypeScript. That code is still important. It defines the behavior of the current chain and the current app. However, server-side mines should be implemented in Rust.

Over the past few days, I have implemented a majority of the EarthBucks library in Rust, translated from the TypeScript implementation and tested against it. This includes:

• serialization primitives;
• keys, public key hashes, and signatures;
• scripts and script templates;
• the script interpreter;
• transactions and transaction signing;
• transaction verification;
• mint transaction validation;
• Merkle trees and Merkle proofs;
• block serialization and parsing;
• block acceptance and full block validation;
• Pow5 header work validation.

This is the kind of work that only looks boring until it is wrong. Consensus code needs to be explicit and tested. Mines cannot be built on vibes. They need exact serialization, exact validation rules, exact error cases, and tests that pin behavior against the existing implementation.

That is the job of this Rust work.

Why Rust

The current web application is TypeScript, and TypeScript remains useful for apps, APIs, and client code. But the mines should be Rust services.

Rust is a better foundation for long-running server-side consensus software. It is fast, native, memory safe, and explicit. It also gives us a cleaner path to separate the consensus-critical library from the current web app.

The first Rust mines will probably be backed by MySQL. That may change before the implementation is finished. The database schema for EarthBucks 2.0 should be designed for the mine architecture, not copied blindly from the current EarthBucks 1.0 app.

The consensus layer is moving into Rust first. The database and networking layers can then be built on top of it.

What We Are Not Doing in 2.0

It is just as important to say what EarthBucks 2.0 is not.

EarthBucks 2.0 is not a new genesis block. It is not a balance reset. It is not a new coin. It is not a visible disruption to users.

EarthBucks 2.0 is also not a post-quantum cryptography rewrite.

I recently wrote “EarthBucks Is Already Quantum Resistant”. The short version is this: EarthBucks still uses classical secp256k1 signatures, but it was designed to avoid exposing public keys unnecessarily. Coins are locked to public key hashes, keys are not reused, public keys are revealed only when spending, and transactions are designed to settle quickly through permissioned mines.

That already gives EarthBucks the practical quantum-resistance properties that matter most. We do not need to bloat EarthBucks 2.0 with larger post-quantum keys and signatures before the post-quantum ecosystem is mature.

Post-quantum cryptography is real, and EarthBucks will probably add it someday. But not in 2.0.

EarthBucks 2.0 is also not the time for every advanced feature I can imagine. The following are saved for EarthBucks 3.0 or beyond:

• unlimited use of script;
• more advanced smart contracts;
• tokens;
• a new proof-of-work function;
• post-quantum cryptography;
• broader third-party mine operation.

Those may all be worth doing eventually. But they are not the next step.

The next step is to finish the network EarthBucks was supposed to have from the beginning, and to connect EBX to an existing cash market through Bitcoin Cash.

What Comes Next

The next pieces are clear:

1. Finish the remaining Rust mine substrate.
2. Design the EarthBucks 2.0 mine database schema.
3. Build the inter-mine synchronization protocol.
4. Launch the first Astrohacker-operated mines.
5. Build the Bitcoin Cash wallet.
6. Design and implement EBX/BCH atomic swaps.

There will be many details along the way. Storage may change. APIs may change. The exact first mine domains may change. The atomic swap design will need its own careful work.

EarthBucks 2.0 means Rust mines, domain-based peer-to-peer consensus, Bitcoin Cash liquidity, and self-custodial swaps.

Conclusion

EarthBucks 2.0 has begun.

The first milestone is not flashy. It is the Rust consensus foundation required to build real mines. That foundation is now well underway.

The vision is the same as before, but sharper: permissioned domain-name mines, continuous transaction and Merkle synchronization, Bitcoin Cash wallet support, atomic swaps, and a practical path to real electronic cash.

Astrohacker builds the products. EarthBucks moves the money.