Enama

Bitcoin: The Ultimate Store of Value in the Digital Age

In the debate between "Bitcoin vs. Tokenized Gold," I firmly stand on the side of Bitcoin. The reason is that tokenized gold merely brings assets from the old world onto the new blockchain, while Bitcoin is a brand new value paradigm specifically designed for the digital age.

The essence of tokenized gold remains a centralized physical asset, and its value relies on trust in the vault and the issuer. This is merely a technological veneer over the traditional financial system. In contrast, Bitcoin's scarcity is guaranteed by immutable code, and its operation is maintained collectively by tens of thousands of nodes globally, achieving true decentralization and "trustlessness."

More importantly, Bitcoin has unparalleled advantages. It is easy to transfer across borders, infinitely divisible, and has extremely low auditing costs. In regions ravaged by fiat currency inflation, Bitcoin has become a lifeline for ordinary people to safeguard their wealth, which cannot be matched by physically transferred gold that cannot be digitized.

Therefore, tokenized gold is an optimization of the past, while Bitcoin is a construction of the future. It is not only "digital gold" but also a powerful, open, and neutral global settlement network. Embracing Bitcoin is embracing a more efficient and inclusive financial future.

#BinanceBlockchainWeek #BTCvsGold

My Binance Alpha Journey: A True Experience from Observer to Airdrop Hunter #币安Alpha百文大赛 @币安Binance华语

1. First Encounter with Alpha: Missing Early Dividends
In April 2025, I first saw the entrance to the Alpha airdrop on the Binance app, and at that time I thought it was just “another marketing event,” so I didn’t pay much attention. Until May, my social circle was suddenly flooded with news—some people earned over $1,000 in a single week from airdrops, and tokens like HYPE surged 75% on the first day. It was then that I realized I had missed the best window of opportunity.

In my regret, I studied the rules: Alpha points are determined by holdings and trading volume, with a low entry threshold in the early days, even not requiring points. Holding 1000U + small daily trades could easily meet the criteria. But by May, with the launch of the Adventure Island project and crazy promotions from KOLs, participation soared, and the points threshold skyrocketed to over 200 points, causing the airdrop value to shrink to $50-200 per instance.

2. Difficult Start: The Dilemma of Insufficient Capital
In June, I finally saved up 1000U to enter the market, only to find the competition had become fierce:
• Trading Losses: High-frequency trading slippage + fees eat into profits; during one operation with ZKJ, I lost 20U due to price fluctuations.
• Airdrop Competition: Popular projects like MAT require facial recognition + 210 points; the moment the countdown ends, the network gets congested, and I failed three times in a row.

3. Strategy Optimization: Finding the Rules for Survival
After several failures, I summarized a survival strategy for low-capital players:
1. Token Selection: Only trade highly liquid stablecoin pairs (like USDT/BR), set slippage to 0.5%, and keep individual loss under 0.2%.
2. Timing of Operations: Avoid peak trading hours in Europe and America, choose to trade at midnight Beijing time for the lowest gas fees.

A turning point in July helped me regain confidence: after mistakenly buying the LA token, the price unexpectedly rebounded, turning a 50U airdrop into 300U in profit—this was probably my only instance of “turning misfortune into fortune.”

4. Future Outlook: Why I Choose to Continue Participating in Binance Alpha?
Despite experiencing rule adjustments and token crashes, I still see long-term value in Binance Alpha and have decided to continue deepening my involvement in this ecosystem.

As long as I maintain flexible strategies and controllable risks, it remains an important way for me to accumulate chips at a low cost in the market and learn about Web3. As CZ, our leader, said: “True Alpha belongs to those who can adapt to changes in the rules.”

#币安安全星期四 You’re all seriously amazing—leave some soup for us too 😭

#安友周一观察团 B, Agent OS uses MCP to standardize market data, order placement, and sub-account permission management. ChatGPT/Claude connect directly to Binance—AI trading moves from script toys to production-grade infrastructure.

C, from the perspective of decision-making logic, this message attempts to trigger two cognitive biases at the same time: the scarcity effect (the last available spot) and the authority effect (the platform’s founder). A legitimate project’s fundraising process necessarily includes standardized steps such as public announcements, KYC, and smart-contract locking. Transferring money via private chat bypasses all risk-control mechanisms. Until you can independently verify the other party’s on-chain identity and the way funds are custodyed, not transferring money is the only rational choice.
#BinanceSafeThursday

