Native Bridge DuskVM WASM · Piecrust · ZK-Native · Privacy-Preserving Rust / WASM DuskEVM OP Stack · Solidity · MetaMask · Hardhat Compatible EVM / Solidity DuskDS Settlement · Consensus · Data Availability · Staking DUSK Token Single DUSK Token Fuels all three layers DS EVM VM
Mainnet · Live

The Dusk Network
Learning Hub

Privacy-first regulated blockchain for real-world assets. A visual, developer-focused reference for the Dusk protocol — architecture, consensus, node operations, and smart contracts.

Privacy by Design Regulatory Ready EVM Compatible ZK-Native Min 1,000 DUSK Stake
1,000
Min DUSK to Stake
~10s
Block Time
1B
Max DUSK Supply
~2s
DuskEVM Block Time
Section 01

Protocol Architecture

A modular three-layer stack: settlement at the base, EVM and privacy execution on top, connected by a trustless native bridge.

DuskDS — Settlement & Data Availability Layer Rusk Node Succinct Attest. Phoenix (Private) Moonlight (Public) Stake Contract Kadcast P2P DuskVM — Privacy Execution Piecrust VM Rust / WASM PLONK ZK DuskEVM — EVM Execution OP Stack Solidity MetaMask/Hardhat ⟷ Native Bridge DUSK token
🔵 DuskDS — Foundation
  • Canonical chain ordering & finality
  • Succinct Attestation consensus (PoS)
  • Phoenix + Moonlight transaction models
  • Transfer & Stake genesis contracts
  • Kadcast P2P networking (UDP 9000)
🟣 DuskVM — Privacy Execution
  • Piecrust WASM VM (10× faster than predecessor)
  • ZK-friendly host functions: PLONK, Groth16, BLS
  • Rust contracts with #[contract] macro
  • Delta-based state — only changes persisted
🔷 DuskEVM — EVM Execution
  • Full EVM equivalence via OP Stack port
  • Settles to DuskDS — no 7-day fault window
  • Standard tooling: MetaMask, Hardhat, Foundry
  • Chain IDs: 744 (mainnet), 745 (testnet)
⟷ Native Bridge
  • Trustless, no wrapped assets needed
  • Single DUSK token across all three layers
  • MIPS pre-verifier eliminates fraud proof delay
  • ~15 min withdrawal finalization
Section 02

Succinct Attestation

Dusk's PoS consensus delivers deterministic finality in three clean steps — essential for financial settlement applications.

STEP 1 PROPOSAL 1 selected proposer broadcasts candidate block STEP 2 VALIDATION Committee votes on validity quorum threshold required STEP 3 RATIFICATION 2nd committee confirms → FINAL Deterministic Sortition — stake-weighted, non-interactive committee selection
⚡ Key Properties
  • Minimum 1,000 DUSK to stake & participate
  • 2-epoch maturity period (4,320 blocks) before earning
  • Deterministic Sortition — no randomness oracle needed
  • BLS signature aggregation for compact certificates
  • Security: honest stake > 2/3 of total
📏 Epoch & Round Parameters
  • 1 epoch = 2,160 blocks
  • 64 committee credits per round
  • Max 50 iterations per round before timeout
  • Block reward: ~19.86 DUSK/block (Period 1)
  • Split: 70% proposer + up to 10% bonus / 5% validation / 5% ratification / 10% Dusk Dev Fund (unclaimed bonus burned)
Finality States
Accepted — block passed all 3 steps in current round
Confirmed — block has subsequent blocks building on it
Stable — sufficiently buried, probabilistically irreversible
Final — deterministic, cryptographically guaranteed finality — cannot be reversed

Committee Selection Visualized

GEN VAL VAL VAL VAL RAT RAT RAT RAT IDLE IDLE IDLE Provisioner Ring Deterministic Sortition selects committees from staked provisioners 1. Proposer (1 node) 2. Validation Committee 3. Ratification Committee Each round: sortition picks 1 proposer + 2 distinct committees from all staked provisioners Block is FINAL after ratification — deterministic, no reorg possible
Section 03

Phoenix & Moonlight

Dusk's dual transaction model — choose privacy or transparency per transaction. Unique in blockchain design.

