The supply of $KAS will soon be fully circulating As soon as late 2026 👀 Dilution from miners is already minimal, but once every token has been mined, it will go to 0 completely Have you prepared your bags?

WarpCore on Kaspa TESTING UPDATE: The only and most comprehensive full stack banking / financial rails on an L1 PoW. We have completed the following tests: 286 transaction type tests to run using various scenarios: 1. ✅ CBDC Full Issuance Workflow Token registration → minting → reserve attestation → Islamic instruments 2. ✅ Multilateral Netting Cycle Multi-participant obligations → gross/net calculations → settlement 3. ✅ Credit Facility Lifecycle Draw → repay → exceed limits → full lifecycle management 4. ✅ Nostro/Vostro Account Operations Multi-currency positions → payments → funding → position reporting 5. ✅ Liquidity Pool Participation Contributions → withdrawals → returns → multi-participant pooling 6. ✅ FX Forward Trading Quote → forward rates → netting → PvP settlement → T 2 7. ✅ Multi-Currency Netting Parallel netting across EUR, USD, GBP currencies 8. ✅ Islamic Finance Instruments Murabaha (cost-plus) → Ijara (lease) → Musharaka (profit-share) → Sukuk (bonds) 9. ✅ Herstatt Risk Exposure Settlement risk monitoring → high/medium/low categorization 10. ✅ Concurrent Transactions Parallel settlement operations → fund conservation 11. ✅ T 2 Settlement Workflow Trade date → T 1 confirmation → T 2 execution 12. ✅ Batch Payment Processing 100-item batch → success rate tracking 13. ✅ Treasury Operations Multi-currency positions → USD equivalency → revaluation 14. ✅ Settlement Failure Recovery Failure → retry logic → recovery verification 15. ✅ End-to-End Cross-Layer Settlement CBDC mint → liquidity allocation → FX trading → netting → nostro settlement Transaction Scenarios Covered Payment Operations ✅ Single payments ✅ Batch payments (100 items) ✅ Multi-currency payments ✅ Concurrent transactions ✅ Failed payments with recovery Netting Operations ✅ Bilateral netting ✅ Multilateral netting (3 parties) ✅ Multi-currency netting ✅ Gross/net calculations ✅ Netting settlement Credit Operations ✅ Credit draw ✅ Credit repayment (partial, full) ✅ Exceeded limits ✅ Credit facility lifecycle ✅ Facility expiry FX Operations ✅ FX quotes (bid/ask spreads) ✅ Forward rates ✅ NDF fixing ✅ PvP settlement ✅ Settlement risk (Herstatt) ✅ T 2 workflows ✅ Multi-currency trading Liquidity Operations ✅ Pool contributions ✅ Pool withdrawals ✅ Share calculations ✅ Return distribution ✅ Multi-participant pooling CBDC Operations ✅ Token issuance ✅ Supply minting ✅ Supply burning ✅ Reserve attestation ✅ Murabaha financing ✅ Ijara leasing ✅ Musharaka partnerships ✅ Sukuk instruments Account Operations ✅ Nostro account management ✅ Vostro account tracking ✅ Multi-currency positions ✅ Balance updates ✅ Position reporting Risk Operations ✅ Herstatt settlement risk ✅ Risk categorization ✅ Exposure monitoring ✅ Risk recovery Cross-Layer Operations ✅ CBDC → Liquidity flow ✅ Liquidity → FX flow ✅ FX → Settlement flow ✅ End-to-end workflows All 286 tests executed sequentially Zero test failures 100% pass rate #kaspa #warpcore #xrp #kii #poweredbyKaspa

KASPA INDUSTRIAL INITIATIVE SET TO UNVEIL FLAGSHIP PROJECTS Kaspa Industrial Initiative (@KaspaKii) confirms the completion of its flagship ecosystem projects designed to run natively on the Kaspa (@kaspaunchained) Layer 1 blockchain. The development team is currently finalizing security hardening and migrating the infrastructure to enterprise-grade servers in preparation for a June launch. This deployment utilizes the high-performance DAG architecture of $KAS to support industrial-scale applications and upcoming unannounced network integrations.

