Eman098

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