兰精灵

Hello September, may the wind of this month bring a little new good luck.
$BNB $BTC $SOL
The busyness of August gradually fades away,
and starting in September, the days slowly grow quieter.

No need to rush to chase after something,
and no need to force yourself to have answers every day.
Have a drink you like,
watch the evening wind once,
and let your mood take some time to settle.

This month,
may we all be able to hold our pace,
in the small, everyday moments,
slowly accumulate the light that belongs to us.

Dew covers the morning-glory vines,
when flowers bloom, sometimes rising and falling unpredictably 🌿
All things in the world have their cycles;
wait quietly for the moment—what has settled will bloom.
$BNB $SOL $BTC

This is how the ride-hailing app is often like: they give you an estimated price to mentally prepare you, and then the final bill is calculated by the actual mileage. The same goes for the Gas fee of @Dusk — the cost is simply `gas_used × gas_price`. Gas price is denominated in LUX, and 1 DUSK equals 1 billion LUX. Unused gas doesn’t get charged, but if Gas runs out mid-transaction, the entire operation gets rolled back, and you’re still billed for the calculations that ran earlier. At first, I also thought this setup was a trap. Later I figured it out: if a failure were completely free, hackers could endlessly trigger complex error calls to make nodes waste work—now *that* would be the real trap.

So every time I confirm a transaction, I check three things separately: whether the Gas limit is enough to run the entire process, whether the Gas price is reasonable, and whether the call target and parameters were filled in correctly. If it fails, don’t rush to resubmit—first use the official browser to verify the type, the fee, the amount used, and the location of the error. Naively doubling the limit just feeds more fuel to the wrong contract; it doesn’t really solve the problem.

The flow of fees is also pretty interesting. Each block’s reward consists of a newly issued $DUSK plus transaction fees, which are distributed to the block producer, the development fund, and the council; the portion that isn’t allocated may be burned. When the network is busy, the fee goes into validator incentives—but that doesn’t mean you can just hold coins and earn passive dividends.

What really made me stop and look closely is privacy. Dusk doesn’t hide *all* transactions; instead, it does selective disclosure. When compliant, it can prove that the necessary information is provided, without putting every detail out on the public chain. XSC, DuskEVM, and Citadel’s identity framework together feel more grounded in real financial scenarios than just loudly calling it a privacy chain.

The Citadel 2 process has four steps: the License Provider performs an offline review and issues encrypted credentials; the user generates a zero-knowledge proof, revealing only that they hold valid credentials; after the contract verifies it, a public session is left behind; then the service decides whether to grant access. On-chain, it only proves that the session is valid—regardless of which organization trusts whom, what attributes are needed, or whether the credential has expired. The same identity material doesn’t have to be stored repeatedly across every platform; the risk shifts from data duplication to the issuer’s governance and revocation synchronization.

Before using Dusk, figure out the Gas first—you can save yourself from a few rounds of paying “error tuition.” Whether it works still depends on the transaction result, and whether value can continuously flow into DUSK requires further observation of the network’s real usage and supply rhythm. #dusk $DUSK

I’ve been watching @Dusk lately, and the more I look at it, the more interesting it feels.

First, let me talk about the transaction lifecycle that really hooked me. At the beginning, I was also misled by the idea of deterministic finality. I spent days reading docs before I realized that “confirmed” and “finalized” are completely different. If a block hasn’t reached the last step, it can still revert. The process goes like this: a provisioner first proposes a candidate block, then a random committee validates it, then a second set of ratifications comes in—only after ratification is it actually settled. It’s not that once it’s proposed you’re doomed, but after it’s finalized you no longer need to keep stacking confirmation counts.

If it’s just a normal transfer, fine—but with exchange deposits or securities settlement, you can’t play like this. Hearing “executed” only means it executed; you still have to confirm the error field is empty. Only the “finalized” event counts as solid. If you receive a “reverted,” then you have to listen again. A contract revert is a code error, while a block revert means consensus changed—those two recovery logics are totally different directions. If an integration party treats “confirmed” as “final,” deterministic finality can fail at the application layer. What I care about most right now is whether exchanges and Dusk Trade both use “finalized” as the boundary, and whether there’s an auditable replay process.

Next, let’s talk about fair trading—this genuinely made me sick. The mempool is like a glass room with no curtains: whatever you want to buy is visible to the entire network, and clipper/robot traders can pounce at any time. $DUSK enables private batch auctions directly at the protocol layer: the bid and quantity are submitted in a way that gets sealed with ZK instantly. Nodes then compute a fair price by estimating that the gap between hidden total buy demand and total sell supply is close to zero; then within the same block, all listed orders settle at that price. Information asymmetry gets exposed—fairness isn’t just on the surface; it’s fair at its core.

