MINA BNB

翻訳参照

I know the real information and truth Current tokenomics documentation states that DUSK is the native token used for transaction fees/gas and staking. Current mainnet denomination uses 9 decimals, with 1 DUSK equal to 1,000,000,000 LUX.
Parameter Current documented value
Symbol DUSK
Mainnet decimals 9
Unit LUX = 1e-9 DUSK
Supply model 500M initial + 500M emitted over time
Maximum supply 1B DUSK
Primary utility Gas + staking
Supply and emission should be studied separately from market price. Tokenomics determines network incentives and security budget; market price determines external purchasing power. The economic protocol report exists specifically because monetary/security design is a protocol concern.
#dusk $DUSK @Dusk

確認済み

翻訳参照

Dusk maintains a public audit repository. The listed reports include Plonk, Kadcast, Piecrust, BLS/hash reviews, protocol security, economic protocol design, Rusk consensus, Rusk node library, Phoenix, migration smart contracts, and 2026 ERC20/BEP20 assessments.
Audit area Publicly listed auditor/date
PLONK Porter Adams — Dec 2023
Kadcast Blaize Security — Apr 2024
Piecrust Porter Adams — May 2024
BLS and hash JP Aumasson — Jul 2024
Protocol security OAK Security — Sep 2024
Economic design POL Finance — Sep 2024
Rusk consensus OAK Security — Sep 2024
Rusk node library OAK Security — Sep 2024
Phoenix Jules de Smit — Sep 2024
Migration contract Zellic — Oct 2024
DUSK ERC20 Mochavi — Apr 2026
DUSK BEP20 Mochavi — Apr 2026
#dusk $DUSK @Dusk

確認済み

翻訳参照

確認済み

翻訳参照

Current tokenomics documentation states that DUSK is the native token used for transaction fees/gas and staking. Current mainnet denomination uses 9 decimals, with 1 DUSK equal to 1,000,000,000 LUX.
Parameter Current documented value
Symbol DUSK
Mainnet decimals 9
Unit LUX = 1e-9 DUSK
Supply model 500M initial + 500M emitted over time
Maximum supply 1B DUSK
Primary utility Gas + staking
Supply and emission should be studied separately from market price. Tokenomics determines network incentives and security budget; market price determines external purchasing power. The economic protocol report exists specifically because monetary/security design is a protocol concern.
$DUSK @Dusk #dusk

確認済み

翻訳参照

DuskEVM is the EVM-compatible execution environment in Dusk's modular direction. Current developer documentation describes Solidity/Vyper support and familiar tools such as Hardhat and Foundry. Deployment documentation lists DuskEVM mainnet chain ID 744 and testnet chain ID 745, with dedicated RPC and explorer endpoints.
The 2025 modular architecture article describes DuskEVM as an OP Stack-based execution layer settling through DuskDS. The current public website describes it as an EVM path for regulated applications and points to Hedger for confidential flows.
$DUSK #dusk @Dusk

I was looking at Dusk modular architecture again and the diagram makes more sense once you stop looking at it as three separate chains. It's really three different jobs being split across the stack. 1. DuskDS — the base layer This is the foundation. DuskDS is responsible for the underlying network functions around: * consensus * data availability * settlement So instead of putting every execution responsibility into the base layer, DuskDS is focused on keeping the underlying system coordinated and settled. 2. DuskEVM — the compatibility layer This is where EVM execution comes in. The interesting part isn't simply “Dusk supports EVM.” It's that EVM execution gets its own layer inside the modular architecture, giving developers a more familiar environment while keeping the underlying DuskDS layer separate. That separation can reduce the amount of integration work needed when building applications. 3. DuskVM — the privacy execution layer Then there is DuskVM. Its role is different again: privacy-focused execution. So the architecture isn't forcing public-style EVM execution and privacy-oriented execution into exactly the same environment. They're being separated into their own execution paths. And then there are two pieces connecting the whole design. 4. One DUSK across the stack The architecture keeps a single DUSK token across the layers. That matters because modular execution doesn't automatically mean fragmented economics. The execution environments can be separated while the token economy remains unified. 5. Native bridge between DuskDS and DuskEVM The layers also aren't supposed to behave like isolated islands. The architecture describes a native bridge concept between DuskDS and DuskEVM, giving the execution layer a path back to the underlying Dusk system. That's the part I find more interesting than the diagram itself. The architecture is basically saying: DuskDS handles the foundation. DuskEVM handles EVM execution. DuskVM handles privacy-focused execution. $DUSK #dusk @Dusk_Foundation

翻訳参照

I was looking at Dusk modular architecture again and the diagram makes more sense once you stop looking at it as three separate chains.

It's really three different jobs being split across the stack.

1. DuskDS — the base layer

This is the foundation.

DuskDS is responsible for the underlying network functions around:

* consensus
* data availability
* settlement

So instead of putting every execution responsibility into the base layer, DuskDS is focused on keeping the underlying system coordinated and settled.

