老青蛙BNB

Yesterday I double-checked the staking data for <0-9>@BabylonLabs_io </0-9> and entered the two figures into a calculator. I pressed through, cleared everything, and re-entered them twice. The vault holds 56,853 BTC locked up; at the current price that’s roughly $3.7 billion. But BABY’s circulating market cap is only a bit over $50 million.

When the market judges how much a project is worth, the usual move is to check the market-cap rankings, then glance at the unlock schedule. The pricing logic is pretty routine. But the staking protocol keeps a second ledger—how much value users actually lock in real assets—and that rarely gets placed side-by-side with market cap for comparison.

I verified the figure of 56,853 from two sources. Babylon’s official dashboard matches third-party TVL statistics. Using today’s BTC price of $64,000, it comes out to about $3.6–$3.7 billion—making it the largest Bitcoin staking protocol locked across the entire network. On the other end, BABY has about 4 billion circulating coins, with a unit price around $0.013. That puts its market cap in the $50 million range. Divide the two and you get a multiple of over 70.

Only after looking at this level did it really hit me: the two ledgers measure fundamentally different things. TVL isn’t recording how much the project is worth; it’s recording how much money people are willing to hand over to these rules. Market cap is recording how much the market is willing to pay for the token’s functionality. One ledger is about security, the other about pricing; between them sits a BTCVaults revenue loop that hasn’t fully run yet.

Of course, a mismatch doesn’t automatically mean an undervaluation. If you switch to FDV, the multiple shrinks to the low 20s. The BTC currently in TVL doesn’t generate revenue for the protocol. Stakers earn inflation rewards—so this ledger isn’t connected to the token’s cash flows. Whether $50 million is expensive or cheap, I can’t draw a conclusion.

So what this set of data truly leaves behind isn’t an answer, but a question. Is the market correctly pricing BABY’s functional value, or is it overlooking the 50,000+ BTC in the vault that will eventually need to be reflected on the same balance sheet? What do you think the market is missing—exactly? #baby $BABY

Before the Trustless Bitcoin Vaults whitepaper by Babylon, I carried two questions: what is the collateralization ratio, and where should the alert line be set. After reading it twice, I couldn’t find a parameters table, yet I got stuck on an example. Bob takes 1 BTC and borrows $50,000—if it falls below $50,000, it gets liquidated. The whole paper contains no LTV numbers. I was stunned; maybe I looked at the wrong thing.
In past lending and liquidation, the platform set the parameters. Collateral ratio, liquidation thresholds, and penalties were all written into the contract; the oracle quotes, and when it hits the line it closes the position. Users only watch the health factor. In short, the rules are written by the platform—trust is bundled into it too.
The thinking behind @BabylonLabs_io doesn’t follow this line. The vault is an independent UTXO. When you lock the coins, you pre-sign a batch of Bitcoin transactions, hard-coding the conditions: once you repay, you can redeem; if the market price falls below the agreed threshold, the other party can liquidate. The official calls this a “cryptographic proof of external contract state” that is gated and verified via BitVM3. The liquidation line isn’t a platform parameter; it’s the condition you hard-coded when you signed.
What changed my mind is that there’s basically no platform setting an alert for you here. The safety boundary is fixed at the moment you sign; afterward, you can only monitor prices yourself, adding collateral or repaying in advance. It’s still at the PoC stage, and the VaultBTC experiment market on Morpho only has liquidity of a dozen or so dollars.
The pitfall still has to be laid out. According to the whitepaper, liquidation is triggered by whitelisted liquidators watching the price—it’s not completely permissionless. The whole flow is still hanging on the oracle, so if the oracle quote is wrong, the judgment follows it and goes wrong too. These steps won’t steal your BTC, but they could get you liquidated by mistake.
So I think TBV isn’t really building a borrowing product with better parameters—it’s turning liquidation from a platform rule into cryptographic conditions that you have signed yourself. Will the big pie be forced-liquidated? The answer isn’t in the alert button; it’s in those transactions you signed. Whether you can withstand it with real money is another question.
#baby $BABY