Today Kii have completed our main flagship projects which will all be running directly on the L1. Now just the final security hardening and migration to enterprise servers. June is going to be a blast! And we have a few surprises in store! Kaspa is an incredible platform to develop on and is only going to get even better. #kaspa #thinkKaspa #KaspainEnterprise

#Crypto is shifting! The first decade was all about Layer 1, consensus, and infrastructure. Now? The real action is moving to the application layer. $KAS #kaspa 👀

PoPMobile Kaspa Miner Running on Android Compatible with rusty bridge to be fork ready. Details coming soon. Let’s go kaspa:native ! Follow for updates!

If you just woke up and saw $DOT @Polkadot hacked, here is what I found (long-read) THE SETUP Hyperbridge uses ISMP (Interoperability State Machine Protocol) to bridge Polkadot assets to Ethereum. The architecture: - EthereumHost - stores consensus state & commitments - HandlerV1 - verifies proofs, dispatches messages - Consensus Client - verifies BEEFY/GRANDPA proofs from Polkadot - TokenGateway - mints/burns wrapped assets (DOT, ARGN, MANTA, etc.) Two critical facts about the live config: 1) challengePeriod = 0 (no delay before state commitments become usable) 2) The consensus client (0xA0Ad0CfD02509321AA5968cD04A8E205Ce53669a) is UNVERIFIED - no public source code --- THE ATTACK (one atomic transaction) TX: etherscan.io/tx/0x240aeb9a8b… Attacker 0xC513E4f5D7a93A1Dd5B7C4D9f6cC2F52d2F1F8E7 deployed an exploit contract whose constructor executed this entire sequence: 1. Deploy sub-contract (0x31a165a956842aB783098641dB25C7a9067ca9AB) 2. Call run() on sub-contract 3. Sub-contract calls HandlerV1.handleConsensus() with a FORGED Polkadot consensus proof 4. The unverified consensus client accepts the forged proof 5. A malicious state commitment (containing attacker-controlled MMR root) gets stored in EthereumHost 6. Since challengePeriod = 0, the commitment is IMMEDIATELY usable, no fisherman dispute window 7. Sub-contract calls HandlerV1.handlePostRequests() with a crafted MMR proof referencing the just-stored malicious root 8. The MMR verification passes trivially, attacker controls BOTH the root and the proof 9. The forged ISMP message contains: action=ChangeAssetAdmin, source="POLKADOT-3367", newAdmin=sub-contract 10. TokenGateway checks request.source == "POLKADOT-3367" - PASSES (source was embedded in forged MMR leaf) 11. TokenGateway calls DOT.changeAdmin(sub-contract), sub-contract is now DOT admin 12. Sub-contract calls DOT.mint(1,000,000,000 DOT) 13. Sub-contract approves DEX router for max, swaps 1B DOT for 108.2 ETH via Uniswap V4 14. ETH flows back: sub-contract -> exploit contract -> attacker EOA All in one transaction. Gas cost: 0.000339 ETH. Profit: 108.2 ETH. --- WHY THE SOURCE CHECK FAILS TokenGateway's authorization for privileged actions like ChangeAssetAdmin: if (!request.source.equals(host.hyperbridge())) revert UnauthorizedAction(); This byte comparison is not a security boundary. It relies entirely on the integrity of the consensus proof upstream. The source field lives inside the MMR leaf, when the attacker controls the MMR root, they control every leaf, including the source field. The check becomes a tautology. --- ROOT CAUSE Two combined weaknesses: challengePeriod = 0: The challenge period is the only defense against forged consensus proofs. When it's zero, any fraudulent state commitment accepted by the consensus client is immediately exploitable in the same block. No fisherman window. No dispute mechanism. Plant and exploit in one tx. Unverified consensus client: The contract at 0xA0Ad0CfD02509321AA5968cD04A8E205Ce53669a has no public source code. Its verifyConsensus() accepted a forged BEEFY proof. Either a cryptographic bug, a deliberately weakened replacement, or a compromised signing key. --- SCOPE: NOT JUST DOT The attacker exploited multiple Hyperbridge-wrapped assets via the same vector: - DOT: 1B minted (~$1.78B face value) - ARGN (Argon): ~999B minted (~$1.03B face) - MANTA: 211K minted (partially captured by MEV bot) - CERE: ~23B minted (partially captured by MEV bot) All ERC6160Ext20 tokens managed by the same TokenGateway. Same forged ISMP message, different action payloads. --- ATTACKER PROFILE - 33-day-old wallet, seeded from a RAILGUN RelayAdapt contract (not a simple EOA) - Spent a month deploying 15 test contracts against live state - Used LI.FI/GasZip to bridge ETH across chains immediately after funding (obfuscation) - Pre-deployed custom zk-SNARK verification keys via RAILGUN 8.5 months before the exploit - Laundering confirmed via RAILGUN zk shielded pool, withdrawing in 15 ETH denominations to fresh exit wallets Months of preparation. --- FUND FLOW Primary swap: ~108.2 ETH ($237k) Secondary waves: ~4,924 ETH ($10.8k) Later stablecoin: ~$8k (WETH/USDC/USDT) Total extracted: ~$250kM EthereumHost is frozen (status=All). Attacker is laundering through RAILGUN. No bridge-out transactions observed yet. Exit wallet 0x43C291c59164e55E27326a719c4FD05a1b72F8b2 holds ~105 ETH from RAILGUN withdrawals. --- KEY ADDRESSES Attacker: etherscan.io/address/0xC513E… DOT Token: etherscan.io/address/0x8d010… TokenGateway: etherscan.io/address/0xFd413… EthereumHost: etherscan.io/address/0x792A6… Consensus Client (unverified): etherscan.io/address/0xA0Ad0… RAILGUN Exit Wallet: etherscan.io/address/0x43C29…