2. DuskEVM — the compatibility layer

This is where EVM execution comes in.

The interesting part isn't simply “Dusk supports EVM.”

It's that EVM execution gets its own layer inside the modular architecture, giving developers a more familiar environment while keeping the underlying DuskDS layer separate.

That separation can reduce the amount of integration work needed when building applications.

3. DuskVM — the privacy execution layer

Then there is DuskVM.

Its role is different again: privacy-focused execution.

So the architecture isn't forcing public-style EVM execution and privacy-oriented execution into exactly the same environment.

They're being separated into their own execution paths.

And then there are two pieces connecting the whole design.

4. One DUSK across the stack

The architecture keeps a single DUSK token across the layers.

That matters because modular execution doesn't automatically mean fragmented economics.

The execution environments can be separated while the token economy remains unified.

5. Native bridge between DuskDS and DuskEVM

The layers also aren't supposed to behave like isolated islands.

The architecture describes a native bridge concept between DuskDS and DuskEVM, giving the execution layer a path back to the underlying Dusk system.

That's the part I find more interesting than the diagram itself.

The architecture is basically saying:

DuskDS handles the foundation.

DuskEVM handles EVM execution.

DuskVM handles privacy-focused execution.
$DUSK #dusk @Dusk

翻訳参照

Every time you prove who you are online, you usually end up revealing way more than needed. Show an ID to prove you're over 18, and suddenly a stranger knows your exact birthdate, your address, your full name. Citadel was built to fix exactly that problem.

It's Dusk identity and access layer a zero-knowledge-based, self-sovereign identity system. The idea is simple: prove a fact, not your whole file. Need to show you live in a certain country? Prove residency, nothing else. Need to prove you're old enough? Prove the age bracket, not your birthdate. Need to show you're an accredited investor? Prove that status alone the rest of your identity stays off-chain, untouched. In regulated markets, where eligibility has to be shown but privacy still matters, that distinction is everything.

Four players make this work, each with their own job. The user owns their identity and decides what actually gets disclosed. The issuer, or credential authority, is the one vouching for those credentials in the first place think of them as the source of truth behind the claim. The verifier, or the application, is the one asking prove it, without ever needing the full story behind the proof. And underneath all of it sits the Dusk protocol itself, running the settlement and verification layer that lets all of this happen without leaning on some central authority to make it trustworthy.

The whole point of Citadel comes down to one line: prove exactly enough, and not one bit more.
$DUSK #dusk @Dusk

#dusk $DUSK @Dusk_Foundation While going through Dusk approach to real-world assets, I spent some time understanding Zedger, and it's clearly built with a very different audience in mind compared to a typical DeFi token standard this is aimed at securities and regulated real-world assets (RWA). What struck me first was how much emphasis is put on regulatory compliance, privacy, and auditability all at the same time. Normally you'd think privacy and auditability are in tension either regulators can see everything, or users get privacy, rarely both. But Zedger is designed so both can coexist: transactions can stay confidential from the general public while still being auditable by the parties who legitimately need to verify them (like regulators or issuers). The functional side is what really shows the "securities" angle. Zedger supports: Minting and burning creating and retiring units of the asset, similar to how a company might issue or retire shares. Corporate actions things like dividend distributions, handled natively at the protocol/asset level instead of being bolted on. Issuer-initiated force transfers this one stood out to me the most, because it's not something you'd typically see in a permissionless crypto asset. It reflects real securities law, where an issuer sometimes needs the legal authority to move or reclaim tokens (court orders, compliance actions, lost-key recovery, etc.). I also came across the term XSC (Confidential Security Contract), and I want to be precise about what that actually means. My initial assumption was that XSC might just be another name for the whole Dusk chain but that's wrong. Zedger is what provides the underlying foundation for XSC functionality, and XSC itself is really an asset/business-standard layer basically a template or standard for how a specific type of confidential security token should behave on top of the base protocol. So: Dusk = the chain, Zedger = the securities protocol, XSC = the standard/contract pattern built using Zedger for a specific security-token use case.

翻訳参照

#dusk $DUSK @Dusk While going through Dusk approach to real-world assets, I spent some time understanding Zedger, and it's clearly built with a very different audience in mind compared to a typical DeFi token standard this is aimed at securities and regulated real-world assets (RWA).

What struck me first was how much emphasis is put on regulatory compliance, privacy, and auditability all at the same time. Normally you'd think privacy and auditability are in tension either regulators can see everything, or users get privacy, rarely both. But Zedger is designed so both can coexist: transactions can stay confidential from the general public while still being auditable by the parties who legitimately need to verify them (like regulators or issuers).

The functional side is what really shows the "securities" angle. Zedger supports:

