peace and love

Joined December 2015
132 Photos and videos
jay zhou retweeted
De Assets is an L1-native asset platform, built on Kaspa's KCC20 standard (kaspanet.github.io/silverscr…) and inspired by Bitcoin's CAT20. We've built a single global order book. Orders live directly on-chain as UTXOs, owned by no platform; assets sit in covenants, with their spending rules enforced by L1 consensus. Alongside it, we built a browser extension and a web wallet, modeled on Bitcoin's partial-signing standard, BIP-174 (PSBT) so you can sign and spend against covenant dApps.github.com/kasmoslabs It's now live on TN10 for open technical testing: tn10.deassets.io Feedback: t.me/kasmos_official
8
28
75
2,922
jay zhou retweeted
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.
55
275
889
29,816
jay zhou retweeted
Tomorrow it's finally time for the first community hangout! Kaspa Under the Hood: Setting the Stage for vProgs Grab a beer, coffee, tea, or whatever keeps you going, and join us for the first regular Kaspa community hangout. We will start with a high-level presentation of the upcoming vProgs architecture and Kaspa’s next stages of development. Since the architecture is extensive, this first session is meant to set the stage for future deep dives. The presentation is meant to be accessible to people with different technical backgrounds. We will take things step by step, build up the necessary context, and gradually develop a shared understanding of Kaspa’s architecture, trade-offs, and long-term vision. After that, we will move into a relaxed open discussion where people can ask questions, share ideas, and talk about anything interesting: Kaspa, decentralized infrastructure, incentives, technology, philosophy, or the future of humanity. Bring your ideas and questions, grab a drink, and join the conversation! discord.com/events/599153230…
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.
21
173
550
20,213
jay zhou retweeted
How Kasmos builds a prediction market on Toccata hard fork It's not a server, database, or custodial wallet. It's a set of SilverScript covenants that your own wallet co-spends — rules enforced by every Kaspa node on every transaction. • CtfVault escrows KAS and splits it into YES NO tokens. Only the winner redeems. •YES/NO shares are bound to their own covenant ID. •Orders permissionless matching, all fully on-chain. The real trick: Toccata's covenants (KIP-17 KIP-20) let a script enforce where funds go and bind tokens to unbreakable rules — all enforced by consensus, with no operator. A prediction market is just those rules, running on-chain.
20
52
188
8,573
jay zhou retweeted
I’m super excited for Toccata. It could open the door to a whole new generation of Kaspa products: real-time, permissionless financial apps that are cheap enough to use at scale. I updated kaspaexplained.com to celebrate. Go on a Toccata-style easter egg hunt while learning how Kaspa works. Visit the site and let me know what you think! Cheers to everyone celebrating this, especially the devs involved: @michaelsuttonil @OriNewman @IzioDev @Max143672 @coderofstuff_ and others.
11
94
317
10,394
jay zhou retweeted
We're releasing a series of products for Kaspa's Toccata Era. First Up: Kasmos Wallet — a Covenant native wallet. The uncomfortable truth about Kaspa wallets today — they're one of two things: • P2PK wallets: send KAS, receive KAS • EVM wallets: bolted on for an L2 Not one of them can construct a covenant transaction. That's fine today. After June 30 it's a wall. Using a covenant app means a wallet has to construct the transaction. Input selection, sighash modes, co-spend, carriers, change, utxo continuation. A different discipline entirely. We've spent years on application-layer development in the Bitcoin. That's the experience that went into Kasmos Wallet. And we're putting the pattern in working code as a reference, so the whole ecosystem has something to build toward. It runs on testnet today. The day Toccata activates covenants on mainnet, it's ready.
13
50
164
7,052
jay zhou retweeted
Product Two. We’re building a full suite of covenant-native products on Kaspa. This one is a proven category. Will $KAS hit $0.2 this year? You can bet on it. Meet Auspice — a native prediction market based on Kaspa Toccata covenant. No custodians. No bridges. No L2. No extra token. Collateral sits in the market’s own covenant. Payouts are enforced by consensus, not promises. You trust code and covenants. Not us. Live end-to-end on TN10 today. Mainnet the moment covenants land. Read the signs. Trade the morrow.
28
146
526
33,463
jay zhou retweeted
In Bitcoin, Kaspa, and other transparent UTXO systems, anyone can independently verify the money supply from genesis. If an extra coin appears, consensus rules are violated and nodes reject it. In $zec's shielded pool, the amounts are hidden. Users rely on the zk circuit to guarantee that hidden inputs equal hidden outputs. The Orchard bug means that guarantee was NOT mathematically sound for years. The result is that nobody can now say with ABSOLUTE certainty: No extra ZEC were ever created, the circulating supply is exactly what it should be, and the shielded pool was never abused. In Kaspa's case every node verifies the network from first principles. The software starts with the genesis block and an empty UTXO set. During sync, peers provide the current pruning point header, the complete UTXO set at that point, and a compact Proof of Genesis linking that state back to genesis. Kaspa uses an incremental cryptographic accumulator called MuHash, allowing the UTXO commitment to be updated efficiently as the state changes instead of recomputing the entire hash from scratch for every block. The node verifies the proof, checks that the MuHash commitment in the pruning point header matches the supplied UTXO set, and then validates all blocks from the pruning point to the current tip. If the state were inconsistent, if extra coins had been created, or if consensus rules had ever been violated, validation would fail and the node would reject the chain. This is why the missing historical payloads have no impact on security. The UTXO set, issuance schedule, and block rewards are all enforced by consensus, so nothing economically significant can be hidden in the missing data. Any secret premine, inflation event, or abnormal early distribution would have to appear in the current UTXO set. If it did not reconcile with the consensus rules, every node would reject it. Likewise, the chain's accumulated proof of work remains preserved through the chain of posterity headers, allowing the historical growth of network security and hash rate to be verified. Don't trust, verify... Verify the proof: kaspa.org/?proof=1 Run the proof: github.com/kaspagang/kaspad-… $KAS $BTC
2
61
179
5,000
jay zhou retweeted
Replying to @KaspaSilver
soon. I finished implementing tie breaking in line with the paper. cc. @michaelsuttonil
4
17
92
1,675
jay zhou retweeted
so this kaspa toccata thing is out now ⚡, wow
64
273
1,103
19,581
jay zhou retweeted
**Official Toccata Release — Mainnet Hardfork Activation Included** (Links in reply) We’re excited to announce the official Kaspa release containing the **Toccata Hardfork** activation logic. Toccata is scheduled to activate on mainnet at DAA score `474,165,565`, expected around **June 30, 2026, 16:15 UTC**. This is a consensus-changing upgrade. All node operators, miners, pools, exchanges, indexers, wallets, and infrastructure providers must upgrade before activation to remain compatible with the network. Toccata introduces a major expansion of Kaspa L1 capabilities, including: • **Native L1 covenant support** through transaction introspection, allowing for more expressive contracts, including stateful contracts • **Covenant IDs**, providing stable covenant lineage across UTXO transitions, so covenant instances can preserve continuity as their state moves from one UTXO to the next • **ZK proof verification on L1** via `OpZkPrecompile`, enabling to trustlessly offload computation off-chain. • **Partitioned sequencing commitments**, improving support for based ZK applications by making lane-local proving scale with relevant activity rather than global throughput Please upgrade as soon as possible and verify your nodes are running the new release well before the activation DAA score. Thank you to everyone who contributed to designing, implementing, reviewing, and testing Toccata.
40
293
763
71,319
jay zhou retweeted
Kaspa Toccata mainnet process update: Today we plan to publish the v1.3.0 mainnet pre-release, without activation, for 1–2 days of broader network sanity testing. Assuming everything looks good, the following release will be v2.0.0, with activation planned for June 30, 4 weeks from today
72
464
1,426
116,901
jay zhou retweeted
4/ Transparency matters. KaSTip is open source: github.com/feciu/kastip-app Privacy policy: kastip.app/privacy Crypto users should be curious and cautious. That's a good thing. Install link is in bio / pinned post.
2
4
15
483
jay zhou retweeted
One cool thing about such simple contracts is that we can track their activity on the explorer as if they were a normal wallet address. This is because they have no state, so their script/lock always stays the same, no matter the amount of KAS they hold in the UTXO. I created another small app that calculates the contract address on mainnet or TN10. The contract you see in the app is the latest KasPot contract, you can also paste the contract below to compile an earlier version I toyed with and examine its activity on the tn10 explorer. P.S. The app uses a WASM compilation of the SilverScript compiler, so the source is compiled directly in the browser. Thanks Codex! p2sh.netlify.app/ Earlier prototype to paste into the app: pragma silverscript ^0.1.0; contract Faucet() { int constant CLAIM_COOLDOWN = 600; int constant MIN_FUND_AMOUNT = 1 kas; int constant MAX_CLAIM_AMOUNT = 1 kas; int constant MAX_MINER_FEE = 10 grains; int constant MAX_SPEND = MAX_CLAIM_AMOUNT MAX_MINER_FEE; int constant FAUCET_OUT_INDEX = 0; function selfPreserve() { byte[] selfScriptPubKey = tx.inputs[this.activeInputIndex].scriptPubKey; require(tx.outputs[FAUCET_OUT_INDEX].scriptPubKey == selfScriptPubKey); } entrypoint function fund() { selfPreserve(); int nextValue = tx.outputs[FAUCET_OUT_INDEX].value; int prevValue = tx.inputs[this.activeInputIndex].value; require(nextValue - prevValue >= MIN_FUND_AMOUNT); } entrypoint function spend() { require(this.age >= CLAIM_COOLDOWN); int prevValue = tx.inputs[this.activeInputIndex].value; bool allowEmptying = prevValue <= MAX_SPEND; if (!allowEmptying) { selfPreserve(); int nextValue = tx.outputs[FAUCET_OUT_INDEX].value; require(prevValue - nextValue <= MAX_SPEND); } } }

