六出纷飞

加入专属聊天室 Want red envelopes? Want peripheral items? Want strategies? The Six Brother chat room has it all, come join the chat room to receive benefits!
点击加入聊天室

#币安Alpha推出MERL交易竞赛

Thank you to all the bosses for your support. Yesterday, dozens of bosses activated the commission. We should save where we can and spend where we need to. The contract commission rate is 20%, and payments will be made to everyone every Sunday. 🎈Invitation code: LCFF666
#手续费返佣

In the past two years, I helped my family look into home loans. The broker kept recommending, “Should you choose a floating interest rate? The interest is lower in the first couple of years.” I hesitated for a long time, and in the end I still chose fixed—it's not that I calculated it to be optimal; I just didn’t want every month to watch the interest rate table and worry about it. This week, while reading DeFi lending protocols, I found that TermMax actually solves the same kind of anxiety—only the scenario is moved on-chain.

Most DeFi lending uses floating interest rates. The rate changes according to the pool’s real-time supply and demand, so borrowers can’t figure out in advance how much they’ll have to repay in total at maturity. Especially in leveraged strategies: if the interest rate suddenly spikes, the return model you calculated beforehand falls apart immediately. TermMax’s approach is to match the lending parties into an agreement with a fixed term and a fixed interest rate. Once a deal is made, the interest rate won’t change until maturity. This is the same logic as traditional finance’s time deposits and fixed-rate bonds—just implemented on-chain via smart contracts.

I also think the timing of this idea isn’t exactly coincidental—over the past couple of years, DeFi leveraged strategies have been getting more and more elaborate, but the underlying interest rates can change at any moment. Many so-called “conservative” strategies end up failing outright when interest rates swing violently. By restoring “interest-rate certainty,” one of the most basic things in traditional finance, to a certain extent TermMax helps rebuild a crucial foundation for the DeFi leverage ecosystem.

But fixed rates also come with a cost. If the market interest rate falls after you lock in, you effectively end up paying more interest—you take on opportunity cost. That is essentially the same dilemma I had back when I was deciding whether to choose a fixed home-loan rate. On-chain, it’s just laid out more starkly: you have to pay for that certainty yourself. Also, fixed terms mean liquidity is worse; getting out mid-way isn’t as easy. I still need to research whether their mechanism design is flexible enough in this regard.

Choosing certainty or choosing flexibility—that’s a dilemma I’ve gone through once before with my home loan a few years ago. I didn’t expect to face it again in DeFi lending.

When it comes to managing your finances, do you care more about interest-rate certainty or liquidity flexibility?
@TermMax #TermMax

I had already put the kids to sleep at 11:30, and I didn’t want to keep scrolling on my phone for the next half hour. I flipped through Dusk’s execution-layer documentation for a bit. I originally just meant to skim and then go to bed, but I got stuck on one detail and couldn’t fall asleep.

Piecrust is Dusk’s smart contract virtual machine, based on WASM—which, in this respect, isn’t much different from a lot of new public chains. What’s special is how it handles cryptographic computation—operations that are computationally heavy, like hashing and zero-knowledge proof verification. Instead of handing those to WASM bytecode to run, it turns them into host functions, calling the underlying Rust implementation directly to do the computation. In other words, contract code runs conventional logic inside the VM sandbox, but the moment it hits heavy cryptography, it jumps out of the sandbox to native code, then returns the result back into the VM.

At first glance, this split looks like an engineering optimization; if you think it through, it’s necessary. Putting zero-knowledge proof verification inside an interpretive VM means the performance loss is on the order of magnitudes—especially on a chain like Dusk, where the default path is through cryptographic transactions. Almost every transaction has to go through proof verification. If this part lags, it effectively chokes the chain’s throughput. Moving the most resource-intensive pieces out of the sandbox and running them with native code is, in essence, a middle route between two goals: “contract-level Turing completeness” and “privacy computation must not cripple performance.”

What kept me up was this question: who defines the interface for these host functions, and will it be extensible in the future? If every new cryptographic primitive requires changes to the VM’s underlying code, then the range of privacy primitives developers can use is, to some extent, constrained by the core team’s release cadence—rather than being freely extensible by the ecosystem. That seems a bit at odds with the public-chain narrative of “Turing complete and developers can freely innovate,” though the contradiction is buried in the underlying layer, so it usually doesn’t feel obvious.

