1. Wallet Configuration: Install UniSat or Xverse wallet. Switch to Bitcoin Testnet:
   - Settings → Network/Developer → Enable Testnet Mode
   - This prevents using real BTC during testing

2. Test Funds Acquisition: Visit the Mempool Faucet:
   - URL: https://testnet-faucet.mempool.co/
   - Request 0.005 tBTC (test Bitcoin) for gas fees
   - Faucets may have daily limits or require CAPTCHA

3. Repository & Simulation: Clone the BRC-8888 reference implementation:
   - git clone https://github.com/xai-org/brc8888
   - Run: python3 deploy_ledger_validation.py
   - This simulates indexer operations locally before mainnet

4. Exploration Tools:
   - Use ord.io/testnet for inscription ID lookups
   - Use mempool.space/testnet for transaction monitoring
   - These tools help verify your inscriptions and track confirmations

5. Mainnet Preparation:
   - Convert testnet addresses (tb1p...) to mainnet (bc1p...)
   - Fund with real BTC for production deployment
   - Use unq_deploy.json for Quantum Edge bootstrap (fee exempt)
    

• u-token: Standard fungible tokens with decimal precision and fixed supply.
  Example: Quantum Edge (UNQ) utility token. Supports phased minting pricing.

• u-nft: Unique Non-Fungible Tokens (supply=1) with evolvable traits.
  Each is distinct; metadata can update via evolution mechanics.

• u-sft: Semi-Fungible Tokens for batches or limited editions.
  Like game items where each batch is identical but limited in quantity.

• u-ai: AI-Aware Objects with verifiable provenance.
  Contains model_hash, dynamic_traits; evolves via AI-generated seeds/attestations.

• u-qid: Post-Quantum Secure Digital Identities.
  Uses Dilithium3 public keys for quantum-resistant signatures in credentials/reputation.

• u-object: Generic extensible container (default for Quantum Edge).
  Custom hybrids possible (e.g., AI-NFT combos).

Selection Strategy: Choose during deployment. Combine types for advanced use cases:
  Example: u-ai + u-sft for AI-generated limited edition collections.
    

QUANTUM EDGE (UNQ) MINTING PROCESS:

1. Mint Quantum Edge Tokens:
   - Navigate to "Mint" tab in interface
   - Set quantity (qty) and ticker (UNQ for Quantum Edge)
   - Generate inscription JSON payload
   - Inscribe as text inscription on Bitcoin
   - IMPORTANT: Add phased pricing outputs + 1% protocol fee

   Phased Pricing Structure:
     • Phase 1 (First 5M UNQ): 2,100 sats per unit
     • Phase 2 (After 5M): 4,200 sats per unit + AI perk eligibility
     • Indexers automatically enforce based on total_minted counter

   Anti-Sybil Measures:
     • Per-user cap: 10,000 UNQ maximum
     • Cooldown period: 144 blocks (~24 hours) between mints
     • Founder exemptions: 1M UNQ vested with linear unlocking post-cliff

2. Transfer Tokens:
   - Use "Transfer" tab
   - Specify quantity, ticker, sender, and recipient addresses
   - Generate transfer inscription
   - Include mandatory 1% protocol fee output
   - Validation: Sender balance ≥ transfer amount, vested tokens non-transferable

3. Verification & Best Practices:
   - Query indexer API: GET /state/UNQ for real-time balance
   - Check inscription on ord.io explorer
   - Start with small test amounts
   - Use provider services for one-click minting (auto-fee calculation)
   - Anonymity: VPN acceptable, no KYC requirements
    

DEPLOYMENT WORKFLOW:

1. Deploy New Object Type:
   - Access "Deploy" tab
   - Configure: ticker symbol, object type (u-token, u-nft, etc.)
   - Set total supply, decimal places, per-user minting caps
   - Choose pricing: flat rate, phased increase, or free mint
   - Advanced options:
       • ai.model_id: Reference AI model (e.g., gpt-q-lite)
       • quantum.identity_pub: Post-quantum public key (Dilithium3)
   - Define mint_rules: caps, cooldowns, exemption lists, phase thresholds
   - Fee structure: 1% per transaction (except genesis deploy)
   - Non-genesis creators pay 10,000 UNQ deployment fee
   - Generate → Inscribe → Record Inscription ID (critical for future references)

2. Evolution Mechanics (State Updates):
   - Prepare evolution bundle:
       1. state.json (new state)
       2. traits.json (from ai_trait_gen.py)
       3. provenance.json (lineage proof)
   - Compute Merkle root: scripts/merkle_root.py
   - Package: package_evolve.py   
   - Quantum Signature: Sign (ref || root || trigger) with Dilithium3 private key
   - Trigger examples: {"type":"transfer","txid":"abc123","details":{"qty":"100"}}
   - Update JSON with IPFS/Arweave URI and signature
   - Inscribe evolution (include 1% fee output)

   Evolution Use Cases:
     • AI trait generation
     • Game level progression
     • Vesting schedule unlocks
     • Phase transition triggers

