尘缘一斩缘

Happy 9th Anniversary of Binance! Let’s connect to infinite possibilities for the future—everyone, let’s do it! #BinanceTurns9 祝福

《There’s a retail protection mechanism on Wall Street—GRVT has brought it on-chain》
If you’ve ever traded stocks, you may know about Retail Price Improvement (RPI).
When retail traders place an order, the system automatically searches—beyond the publicly quoted prices—for a better execution price. If it finds one, the order is filled at the better price, and the difference goes to the retail trader.
This mechanism has been running in the U.S. stock market for over twenty years, saving retail investors billions of dollars.
But in the crypto market, nobody has really done this seriously—ever.
In the past, when I used to trade perpetuals on some on-chain DEX, I often ran into situations like this: the posted order price looked reasonable, but at execution the slippage was worse than expected by 0.3% to 0.5%.
It’s fine for small orders, but once your position gets large, that spread becomes hard to look at.
When I asked customer support, they said, “Liquidity is just like that—the market decides.”
On-chain trading doesn’t help you find a better price. You get filled at the price you posted; if the market depth isn’t enough, you bear the slippage yourself.
Recently, GRVT launched the RPI feature, bringing this Wall Street mechanism to the blockchain.
The specific logic is: after a user places an order, the system automatically looks for a better price beyond the publicly quoted prices. If it finds one, the trade is executed at the better price. The user doesn’t need to do anything extra—any improvement is credited directly to the user.
More importantly: RPI only matches orders from non-algorithmic traders.
Retail’s counterparty isn’t high-frequency quantitative bots. The mechanism design reduces the likelihood of being specifically targeted by algorithms.
I have two concerns.
First, for RPI to find a better price, there needs to be sufficiently deep liquidity. GRVT’s overall trading volume data looks good, but whether depth is enough for niche products like gold, crude oil, and Tesla for RPI to truly work—right now, I haven’t seen any publicly available, per-asset data.
Second, the price-improvement process happens off-chain, not on-chain where it can be verified. You can’t get proof of “how much this RPI saved you this time”—you can only trust the platform’s displayed numbers. This creates a subtle tension with GRVT’s narrative of “on-chain settlement that is verifiable.”
That said, simply introducing the concept of RPI on-chain is meaningful. Retail traders in crypto have long been the side with the greatest information asymmetry. The few basis points eaten by slippage every time, accumulated over time, are a real loss.
After the TGE, liquidity data stabilized. Running small tests yourself to see the actual improvement is more direct than watching any analysis.
@grvt_io $GRVT #grvt

I wrote this over the past few days on GRVT, and I’ll end with a detail that I’ve never mentioned.
GRVT supports signing up with email—no wallet needed, no seed phrase needed. The private key is split and stored using MPC technology, and you unlock it with biometrics.
The first time I saw this design, I was skeptical.
Convenience and control have always run in the opposite direction. The simpler the entry point, the often less control you have over the underlying system.
But after going through the MPC implementation logic carefully, I found that the private key is never fully present in any single place. The key shares are stored separately on the user’s device and on the GRVT node. Neither side can obtain the complete private key, and GRVT itself can’t move your assets.
This is fundamentally different from a security model like “custodying the private key with the platform.”
My concern is: if the user’s device is lost or if the GRVT node has a problem, what does the recovery process look like? Is the fault-tolerance mechanism complete enough? The documentation currently doesn’t explain this in sufficient detail.
Whether it’s easy to get in—and whether it’s easy to get out if something goes wrong—are equally important.
@NewtonProtocol #newt $NEWT