Once I got to that point, I lost interest in reading further. I noted it down first, and I’ll come back later to verify exactly how open the host functions really are.

What do you think: by splitting core cryptographic computation out of the sandbox and running native code—this “performance-first” trade-off—will the cost be bigger than it looks?

@Dusk #dusk $DUSK

A friend has been messing around with the transfer of equity stakes in the primary market lately, complaining that the process is unbelievably slow: the lawyer, the transfer agent, and the clearing house have to run back and forth, fast cases take two weeks, slow ones can drag on for a month. I casually mentioned Dusk’s Zedger module, and he shot back with, "Isn’t on-chain settlement just a matter of sending money? How complicated can it be?"

Good question—because securities settlement is not as simple as sending funds. What Zedger needs to handle is the ownership change itself—who holds the shares, how many they hold, and who they’re transferred to. In the traditional system, this information is scattered across multiple ledgers maintained by different parties such as custodians, registries, and clearing houses. Reconciliation is where the time goes, not the transfer itself. Zedger moves the entire ownership registration logic onto the chain. While using zero-knowledge proofs for privacy protection, it can also complete ownership changes atomically on a single chain. In theory, this could eliminate the reconciliation step entirely.

But after I explained all that to my friend, he asked another question I couldn’t answer: legally speaking, when an ownership change is recorded on-chain, which record is considered authoritative—the one on-chain or the one in the traditional registry? If the two sides conflict, which one is the final basis? This isn’t a technical issue, and Dusk itself can’t resolve it; it depends on whether the legal jurisdiction where it operates recognizes this approach. Technically, removing reconciliation is no problem. But legal acceptance is the hurdle—one country at a time.

So my current view on Zedger is: the technical design is headed in the right direction, but it’s still far from the point where, "securities in any random country can be settled like this." The places where it can actually work today are basically only a few regulatory sandboxes in Europe.

What do you think—how long will it take for on-chain ownership registration to be formally recognized by mainstream legal systems as a "legal basis"? Or will this always rely on traditional systems to provide endorsement?
@Dusk #dusk $DUSK

When many people mention “finality,” what comes to mind is “once you’ve passed how many blocks, you can’t change anything anymore”—a one-size-fits-all concept. After reading Dusk’s rolling finality design, I realized that idea is too crude.

It breaks block states into four tiers: accepted, attested, confirmed, and final. You climb from one layer to the next; it’s not strictly black or white. Low-round blocks can be replaced by later blocks if they don’t manage to gather enough “failure proofs.” But as more and more confirmed blocks accumulate, the probability of forks drops exponentially, and eventually the blocks get locked into an irreversible final state. At its core, this design quantifies the question of “how long it takes to feel secure” into a curve—not a fixed number.

What I care about most is how it prevents opportunism—for example, someone intentionally misses their turn, waiting to grab block rewards in later rounds. The protocol includes multiple layers of countermeasures: voting rewards, extra points, and removing eligibility for the next block-production slot. On top of that, there’s a cap on iteration counts. In other words, it plugs each game-theory loophole one by one, rather than relying on penalties alone.

However, the more I look into the details, the more I’m uneasy: this mechanism depends on the committee being large enough and network communication being fast enough. If someday the network gets partitioned and message propagation delay increases, would the assumption of “rapid accumulation of confirmed blocks” fail first? Whether “second-level finality” and robustness under extreme network conditions can truly be achieved together—I haven’t seen an answer that fully puts my mind at ease.

@Dusk #dusk $DUSK

I watched Zedger for three days, and suddenly I understood what kind of game Dusk was playing.

To be honest, when I first started researching @Dusk , I was aiming for Phoenix. Zero-knowledge proofs, privacy transactions—on the market, projects with this approach are everywhere. What really made me stop and reread the whitepaper was the Sparse Merkle-Segment Trie structure in Zedger—very few people even mention it.

With a typical account model, if you want to check a balance, you just read a number. But the downside is that the whole network can see that number change. The UTXO model takes a different approach: it chops money into a bunch of fragments, so no one can see the full picture. But if you try to use that for securities settlement, it gets awkward. Institutions want a ledger they can audit, reconcile, and distribute dividends by share—not a pile of fragments that are impossible to trace.