Scrolling through my phone at dawn, I saw yet another new chain announcing that it has integrated Bitcoin security. It reminded me of those chains from three years ago that kept propping up their validators with crazily issued tokens—back then, their token price was already doomed by inflation before it even launched.
Following this announcement, I found the document at @BabylonLabs_io , and suddenly I realized that the “Bitcoin staking” narrative has another side to it: for new chains, it’s effectively a cost-cutting and efficiency-accounting deal.
First, credit where it’s due. The hardest part of a new chain’s cold start is security. If you “self-host” validators, you need to use high-inflation tokens to incentivize them—basically trading token price for security. Babylon lets new chains switch to renting BTC as collateral, paying rewards to Bitcoin stakers instead. That means no need for疯狂增发 tokens, and the value anchor is actually steadier. For users participating in mining on these new chains, reduced sell pressure is indeed a real benefit—and I think this logic holds.
But the reality is that security isn’t a commodity you can buy outright with money. What the new chain buys is verified eligibility. But who gets the authority to set the rules for judging whether stakers violate them? The answer lies in the policy and governance process. If the downstream chain’s governance transparency is insufficient, rules can be changed by a small group of people at any time—then this rented security could become meaningless paper, and miners would face the double risk of both token price and governance rules.
I won’t make any promise that a new chain will be more stable just because it uses BTC collateral, because disclosures of governance details are still a gap—and the gap itself is the risk. Would you pay for a new chain backed by BTC? By the time I finished writing this, the sky was just starting to brighten.
#baby $BABY

Bitcoin beat someone up 😱

Not long ago I had tea with an old friend and we talked about Bitcoin investment and wealth management. What everyone fears most is sending their coins to a platform just to get a different number—this obsession with maintaining control over assets is, in essence, the plainest form of psychological safety for old “cultivated” investors. The core of earning interest by holding coins and letting them “grow” is the transfer of the creditor’s claim: once the coin leaves your address, what you have left is only a fragile promise of redemption. If the platform goes under, that promise becomes worthless.
Until I handed over the document numbered @BabylonLabs_io , explaining that the coins could stay in their own addresses and earn interest, their first reaction wasn’t excitement—it was suspicion.
It was that suspicion that pushed me to study its underlying logic in depth. I found that, at the mechanism level, it redefines transactions: by embedding Timelock constraints into the mainnet scripts, Bitcoin can enter a contract-locked state without surrendering the private key—turning it into “active money” that can earn yield. Your coins always rest in your own address. There’s no cross-chain transfer; they’re simply wrapped in rules about time and conditions. The rewards are the price paid by the downstream PoS chain for that safety.
$RIF
It uses EOTS to bind behavior to assets: once the downstream chain performs a double signature, the mainnet-locked coins will be subject to forfeiture. “Trust” in the mechanism replaces “trust” in people. But the reality is that holding the coin doesn’t mean holding the power. That Script has already preset a path for forced execution. Who constrains the authority to change the downstream Policy? The document doesn’t answer that.
$ON
I verified the unlock-trigger process in the Babylon documentation three times, and the permission definition for the emergency circuit breaker remains unclear. I won’t fill this gap for the official—an information gap in itself is risk. How far do you think this kind of design, with coins in hand but power outside, can go? By the time I finished writing, the tea had already gone cold. #baby $BABY

Liang Wenfeng knows we should place multiple bids for the new stock offering 😄

After deploying the automation strategy to an intelligent wallet, I found that while account abstraction solves the transaction-sending problem, it does not define the boundary of the agent’s permissions. Batch transactions and gas prepayment reduce signatures, but when I deliberately swap the target protocol and increase the allowance, the wallet can still construct a UserOperation. After comparing the EntryPoint validations with the strategy contract’s returned data, I confirmed that the final limitation comes from @NewtonProtocol rather than the wallet interface.
$BILL

The core value of account abstraction is to improve the experience: it can bundle multi-step calls and handle gas. But once the automation agent is connected, the intelligent wallet only gains more flexible execution capability. Which assets and protocols the agent can call, and how much allowance it can spend, still requires additional rules management. A more flexible execution wrapper does not mean the actions are inherently safe.
$PALU

Newton Protocol neatly fills the gap in the decision and constraint layer. Strategy constraints predefine which tokens the agent may access, as well as the target protocols and allowance limits. simulatePolicy rehearses asset changes before execution, then passes the result to the smart account for validation. Account abstraction is responsible for completing on-chain calls, while Newton Protocol determines whether the call complies with the user’s intent. Even if the agent changes routes, it still cannot step outside the permission boundaries defined by the contract.

This establishes a sensible division of responsibilities. The smart wallet makes on-chain operations more convenient, and Newton Protocol ensures that automation permissions remain controllable—usefulness and manageability need not sacrifice each other. The more important verification for what comes next is whether, when a strategy update and account recovery occur at the same time, the old permissions can be thoroughly cut off. The smart wallet provides the execution body, but safety instructions must have an independent and verifiable emergency brake mechanism. True automation trust is built on perfect decoupling between execution and constraints.#newt $NEWT