Last year I wanted to go long on gold. After researching for a while, I found there were only two options.
Either open a futures account—go through a bunch of compliance checks, deal with high margin requirements, and trading hours are also limited. You can’t even open positions on weekends.
Or buy a gold ETF, but without leverage. When the move comes, you can’t really catch it.
In the end, I didn’t do either. I just watched gold rally by nearly 20% and I earned nothing.
That experience made me realize something: when retail investors want to trade non-crypto assets, the barrier is clearly designed not for you to use.
Recently I looked at GRVT’s product lineup and saw that it offers perpetual contracts for traditional assets like gold, crude oil, and Tesla.
No need to open a futures account, no complicated approvals—use USDT as margin, trade 24/7, and it doesn’t stop on weekends.
BTC supports up to 50x leverage. For traditional assets the leverage is more conservative, but for retail traders who want to take directional bets on gold, leverage itself is something you didn’t have before.
More importantly, it’s self-custody: your assets are in your own wallet. If the platform has problems, it won’t drag your margin into being locked up as well.
My concern is liquidity.
For traditional assets like gold (XAU) on crypto platforms, how big is the gap in liquidity compared with mainstream CEXs like Binance and OKX, or traditional futures exchanges? That directly determines slippage and the quality of execution in extreme market conditions.
During GRVT Season 2 the overall trading volume looks solid, but when you break it down to niche markets like XAU and WTI, I haven’t seen any publicly available per-asset depth data.
So before you’ve figured out liquidity, directional trading is okay—but before going heavy and increasing leverage, I’d suggest you test with small orders first to see the real slippage.
@grvt_io $GRVT #grvt

Last month I helped a friend set up an automatic stop-loss strategy; it took me two hours of tinkering.
The problem wasn’t that the strategy was complex—it was translating the intent of “sell when the price drops below X” into a bunch of contract function calls.
When I finished writing it, I realized I’d missed an authorization, so the whole logic wouldn’t work; I had to rewrite it.
After rewriting, I discovered I’d gotten the units for the trigger parameters wrong, so I had to fix that too.
In the end, once it was running, my friend asked me: “What if one day the platform upgrades and this stops working?”
I couldn’t answer him.
So I looked through the Newton Protocol documentation and found that it splits this into two layers.
The Intent layer only handles “what I want to do”—for example, “reduce position when volatility exceeds a certain threshold”—described in a way close to natural language.
The Policy layer handles “whether it can be done,” separating constraint conditions from the business logic so they can be maintained independently.
The point of keeping these two layers separate is: when the platform is upgraded, Policy can be updated on its own without touching Intent, so nothing cascades into everything else.
The strategy I wrote for my friend mixed Intent and Policy together, so changing one part could break another.
I think this split is right—the real issue it solves is the engineering problem of “rules and business logic being long-term entangled so nobody dares to change them.”
The concern is: if most developers eventually just treat Policy as a one-time configuration instead of a capability to maintain independently over time, then the value of this design is diminished.
Design can solve problems, but whether it actually does depends on whether the people using it take it seriously.
@grvt_io #newt $NEWT

I was really defeated by the creator platform’s rating system.
For the hard work I put into writing, I only got a little over 2 points.
You think that’s outrageous? There’s something even more outrageous.
As long as you get above 2.8, you can rank within the top 300.
Alright, rant over. On to the main part.
It took me ten minutes to understand GRVT’s account design, and my first reaction was: this thing was not designed for ordinary retail traders $BTC .
It splits the account into two layers.
The funding account is your on-chain primary identity. Withdrawals, transfers between accounts, and permission changes all have to go through this layer. It’s cumbersome to operate, but it holds the most authority, roughly equivalent to a corporate master account at a bank.
The trading account sits underneath the funding account and is what you actually use for trading. The API can only access this layer, and the private key is not stored here.
The practical significance of this design is: even if the API key is stolen, at most a hacker can place orders for you; they can’t move the principal in your account.
This is indeed much more solid than platforms where “one private key controls all permissions.”
But the problem lies here too.
Every operation on the funding account has to go through on-chain procedures. Even moving money from the funding account to the trading account requires a signature confirmation.
For quantitative teams managing tens of millions and needing frequent position adjustments, this kind of permission isolation is a necessity.
For ordinary retail traders, the entry barrier itself is a filter—not because the rules are too complex, but because in the crypto world, rules you don’t understand are often the gateway to losses.
My judgment is: GRVT has a solid underlying architecture, and both compliance and risk-control logic have been carefully designed.
But its real target users at this stage are institutions and quantitative teams, not retail traders who only have a few thousand yuan and want to try futures.
Retail traders can participate, but this system is not optimized around them. Before using it, make sure you understand the account permission logic, and don’t dig a hole for yourself just because you don’t understand the rules.
@grvt_io #grvt