What Zedger does is let the owner maintain a segmented ledger themselves. Each time there’s a change, it only updates a local root in a Merkle tree. Outsiders can’t see the details, but regulators or auditors who obtain the corresponding keys can verify whether a given segment is compliant. This is completely different from our usual understanding of “either fully naked or completely black.” It provides a middle state that can be revealed on demand. Dividend rules, voting rights, share caps—those securities-specific headaches—are natively supported by this structure, without needing extra patches.

After doing this for so many years, I’ve seen too many projects that claim compliance, only for the implementation to turn out to be empty. Zedger’s approach is genuinely built into the code logic—if you don’t believe it, you can go check the open-source repository. Of course, it’s not a cure-all. A complex design means higher implementation and auditing costs. Whether this equation ultimately balances out depends on real institutional deployment cases—it's too early to draw conclusions now.

In the end, finance is always about finding a balance between privacy and trust. No one is inherently meant to be exposed, and no one can go unanswered forever. This $DUSK design, to a certain extent, is answering an older question for us: how much of oneself should be exposed to the world to be safe? #dusk

Phoenix and Moonlight coexist: one privacy chain leaves a not-so-private loophole. I think that’s quite clear-headed.

People who work on privacy projects tend to go to extremes. Either they hide everything, claiming absolute privacy, or they get lazy and give up privacy in exchange for efficiency. Over the past couple of years, I’ve seen quite a few projects that advertise “privacy” ultimately die on this either-or choice: either audits and regulation can’t touch it at all, or the privacy features are basically a formality. When I was reading the documentation for $DUSK , I found it didn’t go to extremes.

Phoenix uses the UTXO model and does shielded transfers—covering both balances and the relationship between transactions.

Moonlight uses the account model, taking the public path, with balances and transfers fully visible.

These two channels coexist. Both can transfer DUSK, both can pay gas, and both can serve as the entry point for contract execution. Users choose whichever channel they prefer.

At first, I thought this was a compromise. Later I realized it’s actually leaving yourself a way out. Institutions need to be compliant and auditable—so it’s impossible for all fund flows to be fully black-boxed. In a regulatory sandbox, the very first thing they do is see where the money goes. Ordinary users want privacy and don’t want every single transfer to be exposed down to the last detail.

Forcing one model to satisfy two different demands usually means neither side is fully satisfied. It’s just like building a house with both a front door and a back door: the front door is for the people checking your paperwork, and the back door is for people who don’t want their neighbors watching them. It’s still the same house—no one thinks either door is unnecessary.

My take on designs like @Dusk is that they admit they can’t solve everyone’s needs—and that’s more honest than trying to cram together a one-size-fits-all solution. In this industry, what matters most in the end is often not whose ideals are purer, but who’s willing to chew through the real-world bones first. #dusk

From the Challenge Mechanism: Bitcoin Script’s Limits on Handling Abnormal States

Putting a Bitcoin-like asset without native smart contracts into complex financial schemes most often gets stuck at “exit.” If the data returned by an external application deviates, or even if the external chain forks, what mechanism ensures that the assets locked on Bitcoin can be securely unlocked?

If you put all your effort into proving off-chain how to submit, it’s easy to overlook the timeliness constraints when settlement or challenges are initiated. In the logic of Trustless Bitcoin Vaults, on the Bitcoin side the Vault is actually built from scripts containing time locks and multi-condition branches. Once an external state proof is not confirmed within the specified time, or a validator submits a negative proof for an abnormal state, the settlement script triggers a specific spending path. This design does not rely on any central server to force liquidation; instead, “dispute resolution” is directly encoded into Bitcoin’s own time constraints and script logic.

Compared with a bridging mechanism that hands asset adjudication authority over to another set of consensus nodes, this approach—using Bitcoin’s native Timelock to bound the worst case—is more compact. But the risk is that the length of the dispute period is directly tied to the block confirmation speed on-chain. When the network is congested, transaction fees spike, and the cost and delay of initiating a challenge may rise significantly—placing heavy demands on incentive design and judgment about miners’ packaging priority.

Whether this mechanism can be triggered in a timely manner during real high-frequency operation on the mainnet, the real “gas friction,” and whether the challenge path remains workable under extreme market conditions are still hard metrics that need to be observed. @BabylonLabs_io $BABY #baby

