Marquitta Ullum lyUI

People who have run across a few PoS chains know that “confirmation” and “final confirmation” are two different concepts. With Ethereum, after you transfer funds, you have to wait two epochs before you can really say the money has arrived. During those dozen-odd minutes in between, in theory the block could still be reorganized. For everyday transfers it doesn’t matter, but for securities settlement it’s a matter of life and death—will the registrar be willing to update the shareholders’ register based on that on-chain record? If a reorg happens once, who will bear the legal responsibility?
Dusk’s Succinct Attestation consensus resolves this at the root. It doesn’t rely on the “longest chain” logic. Instead, in each round it draws a committee from the staked nodes and conducts voting across three phases—proposal, verification, and approval. Blocks that reach the threshold are directly finalized. Since there are no forks on-chain, there is naturally no need for rollbacks. The committee selection depends on a verifiable random function, so nobody knows in advance who will be chosen, leaving very little room for targeted attacks.
The trade-off is that it sacrifices some throughput elasticity. Committees must communicate; if nodes go offline, it slows down the rounds. When the network partitions, the chain stops and waits instead of continuing independently. In narratives that compete on TPS numbers, this looks like a step backward. But in settlement, the core requirement has never been speed—it’s certainty. The party responsible for settlement is willing to wait a few extra seconds for determinism, but it absolutely won’t take on reorganization risk for the sake of speed.
The committee mechanism also reshapes the nodes’ reward structure. Block production rewards go only to the selected proposer. Voting participation in the verification and approval phases is rewarded as well, which makes uptime more important than simply piling up stake. Conversely, long-term offline Provisioners have their rewards suspended, and malicious behavior directly reduces effective stake.
Going even deeper, finality determines how auditing is done. The history preserved by archive nodes must be a single, uncontested version; only then do regulatory spot checks make sense. If fork traces remain on-chain, the audit standards immediately conflict.
Dusk didn’t choose the most flashy technical route—it chose the one that best fits settlement needs.
@Dusk $DUSK #dusk

After the mainnet launch, the Dusk token faces a very specific problem: the two existing external forms on Ethereum and the BNB Chain need to migrate to the native chain in order to participate in staking and pay transaction fees. @Dusk provides migration channels and instructions, but migration is never just a technical process.
The biggest risk during the migration period is phishing. Any messaging that promotes “limited-time migration or it will be void” is worth being wary of. A legitimate process gives you plenty of time, and it will never ask you to hand over your seed phrase. Historically, many projects’ migration windows have been accompanied by fake websites and fake customer service; losses for holders are often concentrated in those few weeks.
The second impact is liquidity fragmentation. During the migration, the same asset may exist in multiple forms at the same time. Support timelines differ across exchanges, and price spreads between forms and arbitrage opportunities can arise. For ordinary holders, whether to stay with the custodian and wait for unified handling, or to manage it yourself via the native wallet, depends on whether you need to participate in consensus.
From the protocol perspective, migration completion directly affects security. Only tokens in native form can be used for staking; any portion stuck on external chains is effectively not included in the security budget. The practically stakeable size of $DUSK therefore depends on the migration ratio, not the total supply. When these two numbers are discussed interchangeably, it’s easy to reach overly optimistic conclusions.
I’m also concerned about the long-term positioning of the external forms. Will they be completely retired, or will a controlled bridged version be kept to serve other ecosystems? The first option is cleaner but cuts off some trading scenarios; the second is convenient but introduces a trust assumption regarding the bridge. For a chain focused on compliant assets, the bridge’s risk exposure needs to be written more clearly than for most projects.
To judge whether a migration is going smoothly, I look at three things: the circulating share on the native chain, the support status of major trading venues for native deposits/withdrawals, and the number of security incidents related to the migration. #dusk ’s technical narrative has been discussed for a long time; whether this foundational work is solid is what holders can truly perceive in the short term.
@Dusk $DUSK #dusk

