C I R U S

For decades, finance has relied on private infrastructure. Banks, clearing houses, exchanges, and custodians all run their own ledgers behind closed doors. Access is restricted, data is siloed, and settlement happens inside networks that the public never sees. When blockchain technology arrived, many institutions tried to replicate this model. They built private blockchains, permissioned networks, and closed ledgers that looked like crypto on the surface but behaved like traditional IT systems underneath.
DuskEVM was built because that model does not actually solve the problem.
Private chains replace one set of trusted intermediaries with another. They remove the openness and composability that make blockchains powerful. They also fail to provide the legal and economic guarantees that public networks offer. DuskEVM takes a different path. It combines public cryptographic security with regulated confidentiality, allowing institutions to operate privately on infrastructure that remains verifiable, open, and economically enforced.
That difference is deeper than most people realize.
What private chains actually are
A private blockchain is usually a consortium database. A group of institutions agrees to run nodes. They decide who can participate. They control upgrades. They can rewrite rules if something goes wrong. Data is not visible to the public, but it is also not secured by a global economic network.
This makes private chains easy to deploy and hard to trust.
If the consortium disagrees, the network stalls. If a dominant member exerts influence, rules change. If a regulator questions the data, there is no independent verification layer.
Private chains are not decentralized. They are federated.
They are closer to shared databases than to blockchains.
Why finance tried private chains first
Institutions were drawn to private chains because they felt familiar. They allowed privacy. They allowed control. They allowed selective access. But they came with a hidden cost: they gave up the one thing that makes blockchains special.
Public verifiability.
On a private chain, you must trust the operators. On a public chain, you only trust math and incentives.
This is why private blockchains have not transformed finance. They made processes a little faster, but they did not change how trust works.
DuskEVM was built to do exactly that.
DuskEVM is public, but not exposed
The key insight behind Dusk is that public does not have to mean transparent. A network can be publicly verifiable without being publicly readable.
Dusk’s Layer 1 uses zero-knowledge proofs and homomorphic encryption to allow transactions to be private while still being provable. Anyone can verify that rules were followed. Not everyone can see the data.
This creates a third category between public chains and private chains.
A confidential public blockchain.
DuskEVM runs on top of that layer.
Smart contracts execute like they do on Ethereum. But when they settle, the data is shielded. Regulators and auditors can be granted access. The public cannot.
This is fundamentally different from a private chain, where data is hidden because only a few entities are allowed to see it. On Dusk, data is hidden because cryptography enforces who can see what.
No consortium controls it.
Economic security vs administrative control
Private chains are secured by legal agreements and governance boards. Dusk is secured by staking, slashing, and cryptographic consensus.
That difference is enormous.
If a private chain misbehaves, you must go to court.
If Dusk misbehaves, the protocol punishes it automatically.
Economic security scales globally. Legal security does not.
This is why institutions can trust Dusk in a way they cannot trust private chains. They do not have to trust the operator. They trust the network.
Why DuskEVM matters
DuskEVM brings this model to Solidity developers.
Instead of deploying financial applications on a closed consortium chain, developers deploy them on a public, cryptographically enforced network that still respects privacy and regulation.
This means:
• Assets are globally verifiable
• Ownership is cryptographically enforced
• Privacy is preserved
• Compliance is built-in
Private chains cannot do this. They must choose between control and openness.
Dusk does not.
Liquidity and composability
Private chains are liquidity islands. Assets issued on them cannot easily interact with the rest of the crypto ecosystem. There is no public market, no permissionless integration, and no composability.
DuskEVM connects regulated assets to the broader EVM world. Tokenized securities, compliant stablecoins, and financial instruments can interact with DeFi infrastructure without exposing sensitive data.
That is how real markets form.
The real difference
Private chains try to make blockchains look like banks.
DuskEVM makes blockchains look like financial infrastructure.
One is controlled.
The other is governed by cryptography and economics.
That is why DuskEVM is not just another permissioned ledger.
It is the first place where institutions can be private on a public chain.
And that changes everything.

@Dusk | #dusk | $DUSK