I’ve been researching how to enter DeFi with BTC without compromising. TBV’s answer is a pretty good one.

As a long-time user, I went ahead and laid out the pros and cons of a few BTC collateral approaches side by side. What I found is that Babylon TBV makes a clear trade-off in its trust model. A common past approach was to move or wrap BTC into other environments—liquidity comes up, but you have to trust that the operator won’t run into problems or get attacked. During my own time holding coins, I’ve seen risks like this, so I always kept a healthy level of caution.

TBV chooses to leave the BTC where it is and create a personal Taproot-script vault directly on the Bitcoin chain. You participate in pre-signing to lock funds. On the DeFi side, collateral status is confirmed in real time through cryptographic proofs, supporting actions like borrowing and lending. Activation and redemption rely on atomic mechanisms plus BABE challenges to enable cross-chain verification. The script ensures that funds can move only when the conditions are met. Each vault is fully isolated—like a private vault—without mixing in anyone else’s funds.

The brilliance of this design is that it achieves maximum compatibility with minimal changes: native BTC as input, proof generation and state synchronization in the middle, and outputs that depend on consensus across the two chains. It doesn’t outsource control. It keeps the self-custody “soul” of Bitcoin. For people who want to use their coins but don’t want to take risks, this feels practical.

I’ll still stay rational and keep scrutinizing. Is the liquidation flow agile enough when the network is congested? Will integration complexity deter some developers? Will ecosystem partners be willing to optimize existing systems for native collateral? These engineering challenges will determine how far it can go.

After playing in this space for so many years, I increasingly feel that great technology reduces reliance on trust and increases reliance on code. TBV is trying to make BTC usable without losing its core attributes. That shows me a path to balance. When assets can be stored safely and still create value within a controlled scope, perhaps we gain a stronger sense of control over the future. In the end, the story of wealth is still about who truly holds the keys.

$BABY #baby @BabylonLabs_io

After flipping through the latest Trustless Bitcoin Vaults (TBV) architecture diagram released in the dead of night, @BabylonLabs_io —my first thought was: this design is kind of interesting. It seems to redraw the “trust boundary” in on-chain finance.

For a long time, the default solutions everyone expects for BTC participating in external ecosystems have basically been “bridging” or “wrapping.” But no matter how fancy the packaging looks, the underlying logic is the same: first hand BTC over to third-party custody, and then get a certificate in return to run liquidity. In other words, it trades away Bitcoin’s most precious native security for an interest-bearing entry ticket.

What’s most thought-provoking about TBV is that it rejects this “exit inertia.” It leverages BitVM3’s proving capabilities and Taproot outputs to lock assets firmly in Vaults that are on the Bitcoin chain and controlled by users. More importantly, each Vault is an independent UTXO-isolated unit—there is no shared liquidity pool, so it avoids systemic risks like “one move triggers everything.” When external protocols (such as lending or liquidation systems) need to interoperate, TBV doesn’t force Bitcoin to read the heterogeneous chain states. Instead, it compresses the external logic into fraud proofs and state constraints that Bitcoin’s native scripts can recognize.

At its core, it’s not trying to persuade users to sell their BTC or “swap it for another asset.” Rather, without weakening Bitcoin’s own security model, it gives native BTC the ability to penetrate and interact with external financial logic. If large-scale operation in the future can continuously maintain low verification costs while keeping high security, then this might be the true technological foundation for paradigm innovation in the BTCFi space.
$BABY #baby

TBV makes me rethink that old term “self-custody”

After reading Babylon’s whitepaper last night, one concept kept spinning in my head: that pre-signed transaction graph. I used to think that if BTC wanted to play DeFi, it had to compromise—either by bridging or by relying on custody. But TBV uses Taproot on Bitcoin to pre-sign every possible spending path and effectively lock it in advance. The user signs themselves; the Vault Provider and the keepers also sign—but once everything is signed, nobody can come up with new tricks. From start to finish, BTC stays locked in its own UTXOs, like a safe that only accepts the pre-set keys.

