Eman098

That massive red candle wick down to 2,384 was likely a sharp liquidity sweep or a sudden flush of long positions. The fact that buyers stepped in immediately and managed to claw back up past 2,470 shows resilience but they are not out of the woods yet.

​If you're looking at this chart:

​Bullish view: The recovery bounce looks relatively healthy and if it can flip the mid 2,500s into support it could target that Supertrend line.

​Bearish view: Until price breaks above the Supertrend at 2,530 and holds this whole up-move is just a relief bounce inside a larger corrective zone.

​Are you currently holding a position on this move or looking for an entry?
$ETH

ENA just had a monster move up 25% to 0.1854 bouncing hard off that 0.1349 low from a couple days ago. That's a textbook V shaped reversal after a grinding downtrend.

The volume tells the real story though: that huge green bar right as price broke out confirms this wasn't a fakeout real buying showed up. RSI(6) at 87 is screaming overbought short term RSI(14) at 74 backs that up so a pullback or consolidation here wouldn't be surprising at all. MACD just crossed bullish and the histogram's turning green which supports the move but it's fresh not mature.

Honestly, this looks like a strong momentum breakout that's due for a breather. Chasing it at 0.1854 is risky waiting for a pullback toward 0.165 0.170 for entry looks smarter than buying the top of this candle.
$ENA

#dusk $DUSK @Dusk
What caught my attention while going through Dusk's docs: only two contracts exist At genesis the stake contract and the transfer contract. Everything else including DuskVM and DuskEVM sits on top of them.

That's a strange amount of concentration for a chain built to settle regulated assets. So I wanted to check what these two actually do and whether they can be changed later.

The stake contract tracks provisioners who is staked how much when rewards mature when slashing applies. The transfer contract handles both public (Moonlight) and shielded (Phoenix) balances and it's the only place contract to contract fund movement actually happens. Every execution environment routes through it for settlement and data availability per current docs.

Why that matters: if you are building on DuskEVM or issuing assets through Dusk Trade, you are not just trusting your own contract logic. You are trusting that these two genesis contracts behave correctly indefinitely since they are the settlement substrate underneath everything else.

Here is what I couldn't pin down. Docs describe these contracts being refactored over time the staking contract was rebuilt to fix a storage issue and later engineering updates changed its Event structure. So they clearly aren't frozen in the immutable at genesis sense.

What's unclear to me is the actual upgrade path: is it discretionary (protocol team ships a network upgrade) or is there a formal on chain governance step that provisioners vote on before genesis contract logic changes? The docs I found describe what the contracts do, not how modifications to them get authorized.

For a chain positioning itself for institutional settlement that distinction team authorized upgrade vs. provisioner ratified upgrade seems like it should be documented explicitly somewhere.

Has anyone seen where @Dusk specifies the actual Authorization process for genesis contract changes?

$DUSK #dusk

#dusk $DUSK @Dusk
What caught my attention was not Dusk's compliance messaging it's what an independent audit firm found sitting inside dusk plonk the proof system securing Phoenix @Dusk 's shielded transaction model on DuskDS.

The mechanism: Phoenix uses PLONK proofs so a spend can be verified without revealing balances. The verifier is supposed to check a batch of polynomial commitments against a trusted verifier key before accepting any proof as valid.

The part I wanted to verify: according to a security firm's writeup four of those selector evaluations were never actually checked against their commitments the verifier consumed them without validating them. In theory that gap could let a forged proof pass as legitimate.

Why it matters: this sits directly beneath the shielded pool that regulated Asset flows are meant to inherit privacy from. A forged proof in an opaque note system is hard to catch after the fact that's the whole point of shielding.

The detail most people would miss: the fix landed mid February 2026 before the public disclosure in April so patched not exploited based on what's been published. What's unclear to me is whether this was caught by Dusk's internal review or an outside party first and how that timeline was communicated to partners relying on this layer.
Does Audited mean much if the fix predates the disclosure by two months?

$DUSK #dusk

#dusk $DUSK @Dusk
What caught my attention about NPEX was not the €300M figure it was that NPEX already holds an MTF license, a broker license and an ECSP license under Dutch/EU rules and Dusk is building directly on top of that existing regulatory stack rather than asking regulators for a new crypto specific framework. So the part I wanted to verify was: how does an onchain trade actually stay compliant with an MTF's investor eligibility rules without a centralized gatekeeper checking every transaction?