Walrus is often described as a decentralized storage protocol, but that description hides what actually makes it powerful. Walrus is not just about storing files. It is about turning data into something blockchains can own, verify, and reason about. That idea sounds simple, but it breaks most traditional blockchain designs. Without a fast, object-centric chain like Sui underneath it, Walrus would not be possible at all.
To understand why, we need to look at what Walrus is really doing.
Walrus does not treat data as an off-chain blob with a link attached. It treats data as an on-chain object. Every piece of data stored through Walrus is represented by an object that has an owner, a size, cryptographic commitments, and economic rules about how long it must be stored and who is responsible for serving it. That object is not just metadata. It is the enforcement layer for storage itself.
On most blockchains, this would be impossibly expensive or slow.
Traditional account-based chains process state changes sequentially. Every update touches global state, which means creating, updating, or verifying thousands or millions of storage objects would clog the entire network. Storage proofs, renewals, ownership transfers, and access control would become bottlenecks.
Sui solves this by being object-centric.
On Sui, each object is its own unit of state. Objects can be owned, updated, transferred, or referenced independently, without forcing the whole chain to process everything at once. That allows massive parallelism. Walrus can manage huge numbers of storage objects at the same time, each with its own lifecycle, without slowing down the rest of the network.
Speed matters just as much as structure.
Walrus requires frequent cryptographic proofs from storage providers to show that data is still being held and served. These proofs must be verified and recorded onchain. If this process were slow or expensive, the entire storage network would become inefficient and insecure. Sui’s fast finality and low-latency execution make it possible for Walrus to continuously enforce availability without sacrificing performance.
This is what turns storage into a live, on-chain resource rather than a passive archive.
The object model also enables composability. A DAO can own a storage object. An AI agent can reference a dataset object. A smart contract can require that a certain file object exists before executing. These are not pointers to off-chain data. They are actual on-chain assets that the protocol can reason about.
That is the key difference.
Walrus is not built on top of Sui by accident. It depends on Sui’s ability to handle millions of independent objects, verify them quickly, and let them interact with smart contracts without congestion.
In a future where data, AI, governance, and finance all run onchain, storage cannot be slow, fragile, or external.
It has to live where everything else lives.
And that is exactly why Walrus could only be built on an object-centric blockchain like Sui.

@Walrus 🦭/acc #walrus $WAL

For most blockchains, a mainnet launch is a marketing milestone. For Dusk, it is a structural one. It is the moment where theory becomes enforceable and where builders can finally deploy applications that are meant to be used by real financial institutions, not just crypto-native traders.
Until now, Dusk existed as an architecture, a test environment, and a roadmap. Mainnet changes that. It turns Dusk into a live settlement layer where privacy, identity, and compliance are not promises but protocol-level guarantees. For builders, this unlocks something that has not existed before: a place where programmable finance and regulated markets can actually coexist.
The most immediate change is finality.
On mainnet, every transaction settles onto Dusk’s Layer 1, which is designed for legally meaningful ownership. That means when a tokenized security changes hands, it is not just a smart contract event. It is a cryptographically enforced record that can be audited, verified, and accepted by regulators and institutions. Builders are no longer creating demo products. They are creating financial infrastructure.
This is especially important for anyone building real-world asset platforms.
With DuskEVM live on mainnet, developers can deploy Solidity contracts for tokenized stocks, bonds, funds, and other instruments while relying on Dusk’s privacy engine, Hedger, to protect sensitive financial data. This allows applications to meet data protection laws and market integrity rules without giving up onchain automation.
For builders, that means products can finally move out of pilots and into production.
The second major shift is composability with compliance.
On most chains, compliance is handled off-chain through KYC providers, custodial controls, or centralized front ends. On Dusk mainnet, compliance becomes something contracts can reason about. Identity, eligibility, and reporting can be enforced inside the protocol without exposing private information. Builders can create markets where only qualified participants trade, where disclosures are provable, and where regulators can audit without seeing everything.
This changes how applications are designed.
Instead of building “crypto apps with compliance glued on,” builders can design “financial apps with crypto rails underneath.”
Another critical impact of mainnet is trust.
Institutions do not integrate with testnets. Custodians, exchanges, and asset issuers require live networks with stable rules, predictable upgrades, and real economic security. Dusk mainnet provides that. Staking, slashing, and consensus are active. Data availability and privacy proofs are enforced. Economic incentives are live.
That gives builders something they have never had on a privacy-preserving chain: credibility.
It becomes possible to onboard partners who care about uptime, audits, and legal accountability.
Mainnet also changes the developer feedback loop. Bugs, performance issues, and edge cases now show up under real load, not synthetic testing. That allows Dusk to mature rapidly, and it allows builders to harden their applications in conditions that resemble real markets.
Perhaps most importantly, mainnet means integration.
Wallets, exchanges, custodians, and analytics providers start treating Dusk as a real chain. Assets can be listed. Data can be tracked. Liquidity can form. Builders can finally reach users outside closed test groups.
This is where ecosystems are born.
Dusk’s mainnet is not about flipping a switch. It is about opening a door.
A door to a new category of onchain applications, ones that are private, compliant, and powerful enough to host the next generation of financial infrastructure.
For builders, that is the difference between experimenting and building something that actually matters.