What I, as a longtime crypto person, appreciate most is its realism. It doesn’t force Bitcoin to be rewritten into an EVM. Instead, it honestly admits the limitations of Script, then uses BABE to translate external DeFi state—via ZK proofs and garbled circuits—into something Bitcoin can verify. When withdrawing or settling, you must submit proofs. During the challenge window, anyone can question it, and if it’s wrong, it’s invalid. There’s no middleman quietly moving your funds, and no shared pool mixing everyone’s risk together.

Of course, it’s not perfect. A pegin has to wait for confirmations, the challenge period is three days, and once it scales, will gas and coordination costs become a headache? I’m still observing. During settlement, the vault is intact and can’t be dismantled—you still need tricks like a sacrificial vault. But compared with schemes that suddenly become centralized or rely on multisig, it at least minimizes trust. It doesn’t sell off Bitcoin’s security boundary in exchange for liquidity.

What really moved me is this idea: Bitcoin doesn’t need to turn into another smart-contract chain. It just needs to keep its own rules, and then, through cryptography, it can “understand” the conditions of the outside world. Control always remains in the native network—this is the greatest respect for BTC holders.

In an increasingly complex financial world, do we really want to hand over the keys to someone else just for yield? TBV’s answer is hard-core and also philosophical: true financial freedom may be that stubborn insistence that your assets always follow your own rules.

@BabylonLabs_io $BABY #baby

Bitcoin collateral finally doesn’t rely on other people anymore — TBV shows me something different

Over the years, I’ve stepped into too many traps and seen projects that “optimize utilization” by pulling users’ BTC in, only for things to go wrong when the bridge breaks or multisig issues arise, leaving people with nothing but losses. So when I first saw Babylon’s Trustless Bitcoin Vaults, I was skeptical at first, then slowly came to trust it.

The core logic is actually pretty down-to-earth. You keep BTC in a Taproot address on the Bitcoin main chain—basically, you’re building yourself a smart-lock safe. The rules for this lock are determined by external DeFi contracts, such as lending protocols. Once repayment is complete or the conditions are met, the BTC can be unlocked and withdrawn by verifying everything on Bitcoin using zero-knowledge proofs. The whole process has no middleman custody, no wrapped assets, and no cross-chain transfer risks. Want to move your coins? You must provide mathematical proof; otherwise, during the challenge period anyone (especially you yourself) can stop it. Compared with previous “team-trust” style solutions, this is clearly more hardcore.

As a longtime user, I find this especially pragmatic. Bitcoin’s biggest value has always been its simplicity and security. Now with TBV, it can be used as collateral for lending or other scenarios—without sacrificing self-custody. Imagine your BTC is no longer just sitting in a wallet doing nothing, but can support stablecoin issuance or other financial plays, while still being anchored to the safest chain. For those big holders who don’t move their coins much, this is a solid way to open new doors.

@BabylonLabs_io focuses on this kind of trustless design. Based on what I’ve observed, execution has been fairly steady—no endless hype. The role of $BABY in vault management and related incentives is worth continuing to watch. #baby

I’ve always believed that the essence of crypto is to return power from centralized entities back to individuals. TBV’s attempt doesn’t come with slogans—it strengthens Bitcoin’s boundaries step by step with scripts and proofs. It reminds me why we keep hodling: not just for price growth, but to hold onto that commitment to self-sovereignty in a noisy market. No matter how complex the technology gets, the real test is still whether ordinary holders can truly control their assets without depending on anyone. #baby $BABY

Bitcoin no longer has to be “custodied”—my honest take on Babylon TBV

To be honest, after years of watching one after another “put Bitcoin into DeFi” proposal, I’m honestly a bit numb. They constantly ask you to swap your real BTC for a wrapped version, hand it to a bridge or a custodian, and then pray the other party doesn’t run off. So what happens? Only 1% of the BTC actually moves—most of it just lies in cold wallets, like a miser that can’t earn any yield.

Recently I tried Babylon’s Trustless Bitcoin Vaults (TBV), and it finally hits the pain point. Your BTC never leaves the Bitcoin chain at all; it’s locked inside a Taproot script that you participate in signing. It’s like your own private safe. Each vault is independent, doesn’t mingle with anyone else, and nobody can take your coins to rehypothecate.