The mechanism as far as current docs describe it runs through Citadel's selective disclosure.
An investor proves a specific claim residency accreditation status, KYC completion as a zero-knowledge proof tied to their wallet without exposing the underlying document or personal data. The counterparty or the protocol logic verifies the proof, not the data itself.

Why this matters for a regulated venue specifically: NPEX can't legally let just anyone trade certain instruments. Historically that meant a centralized broker checking IDs before every order. Here eligibility becomes a reusable cryptographic credential instead of a repeated manual check which is what actually makes instant settlement plausible for regulated assets rather than just a marketing claim.

What I have not been able to confirm from current documentation is how credential revocation works in practice if someone's Eligibility status changes (a residency change, a sanctions flag) how quickly does that propagate to wallets holding proofs issued under the old status and does it require the investor to re-prove or can the issuer invalidate proofs unilaterally?

That Gap the freshness of a disclosure proof relative to a regulator's real-time expectations seems like the actual test of whether this scales past one pilot exchange. Anyone who is looked at the Citadel spec know how revocation is currently handled?

$DUSK #dusk @Dusk

#dusk $DUSK @Dusk
What caught my attention wasn't the zero knowledge side of Dusk that gets most of the attention it was a smaller detail in how a block actually becomes final.

I wanted to check how Succinct Attestation, DuskDS's permissionless, committee Based proof-of-stake consensus protocol actually confirms a transaction since instant settlement gets thrown around loosely in this space.

Each round goes through three steps: a provisioner proposes and broadcasts a candidate block a committee validates it and a second committee ratifies that validation and finalizes the block. Only after both committees agree does the block move forward.

What's interesting is that @Dusk doesn't treat finality as one binary event. A block is Accepted once it passes all three steps Confirmed once later blocks build on it Stable once it's sufficiently buried and finally Final deterministic and cryptographically guaranteed meaning it cannot be reversed.

For regulated settlement, that staged distinction matters more than raw speed. A custodian doesn't just need a transaction to be fast it needs a defined point where irreversible is provable not assumed.

What I'd want clarified is behavior under sustained load. Two separate committees agreeing adds a coordination step that single proposer chains skip. As the provisioner set and stake distribution grow, does ratification stay fast or does committee coordination itself become the constraint?
The docs lay out the phases and reward split 70% proposer 5%/5% to validation and ratification committees clearly what they do not spell out is a throughput ceiling under Real network congestion only testnet behavior.

Has anyone seen committee selection or finality Time data from Dusk under actual sustained transaction load rather than idle network numbers?

$DUSK #Dusk

#dusk $DUSK @Dusk
I have been going back and forth between two Dusk documents that describe privacy in completely different ways and the gap between them is the actual story.

Zedger, Dusk's original regulated-asset protocol, runs natively on DuskDS and is UTXO based the same accounting model Bitcoin uses. l
extended for compliance. Hedger its successor runs on DuskEVM and takes a different route: it combines homomorphic encryption (ElGamal over elliptic curves) with zero knowledge proofs on top of a hybrid UTXO/account model.

What caught my attention is what that combination actually buys you. With HE computations happen directly on encrypted balances no one has to decrypt a value to add or subtract it. ZK proofs then verify the computation was done correctly without revealing the inputs. Balances and transfer amounts stay encrypted end to end while the network can still confirm nothing was forged.

The part I wanted to verify: does this cost you anything versus Zedger? According to @Dusk s own materials yes the EVM's account based model can't offer the full anonymity that a UTXO layer like Zedger provides. Hedger gives you confidential balances and auditability not unlinkability.

So the tradeoff is nOt privacy vs. compliance it's privacy vs. developer surface. Zedger keeps stronger anonymity but stays UTXO native. Hedger sacrifices some of that for plug and play EVM tooling.

What I'd still want to know: in a regulated instrument that touches both Zedger on DuskDS and Hedger on DuskEVM which privacy guarantee actually governs at settlement?

$DUSK #dusk

#dusk $DUSK @Dusk
Phoenix keeps double spend proofs in a Merkle tree of notes instead of an account ledger nO visible balances yet nobody can spend the same output twice. I wanted to see how that actually holds together.