AI just got a wallet. And it talks. And it acts. On Kaspa. KANet.

Man it feels so good to be back working on $KAS, what a crazy alien technology. 🚀👽

The full vprogs vision of composable zk-based apps requires essentially 4 major building blocks: 1. You need a runtime that can efficiently drive state transitions. 2. You need a way to prove the activity of that runtime. 3. You need a way to settle those proofs on the L1 using covenants. 4. You need a "meta-program" that can invoke and orchestrate user-deployed guests for composability while enforcing certain constraints. We are currently working on step 3. which will already enable programmability but interactions between apps have to go through the L1. The full vprogs vision of synchronously composable based apps will only be achieved once we advance to step 4. It's hard to say how long things will take but so far it took a few weeks for each milestone so I would expect a similar rate of progress.

Before ❄️ FrostCard ships, we want it attacked. We’re looking for white-hat hackers and security researchers to help penetration test FrostCard. If you’re experienced in: • Hardware wallet security • NFC attacks • Side-channel analysis • Cryptographic review • Covenant logic & wallet security We want you. FrostCard is open-source, which means security doesn’t come from trust — it comes from verification. Try to break it. Audit the code. Attack the assumptions. If you succeed, you make FrostCard stronger for everyone. Security through transparency. Interested? Reach out. Tag the best Dev’s and Hackers you know! #Kaspa

“Tangem if it was fully open source” Built with Covenants — enabling: • Spending limits • Whitelists • Time locks • Recovery • And more Security shouldn’t be complicated. Frost Card Cold storage, re-engineered. ❄️ #Kaspa only. Target release May 31/2026

