胖鸟

Is there really someone participating? 1 point can be exchanged for 1 u of Alpha—wouldn’t you be losing even with your underwear gone?

Sometimes I find that when a company is most likely to run into trouble, it isn’t because no one is responsible—but because everyone is responsible a little. Product thinks R&D has confirmed it. R&D believes Operations has already approved it. Operations thinks Legal won’t have any objections. In the end, when things go wrong, everyone has been involved—but no one can clearly explain which step was actually the problem.

Later I saw a very small design, @NewtonProtocol , and it suddenly made me think of Authorization Receipt. I had never paid much attention to it. I assumed it was just a credential generated after execution completes—similar to logs and acknowledgments, mainly for record-keeping. But the further I looked, the more I realized its placement was strange.

It isn’t positioned at the end of the workflow. Instead, it sits alongside Authorization, Policy, and Operator, becoming part of the entire execution process. I went back and reread that section several times before I realized my initial understanding was off. Many systems used to save results: when a transaction succeeds, assets are transferred out, statuses are updated—everything leaves a record. But when something truly goes wrong, people often keep asking: Who approved it? Which rule was cited? Was any step skipped in between? In many cases, that information can only be pieced together slowly from logs.

Newton seems to have been solving exactly this. Authorization Receipt records not just that execution is complete. It links an authorization, the corresponding Policy, the Operator who executed it, and the final result into a complete chain. Later, if anyone questions this execution, the system doesn’t need to re-trust a single node, and it doesn’t need to ask Operations. It only needs to re-verify along this record—why each step holds, and what evidence supports it.

When I got to this point, I suddenly realized that the Receipt in Newton isn’t really like a slip or acknowledgment—it’s more like a chain of responsibility for an execution.

So when I look back at Authorization Receipt now, I believe what it truly leaves behind isn’t merely a record.
What it leaves behind is all the evidence for an execution—from authorization, to judgment, to completion. What can be trusted over the long term may never be one particular node, or one particular platform, but rather the process itself that anyone can re-verify.
#newt $NEWT

This is unbelievable

I haven’t claimed the #ALPHA airdrop in the past month—has it gotten this competitive? Tonight at 19:00 there’s a blind box airdrop for 251 points. It’s kind of unbelievable.

I’m not feeling great—one cycle only lets you eat one.

I’m a bit hesitant: should I wait for next week’s new project #tge , or should I claim it first?

Looks like another batch of people are about to make a killing

If nothing unexpected happens, next Tuesday will see the listing of a long-awaited TGE project

This time, #tge uses new rules, and the hype is unusually high

Brothers, are you ready?

According to the pre-market converted price from the $GRVT Whales Market, the current FDV is about $350 million. Next, as usual, I’ll break it down in plain language to see whether this project is actually worth backing.

From the fundamentals, @grvt_io really does address industry pain points. Its pioneering One Balance balance system means that margin is no longer “dead money”—while you open positions in trading, you can seamlessly capture the full underlying automatic interest earnings of up to 11%. Combined with the “hybrid” narrative of CEX speed plus DEX assets being self-custodied, and with team backing from Goldman Sachs and Meta, the long-term foundation looks very solid.

But the most fatal black swan is also right in front of us: this time, the official side has directly increased the share of community airdrops from 20% all the way to 28%！What’s even worse is that the TGE tokens are not forcibly locked on the day of the event. Once those massive 28% tokens hit the market instantly, the ability of the secondary market to absorb them will face an extremely harsh, stress-test level of pressure.

Still, personally I don’t think it will be a “peak on opening” situation. After all, behind it is a zkSync ecosystem “aircraft carrier” level resource package. As a core flagship ecosystem expected to be built on zkSync Hyperchain, GRVT is not just an exchange—it more importantly acts at the base layer as a crucial liquidity relay and an essential data settlement node across the entire ecosystem.

If the first wave of sell-pressure from the initial turbulence can be digested by market makers, and then real trading data starts to run, then the One Balance flywheel effect will begin to show its power. Big money and long-term LPs, for the sake of capturing that 11% interest dividend, will continuously funnel funds back in from the Ethereum $ETH mainnet, forming a natural money-absorbing black hole.