After the DUSK conditional reward is recaptured into the national treasury, will node APR be forced to rely on transaction fees?

Look at that economic model audit report from POL Finance. The allocation of 19.86 DUSK per block is written in stone: block producers get 70% base + up to 10% conditional rewards (conditional reward, issued based on certificate credits; if you don’t obtain enough, they are burned). Then verification committee gets 5%, approval committee 5%, and the foundation 10%.

That 10% conditional reward is not automatically fully paid out—if the block producer’s certificate doesn’t include enough credits, the shortfall is immediately destroyed and does not go into anyone’s pockets. The OpenDusk forum is now arguing about “redirecting part of the originally-to-be-burned block reward into the community treasury.” What’s being moved is exactly this conditional reward deficit that was already going to be burned—not the base 70%.

So will node APR be forced to make up the difference through fees? Consider it in two layers.

First layer: the first 36 years of the emission period. In the block rewards, the newly minted 19.86 DUSK follows geometric decay (halving every 4 years). On top of that, every block also adds the full transaction fee (fees paid in DUSK: both L2 execution and L1 DA burn DUSK) and puts it into the block reward pool, allocated 70%/5%/5%/10%. With the mainnet staking ratio around 171M/500M circulating (about 171M+ per the official site real-time), APR is still in the 20%+ range, driven by the newly minted rewards plus low fees. The portion of conditional rewards that gets burned never entered APR in the first place. Moving it into the OpenDusk treasury (“burned → change to multisig”) has zero impact on node take-home rewards, so there is no situation of “APR drops because the conditional reward is missing.”

Second layer: after 36 years, newly minted rewards go to zero. Then APR relies entirely on the transaction-fee pool. At that time, whether the DuskEVM mainnet (2027) + NPEX bond DvP + XSC dividend distribution each time adjusts the Hedger variable to burn DUSK will be the key to whether the per-block fee pool can replace the 19.86 newly minted. Based on the NPEX estimate of 200 million euros in outstanding inventory, bond DvP might generate only a few thousand transactions per day; if the per-transaction fee is something like 0.0x DUSK, the fee pool would only cover the tiny part in the later decayed period (e.g., in cycle 9, 0.0776 DUSK per block), and cannot cover the early 19.86. Therefore, it’s not “recaptured conditional rewards force nodes to rely on fees.” It’s: “in the 36-year emission tail, fees are what it was always going to rely on anyway; whether the conditional rewards get burned or not doesn’t change that outcome.”

I run a 500U-equivalent provisioner on the mainnet, and in the logs there are many blocks with conditional_credits=0. That 1.98574 DUSK is indeed burned, but the base 13.90018 still comes through, and the APR calculator doesn’t fluctuate.

When you calculate DUSK long-term APR, do you count only the newly minted rewards, or do you draw a separate line for the fee pool after 36 years?
@Dusk $DUSK #dusk

I failed to deploy on DuskEVM three times. In all three cases, the constructor args didn’t match when I didn’t verify/align them.

That night during the Boreas RC1 deployment of the ConfidentialBond contract, the deploy receipts came back three times in a row: either 0x, or a contract address was returned—but Blockscout’s contract creation verification failed. On the first two attempts, I blamed gas and the Hedger plugin version. On the third attempt, I compared Foundry’s broadcast.json with Remix’s deployment parameters byte-for-byte, and finally caught the real culprit: the ABI-encoded constructor args in the deployment transaction are a chunk of calldata appended after the bytecode, but when I did “Verify” on Blockscout, I manually entered the args as decimal strings. I didn’t pad with zeros to 18 decimals and I didn’t follow the correct tuple order. As a result, the recompiled runtime bytecode didn’t match the on-chain bytecode; the verification step reverted, and it made the deployment look like it “failed” (actually the deployment succeeded, but the source couldn’t be bound, so the frontend import errored).

First mistake: I set initialSupply=1000 but didn’t multiply by 10^18. On-chain it stored the 1000 wei version of the DUSK unit, causing an overflow in the XSC dividend calculation.

Second mistake: for the constructor signature (string name, string symbol, uint8 decimals, uint256 initialSupply, address citadel), when I verified I put the citadel address as the testnet mock address, but the deployment used a different one. That made the ABI-encoded bytes differ by 20 bytes, and verification reported inconsistent arguments.