There are many people who talk about privacy, but not many who can clearly explain why institutions need privacy. The most straightforward example is a market maker. Their pricing logic, inventory offsets, and hedging cadence are themselves core assets. Once every trade is tracked step by step on a blockchain explorer, others can reverse-engineer their model and specifically ambush them along their replenishment routes. This isn’t a preference for privacy—it’s a matter of survival.
@Dusk solves this at the L1 layer. Zero-knowledge proofs let the whole network verify that transactions are valid and effective, while the specific amounts, counterparties, and changes in holdings do not enter the public view. Regulators and trading participants can obtain exactly the parts they need through selective disclosure. Verifiability and confidentiality are split into two independent channels instead of being forced to compromise with each other.
According to the official documentation, the network provides different transfer models: one that favors privacy protection and one that favors account transparency. The issuer and users can choose based on the nature of the business. I think this design is more practical than a one-size-fits-all approach, because disclosure requirements for compliant assets are inherently layered—public funds and private notes can’t possibly use the same rule set.
This also explains why many institutional pilots end up stopping at permissioned chains. Permissioned chains can keep things confidential, but they sacrifice open liquidity: participants are restricted to a whitelist and assets can’t be freely recombined. Dusk tried to achieve the same level of confidentiality on a public network, but the trade-off is that technical complexity and audit-explanation costs are both much higher.
So my observation focuses on one point: whether regulators and auditing institutions are willing to treat zero-knowledge proofs as compliant evidence. If they don’t pass that gate, then all the business visions carried by $DUSK can’t be realized. What do you think—privacy is a prerequisite for institutions to put assets on-chain, or just a feature that can be added later?
@Dusk $DUSK #dusk

#dusk At one point I couldn’t understand something: I worked hard to build a native virtual machine, so why do we also need to build an additional EVM layer? It sounds like an admission that the native ecosystem hasn’t really taken off.
Later, I started viewing it as a layered decision, and it made sense. @Dusk ’s thinking is that the bottom layer is left for settlement and data availability, while an execution environment compatible with the Ethereum toolchain sits on top. The bottom layer handles ownership/rights final confirmation, privacy primitives, and compliance constraints—things that shouldn’t be changed casually. The top layer handles what language developers write in, what framework they deploy with, and whether they can directly port existing contracts.
The motivation for this split is very practical. Regulated assets require the bottom-layer rules to remain stable. Stability means you can’t frequently change the core just to accommodate developers’ habits. But the ecosystem also must rely on developers, and most financial app developers’ muscle memory is built around the Ethereum toolchain. Asking them to relearn an entire language and debugging workflow for a single chain comes with real conversion costs and leads to genuine loss.
So the EVM layer is positioned more like a lobby: you come in and first build with familiar tools; when you need privacy and compliance capabilities, you call down to the underlying primitives. That’s far more pragmatic than the “either fully use mine, or don’t come at all” approach.
I’ve also seen the negative case. Some chains make EVM compatibility their only selling point. As a result, besides being a bit cheaper and faster, they can’t do anything that can’t already be done on Ethereum. In the end, the activity they build up—kept alive by incentives—evaporates the day the subsidies stop. Whether layering can hold up depends on whether the bottom-layer primitives are truly one-of-a-kind, and whether calling them from the top layer is truly smooth.
What I’m watching is the seam: whether the latency and complexity of cross-layer calls will undermine the developer experience, and whether privacy assets in the EVM layer can maintain the same compliance properties. These two points determine whether it’s one stack used for two purposes—or two systems that end up dragging each other down. I’ll keep following it and won’t miss any product details. $DUSK ’s judgment is that I’m betting on the pace of ecosystem migration.
@Dusk Dusk $DUSK #dusk

I came over from the Solidity side. At first, I just wanted to get by using a compatibility layer. But in the end I couldn’t resist trying native contracts for a few days. After I finished writing, my understanding of this chain truly took a step deeper.
On the first day, it was mostly me battling the compiler. Rust’s rules around ownership and lifetimes were a pretty big psychological hit for someone like me who’s used to casually changing state. In the past, when I wrote contracts, the contract storage was just there—I could read it whenever I wanted, and write whenever I wanted. Here, you have to spell out where data comes from, how long it lives, and who is allowed to change it. If the compiler doesn’t accept it, it doesn’t accept it—no negotiation.
After feeling miserable for two days, I started to admit that there are benefits. A lot of the pitfalls I’d run into before—like state being changed unexpectedly, or a variable under a certain branch not being initialized—simply can’t compile over here. It pulls part of the audit work forward into the time when you write the code, letting me catch problems while everything is still relatively cheap.
The real difficulty isn’t the language, it’s the ecosystem. When I ran into issues and went looking for help, the reference materials were far less abundant than on Ethereum. Many times I could only read example code from the official repositories and figure things out myself. The process is slow, but the payoff is real, because I’m forced to understand how the underlying pieces are organized—not just copy a template and move on.
You also have to get used to the toolchain again. How to write tests, how to run things locally, what you need to prepare for deployment—I had to build an entire workflow from scratch. I’d suggest newcomers spend time getting this setup working first, and don’t rush into the business logic. I did it the other way around: I wrote a bunch of code, and then got stuck on deployment. I wasted an entire day doing pointless tinkering.
My advice now is pretty simple. If you just want to quickly validate an idea, use the compatibility layer—it’s convenient and saves you trouble. But if you’re going to seriously build something that makes use of this chain’s privacy capabilities, it’s worth learning the native approach, because a lot of capabilities aren’t available in full through the compatibility layer. The learning cost is real—but what you buy with it isn’t guessing from outside the door. It’s genuine control over this chain.
@Dusk $DUSK #dusk