Minting and burning creating and retiring units of the asset, similar to how a company might issue or retire shares.
Corporate actions things like dividend distributions, handled natively at the protocol/asset level instead of being bolted on.
Issuer-initiated force transfers this one stood out to me the most, because it's not something you'd typically see in a permissionless crypto asset. It reflects real securities law, where an issuer sometimes needs the legal authority to move or reclaim tokens (court orders, compliance actions, lost-key recovery, etc.).

I also came across the term XSC (Confidential Security Contract), and I want to be precise about what that actually means. My initial assumption was that XSC might just be another name for the whole Dusk chain but that's wrong. Zedger is what provides the underlying foundation for XSC functionality, and XSC itself is really an asset/business-standard layer basically a template or standard for how a specific type of confidential security token should behave on top of the base protocol. So: Dusk = the chain, Zedger = the securities protocol, XSC = the standard/contract pattern built using Zedger for a specific security-token use case.

So let me walk you through this Dusk entire privacy architecture is really built on top of a specific stack of cryptographic primitives, and here is the thing, each one is doing a job none of the others can actually do. Start with BLS12-381 that's what @Dusk_Foundation uses to power signatures and most of its ZK-related cryptography. Now, specifically for the Phoenix privacy layer, Dusk relies on something called JubJub, which is a SNARK-friendly curve. And honestly, without it, shielded proofs on Dusk would be way too slow to actually run in practice. For authentication across the network, $DUSK sticks with Schnorr signatures a clean, well-tested choice, nothing experimental about it. Now, inside Dusk's ZK circuits, hashing is handled by Poseidon, and this one was built specifically to stay cheap in a context where older hash functions just get expensive fast once you drop them into a circuit. When it comes to state and membership proofs, #dusk uses a sparse Merkle tree, and the entire proving and verification layer runs on PLONK. On top of all that, Dusk also applies something called BLS aggregation basically it compresses an entire committee's signatures into a single package, instead of the network having to verify every single one individually. Let me just lay out the full lineup so it's clear: BLS12-381 — signatures and ZK-related cryptography JubJub — SNARK-friendly curve powering Phoenix-style privacy Schnorr — signature and authentication Poseidon — ZK-friendly hashing Sparse Merkle tree — membership and state proofs PLONK — ZK proving and verification BLS aggregation — compresses committee signatures into one Now here is something worth keeping in mind none of these primitives really mean much just sitting there on paper. Dusk cryptography can be completely sound mathematically and still get undermined in practice think bad serialization, a missed subgroup check, weak transcript binding, or skipped domain separation. So if you are really trying to judge Dusk cryptographic foundation fairly.

翻訳参照

So let me walk you through this Dusk entire privacy architecture is really built on top of a specific stack of cryptographic primitives, and here is the thing, each one is doing a job none of the others can actually do.

Start with BLS12-381 that's what @Dusk uses to power signatures and most of its ZK-related cryptography. Now, specifically for the Phoenix privacy layer, Dusk relies on something called JubJub, which is a SNARK-friendly curve. And honestly, without it, shielded proofs on Dusk would be way too slow to actually run in practice.

For authentication across the network, $DUSK sticks with Schnorr signatures a clean, well-tested choice, nothing experimental about it. Now, inside Dusk's ZK circuits, hashing is handled by Poseidon, and this one was built specifically to stay cheap in a context where older hash functions just get expensive fast once you drop them into a circuit.

When it comes to state and membership proofs, #dusk uses a sparse Merkle tree, and the entire proving and verification layer runs on PLONK. On top of all that, Dusk also applies something called BLS aggregation basically it compresses an entire committee's signatures into a single package, instead of the network having to verify every single one individually.

Let me just lay out the full lineup so it's clear:

BLS12-381 — signatures and ZK-related cryptography
JubJub — SNARK-friendly curve powering Phoenix-style privacy
Schnorr — signature and authentication
Poseidon — ZK-friendly hashing
Sparse Merkle tree — membership and state proofs
PLONK — ZK proving and verification
BLS aggregation — compresses committee signatures into one

Now here is something worth keeping in mind none of these primitives really mean much just sitting there on paper. Dusk cryptography can be completely sound mathematically and still get undermined in practice think bad serialization, a missed subgroup check, weak transcript binding, or skipped domain separation. So if you are really trying to judge Dusk cryptographic foundation fairly.

