Abstract

Zhouswap is a decentralized, non-custodial network for exchanging value across the Bitcoin SV (BSV) and Ethereum chains. It lets anyone swap between ZHOU (a token issued on BSV), BSV (native), and USD stablecoins (USDC and USDT on Ethereum) without handing custody of their assets to any operator. Settlement uses hash time-locked atomic swaps: the two sides of a trade are locked on their respective chains under the same secret, so ownership changes hands simultaneously or not at all — no intermediary ever holds both legs.

Pricing is provided by a constant-product automated market maker (AMM) with a 1% spread denominated in USDC. That spread is not paid to any single operator: it accrues in USDC and, every ten minutes, is used to buy back ZHOU on the open curve and burn it permanently on-chain. ZHOU's supply therefore contracts as the network is used.

The network is run by independent node operators. Anyone can run the zhoud node software, provide liquidity from their own inventory, and serve quotes and swaps. There is no central server, no custodial wallet, and no privileged party who can freeze or seize user funds.

1. Motivation

Most "decentralized exchanges" are decentralized only in their smart contracts; the assets they touch live on a single chain, and the interface is a company. Meanwhile, moving value between chains still overwhelmingly relies on custodial bridges and exchanges — precisely the components that have produced the largest losses in the industry's history.

Zhouswap takes a different position:

• Custody never leaves the user. The only trustless way to trade across two chains without a bridge is an atomic swap. Zhouswap builds its entire settlement layer on that primitive.
• The network, not an operator, captures and recycles value. Fees are not a business line; they are converted into a deflationary force on the token that the whole network shares.
• Anyone can be the counterparty. The node software is open and permissionless. Liquidity comes from operators competing to serve swaps, not from a single pooled contract controlled by one team.

2. Design Overview

A swap in Zhouswap has two legs on two different chains, bound by one secret:

User                          Node (the swap counterparty)
 |  1. quote request (H=SHA256(s))  |   AMM prices the trade, 1% spread
 | --------------------------------->|
 |  2. lock own asset under H        |
 | ---- BSV or Ethereum ----------->|  3. verify, then lock the other asset under H
 |  4. claim, revealing s on-chain   |
 | <---------------------------------|  5. node reads s, claims its side -> settled
 |
 +- if either side stalls, both refund after their deadlines

• BSV side is expressed purely in Bitcoin Script (no Solidity). ZHOU tokens, native BSV, and the swap locks are all script outputs.
• Ethereum side exists only because USDC and USDT are ERC-20s; it is a single, minimal hash-time-locked contract that escrows the chosen stablecoin and releases it on the correct secret. The contract records the token per lock (one deployment serves both USDC and USDT) and uses SafeERC20-style transfers so it tolerates non-standard tokens such as USDT, whose transfer does not return a boolean. USDC and USDT are treated 1:1 on this leg; the AMM keeps its USDC-denominated accounting. Both chains hash the secret with SHA-256, so the same secret opens both locks.
• Node software (zhoud, written in Go, no external chain SDKs) builds and signs both chains' transactions, runs the AMM, watches both chains, and drives each swap to completion or refund autonomously.

2.1 The settlement layer: BSV and Teranode

Zhouswap settles on BSV, a chain engineered for unbounded scaling. BSV's next-generation node implementation, Teranode, has already demonstrated over one million transactions per second in test environments, and its roadmap targets the order of 100 million TPS — an order of magnitude beyond the peak throughput of the major international card networks. Mainnet completed the restoration of the original protocol with the Chronicle upgrade in April 2026 and is now transitioning into the Teranode era.

This figure is not brute-force hardware; it is an architectural change. Unbounded block size invites a classic objection: if blocks grow large, propagation, validation, and mining-template reconstruction cannot keep pace with the block interval, and the resulting rise in orphan rate erodes effective security. Teranode is designed as a structural answer to exactly this. Its core move is to abandon the sequential "discover a block, then distribute its contents" model. Transactions are streamed to the network and validated ahead of time in subtree units, with the Merkle root updated incrementally. When a block is found, all that propagates is a declaration of which subtrees it bundles — validation and propagation are, by then, essentially already done. By severing the proportionality between block size and propagation delay itself, Teranode establishes a base on which million-TPS blocks do not push up the orphan rate.

