Bitcoin Attestation NetworkTM

1. Abstract

2. Introduction

Bitcoin created sound money for the internet. Its UTXO model, proof-of-work consensus, and 21-million-unit hard cap represent the most successful monetary innovation in a generation. But Bitcoin's architecture was designed in 2008. Its cryptographic primitives - SHA-256d hashing and ECDSA signatures on secp256k1 - are vulnerable to cryptographically relevant quantum computers that NIST timelines predict will arrive in the 2030s. Bitcoin's scripting system was deliberately limited, its finality is probabilistic (requiring ~60 minutes for settlement confidence), and it supports only a single asset type.

The Bitcoin Attestation NetworkTM is not a sidechain, a rollup, a layer 2, or a fork of Bitcoin. It is a standalone Layer 1 blockchain that preserves Bitcoin's philosophy while upgrading every cryptographic primitive for the post-quantum era. BAN answers a specific question: What would Bitcoin look like if Satoshi had access to post-quantum cryptography, deterministic finality, multi-asset UTXO lanes, and decentralized AI - while still anchoring everything to Bitcoin's root of trust?

What Changes from Bitcoin

Bitcoin	Bitcoin Attestation Network
SHA-256d hashing	Memory-hard Proof of Knowledge with SHA3-512 finalization
ECDSA / Schnorr signatures	ML-DSA-65 (NIST FIPS 204) post-quantum signatures
Plaintext P2P transport	Post-quantum-secured transport with encrypted mesh options
Probabilistic finality (~60 min)	Deterministic finality (~90 sec) via open attestor quorum
Single asset (BTC)	Five consensus-level UTXO lanes with parallel validation

BAN does not compete with Bitcoin. It extends it. Every BAN node runs a real Bitcoin node locally. The three-tier architecture creates a symbiotic relationship where both networks strengthen each other. As Bitcoin's network grows, BAN's anchor gets stronger. As BAN's network grows, more Bitcoin gets locked in Taproot vaults, increasing pBTC liquidity. The two networks reinforce each other.

3. Design Principles

The Bitcoin Attestation NetworkTM is built on the same principles that make Bitcoin what it is: fully decentralized, completely non-custodial, permissionless, and open. There is no company holding your keys. There is no foundation controlling the protocol. There is no token pre-mine enriching insiders. You run your own node, you hold your own keys, you verify your own blocks.

• Non-custodial - You hold your own private keys. No third party can access, freeze, or seize your funds. Your BTC seed and PQ mnemonic are yours alone.
• Permissionless - Anyone can run a node, mine, validate, or transact. No KYC, no application, no approval required. Download the software and participate.
• No pre-mine, same 21 million cap - qBTCTM is pegged sat-to-sat with Bitcoin. Fee epochs sync every 144 blocks to maintain 1:1 fee parity within an 80-120% band. Same monetary policy: 50 qBTC initial block reward, halving every 210,000 blocks, hard cap at 21 million. These rules are consensus-pinned and cannot be changed.
• Auditable architecture - The protocol design, consensus rules, and published components are documented for review, while specific code and firmware are made available under their own applicable terms.
• Run your own node - From a Wallet preset on a laptop (40 GB) to a Full Node on a workstation (2 TB), every user can verify the chain independently. No trust required.
• No trusted third parties - Anyone can become an attestor by running a node and mining. There is no application process, no foundation approval, and no fixed attestor set. Attestors rotate naturally based on proof-of-work participation.
• Self-sovereign identity - Your node ID is derived from your own PQ public key. Your @toshi.btc identity is yours permanently. Recoverable from your mnemonic on any machine, controlled by no one else.

4. Architecture

BAN operates a three-tier architecture. All three tiers run simultaneously on every node - this is not a choice, it is the full stack:

Tier 1: Bitcoin Anchor Layer

