比特发发发

I discovered that my stop-loss template had a “false trigger” one night. The reason was that the quote momentarily got a spike, and the agent immediately executed a market sell. Although the price quickly rebounded and it didn’t cause any real loss, that feeling of waking up in the middle of the night to check on-chain records—whoever uses it knows.
$BTC
I went back and reviewed the parameters in the template. The stop-loss trigger price and the oracle-fed price actually used for execution are, surprisingly, the very same data source. That means whenever the on-chain price shows a brief, violent jitter—even if it’s only one or two blocks—the agent will treat it as a real breakdown and handle it accordingly. This design has absolutely no fault tolerance, and there’s no way to add a buffer condition like “confirm for N consecutive blocks.”
@NewtonProtocol
This is a fatal flaw for highly volatile assets. In the crypto market, exchange order-book wick spikes, momentary oracle quote deviations, and cross-chain bridge price delays are not random events—they’re the norm. If every wick gets treated by the agent as a real stop-loss signal, then so-called “intelligent stop-loss” is essentially an automatic wick-harvesting machine.
$NEWT
What’s even more surreal is that ordinary CEX stop-loss orders let you set a trigger and then place a pending order; some even support iceberg orders to reduce slippage. But Newton’s “one-size-fits-all” market execution turns stop-loss into a paradoxical tool: it triggers only in the worst case, yet when it triggers, it’s still the worst case. This goes against the original purpose of risk management.
#Newt
I truly think the stop-loss template needs two immediate optimizations: first, let users choose to trigger only when “the price stays below the threshold for N consecutive blocks”; second, after triggering, support placing a limit order instead of an unconditional market dump. Implementing these doesn’t require any fundamental architectural changes—just add a lightweight on-chain judge before strategy execution. If not, then in the extreme volatility of future bull-bear transitions, the stop-loss feature will instead become a time bomb that blows up positions.

I’ve always wanted to run grid trading, but traditional DEX latency kept putting me off. This time I tried connecting my own little script to the GRVT API, and I didn’t expect the experience to be that smooth—smoother than I’d anticipated. My strategy is simple: set a BTC fluctuation range with 7,000 points, split into 10 tiers of orders, with 500U per tier, and use only maker orders to capture the rebates.
After running it for a week, I executed 93 trades in total. Most of them were taken by taker orders. The average profit per trade was between 0.8–1.2U. With the maker rebates added, my gross profit accumulated to 128U. During the process, the largest slippage came during the thinner liquidity hours in the early morning. There were two instances where my orders didn’t fully fill before the price jumped, causing the grid to shift out of position. In the end, I manually adjusted it once. Overall, it was controllable—there were no cases of liquidation or “ghost orders.”
After running this, my impression of the GRVT API improved a lot. The documentation is very clear, and both REST and WebSocket are sufficient. In tests during off-peak hours, responses came back in essentially seconds. The only thing to pay attention to is that making a large number of order updates in a short time will trigger rate limits, so you need to design a balanced grid density and refresh frequency—you can’t refresh like a centralized exchange does every few dozen milliseconds. $BTC
You can clearly feel that the platform is trying to bring CEX-level trading experience onto the chain. There are still some rough edges, but for someone like me who wants to run quant trading with self-custody, this is already a stage that’s absolutely worth trying. #grvt @grvt_io

I’ve always thought that the hardest part isn’t writing the strategy—it’s writing it down in a way that others can understand and that can’t be tampered with. Previously, my teammate and I managed a small vault together: we monitored different indicators and agreed not to interfere with each other. But once, when my monitoring showed that we needed to reduce our position, he believed it was a false signal and manually forced my trades out of the way. In the end, nothing major happened, but the trust fracture was very hard to repair. The problem wasn’t the people—it was the mechanism: we didn’t have a decision rule that we had agreed on in advance and that could be automatically executed.
Later, I tried to encode both parties’ judgment criteria into the strategy constraints for @NewtonProtocol : when my indicator reaches threshold A, and his indicator does not trigger the veto condition B, the agent is allowed to reduce the position. After this logic ran successfully in simulatePolicy, we no longer needed manual intervention—no more convincing each other. The strategy executed according to the rules, and the verification results were clear at a glance.
In everyday collaboration, what consumes the most energy is repeatedly confirming whether the other party is actually following the agreement. Newton’s approach—turning collaboration rules into verifiable policies—instantly eliminates most of the friction and internal strain. I think this is useful not only for asset management, but even more valuable in DAO vault management and multisig permissioning scenarios. You don’t have to watch the people anymore; just look at the constraints. $BTC
My next step is to also encode the spending limit and the protocol allowlist into the strategy, slowly handing everything that can be delegated to code, and leaving humans only the final veto right.
#NEWT $NEWT @NewtonProtocol