In summary, the #grvt mechanism looks decent. But with a pre-market valuation of $350 million, in the short term it likely can’t hold up against a 28% massive airdrop that triggers a stampede. Best move is to wait until the order book stabilizes and the on-chain tokens have been washed through about enough before jumping in. My personal entry price is below $0.2.

Brothers, do you think the pre-market price of $0.35 can hold? What’s your mental “defense line” entry price? Feel free to chat with me.

Don’t let the recent hype-drenched claims about ＄GRVT fool you.

This thing isn’t as friendly to retail investors as you might think.

In the past two days, I cross-referenced the official development documentation synced with @grvt_io , and dug into the settlement data structures. I found two venues and brokers that hardly anyone discusses. After tracing the underlying clearing flow, I was genuinely shocked: everyone is focused on how buying and selling gets handled on the surface, but they overlook how, at the base layer, it opens up an over-the-counter RFQ channel for whales and institutions.

When retail investors trade the same derivatives as whales, they naturally end up taking a heavy informational hit.

I discovered that in the platform under #grvt , ordinary one-way trading goes through the public order book. But the moment complex option combinations or very large block transactions are involved, the system immediately slices that big flow into a dedicated RFQ inquiry session—and performs private matching off-chain through top-tier brokers like CoinRoutes.

So what does that mean?

The highest-quality large-block quotes—those capable of pushing hedging costs to the absolute minimum—have already been cleanly picked over off-chain by institutions and professional brokers. The public order book that retail investors see in the front end is just the leftover crumbs after institutions feed.

If you spend all your effort matching long and short positions on the public order book, you don’t just face a wider bid-ask spread—you also take on the hidden Legging Risk that arises when each leg of the trade is executed separately. This design locks the most favorable block-pricing power inside the broker circle off-chain, and it quietly erects an invisible wall around ordinary retail investors.

That said, setting aside this kind of retail-quote isolation: from a macro, risk-resilience standpoint at the system level, this architecture that fully separates wholesale from retail is actually extremely smart. Traditional on-chain exchanges often suffer liquidity breakdowns because retail small orders and institutional large positions get mixed into the same pool. Once the market violently shakes out, if institutions’ multi-leg positions in the millions are forced to close directly on the public order book, it can instantly trigger a chain-reaction stampede—setting off retail stop-loss orders by proxy.

GRVT routes large trades through independent off-chain RFQs. It uses a broker-based mechanism as a buffer zone, quietly neutralizing these devastating “nuclear” order heads away from the public arena.

It may reduce retail’s chance for a little bit of high-yield arbitrage, but it delivers extremely stable order-book elasticity for the entire market during the storm—so when retail needs to run for their life, they can withdraw at any time.

I really underestimated the ambition of @NewtonProtocol . Last night I went through its white paper myself, especially the chapters on cross-chain architecture and compute synchronization, and only then did I realize that the truly hidden move it was aiming at was actually to eliminate the compliance fragmentation and cross-chain bridge trust crisis that are the most headache-inducing problems in the multi-chain era.

The white paper of $NEWT mentions something called a multi-chain compute table synchronization protocol based on the EigenLayer ELIP-008 specification. That sounds pretty hardcore, right? When I first saw it, I also thought it was just tossing around jargon, but after thinking about it a bit, I realized that what it is actually solving is a super nasty deadlock in on-chain finance, one that no one had been able to solve before: how different chains’ applications can share the same set of high-strength, Ethereum-level economic security guarantees.

Think about it: the current multi-chain world is extremely fragmented. If a stablecoin or RWA project wants to issue on Ethereum, Base, Arbitrum, and Optimism at the same time, the traditional approach is painfully difficult. Either you have to separately find a set of compliance validation nodes on each chain, or you have to rely on a very fragile third-party cross-chain bridge, living in constant fear of being hit by a hacker’s cross-chain poisoning attack. The result is that large institutions simply do not dare to place huge amounts of funds on L2.

In the past, everyone took this as an unavoidable hard limitation, but this time Newton directly used cryptography at the underlying layer to untie this knot. In the logic of #newt , its decentralized compute network only needs to register on Ethereum mainnet and restake through EigenLayer once. Once the state of node members on Ethereum, staking weights, or slashing due to misconduct changes, Newton’s nodes will collectively emit a compute-table Merkle root stamped with a BLS private key.