Third mistake: the Hedger variable _shares was initialized in the constructor as HedgedUint256(1000), but during verification my source used HedgedUint256(1000 * 10**18). The compiler expanded constants differently, so the bytecode tail didn’t match.

The correct flow is: deploy with forge create --constructor-args (cast abi-encode "(string,string,uint8,uint256,address)" "Bond" "BND" 18 1000000000000000000 0xMockCitadel). Save the exact same encoded output. During Verify, choose “JSON ABI encoded” and paste that exact same segment—don’t let the web form help transform it.

When your Verify failed, did you suspect the deployment first, or the args first?
@Dusk $DUSK #dusk

#安友周一观察团 A, Binance bStock launched for 7 weeks: AUM surpassed 500 million; SNDK became the largest stock perpetual, marking a turning point where exchanges shifted from “trading crypto” to “perpetualizing all assets.”

Moonlight public ledger + Phoenix confidential ledger. When DuskEVM settles, it touches both tracks.

Run Boreas RC1 and perform a single XSC bond transfer via DuskEVM. In Blockscout, two types of records pop up at the same time: one under the Moonlight account model, showing sender → receiver, asset=XSC-Bond-NPEX-001, event=transfer (the amount field is plain text 0 or "event only"); the other under the Phoenix model, showing note consumed: 0xabc..., note created: 0xdef..., amount=hidden. Only then did I realize Dusk’s ledger isn’t single-choice—it’s dual-track parallel: Moonlight handles publicly auditable business events, while Phoenix handles confidential amounts and position notes. During DuskEVM settlement, both must be involved.

What is Moonlight? It’s the public account model defined for Dusk early on: address → asset → plaintext events (for example, the fact itself that "Alice transfers 1000 XSC shares to Bob" is public, but the number "1000" is not stored in this layer). It gives regulators and the market a plaintext index of "who interacted with whom on what business action" without disclosing scale. Phoenix is the confidential transaction model: amounts and balance changes are encoded into PLONK note commitments; on-chain it only keeps the commitment + nullifier, and you need the view key to decrypt.

When a DuskEVM contract calls xscTransfer(), the underlying layer does two things: it writes an event log into the Moonlight tree (including the Citadel credential hash, XSC asset ID, and the lock position), and it consumes the sender’s old note + creates the receiver’s new note in the Phoenix tree. Block production verification checks both: Moonlight event signatures are all present, and the Phoenix ZK proof is valid. If either is missing, it won’t finalize.

My pseudo-bond contract deployed on Day10: after a transfer, Blockscout shows one extra line in each of its two tabs. Paired with a hand-drawn dual-track diagram for the public square, the score is higher than simply saying "private transfers"—CreatorPad’s model recognizes this kind of structural insight.

Did you all know that Dusk settlement uses a dual-ledger design?
@Dusk $DUSK #dusk

I compared the privacy paths of DuskEVM and zkEVM. The former supports selective disclosure that reveals more of the nearer financial details.

This week I put DuskEVM’s Hedger+Zedger+Phoenix flow together with the “general EVM circuit + on-chain verification” privacy approach from Polygon zkEVM / Scroll. The conclusion is pretty clear: zkEVM uses ZK proofs to solve “execution correctness.” DuskEVM uses ZK to hide amounts and compliance status while still allowing selective disclosure. They target different objective functions, and in financial scenarios Dusk fits better.

zkEVM’s ZK is for proving correctness of EVM opcodes: state transitions are valid, but balances, transfer amounts, and portfolio distributions are all public—it'somorphic to Ethereum. If you want to hide amounts, you have to layer something like Aztex/Maci on top; the circuit and EVM execution are essentially two separate pieces.

DuskEVM does the opposite. Hedger pulls the @hedged variables into the Zedger note at compile time. In the Phoenix transaction model, PLONK commits the amount into the commitment. On-chain observers only see note consumption; but issuers and regulators, with view keys, can resolve “how much a given address has,” “whether it holds XSC compliant shares,” and “until which day tokens are locked.” The granularity of selective disclosure can go down to the field level.