@Dusk | #dusk | $DUSK

When people hear that Dusk is launching an EVM, the instinctive reaction is to think of it as just another compatibility layer. Another chain that supports Solidity. Another place to deploy familiar contracts. But DuskEVM is not being built to compete with Ethereum or to clone DeFi. It is being built to solve a structural problem that most of Web3 has been ignoring: how do you run regulated financial systems on programmable blockchains without destroying privacy, compliance, or legal enforceability.
DuskEVM is not about copying Ethereum. It is about giving Ethereum’s tooling a new kind of settlement layer.
To understand what it really enables, you have to understand what has been missing from blockchain finance so far.
Why EVM alone was never enough
Ethereum proved that programmable money was possible. Smart contracts made lending, trading, and asset issuance accessible to anyone with an internet connection. But Ethereum also hard-coded one design decision that now limits its reach: everything is public.
Every balance.
Every trade.
Every contract interaction.
Every position.
This radical transparency created trust in a young ecosystem, but it created a wall between crypto and real finance. Banks, brokers, exchanges, and asset managers cannot operate on a ledger that exposes client data, trading strategies, and capital flows to the entire world. Data protection laws, market integrity rules, and fiduciary duties make it illegal.
This is why tokenized stocks, bonds, and funds have struggled to exist on public blockchains. Not because the technology is weak, but because the privacy model is wrong.
DuskEVM changes that by separating execution from settlement.
Execution where developers are, settlement where finance needs it
On Dusk, smart contracts run inside DuskEVM. This environment looks like Ethereum. It uses Solidity. It supports standard tooling. Wallets, libraries, and development workflows carry over.
But when those contracts execute, their results do not settle onto a fully transparent public ledger. They settle onto Dusk’s Layer 1, which is designed for confidentiality, identity, and auditability.
This means developers do not have to choose between programmability and compliance. They get both.
A trading protocol can run like a normal EVM app.
A lending platform can use standard Solidity logic.
A token can behave like ERC-20.
But the underlying data about who owns what, who traded what, and what positions exist can be shielded from the public while remaining provable to regulators and auditors.
This is the difference between experimental finance and real finance.
Compliant DeFi becomes possible
One of the biggest myths in crypto is that DeFi and regulation cannot coexist. In reality, what cannot coexist is regulation and full transparency.
DuskEVM allows DeFi protocols to exist in a way that looks familiar to users but behaves very differently under the hood. Balances can be private. Transfers can be confidential. Yet proofs of correctness and compliance can still be generated.
This allows things that were impossible before:
• Lending markets where positions are not visible to competitors
• Trading venues where order flow cannot be front-run
• Stablecoins and RWAs that respect data protection laws
• Funds that can prove solvency without exposing strategies
DuskEVM makes these applications programmable.
Tokenized real-world assets finally make sense
DuskTrade, built with NPEX, is bringing regulated European securities onchain. Stocks, funds, and other financial instruments are not like meme tokens. They require:
• Identity verification
• Ownership records
• Corporate actions
• Dividend distribution
• Regulatory reporting
DuskEVM allows all of this logic to be encoded in smart contracts, while Dusk’s base layer ensures that sensitive data is not exposed.
This is crucial.
On Ethereum, a tokenized stock would reveal every shareholder and every trade. That violates privacy and market integrity laws. On Dusk, those details can be kept confidential while still being legally enforceable.
This is what makes DuskTrade possible.
Hedger gives EVM something it never had
Hedger is Dusk’s privacy engine. It uses zero-knowledge proofs and homomorphic encryption to allow data to be hidden while still being verifiable.
When integrated with DuskEVM, Hedger allows smart contracts to operate on private data.
That means a contract can:
• Check if someone is allowed to trade
• Verify balances
• Enforce limits
• Trigger settlements
without revealing the underlying numbers to the public.
This is not privacy for criminals. It is privacy for institutions.
DuskEVM as a bridge between worlds
One of the most powerful things DuskEVM enables is interoperability between public crypto and regulated finance.
Assets can move between:
• Public DeFi environments
• Private, compliant financial systems
• Tokenized real-world asset platforms
All while being governed by smart contracts.
This allows hybrid markets where retail and institutional participants can coexist without exposing each other to risk.
Why developers should care
For developers, DuskEVM removes a major constraint. You no longer have to decide whether you are building something for crypto-native users or for institutions. You can build one application that serves both.
You can write Solidity.
You can use familiar tools.
But you get access to a settlement layer designed for finance.
That combination is rare.
The real shift
DuskEVM is not just another EVM chain. It is the first EVM that understands what finance actually requires.
Privacy is not optional.
Identity is not optional.
Auditability is not optional.
DuskEVM brings all of them into programmable money.
That is what it actually enables.

