ForgeOverlay Whitepaper — Sovereign UTXO Indexing for the People

> Why This Is Public

Every other blockchain project hides their indexer behind a proprietary wall. Infura. Alchemy. QuickNode. The chain is public but the access is private. Decentralized storage, centralized retrieval. Open ledger, closed door.

We're publishing our indexer architecture, our API, our self-healing logic, and our monetization model because we believe honesty is a competitive advantage. If you can run your own node, you should. If your node serves the network, you should get paid. If we hide the stack, we're no different from the Archons we're replacing.

The code is the product. The transparency is the brand. The network is the moat.

> 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. 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. The foundation that makes sovereignty real, not theoretical.

> 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. No guarantee.
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. 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 4: Applications (ForgeView, ForgePay, ForgeSocial...)

Layer 3: ForgeOverlay (Sovereign UTXO Indexer)

Layer 2: BSV Chain (Immutable Ledger)

Layer 1: Forgechain OS (Linux Base)

Pure JavaScript TX Parser

Zero SDK dependency for transaction parsing. No native module compilation.
Parses raw TX bytes: version, inputs (prevTxid, prevVout, scriptSig), outputs (satoshis, scriptPubKey)
Handles: VarInt encoding, P2PKH script extraction, Base58Check address derivation
Runs anywhere Node.js runs. ARM, x86, WSL2, bare metal. No build step.

SQLite UTXO Database

utxo_index: tx_hash | tx_pos | value | address | script_hex | spent | spent_by | block_height
raw_txs:    txid | raw_hex | created_at

WAL mode: Concurrent read/write without locks
Atomic transactions: Knex.js transaction wrapping. No partial state ever.
~1KB per indexed TX. 10,000 transactions = 10MB. Fits on any device.

Self-Ingest Pipeline

Every TX your node broadcasts is immediately ingested into your local index. No round-trip to external API. No waiting for confirmation. Spend tracking marks previous UTXOs as consumed. Change output becomes the next available UTXO.

After one initial UTXO fetch, all subsequent TXs chain locally forever.

Self-Healing (v1.2.0)

Endpoint	Method	Function
`POST /reindex`	Local	Re-scan all stored TXs, re-apply spend tracking
`POST /verify/:address`	Network	Cross-check vs WoC, mark stale UTXOs, fetch missing data

Combined: the overlay self-corrects from out-of-order ingestion, missing TXs from sibling nodes, and API inconsistencies. Proven March 13, 2026: 3 stale UTXOs detected and fixed in one call.

Full API

Endpoint	Method	Function
`/status`	GET	Node health, version, UTXO stats
`/utxos/:address`	GET	Unspent outputs for address
`/utxos/:address/stats`	GET	Total/unspent/balance summary
`/tx/:txid/hex`	GET	Raw TX hex by txid
`/ingest`	POST	Ingest a single raw TX
`/ingest/bulk`	POST	Bulk ingest for bootstrapping
`/reindex`	POST	Local self-healing scan
`/verify/:address`	POST	Network-backed verification

> 3. The Sovereignty Model

One Fetch, Infinite Writes

Fetch current UTXOs from any source (WoC, peer overlay, cache)
Build transaction spending that UTXO
Broadcast to miners (TAAL ARC, GorillaPool, or direct)
Self-ingest TX into local index
Change output becomes next available UTXO
Repeat forever. External dependency: one call. Ever.

Fallback Hierarchy

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

Battle-Tested: March 12, 2026

All three BSV API providers degraded simultaneously. TAAL silently auth-gated. GorillaPool returned wrong data format. WoC threw 500s.

We rewrote the bridge. Fixed 5 bugs. Saved 9 files to chain through hostile conditions. Built the overlay so it would never happen again.

13 chain saves. Zero external dependency after initial fetch. Sovereignty proven.

> 4. Monetization: Nodes That Pay for Themselves

ForgeClan Integration

Every ForgeClan member running a Forgechain OS node runs an overlay. This creates a distributed network of sovereign indexers where every node is both consumer and provider.

Tier	Overlay Role	Revenue Share
Initiate (Free)	Consumer only	None
Brother ($5/mo)	Personal overlay + public queries	Query micropayments
Elder ($25/mo)	Public overlay node	Query fees + 35% dividend pool
Founding Father ($100/mo)	Priority routing + bulk indexing	Query fees + 40% dividend pool

Query Micropayments

Non-node users can query any public overlay node for a BSV micropayment:

UTXO lookup: 1 sat (~$0.00001)
TX hex retrieval: 1 sat
Bulk ingest: 10 sats
Verify/reindex: 50 sats

Fractions of a cent per query. But it compounds across the network. Every query is a transaction. Every transaction is revenue. Every revenue event feeds the ForgeClan dividend pool.

The Downline

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

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

vs. The Competition

Feature	Infura	Alchemy	QuickNode	ForgeOverlay
Free tier	100K req/day	300M CU/mo	Limited	Unlimited (your node)
Paid tier	$50-1000/mo	$49-499/mo	$9-299/mo	$0 (self-hosted)
Data ownership	Theirs	Theirs	Theirs	Yours
Revenue share	0%	0%	0%	Up to 40%
Censorship	Platform ToS	Platform ToS	Platform ToS	Impossible
Self-hosting	No	No	No	Yes

> 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)
Default Port: 8270
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). Battle-tested in production.

Phase 2: Peer Sync

Q2 2026

LAN peer discovery. Overlay-to-overlay sync. Sibling node UTXO sharing. ForgeRelay integration.

Phase 3: Public Network

Q3 2026

WireGuard mesh. Query micropayments. ForgeClan tier-based routing. ForgePay integration.

Phase 4: Protocol Standard

Q4 2026

Open specification. Reference implementation. Third-party certification. ForgeView network 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, pure JavaScript TX parser, and sovereign UTXO indexing model are original works first implemented March 12, 2026.

Chain TX: 2aea2c7a...5496

Wallet: 14LQvsvmTzztAPAQRnZ5Aq6nctAnVd9fMu

FORGEOVERLAY