Did you know SilverScript can be used on mainnet? While most of it's powerful features depend on opcodes and features that Toccata would introduce, simple Silver contracts can already be compiled and used on mainnet. I created this faucet/vault example, a contract/UTXO that anyone can open, if - - they close it with more KAS than it had when opened (add funds), or - the pot has not been opened for at least X seconds, and only a small amount is taken out. It's like a wallet that doesn't belong to anyone, that can be filled up fast and drained slowly, and each interaction with it resets the timer (so theoretically, if someone funds it every few seconds, it would become impossible for anyone to take KAS out of it). I intentionally made it possible in the UI to try taking as much KAS out as you want, whenever you want, to show how the network itself validates the contract rules. You should experiment on TN10, but I also made it possible to interact with it on mainnet - use it with care if you choose to do so. Feel free to share questions, observations, or anything else. kaspot.netlify.app/
5
5
17
703
jay zhou retweeted
#MyKAI has about 50 nodes running on a daily base, of which 40ish nodes are running simultaneously. Keep spreading the word to help #Kaspa be really decentralized 🌎🌍🌏 And if you havent done so yet, give it a try & start running a MyKAI node yourself. Work for your $KAS 😜
#MyKAI Node 0.3.23 update🚀 🟢 1-click setup: clock, firewall, antivirus, external IP 🛡️ Inline AV walkthroughs (Bitdefender, Norton, Kaspersky ) 💻 Fresh Windows installs Just Work (VC bundled) 🔄 Self-healing kaspad supervisor 🌐 Outpeers 48→9, kinder to the #Kaspa network
4
27
143
4,323
jay zhou retweeted
I built OpenSilver because Kaspa’s covenant ecosystem is going to need more than theory. It is going to need open-source tooling, reusable patterns, public review, and a development surface that builders can actually understand without starting from zero every time. OpenSilver is an open-source toolkit for building covenant-based applications on Kaspa. For non-technical people, think of it like a public library of reusable “rules for money.” Instead of an app needing a company, custodian, or middleman to decide when funds move, a covenant can lock KAS inside a transaction with conditions attached. Funds can release after a deadline, require multiple approvals, stream over time, recover through backup keys, execute escrow logic, support swaps, or interact with verification systems. OpenSilver collects these kinds of patterns into one shared library so builders can use, inspect, improve, and standardize them in public. For developers, the important part is that OpenSilver is not trying to turn Kaspa into an Ethereum clone. It is built around Kaspa’s UTXO model and SilverScript covenant logic, meaning enforcement happens through transaction constraints rather than a global account-based smart contract VM. The repo includes patterns for ownership, multisig, timelocks, vaults, escrow, vesting, dead man switches, social recovery, HTLC-style atomic swaps, streaming payments, payroll and freelance flows, token-related KRC patterns, and early ZK-aware structures. The goal is to make Kaspa’s post-Toccata programmable surface easier to reason about, test, reuse, and integrate. The open-source angle is the real point. If Kaspa covenants are going to become serious infrastructure, developers need shared primitives, examples, manifests, CLI tooling, runtime checks, walkthroughs, and public review. Otherwise the ecosystem fragments into isolated scripts, duplicated logic, and avoidable security mistakes. OpenSilver gives builders a common foundation while letting the community audit the logic in the open before serious value depends on it. It is still early. These patterns are not externally audited yet, and some advanced ZK-facing pieces depend on upstream SilverScript and protocol maturity. But that is exactly why I built it in the open. OpenSilver is not just code. It is scaffolding for a native Kaspa application layer. github.com/trillskillz/OpenS…
24
77
231
7,005
jay zhou retweeted
🚀 Kasperia Wallet v1.10.81 is now live! What's new in this release: ✅ Support for TN10 fee upgrade (Mainnet is not affected) ✅ Support for KRC20 Payload Transfers ✅ Fixed EVM RPC fetch error issue ✅ Added Kaspa SignMessage support #kas #krc20 #kns
5
17
68
2,947
jay zhou retweeted
Update: Testnet 10 underwent the Toccata hardfork about 30mins ago and everything’s still running like clockwork. Transition was smooth and seamless. This seamlessness is the standard that kaspa devs set. It’s easy to take it for granted so I want to take this moment to recognize the effort and due diligence that went into making this happen @michaelsuttonil @OriNewman @Max143672 @IzioDev @FreshAir08 @manyfest_ @hus_qy (and sorry if I missed anyone) Mainnet HF soon
Here we go again: rehearsing a major hardfork on testnet 10, this time crescendoing into Toccata Activation is scheduled for tomorrow May 18, 16:00 UTC. Existing TN10 miners/operators should upgrade now. In a few hours upgraded p2p nodes will stop connecting to non-upgraded nodes as we enter the 24h pre-activation window. Let’s make the mainnet activation boring by making the TN10 rehearsal as mainnet-real-world as possible
44
230
718
35,346