Compliance is also not being handled loosely. Phoenix uses ZK for privacy, Moonlight uses a transparent ledger, Citadel supports selective disclosure, and XSC writes credentials, restrictions, and reports directly into contract logic. You shouldn’t have to rely on rules outside the chain.

The more complex the product gets, the more rules there are. Whether it can run reliably together across all kinds of workflows is the part I’ll keep watching. Real finality isn’t a buzzword: it’s when node events propagate to the ledger without anyone racing ahead in the middle. #dusk $DUSK

Last night I went through the documents for @Dusk again, and to be honest, it made me feel a bit conflicted.

On one hand, they say they’re in the privacy space. Phoenix’s UTXO-based setup with zero-knowledge proofs is indeed hardcore, and the transfer information is tightly sealed. But then they turn around and do a DuskEVM-compatible Solidity layer, clearly aiming to capture Ethereum developer traffic. Even the official documentation says that the account model and UTXO are fundamentally not the same “species” when it comes to privacy. Full compatibility means sacrificing anonymity. So it’s awkward: building with EVM tooling is very smooth, but privacy is left half-baked. If you really want auditable privacy, you then have to bite into the threshold of the native environment—which makes it genuinely uncomfortable sitting in the middle.

The node side is even more tangled. Under the Succinct Attestation consensus, staking 1000 DUSK lets you serve as a Provisioner. The threshold looks quite friendly, so ordinary people can try it too. But if you look further up, the real value exit—RWA channels, NPEX licensing, and compliant identity verification—everything is held by institutions. The base layer is permissionless PoS, and the top layer is a permissioned club. In this kind of architecture, I still can’t figure out how the token captures value.

And that native issuance—its ambition is genuinely huge. It doesn’t just want to issue a token. It wants to pack the whitelist, view keys, controlled transfers, and settlement delivery into a single state machine. In an ideal world, private placement securities wouldn’t need off-chain ledgers. But the problem is legal enforceability and custodial recognition—no matter how elegantly it runs on-chain, it can’t replace those things.

To be frank, Phoenix’s selective disclosure, Moonlight’s dual-model switching, and Citadel’s certificate issuance logic are indeed cleverly designed. But in actual user experience, the complexity isn’t low, and regular users will likely be discouraged. I’ll admit that there’s room for the compliance narrative under Europe’s MiCA, but whether the technical advantages can translate into on-chain vitality still depends on whether the ecosystem can truly get running.

I’ll keep watching, but before real money goes in, these thorny logics have to be straightened out first. #dusk $DUSK

After running tests for half a year, I’ve gotten used to first digging into the propagation layer for blockchains. I hit a trap recently: the node’s bandwidth suddenly maxed out, and the alert emails filled up an entire screen. At first I thought it was because the transaction volume spiked too hard—after digging through the logs I realized the underlying default behavior is that the whole network keeps getting a full broadcast “drip feed.” Once the node jitters a bit, repeated messages get pushed through relentlessly, like traffic jams.

Later I looked through document @Dusk and found the Kadcast section—I really paused there for a while. It doesn’t use blind flooding. Instead, it builds on the Kademlia topology: it uses the XOR distance computed from the hash of node identity, and groups peers into different routing buckets. When broadcasting, it no longer sprays packets indiscriminately; it pushes messages in an ordered, distance-layered way, turning full-network synchronization into a structured multicast tree. In my local tests, the bandwidth peak was clearly suppressed, and after messages go through multiple hops, it becomes much harder for outsiders to infer the initiator purely from traffic patterns. The whitepaper claims it saves 25%–50% bandwidth compared to traditional Gossip—I’ll treat that as a reference. In practice, though, when nodes frequently go online and offline, jitter across regions, and routing table refresh lags, all of that stacks together, so the actual savings will almost certainly be discounted. Pairing with BitVM3 as a verification fallback means there’s no chance to get into the door for non-compliant transactions either. The underlying idea is similar to the staking-layer logic: bolt the rules into cryptography.

However, relying heavily on logical topology also has a cost. If you run into cross-country partitioning, or a malicious node injects dirty data into routing buckets, then when switching to alternate paths, the addressing/search cost can quickly wipe out any latency advantage. Controllable bandwidth is definitely a good thing: ordinary stakers don’t need to rent dedicated lines, and the threshold drops a notch. But troubleshooting is more complex than with traditional broadcasting, so you need to have it in mind.