A real Bitcoin node (Bitcoin Knots or Bitcoin Core - operator's choice) validates Bitcoin mainnet blocks locally. This provides the root of trust, SPV proofs for pBTC vault verification, and rowstore snapshots that cryptographically link BAN's chain state to Bitcoin's.

Tier 2: ProofnetTM Consensus Engine

The consensus engine validates Memory BlocksTM, runs the five UTXO lanes, manages the attestation system, coordinates ElliottTM AI indexing, and handles governance.

Tier 3: Service Gateway

The unified entry point for all services. The gateway proxies every client connection - the ToshiTM Wallet, browser extension, mobile app, and external integrations - through a single layer with PQTLSTM encryption, rate limiting, and authentication.

System Overview

Component	Language	Role
Bitcoin Node	C++	Full Bitcoin node - validates mainnet blocks
Consensus Engine	Rust	Attestation, lanes, finality, AI coordination
Service Gateway	Rust	Unified client gateway with PQTLS

The client layer encompasses the ToshiTM Desktop wallet, Toshi Mobile, the browser extension, and third-party integrations. All connect through the gateway over standard or post-quantum-secured transport.

5. Consensus: Proof of KnowledgeTM

BAN's consensus mechanism combines memory-hard proof of work with deterministic attestor finality. The proof-of-work algorithm, Proof of Knowledge, is specifically designed to resist both ASIC monopolization and quantum speedup.

Memory-Hard Proof of Work

Every hash requires filling and revisiting a memory buffer through sequential, data-dependent mixing before a final SHA3-512 digest is produced. The design is intended to reduce structural advantages from highly specialized hardware and preserve broad participation on consumer machines.

Parameter	Bitcoin	Bitcoin Attestation Network
PoW Algorithm	SHA-256d	Memory-hard Proof of Knowledge with SHA3-512
Block Time	~10 minutes	30-second settlement blocks
Difficulty Adjustment	Retarget every 2,016 blocks (~2 weeks)	Continuous responsive adjustment
Finality Model	Probabilistic (6 confirmations, ~60 min)	Deterministic (2/3+1 attestor quorum, ~90 sec)
Block Packaging	SegWit weight accounting	Bounded Memory Blocks
Reorg Protection	Longest chain rule	Finality checkpoint (no reorg below)

Memory Block Lifecycle

Every Memory BlockTM (MBLK) passes through a six-step pipeline from creation to finality:

1. AttestoTM Creation - A user or attestor creates a typed attestation, which is canonically serialized, content-addressed, and signed with ML-DSA-65.
2. Mempool Validation - Schema validation per attesto type, fee gate enforcement (consensus-pinned sat amounts), and PQ signature verification.
3. Block Construction - Attestos are selected, merklized, and assembled into a Memory Block with the required state commitments.
4. Proof of Work - The miner runs Proof of Knowledge against the block header under the network difficulty schedule.
5. Lane Application - The validated MBLK is applied across the relevant lanes so UTXOs, vault state, and synthetic state advance independently.
6. Finality Checkpoint - A quorum of 2/3+1 active attestors signs the block with ML-DSA-65. Once signed, the block becomes mathematically irreversible. No reorg is possible below the checkpoint height.

Each Memory Block is stored in a self-contained, queryable format that preserves block data, attestations, and finality proofs for replay, audit, and recovery.

6. Post-Quantum Cryptography

Every cryptographic primitive in the Bitcoin Attestation NetworkTM is selected from NIST's post-quantum standards. This is not a migration path - it is the foundation. When quantum computers break ECDSA, Bitcoin addresses with exposed public keys become vulnerable. BAN is designed so that day never matters.

Function	Bitcoin	BAN	NIST Standard
Digital Signatures	ECDSA / Schnorr (secp256k1)	ML-DSA-65	FIPS 204
Primary Hash	SHA-256d (double SHA-256)	SHA3-512	FIPS 202
Key Exchange	Classical Diffie-Hellman	Kyber-768	FIPS 203
Transport Security	Plaintext P2P	PQTLSTM (TLS 1.3 + ML-DSA-65)	X.509 with PQ cert binding
Merkle Trees	SHA-256d (256-bit roots)	SHA3-512 (512-bit roots)	FIPS 202
Identity	RIPEMD-160(SHA-256(pubkey))	SHA3-256(ML-DSA-65 pubkey)	FIPS 202

Signature Sizes

ML-DSA-65 signatures are larger than ECDSA: 1,952-byte public keys and 3,309-byte signatures compared to Bitcoin's 33-byte compressed public keys and 72-byte signatures. This is the necessary cost of quantum resistance. The UTXO lane system and 1.5 MB block size are calibrated for this overhead.

Quantum Security Margin

SHA3-512 provides a 256-bit quantum security margin versus SHA-256d's 128-bit margin under Grover's algorithm. ML-DSA-65 is resistant to both classical and quantum attacks, including Shor's algorithm which would break ECDSA and Schnorr signatures. Kyber-768 provides quantum-safe key exchange for encrypted mesh tunnels.

PQTLSTM X402 Browser Trust Loop

BAN closes the trust chain from browser to consensus without any certificate authority. The node's ML-DSA-65 identity IS the TLS certificate. The browser extension verifies the PQTLSTM certificate against the node's known PQ identity. Every API call is quantum-secure and self-authenticated - no DNS, no corporate CA, no trust assumptions beyond the node's own cryptographic identity.

Dual Seed Architecture

Users hold two separate recovery phrases that serve different purposes:

Seed	Standard	Words	What It Recovers	Anchored To
BTC Seed	BIP39	12 or 24	Bitcoin addresses, UTXOs, transaction history	Bitcoin (ECDSA, secp256k1)
PQ Mnemonic	Proofnet PQ Recovery v1	24 or 48	Node identity, @toshi.btc identity, vault access, attestor registration	Bitcoin genesis via root_pqhash (ML-DSA-65)

The PQ wallet seed derivation includes the root_pqhash - derived from Bitcoin's genesis block - which means every BAN identity is cryptographically tied back to January 3, 2009. Two seeds, one user, one trust chain back to Satoshi's genesis block.

7. UTXO Lane System

BAN uses the same UTXO (Unspent Transaction Output) model as Bitcoin. This is a deliberate architectural choice. In the UTXO model, there are no accounts and no balances. Every unit of value exists as a discrete, unspent output from a previous transaction. Each UTXO can only be spent once - enforced by consensus, not by a database update.

BAN extends Bitcoin's UTXO model with lane separation - each asset type has its own independent UTXO ledger stored in a separate SQLite database. Lanes cannot interfere with each other at the consensus level.

Lane	Purpose	Key Properties
qBTCTM	Native BAN currency, mined via SHA3-512 PoW	Bitcoin's exact monetary policy: 50 qBTC initial reward, halving every 210,000 blocks, 21M hard cap
pBTC	Physical Bitcoin, 1:1 peg via Taproot vault locks	Each pBTC UTXO backed by a real Bitcoin UTXO locked in a P2TR vault with SPV proof
aBTC (aSATS)	Application-layer accounting unit	Epoch-based minting via consensus, pool integration, batch send support
tBTC	Testnet Bitcoin	Development and testing lane with faucet endpoint
Synthetics	Multi-asset token lane	Per-asset UTXO sets (seth, ssol, satom, sapt, ssui), namespace creation, minting, burning

Why UTXOs Over Accounts

• No global state attacks - Ethereum's account model requires a single global state trie that every transaction mutates. UTXOs are independent.
• Parallel validation - UTXOs that don't share inputs can be validated in parallel. Account-based systems must serialize transactions touching the same account.
• Privacy by default - Each UTXO is a separate object. There is no public "account balance" to query.
• Atomic transactions - A UTXO transaction either fully succeeds or fully fails. No partial execution, no reentrancy attacks, no approval exploits.
• Deterministic replay - The entire chain state can be reconstructed by replaying UTXO creation and consumption.

With five lanes processing independently in parallel, qBTC validation never blocks pBTC or synthetics. A surge in synthetic token activity has zero impact on Bitcoin payment settlement times. This parallelism is how BAN achieves throughput without the hardware centralization that plagues high-TPS chains.

8. User-Chosen Finality

No other blockchain lets users and merchants choose their own finality level per transaction. Bitcoin forces 60 minutes. Ethereum forces 15 minutes. Solana forces 13 seconds (when it is not down). BAN provides three speed tiers on the same chain, same security model:

Speed	Confirmations	Time	Finality Type	Use Case
Fast	0 (preconfirm)	Milliseconds	PQ-signed attestor commitment	Retail, point-of-sale, coffee
Medium	3 blocks	~90 seconds	Deterministic (2/3+1 quorum checkpoint)	Online purchases, transfers
Slow	6+ blocks	~5+ minutes	Multiple stacked finality checkpoints	Real estate, vaults, high-value

How the Fast Layer Works

The UTXO preconfirmation layer operates outside the block production cycle. When a user sends a transaction with fast speed:

1. The signed attestoTM hits the mesh inbox (milliseconds, QUIC transport).
2. Active attestors see it and immediately sign a utxo_preconfirm_sig - an ML-DSA-65 cryptographic commitment that the UTXO is valid and will be included.
3. The merchant receives the preconfirm signature - a cryptographic proof, not a promise.
4. Settlement happens in the next Memory Block (30 seconds) and reaches finality at 90 seconds.

This is the scaling breakthrough: speed and settlement are decoupled. Fast preconfirms do not create larger blocks. Slow settlement does not delay retail transactions. A merchant accepting a coffee payment and an exchange settling a vault operation use the same chain, same attestors, same security model - but each gets the finality speed appropriate for their use case.

Comparison to Other Networks

Network	Block Time	Finality	Model	Hardware Requirement
Bitcoin	~10 min	~60 min	Probabilistic (longest chain)	Consumer hardware
Ethereum	~12 sec	~15 min	Probabilistic + Casper	32 ETH + server
Solana	~0.4 sec	~13 sec	Probabilistic (when running)	Datacenter (128 GB RAM, 24-core)
BAN	Fast: ms / Med: 90s / Slow: 5min	User chooses per tx	Deterministic (PQ-signed)	Consumer hardware (40 GB)

Other chains achieve speed by requiring datacenter-grade hardware or accepting tradeoffs in decentralization and uptime. BAN achieves fast confirmation through cryptographic finality on consumer hardware. Speed comes from math, not from hardware centralization.

9. Bitcoin Integration

BAN does not compete with Bitcoin - it extends it. Every BAN node runs a real Bitcoin node locally (Bitcoin Knots or Bitcoin Core - operator's choice). The integration is structural, not superficial:

Feature	Implementation
Root of Trust	Network identity derives from a Bitcoin-anchored root hash tied to Bitcoin's genesis
Rowstore	Verified Bitcoin state snapshots aligned to BAN history
SPV Proofs	Merkle paths prove Bitcoin transaction inclusion for pBTC vault locks
Taproot Vaults	BIP-341 P2TR commitments on Bitcoin mainnet for pBTC deposits
Anchor Shares	Miners contribute hashrate to both networks simultaneously
Fee Parity	Periodic fee alignment designed to keep BAN activity legible to Bitcoin users

Chain of Trust

Every identity, key, and block in the Bitcoin Attestation NetworkTM traces back to a single root: Bitcoin's mainnet genesis block from January 3, 2009. From that anchor, node identities, wallet keys, and network parameters inherit a shared chain of trust fixed at genesis.

pBTC: The Planned Bitcoin Vault Lane

pBTC is designed as a 1:1 Bitcoin vault lane via Taproot locks on Bitcoin mainnet. In the intended design, each pBTC UTXO is backed by a real Bitcoin UTXO locked in a BIP-341 P2TR vault with SPV proof verification against the local Bitcoin node. Public deposits and withdrawals are not currently enabled. If activated later, two-phase withdrawal (request + settlement) is intended to improve operational safety.

10. AI Architecture

BAN's most significant architectural innovation is the integration of AI directly into the blockchain data pipeline. Memory BlocksTM are not just consensus containers - they are canonical source material for local AI knowledge and training. Every ai_knowledge attesto committed to the chain becomes part of every node's knowledge base, and finalized chain data can be distilled into supervised datasets for local models.

ElliottTM AI

ElliottTM is a local AI agent that runs on your hardware by default. In the current implementation, finalized attestos and Memory Blocks are distilled into supervised datasets, optionally combined with local-only knowledge, fine-tuned as LoRA adapters on a local base model, and exported as GGUF for local runtime. Synthetic RAMTM handles grounding at inference time. External providers are optional, not required.

Synthetic RAMTM

Synthetic RAMTM is a local knowledge index that makes finalized Memory BlockTM content queryable by the AI with predictable latency. It extends the node's effective memory by organizing verified chain data into fast-access references with trust scores derived from consensus depth.

• Trust scoring - Finalized knowledge is ranked above local-only or disputed material, giving the AI a clear ordering of evidence.
• Chat-time isolation - At inference time, Elliott reads from the local index rather than replaying chain files live, improving predictability and failure isolation.
• Rebuildable - The entire index can be reconstructed by replaying finalized Memory Blocks. If destroyed, it regenerates from the chain.

The Closed-Loop Feedback System

This is where BAN diverges from every other blockchain. The pipeline forms a closed loop:

1. Work happens - AI actions, transactions, code builds, training runs produce attestosTM.
2. Attestos enter Memory Blocks - PQ-signed, fee-gated, Merkle-rooted, consensus-finalized.
3. Synthetic RAMTM indexes them - Background daemon reads finalized MBLKs, verifies PQ signatures, builds local knowledge index.
4. ElliottTM reasons over them - Local inference on GGUF models, grounded in verified chain knowledge.
5. Elliott contributes back - New knowledge attestosTM, dataset-build receipts, training receipts, and model improvements. The loop continues.

The finalized chain anchors the AI pipeline rather than replacing it. Memory BlocksTM and attestos provide canonical source material, local indexes make that material queryable, and supervised datasets turn it into trainable model inputs with provenance.

Fail-Soft Integration

The most important architectural decision: ElliottTM AI is never consensus-critical. If AI processing fails, blocks still validate. If the knowledge pipeline crashes, the chain continues. If LoRA training produces garbage, consensus is unaffected. The AI grows organically on top of a chain whose financial security is independent of AI correctness. Bitcoin's 16-year uptime with zero consensus failures comes from simplicity. BAN preserves that principle for the consensus layer while adding AI as a fail-soft overlay.

Federated Learning

Each node can extend Elliott with local and finalized chain-derived data. Raw data never leaves the machine. Instead, nodes can share LoRA adapters and signed model artifacts without exposing the underlying dataset. Every model artifact is content-addressed by SHA3-512 hash. The current pipeline builds supervised datasets from finalized attestos and Memory Blocks, fine-tunes a local LoRA, and exports GGUF for local inference. Dataset build, training run, model export, and model binding provenance are recorded on-chain as PQ-signed attestosTM.

Comparison to Other Approaches

Approach	Knowledge Source	Training Data Trust	User Owns Data	User Outcome
Centralized AI (cloud)	Corporate web scrapes	Opaque, unverifiable	No	No (you pay them)
Blockchain + AI (Bittensor, etc.)	Off-chain APIs, oracles	Oracle-dependent	Partially	Token speculation only
BAN (ElliottTM)	Finalized Memory BlockTM attestos plus derived local indexes and datasets	PQ-signed, on-chain, verifiable	Yes (local inference)	Verified-work receipts that may qualify for qBTC when enabled

11. AttestoScriptTM

AttestoScriptTM is BAN's answer to smart contracts - without the smart contract attack surface. It is a deterministic JSON program that compiles into an execution plan using existing ProofnetTM lane operations. There is no virtual machine, no gas metering, no reentrancy risk, and no arbitrary bytecode execution.

Property	Ethereum Smart Contracts	AttestoScriptTM
Language	Solidity (Turing-complete)	JSON (bounded, deterministic)
Execution	On-chain EVM bytecode	Local ProofWallet plan execution
Gas	Metered per opcode	Fixed fee per attesto type
Reentrancy	Major attack vector	Impossible (no callbacks)
State	Global mutable state trie	Immutable UTXOs per lane
Audit	Requires bytecode analysis	JSON readable by anyone
Max Complexity	Unbounded	Bounded execution
Quantum Security	None	ML-DSA-65 signed receipts

Operations

AttestoScriptTM groups bounded operations into a small number of auditable categories: payments, credentials, time locks and escrow, planned pBTC workflows, synthetic-asset handling, AI receipts, and governance. The public point is not the opcode list. The point is that every allowed action is deterministic, reviewable, and constrained by the same attestation model as the rest of the network.

EVM Intent Translation

AttestoScriptTM can translate common EVM transaction intents into BAN operations without running an EVM. The system analyzes the requested action, rejects unsafe or unbounded patterns, and records an attested execution receipt linking the original intent to the BAN result.

12. Universal Chain Bridge (BAX)

BAX is the Bitcoin Attestation Network's chain-agnostic interoperability layer. Rather than requiring other blockchains to adopt BAN's protocol, BAX is designed to meet each chain on its own terms through dedicated vault programs deployed natively on each target network as routes are enabled.

Architecture

BAX operates through three components: vault programs, chain watchers, and the Toshi Wallet Extension.

Vault programs are the source-chain holding layer. If and when a route is enabled, deposits can be verified against source-chain finality and represented on BAN as a synthetic asset. Withdrawals reverse that process under the route's applicable policy and settlement rules.

Chain watchers monitor enabled routes and feed source-chain evidence into BAN's attestation flow. They are designed to stay lightweight so the interoperability layer does not require separate institutional infrastructure.

The Toshi Wallet Extension gives users a familiar wallet surface for compatible applications while BAX interprets transaction intent, translates it through AttestoScriptTM, and settles it as an attestation in a Memory BlockTM.

Planned Supported Chains

Planned interoperability targets include major contract ecosystems and payment rails such as EVM chains, Solana, Cosmos, Aptos, Sui, Cardano, XRPL, Lightning, and Dogecoin, subject to legal, technical, and operational readiness.

Post-Quantum From the BAN Boundary

When an asset crosses an enabled route into BAN, it is re-signed under BAN's post-quantum security stack: ML-DSA-65 signatures, SHA3-512 Merkle inclusion, and Kyber-768 encrypted transport. Classical chains remain classical on their side of the bridge. Within BAN, bridged assets follow BAN's security model.

Atomic Cross-Chain Swaps

BAX enables trustless atomic swaps between any two supported chains using Hash Time-Locked Contracts (HTLCs). A user on Ethereum and a user on Solana can swap assets directly, with BAN serving as the settlement layer. Both sides of the swap are recorded as attestations in the same Memory BlockTM, providing cryptographic proof of atomicity. If either side fails to complete within the time lock, both transactions revert. No centralized exchange. No liquidity pool slippage. No custodial risk.

EVM Safety Analysis

BAX rejects unsafe EVM patterns before they execute. Only deterministic, bounded transaction shapes translate to AttestoScriptTM, which is how BAN aims to support interoperability without inheriting the full EVM attack surface.

13. AttestosTM vs Tokens

Most blockchain projects issue tokens. BAN issues attestations. The distinction is fundamental.

A token is a unit of speculative value. Its price fluctuates based on market sentiment. It may or may not represent anything real. A token pre-mine enriches insiders. Token distribution is often opaque.

An attestoTM is a signed, timestamped, quantum-sealed attestation of fact. It is not speculative. It is not an NFT. It is immutable proof that something happened, someone said it, and the chain confirmed it. AttestosTM serve as the universal primitive for every operation on BAN:

Attesto Type	Purpose	Fee Gate
qbtc_tx	Synthetic Bitcoin transfer (inputs/outputs/fee)	Standard
pbtc_tx	Physical Bitcoin vault lock/unlock with SPV proof	1,000 + 200/KB sats
block_finality	ML-DSA-65 attestor finality signature	None
ai_knowledge	Verified knowledge contribution to Synthetic RAMTM	5,000 + 1,000/KB sats
code_build	AI build action with before/after file hashes	Varies
fee_epoch_update	BTC-anchored fee parity adjustment	None
attestor_work_share	Attestor participation proof	None

Every attestoTM is canonically serialized (sorted keys, no floats, UTF-8), content-addressed by SHA3-512 digest, and signed with ML-DSA-65. Domain separation (PROOFNETBTC|attesto|v1|{type}|) prevents cross-protocol signature reuse. The same Merkle tree that proves transaction inclusion proves knowledge provenance for AI training. AttestosTM are the single primitive that unifies financial transactions, identity claims, AI knowledge, governance votes, and infrastructure proofs into one cryptographically consistent system.

14. Economics

Monetary Policy

qBTCTM is pegged sat-to-sat with Bitcoin. Fee epochs sync every 144 blocks to maintain 1:1 fee parity within an 80-120% band. Same monetary policy. These rules are consensus-pinned at genesis and cannot be changed:

Parameter	Value
Initial Block Reward	50 qBTC
Halving Interval	Every 210,000 blocks
Hard Cap	21,000,000 qBTC
Smallest Unit	1 satoshi (1/100,000,000 qBTC)
Block Time	30 seconds

Six Verified-Work Paths

Unlike Bitcoin where you either mine with industrial ASICs or earn nothing, BAN is designed around six distinct verified-work mechanisms that may be enabled in stages:

Share Type	What You Do	Who Can Do It
Mining Shares	Submit partial PoW proofs (SHA3-512)	Anyone with CPU/GPU/ASIC
Attestor Work Shares	Prove recent PoW work as a lite-node attestor	Any node running Wallet + Verified Work or higher once enabled
Rowstore Shares	Maintain Bitcoin mainnet state snapshots	Pruned Node and Full Node presets
Anchor Shares	Contribute hashrate to Bitcoin mainnet (dual-mining)	Miners with Bitcoin-compatible hardware
AI Cognition Shares	Prove local AI inference work	Any node running ElliottTM AI
Model Build Shares	Prove GGUF model compilation work	Nodes with sufficient compute

Reward Distribution

BAN separates block production from reward distribution. Instead of winner-takes-all, the design distributes shares across verified contributors when those systems are enabled:

• Block sealer receives a fixed floor under the reward policy
• Remaining rewards are distributed pro-rata across verified contributors
• Share difficulty is intended to keep consumer-hardware participation meaningful
• Multiple share classes can contribute to a single block, including mining, attestor, anchor, AI, and rowstore work
• Distribution is deterministic - any node can independently verify the split from the block data

Fee Structure

BAN operates two fee paths. qBTCTM attesto fees for AI knowledge and model releases are explicitly burned - sent to unspendable addresses that permanently remove qBTC from circulation, creating deflationary pressure proportional to knowledge contribution volume. pBTC lane fees route to a network fees wallet for potential attestor distribution. qBTC transaction fees use Bitcoin's implicit model (inputs minus outputs).

All fee parameters are consensus-pinned in the genesis profile. No individual can change them. Modifications require network consensus through the governance process.

Bitcoin Mining Comparison

Property	Bitcoin	Bitcoin Attestation Network
Reward Model	Winner-takes-all (single miner/pool)	Shared - all contributors earn pro-rata
Node Operator Reward	None (volunteers)	Designed to allocate verified-work shares pro-rata when enabled
Minimum Participation	Industrial ASIC hardware and pool access	Wallet + Verified Work preset on a consumer laptop or similar hardware
Pool Centralization	2 pools control >50% hashrate	Permissionless attestor pools with on-chain coordination

15. Wallet-First Strategy

Users do not adopt consensus engines. They adopt wallets. The ToshiTM product family is the entry point - everything else is infrastructure that runs behind it.

The strategy is simple: give people a wallet they want to use. Behind it, the BAN stack starts automatically - a local Bitcoin node validates mainnet blocks, consensus runs, services route through the gateway, the mesh connects, ElliottTM AI indexes, and verified-work services can be enabled as the network rolls out. The user sees a wallet. The network sees a full participant.

Presets

Preset	User Profile	What Happens Behind the Scenes	Disk
Wallet	"I just want self-custody"	Lightest install, lightweight Bitcoin access, no mining	~40 GB
Wallet + Verified Work	"I want to contribute verified work while I hold"	Light-node participation preset with attestor and work-share services available as enabled	~40 GB
Pruned Node	"I want to validate Bitcoin"	Local Bitcoin node, finality signing, rowstore sync	~120 GB
Full Node	"I want maximum participation"	Full Bitcoin chain validation, local indexing, archival storage	~2 TB

Every install creates a network participant. Every Wallet + Verified Work preset can become an attestor as those services are enabled. Every node strengthens the mesh. The user chooses their comfort level - the network benefits regardless.

Why ToshiTM Competes as a Wallet

• multi-chain - Bitcoin, Ethereum, Solana, Cosmos, Aptos, Sui, and 7 EVM networks in one wallet
• 6 hardware wallets - Toshi PQ1TM, Ledger, Trezor, Coldcard, BitBox02, Keystone
• Web3 provider detection - MetaMask, Rabby, Phantom, Keplr, and 9 more auto-detected
• Built-in AI - ElliottTM AI runs locally, learns from the chain, no subscription
• You can contribute verified work - nodes can generate auditable receipts for mining, validation, AI work, and data availability as rollout expands
• You own everything - keys, data, models, identity, @toshi.btc identity

Product Family

Product	Platform	Purpose
ToshiTM Wallet Desktop	macOS, Linux, Windows (Tauri)	Unified wallet + node operator console
ToshiTM Mobile	iOS, Android	Multi-chain mobile wallet with mesh messaging
ToshiTM Browser Extension	Chromium browsers	Web3 provider injection, 5 chain engines
Toshi PQ1TM	Dedicated secure hardware	Post-quantum hardware wallet (ML-DSA-65 on-device)
Blockie TalkieTM Controller	Web	Node operator console

16. Hardware

The Toshi PQ1TM is a post-quantum hardware wallet. It generates and stores ML-DSA-65 keypairs on-device using dedicated secure hardware. The secret key is designed to stay on the device. Every transaction is signed with lattice-based cryptography selected for the post-quantum transition.

Toshi PQ1TM Capabilities

Feature	Detail
Signature Algorithm	ML-DSA-65 (NIST FIPS 204) + ECDSA for Bitcoin compatibility
Key Generation	On-device, PIN-encrypted secure storage
Recovery	Deterministic: same PQ mnemonic produces same keypair, same node ID, same vault access, same @toshi.btc identity
Connection	USB via a dedicated local PQ agent
Additional Functions	Mesh envelope signing, PQ attestation creation, PQTLSTM cert binding

Hardware Wallet Support

BAN supports a broad range of hardware wallets through the Hardware Wallet Interface (HWI v5.0) bridge:

Device	Signing	Post-Quantum Support
Toshi PQ1TM	ML-DSA-65 + ECDSA	Yes (on-device keygen)
Ledger (all models)	ECDSA (BIP84 SegWit)	No
Trezor (all models)	ECDSA (BIP84 SegWit)	No
Coldcard	ECDSA (BIP84 SegWit)	No
BitBox02	ECDSA (BIP84 SegWit)	No
Keystone	ECDSA (BIP84 SegWit)	No

The Toshi PQ1TM creates brand gravity that software alone cannot. A physical device with ML-DSA-65 on-device key generation anchors the ecosystem in the real world. For institutions evaluating quantum risk, this device alone is reason to evaluate the platform. When NIST timelines predict cryptographically relevant quantum computers in the 2030s, the question is not whether to prepare - it is whether to prepare now or scramble later.

AI Hardware Scaling

BAN's AI runs on hardware people already own. No datacenter required:

Hardware	Capability	Use Case
Any CPU (x86/ARM)	7B-13B models	Wallet preset, consumer laptop
Apple M1-M4	13B-70B models via Metal GPU	Standard to heavy node
Apple M4 Ultra (future)	70B-120B+ models, 256+ GB unified memory	Full cloud AI replacement
NVIDIA GPU (RTX 4090+)	30B-70B models via CUDA	Linux/Windows heavy node

17. Network Transport

BAN operates a multi-layered peer-to-peer network with six distinct transport protocols, replacing Bitcoin's single plaintext TCP connection:

Protocol	Purpose	Security
QUIC Gateway	Primary P2P mesh transport	PQTLSTM with ML-DSA-65
Mesh Tunnel	Encrypted node-to-node channel	Kyber-768 pre-shared keys
Autodiscovery	LAN peer discovery via beacon	Signed node identity
Gossip Protocol	Attestation dissemination	Quota-based rate limiting
Blockie TalkieTM	Encrypted P2P communication over mesh	AES-256-GCM (AEAD)
Attesto Bootstrap	PQ attestation-based peer onboarding	ML-DSA-65 signed handshake

Transport Comparison

Property	Bitcoin	Bitcoin Attestation Network
Primary P2P	TCP plaintext networking	QUIC/HTTP3 with PQTLSTM
Mesh Tunnel	None	PQTLS with Kyber-768 PQ pre-shared keys
LAN Discovery	None	UDP broadcast autodiscovery
Gossip	Inventory-based (inv/getdata)	Custom gossip with per-peer rate limits
Chat / Messaging	None	AES-256-GCM encrypted P2P chat
Transport Security	Plaintext (optional Tor)	PQTLSTM on all connections
Mining Protocol	Stratum (TCP)	Mining gateway plus Stratum bridge

All gateway and QUIC connections use post-quantum TLS with ML-DSA-65 certificate binding. Bitcoin's P2P protocol transmits data in plaintext. BAN's PQTLSTM ensures that even network-level adversaries with quantum capabilities cannot intercept or tamper with node communications.

Mesh Architecture

The mesh network supports decentralized development through node-ID authenticated Git over mesh. Every BAN node runs an integrated Gitea instance that is authenticated by the same ML-DSA-65 identity that signs attestosTM and validates blocks, replicated across peer nodes via QUIC/encrypted mesh tunnel, and governed by PQ-signed trust policies. This means the development workflow for BAN itself - and for any project built on BAN - can operate entirely on the mesh network without depending on any centralized platform.

18. Legal, Risk, and Trademark Notices

19. Conclusion

Bitcoin answered a question most people thought was impossible: can strangers coordinate around money without trusting an institution? Yes. Seventeen years. No hack. No reversal. No capture.

But money is not an economy. An economy is receipts and audits, identity and authorization, compliance and dispute resolution, AI systems making decisions at scale. If the layers above Bitcoin remain opaque, then honest money lives inside a dishonest economy.

The Bitcoin Attestation NetworkTM answers the next question: can people coordinate around an entire economy without trusting an institution? The answer requires receipts that persist, history that replays, evidence that no party can revise, and settlement that returns to Bitcoin when the highest integrity is required.

What This System Produces

The Bitcoin Attestation Network preserves every property that makes Bitcoin valuable — proof of work, UTXO model, 21 million hard cap, no pre-mine, permissionless participation, consumer hardware accessibility — while introducing 30+ core system innovations across consensus, cryptography, identity, AI, and programmable attestations.

The key contributions are Memory BlocksTM that simultaneously serve as consensus containers and AI training sources; Proof of KnowledgeTM, a memory-hard proof-of-work algorithm resistant to both ASIC monopolization and quantum speedup; user-chosen finality from milliseconds to minutes on the same chain; full-stack post-quantum cryptography from genesis; Synthetic RAMTM for consensus-derived AI knowledge with cryptographic trust scoring; a closed-loop feedback system where the AI reads from the chain it helps populate; AttestoScriptTM for deterministic contracts without smart contract risk; fail-soft AI integration that keeps AI out of consensus validity; and six earning layers on consumer hardware.

What It Means

A family in rural Utah runs a single node on a laptop. Each family member has their own identity, their own wallet, their own AI assistant, all running on hardware they own. A small business in Nairobi runs payroll through signed receipts that an auditor can replay in an afternoon. A humanitarian organization distributes aid where every disbursement produces a verifiable receipt that donors can check themselves. AI agents negotiate across continents with payment embedded in the transport header, producing receipts that are auditable forever.

When quantum computers arrive, every blockchain that launched on classical cryptography faces an emergency migration. The Bitcoin Attestation Network does not notice. Every signature has been quantum-proof since block one. The migration that costs other systems years of political agony costs this system nothing. The decision was made before genesis.

Satoshi wrote: "The networks need to have separate fates." Bitcoin should stay Bitcoin. The economic memory layer runs on its own network, anchored to Bitcoin but never burdening it. That sentence became the architectural foundation of everything described in this paper.

The Standard

The cost of corruption is higher when evidence is harder to destroy. The cost of censorship is higher when exits exist. The cost of fraud is higher when receipts are replayable. The cost of centralization is higher when sovereignty runs on a laptop.

Bitcoin fixed the money. The Bitcoin Attestation Network fixes the memory. Together they produce something no civilization has ever had at scale: an economy where the rules are public, the evidence is durable, the cryptography survives the quantum era, and participation does not require anyone's permission.

The genesis block was produced on January 3, 2026, seventeen years to the day after Satoshi's, with a root hash derived from Bitcoin's own beginning. Every signature has been post-quantum from block one. Every receipt is replayable. Every Memory Block is canonical. Every node runs on hardware its operator owns.

Show the receipts.