The slickest part is that this signed root, which carries the economic security guarantees of tens of billions of mainnet nodes, will be aggressively synchronized to all major L2s through completely permissionless relayers. The smart contracts on the target chain only need to verify this BLS aggregate signature using pure math. Once the accounting matches, the local compute weight table is instantly synchronized and updated.

I think I’ve finally understood this ELIP-008 cross-chain compute synchronization flow. This project is not really telling some grand compliance story. It is genuinely bringing out cryptographic hard power that others cannot copy, directly unifying the compliance rails of the multi-chain world into a seamless security net.

Many people who look at @NewtonProtocol find it familiar, thinking it’s just another stitched-together “ZK, MPC, or homomorphic encryption” thing commonly seen in the market. But if you dig through its whitepaper, you’ll find it has many unique highlights.

The first label is called Newton Rego. Other projects can only use existing rule libraries to make simple conditional judgments when building risk-control strategies. But $NEWT directly overhauled an enterprise-grade Rego compiler, hardwiring a proprietary cryptographic extension package into it.

This means compliance teams, when writing the same line of declarative code, can not only perform traditional blacklist filtering, but also directly call low-level interfaces to restore cross-chain identity signatures for secp256k1 and Ed25519. The syntax that atomically binds off-chain multisig validation to cross-chain native roots of trust is unique in Web3.

The second label is Newton’s privacy envelope from #newt . Most privacy-focused projects on the market basically do encryption and then play the turnkey “encrypt-and-send” game. But NPE is a highly composable cryptographic construction: while using threshold encryption, it also forces the user + DApp to perform dual-signature authorization. The hardcore part is that at the wire-format layer, it tightly binds the ciphertext to a specific policy client and a single-transaction intent. No hacker or malicious node can ever replay or reuse this privacy data in other contexts, cutting off man-in-the-middle attacks at the root.

What’s most hair-raising—also the least likely to be copied by other projects—is its ZK slashing/challenge mechanism. Others write ZK proofs by honestly hand-crafting bespoke circuits for each specific compliance use case: it’s painful and not generalizable. But Newton leverages Rego’s pure functional language and absolutely deterministic mathematical properties, and simply stuffs the entire Rego language interpreter directly into an SP1 or Risc0 zero-knowledge virtual machine!

The result is that any line of code casually written by risk-control engineers automatically has ZK-provable properties at the underlying level. When an external challenger discovers a node is misbehaving, they can directly use this universal ZK proof to instantly topple the malicious node and trigger on-chain asset slashing on EigenLayer. Even better, to support this compute stack, the node only stakes once on the Ethereum mainnet; then, using a BLS Merkle tree, its compute weight is securely synchronized to all major mainstream L2s.

Recently I cut a high-frequency script and it crashed. I put up 2000U in chips on @grvt_io to try to capture arbitrage opportunities. A lot of orders went through, but when it came time to reconcile, I was just stunned. Several orders that should have made profit ended up executing at prices that were literally off by a few basis points compared with the fair prices shown on the order book. This live trade experience completely woke me up: although the project’s off-chain privacy order book is touted as preventing sandwich bots (clampers), in extreme market conditions we are still paying an invisible privacy “transaction tax” for this kind of unseen exchange.

One of the core selling points of #grvt is that it introduces a cryptographic privacy order book driven by zero-knowledge technology. The underlying logic is to scramble and encrypt the entire network’s user order placements, bids, and depth entirely off-chain, so that the three-party sandwich clampers/robots and predatory quant teams on the mainnet can’t obtain the mempool data. So what does that mean? If you place orders in it, in theory you have very strong privacy against hunting.

But let me cool you down: in extreme market conditions, this system brings another hidden hard flaw—blind-box slippage caused by liquidity being opaque. Because the order book’s depth is a complete black box to the market, ordinary traders and third-party market makers can’t, like on traditional exchanges, observe the true order thickness at different price levels in real time.

