The $DOG Army is building 💪 $DOG Swap (DEX) $DOG Effect (book) $DOG City (metaverse) $DOG TV (24/7 livestream) $DOG Mode (Bitcoin client) $DOG Shop (plushies & merch) $DOG Summit (IRL conference) $DOG Data (analytics platform) $DOG Millionaires Show (podcast)

IF you can follow below you will understand why below helps us accomplish this i have made it simple to read with out too much technical jargon # How We Fit 10,000 Trades Into 200KB on Bitcoin ## And How You Can Decode Every Single One Back to the Exact User --- Every trading platform makes the same compromise: store a hash on Bitcoin, dump the actual data on Arweave or IPFS, and hope those services stay online. If they don't? Your trade history is unverifiable. **We don't make that compromise.** ordi.network inscribes the **complete trade history** — every user, every token, every amount, every timestamp — directly on Bitcoin. Not a hash pointing somewhere else. The actual data. 10,000 trades. ~20 KB. One Bitcoin inscription. Here's how. --- ### The Insight: Trades Aren't Random If you looked at 10,000 trades on any platform, you'd notice patterns immediately: **→ 30% of all actions are "buy."** Another 20% are "sell." The same few action types repeat thousands of times. **→ 64 users generate 70% of all trades.** A small group of power users dominates activity. **→ Most amounts are round numbers.** People buy 1 wORDI, 5 wORDI, 10 wORDI — not 1.3749283746. **→ Trades happen seconds apart.** Timestamps barely change from one trade to the next. Standard compression algorithms like gzip don't know any of this. They treat trade data the same as a JPEG or a text file. **ONEL knows all of it.** --- ### ONEL: A Language Built for Trades ONEL (Ordinal Network Encoding Language) is a purpose-built binary encoding that exploits every pattern in trading data. It splits each trade into 6 independent streams — like separating a spreadsheet into columns — and compresses each one differently: **Stream 1 — What happened?** "Buy" happens 30% of the time, so it gets a 1-bit code: `0`. "Sell" gets 2 bits: `10`. Rare actions like "cancel NFT listing" get 12 bits — but they barely ever happen. This is Huffman coding, the same principle as Morse code — common things get short codes. **10,000 action types → under 1 KB.** **Stream 2 — Who did it?** The top 64 most active users each get a 6-bit code (like a jersey number). Less active users get longer codes. And if the same user makes 20 trades in a row, you write their ID once. Here's the key: the **first time** a user ever trades, their full 20-byte wallet address goes into the file. But once they're on Bitcoin from a previous epoch, they're referenced by a tiny index number forever. As the platform matures, almost everyone is already on Bitcoin. **2,000 users → ~3 KB (mature epoch).** **Stream 3 — Which token?** Same trick as users. New tokens include their full name, symbol, and creator. Previously-seen tokens are just an index number. Consecutive trades on the same token don't repeat the token ID at all. **50 tokens → ~225 bytes.** **Stream 4 — How much?** This is where the 6-decimal precision matters. "1.37 wORDI" becomes the integer 1,370,000 — encoded in 3 bytes. At the standard 18 decimal places, the same value is 1,370,000,000,000,000,000 — that's 8 bytes. Every amount in every trade, 2-3x smaller. No precision lost. No rounding dust. **10,000 amounts → ~4 KB.** **Stream 5 — Extra data.** NFT IDs, transfer recipients, swap targets, token creation metadata. Most trades don't need any of this — a simple buy has zero auxiliary data. Only the actions that need it pay the cost. **~2 KB.** **Stream 6 — When and in what order?** Instead of writing a full 8-byte timestamp per trade, ONEL writes the first timestamp once and then just the **difference** between consecutive trades. Trades 2 seconds apart? That's 1 byte instead of 8. Sequence IDs delta-encode the same way — each one is roughly 1 byte. **10,000 timestamps + sequence IDs → ~2.5 KB.** --- ### The Result | Component | Size | |-----------|------| | Header + integrity hash | 64 bytes | | User address table | ~2 KB | | Token table | ~225 bytes | | Action types | ~1 KB | | User references | ~3 KB | | Token references | ~1.5 KB | | Amounts | ~4 KB | | Extra data | ~2 KB | | Ordering data | ~2.5 KB | | **Total** | **~17.5 KB** | **2.5 MB of raw trade data → 17.5 KB. A 125x compression ratio.** At 50 sat/vB with BTC at $90,000, that's **$221 to permanently record 10,000 complete trades on Bitcoin.** $0.022 per trade. Every user. Every token. Every amount. Every timestamp. Permanently. --- ### How You Decode It Back This is the part that matters. The data isn't just small — it's **fully reversible**. Anyone with a Bitcoin node can decode every trade back to the exact user. The ONEL file contains its own lookup tables: ``` User Table:  user 0 = 0x46f2...eba7 user 1 = 0x231a...0d46 user 2 = 0x8a9A...cC6B ... Token Table: token 0 = "EVIL EYE" ($EYE) by 0x46f2... token 1 = "SORCER" ($SORC) by 0xe5a9... ... ``` Decoding is just reading each stream in parallel and looking up the tables: **Action #1:** - Stream 1 → "buy" - Stream 2 → user index 3 → look up → **0x46f2...eba7** - Stream 3 → token index 0 → look up → **EVIL EYE ($EYE)** - Stream 4 → 1,370,000 → **1.37 wORDI** - Stream 6 → sequence 1, timestamp 12:00:01 ✅ **"0x46f2...eba7 bought EVIL EYE for 1.37 wORDI at 12:00:01"** **Action #2:** - Stream 1 → "buy" - Stream 2 → user index 3 → **same user** - Stream 3 → token index 0 → **same token** - Stream 4 → 5,000,000 → **5.0 wORDI** - Stream 6 → sequence 2, timestamp 12:00:03 ✅ **"0x46f2...eba7 bought EVIL EYE for 5.0 wORDI at 12:00:03"** **Action #3:** - Stream 1 → "sell" - Stream 2 → user index 7 → look up → **0x231a...0d46** - Stream 3 → token index 1 → look up → **SORCER ($SORC)** - Stream 4 → 200,000 → **0.2 wORDI** - Stream 6 → sequence 3, timestamp 12:00:04 ✅ **"0x231a...0d46 sold SORCER for 0.2 wORDI at 12:00:04"** You keep going — action 4, 5, 6... all the way to 10,000. Every single one decodes to a **full, human-readable transaction** with the real wallet address, real token name, exact amount, and exact ordering. --- ### Verification: Proving It's Real After decoding all 10,000 trades, you hash them and compare to the **actionsRoot** committed on Bitcoin in the settlement inscription. **If they match → the data is guaranteed authentic.** If even a single byte was tampered with — one amount changed, one user swapped, one trade reordered — the hash breaks. Provably. Five independent verifiers also download, decode, and replay every trade before signing off on each epoch. Their cryptographic signatures are inscribed on Bitcoin too. --- ### What This Actually Means To audit any epoch in ordi.network's history, you need **nothing except a Bitcoin node:** 1. Read the inscription from Bitcoin 2. Decode with the open-source ONEL translator 3. See every trade — who, what token, how much, when 4. Replay through the deterministic engine 5. Verify the math matches the committed roots 6. Check the verifier signatures **No Arweave. No IPFS. No API server. No trust.** Every other platform stores a hash and says "trust us, the data is over there somewhere." We store the data itself. **10,000 trades. 20 KB. Permanently on Bitcoin. Fully decodable to every user. $0.022 each.** That's what 100% Bitcoin-native means. --- *ordi.network — Bitcoin-native non-custodial trading on BRC2.0*

You're right that Bitcoin doesn't validate the EVM — but that's the same split Ethereum has. Consensus orders blocks; execution clients re-run every tx. Here Bitcoin is the consensus layer (order + data), and every BRC2.0 indexer is an execution client re-running everything. How OrdiNetwork uses it: • Users sign trades off-chain with their own key • Up to thousands get packed into one compressed blob with a single aggregate signature and inscribed on Bitcoin • Our contract replays every trade and checks every signature and balance. One bad trade and nothing settles So the operator can't forge or edit a trade, only order and package them. Every BRC2.0 indexer re-runs our contract, so every indexer re-checks every band. And if the operator drops a trade it gave a receipt for, its stake gets slashed. Gas: BRC2.0 already prices gas in BTC — you buy computation with the bytes you inscribe. No gas token. Platform fees are in ORDI, the first BRC-20, and every action's network fee is split between whoever settles the band, the executioner pool, the team and a community pool. Still ahead: more independent indexers, and GPU executioners proving their hardware on-chain. The settle-with-replay core is live today on signet — run an indexer and check any band.