DBlock-𐤊as

focus on pow block chain and web3 service!🕹️專職介紹區塊鏈白話式跟web3,如果你是90，00後，區塊鏈是可以讓你未來不用躺平機會之一， 關注我，一起邁向維持世界網路安全一員

[Brady Middleton @planetbrady]

Wouldn’t it be powerful to put U.S. health policy processes and funding streams on a public, real-time ledger?

Live transparency. Real accountability. No more black boxes.

Kaspa’s BlockDAG is uniquely built for this and with zero-knowledge proofs, the coming vProgs, and the DagKnight hardfork, the tech is about to get even stronger.

It’s only a matter of time if we make it happen!

The people deserve transparency and accountability!

Imagine if we had this tech during Covid!

TRUTH & TRANSPARENCY MATTER!

@RobertKennedyJr

[DBlock-𐤊as @singboy_bbrick]

@i_am_akane01 99

[Renksi @renksieth]

the more you compare $KAS to other L1s, the cleaner the thesis gets

➢ secure
➢ decentralized
➢ scalable
➢ fair launched
➢ programmable
➢ MEV resistant

chains solve a few of these and compromise on the rest

@kaspaunchained is trying to check the whole list

[Michael Sutton @michaelsuttonil]

Two weeks later, the kasmiths forum is up and running, and there is now a dedicated repo for the standards effort as well: Kaspa Calls for Conventions (KCCs), a new kaspanet repo for converging on actual, formally defined specs and conventions.

Each KCC is a Kaspa Call for a Convention: a document specifying a convention around which independent ecosystem participants and implementations may converge. Topics may include covenant conventions, script-level ABIs, asset standards, wallet and indexer interoperability, based applications, and more.

The first KCCs are already taking shape. @manyfest_ just PRed KCC20, a fungible token covenant specification:
https://t.co/uJHJgUFvKt
and afaik @iziodev is working on KCC1, a script-bytecode ABI for stateful covenants. This should extract and lift the pure definitions currently living at compiler level (ie silverscript), into a shared reusable convention.

Together, the forum and repo provide a path from open technical discussion to actual specs, before incompatible assumptions turn into deployed fragmented implementations.

https://t.co/FsG0BrWnIA

https://t.co/rqRYt5xRsV

[Michael Sutton @michaelsuttonil]

In programming, the actor model is a concurrency model that avoids lock-based synchronization. Instead of controlling access to a data element through a mutex or a read-write lock, you define a single owning actor for that element, and only that actor can mutate its state.

The actor can receive msgs in a message queue from other actors. Think of it as a single thread waiting for msgs in a loop, processing them through actions, and sending msgs to others as part of those actions. It can also initiate communication with other actors. Synchronization primitives may still appear in the implementation of msg queues, but contention is minimal by design.

To illustrate, if several parts of a program want to update the same state, they do not race to acquire its lock. They send msgs to the owning actor, which alone decides how to update its private state and what actions or msgs follow.

(By the way, rusty-kaspa’s consensus-processing pipeline was inspired by a similar design: actors/processors communicate through msg queues to provide pipeline concurrency, while each uses a worker pool for inner-task parallelism.)

---

UTXO detour

In the UTXO model, each UTXO is a one-time data storage point, consumed by the spending tx, which in turn produces new UTXOs. These storage cells carry kas value and an spk (script public key). The spk holds the rules for spending the UTXO.

With kaspa covenants, we focused on one type of spk called p2sh (pay to script hash), which is basically a simple 32-byte hash committing to a locking script. The locking script (aka the redeem script) can also hold state fields within it (think of them as constants embedded in this specific script and fed to the script’s “main function” as args upon execution).

Recent kaspa Toccata additions allow this script to enforce complex conditions, including inspecting the output spks of the tx and verifying complex rules over them. This means an input can verify that an output follows exactly the same contract/script, and that only the embedded state constants are mutated according to the script rules and embedded in the output. Alternatively, it can verify that control has passed to some other known contract template, with the same or a different state object.