Last year I helped a friend set up an automated workflow for a DeFi protocol, and I spent three hours tinkering.
Every step requires its own separate signature; switch networks and you have to sign again; add an approval and you have to sign again.
In the end my friend said, "Forget it, I’ll just do it manually." Automation was actually more troublesome than doing it by hand.
That incident made me realize: the biggest obstacle for on-chain automation isn’t the strategy—it’s the signatures.
The Newton Protocol uses ERC-4337 smart accounts to solve this problem.
ERC-4337 doesn’t let an AI agent take your private key; instead, it encodes "what is allowed to do" into the logic of the smart account.
The agent executes only within the authorized scope, so it doesn’t need to come back for you to sign every step. But for actions outside the scope, the contract layer rejects them directly—not because the agent "has good manners."
This turns "sign every single operation" into "set the rules once, and let the agent run within them."
My concern is the security of the smart account contract itself.
The rules are written in the contract—if the contract has vulnerabilities, then no matter how carefully you define the boundaries, it won’t help.
Newton’s smart account has been audited, but a contract audit on-chain doesn’t mean zero risk. There have been cases where audited contracts were still attacked, and it’s not unheard of.
Replacing manual signing with ERC-4337 is genuinely convenient.
But the cost of convenience is shifting trust from "confirming every time" to "whether the contract logic is strict enough." Which is safer depends on which you trust more: your own judgment or the security of the contract code.
@NewtonProtocol #newt $NEWT

$DEXE opened an ant warehouse for me—let me see how things work. Without adding more, just see how high it can be pushed.

In 2022, a cross-chain bridge was attacked, and the losses exceeded $600 million.
After a post-incident review, the problem was in the bridge’s verification mechanism—verification nodes were falsifying things. On-chain records showed “transaction valid,” but the money had already been transferred away.
Since then, every time I see descriptions like “on-chain settlement, secure and transparent,” I’ve started by asking: what exactly is being verified on-chain, and what can’t be verified.
GRVT’s settlement layer uses a ZK Validium architecture built on ZKsync. Behind this choice is specific engineering logic worth unpacking.
What ZK proofs do is compress the computation results of a batch of transactions into a cryptographic proof, then submit that proof to Ethereum L1 for verification. Ethereum doesn’t need to re-execute every transaction; it only needs to verify whether the proof is valid.
This allows GRVT to process 600,000 transactions per second, with settlement security anchored on Ethereum L1.
The difference between Validium and a standard ZK Rollup lies in data storage.
With a ZK Rollup, transaction data is also submitted on-chain—fully transparent but expensive.
GRVT chose Validium—in other words, it deliberately picked “lower cost and higher speed” over “full transparency.”
That choice introduces a concrete risk: if the off-chain data availability/storage layer has issues—such as data loss or tampering—the on-chain ZK proof can’t detect that. The proof only attests that the computation result is correct; it doesn’t care whether the original data was altered.
In the 2022 bridge attack, the verification mechanism itself wasn’t the problem—the object being verified was.
Under the Validium architecture, the ZK proof verifies the computation process, but the reliability of the off-chain data layer is another matter.
GRVT currently integrates EigenDA to provide data availability guarantees. EigenLayer’s EigenDA data-layer product uses re-staked ETH nodes to ensure that off-chain data can be verified and recovered.
In theory, it patches Validium’s biggest vulnerability.
But EigenDA is still a relatively early product. Using it as a security backbone means GRVT’s security model partly depends on EigenDA’s maturity; it’s not fully autonomous.
On-chain settlement plus ZK proofs does provide a security layer that’s higher than a typical DEX.
However, the off-chain data risk of Validium is real. Whether EigenDA can hold up under extreme conditions hasn’t been tested through true stress testing yet.
@grvt_io $GRVT #grvt

There were positions on three chains at the same time the previous year—some capital was allocated to Arbitrum, Base, and BSC.
One day an opportunity came up and I needed to quickly increase my position, but the money was split across three places, and even using the cross-chain bridge would take at least ten-plus minutes.
By the time I had consolidated the funds, the opportunity had already passed—I just watched it rise 18% without getting a chance to profit.
That loss wasn’t because someone stole anything. It was because of the question of “on which chain the funds are located.”
What Newton Protocol’s Keystore Rollup aims to solve is this problem.
Users’ cross-chain permission states are unified in a single Rollup. Proxy execution on different chains all comes back here to verify authorization. In theory, the same chunk of capital can be used simultaneously across multiple chains to execute strategies, without having to manually move funds around.
My concern is that this feature is still on the roadmap and hasn’t launched yet.
What’s available right now is only the single-chain Recurring Buy.
The need for cross-chain unified margin is real—I personally lost an opportunity because of it. But Newton hasn’t solved this issue yet; they’ve only promised they will.
@NewtonProtocol #newt $NEWT