My previous understanding of tokenization was quite crude. I thought it was simply turning an asset into a token and that you could transfer it—that’s it. After watching Zedger, I realized that for a genuinely compliant securities-type asset, transferability is only the simplest part.
The real difficulty is: who can transfer it to. In the traditional world, a piece of equity comes with a shareholder register—there are restrictions on who can hold it, lock-up periods, and review steps required for any transfer. These rules aren’t burdens conjured out of thin air by the blockchain; they already exist in real life. If you want to bring such an asset on-chain, you have to bring those rules along too—otherwise you’re only porting a shadow.
What Zedger is trying to handle is precisely this pile of requirements. It’s not a token standard that anyone can freely transfer. It has to be able to restrict the recipient, remember who has held it, make sure the right people can see it, and keep it invisible to those who shouldn’t see it. When I was reading it, I had a very specific feeling: this isn’t about designing a token—it’s about translating a whole compliance workflow into code.
That’s also why I understand why it’s complicated. A freely circulating token standard can be short—maybe a few dozen lines. A standard with holder restrictions and disclosure requirements will definitely be longer. I think it’s a bit unfair to complain that it’s complex; the complexity comes from reality, not from the designers’ preferences.
But another question I care about is: once this is written, who will use it? The issuance of compliant assets can’t be decided by the technical team alone. It requires issuers who are willing to come, a venue where it can be traded, and investors who are allowed to buy. With the on-chain piece prepared, the remaining pieces are all off-chain. I’ve seen the official team constantly pushing for integration with licensed venues. As for the specific stage, I haven’t verified it, and I won’t treat a roadmap as something that has already happened.
My current judgment is that Zedger’s value doesn’t lie in how many fancy products it can create. It lies in whether there are the first batch of real-world issuance cases—cases that can be audited, accepted by regulators, and actually bought and sold. Those truly demonstrate the point more than ten technical documents. I’m waiting for that.
@Dusk $DUSK #dusk

The history of BTC entering DeFi is, in half, the history of stolen funds via cross-chain bridges. Every scheme—wBTC, renBTC, tBTC—comes with its own trust assumptions, and each has also suffered major problems. The arrival of TBV brings an entirely new way of thinking to this space. @BabylonLabs_io
The core of the wBTC model is custodial storage plus wrapping. Users deposit BTC with BitGo, and off-chain auditing issues ERC-20 tokens representing the equivalent value; in theory, they can redeem at 1:1 at any time. The problem is that all security ultimately depends on the custodian itself. If BitGo fails, hundreds of billions worth of wBTC can go to zero instantly. This isn’t a hypothetical—it’s the blood lesson the entire industry learned from Multichain and FTX.
Decentralized bridges are somewhat better, but they face their own challenges too. Light-client bridges rely on the validator set; multisig bridges rely on signature-threshold requirements; optimistic bridges rely on a challenge period. Any approach introduces a new trust layer, lowering the security of BTC itself to the bridge’s level.
TBV takes a completely different path. BTC stays on the Bitcoin mainnet end to end—no cross-chain, no wrapping, no bridge. When an application on Ethereum or other PoS chains needs to verify the TBV status, it reads Bitcoin block headers through Babylon’s relay layer, and then combines EOTS signature verification to confirm the honesty of the Finality Provider. Security boils down to Bitcoin consensus itself, plus an additional slashing constraint.
What’s the trade-off? Slightly less flexibility. TBV can’t freely circulate on-chain like wBTC. Every time you stake and unstake, it must be done on the Bitcoin mainnet, constrained by the 10-minute block time and volatility in on-chain transaction fees. But the benefit is a dramatically simplified security boundary.
In October, Babylon ran a native BTC lending experiment on the Ethereum mainnet using USDC, proving that this route is fully feasible from an engineering standpoint. The BABY token plays protocol incentives and governance roles in it.
Security and flexibility have never been a zero-sum game. Do you trust the reputation of custodians more, or the mathematics of Bitcoin itself?
@BabylonLabs_io $BABY #baby