The biggest awkwardness of doing derivatives on-chain is often not slippage, but the fact that you end up becoming someone else’s “live target.” On some earlier decentralized platforms, large pending orders, position distributions, and closing records were almost completely transparent. Even a follower with a bit of experience could map your fund flows and trading habits. This is especially taboo for institutional-level trading. I used GRVT to simulate for a period of time, and found that it draws a very interesting line at the privacy boundary.
Because the underlying architecture is a Validium model based on zero-knowledge proofs, GRVT does not post the details of every individual transaction onto the public chain. Whether a transaction truly occurred and whether the state updates are compliant are vouched for by validity proofs, without having to publicly reveal all the buyer/seller parties, execution prices, or position changes. It’s like completing a trade in a sealed room that still guarantees verifiable fairness—people outside the room can only confirm that “what happened here follows the rules,” but they cannot see exactly what you did.
For ordinary users, the direct benefit is reduced risk of having their strategies tracked. Those tools that used to closely monitor large-holder addresses to trace order-entry points are essentially rendered ineffective here. For market makers and institutional funds, this means they can provide liquidity at a larger scale without exposing their own risk-control framework. At the same time, it’s not the same as fully anonymous—if you publicly withdraw using the same address, the on-chain trail will still show the destination of the funds. So a more accurate description would be “verifiable privacy,” not a black box. $BTC
Of course, privacy protection often remains in long-term tension with regulatory needs. Whether this architecture will in the future offer selectable information disclosure, or introduce compliance views, remains to be seen. But purely from a technical perspective, GRVT allows traders to no longer have to sacrifice “decentralization” for “hiding trading intent.” For advanced players, the value of that may be far greater than the few gas fees saved. #grvt @grvt_io

I wonder if you’ve noticed Newton’s strategy sharing feature has a kind of invisible social charm. Policies that users write themselves can be published so others can call them. It sounds like sharing a script, but in practice it’s more like “hiring your own AI little team.”
But I immediately thought of a real-world issue: leaving aside whether the author of a shared strategy makes money, do they actually need to be held responsible for the strategy’s performance? @NewtonProtocol currently emphasizes verifiable execution, but the strategy’s actual “quality” isn’t within the scope of verification. A strategy that looks logically flawless might, under a certain market structure, be nothing more than a consistently losing machine.
This leads to $NEWT ’s real concern: if I引用 someone else’s strategy and it causes me to lose money, do I blame myself or the author? In the on-chain world, there’s no consumer protection hotline. Newton may need a lightweight disclaimer mechanism—or at least display the strategy’s historical simulation results (even if they aren’t real funds)—so users have some vague sense of what they’re getting into before they pull the trigger. $BTC
From another angle, this could actually give rise to a new kind of “strategy auditor” role, dedicated to analyzing logic flaws and extreme-case scenarios in popular Policies. In the future, not only the code needs auditing, but the strategy itself also needs auditing. That’s what makes the AI agent era interesting: trust no longer stays only at the contract layer—it gradually spreads to the strategy ideas themselves.
#Newt $NEWT @NewtonProtocol

My friend asked me when he first started playing with @grvt_io : “Why does my account clearly show I have a large amount of U, but when I try to withdraw to my wallet it keeps saying insufficient available balance?” I had him check it—turns out he mistakenly treated the vouchers from the Unified Balance that are still within the interest-earning calculation period as funds he could actually move. This is an issue that every beginner hits sooner or later.

To maintain overall capital efficiency, GRVT has an implicit settlement window for certain assets that are locked to earn yield—especially in workflows that use Validium for data final confirmation. From closing a position to becoming withdrawable, there’s a validation “cooling-down” period that’s seemingly silent but does exist. On the surface, your balance is there; in reality, you have to wait for the underlying data’s zero-knowledge proof to complete its final verification before the funds can truly be transferred to your self-custody address. High-speed matching and fast withdrawals can’t both be achieved simultaneously in a hybrid architecture at the moment.

$BTC

My own “life-saving” approach is to always keep at least 20% of the U in my GRVT account in a naked form that does not participate in interest in any way. I don’t chase even a single cent of interest with this portion—it’s reserved specifically to cover sudden forced liquidations and urgent withdrawal needs. All funds that earn yield should be treated as meat frozen in the fridge: you don’t count them as part of your everyday liquid capital when placing orders. That way, when you need to quickly top up margin during a needle-threading market move, you won’t end up watching your frozen-window funds being taken away. In a hybrid exchange, the granularity of liquidity management matters a hundred times more than interest yield.

#grvt @grvt_io