Stealing strategies happens often not because someone accidentally slipped their words, but because on-chain records reveal all your hidden cards. Nowadays, most DEXs default to publishing wallet addresses and fund-flow directions. If others follow the timeline and watch a few times, your initial position direction and your DCA/add-later cadence are completely exposed. @grvt_io is all about trading privacy—not bragging about being invulnerable to copycats, but truly reducing the direct on-chain exposure of your trading intent.

I reviewed on-chain data from an active address once. A single transaction record might not show much, but when you overlay transfers with balance changes, you can clearly see when they built positions, where they topped up/added to protect, and when they reduced exposure. Retail traders may not care, but for whales and market makers, this is a disaster: getting front-run and having your strategy copied. Slippage also tends to get worse.

The real issue lies in the public execution environment where everything is on-chain. Once orders and account states are written in plain text to the blockchain, data analytics tools can map out a complete behavioral profile. The money is still yours, but the strategy path becomes public data. The larger the capital, the more regular the actions—and the cost of having your intent exposed becomes far more painful.

GRVT’s solution is to separate verification from disclosure. Orders are handled off-chain in an order book, while settlement uses Validium based on ZKsync. Transaction data stays off-chain; only zero-knowledge proofs are used to verify state updates. There’s no need to publicly reveal all margin and trade details. This greatly increases the difficulty for others to reverse-engineer your strategy from on-chain data.

That said, we should also be objective: privacy protection doesn’t mean absolute invisibility. Your on-chain transfers, interactions with external wallets, and even your order-placement habits may still leave traces. GRVT solves the problem of public exposure surfaces—not making you fully disappear. This direction has real value, but where the privacy boundaries truly are, and what the long-term results look like, still needs time to be tested. #grvt

When the capital size of the same strategy scales up from small tests, my focus on @NewtonProtocol shifts away from returns and toward why the Agent can accommodate a larger capital volume. In small trades, an occasional abnormal slippage can be treated as execution error, but once the funds are amplified, even tiny route deviations or permission boundary breaches can become real asset losses. To confirm that the Agent always adheres to the rules, I have to manually cross-check the calldata of several trades, the approved allowances, and the final settlement outcomes one by one. This validation work is far more time-consuming than assessing the strategy’s profitability.

The bottleneck of traditional Bots often isn’t that the strategy isn’t smart enough, but that as the capital size increases, the cost of trust rises exponentially. Users typically can only see backtest data and the final trade results; they cannot inspect whether the code running in production has been secretly replaced, nor can they verify whether the Bot temporarily expanded its authorization scope while running. A black box that holds asset permissions over the long term cannot, even with perfect historical performance, be allowed to redeem unconditional trust.

Newton Protocol’s breakthrough approach is to verify first, then scale up. It provides strategy constraints that strictly limit the callable contracts, the maximum limit per transaction, and the effective time window. It uses simulatePolicy to preview asset changes before execution, and it cryptographically proves and tightly binds the code state to the task outcome. Under this mechanism, the Agent can search for the optimal execution path within the rule framework—yet every action must leave behind evidence that can be independently verified. This means that the safety of large allowances is built on rigorous code rules, not on the operator’s credit endorsement.

That, in turn, is Newton Protocol’s redefinition of the direction of Bot evolution: strong capability only means it can complete tasks, but verifiability determines whether it deserves to manage more capital. Admittedly, Newton Protocol still needs to prove that in high-frequency scenarios its verification mechanism won’t drag down execution efficiency. But when dealing with large assets, being fast by a few seconds is far less important than clearly proving how the funds are used. True capital trust should be strengthened as more verifiable evidence is produced—not blindly accumulated as runtime increases.#newt $NEWT