🌑 Phoenix Private UTXO Model Input Notes ZK Proof Output ✓ Sender hidden from public* ✓ Receiver hidden from public ✓ Amount hidden Nullifiers prevent double-spend PLONK proofs (JubJub curve) *Sender known to receiver (auditable) Use: private transfers, OTC, institutional ☀ Moonlight Transparent Account Model Account A Transfer Tx Account B ✓ Exchange compatible ✓ Higher throughput ✓ No ZK proof required MiCA / regulatory compliance EVM-interop friendly Same gas model as Phoenix Use: exchange deposits, DeFi, public payments
Conversion: Atomic Swap Between Models
shield — Moonlight balance → Phoenix notes (public to private)
unshield — Phoenix notes → Moonlight balance (private to public)
Handled by the Transfer Contract in a single atomic transaction — no bridges, no wrapped tokens
Both models can interact with the same smart contracts — full composability
Section 04

Kadcast P2P Network

Structured UDP-based broadcast protocol using Kademlia DHT. O(log n) complexity vs gossip's unpredictable fan-out.

ORIGIN node B1 B2 B3 β = 3 delegates per bucket level RaptorQ FEC 12% UDP loss tolerance f = 0.15 overhead O(log n) broadcast vs gossip's unpredictable fanout
🌐 How It Works
  • Peer IDs: 128-bit Blake2b hash of IP+port
  • XOR distance routing (Kademlia-style)
  • k-buckets with LRU eviction + PING/PONG liveness
  • β=3 delegates per bucket on broadcast
  • Duplicate CHUNK messages are ignored (no storms)
📊 vs Gossip Protocols
  • 25–50% bandwidth reduction vs gossip
  • Predictable, lower latency
  • Handles 12% UDP packet loss gracefully
  • Sybil and Eclipse attack resistant by design
  • Port: 9000/UDP — must be open inbound
Section 05

DuskEVM

Full EVM equivalence via OP Stack, settling to DuskDS instead of Ethereum. Solidity contracts with no code changes. Integration time drops from months to ~2 weeks.

DuskDS Settlement · Consensus · Data Availability DuskEVM — OP Stack op-geth op-batcher MIPS pre-verifier blobs (EIP-4844) No 7-day fault window Standard Tooling MetaMask Hardhat Foundry ethers.js / viem OpenZeppelin Blockscout Explorer User submits tx via JSON-RPC standard Ethereum endpoint Gas Model L2 Execution Fee EIP-1559 base + tip L1 DA Fee blob posting to DuskDS Gas token: DUSK
🌐 Network Config
NetworkChain ID
Mainnet744
Testnet745
RPC: https://rpc.evm.dusk.network
⚠ EVM Behavioral Differences
  • COINBASE → sequencer fee wallet (not miner)
  • PREVRANDAO → DuskDS beacon (not ETH beacon)
  • tx.origin → aliased for cross-layer calls
  • All other opcodes identical to standard EVM