Okay so here is the thing about @Dusk_Foundation sortition process — its non-interactive, which just means every single node figures out the same result on its own, no back-and-forth needed with anyone else. Why does that work? Simple — everyone's plugging in the exact same inputs, so no matter who runs the numbers, they land on the same answer every time. The basic idea is this: provisioners who qualify get handed credits based on how much they've staked. Stake more, get more credits. That's what they call "deterministic extraction." And because it works this way, two things fall into place naturally anyone can go check the selection was legit, and people with bigger stakes naturally get better odds. There is one thing doing a lot of work behind the scenes here though the seed. It travels along with the chain, and whoever generates the current block updates it before passing it on. When a score needs to be worked out, Dusk runs SHA3 hashing on three things at once: the seed, the round/step details, and the credit number. Put those together and you get a one-of-a-kind score. Why go through all this trouble? Mainly so nobody can guess ahead of time who's getting picked next as generator or committee member that unpredictability is what keeps bad actors from gaming the system. But here is the flip side: once the data's actually on-chain, anyone can look back and confirm everything was done properly. A few terms worth knowing here: Eligibility — your stake has to hit a minimum amount and also sit long enough to count as "mature" before you're in the running. Epoch — right now on Dusk, an epoch lasts 2160 blocks, then it resets and a new one kicks off. Credit — basically your stake translated into a unit that gets used in the selection math. Seed — the randomness that comes straight from the chain itself, getting refreshed with every block signature. Committee — a random bunch of provisioners picked to either validate blocks or ratify them. $DUSK #dusk

翻訳参照

Okay so here is the thing about @Dusk sortition process — its non-interactive, which just means every single node figures out the same result on its own, no back-and-forth needed with anyone else. Why does that work? Simple — everyone's plugging in the exact same inputs, so no matter who runs the numbers, they land on the same answer every time.

The basic idea is this: provisioners who qualify get handed credits based on how much they've staked. Stake more, get more credits. That's what they call "deterministic extraction." And because it works this way, two things fall into place naturally anyone can go check the selection was legit, and people with bigger stakes naturally get better odds.

There is one thing doing a lot of work behind the scenes here though the seed. It travels along with the chain, and whoever generates the current block updates it before passing it on. When a score needs to be worked out, Dusk runs SHA3 hashing on three things at once: the seed, the round/step details, and the credit number. Put those together and you get a one-of-a-kind score.

Why go through all this trouble? Mainly so nobody can guess ahead of time who's getting picked next as generator or committee member that unpredictability is what keeps bad actors from gaming the system. But here is the flip side: once the data's actually on-chain, anyone can look back and confirm everything was done properly.

A few terms worth knowing here:

Eligibility — your stake has to hit a minimum amount and also sit long enough to count as "mature" before you're in the running.

Epoch — right now on Dusk, an epoch lasts 2160 blocks, then it resets and a new one kicks off.

Credit — basically your stake translated into a unit that gets used in the selection math.

Seed — the randomness that comes straight from the chain itself, getting refreshed with every block signature.

Committee — a random bunch of provisioners picked to either validate blocks or ratify them.
$DUSK #dusk

確認済み

翻訳参照

So i totally understand $DUSK uses something called Kadcast as its main protocol for spreading blocks, transactions, and consensus votes across the network. It's not something built from zero it actually takes a lot of inspiration from Kademlia distributed hash table setup, especially the whole XOR distance concept. Basically, instead of just dumping messages onto every single neighbor like old-school gossip protocols do, it's smarter about it — it sends data through specific, structured paths using selected peers.

Breaking it down a bit:

Every node has its own identifier, and the XOR distance between nodes decides how peers get organized around each other.
Peers aren't just randomly connected they're grouped into what's called routing buckets, based on how far apart they are from a node.
When a message needs to spread, it doesn't go to everyone at once it's passed along through a chosen set of peers instead of flooding the whole network.
Since each bucket holds more than one peer, there's a safety net if one peer drops out or fails, there are other paths ready to carry the message forward.
There's also a security layer built in messages get signed, and before anything gets forwarded further, that signature is checked. This helps stop bad actors from messing with how data spreads.

And in terms of actual performance, @Dusk has reported that this setup cuts bandwidth usage by around 25–50% compared to regular gossip-style protocols. That said, it's worth keeping in mind this number comes from Dusk's own testing and design claims it's not some fixed guarantee that'll hold true in every single setup or condition out there. #dusk

翻訳参照

‎I wanted to actually try Babylon testnet myself, not just read about it. First thing I needed was tBABY tokens. I figured there'd be one faucet somewhere, buried in a Discord. Turns out there are three, all live, all working right now.
‎
‎I started with the Xangle faucet. Nothing complicated paste your wallet address, hit Request tBABY, and you're done. It gives 0.1 tBABY per wallet, once every 24 hours.
‎
‎Then I found HoodScan faucet, and this one surprised me a bit. It's not just for Babylon it's a multi-chain faucet covering Cosmos, EVM, and Bitcoin chains from one screen. I picked Babylon Testnet from the chain dropdown, connected my wallet provider, and requested tokens the same way.
‎
‎Last one was IT Rocket faucet, sitting right inside their full Babylon testnet explorer. Validators, governance, staking, IBC, supply all of it's there. I just dropped my address in the Get Tokens box and it went through.
‎
‎Across all three, the pattern was the same: small amounts, roughly 0.02 to 0.1 tBABY per request, capped at 1 tBABY every 24 hours per wallet or IP.
‎
‎None of this looked flashy on screen. But that's kind of the point. A faucet is the boring front door to any testnet, and when I see three independent teams all running one for the same network at the same time, that tells me something there's real builder activity happening around Babylon Trustless Bitcoin Vaults right now, not just talk.
‎
‎Sometimes the smallest, most unglamorous part of a project is the clearest sign that people are actually building on it.
$BABY #baby @BabylonLabs_io