eg:

Counter { count: 5 } → Counter { count: 8 }

or:

League { players: n, ... } -- register_new_player → League { players: n+1, ... } + Player { games: 0, ... }

---

To get to my point, imo this makes it natural to name such a stateful covenant UTXO an “actor.” It is not an actor with a long-lived process and a msg-queue processing loop, but it is an actor in the sense of state ownership. Only my fixed logic can consume my own state and produce the actor(s) I become next, with updated state. No one else can consume or mutate that state without going through the rules the covenant itself enforces.

The tx is the interaction/msg that triggers the actor’s next state transition.

A logical actor can therefore continue as a chain of UTXOs:

Actor₀ → Actor₁ → Actor₂ → ...

Each arrow is a valid tx that respects the actor’s transition rules. A covenant id can also give this evolving UTXO lineage a stable identity across state transitions.

---

I argue that this is the right mental model and terminology to establish when discussing covenant state-controlling entities: a piece of code owning a state and exclusively authorizing its mutation/consumption. I think many more details now emerging from eg Argent will be easier to discuss once we establish such jargon.

[Michael Sutton @michaelsuttonil]

After playing around with my Argent compiler (multi-app multi-contract compiler to Silverscript) for several days now, my belief that interesting and rich partitioned-state defi with atomic composability is possible on pure L1 UTXO rails is growing stronger by the day

[DBlock-𐤊as @singboy_bbrick]

@iam678 需求跟供給會有平衡那天😎

[AB Kuai.Dong @_FORAB]

中午 12 点，中国长征十号乙运载火箭，在海南发射场点火升空。火箭在空中完成一二级主体分离后，一子级主体随后返回，落地海上回收平台成功。

中国也开始走马斯克 SpaceX，火箭回收之路了。

[Michael Sutton @michaelsuttonil]

Mission accomplished

[Dr Martin Hiesboeck @MHiesboeck]

The Architectural Edge: Why Kaspa Outpaces Ethereum for DEX Infrastructure

Building a Decentralized Exchange (DEX) on a traditional single-chain blockchain like Ethereum is like trying to run a high-frequency trading firm on a narrow, one-lane highway. While Ethereum pioneered automated market makers (AMMs), its sequential design forces every transaction to wait in a single queue.

Kaspa’s BlockDAG architecture—complemented by the Toccata hard fork—rebuilds the Layer 1 foundation to handle the intensive demands of decentralized trading natively. Kaspa offers several architectural advantages that make it a superior backbone for a modern DEX compared to Ethereum.

Parallel Processing vs. Sequential Bottlenecks

Ethereum processes transactions sequentially. One block is added at a time, roughly every 12 seconds. When thousands of traders rush to swap assets during market volatility, the network bottlenecks, causing a massive surge in gas fees.

Kaspa replaces the single blockchain with a Directed Acyclic Graph (**BlockDAG**). Using the GHOSTDAG protocol, the network processes multiple blocks **in parallel** simultaneously (~10 blocks per second on mainnet). For a DEX, this means transactions don’t get jammed in a single queue; trades are woven together concurrently without degrading network performance.

Structural Defense Against Predatory MEV

Because Ethereum relies on a public mempool where a single block producer dictates the exact sequential order of transactions every 12 seconds, **Maximal Extractable Value (MEV)** bots thrive. They spot a pending trade and "sandwich" the user—buying right before them and selling right after—forcing the trader to execute at a worse price.

Kaspa's Advantage: Real-time decentralization dismantles the mechanics of MEV bots. With Kaspa producing blocks at a rapid-fire pace, there is no single consensus leader holding a monopoly over transaction ordering for long intervals. Rapid parallel block creation and real-time sequencing make it virtually impossible for bots to accurately predict the state and insert predatory sandwich attacks. Traders get the exact execution price they expect.

Sub-Second Latency (CEX Speed, DEX Security)

