This wallet has stolen USDT in my account on MEXC and BYBIT exchanges approximately $256
0xe2a6b2561a0d90ee37f1e31095f2144239df48ba
Please be careful account users
@MEXC_Official @Bybit_Official
I think one day we will look back and better understand, myself included, how important this component is for Kaspa and for the sequencing and programmable capabilities it opens up. More on that in followup posts when I get some air. A few days late, but this is the nearly final step before the Toccata feature freeze and TN12 reset.
Huge kudos to @Max143672 for shipping such a monumental end-to-end change with elegance.
Approved and merged: https://t.co/qJgCWyk7mw
Also, on a personal note: ai was incredibly powerful in this review journey. Not as a substitute for judgment or ownership, but as a force multiplier for understanding, walkthroughs, invariant checking, ascii drawing, and staying deep in a very large design. And yes, that includes writing this paragraph ;)
The Bitcoin low for 2026 is in.
Those calling for and waiting for $30,000 to $40,000 were wrong and will be sidelined unless they chase.
As I said, the max drawdown I expected was 50-60%, not the 80-90% seen in past cycles.
$60,000 was a gift (52% down from the ATH), and it took a Binance "glitch," months of Jane Street manipulation, and plenty of shenanigans to get us there.
We got follow through on the PMI, and it is time for the main event: the full bull market.
The bull market correction is over.
HUGE $KAS NEWS
$KAS Smart Contracts Update:
$KAS has made big moves towards enabling smart contracts, though full native Kaspa's Layer-1!!!
Move over L2s, $KAS WILL TAKE OVER FROM HERE
Recent developments in Silverscript Launch: Developer Ori released Silverscript, Kaspa's first high-level SMART CONTRACT LANGUAGE
This tool allows advanced DeFi and covenants directly on Kaspa - it preserves Kaspa's UTXO model (unlike account-based systems like Ethereum), works natively with BlockDAG, maintains PoW security, and supports bounded logic to avoid bottleneck - currently AVAILABLE on Testnet 12
Covenant-Centric Hardfork (Scheduled for May 5, 2026): This major protocol upgrade is the cornerstone for native smart contracts on Kaspa's L1 - it introduces: Covenants++ (enhanced spending conditions in transactions) - native asset tracking/support for tokens - DEEPER zero-knowledge (ZK) verification capabilities - programmability features without altering the core PoW consensus!!!
OVERVIEW: The upgrade aims to expand beyond pure speed/payments into full L1 programmability, enabling real-time DeFi, NFTs, and more at Kaspa's high throughput. Kaspa devs CONFIRM the Covenants Hard Fork (target May 5, 2026) and SilverScript Compiler & Developer SDK (releasing alongside it) as active PRIORITIES. This positions Kaspa as a base layer for ZK-rollups, where complex apps can run off-chain while settling securely on L1
I keep saying, greatness takes time and the wait is almost over...
@moshikrl@kaspaunchained@michaelsuttonil aiming for two HFs in 2026, cov++ beginning of May, DK+increased BPS end of Q3 god willing. both are aggressive timelines, but realistic with the newly expanded devforce
🚨 JUST IN: Yonatan Sompolinsky confirms DAGKnight mainnet implementation final release Q3 2026 100 BPS.
Proof-of-Work to levels all thought impossible.
Kaspa’s evolution: from local scripts to stateful systems, without losing locality
I want to try to explain, in simple words, the vision and the gradual implementation path for smart contracts and complex financial systems on Kaspa.
Instead of trying to cover everything, I am going to weave one continuous line of thought: from the most basic primitives, through the key additions we are making, toward the system-level picture.
A meta note: even in parts where the destination feels intuitively clear, conceptual clarity only emerges while building. This is not just engineering, and not pure theory either. It is system research: making the model itself clear as we walk.
A simple ladder to keep in mind:
• UTXO scripts constrain spend authorization
• Covenants constrain next outputs
• Lineage authenticates which instance is “the real one”
• ZK verifies transitions by succinct proofs, without on-chain execution
One guiding principle throughout: we want these capabilities as first-class consensus and script-engine primitives that compose cleanly, not as clever edge-case constructions.
---
UTXO as the base model: a constitution that governs a resource
The UTXO model is, at its core, a script (a “constitution”) that controls a resource.
That constitution is local in two senses:
• Local in space: the spending script sees only the inputs it spends, plus whatever data the spender provides.
• Local in time: the script is a one-shot gate. Once a spend happens, the old constitution does not persist into the future. The future is governed by whatever new scripts the coins are sent to--but there is no inherent linkage between old rules and new rules.
In the common case, the constitution is minimal: “only someone who can prove possession of a private key may spend”.
In pseudo-form it is basically: SigVerify(pk). The spender provides a signature proving they control the private key behind pk, and that they authorized this specific transaction.
---
The one thing that is enforced over time: conservation of value
There is one strong temporal law baked into the base model: conservation of value.
Consensus enforces that the total KAS value created by a transaction is less than or equal to the total KAS value it consumes. This is why “Kaspa the asset” is not just data in a UTXO. It is a native resource with a conservation law enforced by the protocol.
So Kaspa already has one temporal invariant “for free”.
---
But what if we want richer rules than “who can spend”?
Now imagine we want more complex logic. Examples:
• Coins can only be sent to a whitelist of addresses.
• Only 5% of the balance can be spent per day.
• This resource must evolve under a fixed policy over time.
This is where the right mental model becomes a state machine.
A state machine has a state and a transition function. The transition function must be able to enforce what the next state is allowed to be. In UTXO terms, “writing state” happens by creating the outputs of the spending transaction--so a real transition function must be able to constrain the outputs.
The problem is the locality constraint: in the classic btc-style scripting model, without introspection, the spending script cannot constrain what it is creating. It gates the spend, but it cannot reason about outputs. Without seeing outputs, implementing a genuine state machine is impossible.
(Notwithstanding btc’s indirect workarounds via sighash tricks, which can approximate limited introspection in specific patterns.)
---
Introspection: enabling state machines in a local-compute model
This is why transaction introspection opcodes are a foundational step. (This is what KIP-10 introduced, starting with Crescendo.)
Once the script engine can read transaction fields, and crucially inspect output scripts, the transition function can finally say: “you may spend this input only if you create outputs that satisfy these constraints”.
Conceptually, that is the birth of what we call a covenant: a spend is no longer pure ownership transfer. Spending becomes conditional on preserving a policy across time.
It lets a resource enter a covenant: the owner’s freedom becomes constrained by an on-chain policy that must remain true after the spend, not only at the moment of spending.
Note how this enables persistence without losing locality. The script only enforces a one-step look-ahead, by constraining the next outputs. But if it requires those outputs to carry the same policy forward, it becomes an inductive rule: one-step enforcement is enough to preserve the covenant across arbitrarily many future transitions.
---
Completing the state machine model: primitives and lineage
At this point we can describe covenants in principle, but to make general state machines possible we need two things: better building blocks, and a notion of authority for non-KAS state.
(1) Byte and hash primitives: even if you can see outputs, you still need the low-level tools to express robust constraints. That means byte-string construction and parsing (e.g., OpCat, OpSubstr) and strong hashing with domain separation (e.g., OpBlake2bWithKey). Without these, you can’t reliably build commitments, slice out exact fields, or enforce consistent state encodings that make transition validation composable. (This is what KIP-17 added on TN12.)
(2) Lineage (provenance): “who says this state is real?”
Once a covenant represents non-KAS state (a token, an asset, or the compressed state commitment of an off-chain application), the state is no longer self-authenticating the way KAS value is.
A short concrete story:
• I can create a UTXO whose script claims “I am TokenX with supply 1,000,000”.
• Nothing in consensus prevents me from writing that claim into a script and funding it with real KAS.
• So the real question becomes: how do wallets know which instance is the real TokenX state machine?
This problem only appears once “state” is no longer the native KAS resource, so it helps to separate the KAS case from the non-KAS case:
• If the covenant is “about KAS”, the value already has native, consensus-backed provenance via conservation. You do not need lineage to prove the KAS value was not created from thin air.
• For non-KAS state, there is no conservation law. Without lineage, you cannot prevent “fake instances” of the same-looking scheme.
So for non-KAS covenants, lineage must be part of the design: the instance has to be anchored to a recognized genesis, meaning an agreed initial state and rules for a specific state machine instance, and then continued through valid transitions. KIP-20 addresses this by introducing consensus-tracked covenant IDs for instance identity and lineage.
---
The next layer: ZK
With covenants able to enforce transitions and lineage, we can move beyond “everything must be revealed and executed in-script on-chain”. This is already the direction on TN12 with ZK verification opcodes (KIP-16).
Without ZK, each state transition must be validated on-chain by revealing what the base layer needs to check. In practice, every step tends to carry three costs: revealing the state preimage, revealing the rules preimage, and executing the transition checks in-script.
ZK verification opcodes let us keep only commitments on-chain and prepare the public transition inputs, then a proof attests that there exists a valid hidden witness and execution trace that takes the old commitment to the new commitment under the intended rules.
That gives scalability, and sometimes privacy. L1 enforces correctness without re-executing the full computation in-script, and without forcing state and rules to be re-published on every transition.
The bigger consequence is expressiveness: ZK is machinery above covenants that lifts the “on-chain execution” ceiling. The base layer verifies validity, while the full transition function can be arbitrarily complex off-chain, including loops and large computations. In that sense, covenants plus ZK give a path to general-purpose computation anchored and enforced by L1.
---
Outlook: Part 2
Part 2 will go deeper into the ZK layer and the shared-state story:
• How a zk app can be based, meaning L1 sequencing fully determines the transition history.
• How these primitives support canonical bridging of KAS.
• How we further modify the base layer so multiple zk apps or vprogs can synchronously compose without waiting for base-layer messaging roundtrips.
Post 1/6
⚡️ ATTENTION CRYPTO FAM! CoinGecko just revealed the MOST SEARCHED altcoins in the last hours… and guess who’s on the list?
$KAS - Kaspa deserves WAY more attention! 😤
@elperorr spotted this and I 100% agree. Let’s dive into why this project is quietly flying under the radar and ready to explode.
Full thread 👇 #Kaspa #KAS #Crypto
Post 2/6
Kaspa isn’t just another altcoin. It’s a BlockDAG blockchain (not the old linear chain) that processes blocks in parallel.
Result? INSANE speed:
10 blocks per second (and climbing)
Transactions confirmed in seconds
Full security with Proof-of-Work (like Bitcoin, but supercharged)
Think of it as "Bitcoin 2.0" for fast payments. 🚀
What do you think? Reply if you love real tech! #Kaspa
Post 3/6
Why is $KAS trending on CoinGecko?
Current Market Cap: ~$850M (rank ~71)
Price: ~$0.031 (up 6% this week)
24h Volume: $11M+
95% of supply already mined (scarcity incoming)
Retail is watching, but institutions and whales haven’t fully entered yet. Pure opportunity! 💎
Fresh data for you.
Post 4/6
Upcoming 2026 upgrades that will be game-changers:
Covenant Hardfork in MAY: Native assets + smart contracts on L1 (no messy L2 needed)
DagKnight: More speed & privacy
ZK bridges & hackathons like KaspPathon (prizes in KAS)
The roadmap is on fire. Kaspa isn’t hype, it’s execution. 🔥
Which upgrade are you most excited about?
Post 5/6
Strong community, 100% fair launch (no pre-mine or VC), and miners using the network for L2 sequencers like Igra Network (EVM compatible).
Truly decentralized, fast, and cheap. Perfect for DeFi, NFTs, and even real payments.
If you don’t have $KAS yet, it’s time to research. DYOR, but the momentum is here. 📈
Post 6/6
Bottom line: Kaspa is on CoinGecko’s radar for a reason. Undervalued, elite tech, massive upside for 2026.
All it needs is more eyes like ours.
Liked it? Like + RT to spread!
Follow for more crypto BR threads and reply with your thoughts on $KAS.
Let’s make this thing explode! 🚀 #Kaspa #KAS #Altcoins
Imagine this: you transfer 50,000 Kaspa straight from your Tangem to Bybit. The platform says the deposit might take a few minutes (or more, depending on confirmations)... but in reality, you get the incoming deposit notification in seconds, almost instantly. Then you check the network fee: a tiny 0.000099 KAS — worth about $0.000003168 USD (like three-thousandths of a cent!). Practically zero cost.And most people still haven’t realized it: the true realization of Satoshi Nakamoto’s vision happened on November 7, 2021. Not back on January 3, 2009. It was with Kaspa that peer-to-peer digital money — fast, cheap, and accessible to everyone — finally became reality in everyday use… even if some exchanges still add artificial delays for “security.”This is what we’re living right now. The network delivers in seconds, the fee disappears from your pocket.
Many of us don’t understand this code.
But let me explain what will happen to Kaspa’s price once it’s merged into Kaspa’s Layer 1.
The price could shoot to $10 in a microsecond.