My dad is sixty-two. He has a little BTC in his hands—it's something I convinced him to buy a few years ago. Last month, I took him through the entire TBV process. It was more troublesome than I expected, but the gains were different too.
At first I thought the difficulty would be technical. Turned out, it wasn’t. He’d already gotten used to concepts like private keys and addresses. What really stumped him was the sentence, “My coins are still in my own possession, but I can’t withdraw them for now.” I had to explain it three times before he finally accepted it. What he meant, in essence, was: “Then is it really mine?” I finally gave him the analogy of a time deposit—your money is yours, the bank hasn’t taken it, but if you withdraw early you have to follow the rules. Once I said it that way, he understood immediately, and he accepted it faster than I did.
The real hurdles are in two places. One is the withdrawal waiting period—he needs to know in advance that during this time he won’t be able to move anything. Otherwise, when the moment comes, he’ll definitely panic and will start wondering if he’s been scammed. The other is choosing the service provider—he has absolutely no ability to judge. I had to pick for him, and I also had to explain clearly what could be affected if that step is chosen incorrectly. Neither of these things is very noticeable in the existing interface. For people like us who need to bring our family members along to operate it, the burden is real.
What reassures him is also very clear. I showed him the address—his coins were indeed still on the Bitcoin mainnet, not turned into something else. The withdrawal conditions are written into the script, so anyone can verify. After he finished reading, he said something pretty interesting: “So no one can make decisions for me.” I think that sentence captures the point more accurately than any explanation of returns. He latched onto the most core idea of this design.
My conclusion is: for someone with a certain level of understanding, this is a relief; for a complete beginner, it adds burden. It replaces the cost of trust with the cost of understanding—and the understanding cost can’t be outsourced.
Next, I plan to write the whole process on a single sheet of paper for him. I’ll also record his redemption time from this round, to see whether it matches my own time.
@BabylonLabs_io $BABY #baby

I haven’t written anything about macro for a long time, but TBV reminded me of an old question: what ultimately supports Bitcoin’s security budget over the long run.
Block rewards are going down. This is written into the protocol—there’s no room for negotiation, and it won’t change just because the price rises. Over the long term, the system’s security will increasingly rely on other sources. Transaction fees are one part. Another part very likely comes from whether BTC itself can generate real economic value without leaving the mainnet. This isn’t an emotional issue, and it isn’t a narrative issue—it’s a mathematical one, and when the time comes, you naturally have to face it.
I think TBV’s significance lies right here. It doesn’t wrap BTC and send it somewhere else. Instead, it lets holders deploy their capital while keeping self-custody, providing guarantees for networks that need security, and receiving a return in the process. This path is fundamentally different from the old approach of “hand over coins to earn interest.” The underlying assumptions are completely different: the former doesn’t add custodians, so risks don’t stack; the latter adds another layer—each additional layer is another potential point of failure, and in recent years, every failure has come from exactly those layers. None of them escaped.
My doubts are also very concrete. How big is the demand side, really? How many networks are willing to pay for security long-term? At what level can the unit price be supported? Can this market grow into scale? We still don’t have long enough data to answer those questions. Any claims that talk only about aspirations but not about demand, I’ll discount. This is also the most important point I care about when looking at assets like $BABY —its value ultimately has to be supported by real paid demand, not by storytelling, and stories never last long enough to carry them.
But at least the direction is right. Bitcoin’s biggest waste isn’t price volatility—it’s that trillions in capital have long been left completely idle, and at the same time you can’t just hand over custody rights simply to make it move. For the past decade, basically no one has solved this problem well. TBV tries to address both of these things at once, and this line of thinking deserves to be taken seriously for a while.
Next, I plan to record changes on the demand side each quarter—only looking at data, not listening to stories.
@BabylonLabs_io $BABY #baby