Waiting 12 seconds for a block—and minutes for true finality—is a lifetime in live trading. While Layer 2 rollups speed up execution, they fragment liquidity, introduce bridge vulnerabilities, and complicate the user experience.

Driven by the Rusty Kaspa engine, the network features sub-second block times. After just 10 seconds, a trade has accumulated roughly 10 layers of confirmation deep within the DAG structure. A DEX on Kaspa delivers the instant, responsive user experience of a Centralized Exchange (CEX) while settling entirely on an ultra-secure, decentralized Layer 1.
.
Predictable, Sub-Cent Transaction Fees

High traffic turns Ethereum into a playground for whales, where a simple token swap can easily cost $20 to $100+ in gas fees.

Because Kaspa scales horizontally at the base layer rather than relying on vertical scaling, the throughput handles massive volume natively. Transaction fees remain consistently sub-cent (<$0.01), making micro-swaps and algorithmic high-frequency trading economically viable for retail users.

[Elon Musk @elonmusk]

Tesla FSD 14.3.4 rolling out now

[Y.S. @YStan__]

This is why $KAS is different.

The community doesn’t only debate price, it debates architecture, consensus, pruning and what a ledger should actually prove.

That’s the type of community worth building for.

Also prepared something for the strongest community in crypto 👀
#Kaspa #YTangem

[Yonatan Sompolinsky @hashdag]

since many (~4) asked me about the zcash bug - - - earlier this year I had this convo with a zcash core dev:

zk: it's weird that kaspa is pruning past records
me: why does it need to keep 'em?
zk: the whole point of ledgers is to prove correctness of all state transitions
me: the whole point of ledgers is to provide focal points for the consensus state
zk: the whole point...
me: hmm then why did you come work in zcash? you know the Sprout->Sapling counterfeiting bug
zk: Turnstile guarantees that the counterfeit could have been very limited
me: true but you still cannot prove or even reason about correct state transitions besides the total supply cap
zk: that's actually a good point

----

the most hardcore cryptography coin is shifting away from correctness proofs to practical-enough proofs. I believe this is a step in the right+practical direction, yet the paradigm shift should not go unnoticed - -cryptography is giving way to consensus.

if you came to zcash for cryptographic integrity, reconsider. there are many good reasons to root for zcash prospering. zcash is serving a more important role than bitcoin, whose utility for the original mission is by now blurry. cryptographic integrity is/should not be one of those reasons.

----

BTW the bug should definitely have been exploited. I don't know the personal values of Taylor Hornby, and I shouldn't be required to make the effort to learn them. I only know that if I found such an exploit, it wouldn't take me more than a few minutes to tempt myself into printing a longint amount of ZEC and deciding later what to do with it.

I wouldn't necessarily use it to exit the pool immediately and corrupt the supply, I'd wait to see if some portion of the broken pool does not seem to migrate on time (probably lost funds), in which case I would not think twice before claiming the funds myself.

you could argue that no harm done, and you might be right, but then again you are here -- in zcash / in crypto -- for its consensus dynamics, the ability to coordinate interests and convictions across different trust zones around some shared asset; not for some pristine mathematical integrity.

[Alex𐤊ander @AleksandrA65113]

🚨 BY JUNE 30, KASPA WILL HAVE QUIETLY ASSEMBLED EVERY PIECE INSTITUTIONS SAID WAS MISSING. AND ALMOST NOBODY HAS NOTICED THE STACK IS COMPLETE.

On June 30, Kaspa activates Toccata. This is not the start of programmability on Kaspa. It is the moment programmability becomes native to the base layer, on top of an L2 ecosystem that has been running in production since March.

Let me show you the picture most observers are missing.

⚡ WHAT IS ALREADY LIVE TODAY