Last year I traded futures on a certain CEX. When the market suddenly moved, my first reaction was to withdraw my funds. But I found out the assets were basically not under my control—withdrawals require approval, and approval takes time. By the time it went through, the market had already changed.
The loss wasn’t huge that time, but it made me realize something: CEX speed is yours, but the assets are not.
Recently I’ve been using GRVT. Its design logic is different from anything I’ve used before.
The matching engine runs off-chain and is so fast it can reach the millisecond level. It supports 168 perpetual futures markets, including traditional assets like gold, oil, and Tesla.
However, settlement happens on-chain, so your assets always remain in your own wallet, and you don’t hand the private key to anyone.
You can have both: the speed of a CEX and the custody/control of a DEX at the same time.
Also, its market maker fee rate is negative—meaning placing orders not only doesn’t cost fees, it also pays you a rebate, up to -0.003%.
Let me also share my doubts: in a hybrid architecture, if something goes wrong with the off-chain matching layer, even though on-chain settlement is secure, your trade execution price itself may already be wrong. The risk of this layer can’t be completely solved just by ZK proofs.
Overall, using it, I’ve got both speed and asset control covered—this kind of experience is indeed not very common in the market right now.
@grvt_io $GRVT#grvt

Alpha Daily Report
July 10 (Old Coins) 245 points 17:00 Airdrop
Today’s recommendation: buy/earn coins $ARX (12 days left) or another token that will be listed within the next 30 days—points ×4
Recommended: 500 or 200 per transaction, multiple small transactions.
There should be lots of perfect scores—eat your fill if you can. I didn’t notice when I was buying the past couple of days, so I bought a few hundred less; I was short by a point, not enough to eat.

Last year I pledged a sum of money into a certain protocol, with the understanding that I could redeem it at any time.
The market turned suddenly and I wanted to exit.
System prompt: Unstaking requires a 21-day cooldown period.
During those 21 days, I watched the price drop from the high point by nearly half.
On the day the funds were finally unstaked, my balance was down by 6000U on paper.
No one stole the money, and no rules were violated—it's just that the “cooldown period” locked it up.
When I went through Newton Protocol’s staking documentation, the cooldown period is 14 days.
That’s one week shorter than my case, but the logic is the same.
Within 14 days you can’t transfer, trade, or place stop-loss.
If, during those 14 days, the NEWT price gets cut in half, all you can do is watch.
Many people only look at the APY when staking and don’t factor in the opportunity cost of those 14 days.
They also don’t factor in this: once Slashing is triggered, during the cooldown period you can’t even run—you’re stuck.
Newton’s staking rewards currently rely heavily on subsidies from the foundation; they aren’t generated naturally from protocol fees.
APY looks good, but during those 14 days, this money is in a locked state.
Before the DeFAI track can truly produce real protocol revenue from actual use, every single amount staked is trading liquidity for a story that hasn’t been validated yet.
@NewtonProtocol #newt $NEWT

Last year, I used an automation tool to set up a conditional order. The condition triggered, but the execution direction was reversed.
Buying became selling.
The loss wasn’t big—around 300 U—but when I contacted customer support, they said, "It has already been executed on-chain and cannot be reversed. No responsibility is assumed."
Since then, I’ve added one more question to "automated execution": what to do if something goes wrong, and who to turn to.
After looking at Newton Protocol’s Trustless Dispute Resolution mechanism, it’s one of the most seriously designed solutions I’ve seen for this problem.
Once a dispute is triggered, the assets are automatically frozen first—rather than waiting for manual review before anything moves.
Then it follows an on-chain arbitration process, with dedicated arbitration nodes participating in the decision. The arbitration result is then executed on-chain.
This is far more solid than "contacting customer service and waiting for a reply."
But my doubts remain:
Who is the one that first notices the execution direction is wrong?
If the user doesn’t notice themselves, and no one proactively triggers a dispute, this whole mechanism simply won’t start.
If the automated monitoring layer relies on off-chain scripts, then the reliability of the scripts themselves becomes another issue.
The process for assigning responsibility after an error is well designed, but I still haven’t seen a clear answer to the step of "detecting the error in time."
@NewtonProtocol #newt $NEWT