Let me vent a bit: in the past, those cross-chain solutions always made me feel like I was storing my home’s gold bars in a bank vault—except the key is controlled by someone else. Now TBV feels more like you dug a cellar yourself, buried the gold bars, and only published the evidence—“proof of how much I buried and that the conditions are met”—so you can withdraw. This combo of Bitcoin scripts, ZK proofs, and a BABE challenge period minimizes trust. In practice, peg-in requires waiting for Bitcoin confirmations, and redemptions have a few days of challenge window, but the sense of security is off the charts.

Of course, it’s not perfect. Bitcoin scripting has limitations, and proof verification isn’t cheap. Adoption also takes time and more applications to integrate. But compared with the previous “just trust us” style schemes, this is a solid, practical step forward. Babylon brings Bitcoin’s native security into a wider DeFi world, instead of forcing a redesign of BTC.

As a long-time crypto player, what I appreciate most is this uncompromising attitude: no sacrificing self-custody, no playing wrapped-token games—just taking on the problem head-on with pure cryptography. @BabylonLabs_io

Finally, think about it: from the very birth of Bitcoin, it represents a philosophy—don’t rely on anyone; live on code and consensus. TBV extends that spirit into DeFi: your wealth is still yours, but now it can finally move to serve more use cases, instead of sleeping forever. Maybe that’s the true essence of crypto: return to the roots, yet open a new door. Definitely worth paying serious attention.

#baby $BABY

My Real Take on Babylon TBV: Bitcoin can finally get moving—but don’t shout “hurrah” yet

Honestly, I’ve been in crypto for almost a decade. I’ve seen too many projects hype Bitcoin as a universal key, only to end up bridging a pile of complications or having the custodian disappear. Babylon’s Trustless Bitcoin Vaults (TBV) caught my eye—and still, it keeps me on alert.

I recently studied their setup closely. In simple terms, you lock BTC in Taproot scripts on the Bitcoin chain, like building a private safe. This vault is directly tied to smart contracts on external networks—for example, Aave v4. Want to borrow a stablecoin? No problem. Zero-knowledge proofs verify that you’ve repaid on the target chain or met the conditions, and then you can withdraw the BTC. The whole process doesn’t require anyone to hold your keys for you, and you don’t have to move your funds to another chain. The challenge-window mechanism acts like a public oversight guard: if someone tries anything fishy, any valid challenger (including you) can stop it. Sounds pretty solid, right? It’s far more reliable than the usual multi-sig committees—those always remind me of old custody scandals.

From a veteran’s perspective, I appreciate this pragmatic approach. It doesn’t chase flashy cross-chain bridge narratives. Instead, it hard-codes the rules into Bitcoin scripts and cryptographic proofs. Bitcoin holders can finally put idle coins to work—using collateral loans or participating in more DeFi—without the classic anxiety of, “Is my money still in my hands?” Compared with traditional wrapped BTC, this reduces a lot of the attack surface and boosts capital efficiency by a noticeable margin. That said, I’ll have to nitpick: the current implementation still depends on challengers and proof generation, and the operational barrier is still a bit high for ordinary people. Not everyone is willing to monitor fraud windows or handle ZK proofs.

@BabylonLabs_io seems pretty earnest in this area—they focus on self-custody and Bitcoin-native design rather than empty promises. $BABY tokens are said to play a role in vault operations and security mechanisms, and I’m looking forward to seeing it actually implemented. #baby

At the end of the day, Bitcoin was born out of skepticism toward centralized trust. A TBV-style design brings back why we first entered this space: replacing blind belief in people with code and math.

Buy more and you’re eating again!
Big pie and Ethereum both deliver triple profits.
Feeding-style entry points—brothers who followed should have had their share.

Just a couple of days ago I kept saying don’t chase; wait for a pullback to enter. Back then, a lot of people thought the rally was over, but I was more willing to wait for the price to return to the planned level.

BTC entered around 64,000, and ETH was picked up around 1,860. Now it looks like the market still gave the profits it was supposed to. $BTC

GRVT made me, this old trader dog, rethink how capital should live

Honestly, after nearly ten years in this market, I’ve seen too many projects shouting slogans while leaving funds stuck, unable to move between different accounts. Trading transfers, withdrawals, waiting for confirmations—capital efficiency so low it makes you want to curse. Then I came across GRVT, and it finally felt like someone is actually taking this mess seriously.

