Nusi

Brother I am begging you to delete this and never shit talk $KAS again without having some basic knowledge about $BTC first. You are referring to the block subsidy as the fees 🤦🏻‍♂️

Stablecoins on $KASPA will a game changer. You’re not ready!

@kaspabit @kuda_ch @michaelsuttonil I personally think that constraints drive innovation and the faster Kaspa needs to look for a viable economic model to displace shrinking block rewards, the earlier we can discuss the really interesting things like uPoW.

I wana test a theory Retweet for $KAS Like for $BTC

wrote an outlook for the upcoming “Toccata” hard fork -- native L1 covenants, based zk apps, why the activation window moved, and what the road from feature freeze to mainnet looks like: @michaelsuttonil/kaspa-covenants-toccata-hard-fork-outlook-a4d81a40900c" target="_blank" rel="nofollow noopener">medium.com/@michaelsutton…

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.

60+ Enterprises that could be disrupted by #Kaspa-enabled systems #28 - Artificial Intelligence & Machine Learning Legacy Standards (NA & Global) • OpenAI, Google DeepMind, Anthropic, Meta AI • AWS, Azure, Google Cloud for training and inference infrastructure • Centralized data pipelines and proprietary datasets • API based access to models with usage based billing • Internal logging systems for training, inference, and outputs Platforms & Systems • #AI models are trained and deployed within centralized environments • Data provenance and training inputs are not publicly verifiable • Inference outputs are generated without independent auditability • Compute coordination is managed by cloud providers • Access, pricing, and model behavior are controlled by platform owners What’s Broken / Innovation Gaps • Training data sources are opaque and difficult to verify • Model outputs cannot be independently audited or reproduced • Centralized control over model access and pricing • Weak proof of contribution for distributed compute or data providers • Lack of verifiable logs for inference events and decisions • Increasing reliance on a small number of infrastructure providers Where AI Systems Can Still Innovate and Where Kaspa Could Help ❌ Training data provenance is unclear Datasets are aggregated from multiple sources with limited transparency. ✅ Kaspa could anchor hashes of datasets and data ingestion events, creating timestamped proof of inclusion and origin without exposing raw data. ❌ Model training and updates are not publicly verifiable Changes to models are controlled internally by organizations. ✅ Kaspa could support anchoring of model version hashes and update events, allowing independent verification that a model has or has not changed over time. ❌ Inference outputs lack auditability Users receive results without a verifiable record of how or when outputs were generated. ✅ Kaspa’s globally ordered ledger may support anchoring inference events, creating a verifiable sequence of outputs tied to specific model states. ❌ Distributed compute lacks verifiable contribution Participants providing compute or data cannot always prove their role or contribution. ✅ Future covenant structures and vProgs may enable conditional reward logic tied to verifiable contribution proofs, supporting more transparent coordination of distributed AI workloads. ❌ AI decisions are difficult to audit across systems Logs are fragmented across providers and internal systems. ✅ Kaspa, strengthened by DagKnight, could provide a consistent ordering layer for critical AI events, enabling cross system audit trails that remain tamper resistant. ❌ Data integrity and external inputs are hard to validate AI systems rely on external data feeds that may be incomplete or manipulated. ✅ Oracles anchored to Kaspa could verify external data inputs through timestamped commitments, improving trust in upstream data used by models. ❌ Execution conditions are opaque There is limited visibility into how decisions or actions are triggered. ✅ SilverScript and covenant based logic may enable clearly defined, verifiable execution conditions for AI driven actions, where rules are transparent and enforceable at the settlement layer. Kaspa’s architecture does not replace AI systems or model development. It could provide a coordination and verification layer where data inputs, model updates, inference events, and contribution proofs are anchored in a globally ordered, tamper resistant ledger. The opportunity is not to move AI onto a blockchain. It is to strengthen trust, auditability, and coordination around systems that are becoming increasingly central to decision making across industries. Why This Matters Now AI is becoming infrastructure. Not just for users, but for systems, services, and entire industries. A growing share of “users” will be agents, models, and automated systems interacting with each other. These systems require coordination that is: • verifiable • ordered • globally consistent • accessible without central dependency Kaspa is positioning itself as a settlement and coordination layer that could support: • verifiable data flows • ordered model interactions • accountable decision trails • machine to machine value exchange Where This Becomes Real AI is expanding across: • finance • logistics • healthcare • energy • governance • autonomous systems These environments rely on systems that coordinate value, decisions, and interactions across boundaries. They benefit from infrastructure that supports: • trust through verification • consistent ordering of events • shared, tamper resistant records Kaspa could contribute to this layer as these systems evolve. The Call to Builders The next phase depends on development. There is a clear opportunity for: 🛠️ Developers 🧠 Researchers 🏗️ Infrastructure teams To build: • verifiable AI pipelines • data commitment layers • inference anchoring systems • covenant driven coordination logic • tools that connect AI systems to a globally ordered ledger The connection between AI systems and decentralized settlement layers is still emerging. This is where meaningful work can begin. The Shift AI will participate directly in digital infrastructure. In many cases, it will act as the primary user interacting with systems at machine speed. This introduces demand for environments that support: • high frequency interaction • deterministic ordering • global accessibility Kaspa is moving toward these capabilities. The opportunity is to help build the systems that make this usable in practice. #BuildonKaspa → protocol layer #BuildwithKaspa → application / integration layer #PoweredbyKaspa → user-facing outcome layer See more markets to be disrupted in link in thread