I also stepped into a pit with cross-chain. Moving from the mainnet to BSC isn’t a simple “move.” You have to transfer the native DUSK to the official bridge account. After the mainnet locks the verification, you generate a BEP20 token according to the BSC address specified in the Memo. The amount must be greater than 1 DUSK. The fee is the mainnet transaction fee plus a 1 DUSK bridge fee. It usually takes about an hour to arrive; in reality, the received amount is the sent amount minus 1.

Kadcast uses mathematical distance to mitigate redundancy and provenance-reconstruction risks, but in the public-network environment where nodes come and go, whether routing table updates are fast enough and whether the alternate pool is thick enough—that’s the real thing you need to watch. If it runs smoothly, it’s a pragmatic upgrade; if it doesn’t, it’s just a paper façade. $DUSK #dusk $DUSK

I’ve been keeping an eye on RWA lately—honestly, the more I watch it, the more anxious I get. On the asset tokenization on-chain front, there’s no shortage of technical solutions: one idea leads to another. But the moment you ask institutions to actually move real-world assets—houses, bonds, stocks—onto a public blockchain, try it out and see. Public chains are as transparent as glass houses; every business secret is laid bare. Who would dare? Meanwhile, privacy chains are so opaque that regulators can’t even get close to the door. I looked around and found that @Dusk hasn’t taken sides—directly baking privacy and compliance into the underlying layer. That approach is kind of interesting.

I went digging into its tech stack on purpose. The Succinct Attestation consensus runs with a random committee doing the work; fork rollbacks are basically a non-starter. DuskEVM is Ethereum-compatible—I ran a small demo with Solidity, and the privacy features were included right out of the box. The Hedger protocol’s auditable privacy left me staring for a while: everything is locked down in terms of details, yet when it comes to compliance, it can produce verifiable proofs. That trick is pretty brilliant. Moonlight and Phoenix provide two transaction models in parallel—different needs, different options. I also checked the NPEX plan to tokenize more than 300 million euros in securities onto the chain; I’ll have to watch how they roll it out.

But honestly, there’s one question that keeps hanging over me: who ultimately holds the key that can unlock all privacy? That directly determines whether it’s truly freedom—or just another form of control. I did some back-of-the-envelope math: continuous token issuance and the token-locking structure suppress momentum; if EU regulation shifts, the narrative could get completely washed away. The secondary liquidity of the first batch of assets and the ZK costs still have to be validated in practice.

Recently, a lot of people were fooled by claims of 2.8 ms on-chain verification—I almost believed it too. PLONK does push verification to the limit, but that’s “light on-chain, heavy off-chain.” I ran Citadel identity circuits locally: with a single license you get over 30,000 constraints, the prover took a full 16 seconds, while the verifier only needed 0.007 seconds. The computational overhead of ZK is roughly ten thousand times the cost of the original computation—the pressure is basically dumped onto local devices.

I’m the type who likes to verify things myself; I don’t look at the head and judge from the code’s reputation. Dusk’s path is hard but correct—yet getting from technology to real-world deployment still depends on regulatory battles and market acceptance. For now, my focus is just two things: how the key is managed, and the real transaction volume after tokenizing 300 million euros’ worth of assets on-chain. As for everything else, I’ll wait until I finish running the tests before talking. #dusk $DUSK

Last night I read the @Dusk whitepaper. Honestly, I started out with a nitpicking mindset, but the more I read, the more I felt this project is a bit stubborn.

Let me start with the gripes: the whitepaper is ridiculously hardcore—full of cryptography academic jargon. It reads like a financial engineering paper, and I almost gave up halfway through. The ecosystem push is also slow. While others post collaborations every day, they quietly work on the mainnet and the XSC standards with little external noise. Token and community are even more laid-back—there’s no hype for a pump.

After venting on those three points, though, I’m actually more willing to observe it long-term. Because financial infrastructure was never something you can run on hype alone. Institutions want stability and compliance.

But technically, there really is something: Dusk has natively built PLONK zk-SNARK and Bulletproofs into the protocol layer. Privacy isn’t a DApp add-on—it’s a built-in property of the chain itself. Pair that with Citadel ZK-KYC: when users complete identity verification, they don’t need to upload raw data like passports; instead, they only submit a zero-knowledge proof that has already passed compliance checks. This directly targets institutional-grade RWA and security token scenarios—needing compliance, while not exposing holdings and strategies entirely on the public ledger.