翻訳参照

‎I used to think Bitcoin confirmations were enough. Then I learned what Babylon does when the impossible happens.
‎
‎I was reading how Babylon handles one of Bitcoin rarest events: a deep blockchain reorganization (reorg).
‎
‎Imagine Bitcoin reaches block 150, then an unexpected 10-block reorg rolls the chain back to block 140.
‎
‎Instead of pretending nothing happened, Babylon Genesis immediately pauses the network to protect Bitcoin staking.
‎
‎Every BTC delegation, inclusion proof, or undelegation confirmed from block 140 onward is rechecked and removed if it's no longer valid. Delegations confirmed before block 139 remain untouched because their proof still exists on Bitcoin canonical chain.
‎
‎The protocol then recalculates voting power, finality, and rewards across its three core modules before resuming normal operation.
‎
‎This is why BABY, Babylon Genesis, and Trustless Bitcoin Vaults work together so well. TBV can only secure native Bitcoin if Babylon always follows the real Bitcoin chain, even during extremely rare network events.
‎
‎Most people focus on yields and staking rewards.
‎
‎I pay attention to the recovery system that's built for the 0.001% scenario because that's where real infrastructure proves itself.
$BABY #baby @BabylonLabs_io

BTC-1.68%

翻訳参照

‎I assumed Bitcoin staking was just about locking BTC and earning rewards. The deeper I looked, the more I realized it's powered by an entire security architecture working behind the scenes.
‎
‎The Babylon network is built on multiple layers, including Bitcoin scripts, Babylon nodes powered by the Cosmos SDK, Finality Providers, and supporting software that work together to securely connect with the Bitcoin network.
‎
‎At the top layer, Checkpointing keeps Bitcoin and Babylon Genesis synchronized. A BTC staking monitor and indexer track staking activity, while the Vigilante Network continuously watches both chains for malicious behavior. Anyone can run these nodes and help strengthen the network.
‎
‎The middle layer is the Babylon Node, built on the Cosmos SDK. It handles core functions such as Epoching, Checkpointing, BTC Staking, Finality, Rewards, BTC Light Client, Zone Concierge, and BTC Checkpointing, while Babylon Genesis reaches consensus through CometBFT.
‎
‎At the foundation, the EOTS Manager, Finality Provider nodes, and the Covenant Emulator validate external network data and enforce staking, unbonding, and slashing rules. IBC Relayers and Babylon Contracts enable secure communication and standardized data exchange between networks secured by Bitcoin.
‎
‎And the good thing is $BICO and $KOMA made my day with some solid profits today, but learning how Babylon is expanding Bitcoin utility feels like an even bigger win.
$BABY #baby @BabylonLabs_io

確認済み

翻訳参照

‎I stopped scrolling the BABY chart today and opened the vault explorer instead. What I found was more interesting than any candle.
‎
‎Babylon Trustless Bitcoin Vaults are not just a concept anymore. They are live on testnet, integrated with Aave v4, and every single action is on-chain and traceable.
‎
‎The numbers:
‎
‎TVL sits at 7.49 sBTC (~$517K), up 3.02 sBTC in just 30 days
‎320 vaults are active out of 2.12K total
‎28.35% utilization, with $146.6K currently borrowed against BTC collateral
‎0.517 sBTC ($35.7K) has already moved through liquidations cleanly, on-chain
‎But the part that actually got my attention was the activity feed. Every vault goes through a visible lifecycle: Signatures Collected, Pending, Verified, Available, Redeemed. Providers like Babylon Labs VP 0 and Kiln are actively working these vaults in real time, with full transaction hashes and block numbers attached to every step.
‎
‎No black box. No "trust us." Just a system doing exactly what it claims to do, in the open.
‎
‎Most people are still asking why BABY hasn't pumped. I'm more interested in what happens when this scales past testnet and hundreds of vaults turn into hundreds of thousands.
‎
‎The chart is the least interesting part of this story right now.
$BABY #baby @BabylonLabs_io