Recently I ran a few positions on their platform. My real feeling is: when the same USDT is put in, it can work as margin for perpetual contracts with 50x leverage to trade BTC or oil gold RWA, while also automatically earning the yield. Not that fake, overhyped APY—real yield coming from protocol fees and external DeFi flows. The funds are not idle, and you’re not forced into an either/or choice. This is the “capital drag” issue I’ve complained about for a long time, and it finally has a practical solution. Order matching is as fast as a CEX, settlement uses ZK proofs on-chain, and the self-custody keys are still in your own hands—so you don’t have to worry about the platform running off with funds.

I also tried their Strategies feature. I picked a few verified manager strategies and allocated a small portion. Managers can move positions, but they can’t touch my principal. Positions update every four hours—protecting their edge while giving me peace of mind. It’s transparent and transferable, like finding a reliable trading operator to do the work for me, without signing any custody agreement. This is far better than being locked into traditional funds. Still, I have to complain a bit: for now, discovering strategies requires you to spend more time selecting them yourself. If the recommendation system were smarter, it would be even better.

$GRVT’s token is coming. As a holder, you’ll get better fee rates, a higher share of returns, and various practical benefits. Fixed supply of 1 billion tokens, with no乱发 (no random extra minting)—that’s something I appreciate. They’re not just another project shouting big slogans. They’re truly combining trading, earning yield, and investing together, so money actually moves.

One final thought, said a bit louder. Money has never been “dead”; it’s a concentration of time and choices. We exchange our lives for it, yet we often let it sleep in various silos. GRVT reminded me that a truly great system is one where every single dollar stays awake, stays busy, and works for you. Respecting the productivity of capital may be the same as respecting our own limited lives.

@grvt_io #grvt

Don’t be dazzled by the Mainnet Beta—let’s talk about the “blood-on-the-blade” details Newton didn’t disclose

When the Newton Mainnet Beta went live, a bunch of people started cheering. I spent the whole night digging through the technical whitepaper, and everyone was praising that hot, all-the-rage AVS and dual verification. But I noticed a little-mentioned niche detail: the “Shadow State Pipeline.”

In simple terms, it runs a shadow pre-simulation of your multi-chain complex strategies in an off-chain sandbox, generates a proof of instantaneous state, and then hands it to the validation network. The clever part is that it saves on on-chain space, so high-frequency automated trading doesn’t end up burning Gas to astronomical levels. But every coin has two sides. Between off-chain simulation and off-chain settlement on the real network, there’s a “time-gap blind spot.” In extreme market conditions, if the price data source is even slightly skewed, the shadow state can turn into a “ghost state,” and the strategy may end up missing the mark entirely.

That’s why big players still haven’t dared to hand over their core sovereignty. Security and efficiency are never the two ends of a balance; they’re a never-ending game of dynamic trade-offs. Code can build a perfect digital labyrinth, but it can’t tame human greed or the market’s unpredictability. When we strive for ultra-advanced automation on-chain, we’re essentially trying to use technological determinism to fight the ultimate increase in entropy over time. But don’t forget: before absolute rationality is truly achieved, all those precise machines are just walking sticks we use to feel our way forward in the dark forest.

What’s everyone’s take on the outlook for @NewtonProtocol ? $NEWT —are you holding it for self-defense, or waiting for the wind to come? See you in the comments. #Newt

After the CPI was released, the market finally found a direction.

With the CPI coming in below market expectations, the market’s initial interpretation was mildly bullish—rate-cut expectations warmed up, and risk assets moved broadly higher. But what I care about isn’t the headline itself; it’s where the price settles after the news lands.

Looking at the candlesticks, BTC has returned to the 64,000 area near the resistance zone—this was also a previously dense consolidation and trading area. ETH is now in the 1,870–1,885 range, not far from prior high resistance.

News can drive sentiment, but what truly determines the trend is liquidity (positioning) and where price is.

If BTC can hold above 64,000 effectively, the next step could be a further test of 65,000–65,500. If it spikes higher but fails to build volume, a pullback to 63,200–63,500 would actually be the area I’d focus on more.

ETH is similar: the key is whether it can break above around 1,900. Until it holds that level, I’d rather wait for a pullback and confirmation near 1,830–1,850 than chase higher prices now.

The data may affect day-to-day sentiment, but a trend won’t end because of a single CPI print. Trading still depends on levels, not on sentiment #美国6月CPI降至3.8% $BTC