When the market was getting hammered and panic-selling last night, the real depth in the off-chain encrypted network had already severely fragmented. Yet the front end still showed normal figures due to data isolation. My buy orders crashed straight into a vacuum zone lacking public depth, causing a kind of invisible price spread to be filled—when the orders should have taken profit. This passive “can’t-see-the-book” effect is extremely deadly in markets where every second counts.

That said, turning the complaint around: after all the slippage haze, I also have to admit that, on-chain, its anti-misuse and rigid settlement mechanisms hit the money line hard.

What I find most disgusting about traditional platforms is disconnecting servers (“pulling the plug”) and targeted pinpoint explosions. Their liquidation and clearing are completely black-box code running on centralized servers. But with #grvt , the most core liquidation red lines and account-state validation are locked into smart contracts on-chain. Whether you need to be forcibly reduced in position is determined automatically by openly verifiable smart code—platform operators can’t interfere to change your liquidation trigger.

In short, #grvt sacrifices order-book transparency, but it also helps retail traders kill the dealer’s most poisonous bullet—malicious market manipulation and harm.

Recently I found that @NewtonProtocol spent a lot of space talking about Attestation, Verification, and Replay. At first, I didn’t really understand it. In my understanding, as long as the final outcome is correct, the way it’s achieved in the middle doesn’t seem that important. Who the executor is, what happens during execution—these feel more like implementation details rather than things the protocol truly cares about.

It wasn’t until later that I went back and re-traced the entire execution flow—from entering the Gateway from the Transaction Intent, to Policy Evaluation, then Operator execution, and finally the later Attestation—that I realized where my doubts had been coming from.

$NEWT seems to care not so much whether the result is correct, but why the result is worth trusting. The Transaction Intent doesn’t execute immediately just because it enters the system; it first goes through Policy Evaluation. And even after the Operator completes the task, it doesn’t automatically become the final result just because execution has ended. There still needs to be Attestation, and if necessary, Replay.

Keep reading— and the more I look, the more I find that they’re all answering the same question about this execution: whether it was carried out according to the rules jointly accepted by the whole network.

Only then did I realize that #Newt doesn’t truly record the outcome of a single execution, but the process of an execution. Later, I went over it again carefully and suddenly thought of a question I hadn’t taken seriously before.

Why do many systems focus more on proving the result, while Newton spends so much effort proving the process?

The more I think about it, the more it feels like the designs behind these two approaches actually represent two completely different ways of establishing trust. If you only prove the result, in the end you still need to trust the person who tells you that result. But if the entire execution process can be verified, then what truly needs to be trusted is no longer a particular Operator; instead, it’s the execution path that anyone can repeat and verify.

So I think Newton isn’t really trying to reconstruct the execution flow. What it truly challenges is a default assumption that has existed for many years: is the result correct enough?

At least, in Newton’s view, it doesn’t seem to be enough. Maybe this is precisely the real significance of Attestation, Verification, and Replay. They don’t protect just the result, but the entire process that makes the result hold.

Over the past few days I’ve been browsing the blog of @grvt_io , and one term shows up especially frequently: Capital Productivity. At first, I didn’t really take it seriously—I just thought it was some kind of marketing concept. In the end, don’t exchanges compete on liquidity, trading fees, and trading speed? An exchange that keeps talking about capital productivity doesn’t sound quite like something an exchange should be saying.

So when I first saw One Balance and Unified Margin, I kept interpreting them in the direction of experience optimization. Later, I put several blog posts together and read them again. What I originally wanted was to understand what Unified Margin actually solves, but the more I read, the weirder it felt.

The official side hardly discusses trading speed at all, and it doesn’t constantly emphasize Hybrid Exchange. Instead, it keeps bringing up Capital Productivity and Capital Drag, and even the later Yield Layer—so the discussion is always about the same thing.

That’s when I realized I may have misunderstood from the start. GRVT seems to have been asking a different question: why can one unit of capital only serve one use case? And it’s only here that I understood why the official team keeps emphasizing Capital Drag. The real waste might not be trading speed, but the process where capital is constantly waiting, migrating, and being reconfigured.

After that, I went back to look at One Balance, Unified Margin, and the Yield Layer, and suddenly it occurred to me: they look like three different functions, but in fact they’ve all been answering whether the same pool of capital can keep going instead of stopping whenever its purpose changes.