Of course, there have been issues too. OtterSec once found a verifier vulnerability in dusk-plonk, where a malicious prover could potentially forge a proof. The good news is that the team later used AEGIS to lock fees, refunds, and address consistency across both the mempool and the VM boundaries, and added targeted regression tests. The lesson is real: even if a zero-knowledge proof holds, it doesn’t automatically mean the surrounding transaction data is secure.

So now, when I look at $DUSK , it feels more like I’m observing a path that genuinely wants to build privacy-preserving financial settlement. Slow isn’t a problem—the key is whether the underlying layer and security can hold up to institutional needs. $DUSK #dusk $DUSK

Recently I chatted with friends about DeFi, and the biggest complaint everyone had is variable interest rates. It looks great—once you deposit, the rate can change anytime, and you can’t really tell how much you’ll earn six months from now. I got tired of the whole hassle, so I started looking for fixed-rate options, and then I came across @TermMax .

First, let me explain the mechanism: it splits lending and borrowing into three parts—FT, XT, and GT. FT is similar to a zero-coupon bond: it’s bought at a discount and redeemed at face value at maturity, so lenders profit from the price difference. GT is a position in NFT form that records collateral and debt. XT works in conjunction with maintaining balance.

Borrowers mint GT and FT by locking collateral assets, sell the FT to obtain funds, and then repay the debt at maturity to redeem the collateral. On top of that, there are Range Orders: by using a pricing curve, the interest-rate range is written into the mechanism. In theory, this can generate an on-chain yield curve.

Then the points I care about: the automatic rollover feature is very useful. After maturity, it finds a new interest rate through a Dutch auction; keepers execute it, so you don’t have to do manual operations. But whether the system is truly stable depends on whether the keeper set is sufficiently decentralized—the actual data matters most: how many keepers are active, and the execution coverage/ratio. Those are the real safety cushion.

Of course, there are concerns too. The cost of fixed interest is reduced flexibility. If you want to exit mid-term, you can only sell the FT in the secondary market, and the price will fluctuate. Also, if the collateral is volatile, the amount you receive at maturity may not be stablecoins.

So my own strategy is to prioritize mainstream assets and markets with conservative collateral ratios. If the yield is too high, I treat it first as a risk premium.

I do recognize the direction of #TermMax —DeFi really has lacked deterministic returns for a long time. But whether it actually works out depends on real borrowing demand and liquidity. I’ll keep observing for now and see before deciding further, especially once real usage grows.

What do you think is the biggest reason fixed interest rates are hard to push on-chain?

I re-read the @Dusk whitepaper last night, and when I got to the page about the “dual VM architecture,” I got stuck.

Let’s start with the architecture. Piecrust is a native zero-knowledge virtual machine based on WASM, with settlement compressed down to 2–3 seconds. DuskEVM is compatible with Solidity, so Hardhat and MetaMask can connect directly and run it; privacy is filled in at the underlying ZK layer through Hedger’s adjustments. The dual-track design is definitely thoughtful—one pipeline handles privacy contracts, the other handles compatibility, each doing its own job.

But the further I read, the more something felt off. Piecrust developed its own VM. This March, the AEGIS audit uncovered 39 issues: 7 classified as severe, and two critical vulnerabilities were tied to the sandbox layer. Even honest nodes running the same code could end up with inconsistent results. Malicious contracts could push the runtime into a state where ownership guarantees no longer hold. If the sandbox is breached, the entire top-layer confidential contract is basically finished. DuskEVM itself only supports public transactions, and privacy is covered only through additional modules. With two separate VMs fighting independently, the codebase size and attack surface effectively double.

Next, let’s look at the partnerships. NPEX, Chainlink, Cordial, Quantoz, 21X—on the official site it says €300M+ confirmed issuance, 50K+ investor reach, and 210M+ DUSK staked. The resources are indeed more solid than projects that only talk about RWA stories. But even the official team admits that tokenization can reduce friction—it can’t create buyers, sellers, and market depth on its own. Dusk Trade is still “Building/Waitlist,” and both DuskEVM and Hedger are also still on Testnet. The partnership list shows they’re willing to work together, but when it’s truly running, what matters is hard metrics like the amount of assets actually moving on-chain, number of traders, and secondary-market depth.