OMG、バビロンTBVのヴォルト隔離が私の視点を変えた ‎ ‎私が最初にビットコインDeFiについて学んだとき、ある疑問がずっと頭から離れませんでした。 ‎ ‎もし1つのプロトコルがハッキングされたら、どうなるの？ ‎ ‎ほとんどのラップBTCやブリッジ型のシステムでは、みんなのビットコインが一つにプールされます。何百人もの人が、巨大な一つの金庫にお金を預けているようなものです。その金庫が侵害されれば、何千人ものユーザーが同時に影響を受ける可能性があります。 ‎ ‎バビロンTBVは、まったく別のアプローチを取っています。 ‎ ‎みんなのBTCを1つの共有プールに入れるのではなく、各ユーザーがそれぞれ自分専用のビットコイン・ヴォルトを持つのです。巨大なロッカーをみんなで共有するのではなく、自分だけの貸金庫を持っているような感覚だと思ってください。 ‎ ‎各ヴォルトは： ‎ ‎ビットコインの保有者によって作成される。 ‎単一のDeFiアプリケーションに紐づけられる。 ‎あらかじめ定義されたビットコイン・スクリプトのルールで保護される。 ‎ビットコイン・ネットワークによって直接強制される。 ‎ ‎つまり、もしあるDeFiアプリケーションでバグやガバナンスの不具合が起きても、それが自動的にすべてのビットコイン保有者を危険にさらすわけではありません。その影響は、その特定のアプリケーションに接続されたヴォルトに限定されます。 ‎ ‎もう一つ、素晴らしいと感じた点は、あなたのビットコインが突然別の場所に転用されることがないことです。引き出し先はヴォルトが作成されるときに定義され、ビットコイン自体がTaprootスクリプトを通じてそれらのルールを強制します。 ‎ ‎さらに良いのは、各ヴォルトが隔離されているため、あなたのBTCが裏でこっそり再利用されたり、再担保化（rehypothecation）されたり、他人の資金と混ぜられたりすることができない点です。 ‎ ‎バビロンTBVをもっと調べていくほど、これは単にビットコインをDeFiに持ち込もうとしているだけではない、と気づきます。ビットコインを、そもそもビットコインが価値あるものにしたセキュリティ原則を犠牲にせずにDeFiへ持ち込もうとしているのです。 $BABY #baby @babylonlabs_io

OMG、バビロンTBVのヴォルト隔離が私の視点を変えた
‎
‎私が最初にビットコインDeFiについて学んだとき、ある疑問がずっと頭から離れませんでした。
‎
‎もし1つのプロトコルがハッキングされたら、どうなるの？
‎
‎ほとんどのラップBTCやブリッジ型のシステムでは、みんなのビットコインが一つにプールされます。何百人もの人が、巨大な一つの金庫にお金を預けているようなものです。その金庫が侵害されれば、何千人ものユーザーが同時に影響を受ける可能性があります。
‎
‎バビロンTBVは、まったく別のアプローチを取っています。
‎
‎みんなのBTCを1つの共有プールに入れるのではなく、各ユーザーがそれぞれ自分専用のビットコイン・ヴォルトを持つのです。巨大なロッカーをみんなで共有するのではなく、自分だけの貸金庫を持っているような感覚だと思ってください。
‎
‎各ヴォルトは：
‎
‎ビットコインの保有者によって作成される。
‎単一のDeFiアプリケーションに紐づけられる。
‎あらかじめ定義されたビットコイン・スクリプトのルールで保護される。
‎ビットコイン・ネットワークによって直接強制される。
‎
‎つまり、もしあるDeFiアプリケーションでバグやガバナンスの不具合が起きても、それが自動的にすべてのビットコイン保有者を危険にさらすわけではありません。その影響は、その特定のアプリケーションに接続されたヴォルトに限定されます。
‎
‎もう一つ、素晴らしいと感じた点は、あなたのビットコインが突然別の場所に転用されることがないことです。引き出し先はヴォルトが作成されるときに定義され、ビットコイン自体がTaprootスクリプトを通じてそれらのルールを強制します。
‎
‎さらに良いのは、各ヴォルトが隔離されているため、あなたのBTCが裏でこっそり再利用されたり、再担保化（rehypothecation）されたり、他人の資金と混ぜられたりすることができない点です。
‎
‎バビロンTBVをもっと調べていくほど、これは単にビットコインをDeFiに持ち込もうとしているだけではない、と気づきます。ビットコインを、そもそもビットコインが価値あるものにしたセキュリティ原則を犠牲にせずにDeFiへ持ち込もうとしているのです。
$BABY #baby @BabylonLabs_io

翻訳参照

People often hear "Trustless Bitcoin Vault" and assume it's just another crypto buzzword.
I thought the same at first.
But after spending time reading the TBV research, I realized it's something very different. What impressed me most wasn't the name—it was the way the entire system is designed.
Everything starts with a Deposit.
When BTC enters a Trustless Bitcoin Vault, it isn't simply locked. The protocol already defines every valid path that Bitcoin can take from that point forward. Whether the vault ends with a normal withdrawal or a dispute, those possibilities are established from the beginning.
Then comes the Assert step.
This is where Lamport Signatures become important.
Instead of asking anyone to trust a participant's claim, the protocol asks for cryptographic proof. A Lamport Signature proves that a participant committed to a specific state without exposing their secret key. It's evidence, not reputation.
If something doesn't look right, the protocol doesn't rely on human judgment.
It opens a challenge process.
The Verifier can challenge the commitment, and from there Bitcoin Script enforces the outcome. The participant either proves the commitment was valid, or loses the ability to continue. There isn't a hidden escape hatch or manual intervention.
Timelocks make sure nothing happens too quickly.
A withdrawal cannot happen immediately. Bitcoin waits for a predefined number of blocks, giving enough time for any invalid commitment to be challenged before funds can move.
To me, that's one of the smartest parts of the design.
The security isn't based on trusting operators, committees, or bridge validators. It's based on predefined Bitcoin Script conditions like CheckSig, HashLock, RelTimelock, and CheckLampSig, all working together to enforce the rules.
Every possible outcome is defined before the vault is even used.
That's why I think Babylon TBV stands out.
It doesn't ask Bitcoin users to trust another system.
$BABY #baby @BabylonLabs_io