The anticipated covenants++ hard fork will not be May 5th but about a month later. No dates given are ever absolute. Much testing and research is always involved which can always push things back. Stay in tune with Kaspa Core developments via Telegram: t.me/kasparnd

The confirmation time problem has been unsolved since Bitcoin. $KAS is the first serious academic attempt to fix it at the protocol level 📊 DAG KNIGHT is the first parameterless consensus protocol ever built No hardcoded latency bound. Confirmation times adapt to real network conditions instead of worst case assumptions baked in at launch Every protocol before this had the same flaw. Set k too low and you're vulnerable. Set it too high and you're slow even when you don't need to be DAG KNIGHT fixes that: → Confirmations scale with actual network speed, not assumptions → Attacked or congested network = slower, but never broken → Minimum k selected dynamically, never predetermined → Self-stabilizes after 51% attacks without human intervention 🔧 Pass and Shi proved no responsive protocol can tolerate 50% byzantine corruption KNIGHT circumvents that by responding to adversarial latency rather than observable latency Most L1s compete on marketing. #KAS is competing on computer science 📈

7 MILLION $KAS RAISED IN 6 DAYS. While the entire crypto market is cooling off, $IGRA just raised over 7 million $KAS through the ZAP auction on @ZealousSwap. Someone dropped 500K $KAS in a single bid a few hours ago. 🔨 15 hours left. CEX listings on the horizon. Deep liquidity pools on DEXs incoming. Stablecoins imminent. @Tangem integration confirmed. 15+ teams building already on @Igra_Labs. Defi on Kaspa - the next era.

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

Meme Monday! 🙌🙌 Next, crypto monument goes to...

@CryptoEndeavr @hus_qy The upcoming one. L1 will support based standalone zk apps with canonical bridging, and Hans is building the complementary client/L1.5 for it

GM 👀 猜猜图里有多少个币种？

How many cryptos can you spot? 👀 Drop your count ↓ Get a ❤️ if you’re right.

Hey dapp devs, Igra Network has been merged into viem.sh. You can now `import { igra } from 'viem/chains' to get full chain config. Any dapp built with wagmi, RainbowKit, ConnectKit, or Reown AppKit can add Igra support without manual chain definitions. Chain ID 38833, iKAS native token, EIP-1559 enabled. github.com/wevm/viem/pull…

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/vprog…): 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/vprog…): 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/vprog…): 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/vprog…): 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/vprog…): 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/vprog…): 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/vprog…): 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/vprog…): 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 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

- @roll_bitcoin - Just put $1,100 into #Kaspa and $1,100 into #Bitcoin at the exact same time. This website will track performance over the next 5 years. Rollbitcoin-tracker.web.app

**SilverScript: The piece nobody is talking about** Everyone's focused on Kaspa's May 5 hardfork. Covenants, native assets, ZK verification. All valid. But the thing that determines whether any of this actually gets *built on* is SilverScript. And it's being slept on hard. Announced February 10 by Ori Newman, SilverScript is Kaspa's first high-level smart contract language. No external VMs. No shared global state like Ethereum's EVM. It compiles directly to native Kaspa Script. No bolt-on layer, no overhead, native opcodes all the way down. Here's the distinction most coverage misses. Newman described SilverScript as handling "contracts with local state (UTXO model)" - a complement and infrastructure layer for vProgs (shared state). That difference is massive. In Ethereum, every contract touches a global state that every other contract can read and modify. That's why reentrancy attacks exist. That's why the DAO hack happened. Billions drained from one fundamental design flaw. Kaspa eliminates the problem at the root. Every contract state lives inside individual UTXOs. Local state validation removes entire exploit classes before they can even exist. What can you build? Smart wallets with timelocks. Vaults with multi-stage authorization. Release schedules baked into transactions. Destination-restricted payments enforced at consensus. All without touching low-level scripting. And SilverScript is only half the picture. It handles local UTXO logic. vProgs handle shared state with ZK-verified off-chain execution. Two layers, designed to work together from the ground up. Bitcoin has argued about OP_CTV, a covenant opcode, for years. Nothing ships. Kaspa isn't debating. It's testing on Testnet-12 right now with a full language and compiler on top. Foundational infrastructure always appears quietly before ecosystem growth becomes visible. This is that moment. May 5 the testnet experiment becomes mainnet reality. The DAG is just getting started. 👁