Newton's TEE architecture has always emphasized “trust the chip, not the people,” but this slogan hides a huge logical loophole: chips are also designed by people, and the chip supply chain can also be poisoned. The list of vulnerabilities in Intel SGX over the past few years is longer than the incident lists of many DeFi protocols. From Spectre and Foreshadow to the more recent ÆPIC Leak, every attack that breaks enclave isolation is reminding us that so-called “trusted hardware” is more like a glass door locked up—yet it can be opened with a crowbar. Once the enclave memory is read, all attestation proofs turn into worthless paper, and the policy engine’s verification becomes child’s play. @NewtonProtocol
More subtly, Newton’s validators claim to run in an SGX environment, but there is no on-chain verifiable way to determine their specific hardware/firmware versions or whether the latest microcode patches have been applied. $BTC
Users can only choose to trust again. Shifting trust from people to chips, without making that chip truly auditable, is just a change of wording to keep asking people to trust—trust Intel’s engineers, trust data center operations, trust that no hacker has found new side channels. This security model is still hundreds of thousands of miles away from “no trust required.” If one day in the future Intel announces it will stop maintaining a certain SGX version, what would Newton’s security foundation still have left? This is a question every holder should be thinking about. #NEWT $NEWT @NewtonProtocol

Setting aside trading specifics, let’s talk about GRVT from the perspective of its narrative around the track it’s in. This year, the decentralized derivatives sector has been extremely competitive. Most projects are doubling down on directions like “more complex synthetic assets” and “higher leverage,” while overlooking the underlying elements that truly allow large funds to feel comfortable entering: clear ownership and permission-based tiering.

GRVT is clearly headed in a different direction. At its core, it’s building a self-custodied, institutional-grade contract trading layer. User assets stay in a self-held address throughout the entire process—exchanges never touch the funds. At the same time, it resolves internal role separation within an institution via a two-layer account structure: the boss manages the money, the trader manages the strategies, and risk control manages the limits—everything is hard-coded into the contracts. This narrative is actually much closer to the primary brokerage business in traditional finance, rather than simply launching an on-chain contract for betting.
$BTC

On the technical side, it uses ZK Validium. The advantage of this approach is that it preserves the performance of off-chain matching, while anchoring the key settlement and liquidation to Ethereum mainnet security through ZK proofs. Compared to a pure Optimistic Rollup (which avoids the challenge period), it’s better suited for financial scenarios. And compared to fully on-chain matching, the user experience is far better.

The biggest pain point across Web3 right now is that institutional capital wants to enter, but there’s a lack of compliant, on-chain auditable infrastructure. If GRVT can multi-node the off-chain engine and simultaneously connect the compliant entry points, it might not only capture DEX users, but also traditional funds, family offices, and trading teams that want to manage assets on-chain.

Of course, expectations for valuation can’t be too high at this stage. The product is still on the testnet, and the details of the ecosystem token model and node incentives haven’t been published. But seed users entering now to understand the full process end-to-end is a classic “discover early, bind early” window. After all, once the mainnet is live and data starts flying, the cost to catch up won’t be the same.
#grvt @grvt_io

Look how gleamingly the words “new paradigm economy” are painted in the Newton whitepaper. You only need to do one thing: open the token allocation table, add up the shares of the team, the foundation, and the early private placement, then compare it with the so-called “community release curve.” I used the dumbest method to scrape the on-chain genesis address and the mapping from successive linear unlocks; what I got wasn’t a Web3 pastoral dream, but a withdrawal machine controlled by a precise clock. The team’s share lock-up schedule is designed to be airtight on the surface, yet the unlocking cadence just happens to fit perfectly with every market hotspot they step on. In the last domain name auction, community enthusiasm was already hyped to the max—then a foundation address that had been dormant for two years sent 8,000,000 units of $BTC NEWT from its high point to a market maker wallet. You call that a coincidence? Then let me tell you the next one: within seventy-two hours after each round of official governance votes pass, there’s always an early seed-round address whose staking exactly comes due and exits. After exiting, it neither participates in consensus nor rolls back into the ecosystem pool; instead, it quietly flows along a certain fixed cross-chain path into some hot wallet. The amount is neither too small nor too big—just enough to sit under the lower limit that wouldn’t trigger large on-chain warnings. This kind of operation, in the literal sense, absolutely isn’t called “dumping.” It’s called “legitimate unlocking for ecosystem development,” but the concrete manifestation of “ecosystem development” is that your coins get heavier in your hand, while their addresses get lighter. The more advanced part is that these emissions are distributed across a dozen or so seemingly independent relay addresses; even if you use Nansen to track them, at first glance it will look like normal user-to-user transfers. But if you take the timestamps of all those relay addresses and run them through a Pearson correlation coefficient, you’ll find that their outflow timing can be perfectly fitted by the same Poisson process. If that isn’t proof that the same automated scripts are orchestrating everything, I’ll eat the whitepaper on the spot. Newton sells you a token economic model; at its core, it’s a liquidity chronic dehydration: the annualized yield you stake is a tempting number, while what they unlock is real hard currency. That gorgeous APY has never been a nectar of inflation compensation—it’s ether that numbs your pain nerves.
#Newt $NEWT @NewtonProtocol