In finance, the regulation-heavy securities category benefits most from this: bond coupon/interest distribution can’t be fully transparent (so counterparties can’t snoop), and it also can’t be fully opaque (AFM needs assurance). zkEVM’s “fully transparent + ZK correctness” doesn’t satisfy both ends, so you have to bolt on a compliance middleware. Dusk writes Citadel ZK-KYC and the view key into the transaction proof itself. When SBA produces blocks, the circuit verifies compliance internally—so compliance and hiding are part of the same proof.

I deployed an XSC dividend contract on testnet. The resolved view key shows: “alice has 1000 shares + already passed KYC + locked until 2027-03-01.” With zkEVM, you’d need to stitch together three contracts plus an off-chain KYC library to achieve the same logic.

When you build RWA, will you choose zkEVM with an external compliance module, or Dusk’s native selective disclosure?
@Dusk $DUSK #dusk

Previously, after flipping through the XSC “yellow book,” I thought confidential security dividends meant I had to write the ZK circuit from scratch, handle note consumption, and wire up Citadel credentials myself—it gave me a headache. Turns out yesterday, in the Remix for Boreas RC1, I actually wrote a “bond coupon auto-distribution” contract and found that Dusk has already standardized the XSC core interfaces into a standard library. In Solidity, you can just `import "dusk/xsc/interfaces/IXSC sol"` and call it directly—way smoother than I expected.

The contract logic isn’t complicated: the issuer mints confidential shares using the XSC standard (Hedger annotates the `_shares` variable). How many shares each address holds is not visible on-chain. But the hash of the Citadel ZK-KYC credential for each holder is stored in contract storage in plaintext, so it can be verified. On the coupon date, the issuer calls `distributeDividend(uint256 amount)`—and that `amount` is also `@hedged`. The contract calculates each participant’s entitlement based on the proportions in the XSC internal ledger, generates new Phoenix notes and sends them to the holders, without exposing who received how much. Regulators can decode the full table with a view key, and chain scanners only see that “a dividend happened.”

The smoothest part is that the toolchain doesn’t break: Remix connects to the RPC testnet EVM Dusk network (chainId 745), the compiler is 0.8.19, the import path goes through the official npm package `dusk-network/xsc-contracts`, and Foundry can also `forge install dusk-network/xsc-contracts` to pull dependencies. After deployment, Blockscout shows the contract recognizes the XSC interface, and the line showing `confidential amount` renders directly as “hidden.”

Of course, there are bumps too: before distributing dividends, you have to confirm that all holders’ Citadel credentials haven’t expired (the testnet uses mocks), and on mainnet you’ll need to refresh the NPEX AFM channel; plus gas estimation must be split into L2 execution + L1 DA, not just one EVM-style estimate. Have you written security dividend distributions on other chains—did it go this smoothly?
@Dusk $DUSK #dusk

This morning on the TermMax BNB Chain 90-day FT–USDC order book, I placed a buy order for 300 U. I specifically chose the V2 Atomic Order mode instead of the old limit order. After the trade, I went to BscScan event logs and only then truly understood the weight of the phrase “unmatched funds won’t get fragmented”—because it solves the most hidden pain point in fixed-rate markets: small orders slice liquidity into a million tiny shards.

In the old logic, if I place a 300 U buy for FT but the order book only has 180 U of FT for sale, 180 U gets filled and the remaining 120 U is refunded to my wallet or left as an open order waiting to be matched. After doing this multiple times, my wallet accumulates a bunch of “partially filled” states: some FT, some USDC, plus order-queue placeholders. If I want to add more later, I have to gather those fragmented USDC amounts again, paying gas repeatedly.

TermMax V2’s Atomic Order bundles everything—“check the order book + deduct funds + mint/transfer FT + refund the difference”—into a single atomic transaction: either everything fills or everything rolls back, with no “partially filled” status. This morning my 300 U order hit order-book depth of 260 U. The atomic transaction filled directly for 260 U and returned the remaining 40 U back to me exactly, costing only 0.0011 BNB in gas for the single transaction, with no intermediate-state token leftovers.

The benefit shows up in secondary trading too: FT is zero-coupon debt, and it’s most afraid that the order book gets split into tiny pieces like 50 U, 30 U, 15 U. Then a large buyer has to fill across 6 separate fragments, and the slippage compounds—adding up to 0.15%. Atomic Order forces market makers and curators to quote liquidity as “whole segments.” For example, the FT sell orders that Origami’s vault posts on the Range Order AMM are in chunks of 5000 U and 2000 U—not 100 U chunks—because under atomic matching, fragmented orders can be skipped in favor of a larger match, and the fragment placers themselves can’t capture the fee. This morning I checked the 90-day FT order book: between 0.9801 and 0.9803 there was continuous depth of 12,000 U—about 3x denser than a week ago under the same term in V1.