To figure out exactly where a cross-chain operation is costing money, I broke down the different paths provided by @NewtonProtocol item by item. The lowest-quoted option doesn’t necessarily end up being the cheapest. One route has a lower bridging fee, but it adds an extra asset exchange, and after funds arrive you still have to do an additional authorization. Once you account for slippage and the Gas on both sides, the final cost is actually higher than taking the direct route. I matched the estimated values against on-chain spending over several rounds before confirming that the issue comes from the quotation’s assumptions, not an abnormality in any single transaction.
In a multi-chain environment, Gas optimization is never just about finding the network with the lowest fees. The congestion level on the source chain, the bridge fees for the cross-chain transfer, and the liquidity on the destination chain all affect the final expense. More subtle still is confirmation time. If a “cheap” route takes longer, price fluctuations during the wait can wipe out the savings. Many routes only compare the numbers at the moment the transaction is initiated, and don’t continuously verify whether the entire path still remains worthwhile.
Newton Protocol’s role is closer to a constrained path-decision system. After the user provides the target chain, the expected receive amount, and an acceptable time window, simulatePolicy can preview the net received outcome for different routes. Policy constraints limit which cross-chain bridges and asset amounts the agent is allowed to use. Execution nodes can adjust routes based on real-time Gas changes, but they can’t use fee optimization to expand authorization scope.
Therefore, what Newton Protocol calls “low cost” isn’t just about a single step being cheap—it’s about compressing the total cross-chain end-to-end expense. Whether it can quickly abandon an invalid route when the chain suddenly becomes congested is something I’ll focus on verifying next. The current data isn’t enough yet, so I’ll hold off on a final judgment. #newt $NEWT

Used to centralized exchanges, the hardest habit to quit is that convenient feeling of “order placed = filled.” What’s even harder to ignore, though, is the unease after you hand over your funds. When the market gets urgent, I still worry about the withdrawal channel and the platform’s reserves. To figure out exactly where @grvt_io keeps control of the assets, I ran through the deposit, order placement, order cancellation, and withdrawal processes, then cross-checked the on-chain records several rounds. Most of the time was spent confirming who signs each step and where the settlement happens. $BEE
Longtime users still remember when exchanges blew up. The issue has never been just a management mistake by one platform. It’s that traditional CEXs concentrate custody, matching, and settlement within the same backend system. The order book is fast, but account balances are just numbers in a database. Users can’t continuously verify the status of their assets. Once a platform misappropriates funds or halts withdrawals, there’s almost no room to regain control. $OWL
GRVT breaks this structure into two layers. Orders first enter an off-chain centralized limit order book, preserving the smooth experience of low-latency matching for placing, canceling orders, and checking positions. Asset transfers and final settlement return to a Validium based on ZKsync, with state updates verified via zero-knowledge proofs. The “hybrid exchange” GRVT talks about isn’t about mixing two labels. The key is to have matching efficiency and fund custody handled by separate mechanisms.
Self-custody doesn’t mean risk disappears, either. You still need to consider lost private keys, smart contract failures, and Validium data availability. In extreme cases, whether you can exit smoothly is worth testing. But compared to handing over your coins entirely to a platform, GRVT at least offers another trade-off. Trading can feel close to CEX-level convenience, while you don’t have to give up control of your funds completely.
What I want to focus on next is the withdrawal path under abnormal conditions and the proof generation speed. Security can’t be built on marketing pages—it still has to be established through long-running verification. GRVT’s approach is reasonable, and the engineering bar is also not low. I’ll keep running it for now, not rushing to conclusions.
This version mainly adjusts the opening: it directly tackles the tension between convenience for long-time users and fund safety, then naturally leads into GRVT. The project name is kept three times, but scattered throughout the body to avoid rigid, ad-like repetition. #grvt

Last week, while testing the automated trading flow for <c-1/> @NewtonProtocol , I set myself a very specific rule: if Coin A rises more than the set threshold, sell Coin B, then convert the proceeds into Coin C. It sounds like just three steps, but when you actually run it, it gets stuck at the handoff between states. After the first trade, the balance update, the change in slippage, and the next authorization all have to align at the same time. Figuring out how to pass the conditional parameters took quite a while, and I cross-checked the data returned by two interfaces several times. $BEAT
This isn’t that the front-end buttons are unusable; it’s that most on-chain automation still relies on stitching together manual trading flows. The wallet handles signing, the script handles listening, the bot handles execution—each layer holds part of the permissions, but there’s no unified verification boundary. Once Coin A triggers, how much of Coin B to sell, whether Coin C can be bought within the slippage range—if any step’s state expires, the whole strategy deforms. What’s often called “automation” is, in many cases, just swapping the manual task of watching the market for a long-running private-key script.
What’s truly worth studying in Newton Protocol isn’t that it presses a trade button for users, but that it breaks a combination of conditions into verifiable execution rules. The strategy is first run through simulatePolicy to rehearse it, checking the asset ranges, limits, and trigger conditions, and then strategy constraints determine what the proxy account is allowed to do. Execution nodes can only call transaction paths within the authorization boundaries; on-chain verification confirms whether the outcome matches the original intent. $XPIN
This makes Newton Protocol more like an automation permissions-and-verification infrastructure layer. It doesn’t solve “whether you can automatically sell tokens,” but rather how to constrain an executor and how to validate the process when complex conditional triggers happen in sequence. Newton Protocol’s threshold is still relatively high, and state competition under abnormal market conditions still needs further testing. I plan to keep observing for a while longer; I’m not rushing to draw a conclusion. #newt $NEWT