@Dusk #dusk $DUSK

For most of Web3’s history, storage has been treated as something separate from blockchains. We talk about execution, liquidity, rollups, and consensus, but data itself has usually lived somewhere else. IPFS, Arweave, Filecoin, centralized clouds, or hybrid solutions have been bolted onto blockchains to hold what chains could not or would not store. This split was tolerable when blockchains were mostly about moving tokens. It becomes fragile when blockchains start to represent real systems, identities, histories, and autonomous agents.
Walrus exists because this separation is no longer sustainable.
To understand why, it helps to look at what is actually changing in Web3. Blockchains are no longer just transactional ledgers. They are becoming coordination layers for AI agents, DAOs, games, on-chain identities, governance systems, and tokenized real-world assets. All of these systems depend on data that must be persistent, verifiable, and available far into the future. When that data is missing, corrupted, or selectively withheld, the system itself breaks.
Walrus is designed to make storage a first-class on-chain resource, not an afterthought. And Sui’s object-centric architecture is what makes that possible.
The problem with off-chain storage
In most blockchain architectures today, data lives in a precarious place. A smart contract might reference a file stored on IPFS. An NFT might point to metadata on Arweave. A DAO might rely on off-chain records for governance history. These systems work until they don’t.
The problem is not that these storage networks are bad. The problem is that they are not tightly coupled to the chain’s economic and security model. When a blockchain executes a transaction, it has strong guarantees about ordering, finality, and validity. When it references external storage, those guarantees evaporate. Nodes may go offline. Pinning may stop. Incentives may change. Data may disappear.
For applications that only care about pictures or documents, this is annoying. For applications that care about governance, identity, compliance, or AI agents, it is existential.
An AI agent that executes trades based on data must be sure that the data it reads is exactly what was written. A DAO that votes on proposals must be able to verify historical context. A protocol that settles disputes must be able to retrieve evidence. If storage is unreliable, everything built on top becomes brittle.
Walrus is not just another decentralized storage layer. It is an attempt to align storage with on-chain economics, consensus, and object ownership in a way that makes data part of the chain’s trust fabric.
Why Sui changes the storage equation
Sui is not a traditional account-based blockchain. It is built around objects. Every asset, NFT, or piece of state on Sui is an object with a unique ID, an owner, and a version history. Objects can be owned by accounts, shared by multiple users, or governed by smart contracts.
This matters because data, at its core, is also an object. A file has a size, a hash, an owner, and a lifecycle. On most chains, there is no native way to represent this. Storage exists in an abstract, off-chain world. On Sui, objects are the fundamental unit of reality.
Walrus uses this to turn storage into something that can be priced, owned, transferred, and verified on-chain.
When a user stores data in Walrus, they are not just uploading a file to a network. They are minting an object on Sui that represents the right to store that data. That object contains cryptographic commitments to the data, metadata about its size and availability, and economic parameters governing how long it will be stored.
Storage becomes something you can hold.
This is a profound shift. Instead of renting space from a service, you own a storage object that is enforced by the chain. The guarantees are no longer social or off-chain. They are economic and cryptographic.
From disk space to economic resource
Walrus turns storage space into a market.
Storage providers contribute disk space and bandwidth to the Walrus network. They are compensated for making data available and proving that they are storing it correctly. Users pay for storage in a way that is directly enforced by on-chain objects.
Because these objects live on Sui, they inherit all of Sui’s properties: fast finality, low latency, parallel execution, and verifiable ownership.
This creates something that did not exist before: storage that is as programmable as tokens.
A DAO can hold storage objects for its governance records. An AI agent can rely on storage objects to access historical data. A game can issue storage objects to players for persistent assets. A compliance-driven protocol can require certain data to be stored for regulatory reasons.
In all of these cases, storage is no longer an external dependency. It is part of the protocol.
Availability as a consensus property
One of the most subtle but important aspects of Walrus is that it treats data availability as something that must be enforced by the network, not assumed.
In most storage systems, you trust that data will be available because someone is being paid or incentivized to keep it. But that incentive is usually external to the blockchain’s own security. If it fails, the chain cannot do anything about it.
Walrus changes this by making availability provable.
Storage nodes must regularly produce cryptographic proofs that they are holding and serving the data they claim to store. These proofs are verified and anchored on Sui. If a node fails to provide proofs, it loses rewards or is slashed.
This creates a direct link between economic incentives and data availability. It is not enough to promise to store data. You must prove it, and the chain enforces that promise.
For applications that depend on data being there when it is needed, this is the difference between a hobbyist system and infrastructure.
Why this matters for AI agents
The rise of AI agents onchain is one of the biggest reasons Walrus exists.
An AI agent that manages funds, executes strategies, or coordinates workflows must be able to trust the data it reads. If that data can be changed, withheld, or selectively served, the agent becomes manipulable.
Traditional blockchains cannot solve this alone. They are good at tracking balances and transactions, but terrible at storing large datasets, models, or histories.
Walrus allows AI agents to treat data as something that is part of the chain’s state. A model’s parameters, a dataset, or an execution log can be stored as Walrus objects. Their integrity and availability are enforced by the same economic and cryptographic mechanisms that protect tokens.
This makes it possible to build agents that are not just autonomous, but verifiable.
Identity, governance, and memory
There is another dimension to this that is easy to miss: memory.
Blockchains are often described as immutable ledgers, but in practice they are terrible at remembering anything that does not fit into a transaction. Off-chain storage becomes a shadow memory that can be lost.
For identity systems, this is fatal. Credentials, attestations, and histories must persist. For governance, it is equally important. Votes, proposals, and context must be available long after the fact.
Walrus allows these systems to anchor their memory onchain.
Because storage objects are part of Sui’s state, they can be referenced, transferred, and governed like any other asset. A DAO can require that certain records be stored in Walrus as a condition of legitimacy. An identity system can use Walrus to ensure that credentials remain accessible.
Memory becomes enforceable.
Why Sui was the right coordination layer
Walrus could not exist on every blockchain.
Sui’s object-centric design, high throughput, and low latency make it uniquely suited to coordinate a large number of storage objects and proofs. Each storage object can be updated, transferred, or referenced without forcing the entire network to process everything serially.
This is critical for scaling.
A storage network may have millions of objects, each representing a piece of data. Sui’s ability to process these in parallel allows Walrus to operate at a scale that would choke traditional chains.
At the same time, Sui provides the finality and security needed to make storage commitments meaningful. When a Walrus object says data will be available for a certain period, that promise is anchored in Sui’s consensus.
Storage as composable infrastructure
The most exciting part of Walrus is not just that it stores data. It is that it makes storage composable.
Developers can build protocols that assume the existence of reliable, verifiable data. They do not need to invent their own storage layers or trust external services. They can use Walrus objects as building blocks.
This unlocks a new category of applications: ones where data, logic, and economics are tightly integrated.
Think of decentralized social networks where posts and histories cannot disappear. Think of compliance-driven financial products where records must be kept for years. Think of AI systems that need to audit their own decisions.
These are not speculative ideas. They are emerging requirements.
A different way to think about blockchains
Walrus forces us to rethink what a blockchain is.
It is not just a place to move tokens. It is a place to coordinate resources. Compute, liquidity, identity, and now storage all become things that can be owned, priced, and enforced by the network.
Sui provides the substrate. Walrus turns storage into something that lives on it.
This is why Walrus is not just a storage protocol. It is a piece of infrastructure that changes what on-chain systems can be built.
When storage becomes an on-chain resource, data stops being a liability and starts being a foundation.
And that is what the next generation of Web3 will be built on.