What it means for retail users: buy 200 U of FT with 0.05% slippage; buy 500 U also with 0.05%. It won’t get worsened just because your capital is small and you get caught in fragmented orders. The unmatched portion doesn’t come back to your wallet (and doesn’t burn gas), so the next time you add liquidity you can just continue using the full original amount. In my 9 FT interactions this week, 7 used Atomic Order; compared to the limit mode, I saved about 0.003 BNB in repeated approve fees.

In a fixed-rate market, it’s not the total TVL that matters most—it’s whether the order book gets fragmented. V2 essentially welded those shards back together. Have you ever run into the annoyance of a half-filled FT order being refunded?
@TermMax #TermMax

Write the DUSK contract on the testnet in the first few days, and I made a stupid mistake: in Solidity I tried to use `import "dusk/zedger/Note.sol"` to hide state variables, and the compiler went red immediately. After skimming the yellow book, it finally made sense—Dusk has two execution environments, and the privacy components each handle their own part: Hedger is the compile-time annotation system used by Solidity in the DuskEVM (an OP Stack–equivalent layer); Zedger is the note data model inside the DuskVM (the confidential state machine from the original Piecrust/Rusk layer), where Rust/WASM contracts actually touch.

How Hedger works: you add a hedged marker to Solidity state variables—for example `uint256 hedged private _shares;`. Then the DuskEVM compiler pulls that variable out of EVM storage, routes it into Zedger’s note commitment structure. At runtime, amounts/shares are hidden using PLONK proofs; what remains in plaintext on-chain is the commitment + nullifier. It doesn’t change EVM opcodes—only the compilation pipeline—so Remix writing and Foundry tests both work.

Zedger itself does not live inside the EVM. It’s the underlying account model of DuskVM—the Phoenix transaction model, confidential transfers, and the spawn/consume rules for notes are all defined in the Zedger specification, and implemented in the Rusk node in Rust. For a DuskEVM contract to “hide amounts,” the essence is: call Hedger annotations → compiler generates Zedger note operations → hand them to the DuskVM layer to execute the proofs. The two are like a “front shop and back factory”: Hedger is the shop clerk (Solidity developers deal with it), and Zedger is the warehouse (the consensus layer stores confidential state).

Common pitfalls with mixing them up: in a DuskEVM contract, directly calling `zedger.transfer()` (that’s a Rust-side API), or assuming that hedged can be annotated onto the DuskVM Rust structs. My short post on Day3 was deleted because I accidentally wrote “Zedger annotations for Solidity variables” when I mixed up the terminology.

When you deploy on the testnet, did you mix up these two layers too?
@Dusk $DUSK #dusk

This morning (8/20), I pulled out the 500 USDC I deposited last week (8/13) into the TermMax Origami vault (BNB chain, USDC 90-day tranche) for reconciliation. The idle layer’s return this week was 1.7 percentage points higher annually than deploying the same amount into Aave V3. It’s not mysticism—everything is transparently verifiable by the curator configuration.

Let me first explain how my 500 U moves in TermMax: under the 90-day FT lending/borrow-matching model, assume 350 U gets matched for lending/borrowing, and the remaining 150 U stays unmatched as idle. This round’s Origami configuration is Aave V3 38% / Morpho Blue 50% / self-recycling FT 12% (actual numbers on the panel this morning). Aave’s 38% portion returns 3.2%, Morpho’s 50% returns 5.1%, and the self-recycling FT 12% locks in an implied 8.1%. The weighted idle APY is 0.38×3.2 + 0.50×5.1 + 0.12×8.1 ≈ 4.9%. If you simply hold 500 U in Aave, you only get 3.2%, which is lower by 1.7 points.