To understand the value of TBV, you first need to see what it replaces.
Traditional Bitcoin cross-chain custodial solutions are generally threshold multisig: out of n signers, t signatures are enough to move funds. Security is therefore expressed as the phrase “at least n−t+1 people do not conspire.” The problem with this assumption is that it fails as the size of the conspiracy grows. But conspiracy is an off-chain behavior: it is invisible on-chain and cannot be proactively prevented. Historically, most bridges that went wrong failed here.
What TBV aims to do is to change the direction of the assumption: from “most people are honest” to “at least one person is honest.” The spending path of funds is fixed in advance by pre-signing. Whether the funds can be successfully recovered depends on whether the operator’s assertion is correct, and any single honest participant has the ability to submit a fraud proof that overturns it. To cause harm, everyone must be silent at the same time; it’s no longer a matter of reaching a threshold.
The difference along this direction is substantive. The former’s security is diluted as the number of participants increases; the latter’s security strengthens as the number of participants increases, because with one more person comes one more chance of being reported.
The costs are also clear. The challenges window, the liquidity prepayment mentioned in the earlier sections, the key assumptions behind the pre-signing ceremony, and the fee liveness—all of these are the added complexity paid to swap that assumption. Whether this complexity is worth it depends on whether it can run stably in real environments. I understand the mechanism design; what remains is to look at the data from actual deployments.
@BabylonLabs_io $BABY #baby

When studying TBV @BabylonLabs_io , I paid special attention to its peg-out process. The design of the fraud challenge period in this part is the backbone of the entire TBV security model, but it is also the cost most likely to be overlooked by users.
First, the mechanism. When a user wants to redeem assets into BTC, the counterparty will initiate a peg-out transaction. This transaction does not take effect immediately; instead, it enters a challenge period. During this period, any watcher can submit a fraud proof. If the counterparty tries to steal BTC or submits an incorrect state, the proof will be verified and the transaction will be blocked. Only after the challenge period ends with no disputes will the peg-out be finally confirmed.
This design essentially ties “security” to “time.” The longer the challenge period, the more opportunity watchers have to detect issues, but the longer users’ funds are locked. The shorter the challenge period, the better the user experience, but the narrower the window for fraud to be discovered. This is a standard trade-off problem, and Optimistic Rollup follows the same logic.
I think there are two details worth looking into. First, is the watcher role permissionless? If anyone can watch, anyone can submit challenges, and there is economic incentive for submitting challenges (for example, confiscating the malicious party’s staked collateral as a reward), then the security model is more solid. If watchers are whitelist-based or require special qualifications, then the risk concentrates. Second, how long exactly is the challenge period—seven days, fourteen days? This directly affects user experience and capital efficiency, and it also determines whether TBV can support DeFi strategies with short cycles.
TBV brings the trust assumption of BTC’s security level to cross-chain bridges, but the price is that users must accept this time cost. When evaluating product-market fit for $BABY , whether the challenge period can be accepted by DeFi users is the first practical hurdle—not a purely technical one.
@BabylonLabs_io $BABY #baby

I’ve spent a few years working on BTCFi-related things, and I’ve gone through every “bring Bitcoin out” scheme on the market—wBTC, tBTC, renBTC, and all kinds of LP bridges. After reading the TBV whitepaper seriously yesterday, I got pretty upset.
First, the wBTC setup: BitGo custody. Users send BTC to the custodian, and ERC-20 tokens are minted 1:1 on-chain. The risk model is simple and brutal—fully trust BitGo not to run away, not to misuse funds, and not to get frozen by regulators. This is pure centralized custody.
tBTC v2 is better: it uses a set of signers to manage BTC via tECDSA threshold signatures. The signers need to stake T tokens as economic collateral, so in theory, wrongdoing can be punished. But the BTC pool is centralized—once the threshold is broken, the entire batch of BTC is at risk. Also, users rely on the signers’ collective availability to process withdrawals.
TBV is completely different. It doesn’t “bring BTC out” at all. The BTC stays on the mainnet in its own Taproot UTXOs the whole time. The user is always one of the co-signers of the UTXO. The Covenant Committee only has approval rights over the pre-signed spending path; it can’t move the coins by itself. Even if the entire Babylon ecosystem disappears tomorrow, users can retrieve their funds independently after the unbonding timelock.
One sentence to summarize the difference: wBTC is “the custodian has BTC; you have an IOU,” tBTC is “the threshold bridge has BTC; you have wrapped tokens,” and TBV is “you always have BTC—you’ve just made a usage-right commitment.”
This difference is crucial for institutional entry. For compliance-focused funds buying BTC, the hardest hurdle is auditing—once funds leave a self-custody wallet, it triggers a whole bunch of processes. Under the TBV model, on-chain audit tools can directly scan the UTXOs to prove holdings, with no cross-chain or custody involved.
What do you all think about this “staking-in-place” vs. traditional cross-chain bridge battle—will it, in the long run, squeeze the share of wrapped BTC?
@BabylonLabs_io $BABY #baby