So now, looking back, I feel that what GRVT is truly trying to restructure probably isn’t “an exchange.” What it challenges is a default habit in the financial system that almost nobody questions: why, after capital completes one task, must it end that segment and start the next?

At least now I’m increasingly inclined to this understanding: what GRVT really wants to preserve isn’t a particular account or a particular product—it’s the continuity of the same pool of capital.

Trading, returns, investing, and payments weren’t four different pools of capital in the first place. They should all be the same pool of capital, carrying different responsibilities in different stages.

So now when I look at Capital Productivity again, I feel that what it truly wants to optimize isn’t trading efficiency, but the way capital runs throughout the entire financial system.
#grvt

It’s been a long time since I visited a new TGE. The newly launched @grvt_io is another big one.

@grvt_io also rolled out a value-for-money Booster campaign: you can exchange for tokens worth 8u with just 2 points. Don’t miss it!

When I first looked at @grvt_io ’s HEX Architecture, I had a question: if order matching happens off-chain, then how does the chain actually trust it?

In my understanding, the biggest value of a blockchain is determinism. If the most core matching process leaves the chain, then what’s the difference from traditional exchanges? At first, I thought GRVT was just a compromise between performance and decentralization. But after reviewing its execution flow again, I realized I misunderstood it initially.

The real problem that #grvt solves isn’t simply where to place trading, but how to ensure that the transaction states generated off-chain are ultimately recognized by the on-chain system. In its design, orders first go into an Off-chain Matching Engine to complete matching. This means high-frequency trading doesn’t have to wait for on-chain confirmations, achieving execution efficiency close to that of traditional exchanges.

What’s interesting is that a trade being executed doesn’t mean the final state is established. The transaction result still needs to go through On-chain Settlement, where on-chain rules and smart contracts perform the final verification. In other words, the off-chain side is responsible for high-frequency computation, while the on-chain side is responsible for the final state.

Only then did I realize that #grvt is trying to split the boundary between producing state and defining state. The Matching Engine is responsible for generating trading results, the Settlement Layer confirms the asset state, and the Smart Contract Vault ensures that users’ assets don’t rely entirely on a centralized ledger.

So it feels to me that a Hybrid Exchange isn’t simply stitching CEX and DEX together. What it truly changes is the trust boundary inside the trading system. Not every step of trading necessarily has to happen on-chain, but the final impact on users’ asset states must be confirmed by on-chain rules.

Later, when looking at Unified Balance, I found this logic isn’t limited to trading settlement—it runs through the entire asset state management. Trades, margin, and profits are no longer fragmented account states; they flow within a unified system, so assets aren’t locked into a single scenario but can keep changing.

Now let me consider it: GRVT seems more like it’s solving a mechanism for how off-chain state enters on-chain reality—and becomes reality recognized by the on-chain world.

I’ve always felt that the most important thing about an authorization system is its rules.

As long as the Policy is written with sufficient rigor, the system can determine which transactions should be executed and which should be rejected. So when I first read the <a>@NewtonProtocol </a> Whitepaper, I kept focusing on the Rego Policy and the Authorization Flow.

It wasn’t until later that I revisited the section on the Data Provider that I realized I had overlooked a deeper issue. Even if the rules are accurate, if the input data isn’t trustworthy, then the final judgment still doesn’t matter.

The <a>$NEWT </a> Policy Evaluation doesn’t simply run the rules directly. Operators need to call external data sources—such as the Oracle Price, Sanctions Feed, Risk Score, and so on—then feed those inputs into the Rego Policy for decision-making. But these data themselves are not native on-chain. That’s when it clicked for me: this seems to be a problem that all on-chain automation systems run into. People have long debated whether smart contracts are trustworthy, but they rarely ask whether the data the system sees when making decisions is actually reliable.

If the address status check is wrong, if the risk score is skewed, or if different nodes obtain inconsistent data, then even if the subsequent Policy, Attestation, and Consensus are computed correctly, they may still be “correct” outcomes built on incorrect inputs.

<a>#newt </a>‘s design for this is quite interesting. Instead of choosing to become the single data provider, it makes the Data Provider a plug-and-play module. Operators can independently run a WASM Data Provider in an isolated environment to retrieve external data, and then generate an ECDSA Attestation based on what they observed—bringing the inputs themselves into the verification scope.