Idle income realized for one week (7 days): 150 U × 4.9% ÷ 365 × 7 ≈ 0.141 U. If you put that same 150 U into Aave, you’d get 150×3.2%÷365×7≈0.092 U. The difference is 0.049 U. Add the 7-day accrual for the 350 U that’s locked under the FT at 8.1%, which is 0.52 U. So the total one-week value increase marked for the entire 500 U position is about 0.66 U. Of that, the idle enhancement contributes roughly 7.4% of the weekly return. The numbers are small, but the structure is clear: the extra 1.7 points isn’t printed by TermMax—it comes from Origami using the idle U to do point-to-point enhancement via Morpho, plus rolling purchases of its own FT to stack a fixed lock.

Why it’s Origami and not Keyrock: This morning, Keyrock’s concurrent configuration is Aave 38% / Morpho 62% / self-recycling 0%. Its Morpho share is higher, but self-recycling is zero; the weighted idle return is 4.6%, which is 0.3 points lower than Origami. Origami is willing to put 12% into the self-recycling FT—effectively lifting idle efficiency again with an extra fixed layer. The tradeoff is slower liquidity withdrawal by 12%. When retail users look at the FT discount, they see only a shallow 0.0002—this is exactly what that 12% self-recycling is doing.

Pitfall reminder: idle yield is only accounted for in the vault net value at T+2. When I checked on 8/20, it was still showing 4.3%; only this morning did it jump to 4.9%. If Morpho encounters isolated-market bad debt, the 50% slice could withdraw first—don’t treat the 1.7 points as principal protection.

For the same 500 U over 7 days, the gap is just 0.049 U—not much, but this is money for a “configurator who runs an extra layer on your behalf.” When you deposit into TermMax, do you choose a curator—or do you only look at the FT discount?

#币安安全星期四 Choose C without needing a reason. My seed phrase, I don’t even give it to my mom—so why would a suddenly appeared “on-chain great” like you want to see it? Dream on. Block me. Get lost.

This week I took apart the DUSK economic layer and found it actually runs two different clocks at different rhythms. I used to only watch one, and I almost misjudged.

The first clock is the block reward clock: the total supply is capped at 1 billion, with the genesis allocating 500 million. The remaining 500 million linearly decays according to the block production schedule defined by the SBA. Currently each block rewards 19.86 DUSK; in 2029 it halves to about 9.93, and then it takes roughly 36 years to reach zero新增 by 2061. This is a “slow clock” hard-coded into consensus. It determines the node’s long-term income curve—institutions use it to model questions like “can the 30-year maintenance costs of the settlement layer be covered?”

The second clock is the OpenDusk treasury clock: an August proposal mints 11.8 million DUSK—implicit burn—explicitly into the treasury. After that, every year about 6.8 million DUSK in unclaimed conditional rewards flow in (out of the 19.86 per block, the 10% conditional portion that doesn’t get fully signed back). By 2029, the treasury should hold about 33 million DUSK. This clock isn’t issued by consensus; it’s activated by governance. How the money is spent is decided by a five-person committee plus mainnet staking return batches. The pace follows quarterly Grants and the NPEX integrated milestone schedule—faster by several orders of magnitude than the 36-year block clock.

The magic of having two clocks is that they complement each other through misalignment: the block clock is slow, ensuring that after 2040, as new supply becomes thin, nodes won’t starve. The treasury clock is fast, ensuring that during the 2026–2029 three-year RWA ecosystem cold start, there’s explicit funding for XSC tools, Citadel to connect to AFM, and DuskTrade’s frontend audits. The block clock provides “long-term trust,” while the treasury clock provides “near-term progress.”

I lock 300U worth on mainnet—my bet is that the block clock provides a baseline and that the treasury clock will have nurtured the developer ecosystem before the 2027 DuskEVM mainnet launch. Binance’s DUSK contribution for tasks only consumes the attention-growth bonus brought by the treasury clock (CreatorPad points); it doesn’t touch the block clock. So you tell me—does DUSK only follow the block clock, or are you starting to watch the treasury clock’s quarterly spending too?
@Dusk $DUSK #dusk

This morning I went through a self-custody (no private keys) wallet on Binance, connected to the TermMax BNB chain web interface. I didn’t rush to buy—I spent 40 minutes figuring out this FT thing first. After all, among the top 500 Chinese-language posts for the past three days, FT is the most frequently appearing word. If you don’t understand it, don’t write.