javascript — hardhat.config.js
module.exports = {
  solidity: "0.8.24",
  networks: {
    duskEVM: {
      url: "https://rpc.evm.dusk.network",
      chainId: 744,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};
Section 06

Economic Protocol

How DUSK flows through the system — staking rewards, gas fees, autocontracts, and the transfer contract as financial middleware.

DUSK native token Block Reward ~19.86 DUSK/block Period 1 (halves every 4yr) Staking Min 1,000 DUSK Earn via committees & proposing Gas Fees Paid in DUSK Contracts can pay on behalf Block Participants 70% proposer + up to 10% bonus 5% validation + 5% ratification Autocontracts Autonomous execution triggered by events Dusk Dev Fund 10% of block reward (fixed) Unclaimed proposer bonus → burned
🤖 Autocontracts
  • Execute autonomously when triggered by on-chain events
  • Useful for: trading strategies, automated transfers, rebalancing
  • Contracts can pay gas on behalf of users (sponsor model)
  • Enables subscription fee models vs traditional tx taxes
💰 Token Supply
  • Max supply: 1,000,000,000 DUSK
  • 500M initial + 500M emitted over 36 years
  • Halving every 4 years (Bitcoin-style)
  • Period 1 ends ~2029 — highest emission now

Emission Schedule — 500M DUSK over 36 Years

250M 187.5M 125M 62.5M 0 250.5M 0-4y 125.2M 4-8y 62.6M 8-12y 31.3M 12-16y 15.7M 16-20y 7.8M 20-24y 3.9M 24-28y 2.0M 28-32y 1.0M 32-36y 50% reduction every 4-year period · Max supply: 1,000,000,000 DUSK Red dashed line: cumulative decay curve
PeriodYearsEmissionDUSK/Block
10–4250.48M~19.86
24–8125.24M~9.93
38–1262.62M~4.96
412–1631.31M~2.48
516–2015.65M~1.24
620–247.83M~0.62
724–283.91M~0.31
828–321.95M~0.16
932–360.98M~0.08
Section 07 · Key Differentiator

Dusk vs Ethereum

Ethereum is a general-purpose platform. Dusk is purpose-built for regulated finance. Not a fork — a ground-up redesign for the institutions that actually need compliance.

Ξ Ethereum General Purpose Layer 1 Stake: 32 ETH Finality: ~16 minutes Privacy: roadmap (Phase 1–5) ZK: L2 rollups only MEV: active extraction Compliance: none native VS ◈ Dusk Network Regulated Finance Layer 1 Stake: 1,000 DUSK Finality: faster, deterministic Privacy: native (Phoenix ZK + Moonlight) ZK: protocol-level PLONK MEV: private execution → no surface Compliance: Citadel ZK-ID + NPEX
Feature Ethereum Dusk
Consensus Gasper (Casper FFG + LMD GHOST) Succinct Attestation
Min Stake 32 ETH 1,000 DUSK
Block Time 12s (targeting 2s by 2029) ~10s DuskDS / ~2s DuskEVM
Finality ~16 min (targeting 6-16s by 2029) Deterministic via SA
Privacy Public by default, privacy is multi-phase roadmap Native — Phoenix (ZK UTXO) + Moonlight (transparent)
Transaction Model Account-based only Dual: Phoenix (UTXO/private) + Moonlight (account/public)
Smart Contracts Solidity on EVM Solidity on DuskEVM + Rust/WASM on DuskVM
ZK Proofs L2 rollups only — L1 has none Native PLONK at protocol level
MEV Protection Transparent mempool → MEV extraction Private execution — no surface to front-run
Compliance No native compliance tooling Citadel ZK-ID, NPEX licensed (MTF, ECSP, Broker)
Hardware 32 ETH + execution + consensus clients 2 cores, 4 GB RAM, 1,000 DUSK
P2P Network Gossip (libp2p) Kadcast — O(log n) structured broadcast
🔐
Privacy by Design
Ethereum's privacy spans 5 roadmap phases over years. Dusk has ZK privacy at the protocol level today.
Regulatory Ready
Licensed under NPEX (MTF, ECSP, Broker, DLT-TSS pending). Citadel ZK identity. Ethereum has no native compliance.
🌱
Accessible Staking
1,000 DUSK vs 32 ETH. A dramatically lower barrier means more validators, better decentralization.
Dual Execution
Solidity (DuskEVM) + privacy Rust/WASM (DuskVM) under one roof with a trustless native bridge.
🛡
No MEV by Design
Private state execution means nothing to front-run. The transparent mempool problem doesn't exist.
🏦
RWA Native
Securities tokenization and compliant DeFi from day one. T-REX (ERC-3643), EMT contracts, OnchainID deployed.
Section 08

Node Setup Guides

Three tracks: standard setup, separated key for security, or USB cold storage with LUKS encryption for maximum protection.

1. Install node installer 2. Wallet rusk-wallet create 3. Export Key consensus.keys 4. Start Node service rusk start 5. Stake min 1,000 DUSK
bash — Standard Setup
# Install Rusk (mainnet)
curl --proto '=https' --tlsv1.2 -sSfL \
  https://github.com/dusk-network/node-installer/releases/latest/download/node-installer.sh \
  | sudo bash

# Create wallet (save mnemonic securely!)
rusk-wallet create

# Export consensus key to correct location
rusk-wallet export -d /opt/dusk/conf -n consensus.keys

# Set consensus key password
sh /opt/dusk/bin/setup_consensus_pwd.sh

# Fast sync state, then start node
service rusk stop && download_state && service rusk start

# Monitor sync progress
tail -F /var/log/rusk.log | grep "block accepted"

# Check block height (compare with explorer)
ruskquery block-height

# Stake once synced (min 1000 DUSK)
rusk-wallet stake --amt 1000

# Verify stake
rusk-wallet stake-info
Requirements
Ubuntu 24.04 LTS x64 — officially supported OS only
2 CPU cores, 4 GB RAM, 50 GB SSD, 10 Mbps stable connection
Open port 9000/UDP (Kadcast) — required for consensus
2-epoch maturity period (~4,320 blocks) before earning rewards
🔒 Owner Machine (Cold) rusk-wallet create → note owner address Controls: unstake, withdraw, restake Keep offline / hardware wallet separated 🌐 Node Machine (Hot) rusk-wallet create → export consensus.keys Controls: block signing only Node compromise = no fund loss How --owner staking works 1. Node wallet stakes stake --amt --owner 2. Chain records consensus → node, owner → you 3. Only owner can unstake / withdraw rewards
How does --owner make this secure?
When you run rusk-wallet stake --amt 1000 --owner <owner-address> from the node wallet, you're writing an on-chain record: "this node's consensus key earns rewards, but only the owner address can unstake or withdraw." The node wallet can only sign consensus messages — if the server is compromised, the attacker cannot move funds. The owner address (your cold/hardware wallet) is the sole key that can call unstake or withdraw. Think of it as: the node is a worker, the owner holds the paycheck.
bash — Step 1: Owner Machine (cold/secure)
# Create the OWNER wallet on a secure machine (offline preferred)
rusk-wallet create

# Note your owner address — you'll need it for the staking step
rusk-wallet addresses
# Example output: owner address = 27xyK9gR...a1Bk
bash — Step 2: Node Machine (server/VPS)
# Install Rusk node
curl --proto '=https' --tlsv1.2 -sSfL \
  https://github.com/dusk-network/node-installer/releases/latest/download/node-installer.sh \
  | sudo bash

# Create a SEPARATE wallet on the node (different mnemonic!)
rusk-wallet create

# Export consensus key for the node to use
rusk-wallet export -d /opt/dusk/conf -n consensus.keys
sh /opt/dusk/bin/setup_consensus_pwd.sh

# Fast sync state, then start node
service rusk stop && download_state && service rusk start

# Wait for sync — check block height matches explorer
ruskquery block-height
bash — Step 3: Stake with --owner (from node wallet)
# From the NODE machine, stake with the --owner flag
# Replace <owner-address> with the address from Step 1
rusk-wallet stake --amt 1000 --owner <owner-address>

# Verify stake and owner assignment
rusk-wallet stake-info
# You should see: owner = <owner-address> (NOT the node address)

# What this means:
#   Node wallet → signs blocks, earns rewards
#   Owner wallet → sole key that can unstake or withdraw
#   Server hacked? → attacker CANNOT touch staked DUSK
Security Model
Node compromised? Attacker can only sign consensus — cannot unstake, withdraw, or move funds
Owner key stays on a hardware wallet, airgapped machine, or secure cold storage
Two separate mnemonics — do not use the same mnemonic on both machines
To unstake later: run rusk-wallet unstake from the owner wallet only
Recommended by Dusk docs for validators with significant stake
🔐 USB Drive (LUKS) Encrypted partition Contains: owner wallet files Lost USB = unreadable without passphrase Plug in only when unstaking/withdrawing airgapped 💻 Secure Machine Mount USB → generate wallet rusk-wallet -w /mnt/dusk Ideally offline / airgapped Wallet never stored on disk separated 🌐 Node Machine (Hot) — separate wallet, consensus.keys only, stakes with --owner <usb-wallet-address> If node is compromised → attacker cannot unstake, withdraw, or access the USB-stored owner key Three layers of protection ① LUKS encryption on USB ② rusk-wallet password ③ --owner key separation
Why USB + LUKS?
This is the most secure owner key setup. The wallet is generated directly onto a LUKS-encrypted USB drive — the owner key never exists on any hard drive. Even if the USB is lost or stolen, the data is encrypted and unreadable without your passphrase. You only plug it in when you need to unstake or withdraw rewards.
bash — Step 1: Prepare the LUKS-encrypted USB
# Insert USB drive and identify it (usually /dev/sdb or /dev/sdc)
lsblk
# IMPORTANT: Replace /dev/sdX with YOUR device — this ERASES the drive

# Install cryptsetup if not present
sudo apt update && sudo apt install -y cryptsetup

# Wipe and create a LUKS-encrypted partition
# You will be asked to set a strong passphrase — DO NOT FORGET IT
sudo cryptsetup luksFormat /dev/sdX1

# Open the encrypted partition (you'll enter the passphrase)
sudo cryptsetup open /dev/sdX1 dusk-cold

# Format the decrypted volume with ext4
sudo mkfs.ext4 /dev/mapper/dusk-cold

# Create a mount point and mount
sudo mkdir -p /mnt/dusk-cold
sudo mount /dev/mapper/dusk-cold /mnt/dusk-cold

# Set permissions so your user can write
sudo chown $(whoami):$(whoami) /mnt/dusk-cold
bash — Step 2: Generate owner wallet onto USB
# Create the owner wallet DIRECTLY on the encrypted USB
# The -w flag tells rusk-wallet to use a custom directory
rusk-wallet create -w /mnt/dusk-cold/wallet

# Save your mnemonic phrase on paper (NOT digitally)
# This mnemonic + the USB are your only recovery paths

# Get the owner address — write this down, you need it for staking
rusk-wallet -w /mnt/dusk-cold/wallet addresses
# Example output: owner address = 27xyK9gR...a1Bk

# Verify the wallet files exist only on the USB
ls -la /mnt/dusk-cold/wallet/
# Should show .dat wallet files
bash — Step 3: Safely unmount and eject
# Unmount the drive
sudo umount /mnt/dusk-cold

# Close the LUKS encryption layer
sudo cryptsetup close dusk-cold

# Physically remove the USB drive
# Store it in a safe place (fireproof safe, safety deposit box, etc.)
bash — Step 4: Set up node + stake with --owner
# === ON NODE MACHINE (server/VPS) ===
# Install Rusk node
curl --proto '=https' --tlsv1.2 -sSfL \
  https://github.com/dusk-network/node-installer/releases/latest/download/node-installer.sh \
  | sudo bash

# Create a SEPARATE node wallet (different mnemonic from USB!)
rusk-wallet create

# Export consensus key
rusk-wallet export -d /opt/dusk/conf -n consensus.keys
sh /opt/dusk/bin/setup_consensus_pwd.sh

# Sync and start
service rusk stop && download_state && service rusk start
ruskquery block-height  # Wait for sync

# Stake using the owner address from your USB wallet
# Replace <owner-address> with the address from Step 2
rusk-wallet stake --amt 1000 --owner <owner-address>

# Verify: owner should show the USB wallet address
rusk-wallet stake-info
bash — Later: Accessing USB wallet to unstake/withdraw
# When you need to unstake or withdraw rewards:
# Insert the USB drive
sudo cryptsetup open /dev/sdX1 dusk-cold
sudo mount /dev/mapper/dusk-cold /mnt/dusk-cold

# Unstake or withdraw using the USB wallet
rusk-wallet -w /mnt/dusk-cold/wallet unstake
rusk-wallet -w /mnt/dusk-cold/wallet withdraw

# Close up when done
sudo umount /mnt/dusk-cold
sudo cryptsetup close dusk-cold
# Remove USB and store safely
Security Model
Three-layer protection: LUKS drive encryption + rusk-wallet password + --owner key separation
USB lost or stolen? Data is LUKS-encrypted — unreadable without your passphrase
Node compromised? Attacker has no access to the USB wallet — cannot unstake or withdraw
Key never on disk: owner wallet exists only on the USB — no trace left on any machine
Backup your mnemonic on paper — if the USB dies, the mnemonic is your recovery path
Use /dev/sdX1 carefully — lsblk confirms the correct device before formatting
Section 09

Smart Contract Development

Two parallel paths: Solidity on DuskEVM for EVM-standard contracts, or Rust/WASM on DuskVM for privacy-native contracts.

Both paths can interact via native bridge Rust #[contract] WASM make wasm rusk-wallet contract-deploy DuskVM Piecrust WASM VM ZK-native · Privacy Solidity standard EVM Compile Hardhat/Foundry Deploy npx hardhat deploy DuskEVM OP Stack EVM MetaMask compatible Native Bridge cross-layer calls
🦀 DuskVM Path (Rust)
  • Use Forge framework — #[contract] macro
  • Target: wasm32-unknown-unknown
  • State as ordinary Rust structs (no key-value store)
  • Native ZK host functions: verify_plonk, verify_bls
  • Deploy via rusk-wallet contract-deploy
⚡ DuskEVM Path (Solidity)
  • Standard Solidity 0.8.x — no modifications needed
  • OpenZeppelin, ERC20/ERC721/ERC4626 all work
  • T-REX (ERC-3643) security tokens deployed and live
  • OnchainID (ERC734/ERC735) for KYC identity
  • Verify contracts on Blockscout explorer
rust — DuskVM contract (Forge)
#![no_std]
#![cfg(target_family = "wasm")]
extern crate alloc;

use dusk_forge::contract;

#[contract]
mod counter {
    use dusk_core::abi;

    pub struct Counter { value: i64 }

    impl Counter {
        pub const fn new() -> Self { Self { value: 0 } }

        pub fn read_value(&self) -> i64 { self.value }

        pub fn increment(&mut self) {
            self.value += 1;
            abi::emit("incremented", self.value);
        }
    }
}
Section 10

Wallet & Key Management

The rusk-wallet CLI manages DUSK, staking, smart contracts, and the Phoenix/Moonlight conversion in one tool.

Mnemonic Phrase 12-word recovery phrase BLS Key Pair (BLS12-381) Moonlight · Consensus · Staking JubJub Key Pair 2× curve points (A, B) · Phoenix shielded Consensus Key Hot · Signs blocks Owner Key Unstake · Withdraw rewards Moonlight Acct Public address Phoenix Keys Secret · View keys Stealth Addrs One-time per tx
CommandWhat It Does
rusk-wallet createCreate a new wallet, generates 12-word mnemonic — back it up immediately
rusk-wallet restoreRestore from mnemonic — enter all words in lowercase
rusk-wallet balanceShow DUSK balance (all accounts)
rusk-wallet stake --amt 1000Stake 1,000 DUSK (minimum)
rusk-wallet stake-infoView current stake, maturity, rewards
rusk-wallet withdrawWithdraw accumulated staking rewards
rusk-wallet unstakeUnstake — no waiting period, no penalty
rusk-wallet shield --amt 100Convert public (Moonlight) → shielded (Phoenix)
rusk-wallet unshield --amt 100Convert shielded (Phoenix) → public (Moonlight)
rusk-wallet export -d /opt/dusk/conf -n consensus.keysExport consensus key to node directory
rusk-wallet contract-deploy --bytecode ./my.wasmDeploy a smart contract to DuskVM
Section 11

Node Maintenance & Security

Keep your node healthy to avoid slashing. Dusk currently uses soft slashing only — stake is moved to claimable rewards, not burned.

Public Network peer peer DoS? scan Sentry Nodes Public-facing, known addresses Sentry A Sentry B Filter traffic · relay consensus msgs 🔒 Validator Node Private IP · consensus.keys Only connects to sentries Not directly internet-exposed
⚠ Soft Slashing (Recoverable)
  • Triggered: missed block production (offline/slow)
  • 1st offense: warning only, no stake loss
  • 2nd+: N×10% moved to claimable rewards
  • Suspended N epochs per consecutive fault
  • Recoverable: withdraw and restake
  • Faults reset on next reward earned
💡 Best Practices
  • Never run two nodes with the same consensus.keys
  • Monitor block height against explorer.dusk.network
  • Keep your node updated to the latest Rusk version
  • Use sentry node architecture for DoS protection
  • Set up log monitoring and alerting
bash — Monitoring Commands
# Service status
service rusk status

# Live block acceptance (healthy node shows frequent output)
tail -F /var/log/rusk.log | grep "block accepted"

# Current block height (compare with explorer.dusk.network)
ruskquery block-height

# Stake status
rusk-wallet stake-info

# Port check — 9000/UDP must be open
ss -ulnp | grep 9000

# Node stuck? Fast resync:
service rusk stop && download_state && service rusk restart
Section 12

Ecosystem & Community Projects

Live projects, integrations, and developer tools built on or partnered with Dusk Network.

DUSK Network REGULATED MARKETS NPEX Dutch MTF · Tokenized Securities Dusk Trade Trading Platform · DuskEVM 21X Frankfurt DLT Pilot Regime PRIVACY & IDENTITY Citadel SSI Private KYC · ZK Identity Hedger HE + ZK Privacy Engine EURQ (Quantoz) MiCA-Compliant Stablecoin DEV TOOLS & SDKs w3sper.js JS/TS SDK · dApp Integration Moat SDK Citadel Integration Toolkit INFRASTRUCTURE Chainlink CCIP · DataLink · Data Streams Cordial Systems Institutional Custody CORE APPS Web Wallet · Block Explorer · BSC Bridge THESAN DEV FUND 15M DUSK · Ecosystem Grants
Section 13

Resources & Links

Official documentation, GitHub repositories, block explorers, and community channels.

Built with data from docs.dusk.network, github.com/dusk-network, and dusk.network. Not an official Dusk Foundation publication. Research date: March 2026.