Finally, let’s talk about how compliance and privacy connect. At issuance, Zedger builds whitelists, single-identity single-account rules, and explicit recipient approvals into the protocol. Transfers are split into two steps, and if it times out, it’s automatically voided. Phoenix uses a UTXO architecture: funds are stored as encrypted notes, and during transactions the ZK simultaneously verifies five things. Pedersen Commitments hide both the amount and the address. DuskDS confirms in three phases, and once the block is produced, it’s final. Whether the rules can occur, which parts of Phoenix are required not to be public, and which state counts as valid under DuskDS—these three links cover the same bottleneck: securities from issuance to settlement, aiming not to retreat off-chain to coordinate again.

The partnership roster is already quite “financial-institution” shaped. In the next stage, I’d rather see real migration and deal data—stop staying stuck in PPTs. #dusk $DUSK

I used to think fixed-rate lending was a fake demand. Just look at the volatility in the crypto space—who isn’t chasing short-term gains by taking variable rates? At most, people occasionally set up a hedge, so there’s really no need to lock in rates. So when @TermMax first launched, I even told my friend that within half a year it would definitely pivot.

But recently I reviewed the data: on Token Terminal, its daily active users have been steady at around 4,000, which is higher than Morpho’s roughly 3,700. That’s what made me take the documentation seriously.

Once I dug in, I realized it’s essentially a “lending AMM.” It borrows the idea from Uniswap V3 and splits fixed rates using three tokens. FT is like a zero-coupon bond: it’s redeemed 1:1 at maturity. XT works together with FT: 1 FT plus 1 XT always corresponds to 1 debt token; at maturity, XT goes to zero. GT is an NFT that records each loan’s collateral and debt. Borrowers lock their collateral into GT, mint FT based on the maximum loan-to-value ratio, then sell the FT for cash. Lenders buy FT at a discount, and at maturity redeem at face value to profit from the spread.

Liquidations are even more straightforward: if LTV goes over the threshold or the loan isn’t repaid by maturity, within a two-hour window, liquidators receive a 5% reward, and borrowers are hit with a further 10% penalty. If nobody liquidates, then it settles via physical delivery—the collateral is handed directly to the lender, with no robot swooping in to steal the liquidations.

The problem of interest-rate jumps seems to be fixed, but the risks didn’t disappear: collateral prices still swing wildly, and secondary-market liquidity remains a concern. Range Order lets market makers post segmented interest rates themselves; the pool follows a constant product model, so the deeper the borrowing, the more the rate spikes. Cold-starting is really hard—without retail LPs to hold things up, it all depends on professionals propping up the quotes.

Now look at TMX. Don’t just stare at TVL. Focus on the trading depth of FT with the same maturity, the lending price spread, and whether people are concentratedly bailing before maturity. Those are the real signals. Whether fixed-rate can truly survive depends on whether people are willing to borrow at that price with real money—consistently. #TermMax

$DUSK #dusk To be honest, I’m researching a new project. My habit is to first check who it’s tied to—not the kind of “official announcement” partnership, but a proper equity-based linkage. So after @Dusk , the first thing I looked at was its relationship with Dutch NPEX.

This isn’t just signing a memorandum—it’s real money buying shares. Dusk got about 10% equity in NPEX back in 2020, directly making it into the shareholder registry. The weight of that is far more than a dozen cooperation announcements. Contracts can be torn up, but equity rises and falls together. NPEX holds three AFM-regulated licenses: the MTF, the broker-dealer, and ECSP. They’ve helped small and medium-sized enterprises raise more than €200 million, with 17,000+ active investors—this is a legit veteran operation. If the real economy is willing to treat Dusk as its underlying layer, that’s the biggest endorsement.

That said, if we’re being real: 10% is still far from control. The licenses are in their hands, and the main net isn’t fully deployed yet. The official statement is blunt: Tokenization can reduce friction, but it can’t conjure up buyers and fair prices out of thin air. The issuance size is now over €300 million and covers 50,000+ investors—data looks solid. But Dusk Trade is still under construction, and both the EVM and Hedger are still testnets. The real crux is: after the assets are on-chain, who provides buy-side demand, who does price discovery, and do disputes get resolved on-chain or in court? If it relies heavily on NPEX and a custodian bank, then how much of the middle layer is actually being removed?

The official side admits that Tokenization ≠ Liquidity—at least it’s honest. Next, I’ll focus on the trades, holders, and turnover rate after the first batch of assets goes live. That’s the real acceptance test.