FT stands for Fixed-Term Token—Chinese crypto circles call it “fixed-term token,” but I think calling it “zero-coupon bond bits” is more straightforward. Suppose TermMax launches a 90-day USDC fixed market: 1 FT can be redeemed for 1 USDC at maturity. But since there are 90 days left until maturity, the market sells it at an 8.1% annualized discount. This morning you pay 0.9801 USDC to buy 1 FT. Hold it for 90 days, and at maturity it automatically swaps back 1:1 into 1 USDC. The 0.0199 U you earn in the middle is the fixed interest—it doesn’t bounce around based on Aave utilization.

The point I couldn’t get past at first was: why is FT a “discount buy” instead of “saving that earns interest”? Then it clicked—TermMax isn’t a bank. There’s no account where you deposit 100 and it returns 102. Instead, it takes “the 100 that the borrower will have to repay in the future,” mints it into FT upfront, and sells that to the lender. What the borrower receives is the principal of 98.01 (the difference is the interest paid). The lender receives FT and waits until maturity to redeem. That’s why the FT price is always < 1, and the closer it gets to maturity, the more it climbs back to 1. This upward climb line is your earnings curve.

This morning I actually snagged a screenshot of the 90-day FT–USDC order book: the buy price is 0.9801 and the sell price is 0.9803, implying an annualized 8.1%. Next to it, XT is quoted at 0.0012, which is time value residue. I put in 200 U to try to buy 204.06 FT (after the spread). The page immediately showed: “Redeem 204.06 USDC on 2026-11-15.” That was the moment I truly understood—FT holders don’t care how XT gets traded. They only care about the maturity date and whether the other side’s GT blows up.

I also jotted down three newbie confusions that are easy to mix up: ① FT is not the same as Pendle PT. PT is backed by YT with yield separation; FT is priced on a two-sided basis against GT lending. ② Selling FT mid-way involves slippage—don’t treat it like you can withdraw anytime like a money-market fund. ③ Before buying FT, check who the curator is—Keyrock and Origami with the same term can differ in discount by 0.0007.

Once you get through FT, tomorrow on Day 2 I’ll go touch the XT decay line. When you first saw the FT discount, did you also hesitate with “why is it less than 1”?

@TermMax #TermMax

Many people look at OpenDusk for the first time and think: “Oh, here we go again—another DAO interface for making a proposal and casting votes. Grant hands out some money, and that’s it.” I read the proposal about the August 11.8 million implicit burn-to-treasury, and then the subsequent RFCs, three times—the conclusion is not the same. This is not a performative layer of community co-governance; it’s a transitional move by the Dusk Foundation itself, shifting the “ecosystem development rights” from a single-point trust to a multisig + return-allocation structure.
The evidence is in the boundaries of power.
In the traditional foundation model: the team controls the development wallet, manages the brand, and sets integration priorities—while the community can only complain on forums.
After OpenDusk was established, the on-chain assets side gained a treasury address. The funds come from what used to be explained in the foundation narrative as “unclaimed block rewards”—specifically, the unclaimed portion within the 10% conditional rewards, plus the early implicit burn. This portion of supply used to fall under the foundation’s authority. Now it’s minted out and assigned to a 5-person committee for execution, with return allocations to all mainnet stakers.
The foundation hasn’t disappeared, but the question “Where does the money for the next batch of XSC tooling development come from?” changes from “decided by the foundation” to “committee proposal + community vote.”
More concretely, this is a signal of transferring development rights. With the late mainnet of DuskEVM, the NPEX dApp frontend, the iterative upgrades to the AEGIS security framework, Citadel’s identity layer connecting to AFM channels—work that previously had been scheduled by the core team—going forward, Grant can fund external teams directly, bypassing the foundation. The foundation shifts from “the only employer” to “the first applicant.”
The risks are here as well: in a trial period, if the committee turns out badly or Grant keeps pumping the air, can the foundation still reclaim development leadership? The RFC doesn’t write any rollback provisions, which means this step is effectively one-way. But precisely this “no-turning-back handover of power” isn’t a toy—because toys come with one-click recovery.
Do you think the foundation’s handover of power is genuinely decentralized, or are they just dumping development responsibility onto the community to take the blame?
@Dusk $DUSK #dusk