. Igra Network: an EVM-compatible L2 launched on public mainnet in March 2026, processing thousands of transactions per hour with 3000+ TPS capacity, audited by Sigma Prime
. Kasplex: a second EVM L2 also live and accumulating activity, with USDT and USDC bridged from BNB Chain providing stablecoin liquidity
. 15 protocols deployed at Igra launch (lending, DEXes, bridging, wallets, explorers, launchpad)
. KRC-20 tokens with simulated AMM trading on existing infrastructure
. USDC.e bridged through Hyperlane and circulating on L2
. Over 95% of the total KAS supply mined. Fair launch. No premine. No VC unlocks. No insider distribution
. Four years of mainnet operation with documented uptime history

🎯 WHAT TOCCATA ADDS

. Native Silverscript compiler for L1 covenant programming. UTXO-based smart contracts without a separate VM
. ZK application infrastructure anchored directly to L1
. KRC-20 tokens promoted from indexer standard to base-layer protocol primitive, enabling native token issuance directly on L1 (including stablecoins, utility tokens, and tokenized assets)
. Foundation for vProgs (synchronously composable applications) in later upgrades

🎩 WHO HAS TO REASSESS AFTER JUNE 30

Grayscale, whose own published research framed PoW as digital capital. After Toccata, that capital is also programmable through Silverscript. The thesis they wrote becomes one chain that fully expresses it.

Michael Saylor, who repeats that Nakamoto-style consensus is the only honest security model. Toccata adds programmability without breaking that model. No validator cartel. No PoS attack surface. Either his thesis applies here or it never applied at all.

CZ and Binance, who say they listen to community demand. Kaspa community has been one of the most consistently active in crypto for years. After Toccata ships with the L2 stack already running, the listing case becomes harder to defer.

Coinbase, whose stated listing standard is real fundamentals. Fair launch, no premine, no VC unlocks, four years of operating history, now full programmability across L1 and live L2s. The fundamentals stack ranks among the strongest in their alt screening pipeline.

Larry Fink and BlackRock, who frame crypto as the rails of the agent economy. Agent settlement at scale needs low fees, fast finality, and security inherited from Nakamoto-style consensus. Kaspa is the only PoW network where all three are present at the same time.

📊 THE QUESTION INSTITUTIONS HAVE TO ANSWER

Not "is Kaspa real." Four years of uptime has answered that.

The question after June 30 is "is Kaspa now competitive on functionality with the chains we already cover, while keeping the security profile they cannot match." Portfolio managers have to write that answer down.

⚠️ WHAT THIS POST IS NOT SAYING

Not a price prediction. Not a guarantee. Not a moonshot pitch. The next 6-12 months remain gated on execution, adoption, market conditions, and macro. Anyone telling you otherwise is selling you something.

What I am saying: after June 30, the question changes. And the table that has had Kaspa-shaped empty chairs for two years gets harder to leave empty.

🎤 COMMUNITY — YOUR MOVE

Quote this post and tag ONE institutional account from the list. One line, your own words, on why their stated thesis becomes harder to ignore after Toccata.

No hype. No price talk. Just the structural argument, named clearly.

Let's make June 30 impossible to overlook.

#Kaspa $KAS #Toccata #PoW #BlockDAG #SmartContracts #Crypto #DeFi #Institutional #Web3 #Bitcoin #L1 #IgraNetwork #Silverscript

[Sukie @bySukie]

A $20 $KAS is only $600 billion market cap

Peanuts for sound money that truly fulfills $BTC Satoshi Nakamoto’s vision of P2P

then its only a 5x to $100 $KAS

$3 trillion market cap. ft @nic_carter @lexfridman

[𝐂𝐫𝐲𝐩𝐭𝐨 𝐏𝐫𝐨𝐬𝐞𝐥𝐲𝐭𝐞 @Crypt0Proselyte]

Because #Kaspa is something the whole crypto has been chasing for 15 years.
BlockDAG + GHOSTDAG = pure fire. No more linear blockchain bottlenecks. $kas confirms blocks in seconds while staying fully decentralized and PoW-secure like Bitcoin. Real-time finality. This is what Satoshi dreamed of but scaled to the moon. Founder Yonatan Sompolinsky literally invented the GHOST protocol that Ethereum built on early Kaspa took it to the next level.

