docs: clarify native Dusk and wallet extension

Author: HDauven

public/llms-full.txt

@@ -62,7 +62,7 @@ Relevant docs:
 Dusk has two main developer paths:
 
 - DuskEVM: Solidity, EVM tooling, EVM wallets, Ethereum-compatible infrastructure.
-- Native Dusk: Rust/WASM contracts through DuskVM for protocol-level assets, custom execution, privacy, or zero-knowledge capabilities close to the settlement layer.
+- Native Dusk: general-purpose Rust/WASM contracts through DuskVM for protocol-level assets, native transaction models, custom execution, market logic, privacy, or zero-knowledge capabilities close to the settlement layer.
 
 Relevant docs:
 
@@ -91,6 +91,7 @@ Relevant docs:
 - Deploy on DuskEVM: https://docs.dusk.network/developer/smart-contracts-dusk-evm/deploy-on-evm/
 - Smart Contracts on DuskDS: https://docs.dusk.network/developer/smart-contracts-duskds/
 - Dusk Connect: https://docs.dusk.network/developer/integrations/dusk-connect/
+- Dusk Wallet Extension: https://docs.dusk.network/developer/integrations/wallet-extension/
 - Transaction Lifecycle: https://docs.dusk.network/developer/integrations/tx-lifecycle/
 - HTTP API: https://docs.dusk.network/developer/integrations/http-api/
 - W3sper SDK: https://docs.dusk.network/developer/integrations/w3sper/

public/llms.txt