Phoenix treats every unit of @Dusk as a UTXO called a note. Each note lives as a hash inside a Merkle tree. Spending a note doesn't erase it that's not how these trees work. Instead spending it produces a nullifier: a value derived from the note's secret key that appears publicly once it's used. The network never learns which note the nullifier came from, only that it's now invalid. Try to reuse the same note, and the duplicate nullifier gives it away instantly.

That design is why Phoenix can stay shielded and still be enforceable. Regulated finance can't tolerate ambiguous settlement, and nullifiers give deterministic finality without exposing sender receiver or amount. A view key lets an owner selectively prove what a note contained so auditability is not traded away entirely it's deferred to the key holder.

What I couldn't fully resolve from docs: how nullifier set growth is managed long term and what the proving overhead looks like as the note tree scales under sustained institutional volume rather than test Conditions.

Genuinely curious has anyone seen throughput numbers for Phoenix proof generation under real settlement load not testnet benchmarks?

$DUSK #dusk

#dusk $DUSK @Dusk

I keep two different browser profiles for work and personal stuff same person but the accounts Never touch each other. Something similar is going on under the hood of DuskEVM's privacy layer and it's a stranger design than I expected.

What caught my attention while reading through Hedger's spec: a @Dusk user operating in this system doesn't have one address they have two. A regular EVM address for normal contract calls and a separate Hedger address that holds an encrypted balance. The interesting part is why it's not just for show.

The Mechanism step by step: your Hedger balance is encrypted using ElGamal over elliptic curves (a homomorphic scheme) so the network can add and subtract encrypted amounts without ever decrypting them. When you send a private transfer you attach a zero-knowledge proof showing the math checks out inputs match outputs no negative balances without revealing the actual numbers. Compliance is handled through allowlisting rather than blanket transparency so an auditor can be given access without the whole chain seeing it.

Why it matters: this is a genuinely different tradeoff than most private DeFi setups which usually shield the transaction but leave you working inside one identity. Splitting the public execution identity from the confidential balance identity means an application can plug into normal EVM tooling for logic and only route the money side through the encrypted path.

What I couldn't fully resolve from the docs: how the two addresses are meant to be linked or unlinked at the UX layer does binding happen once at wallet setup per-session or per-contract?
That seems like the detail that decides whether this feels seamless or like managing two separate accounts forever.

Anyone who's actually tested Hedger on Sepolia how dOes that binding work in practice?

$DUSK #dusk

#dusk $DUSK
Every RWA chain claims compliance built in. What actually made me stop was one specific line in Dusk's market infrastructure docs: transfer controls exist as a distinct, enforced step Enforce who can hold or transfer separate from onboarding and separate from settlement. Most chains blur those into one thing: if you have tokens, you can move them.

So I wanted to check what that separation actually means for NPEX going onchain.

Documented: Dusk's architecture splits the regulated-asset lifecycle into stages issuer setup, investor onboarding (wallet binding to verified participants), transfer controls, trading/distribution, and settlement with deterministic finality. Each stage is a checkpoint, not just a UI step. Zedger runs this natively on DuskDS Hedger brings a similar model to DuskEVM using homomorphic encryption plus ZK proofs so balances stay encrypted while remaining auditable.

Why it matters: a public ledger can prove a transaction happened. It can't, by itself, prove the recipient was eligible to receive that asset. That eligibility check is what separates Tokenized from regulated. NPEX bringing its ~€300M+ AUM onchain is the first real test of whether that enforcement layer runs live, not just in docs.

What I can't confirm from public material: whether NPEX's current onchain activity actually routes through wallet binding and transfer control logic at the contract level, or whether that enforcement still happens off-chain today with the blockchain acting mainly as a settlement and record layer for now. Dusk's docs describe the design; they don't show me NPEX's live configuration.

Genuinely curious has anyone seen a transaction (or rejected transaction) from the NPEX deployment that shows transfer-control logic actually blocking an ineligible holder onchain rather than at the brokerage layer?

@Dusk $DUSK #dusk

#dusk $DUSK
What caught my attention was not the €300M figure attached to NPEX it was a smaller detail buried in Dusk's market infrastructure docs: before any asset can move a wallet has to be bound to a Verified participant. Not KYC'd once and forgotten. Bound per asset as an enforceable transfer condition.

I wanted to check what that actually means mechanically because compliant tokenization gets thrown around loosely.