Crescendo hasalready shipped (May 2025) 10 BPS mainnet.
That’s 10 blocks per second, thousands of TPS right now. Rusty Kaspa (the Rust rewrite) is the official node standard since early 2026ultra efficient, rock-solid, and ready for more. Roadmap has 25-40 BPS by Q3 2026 and 100 BPS in sight for 2027. Hardware is the only limit. No congestion, no gas wars, ever.

Toccata Hard Fork dropping ANY DAY (Late June 2026). Native programmability, KRC-20 tokens, covenants, ZK verification opcodes all on L1. Kaspa just went from “fast money” to full programmable beast. Kaskad Lending (first DeFi protocol) already live on Igra L2 since late May. Smart contracts + DeFi + 10+ BPS = Solana-level speed but with real PoW security and zero VC baggage.

Fair launch, no premine, no insiders, 95%+ supply circulating. Pure community-driven PoW. Hashrate is healthy and growing. Top holders are spread out. This is the anti-VC, anti-rug, sound-money coin that actually delivers on Bitcoin’s original vision but usable for everyday payments right now.

Why is Kaspa THE ENDGAME?
Bitcoin = digital gold (store of value).
Kaspa = digital cash (actual p2p money that moves in real time). It solves the blockchain trilemma without compromises: insane scalability + ironclad decentralization + maximum security. No PoS centralization risks, no L2 fragmentation headaches. Just pure, fast, permissionless money that’s evolving into a full ecosystem. While everyone else is chasing narratives and VC pumps, Kaspa is quietly building the protocol that becomes the new TCP/IP of money. Low cap, massive tech edge, imminent catalysts, and the community that actually ships. it’s the final form of PoW crypto.

[DBlock-𐤊as @singboy_bbrick]

@EvanLuthra It looks like $kas 👀👀👀

[Travladd 𐤊 @travladd]

BREAKING: Tocatta Hardfork June 30.

Do you know what it is and why this is MAJOR for Kaspa? Here's a summary:

This is the foundation for a programmable Kaspa.

By introducing covenant capabilities, zk-proof verification infrastructure, and a new sequencing architecture, Toccata expands what developers can build directly on Kaspa while preserving its high-throughput PoW design.

Rather than launching apps itself, Toccata unlocks the rails for native L1 programmability, advanced asset logic, canonical bridges, and future zk-powered applications. In short, Crescendo scaled Kaspa’s throughput, Toccata scales its utility.

$KAS

[Uncle Stayfun @unclestefan]

Interesting times ahead for #Kaspa.

People keep watching the short-term price action while missing a lot of what’s happening behind the scenes.

TOCCATA isn’t just some random upgrade.

It’s years of engineering, testing, and vision finally getting close to launch.

Programmability.

Better usability.

Fresh design space.

A different direction for Layer 1.

And honestly, the most interesting part?

Price is still pretty weak going into the event.

Normally markets hype up major upgrades way ahead of time.

But this time?

Things feel compressed.

Hardly any excitement.

Which honestly makes it even more interesting.

Maybe the market still hasn’t figured out what’s coming.

Or maybe people are just waiting to see how it performs.

And that’s fair.

Because after TOCCATA, it gets a lot easier to judge things.

Zeta.

Kasplex.

The Kaspa ecosystem.

Potential stablecoin infrastructure.

Builders finally getting some new tools to work with.

At some point, this stops being about “marketing.”

Capability speaks for itself.

Nobody spends years building infrastructure for nothing.

Nobody puts a tunnel in their backyard just for fun.

You build the tunnel first.

Traffic comes later.

Maybe that’s exactly why Kaspa never seemed in a rush for major T1 listings.

What were they really supposed to list before?

The engine was still being built.