Finally, a reminder: same-name DUSK—mainnet has 9 decimal places; ERC20/BEP20 has 18. The mainnet uses LUX for accounting, where 1 DUSK = 1 billion LUX. During cross-chain migration, the wallet and system must correctly recognize the chain and standard; otherwise the balance may look right but be off by orders of magnitude. The documentation points to the mainnet migration guide, and the ecosystem should keep these fields consistent with the asset presentation—don’t make users guess.

When judging a project, I still look first at the depth of the binding and whether execution lands, and only then at the technical details. $DUSK

I’ve been following TermMax for quite a while. To be honest, it’s rare to find an on-chain project that lets me claim every day and keep staking without missing a single day—this is the first one. The TGE is on the 25th, and I’m a little excited. I also want to chat with the brothers about how this project really is.

What it’s doing is decentralized fixed-rate lending. The gameplay is pretty interesting. Simply put, it splits a loan into two tokens: FT and XT. FT is like a zero-coupon bond—you buy it at a discount, redeem it for face value at maturity, and the yield is locked in from the start. XT, on the other hand, is a yield token. When the borrower receives the loan, they also receive XT, which they can sell right away to get liquidity—so the cost is fixed in advance. One FT plus one XT equals one debt token, and the principal and interest are separated “in a physical sense.” There’s also GT, which is more practical: a leveraged NFT that wraps collateral and debt. In the past, those repetitive loop lending strategies had crazy gas fees and were a hassle, but now you can handle it in one click, and position management is much more straightforward.

FT handles fixed yield, XT handles interest realization, and GT handles leverage—each does its own job. I think the strongest part is that it turns the interest rate itself into a tradable asset, not some hard-simulated fixed-rate mechanism. The logic is honestly pretty clear.

The project launched on the mainnet last year, covering both Ethereum and BNB Chain. Its peak TVL has been over 71 million. It has more than a million users. This year, in January it also supported using Ondo tokenized stocks as collateral, and in March V2 solved the problem of liquidity fragmentation. The data has stayed fairly stable. Fixed-rate lending isn’t new, but TermMax’s engineering execution and user experience are indeed solid.

Now there’s also the Booster activity going on: spend 2 Alpha points to draw TMX. The token price before the listing is around 0.18 U. I roughly calculated the MP points—early entrants should have decent returns, but the pre-listing price feels a bit inflated. After it launches, volatility is definitely coming. Whether the prize pool will give everything out is still hard to say. Personally, I’m still planning to keep following it—after all, I’ve stuck with it for this long. The fixed-rate lending track isn’t easy to find, and whether future pricing and arbitrage will introduce more complexity… we can only see as we go. @TermMax #TermMax

#dusk Many people discuss public chains, and the first thing out of their mouths is TPS, as if higher benchmark numbers mean everything. But when I read the @Dusk whitepaper, I noticed an interesting detail: they explain the Kadcast network protocol before the consensus mechanism.

At first I didn’t pay much attention, but then I thought it through. If candidate blocks, transactions, and votes can’t be transmitted, or they’re transmitted too slowly, then even if the committee is selected correctly afterward, forks or repeated verification may still happen due to information being out of sync—so all the effort beforehand would be wasted.

The traditional Gossip protocol is like shouting at people on the street: messages get repeated everywhere, and bandwidth is wasted on redundancy. Kadcast borrows the XOR distance and routing table from Kademlia, turning propagation into a structured multicast tree. Messages move hop by hop along predesigned routes—clean and efficient. The whitepaper cites research claiming it can save 25% to 50% of bandwidth, and also reduce the stale block rate by 10% to 30%. Of course, these are research results, not real-world measurements in all scenarios, but for financial chains, delays of a few seconds may cause different nodes to see different candidate blocks, affecting transaction finality.

Structured routing also has another advantage: it makes it harder for outsiders to directly trace the source of messages, designing privacy and efficiency together.

The most troublesome part of on-chain finance is the tension between transparency and privacy. With full transparency, institutions won’t touch it; with full privacy, regulators are watching closely. The $DUSK XSC standard uses PLONK zero-knowledge proofs to separate the validity of transactions from the details. Default amounts and counterparties are kept confidential, and when regulators need it, they use a viewing key for selective disclosure. You can prove compliance without having to show all your cards.

The mainnet is already running, and DuskEVM is also being advanced. Collaboration with the Netherlands-licensed exchange NPEX is also moving real-world assets onto the chain. The technical direction is very clear, but there are indeed pressures on token circulation and changes in liquidity, and sometimes the market price and fundamentals can be out of sync.

The path for compliant RWA is still long. The key is whether permission management and real-world deployment can keep up with regulatory requirements across different regions. The networking layer has never been a side character—privacy and compliance can’t be a choice between one or the other; you have to get both. $DUSK