While researching Babylon’s token model, I noticed a two-layer structure: BABY staking and BTC staking coexist. Both participate in protocol security, but their roles are different.
BABY stakers mainly handle the protocol’s own PoS consensus, validating transactions and state transitions on the Babylon chain. BTC stakers, on the other hand, economically commit BTC to the protocol through time-locking, providing additional economic security for cross-chain verification and the finality of TBV. Both groups receive BABY incentives, but the boundaries of responsibility are clearly defined.
What’s interesting is the inflation allocation ratio. Of BABY token inflation, part goes to BABY stakers, part to BTC stakers, and part to protocol development and ecosystem building. This allocation model acknowledges a reality: BTC holders are the largest user group in Babylon’s TBV system, and their participation directly determines the ceiling of the protocol’s TVL. Rewarding them with real economic incentives is far more effective than just promoting a narrative.
From a game-theory perspective, this dual-staking design effectively binds the interests of holders of two different assets. BTC stakers want TBV to be secure, usable, and to connect with more DeFi use cases, because only then can their returns remain sustainable. BABY stakers want protocol usage to grow, so that fee revenue and token demand will increase as well. The goals of both sides are highly aligned, creating a positive feedback loop.
Compared with other BTCFi projects, many either rely entirely on BTC’s brand endorsement without real economic binding, or they use an independent token logic that has no relation to BTC. Babylon, through TBV, achieves functional-level coupling between the asset properties of BTC and the governance properties of BABY. This architectural difference is likely to become evident over the long term.
I can’t predict BABY’s short-term price, but I can say that if the adoption curve for TBV plays out, BABY’s value-capture model is clear and sustainable—not driven by sentiment, but by protocol cash flows and real usage.
@BabylonLabs_io $BABY #baby

EOTS is the hardest-core piece of the Babylon tech stack—I've been chewing on it for three straight nights just to barely get it down. Full name: Extractable One-Time Signature, meaning an extractable one-time signature. TBV needs it to implement slashing on the BTC chain.
The rough idea: a signer can only sign a given message once. If they sign the same message twice with different contents, the mathematical relationship between the signatures automatically leaks the private key. The whole process happens purely at the cryptographic layer—no additional arbitrators needed. It sounds like a fairy tale, but academia has studied it for many years, and Babylon has engineered it into a form verifiable by BTC scripts.
What does it mean for TBV? If a finality provider signs on two conflicting blocks, their EOTS signatures for the BTC staking pool would reveal the private key at the same time. Anyone who finds that private key can execute a slashing transaction on their behalf, moving their BTC away. The punishment doesn’t require committee decisions or governance votes—it’s triggered purely by cryptography.
A quick analogy: ordinary default penalties are like "sign contract → default → court judgment → forced enforcement." EOTS is more like "while signing the contract, the key is already left on the doorstep—at the exact moment you default, the key automatically flies out. Whoever sees it can open the door." The immediacy and unavoidability of enforcement are guaranteed by mathematics.
But engineering has boundaries. Section 14 of the whitepaper admits: EOTS assumes the signer’s private key is protected by a single entity. If you split it using MPC, detecting double-signing requires additional mechanisms. And in production, finality providers commonly use MPC to improve availability—this opens up new attack surfaces.
One of the issues the governance layer—$BABY —will need to address in the future is how to reconcile the purely theoretical idea of EOTS with the real-world engineering constraints of MPC. This isn’t a cryptography problem; it’s a systems engineering problem.
My take: EOTS is the most beautiful cryptographic breakthrough for TBV, enabling BTC to support proactive punishment via slashing. But beautiful theory inevitably takes a hit when translated into engineering—don’t just transplant the security assumptions from academic papers directly into the operating environment.
As usual, DYOR. EOTS is Babylon’s moat—a glass bridge between academic theory and engineering practice? Tear it apart in the comments.
@BabylonLabs_io $BABY #baby

