ForgeOverlay Whitepaper — Sovereign UTXO Indexing for the People

Version: 1.0
Author: Jack Mosel / Forgechain OS
Date: March 13, 2026
Product #16 in the Forge Ecosystem

Abstract

Every Bitcoin application depends on someone else's index. You write to the chain, but you read through their API. They can throttle it. Gate it. Monetize it. Kill it.

On March 12, 2026, all three BSV infrastructure providers degraded UTXO access simultaneously. TAAL silently auth-gated. GorillaPool returned wrong data formats. WhatsOnChain threw intermittent 500s. The one endpoint needed to WRITE to chain.

ForgeOverlay was born from that moment. A sovereign UTXO indexer that runs on your hardware, tracks your transactions in your database, and self-heals when data is missing. Layer 3 of the Forgechain OS 7-layer stack. The layer between the chain and everything above it.

We're making it public because honesty is the product. Every other blockchain project hides their indexer behind a proprietary wall. We open ours because we want you to run your own.

1. The Problem

1.1 The API Dependency Trap

Every BSV application today depends on third-party APIs for one critical function: knowing which UTXOs are available to spend.

• WhatsOnChain: Free tier, intermittent 500s under load. No SLA.
• TAAL ARC: Silently introduced authentication requirements. Your existing code breaks without warning.
• GorillaPool: Returns transaction_id instead of tx_hash. Different format. Your parser breaks.

None of these providers are obligated to keep your application running. You are a tenant on their infrastructure.

1.2 The Indexer Monopoly

Running a full BSV node indexes the entire blockchain. That's hundreds of gigabytes you don't need. You need YOUR transactions. Your UTXOs. Your address.

Existing solutions force a choice: depend on someone else's API, or index everything. ForgeOverlay is the third option: index only what matters to you, on your own hardware.

1.3 The Monetization Wall

BSV infrastructure providers see adoption coming. They're positioning for fee-for-service on a chain with minimal traffic. What's free today will cost tomorrow. We got in under the wire. You can too.

2. Architecture

Layer Structure

Layer 4: Applications (ForgeView, ForgePay, ForgeSocial, etc.)
Layer 3: ForgeOverlay (Sovereign UTXO Indexer) ← YOU ARE HERE
Layer 2: BSV Chain (Immutable Ledger)
Layer 1: Forgechain OS (Linux Base)

Components

Pure JavaScript TX Parser
- No BSV SDK dependency for transaction parsing
- Parses raw TX bytes: version, inputs, outputs, scripts
- Handles VarInt encoding, P2PKH script extraction
- Zero native module compilation. Runs anywhere Node.js runs.

SQLite UTXO Database
- WAL mode for concurrent read/write
- Two tables: utxo_index (outputs with spend tracking) + raw_txs (raw hex storage)
- Atomic knex transactions. No partial state.
- Columns: tx_hash, tx_pos, value, address, script_hex, spent, spent_by, block_height

Self-Ingest Pipeline
- Every TX your node broadcasts is immediately ingested into your local index
- No round-trip to external API to confirm your own transaction
- Spend tracking: when a TX is ingested, its inputs mark previous UTXOs as spent
- Result: after one initial UTXO fetch, all subsequent TXs chain locally forever

Self-Healing (v1.2.0)
- POST /reindex: Re-scans all stored raw TXs and re-applies spend tracking. Pure local operation.
- POST /verify/:address: Cross-checks unspent UTXOs against WoC. Marks stale entries. Fetches missing data. Runs reindex after.
- Combined: the overlay self-corrects from out-of-order ingestion, missing TXs from sibling nodes, and API inconsistencies.

API Endpoints

3. Sovereignty Model

One Fetch, Infinite Writes

After a single initial UTXO fetch from any source (WoC, overlay peer, or cached), your node can:

1. Build a transaction spending that UTXO
2. Broadcast to miners (TAAL ARC, GorillaPool, or direct)
3. Self-ingest the TX into local index
4. The change output becomes the next available UTXO
5. Repeat forever

External API dependency: one call. Ever. After that, you are sovereign.

Fallback Hierarchy

Primary:   Local Overlay (your machine)
Fallback:  Peer Overlay (sibling node on LAN)
Fallback:  WoC API (last resort)
Emergency: UTXO cache file (survives restarts)

Proven in Battle

March 12, 2026: 13 chain saves completed through simultaneous degradation of all three BSV API providers. Five bugs found and fixed in the bridge. Sovereign UTXO chaining proved. The overlay went from concept to battle-tested in one session.

4. Monetization

For ForgeClan Members

Every ForgeClan member running a Forgechain OS node runs an overlay. This creates a distributed network of sovereign indexers.

Query Micropayments

Non-node users can query any public overlay node for a BSV micropayment:
- UTXO lookup: 1 sat
- TX hex retrieval: 1 sat
- Bulk ingest: 10 sats
- Verify/reindex: 50 sats

At BSV's current fee structure, this is fractions of a cent. But it compounds across the network. Every query is a transaction. Every transaction is revenue. Every revenue event feeds the ForgeClan dividend pool.

Downline Economics

User joins ForgeClan as Brother ($5/mo)
  → Runs overlay node
  → Serves queries to network
  → Earns micropayments per query
  → Micropayments exceed $5/mo at ~5,000 queries/month
  → Node pays for itself
  → Surplus flows to dividend pool
  → Dividends distributed to Elders + Founding Fathers

The overlay is not a cost center. It's a revenue engine. Every node makes the network faster AND generates income.

Competitive Analysis

5. Technical Specifications

• Runtime: Node.js 20+
• Database: SQLite 3 (better-sqlite3) with WAL mode
• ORM: Knex.js
• Framework: Express
• TX Parser: Pure JavaScript (zero native dependencies)
• Port: 8270 (configurable)
• Memory: ~50MB baseline
• Disk: ~1KB per indexed TX
• Startup: <5 seconds
• Self-healing: Automatic on ingest, manual via /reindex and /verify

6. Roadmap

Phase 1: Single-Node Indexer (COMPLETE)

• Personal UTXO tracking
• Self-ingest pipeline
• Self-healing (reindex + verify)
• Proven in production

Phase 2: Peer Sync (Q2 2026)

• LAN peer discovery
• Overlay-to-overlay sync
• Sibling node UTXO sharing
• ForgeRelay integration for cross-node coordination

Phase 3: Public Network (Q3 2026)

• WireGuard mesh overlay
• Query micropayment protocol
• ForgeClan tier-based routing
• ForgePay integration for cross-chain settlement

Phase 4: Protocol Standard (Q4 2026)

• Open specification
• Reference implementation
• Third-party node certification
• ForgeView network topology visualization

The Gnostic Layer

Infura is the Archon of Ethereum. Alchemy is the Archon of multichain. Every blockchain "infrastructure provider" is a middleman between you and the truth that's already on the chain.

The chain is public. The data is yours. But you can't READ it without going through them. That's the trap. Open ledger, closed access. Decentralized storage, centralized retrieval.

ForgeOverlay breaks the pattern. You index your own data. You query your own database. You serve your own network. The Archon is removed. The path from you to the chain is direct.

This is not infrastructure. This is liberation.

IP Declaration

This whitepaper is the intellectual property of Jack Mosel and Forgechain OS. Saved to BSV blockchain before publication.

The ForgeOverlay protocol, self-healing architecture, and sovereign UTXO indexing model are original works first implemented March 12, 2026.

Chain TX: 2aea2c7ab89f3124d6f74686d079ff820640fcda908733cec5d76c64b75a5496
Wallet: 14LQvsvmTzztAPAQRnZ5Aq6nctAnVd9fMu