Okay, it's time for a little update: I just finished the work on the zero knowledge part of the vprogs framework, which introduces the ability to prove arbitrary computation. It consists of the following 8 PRs that gradually introduce the necessary features: 1. ZK-framework preparations (github.com/kaspanet/vprogs/p…): This PR cleans up the scheduler and storage layers, extends the build tooling with workspace-wide dependency checking, adds the ability to publish artifacts for transactions and batches (which will later hold the proofs), renames some core types for clarity, and introduces lifecycle events on the Processor trait that allow a VM to hook into key scheduler events like batch creation, commit, shutdown, and rollback. 2. Core Codec (github.com/kaspanet/vprogs/p…): This PR introduces a lightweight encoding library for ZK wire formats. In a zkVM guest, every byte operation contributes to the proof cost, so the codec is designed to reinterpret data in-place rather than copying it. It includes zero-copy binary decoding (Reader, Bits) and sorted-unique encoding for deterministic key ordering. It is built for no_std so it runs inside zkVM guests. 3. Core SMT (github.com/kaspanet/vprogs/p…): To prove state transitions, we need cryptographic state commitments. This PR adds a versioned Sparse Merkle Tree that produces a single root hash representing the entire state. It includes all state-of-the-art optimizations: shortcut leaves at higher tree levels to avoid full-depth paths for sparse regions, multi-proof compression that shares sibling hashes across multiple keys, and compact topology bit-packing to minimize proof size. It integrates into the existing storage and scheduler layers so that every batch commit updates the authenticated state root, while rollback and pruning maintain tree consistency. 4. ZK ABI (github.com/kaspanet/vprogs/p…): Defines the wire format for communication between the host and zkVM guest programs, establishing a universal language for proof composition. It specifies how inputs, outputs, and journals are structured for two levels of proving: the transaction processor, which proves individual transaction execution against a set of resources, and the batch processor, which aggregates transaction proofs and proves the resulting state root transition. Because the ABI is backend-agnostic and no_std compatible, any zkVM backend can directly use it (non-Rust zkVMs would need to reimplement the ABI in their language). 5. ZK Transaction Prover (github.com/kaspanet/vprogs/p…): Introduces the transaction proving worker, which receives serialized execution contexts via the ABI wire format and submits them to a backend-specific prover on a dedicated thread. The Backend trait abstracts the actual proof generation, so different zkVM backends can be swapped without changing the pipeline. 6. ZK Batch Prover (github.com/kaspanet/vprogs/p…): Introduces the batch proving worker, which collects the individual transaction proof artifacts, pairs them with an SMT proof covering the batch's resources, and submits the combined input to a backend-specific batch prover. The result is a single proof attesting to the entire batch's state root transition. Like the transaction prover, the Backend trait abstracts proof generation so different zkVM backends can be swapped without changing the pipeline. 7. ZK VM (github.com/kaspanet/vprogs/p…): Wires everything together by implementing the scheduler's Processor trait with ZK proving support. The VM hooks into the lifecycle events introduced in PR 1 to feed executed transactions into the transaction prover and batches into the batch prover. Proving is optional and configurable - it can be disabled entirely, run at the transaction level only, or run the full batch proving pipeline. 8. ZK Backend RISC0 (github.com/kaspanet/vprogs/p…): Provides the first concrete zkVM backend using risc0. It implements the transaction and batch Backend traits, includes two pre-compiled guest programs (one for transaction processing, one for batch aggregation), and ships with an integration test suite that verifies the full pipeline end-to-end - from transaction execution through batch proof generation to state root verification. TL;DR: While the early version of the framework focused on maximizing the parallelizability of execution, this feature focuses on extending this capability to maximizing the parallelizability of proof production. If you're a builder: this is the first version of the framework that lets you write guest programs with a Solana-like API (resources, instructions, program contexts) and have them proven in a zkVM. The current milestone uses a single hardcoded guest program - composability across multiple programs and bridging assets in and out of the L1 are part of the upcoming milestones, but if you're eager to start tinkering, the execution and proving pipeline is fully functional and provides a minimal environment to build and test guest logic today. Once we add user-deployed guests, they will move one logical layer down: the current transaction processor will become a hardcoded-circuit that handles invocation and access delegation to user programs, similar to how SUI handles programmable transactions (including linear type safety at the program boundary). In practice, this means guest programs will be invoked with a very similar API but scoped to a subset of resources, so the basic programming model won't change. Note that guests currently handle their own access authentication (e.g. signature checks) - the framework will eventually manage this automatically. If you want to contribute, two areas where community involvement would be especially impactful: - An Anchor-like DSL for writing guest programs -- the ABI is stable enough to build on, and a good developer experience layer would make this accessible to a much wider audience. - A second zkVM backend (e.g. SP1) - the Backend traits are designed for this, and a second implementation would prove out the abstraction. One thing I find particularly interesting in the context of PoW: the block hash provides an unpredictable, unbiasable random input that is revealed after transaction sequencing. This gives guest programs native access to on-chain randomness without oracles or additional infrastructure - something traditionally hard to achieve in smart contract platforms. PS: I am also planning to start with the promised regular hangouts but since I will visit my family over easter and want to get a better understanding of the open questions next week (it's good to have some problems to wrestle during that slower time 😅), I decided to start with that once I am back (12th of April). Generally speaking, is there a day that people would prefer for these hangouts? I guess monday would be bad as there is already another community event (write your preferences in the comments if you have a strong opinion).