Any so-called "de-trust" system ultimately has to answer a question: who actually operates the infrastructure, and why they don't do evil. TBV is no exception.
Architecturally, TBV involves several key roles. The Vault Operator coordinates users' deposits, withdrawals, and status updates. Universal Challengers monitor fraudulent behavior and, when necessary, submit challenge proofs. The Proof Generator produces the zk proofs required for unlocking and settlement. If all three of these roles fail—or are controlled by the same party—then "de-trust" becomes a paper promise.
What I care most about is the incentive design for challengers. In optimistic Rollup models, challenger incentives have always been a longstanding problem: under normal conditions, most transactions are honest, so challengers rarely get a chance to act. But if fraud is truly caught, will the reward be enough to cover the long-term cost of waiting and watching? If not, rational challengers will exit, leaving only a few specialized institutions—centralization risk quietly returns.
The role of the Vault Operator also needs careful dissection. Can the operator refuse service? Can they disappear at a critical moment, forcing users onto a complicated and cumbersome emergency exit path? TBV's design should include a forced-exit mechanism so users can recover BTC even if the operator fails. But whether this process is user-friendly for ordinary users is another issue at a different level.
TBV's economic security is not a single cryptography problem—it is a system engineering challenge involving multiple parties in game theory. Protocol parameters, slashing/penalty rules, and admission thresholds: if any one of these is set incorrectly, it could tip the entire balance. I expect to see more detailed economic security models released, including cost-benefit calculations under different attack scenarios, and stress-test results under extreme market conditions.
Technical feasibility does not necessarily mean economic coherence. These two lines have to move together.
@BabylonLabs_io $BABY #baby

Stablecoins are now the most profitable track in the crypto world. Combined, the market caps of USDT and USDC exceed $200 billion. Circle and Tether both post annual profits in the tens of billions. In terms of collateral structure, the two major issuers rely mainly on U.S. Treasuries and cash. Decentralized alternatives like DAI/USDS are also shifting toward RWA. As the crypto asset with the largest total market cap, BTC has long failed to secure its rightful share in the stablecoin-collateral market; the root cause lies in custody risk. TBV @BabylonLabs_io has the potential to change this landscape.
TBV stands for Trustless Bitcoin Vault. BTC is locked into a vault contract on the Bitcoin mainnet that never migrates. Based on the BitVM3 design, complex computation is performed off-chain using garbled circuits, while only compact fraud proofs are kept on-chain. On the Ethereum side, cryptographically generated collateral-state credentials are produced for smart-contract calls. To unlock, you must submit the corresponding ZK proof of the contract state; liquidation also requires a ZK proof. There is no multisig, no custodians, and no oracles.
For stablecoin protocols, TBV provides a collateral option of “BTC-level liquidity + decentralized custody,” which has been almost nonexistent in the past. The whitepaper explicitly states that stablecoin minting is one of TBV’s core use cases. This implies that in the future there may emerge a BTC-backed decentralized stablecoin, where the collateral is self-custodied BTC, and minting and liquidation are driven entirely by ZK proofs. If this product can be made to work end-to-end, the market opportunity is not small.
The foundation is Babylon’s Bitcoin staking protocol, with TVL over $5 billion and more than 50,000 BTC locked. The first integration is Aave v4: lock BTC → mint a collateral credential → borrow stablecoins → repay to unlock. In May, the Gomining collaboration first introduced a real test with 1,000 BTC.
Let’s stay level-headed: BTC volatility is significantly higher than that of U.S. Treasuries. Using BTC as stablecoin collateral requires a more conservative collateralization-ratio design, which will reduce capital efficiency. The liquidation-delay risk under extreme market conditions also needs to be validated by a model. Still, the direction is sound—and worth watching.
@BabylonLabs_io $BABY #baby

There are mainly three paths for BTC into DeFi right now. The first is WBTC, which is custody by BitGo. It has the largest market cap and the best liquidity, but you have to trust BitGo as a company. After the change of management-control turmoil in 2024, trust has split badly. The second is tBTC, the multisig solution from Threshold Network. It’s more decentralized, but liquidity is thin. The third is TBV, given by @BabylonLabs_io —completely different in design: BTC never leaves the Bitcoin mainnet.
TBV’s mechanism is to lock BTC in a vault contract on the Bitcoin chain. Using the BitVM3方案, it generates verifiable collateral state proof credentials on the Ethereum side. Off-chain, it uses garbled-circuit circuits to handle complex computation; on-chain, only a minimal fraud proof is kept, keeping the costs under control. To unlock BTC, users must submit a ZK proof of the corresponding contract state. Any liquidator who wants to move the collateral must also submit a ZK proof. Throughout the process there’s no custodian, no multisig, and no oracle.
Compare them and it becomes very clear: WBTC trusts a custodian; tBTC trusts a set of signers; TBV trusts only cryptography and the challenge period. The first two are “human problems,” and the latter is a “math problem.” Math can have bugs fixed; human problems are hard to fix.
Babylon’s Bitcoin staking protocol is the foundation: it has TVL over $5 billion, with more than 50,000 BTC locked, providing TBV with a mature validator network and liquidity base. The first integrated use case is Aave v4: lock BTC → obtain credentials → borrow stablecoins → repay to unlock. The whitepaper also lays out extensions such as stablecoin minting, perpetual margin, and liquid staking. The May Gomining partnership was a real-gold test at a scale of 1,000 BTC.
No sugarcoating the downsides. TBV’s user experience is more complex than WBTC’s. The challenge period slows down the operation cadence, and the auditability of the off-chain circuits is also a new issue. In the short term, WBTC’s liquidity and convenience will still have the advantage. But if TBV can encapsulate the complexity to the point that users don’t perceive it, long-term replacement is not impossible.
@BabylonLabs_io $BABY #baby