BTC-1.68%

‎DeFiにおいて実際にビットコインの需要があるのかどうか、みんながよく聞いているのを見かけます。 ‎ ‎数字を見てみると、答えはかなり明白でした。 ‎ ‎Aave V3だけでも、すでに数十億ドル規模のビットコイン担保資産が担保として使われています： ‎ ‎WBTC: $2.9B 供給 ‎cbBTC: $1.8B 供給 ‎tBTC: $209.7M 供給 ‎LBTC: $167.4M 供給 ‎ ‎つまり需要が問題ではありません。 ‎ ‎より大きな問いは、なぜこれほど多くのネイティブ・ビットコインがまだ傍観（サイドライン）に置かれているのか、ということです。 ‎ ‎私の考えでは、それは「信頼」に尽きます。 ‎ ‎多くのビットコイン保有者は、何よりも自分自身で管理（セルフカストディ）することを重視しています。彼らはDeFiに関心はありますが、BTCをラップすることや、カストディアンに依存すること、あるいは追加の信頼前提を導入することにつながるなら、それは望まないのです。 ‎ ‎だからこそ、@babylonlabs_io Trustless Bitcoin Vaultsに注目しました。 ‎ ‎狙いは、人々にDeFiでビットコインを使わせることではありません。 ‎ ‎狙いは、そもそも彼らがビットコインに惹かれた原則を手放すよう求めることなく、それを可能にすることです。 ‎ ‎ネイティブBTCをビットコイン・ネットワークによって安全に保ったまま担保として使えるなら、今日のラップされたソリューションが解放できる以上にずっと大きな「遊休ビットコイン」のプールを引き出せる可能性があります。 ‎ ‎それが、私が最も興味を持っている点です。 ‎ ‎需要はすでに存在します。 ‎ ‎あとは、ビットコインの価値を損なうことなく、ビットコインがDeFiに参加できるようにするインフラを構築することです。 ‎ ‎私自身にとってBabylonは、DeFiにおけるビットコイン需要を新たに作ろうとしているわけではありません。需要はすでにあります。必要なのは、その需要をようやく満たせるようにする「トラストレスなインフラ」を構築することです。 ‎$BABY #baby

‎DeFiにおいて実際にビットコインの需要があるのかどうか、みんながよく聞いているのを見かけます。
‎
‎数字を見てみると、答えはかなり明白でした。
‎
‎Aave V3だけでも、すでに数十億ドル規模のビットコイン担保資産が担保として使われています：
‎
‎WBTC: $2.9B 供給
‎cbBTC: $1.8B 供給
‎tBTC: $209.7M 供給
‎LBTC: $167.4M 供給
‎
‎つまり需要が問題ではありません。
‎
‎より大きな問いは、なぜこれほど多くのネイティブ・ビットコインがまだ傍観（サイドライン）に置かれているのか、ということです。
‎
‎私の考えでは、それは「信頼」に尽きます。
‎
‎多くのビットコイン保有者は、何よりも自分自身で管理（セルフカストディ）することを重視しています。彼らはDeFiに関心はありますが、BTCをラップすることや、カストディアンに依存すること、あるいは追加の信頼前提を導入することにつながるなら、それは望まないのです。
‎
‎だからこそ、@BabylonLabs_io Trustless Bitcoin Vaultsに注目しました。
‎
‎狙いは、人々にDeFiでビットコインを使わせることではありません。
‎
‎狙いは、そもそも彼らがビットコインに惹かれた原則を手放すよう求めることなく、それを可能にすることです。
‎
‎ネイティブBTCをビットコイン・ネットワークによって安全に保ったまま担保として使えるなら、今日のラップされたソリューションが解放できる以上にずっと大きな「遊休ビットコイン」のプールを引き出せる可能性があります。
‎
‎それが、私が最も興味を持っている点です。
‎
‎需要はすでに存在します。
‎
‎あとは、ビットコインの価値を損なうことなく、ビットコインがDeFiに参加できるようにするインフラを構築することです。
‎
‎私自身にとってBabylonは、DeFiにおけるビットコイン需要を新たに作ろうとしているわけではありません。需要はすでにあります。必要なのは、その需要をようやく満たせるようにする「トラストレスなインフラ」を構築することです。
‎$BABY #baby