WarpCore now provides comprehensive support for: 1. **Fedwire** (US Federal Reserve wire transfers) - all tests passed 2. **SEPA** (Single Euro Payments Area) - all tests passed All tests verify end-to-end payment processing, compliance screening, Kaspa blockdag settlement, and regulatory adherence for both global payment systems. **Status: ✅ READY FOR INTEGRATION WITH FED/SEPA TEST ENVIRONMENTS** --- #kaspa #warpcore

KAS is quietly setting up… and most people are not paying attention 👀 In about 12 days, block rewards drop to 2.91 KAS. That means fewer new coins entering circulation — a slow but powerful supply squeeze over time. Now look at the activity 👇 Over 2.5 million transactions in just 1 hour Total transactions just passed 1.17 BILLION That’s 50 million in only 2 days This is not normal growth — this is acceleration. TPS has cooled from the crazy 1,400 peaks, but it’s still holding around ~700 average. That’s not weakness — that’s the network stabilizing at a very high level. And the pattern is clear: quiet periods → sudden spikes → repeat 👉 That usually means real demand waves, not artificial activity. Now the most important part — the ecosystem 🧩 • Igra L2 → 311 (new all-time high) • Kasia → 213 (strong and consistent) • Kasplex → 110 (back in form) That’s 634 combined activity from just 3 players. Igra is the real surprise — from almost nothing to the top in under 3 weeks. Kasia keeps delivering daily. Kasplex is recovering and holding strong. 👉 This is what a healthy network looks like — not one project carrying everything, but multiple pillars growing together. Market side is still calm: Price: $0.037 ( 6.2%) Market Cap: $1B Rank: #56 Nothing explosive yet… but fundamentals are heating up fast. 🧠 KAS is no longer in the “idea phase” It’s entering the usage phase More transactions. Stronger ecosystem. New leaders emerging. Supply reducing soon. 👉 This kind of setup usually happens before big moves — not after. Right now, KAS isn’t just growing… it’s learning how to sustain growth. And that’s where real strength begins 🔥

When the coming ‘Iranian Cyber Attack’, takes out our cyber infrastructure, I want you to remember who was actually behind it.

My greatest fear is they'll use a false flag on the U.S. financial system (SWIFT) as the excuse to topple Iran. There's clearly a problem in the system with REPO exploding higher just like 2019 & 2008. They need an excuse to bail out the banks again & introduce a CBDC.