@@ -16,6 +16,7 @@
 - [Deploy on DuskEVM](https://docs.dusk.network/developer/smart-contracts-dusk-evm/deploy-on-evm/): deploy Solidity contracts on DuskEVM.
 - [Smart Contracts on DuskDS](https://docs.dusk.network/developer/smart-contracts-duskds/): write Rust/WASM contracts for native Dusk execution.
 - [Dusk Connect](https://docs.dusk.network/developer/integrations/dusk-connect/): integrate wallet discovery and account connection.
+- [Dusk Wallet Extension](https://docs.dusk.network/developer/integrations/wallet-extension/): integrate with the first-party browser wallet provider.
 - [Transaction Lifecycle](https://docs.dusk.network/developer/integrations/tx-lifecycle/): understand transaction flow.
 - [HTTP API](https://docs.dusk.network/developer/integrations/http-api/): integrate with Dusk APIs.
 - [W3sper SDK](https://docs.dusk.network/developer/integrations/w3sper/): SDK integration.

src/content/docs/developer/integrations/dusk-connect.md

@@ -42,6 +42,7 @@ The Dusk Connect SDK is developed in the Dusk Network GitHub organization:
 
 ## Read next
 
+- [Dusk Wallet Extension](/developer/integrations/wallet-extension)
 - [Web Wallet](/learn/web-wallet)
 - [Transaction Lifecycle](/developer/integrations/tx-lifecycle)
 - [W3sper SDK](/developer/integrations/w3sper)

src/content/docs/developer/integrations/wallet-extension.md

@@ -0,0 +1,89 @@
+---
+title: Dusk Wallet Extension
+description: Use the Dusk Wallet browser extension as a first-party wallet for Dusk applications.
+---
+
+The Dusk Wallet extension is the first-party browser wallet for Dusk. It gives users a self-custodial wallet in Chrome and Firefox, and gives applications a provider surface for connecting Dusk accounts.
+
+Use the extension when you need:
+
+- a browser wallet for Dusk accounts
+- public and shielded account flows
+- mainnet, testnet, devnet, or custom node support
+- dApp connection through Dusk provider discovery
+- a first-party wallet to test Dusk Connect integrations
+
+For users who only need a hosted browser wallet, see [Web Wallet](/learn/web-wallet). For terminal and operator workflows, see [Rusk Wallet](/learn/rusk-wallet).
+
+## How it fits with Dusk Connect
+
+Dusk Connect is the SDK layer for wallet discovery and account connection. The Dusk Wallet extension is one wallet provider that can be discovered through that flow.
+
+A typical dApp flow is:
+
+1. Use Dusk Connect or provider discovery to find available Dusk wallets.
+2. Let the user choose the Dusk Wallet extension.
+3. Request account access.
+4. Ask the wallet to approve account actions or transactions when needed.
+
+See [Dusk Connect](/developer/integrations/dusk-connect) for the SDK-level integration path.
+
+## Provider discovery
+
+The extension announces an EIP-1193-style provider through Dusk discovery events. Dusk is not an EVM chain, so wallet methods use Dusk-specific names.
+
+```js
+const providers = [];
+
+window.addEventListener("dusk:announceProvider", (event) => {
+  providers.push(event.detail);
+});
+
+window.dispatchEvent(new Event("dusk:requestProvider"));
+
+const dusk = providers[0]?.provider;
+const [account] = await dusk.request({ method: "dusk_requestAccounts" });
+
+dusk.on("accountsChanged", console.log);
+dusk.on("chainChanged", console.log);
+```
+
+For the canonical provider API, see the wallet repository:
+
+- <a href="https://github.com/dusk-network/wallet/blob/main/docs/provider-api.md" target="_blank" rel="noreferrer">Dusk Wallet provider API</a>
+
+## Install for development
+
+The extension builds Chrome and Firefox targets from the same repository.
+
+```bash
+git clone https://github.com/dusk-network/wallet
+cd wallet
+npm install
+```
+
+For Chrome:
+
+```bash
+npm run build:chrome
+```
+
+Then load `dist/` as an unpacked extension in `chrome://extensions` with Developer mode enabled.
+
+For Firefox:
+
+```bash
+npm run build:firefox
+```
+
+Then load `dist-firefox/` as a temporary add-on in `about:debugging`.
+
+## Repository
+
+- <a href="https://github.com/dusk-network/wallet" target="_blank" rel="noreferrer">dusk-network/wallet</a>
+
+## Read next
+
+- [Dusk Connect](/developer/integrations/dusk-connect)
+- [Transaction Lifecycle](/developer/integrations/tx-lifecycle)
+- [Web Wallet](/learn/web-wallet)

src/content/docs/developer/overview.mdx

@@ -10,10 +10,10 @@ Dusk has a **modular architecture** for regulated digital assets, privacy-aware
 - **DuskDS** – the Dusk L1: settlement, consensus, data availability, native transaction models, protocol contracts, and DuskVM.
 - **DuskEVM** – the EVM execution layer for Solidity applications and familiar EVM tooling.
 
-As a builder, choose the path based on what your product needs:
+As a builder, choose the path based on what your product needs and which tooling model you want:
 
 - use **DuskEVM** when your application benefits from Solidity, EVM tooling, existing wallets, and Ethereum-compatible infrastructure.
-- use **native Dusk** when your application needs protocol-level assets, custom execution, privacy, or zero-knowledge capabilities close to the settlement layer.
+- use **native Dusk** when your application should build directly on Dusk's own execution model, native transaction models, Rust/WASM contracts, protocol-level assets, privacy, or zero-knowledge capabilities.
 
 ## Choose your path
 
@@ -26,7 +26,7 @@ As a builder, choose the path based on what your product needs:
   <LinkCard
     title="Native Dusk smart contracts"
     href="/developer/smart-contracts-duskds"
-    description="Write Rust/WASM contracts directly on Dusk when your application needs native execution."
+    description="Write general-purpose Rust/WASM contracts directly on Dusk's native execution layer."
   />
   <LinkCard
     title="Integrate with DuskDS"
@@ -59,19 +59,24 @@ See: [Smart Contracts on DuskEVM](/developer/smart-contracts-dusk-evm/deploy-on-
 
 ## When to use native Dusk contracts
 
-Use native Dusk smart contracts when you need:
+Native Dusk smart contracts are general-purpose smart contracts for Dusk's own execution environment. They are written in Rust, compiled to WASM, and executed by DuskVM.
+
+Use this path when you need:
 
 - protocol-level control on the settlement layer
 - direct interaction with Dusk transaction models
 - specialized contracts that need Rust/WASM execution
 - privacy or zero-knowledge capabilities that should live close to the base protocol
+- application logic that benefits from native Dusk assets, transaction models, or execution primitives
 
 Typical examples include:
 
 - genesis or protocol contracts such as transfers and staking
 - low-level infrastructure contracts
 - applications that need direct access to DuskVM and native Dusk features
 
+Compared with DuskEVM, native Dusk contracts require more familiarity with Dusk-specific tooling and architecture. The tradeoff is deeper access to the protocol's own model rather than compatibility with the broader EVM ecosystem.
+
 If that’s you, start with:  
 [Smart Contracts on DuskDS](/developer/smart-contracts-duskds).
 

src/content/docs/developer/smart-contracts-duskds.md

@@ -5,10 +5,12 @@ description: Build Rust/WASM smart contracts on DuskDS using the Forge framework
 
 Dusk offers two paths for smart contract development:
 
-- **DuskDS** (this page) - Rust/WASM contracts on Dusk's native settlement layer with access to privacy features and the full power of Rust's ecosystem
+- **DuskDS** (this page) - general-purpose Rust/WASM contracts on Dusk's native execution layer, with access to native transaction models, privacy-aware flows, and the full power of Rust's ecosystem
 - **[DuskEVM](/developer/smart-contracts-dusk-evm/deploy-on-evm)** - An Optimism-based EVM application layer for Solidity/Vyper contracts using familiar tooling (Hardhat, Foundry)
 
-Choose DuskDS for native integration with Dusk's privacy and settlement features. Choose DuskEVM for rapid prototyping or when porting existing Solidity contracts.
+Choose DuskDS when you want to build directly with Dusk's native primitives: Rust/WASM execution, protocol-level assets, custom market logic, public and shielded transaction models, or privacy-aware compliance flows. Choose DuskEVM when you want Solidity, EVM wallets, and the broader Ethereum tooling ecosystem.
+
+Native Dusk contracts are not limited to privacy-specific use cases. They can support general application logic, but they require developers to work closer to Dusk's own account, asset, and execution model than an EVM application would.
 
 ## Quick Start
 

src/content/docs/learn/deep-dive/dusk-evm.md

@@ -7,7 +7,7 @@ DuskEVM is an EVM-equivalent execution environment built on the OP Stack that us
 
 Use DuskEVM when your application benefits from Solidity, Ethereum-compatible tooling, EVM wallets, and existing smart contract infrastructure.
 
-Use native Dusk development instead when your application needs Rust/WASM execution, direct access to native Dusk transaction models, or protocol-level privacy and zero-knowledge capabilities. For that path, see [DuskVM](/learn/deep-dive/dusk-vm/) and [Smart Contracts on DuskDS](/developer/smart-contracts-duskds/).
+Use native Dusk development instead when your application should be built directly against Dusk's own execution model: Rust/WASM contracts, native transaction models, protocol-level assets, custom market logic, or privacy and zero-knowledge capabilities. For that path, see [DuskVM](/learn/deep-dive/dusk-vm/) and [Smart Contracts on DuskDS](/developer/smart-contracts-duskds/).
 
 ## Where DuskEVM fits
 

src/content/docs/learn/deep-dive/dusk-vm.md

@@ -6,20 +6,20 @@ description: Learn about DuskVM, the Wasmtime-based VM that executes native smar
 
 ## Overview
 
-[DuskVM](https://github.com/dusk-network/rusk/tree/master/vm) is the WASM virtual machine for native smart contracts on Dusk. It is based on the <a href="https://wasmtime.dev" target="_blank" rel="noreferrer">Wasmtime</a> runtime, with custom support for Dusk’s execution model.
+[DuskVM](https://github.com/dusk-network/rusk/tree/master/vm) is the WASM virtual machine for native smart contracts on Dusk. It is based on the <a href="https://wasmtime.dev" target="_blank" rel="noreferrer">Wasmtime</a> runtime, with custom support for Dusk's execution model.
 
-Use DuskVM when your application needs native Dusk execution: protocol-level assets, Rust/WASM contracts, custom execution, privacy, or zero-knowledge capabilities close to the settlement layer.
+Use DuskVM when your application should run as a native Dusk contract: protocol-level assets, Rust/WASM contracts, custom execution, market logic, privacy-aware flows, or zero-knowledge capabilities close to the settlement layer.
 
-Use DuskEVM instead when your application is designed around Solidity, EVM wallets, and Ethereum-compatible tooling. See [DuskEVM](/learn/deep-dive/dusk-evm).
+Use DuskEVM instead when your application is designed around Solidity, EVM wallets, and Ethereum-compatible tooling. DuskVM is closer to Dusk's native model; DuskEVM is closer to the Ethereum developer ecosystem. See [DuskEVM](/learn/deep-dive/dusk-evm).
 
 ## Where DuskVM fits
 
-DuskVM is part of the DuskDS layer. It is the native execution environment for smart contracts that should live close to the Dusk L1 transaction models and settlement layer.
+DuskVM is part of the DuskDS layer. It is the native execution environment for general-purpose smart contracts that should live close to Dusk's transaction models and settlement layer.
 
 At a high level, DuskVM provides:
 
 - Specific memory management mechanism
-- Support for Dusk’s ABI
+- Support for Dusk's ABI
 - Support for inter-contract calls 
 
 DuskVM functions as the host-side interface, handling the execution environment and system-level operations.

src/sidebars/siteSidebar.js

@@ -63,6 +63,7 @@ const siteSidebar = [
           { label: "Stake Abstraction", link: "/learn/hyperstaking" },
           { label: "Digital Identity Protocol", link: "/developer/digital-identity/protocol" },
           { label: "Dusk Connect", link: "/developer/integrations/dusk-connect" },
+          { label: "Dusk Wallet Extension", link: "/developer/integrations/wallet-extension" },
         ],
       },
       {