翻訳参照

Bitcoin Vault Security isn't about adding more features.
It's about removing the need for trust.
When I first compared different Bitcoin lending designs, one thing stood out immediately.
Most solutions can work.
But they usually depend on committees, bridge operators, multisig signers, or other trusted parties behind the scenes.
@BabylonLabs_io Trustless Bitcoin Vaults take a different path.

Bitcoin Vault Security

Borrower Creates Loan
│
┌────────┬────────┬────────┐
▼ ▼ ▼
DLC BitVM TBV
│ │ │
Committee Signers Trustless
& Ops Rules
└────────┼────────┘
▼
Borrower Withdraws
│
DLC → Committee
BitVM → Signers
TBV → Trustless
│
▼
Liquidation
│
DLC → Oracle
BitVM → Operators
TBV → Vault Rules

What I find most interesting is not that TBV removes every external assumption. Collateralized lending still depends on a price oracle.
The real innovation is removing unnecessary trust.
Instead of asking users to rely on committees, bridge operators, or multisig groups, TBV lets predefined cryptographic vault rules determine what can happen to Bitcoin.
To me, that's a much stronger security model.
Because security shouldn't depend on who signs a transaction.
It should depend on whether the protocol's rules have been satisfied.
That's the idea behind Babylon Trustless Bitcoin Vaults.
$BABY #baby

BABE: A Smarter Way to Verify Proofs on Bitcoin One of the biggest challenges in bringing advanced applications to Bitcoin has never been security its efficient verification. Previous approaches such as BitVM made trustless verification possible, but they still relied heavily on large garbled circuits and expensive dispute mechanisms. In some cases, verification could require massive on-chain data, higher capital requirements, and costly challenge transactions. BABE (@babylonlabs_io new verification protocol) introduces a different approach. Instead of depending solely on garbled circuits, BABE combines Witness Encryption (WE) with a lightweight interactive protocol to verify Groth16 zero-knowledge proofs on Bitcoin. The result is a system that reduces off-chain verification costs by more than 1,000× compared to previous Groth16 verifier implementations while maintaining the low on-chain footprint achieved by modern BitVM designs. Here's what makes BABE stand out: Witness Encryption ensures that only a valid proof can unlock the encrypted secret. • The Verifier encrypts a secret during setup without revealing private randomness. • The Prover can successfully decrypt the secret only after presenting a valid Groth16 proof. • An interactive protocol allows the Prover to compute the required cryptographic values without ever learning the Verifier private randomness, preserving both privacy and security. This architecture eliminates much of the computational overhead that has historically limited Bitcoin-native verification, making advanced cryptographic applications significantly more practical. BABE is not just another cryptographic upgrade. It's one of the technologies that can make Babylon Trustless Bitcoin Vaults more practical and scalable. Faster and cheaper proof verification strengthens the infrastructure that allows native BTC to be used as trustless collateral across lending, stablecoins, and other BTCFi applications without wrapping Bitcoin or relying on custodians. That's the direction Bitcoin DeFi has been waiting for. $BABY #baby

確認済み

翻訳参照

BABE: A Smarter Way to Verify Proofs on Bitcoin

One of the biggest challenges in bringing advanced applications to Bitcoin has never been security its efficient verification.

Previous approaches such as BitVM made trustless verification possible, but they still relied heavily on large garbled circuits and expensive dispute mechanisms. In some cases, verification could require massive on-chain data, higher capital requirements, and costly challenge transactions.

BABE (@BabylonLabs_io new verification protocol) introduces a different approach.

Instead of depending solely on garbled circuits, BABE combines Witness Encryption (WE) with a lightweight interactive protocol to verify Groth16 zero-knowledge proofs on Bitcoin. The result is a system that reduces off-chain verification costs by more than 1,000× compared to previous Groth16 verifier implementations while maintaining the low on-chain footprint achieved by modern BitVM designs.

Here's what makes BABE stand out:

Witness Encryption ensures that only a valid proof can unlock the encrypted secret.

• The Verifier encrypts a secret during setup without revealing private randomness.

• The Prover can successfully decrypt the secret only after presenting a valid Groth16 proof.

• An interactive protocol allows the Prover to compute the required cryptographic values without ever learning the Verifier private randomness, preserving both privacy and security.

This architecture eliminates much of the computational overhead that has historically limited Bitcoin-native verification, making advanced cryptographic applications significantly more practical.

BABE is not just another cryptographic upgrade. It's one of the technologies that can make Babylon Trustless Bitcoin Vaults more practical and scalable. Faster and cheaper proof verification strengthens the infrastructure that allows native BTC to be used as trustless collateral across lending, stablecoins, and other BTCFi applications without wrapping Bitcoin or relying on custodians. That's the direction Bitcoin DeFi has been waiting for.
$BABY #baby

BTC-1.68%