Here's the sequence Dusk documents for something like NPEX's onboarding: an issuer defines eligibility rules for the asset. Investors' wallets get bound to verified credentials. From that point, the Transfer contract layer enforces who's even allowed to hold or move the token the restriction lives at the settlement layer not in a frontend checkbox. Settlement itself ties the asset leg and payment leg together for deterministic finality, so you don't get a state where shares moved but payment didn't.

Why this matters: NPEX is a Dutch MTF under AFM supervision. It can't just point at a public ERC-20 and call it a security. The eligibility check has to be enforceable on chain not just at the interface otherwise the Regulated part is theater.

The part I'd want to verify and haven't seen fully specified: what happens when eligibility changes an investor gets deregistered or a jurisdiction rule updates for tokens already held. Does the binding get revoked retroactively or does it only gate future transfers?
That's the actual test of whether this is a real regulated asset system or a issuance time compliance check.

NPEX moving €300M is one data point. Whether transfer control logic holds up under a live regulatory edge case is the one that decides if this generalizes to the rest of the sector.

Genuinely curious how Dusk handles the revocation case anyone dug into the Zedger/Hedger controlled Transfer spec closely Enough to know?

@Dusk $DUSK #dusk

#dusk $DUSK
I was reading through some old notes on tokenized securities the other night, and something clicked that I hadn't really sat with before. Most people talk about @Dusk like it's another RWA chain just a place to wrap real assets and call it innovation. But the more I looked into it the more it seemed like the real story is somewhere else in the boring parts nobody gets excited about. Reconciliation. Settlement. Compliance checks that Actually hold up if a regulator asks questions.

I kept wondering why so few projects treat that as the hard problem because it is the hard problem it's the reason regulated markets move so slowly in the first place.
Privacy without losing auditability transactions that settle cleanly without every detail being public rules that get enforced at the protocol level instead of bolted on after the fact. That's a different kind of infrastructure than what people usually picture when they hear crypto.

I noticed myself asking less Does this scale and more would an actual compliance officer trust this. Still none of that matters if nobody's trading and liquidity feels like the part that's hardest to just build your way into. So I'm left wondering if the market side catches up to the technical side or if that gap stays the real bottleneck for something like this.

#dusk
$DUSK @Dusk

#dusk $DUSK
I kept scrolling past Dusk updates for months without really stopping on them.
Roadmap items partnership names a Module called Hedger I couldn't quite picture in action. It all sounded fine but distant like blueprints for a building I'd never actually walk into.

Then DuskEVM mainnet went live and something shifted in how I was reading all of it. I remember opening the docs again and realizing NPEX and Chainlink weren't just names in an announcement anymore they were things that could actually get tested against a real running chain. Same with Hedger. Homomorphic encryption and zero knowledge proofs sound abstract until there's an actual Environment for them to sit in and do their job.

I think what struck me is how much of crypto lives in that gap between planned and deployable and how rarely we notice the moment something crosses over. Mainnet didn't feel like a finish line when I looked closer more like the point where everything they'd been saying either has to hold up or it doesn't.

I guess I'm just sitting with that distinction now between announcing something and having to run it. Makes me wonder how many other projects I have been half following are still stuck on the blueprint side of that line.

$DUSK #dusk @Dusk

#dusk $DUSK
I once watched a friend explain their bank transaction to a group chat screenshot and all just to prove they'd actually paid rent. Everyone laughed it off. But it stuck with me: we have normalized having zero privacy over money and calling it trust.

Crypto was supposed to fix that. Instead it split into two camps chains that show everything and chains that hide everything. Neither works for real finance.

The common story is that privacy and compliance are opposites you pick one, you lose the other. But I think the real issue is not technical it's behavioral. Institutions don't actually want secrecy. They want control over who sees what, when. A company doesn't mind an auditor seeing its books it minds a competitor seeing them first.

That's a different problem than hide everything from everyone.

This is where DuskEVM's approach is interesting. Through Hedger transactions stay encrypted by default balances, amounts, counterparties but the proof of correctness is still verifiable. A Regulator can review when needed. A competitor scrolling a block explorer can't. It is not privacy vs. compliance it's privacy for compliance on tooling Solidity developers already know.

Maybe the real unlock in finance was never More transparency. Maybe it was always controlled disclosure and we just didn't have the cryptography to build it until now.

What would you actually want visible about your own transactions and to whom?

@Dusk $DUSK #dusk