I don’t want to get out of bed for work, and why did I wake up too early even when I was trying to rest?!
$BTC $SOL

Yesterday I saw @TermMax on my feed, and the very first image that popped into my head was: Finally, someone has taken the wild mustang of DeFi lending and put a bridle on it.

Why did it feel like that? Because a couple of years ago I played with leverage on Aave and Compound, and got burned by floating rates way too many times. When the market blew up, borrowing costs doubled immediately—wiping out all the room for profit, and liquidations were happening in the most inexplicable way. Back then I kept thinking: in traditional finance, fixed income and interest-rate locking are basic common sense—so why is nobody doing it on-chain?

So when I saw TermMax, my first reaction was to dig into their whitepaper and the team background. Founder Jerry Li, a former MD from Deutsche Bank, spent most of his career in fixed income. In his view, interest rates are never just random numbers like “5% today, 15% tomorrow”—they’re tools that can be agreed upon in advance, traded, and hedged. That logic has worked in traditional bond markets for decades; when brought into DeFi, it solves exactly the problem that borrowers can’t accurately calculate costs, and lenders can’t lock in收益.

The solution #TermMax proposed is pretty hardcore. Their three-token structure cleanly separates lending, leverage, and returns. FT works like a zero-coupon bond—bought at a discount and redeemed at maturity. XT corresponds to locking in the cost. GT manages leveraged positions. On top of that, the Range Order AMM lets the Curator set their own interest-rate range, which is quite nuanced. Later they also added features like putting idle funds to earn on Aave/Morpho and enabling early exit—shows they’re truly building a product, not just jumping on buzzwords.

Right now, lending and one-click leverage are already live, supporting Pendle PT, certain RWA, and tokenized stocks. They’ve deployed across roughly 10 chains and integrated with Morpho, Aave, and Pendle. Official data puts TVL above 90 million, with 1.5 million+ registered wallets. V2 integrates multi-chain markets into a single interface, connects to HyperEVM and Robinhood Chain, and supports using tokenized stocks like QQQ and SPY as collateral. The TGE on August 25 will open claims for XP, AP, and MP rewards.

That said, the biggest hurdle for fixed-rate lending is liquidity, and Curator quality may vary. After the TGE, incentives will taper off—whether they can hold up is the real test.

I’m not paying attention to TermMax just because I like the narrative. It’s because in a DeFi space that still has a very strong speculative taste, seeing someone willing to bring those proven pieces of traditional finance onto the chain is, in itself, worth a closer look.

#TermMax The discussion around @TermMax has suddenly picked up recently. Everyone seems to be waiting for the TGE, so I went back to review how it works. To be honest, after playing DeFi lending for a long time, the biggest pain point isn’t whether the returns are high or low—it’s that interest rates are too erratic. Floating rates might be 4% today and potentially 9% next month. Borrowers can’t control their borrowing cost, and lenders can only guess their eventual yield.

TermMax’s solution is pretty interesting: it modifies Uniswap V3’s AMM, turning the price curve into an interest-rate curve. The market then competes directly within a custom range on “how much interest to pay for borrowing this amount.” By introducing a time-to-maturity dimension, rates aren’t just determined by current supply and demand—they also account for time duration. I spent a while figuring out its three-token structure: FT is like a zero-coupon bond—bought at a discount for redemption at maturity; XT locks in the borrowing cost; and GT is a leveraged position certificate. Pricing is based on Range Orders, and idle capital can be automatically routed to Aave or Morpho to earn yield. In short, it doesn’t simulate fixed-rate lending in a naive way—it turns it into a tradable asset.

Its product positioning is straightforward: fixed-rate lending + options. The slogan is just three words: known interest rate, known maturity, known risk. Lending and one-click leverage are already live, supporting Pendle PT, some RWA, and stock tokens. It’s deployed across roughly 10 chains, with TVL over $90 million. Canton Network’s institutional business has also been rolled out.

The TGE is scheduled for August 25, with a simultaneous listing via Binance Wallet Booster. The total prize pool is $2 million TMX. 1.7 million is allocated to 80,000 winning users for the raffle, and 300,000 goes to the first 1,000 people who post on Binance Square. Participation is open with or without a key wallet, and requires at least 2 Alpha points. The Square posting deadline is 23:59 on August 21. Make sure to verify your ranking to claim the rewards—TGE unlocks them.