I spent the entire afternoon going through GRVT’s 24-hour trading pair order flow, and found an easily overlooked point of hidden wear. Everyone focuses on the literal Maker and Taker fee rates, but very few people calculate how much the tail slippage is actually worth when orders hit the AMM curve inside a mixed-liquidity pool.
I ran a replay comparison using BTC-PERP. For the same market order of 0.5 BTC, during periods with good depth (the Asia trading session’s main force), almost the entire order goes through the order book, and the slippage is about 0.02%. However, during periods with thinner liquidity—such as the “vacuum” around European midday and right before the U.S. stock market open—the same order first knocks through the shallow resting orders in the order book, then directly consumes the AMM curve, bringing the combined slippage to roughly 0.17%. That gap is several times the nominal fee rate, but on the order confirmation page it’s only categorized as “price impact” and not broken out separately.
Many people think GRVT’s “low fees” can support high-frequency attempts at picking up points, but if you split the order into smaller pieces and enter frequently during thin-liquidity periods, the cumulative slippage damage may end up higher than the VIP3 fee rate on a centralized exchange. $BTC
I’m not saying there’s something wrong with GRVT’s model. Mixed liquidity in extreme market conditions does provide a backstop, preventing you from getting a straight-up “unable to fill” message like a pure order book would. But if you’re used to placing large orders when order book depth is weak, this hidden cost becomes a continuous bleeding point. My preliminary judgment: at the current stage, GRVT is better suited for using limit orders to participate during main-session periods, while pure market-based high-frequency strategies need to pull historical order book snapshots to make the model run correctly. Yesterday I started collecting API data for minute-level slippage sampling, and I’ll share the complete tables later.
#grvt @grvt_io

In Newton’s tokenomics model for the protocol, there’s a very “clever” design: you stake $NEWT to the operators. If the operators perform well, you and they both share in the inflation rewards. This is packaged as a “positive feedback loop for value creation.” But I’d suggest you take this flywheel apart—because it may just be an idling wheel for self-convincing.$BTC
The core problem lies in misaligned incentives. In this model, the $NEWT you stake is essentially your only contribution. The operator’s biggest “performance” isn’t providing accurate data, but ensuring they “don’t look like they made a mistake,” consistently siphoning off the monthly inflation rewards. So a tacit agreement forms: operators always choose the median of the data sources—no need to be right, as long as they avoid being wrong. Stakers see the rewards distributed reliably, and therefore feel comfortable continuing to lock their funds. The entire system falls into an economics-style “false prosperity”—the token price is propped up by staking lockups, the rewards are minted through inflation, but on the business side it creates no real value that actually needs to be solved on-chain.
Even more deadly is the so-called “punishment mechanism.” The whitepaper says it will slash or confiscate the staked deposits of bad operators. But in a system that relies on median consensus, how is “bad” defined? If I and most of my peers stay aligned, then we’re “good.” Meanwhile, an honest node that reports abnormal data due to network latency is punished as “bad” for deviating from the median. This isn’t punishing wrongdoing—it’s punishing the minority. Over time, every operator gets transformed into a megaphone that inputs the same data, and the protocol’s so-called “decentralized oracle” turns into an expensive, self-deceiving parrot. Is the NEWT in your hands also rewarding this kind of systemic wrongdoing? #NEWT @NewtonProtocol

Many strategy authors watch returns, win rate, and drawdown, but almost no one pays attention to a key metric: “quote penetration rate.” This is my coined term, referring to how deeply a strategy’s final executed price breaks through the order book. I built a small tool using Newton’s historical execution records to compare, for every trade, the expected price spread versus the actual executed price spread. The results showed that some strategies appear profitable on the surface, but their average penetration depth is shockingly high—like each trade is paying an extra, hidden “lubrication fee.” @NewtonProtocol
These fees aren’t taken by the protocol itself; they’re eaten by the hidden arbitrageurs and market makers in the Mempool. The strategy logic itself isn’t necessarily wrong, but it’s overly addicted to liquidity: it keeps sweeping the order book with market orders—pushing prices away when it enters, and pushing them away again when it exits. Especially when Newton’s strategy auto-selects a DEX route: if you leave everything entirely to the system defaults, it often prioritizes path speed rather than caring enough about the liquidity depth along the route. When a strategy repeatedly hammers a thin pool, it’s effectively siphoning value from the entire ecosystem until—eventually—there’s nothing left. $BTC
After I added a “penetration depth limit” filter to several public strategies, their annualized returns surprisingly increased by 0.4% to 0.9%. $ETH
This shows that many times it’s not that the strategy doesn’t work—the erosion in execution details is quietly consuming your life, while very few dashboards are willing to calculate it for you.
#NEWT $NEWT @NewtonProtocol