For Zhouswap this capacity carries a double meaning. First, settlement-layer throughput will, at any conceivable scale, effectively never be the binding constraint on the protocol's growth. Second, because BSV's security model presupposes the existence of enormous transaction volume (see §7), the 100M-TPS target is not marketing but a requirement of the security budget: a chain that has chosen to fund its budget with volume must first build the vessel that carries the volume. Teranode is that vessel.

3. The Atomic Swap Protocol

3.1 Hash-locked outputs

Each locked leg pays to a hash time-locked output. On BSV the output carries two spending paths:

IF   OP_SIZE <32> OP_EQUALVERIFY OP_SHA256 <H> OP_EQUALVERIFY
     OP_DUP OP_HASH160 <claimerPKH> OP_EQUALVERIFY OP_CHECKSIG   (claim with secret)
ELSE OP_2 <pkA> <pkB> OP_2 OP_CHECKMULTISIG                      (refund, 2-of-2)
ENDIF

The claim branch is spendable only by presenting a 32-byte preimage s such that SHA256(s)=H, together with the claimer's signature. The OP_SIZE guard forces the preimage to be exactly 32 bytes so that BSV and Ethereum hash identical inputs. The Ethereum contract mirrors this with sha256(abi.encodePacked(preimage)).

3.2 Why it is atomic

The party that claims first must reveal s on-chain in the process. Once s is public, the counterparty can always claim the other leg. There is no state in which one side has been claimed and the other cannot be — the swap either completes on both chains or is refunded on both.

3.3 Refunds without on-chain timelocks

BSV's Genesis upgrade disabled OP_CHECKLOCKTIMEVERIFY, so a BSV script cannot enforce a refund deadline on its own. Zhouswap instead uses the standard cross-chain-swap construction: the refund path is a 2-of-2 output, and the counterparties exchange a pre-signed refund transaction with nLockTime = deadline and a non-final input sequence before the funds are locked. After the deadline, the holder of the pre-signed transaction can broadcast it unilaterally to recover the locked asset. The Ethereum leg has a real contract-enforced deadline and refunds directly.

The party that locks first is always given the longer deadline, so the later locker (with the shorter window) can never strand the earlier one.

4. The Automated Market Maker

Each node runs constant-product (x·y=k) pools:

• ZHOU / USDC
• BSV / USDC

A ZHOU ⇄ BSV trade is routed through USDC across both pools; the 1% fee is charged once, on the intermediate USDC, never twice.

The spread is always denominated in USDC. On a buy (USDC in) it is taken from the input before the curve; on a sell it is taken from the curve's USDC output. Fees accrue to a per-pool fee reserve.

To keep quoted prices honest under concurrency, a quote reserves inventory at quote time — the curve moves for the next quote immediately, and the exact quoted amounts are the amounts committed on settlement. Unfilled quotes release their reservation when they expire.

5. ZHOU Token & Tokenomics

5.1 The token

ZHOU is a UTXO-based token on BSV. Its unit is the satoshi: 1 ZHOU unit = 1 satoshi of a specially-tagged output. There is no ERC-20 contract and no separate ledger — the Bitcoin UTXO set is the ledger, and validity is established by tracing an output's ancestry back to a single issuance transaction (indexer-verified, as miners do not enforce token rules).

5.2 Monetary policy — Bitcoin's model exactly

ZHOU follows Bitcoin's monetary policy, to the number:

• Hard cap: 21,000,000 ZHOU. No premine, no team allocation, no sale.
• Block reward: 50 ZHOU per block, paid to the operator that produces the block — the "miner" of the Zhou network.
• Halving every 210,000 blocks, so the reward steps down 50 → 25 → 12.5 → … and asymptotically stops.

These are the same constants as Bitcoin, and they sum to the same cap: 50 × 210,000 × 2 = 21,000,000. Emission is clocked by block height, starting from the network's genesis block. Every ZHOU that will ever exist enters circulation as a block reward to whoever mined that block — there is no other issuance path. Distribution is maximally fair in the Bitcoin sense: the supply is handed to the participants who do the work of running and securing the network, over time, rather than to a treasury or an investor round.