Now the engine’s in place.

And the track testing starts.

That’s why TOCCATA feels different.

Not because of hype.

Because it feels like the point where years of research finally start turning into real-world execution.

Honestly, can’t wait to see what they’ve built and how far they plan to take it.

Great time to be alive 🍻

[Hans Moog @hus_qy]

That's a really good question, but it's hard to answer in a single tweet because our mission is quite extensive, and it requires a lot of background knowledge to really understand what sets Kaspa apart.

Currently, a lot of people see Kaspa as “Bitcoin’s crazy little brother” that improves time-to-finality by leveraging the benefits of DAG-based consensus protocols without accepting their traditional drawbacks, such as decreased decentralization or a limited validator set.

This perception is somewhat accurate, but it falls short of conveying the full picture, because Kaspa’s vision extends far beyond just trying to be a better Bitcoin.

Anyone willing to study Kaspa and its broader vision will discover similarities to nearly all major existing DLT designs: from Bitcoin, to Ethereum, to Solana, Sui, Celestia, and beyond.

My personal view is that “research” in the DLT space is approaching a point of convergence. We increasingly understand how to push distributed systems close to the limits of what physics permits. The frontier is no longer only about raw throughput or faster finality. The attention is shifting toward game theory, incentives, sequencing, MEV, alignment, and how to build systems where the economic incentives of users, builders, miners, validators, applications, and infrastructure providers do not work against each other.

That is why debates like based rollups versus arbitrary sequencing, shared sequencing, MEV mitigation, proposer-builder separation, and execution-layer incentives matter so much. These are not niche technical details. They determine whether a network can remain neutral, decentralized, and aligned while scaling to global usage.

And this is where I think Kaspa is pushing the boundaries in a very important way.

Kaspa is not merely trying to be “fast.” The goal is to build an L1 where speed, decentralization, security, and incentives are aligned at the base layer. A system that does not scale by hiding complexity behind trusted committees, privileged sequencers, centralized validator sets, or opaque coordination mechanisms, but instead tries to preserve the spirit of proof-of-work while extending what an L1 can realistically do.

Because Kaspa arrived later than many other major projects, it does not carry the same degree of technological debt. It can absorb lessons from Bitcoin, Ethereum, rollups, modular blockchains, high-throughput monolithic chains, DAG research, MEV research, and the broader history of decentralized systems, and combine those lessons into something more optimal.

To me, that is what Kaspa is building: not just a faster blockchain, but a more incentive-aligned decentralized infrastructure layer.

But this also creates a different challenge.

Kaspa’s biggest problem today is not its technology. It is the lack of centralized coordination around communicating the vision. And because Kaspa is a grass-roots movement, that responsibility does not belong to a marketing department, or a single leadership team. It belongs to the community.

That also means the community has a different role to play.

There will always be holders who are mainly interested in price, and that is completely fine. But there also need to be people who are here because they want to use the technology to build a different future. People who care about the architecture, the incentives, the open questions, the trade-offs, and the long-term trajectory of decentralized infrastructure.

I am one of those people.

I am not interested in DLTs merely as a way to generate wealth. I am interested in them because I believe they can change the trajectory of humanity as a whole.

For that reason, I want to use this opportunity to announce a regular community hangout where we discuss the current state of development, the open questions, and where we can align our vision together.

The first session will be on Tuesday, June 9th, 2026.

We will talk about the vProgs framework, how the codebase works, what sets Kaspa apart, where we improve on existing solutions, and what still needs to be done. The goal is for this to become a regular, possibly bi-weekly, event where we as a community come together to discuss the future and understand the technology.

Eventually, we can invite people from other projects as well, but the main focus at the beginning will be explaining and communicating how things work under the hood.

There is still a lot of work to be done, and I do not want to waste precious time. So the first sessions may feel a little improvised, but we can improve as we go.

The important thing is that we start.

So mark the date: Tuesday, June 9th, 2026.