Fixed-rate lending is infrastructure-level stuff in traditional finance, and it’s not easy to build a tradable asset on-chain. TermMax’s engineering is indeed solid, but whether liquidity, the quality of Curators, and post-TGE demand can hold up—all remains to be seen. I’ll keep watching it. Not because its narrative is particularly sexy, but because it pushes forward something that’s genuinely hard to do yet has long-term value by one more step.

#dusk I’ve been watching the $DUSK order book for days. Honestly, I’m not most wary of up or down—I’m wary of that “paper-thin window” of liquidity. Today the numbers are right in front of us: contract trades at $3.79 million, while spot is only a bit over $420,000. But the contract open interest is more than 30 times the spot—$14.27 million versus $420,000. That ratio alone makes your stomach feel uneasy. Orders are usually posted neatly and orderly; but when a big order really comes through, once the contract position gets snapped up, the spot side can’t possibly take it. Slippage, order cancellations, mark price versus execution price—everything can tear a big hole in front of you in minutes. Big volume doesn’t automatically mean good liquidity, and lots of open interest doesn’t mean the order book can actually hold. That’s a lesson people only believe when real volatility shows up.

@Dusk Project-wise, I’m actually more concerned with another aspect. In their workflow, investor verification, wallet binding, and transfer eligibility checks look tedious—but really, they’re making sure the “no” is spelled out clearly. If a security product works for everyone, then it probably isn’t a real security in the first place. If nationality doesn’t match, if the person isn’t a professional investor enough, if the lock-up period hasn’t passed, if the tool isn’t allowed for that kind of person—then the trade shouldn’t happen, and even if the money is paid, it still shouldn’t. The $DUSK token can be held by anyone, but the tools on NPEX can’t be used by everyone—these two things are fundamentally not the same. I saw their demo focus on pathways that get rejected; anything that didn’t get rejected, I just treated as a game.

This makes me think of a friend. A few years ago, they bought non-public fund shares. If they wanted to sell or transfer them, it was basically impossible. They had to find a qualified buyer, get approval from the issuer, re-sign the documents—broker fees were even higher than the discount. The asset just sat there for three years. Dusk puts the shares on-chain: eligibility can be verified, restricted code execution limits transfers, and in theory transfers no longer depend entirely on manual checks. Once friction drops, small and medium players finally get a chance to get in. Of course, where the buyers are, who sets the valuation, where disputes go, whether custody is accepted—blockchain can’t solve all of that.

In short, Dusk doesn’t create short-term hype, and results take time—they depend on regulators, custody, and buyers all being in place. Projects like this are the easiest to be criticized as “no progress,” and I’m actually more willing to give it extra patience.

Wandering through the Loquat Garden at night, heading to a feast of lantern-lit lights in a mountain city 🌙
With lights scattered across the hills, fireworks soaring, and all the busyness of the world in this very moment.
Breathe in the evening breeze of the mountain city and savor the romance of Chongqing’s night, uniquely its own.$BNB $SOL

#dusk I’ve been turning @Dusk over and over in my mind lately, and the more I look, the more I feel that a lot of people got it wrong right from the start.

When you mention $DUSK , everyone immediately talks about that privacy coin on Ethereum. Not at all. I went and dug into the whitepaper specifically—it’s an independent Layer 1 public chain with its own nodes, gas fees, and settlement layer, all built in-house. The ERC-20 token you see on Etherscan is just a mapping token created early on for convenience.

Once you understand that, the whole logic suddenly clicks. It’s not sitting there debating whether the privacy track still has hype. What it’s doing is building a privacy settlement chain specifically for financial assets.

Think about it: for fully transparent ledgers like Bitcoin and Ethereum, validation is convenient—but how do large institutional funds actually come in? If I were a fund manager, I’d adjust my holdings and hedge, and every position change would be visible in the mempool for people to stare at—that’s hardly not “naked.” Fully anonymous? Then audits and regulation can’t pass.

What Dusk is trying to untie is this knot. It uses Phoenix to hide transaction details, Zedger to handle securities-related items, and that XSC module—whitelists, position limits, and transfer conditions are all written into the contracts. Sensitive information stays opaque, compliance can still be verified, and then it finally goes through consensus to seal the deal.

So I don’t really argue with people about whether privacy is still “hot” or not anymore. The more interesting question for me is: if one day funds and bonds are truly put on-chain to do RWA, will these institutions actually need a底层 like this?

The market has a new hot trend every day. But the ones that can hold their breath and build financial infrastructure without making noise—that’s what I find kind of interesting.