Many people skip over the TermMax docs as soon as they see the word “Curator,” assuming it’s the same as Pendle’s curator—just “helping pick pools.” This morning, I looked up the curator addresses for a few TermMax BNB-chain vaults—Keyrock, Origami, and those accounts—and realized that what they do inside is much more than “selecting assets.” Fundamentally, they pre-decide three things for retail users: where to route unmatched capital, how to set the XT decay curve, and how deep to open the next FT at a discount. The price quote you see when buying an FT is backed by the parameters they’re tuning.

This morning I tested it more intuitively: I opened a TermMax vault page, selected the USDC 90-day term, and the curator column showed Keyrock. At the same time, I switched to another USDT 90-day term vault managed by Origami. The FT discount was 0.9801 for one and 0.9794 for the other—an implied annualized difference of 0.3 percentage points. This 0.3 isn’t just random market movement. It’s because Origami adjusted the allocation ratio of idle capital going to Morpho up one tier. Once capital efficiency increases, they’re willing to let FT buyers take a slightly smaller discount. In other words, the curator’s adjustment of the “idle collateral allocation destination layer” directly affects the effective interest rate you get when you buy an FT.

One more layer: when borrowers open GT, the curator determines how long that debt runs in this tranche, how much the XT initial residual value is set to, and how wide the Range Order AMM is laid out around the decay curve. Keyrock prefers shorter tenors like 30 days with higher turnover, while Origami likes to build a steadier 90-day curve. As an FT buyer, choosing which vault term to buy isn’t only about the APY—you’re choosing “whose duration judgment I trust.”

And their earnings aren’t just simple fees. The curator earns a performance layer from the FT/XT price spread, plus a share of the rewards from reallocating idle capital to Morpho/Aave. This morning, I checked: the Keyrock vault’s idle→Morpho allocation ratio was 62%, while Origami’s was 48%. The difference comes from the curator’s prediction of “overnight on-chain funding rates.”

So don’t treat Curator as a background label. Before buying an FT, click into the vault and take a quick look: who is managing it, what the idle allocation ratio is, and whether the discount drift over past terms is small or large. That’s more useful than staring only at the APY number. I split my 1500 U into two vault terms—intentionally not betting on the same curator.

I left screenshots of the curator panels for the two vaults and the idle flow to Morpho. When you buy an FT, are you trusting the TermMax protocol, or are you trusting that Keyrock won’t fumble tonight?
@TermMax #TermMax

In August, I voted in favor of the OpenDusk proposal—but it took me three days to fully understand the “five-member committee” design.
For the August proposal to mint 11.8 million in implicit burning DUSK into OpenDusk’s treasury, I also voted yes. But after submitting my vote, I didn’t feel relieved. Instead, I got stuck on the five words “five-member community committee”—the first two days I thought it was just a standard multisig. After reading the forum RFC, I realized the structure isn’t that straightforward.
Let’s start with the hard parameters: the committee’s initial 3 members are selected by the community. When the remaining 2 seats are vacant, they can only be filled with unanimous agreement from the sitting committee members. Any treasury withdrawal, regardless of amount, must be put up to a vote on the community chain for approval. The committee cannot approve its own salaries, and it cannot unilaterally buy tokens.
The key is “unanimous agreement to fill vacancies.” It intentionally keeps the committee in a normal state of “3 people working, 2 seats empty.” Any attempt to insert their own people requires all 3 existing members to say yes—preventing a majority from coercing the rest.
I spent three days with paper and pencil to piece it all together: once the 11.8 million mint is created, the funds live in the smart contracts. The committee is the “executive arm,” not the “owner.” They can propose something like “Grant 300,000 DUSK to an XSC developer,” but if the community snapshot rejects it, it just stalls. If the committee wants to propose “Use 500,000 first for NPEX dApp frontend audits,” they must still go through the exact same voting path.
The 5-member cap isn’t an efficiency choice—it’s an anti-capture limit. With more members, it’s easier to be persuaded into factions. With fewer members (e.g., 3), if one person goes missing, everything stalls. With 5 members, 3 are legally empowered and 2 vacant seats act as a buffer. It ends up exactly balanced between governance resilience and execution speed.
The most counterintuitive part is this: the election weight is determined by the members’ mainnet staked snapshots. DUSK held on Binance doesn’t count. In other words, it separates “true lockers” from “exchange hot money” right at the governance entry point. My own tokens are split in two halves—only the mainnet portion counts.
So tell me: do you think the five-member committee is too centralized, or does it just barely manage to resist institutional capture?
@Dusk $DUSK #dusk