Implementation status: the block-reward emitter is implemented and unit-tested in the node software (internal/emission). At genesis the cap is minted once into a locked reserve; the node reads BSV block height and releases the scheduled amount from reserve into circulation, halving on schedule. Each operator activates it via zhoud -issue-reserve and emission_enabled. Because ZHOU is a whole-unit token, integer halving truncates exactly as Bitcoin's does — 20,370,000 ZHOU is released over the full schedule (21,000,000 is the reserve/ceiling; the remainder stays unreleased unless tail-emission is enabled). The current public testnet node has not yet switched from bootstrap issuance to live emission.

5.3 Buyback & burn — the deflationary counterweight

The 1% spread the network collects in USDC is never withdrawn as profit. Every ten minutes, the accumulated USDC across all pools is used to buy back ZHOU on the open curve, and the bought-back ZHOU is sent to a provably unspendable OP_FALSE OP_RETURN output — burned permanently and verifiably on-chain.

• Every swap — including BSV/USDC and USDT swaps — increases the USDC available to buy back ZHOU. Listing more trading pairs increases buy pressure on ZHOU.
• Emission is capped at 21,000,000 and tapers with every halving; burning is continuous and unbounded. Once emission falls below the burn rate, the circulating supply turns net-deflationary and trends below the 21M cap.
• Because the buyback executes on the same curve, it verifiably raises the ZHOU mid-price with each cycle.

Every burn is a public on-chain transaction; total burned is reported by every node.

6. Node Software & Decentralization

zhoud is a single Go binary with no external blockchain SDK dependencies. It implements from first principles: BSV transaction construction and SIGHASH_FORKID signing, Ethereum EIP-155 signing, RLP/ABI encoding, both chains' watchers, the AMM, and the buyback-burn scheduler.

Responsibilities of a node: serve quotes and swaps over a small HTTP/JSON API (also the backend for the web UI); provide liquidity from the operator's own BSV, ZHOU, USDC and USDT inventory; watch both chains and drive swaps to completion or refund without human intervention; and run buyback & burn on schedule.

Users interact through a command-line client (zhou-cli) that holds their keys locally and independently reconstructs and verifies every lock script before committing funds — so a malicious node cannot trick a user into locking to the wrong script or revealing a secret against a lock that does not exist. The web interface connects to any node's public API; the user's swap secret is generated in the browser and never leaves it (only its hash is sent).

There is no central operator, no custodial hot wallet holding user funds, and no party who can pause or seize a swap in progress.

7. Security Model

What the protocol guarantees. Custody stays with each party throughout. Atomic-swap settlement means neither the node nor the user can take one leg without enabling the other to take the second. Secrets are client-generated; the server sees only a hash. Both chains hash with SHA-256 over a fixed 32-byte preimage, so the two legs are cryptographically bound. Signatures are low-S canonical (no malleability), and the node independently verifies the counterparty's on-chain lock — correct script, token, amount, recipient, and confirmation depth — before committing its own funds.

What it does not remove. An atomic swap protects against theft, not against non-completion: a counterparty who abandons a half-finished swap forces the refund path, which is why pre-signed refunds and staggered deadlines matter. Cross-chain finality (reorgs), fee estimation, and inventory management are operational risks a node must handle, and Zhouswap gates its actions on configurable confirmation depth to reduce them.

Maturity. The protocol and node software have undergone extensive internal adversarial review and iterative hardening, and a full swap (including refunds and buyback-burn) has been demonstrated end-to-end on public test networks (BSV testnet + Ethereum Sepolia). The system has not completed an independent third-party audit. Until it has, it should be treated as pre-production: testnet and small-value use only. Nothing in this document is a solicitation to deposit funds.

8. Roadmap

• Testnet hardening — pre-signed refund exchange for both legs, confirmation-gated settlement, inventory reconciliation across restarts. (largely implemented)
• Independent audit — third-party review of the Bitcoin Script, the Ethereum contract, and the node's swap state machine.
• Mainnet — deploy the Ethereum contract to mainnet, issue ZHOU on BSV mainnet, and open swaps with real inventory, subject to the audit and the operator's regulatory posture.
• Block-reward emission engine — the Bitcoin-model emitter of §5.2: 50 ZHOU per block to the block's miner, halving every 210,000 blocks, hard-capped at 21,000,000. Implemented and unit-tested (internal/emission); activated per-operator and the default monetary policy at mainnet, replacing the testnet's bootstrap issuance.
• Multi-node network — operator discovery, quote aggregation across nodes, and distribution of the block reward across operators.
• More pairs — every additional pair routed through USDC compounds the buy-and-burn pressure on ZHOU.