Only then did I realize I had misunderstood earlier. I thought Newton’s core was making rules verifiable. But in reality, it first needs to ensure that when the rules run, they face the same trusted reality. The Policy determines how the system judges; the Data Provider determines what the system sees.

The truly hard part has never been getting the machine to run according to the rules. It’s making sure that before the machine makes a decision, the world it sees hasn’t been altered by wrong inputs. That may be the real significance of the <a>$NEWT </a> Data Provider Ecosystem design.

In the future, competition among on-chain systems will not only be about rules and execution, but about who can ensure that, before the network makes decisions, everyone is first operating from the same reality.

I’ve always thought that as long as all nodes are getting the same data, consensus won’t be a problem. So when I first saw the “Streaming Two-Phase Consensus” in the @NewtonProtocol Whitepaper, my first reaction was performance optimization—Gateway, NATS, and Streaming all looked like they were just there to reduce latency.

Later, I reread that section and realized I had misunderstood.

The whitepaper states that the Operator will each independently call a WASM Data Provider to fetch external data such as Oracle Price, Sanctions Feed, and Risk Score. Even if they query the same data source, differences in network paths and response times mean that each Operator may end up seeing different data. And BLS Aggregate Signature requires that all nodes sign exactly the same message—if the data differs, the aggregated signature can’t be generated.

That’s why Newton splits it into two phases. In the Prepare phase, each Operator independently fetches data and generates an ECDSA Attestation, and then the Gateway aggregates them into a unified Canonical Dataset. In the Evaluate phase, all Operators execute the Rego Policy based on that same dataset, and finally generate an aggregatable BLS Signature.

Only when I got here did I realize I’d been wrong all along.

I always thought consensus is about deciding who’s right.

But what Newton truly solves first is this: are we even discussing the same reality.

If each Operator is working with data from a different point in time, then even if all later steps—Policy Evaluation, Attestation, and BLS Aggregation—are completely correct, they’re still only proving different realities, separately.

Looking back now, I increasingly feel that the most important part of Streaming Two-Phase Consensus isn’t improving performance, but first unifying reality and then unifying the answer. The real difficulty may never have been forming consensus at all, but ensuring everyone is facing the same world.
#newt $NEWT

I’ve always felt that the most important thing in a decentralized system is determinism. Once the network reaches consensus, things should be over.

Operator completes Policy Evaluation, generates a BLS Attestation, the transaction obtains Authorization, and then execution follows—this should be a complete path.

So when I first started reading the @NewtonProtocol Whitepaper, I couldn’t figure out why they still needed to design a Challenge Protocol afterward. At one point, I even thought it was just an extra error-correction layer to prevent the Operator from making mistakes.

Later, I went back and looked specifically at the Challenge section, and the more I read, the more something felt off. The Challenger doesn’t re-decide whether the transaction should be executed. Instead, it receives the same Transaction Intent, Policy CID, and Policy Hash, and then runs the same Rego Policy Replay to obtain Authorization again. Only if the Replay result differs from the original BLS Attestation will it submit a ZK Proof and trigger Slashing. What’s being re-verified here isn’t the transaction itself, but whether that Authorization was produced strictly according to the predefined policy.

At this point, I suddenly got stuck.

If the Operator has already reached consensus, why does Newton allow others to recompute? I had always assumed that consensus means the answer has already been produced, and that Challenge is only there to correct errors. But what the whitepaper’s real Challenge is trying to express is not to overturn the result—it’s to prevent any single consensus from having the final authority to interpret.

That’s when I realized I had misunderstood from the beginning.

$NEWT isn’t trying to prove that a particular Authorization is correct; it’s ensuring that any Authorization can be re-validated by other participants using the same rules.

Now looking back, the most interesting part of the Challenge isn’t that it adds a whole dispute mechanism, but that it redefines trust.

In the past, I always thought trust comes from consensus that has already been reached.

But #newt sounds more like it’s saying the truly trustworthy thing isn’t an already-produced result, but that anyone can take the same Intent, the same Policy, and the same set of rules to reproduce and prove that result again.