After 2024, global regulation of crypto derivatives has clearly tightened. Against this backdrop, when re-examining the positioning of <@grvt_io >, I think the route it chose is actually forward-looking.
First, the background. The U.S. SEC and CFTC have increased the intensity of enforcement against contract-based products. The EU’s MiCA is now fully in effect. Compliance license frameworks in Hong Kong, Singapore, and Japan have been gradually improving. The traditional “offshore + anonymous” crypto trading model is being systematically squeezed. The choices users will face next are: either accept KYC on compliant platforms, or trade in gray areas that lack protection.
$BTC
GRVT has chosen a middle path that is friendly to compliance without sacrificing user sovereignty. It has a license (according to publicly available information, it is registered in Bermuda and holds the relevant approvals). It performs institutional-level KYC, while preserving a non-custodial nature—funds remain in the user’s smart account, so the exchange cannot freeze or misappropriate them. In an environment where regulation is getting stricter, this combination has more room to survive than a purely anonymous DEX, and it can respond better than a traditional CEX to the “custody risk” layer.
What are the practical impacts on ordinary users?
First, in the future, platforms that can smoothly handle deposits and withdrawals will almost certainly require KYC. Refusing KYC means fewer and fewer optional platforms. GRVT’s KYC process is relatively user-friendly—standard mainstream identity verification and address proof are usually enough, without overly collecting data.
Second, compliant platforms have a higher probability of survival. In recent years, many exchanges that were shut down by enforcement had long avoided regulation. Choosing compliance-friendly platforms generally offers better long-term protection for fund safety.
Third, compliance does not mean centralization. GRVT’s compliance mainly exists at the legal-entity level; technologically, it remains non-custodial on-chain. These two aspects can coexist—you don’t have to choose one over the other.
A reminder: no single platform should carry all the positions. This is something I emphasize repeatedly across many posts. Diversification means not only diversifying assets, but also diversifying platforms and regions. Non-custodial on-chain platforms, compliant CEXs, and cold wallets each have their own roles.
Tighter regulation isn’t a bad thing. It will weed out bad actors who have existed for a long time, leaving teams that take product seriously. This process is a net positive for users.
<@grvt_io > <#grvt >

I’ve been thinking about a question: how exactly does @NewtonProtocol ’s “intent-centric network” differ from the traditional transaction model?
I’ve gone through the documentation several times. In plain terms, intent is what the user expresses as “I want this result,” not “I want to execute this step.” Traditional transactions are like: I want to swap 100 USDC for ETH, using the 0.05% pool on Uniswap V3.
Intent is: I want to use 100 USDC to get as much ETH as possible, and the operator helps me compute the path.
That sounds like it saves users work, but I don’t think it’s that simple.
The intent model has a prerequisite: there must be a pool of operators willing to help users solve it, and the answers they produce must be better than what users could come up with on their own. Here there are two costs: one is the solving cost, and the other is the competition cost. Newton’s approach is to run operators inside a TEE, and simultaneously use policies to constrain the execution boundaries—so, in theory, it can handle both “help me compute quickly” and “don’t let you compute wildly.”
But I worked out the overhead at the experience layer. Before users sign an intent, they have to figure out what their policy is. If that policy is written too broadly, the operator might act in a gray area; if it’s too narrow, the intent can’t be executed. This trade-off is something ordinary users simply don’t know how to set.
My judgment is: the intent model is developer-friendly and curator-friendly, but not retail-user-friendly. If Newton wants retail users to use it directly, it needs an extra “foolproof” layer in between—some kind of template so users can click a few buttons and generate a reasonable policy. $BTC
Next, I’ll focus on when Newton can build that layer. No matter how elegant the technical architecture is, if users can’t understand it, it’s pointless. If that step can’t work, then an intent network will always be just a B2B toy. The real volume isn’t in the protocol itself—it’s in the packaging layer.
$NEWT @NewtonProtocol #Newt