3. Security Recommendations:
   - Generate PQ keys on air-gapped systems
   - Pin metadata archives to decentralized storage (IPFS/Arweave)
   - Test with validation scripts before mainnet
    

VALIDATION PIPELINE:

1. JSON Parsing:
   - Protocol identifier: p:"brc8888-1"
   - Version: v:1
   - Operation type: deploy/mint/transfer/evolve

2. Fee Validation:
   - Transaction outputs must include ≥ 1% of transferred value
   - Additional phased fees for mint operations
   - Verify fee addresses are within protocol scope

3. Deployment Checks:
   - Ticker must be unique (not previously deployed)
   - Supply and decimals within valid ranges
   - Store metadata: mint_rules, phases, AI config, quantum keys

4. Mint Operation Validation:
   - Corresponding deployment must exist
   - total_minted + requested_qty ≤ total_supply
   - Enforce user caps, cooldown periods, vesting schedules
   - Calculate phased pricing based on current total_minted
   - Founder exemptions skip phased pricing but respect locks
   - Update: balances, minter stats, totals, last_block

5. Transfer Validation:
   - Sender balance ≥ transfer quantity
   - Respect lock conditions (vested tokens)
   - Update ledger debit/credit entries

6. Evolution Verification:
   - Reference inscription must be valid and latest in chain
   - Recompute Merkle root from provided URI (must match)
   - Verify post-quantum signature using oqs library
   - Confirm trigger conditions met (e.g., txid exists with correct parameters)

7. Ledger Management:
   - Use defaultdicts for balance tracking
   - Deterministic processing (ordinal inscription order)
   - Multi-indexer synchronization for consensus

8. Operational Tips:
   - Reference implementation: deploy_ledger_validation.py
   - Emit state change events via /state/TICK API
   - Implement minimum fee/rate limits against spam
   - Complete algorithm: indexer_validation.md
    

❓ What is BRC-8888?
   Bitcoin-native protocol for stateful, evolving, AI-aware, post-quantum ready digital objects.
   Universal layer for tokens, NFTs, AI assets, and quantum-resistant identities.

❓ How does it compare to BRC-20?
   Complementary and extensible. While BRC-20 handles simple fungibles,
   BRC-8888 adds evolution mechanics, AI integration, and post-quantum security.

❓ Does it require Bitcoin consensus changes?
   No. Uses standard Bitcoin inscriptions. Indexers enforce rules off-chain
   while settling finality on Bitcoin's base layer.

❓ What is the fee model?
   Mandatory 1% protocol fee on all transactions (sustainability).
   Plus phased minting prices: 2,100 sats/unit (Phase 1), 4,200 sats/unit (Phase 2).

❓ What is Quantum Edge (UNQ) genesis?
   • Total supply: 21,000,000 UNQ
   • Decimals: 8
   • Phased minting: First 5M at 2,100 sats, remainder at 4,200 sats
   • Founder allocation: 1,000,000 UNQ with vesting/lockup

❓ Anti-abuse measures for minting?
   • Per-user cap: 10,000 UNQ
   • Cooldown: 144 blocks between mints
   • Founder exemptions with vesting schedules
   • Phased pricing to prevent front-running

❓ How do evolutions work?
   Immutable state updates via Merkle roots, post-quantum signatures,
   and trigger conditions. Unlimited updates enable adaptive digital assets.

❓ Are PQ/AI features mandatory?
   Optional but recommended. Post-quantum for secure evolutions,
   AI for provenance and dynamic traits. Demo available in ai_trait_gen.py.

❓ Wallet and marketplace support?
   Coming soon via indexer integration. Early integration bounties:
   0.5% fee share + 100,000 UNQ reward for first major wallet integration.

❓ What if an indexer rejects my transaction?
   Ignored by network consensus—no penalty. Common causes: missing fees,
   invalid signatures, cap violations. Use multi-indexer verification
   and simulation API (/simulate/mint) before mainnet.

❓ Can I deploy my own token?
   Yes. Create non-genesis JSON with unique ticker, object type,
   supply, and rules. Pay 10,000 UNQ + 1% fee deployment cost.

❓ What about anonymity?
   Pseudonymous by design. Uses Bitcoin's Bech32 addresses.
   Air-gapped PQ signing enhances privacy. Treasury operations transparent.

❓ Security considerations?
   • Deterministic validation algorithms
   • PQ signatures + Merkle proofs prevent tampering
   • Best practices detailed in security.md
   • Regular security audits planned

❓ Where do I start?
   1. Read the specification and validation documentation
   2. Experiment with reference implementation code
   3. Review examples (unq_deploy.json)
   4. Join community on X/Discord for support