Fees, mining, and what it adds up to

Two smaller changes ride in with Toccata, and both are constantly getting misread.

First, the transient-mass byte allowance roughly doubles, from about 125 KB to 250 KB. This has little to do with increasing TPS (although, sure). A large STARK-based proof can be big enough that a block needs room for the proof plus the surrounding transaction data. No room for the proof, no ZK verification on L1. Simple as that.

Second, a minimum standard fee. Doubling the byte allowance means the DAG can soak up more data, which increases the disk burden on everyone running a node, an archive, or an explorer. This isn't abstract: the Toccata guide now says 640 GB SSD minimum, 1 TB preferred. If storage requirements are going there, the space should be filled by proofs, app transactions, asset activity, payments, actual use, not free junk. For a service or app, the fee is small compared with the thing being purchased, settled, or protected. For someone filling blocks with junk, the floor makes chain filling cost real money.

This is just a standard-relay fee floor. A miner can accept cheaper transactions, but most run the default, so only that miner's share of blocks would carry the spam. Nodes can change policy later if the number stops making sense. The point is simple: make proofs fit, and make bulk junk cost real money.

This one's wired straight into the sovereignty story, and imo, it's underrated. Shoutout to @LiveLaughLove13, who built the Rust Stratum Bridge that's now provided with rusty-kaspa and currently marked beta.

The sovereignty pitch usually stops at "run your own node." For proof-of-work the better version is "mine to your own node." Problem is ASICs don't speak Kaspa's node language, they speak Stratum, so for a long time you needed a separate bridge or, more commonly, you just handed the job to a pool because wiring yourself directly into the network is a pain. Pulling a maintained Stratum bridge into the rusty-kaspa package itself makes solo mining a normal thing instead of a weekend science project. Run your own node, verify your own chain, mine to your own node. Be your own bank, be your own miner.

An implication came up that I hadn't chewed on before, and I'd flag it as speculation (for now) because the mechanism isn't decided: if RTD-style oracle flows ever need miners to attest to outside claims on chain, the Stratum bridge is one plausible place for that app-layer work to plug in. It already sits between ASICs and a Kaspa node. This is app responsibility, not base consensus responsibility. Maybe nothing, but the direction is interesting.

Solo mining guide for the actual miner-to-node setup.

Covenants make UTXOs expressive. Covenant IDs keep that expressiveness honest. ZK moves the expensive computation off chain while keeping cheap verification on it. KIP-21 lets apps find their own activity instead of scanning the (DAG) universe. The fee and byte-room changes make room for proofs without making spam free. The Stratum Bridge makes solo mining real, and maybe gives future miner-side app jobs a place to plug in. Stack those up and the sovereignty story gets a lot more complete: sovereign money, sovereign verification, sovereign mining, sovereign apps, and maybe one day a sovereign way to bring real-world information in.

Yet this still isn't completely finished. vProgs aren't here. DAGKnight isn't here. 100 BPS isn't here. Toccata isn't the final form. But it's also not nothing, which is the thing Kaspa people keep doing to ourselves: under-celebrating what's shipped because we're already squinting at the next milestone. Toccata isn't a roadmap promise anymore. Once activation completes, it's live primitives: vaults, assets, weird state channels, ZK apps proving work back to L1, chess games, or something none of us has thought of yet. That's the fun part.

For years, UTXO programmability has been this quiet research corner full of brilliant people inventing clever workarounds. Bitcoin has some of the sharpest minds in the entire space, and a lot of them are stuck working around a culture that doesn't want the solution to exist on L1. The same little opcode that quietly makes most of this possible, OP_CAT, is something Bitcoin has refused for years on purpose, because it treats that much expressiveness as a risk, both to keeping coins as pure money and to Bitcoin's own security. This is a legit philosophy and not necessarily a dumb one. Kaspa just made a different call, and tried hard not to lose the lean, verifiable, sovereign properties that made this whole thing worth caring about in the first place.

That's why I keep landing on the word elegant, because none of this has been, is, or will be easy. It's taken the Rust rewrite, Crescendo, years of grinding performance work, and a stack of upgrades and tools most users will never need to know by name (the new opcodes, covenant IDs, the ZK verifier, KIP-21's activity tracking, SilverScript, Argent, on and on), plus a pile of people quietly building parts most users will never see or thank them for. Not to mention the stuff I'm sure core is already working on to make this future more usable.

Which is the real reason I'm "bullish," more than any chart. The design is good. The people are better. Core devs, contributors like @LiveLaughLove13, the SilverScript and tooling folks, the writers and explainers (people like me, hello) trying to make this legible to humans who don't read consensus code for fun. We're a real community doing hard, unglamorous work because this design goal is worth pursuing.

Underneath the coin, even underneath the people, there's this idea I've actually fallen for. You take something simple and clean, a lock, a key, one rule about what's allowed to come next, and you arrange those tiny pieces into something complex and genuinely beautiful. That's the whole story of computing. It's the story of covenants. It's the thing Bitcoin's best researchers wanted for years and weren't allowed to have on Bitcoin. Bitcoin Cash built a version first. Kaspa built it on a base layer fast enough to make it relevant.