When my phone is most busy, the exchange app, the wealth management app, and the overseas brokerage app line up in a row. Last night I wanted to rebalance my holdings: first sell the coins, then wait for the funds to arrive, convert to stablecoins, and finally switch networks for confirmation. After wrestling with it for twenty minutes, the market moved on. @grvt_io was my first impression: I finally don’t have to install five apps on my phone.
Old veterans of the market know this—multiple apps are not just a nuisance to the interface; they split your capital into isolated islands. Each time you switch platforms, you add another layer of funding, withdrawals, cross-chain, and account risks. Grvt wants to bring crypto trading and traditional asset entry points into the same underlying chain-based financial system, balancing privacy, speed, and verifiable settlement through a Validium architecture, ZK technology, and an off-chain order book. This direction is right—true unified accounts shouldn’t just mean stacking buttons on one page. $EVAA
But I still want to pour some cold water. It’s easy to aggregate the entry point; it’s hard to aggregate real liquidity. Trading windows for different assets, custody boundaries, quote depth, and clearing rules won’t magically disappear just because everything is handled by a single app. The interface may look unified—can the underlying capital efficiency truly be unified? What I care about most is whether, under extreme market conditions, order execution, cross-market settlement, and asset withdrawals remain smooth. Installing fewer apps but having to wait through four layers of confirmation—that’s too counterintuitive! $TAC
As for the Grvt token, I won’t only look at the price chart after it gets listed. If it can form a closed loop among fee offsets, staking security, governance permissions, and ecosystem incentives, then platform trading volume may truly take root as real demand. If its primary purpose relies on subsidies, then the so-called value capture is still just short-term “borrowed” prosperity.
So I’m willing to continue using a small position to test Grvt’s trading depth, settlement speed, and the experience of deposits and withdrawals. I agree with the direction, but I won’t put heavy weight into it just because it says “all-in-one.” Making unified financial entry points is tough work—I respect Grvt for being willing to go all-in on underlying infrastructure. The question is: when all assets are packed into a single entry point, do we get higher efficiency—or a more concentrated single point of risk? #grvt

I’m always most afraid that the position management module goes wrong when backtesting quantitative strategies. The risk-control thresholds are essentially meaningless, and a single black swan can wipe out months of profits. That fear of risk controls failing is what makes me pay extra attention when researching the DeFi Vault use case of @NewtonProtocol . Veteran players of vaults and yield aggregators know this: many liquidity pools don’t fail because the strategy is wrong, but because the risk-control rules are only written in documentation—they’re not truly embedded in the execution layer.$VELVET
The industry’s pain points are really hard to ignore. Many vaults’ checks on investor eligibility and position limits are still stuck at the manual review stage; by the time problems are discovered, it’s already too late. Newton Protocol’s approach is to turn these rules into on-chain verifiable execution logic. Using the Newton Keystore and programmable permission modules, it “welds” investor eligibility review, position limits, and counterparty screening directly into every fund in/out workflow of the vault. Whether it’s strategy rebalancing or external fund subscriptions, everything must first pass through this on-chain risk-control gate. This front-loading of safety boundaries is genuinely reassuring!
But the ideal is full; reality often comes with a hint of harshness. Even with Newton Protocol’s fine-grained on-chain risk control, delivery gaps still pose challenges. When those complex position limit rules are truly triggered under high-volatility, high-frequency conditions, can the execution layer withstand sudden congestion and latency? Or will the rules take effect only after the price has already collapsed?$TAC
When it comes to whether to go heavy on positions, I’m actually not that anxious.$NEWT plays the role of verifying node staking and covering execution fees within this risk-control system. The value-capture logic is clear, but the ceiling depends on how many vaults are willing to outsource risk control to this on-chain framework. For now, I’d rather treat it as a safety backup and observe it—quietly waiting for more real vaults to run and produce data—without rushing to place a heavy bet.
Finally, I want to pay tribute to the developers who obsess over vault risk-control infrastructure and try to code safety rules. If in the future all DeFi Vaults run on a verifiable framework like Newton Protocol, how far away are we really from the ideal state where we no longer need to worry about catastrophic blow-ups?#newt