@Walrus 🦭/acc #walrus $WAL

For most of crypto’s history, data has lived in an awkward place. Tokens, balances, and transactions sit safely onchain, but the data that gives those things meaning lives somewhere else. NFT images are stored off-chain. Governance records sit on IPFS. AI models, game state, social graphs, and histories are scattered across external systems that blockchains do not truly control.
This worked when blockchains were just financial ledgers. It breaks the moment blockchains try to become coordination layers for real systems.
Walrus exists to close that gap.
At its core, Walrus is not a storage network. It is a way to turn data into something blockchains can actually reason about. On Sui, data is no longer just a file. It becomes an object, owned, priced, referenced, and enforced by smart contracts.
That single shift changes everything.
Why files don’t belong off-chain anymore
When a smart contract references a file stored off-chain, it is trusting something it cannot verify. The blockchain can confirm a payment happened, but it cannot confirm that the data still exists, has not been tampered with, or will be available tomorrow.
For simple applications, that might be fine. For AI agents, identity systems, financial records, or governance history, it is unacceptable. If data disappears, the contract becomes meaningless.
Walrus solves this by anchoring data directly into the onchain object model.
When data is uploaded to Walrus, it is represented as a storage object on Sui. That object contains cryptographic commitments to the data, information about size and availability, and the economic terms under which it must be stored. The data itself is held by Walrus storage nodes, but the right to that data and the obligation to serve it are enforced by the blockchain.
Data becomes something a smart contract can own.
From files to programmable assets
Because Walrus storage is represented as Sui objects, it becomes programmable.
A DAO can require that all proposals and votes be stored as Walrus objects.
An AI agent can only act on datasets that exist as verified storage objects.
A game can issue permanent in-game assets backed by guaranteed data.
A financial protocol can require records to be stored for regulatory reasons.
Instead of passing around file links, contracts pass around storage objects. Those objects can be transferred, locked, verified, or expired just like tokens.
This is the missing piece for truly autonomous systems.
Availability you can prove
The biggest weakness of decentralized storage has always been availability. You can prove data was uploaded, but you cannot always prove it is still there.
Walrus fixes this with cryptographic proofs of storage.
Nodes in the Walrus network must regularly prove to Sui that they are still holding and serving the data they claim to store. If they fail, they lose rewards or get slashed. Availability is no longer based on trust. It is enforced by the same economic rules that secure the blockchain.
For smart contracts, this means data is not just referenced. It is guaranteed.
Why Sui makes this possible
Sui’s object-centric design is what allows Walrus to exist. Objects on Sui can be independently owned, updated, and verified without forcing the entire chain to process everything. This makes it possible to manage millions of storage objects efficiently.
Each piece of data becomes a first-class citizen of the blockchain.
That is not just better storage. It is a new way to think about what blockchains are.
They are no longer just ledgers for money. They become ledgers for memory, identity, history, and intelligence.
Walrus is what turns data into something blockchains can actually understand.

@Walrus 🦭/acc #walrus $WAL