docs: add Dusk Connect integration path

Author: HDauven

public/llms-full.txt

@@ -13,7 +13,7 @@ Dusk should be understood as a stack:
 - DuskVM: the WASM execution environment for native Dusk smart contracts.
 - Rusk: the Rust node implementation that runs DuskDS.
 - Citadel: identity and access primitives for selective disclosure and regulated workflows.
-- Dusk Connect: wallet discovery and account connection for Dusk applications.
+- Dusk Connect: wallet-extension discovery, profile access, and user-approved transactions for browser dApps.
 - Dusk Trade: application-layer market infrastructure for tokenized financial assets.
 
 ## Key Concepts

public/llms.txt

@@ -18,7 +18,7 @@
 - [Native Dusk Overview](https://docs.dusk.network/developer/duskds/overview/): understand native Rust/WASM contract development.
 - [Native Dusk Quickstart](https://docs.dusk.network/developer/duskds/quickstart/): create, test, build, and deploy a native contract.
 - [Native Contract Reference](https://docs.dusk.network/developer/duskds/reference/): understand the native contract, ABI, state, event, and deployment model.
-- [Dusk Connect](https://docs.dusk.network/developer/integrations/dusk-connect/): integrate wallet discovery and account connection.
+- [Dusk Connect](https://docs.dusk.network/developer/integrations/dusk-connect/): discover wallet extensions, request profile access, and submit user-approved transactions from browser dApps.
 - [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.

src/content/docs/developer/duskds/overview.md

@@ -23,13 +23,14 @@ Both environments are general-purpose. The choice is primarily about the executi
 | [Forge](https://github.com/dusk-network/forge) | Scaffolds contracts and generates ABI exports, schemas, and data drivers from annotated Rust |
 | [DuskVM](/learn/deep-dive/dusk-vm/) | Executes contract WASM and persists contract state |
 | [Rusk Wallet](/learn/rusk-wallet/) | Signs and submits deployment and contract-call transactions |
+| [Dusk Connect](/developer/integrations/dusk-connect/) | Connects browser dApps to compatible Dusk wallet extensions for account access and transaction approval |
 | [W3sper](/developer/integrations/w3sper/) | Connects JavaScript applications to Dusk nodes and contract data drivers |
 
 A typical workflow is:
 
 1. Scaffold a contract with Forge.
 2. Implement and test it locally against DuskVM.
 3. Build and verify the contract and data-driver WASM artifacts.
-4. Deploy the contract and submit calls through Rusk Wallet or an SDK.
+4. Deploy the contract, then connect applications through Dusk Connect, W3sper, or the HTTP API.
 
 Start with the [native Dusk quickstart](/developer/duskds/quickstart/). Use the [contract reference](/developer/duskds/reference/) when you need the ABI, state, serialization, event, or deployment details.

src/content/docs/developer/duskds/quickstart.md

@@ -112,6 +112,6 @@ rusk-wallet --network testnet contract-call \
   --fn-args "${ARGS#0x}"
 ```
 
-`contract-call` submits a transaction and waits for inclusion. For read-only queries and application integration, use [W3sper](/developer/integrations/w3sper/) or the [Rusk HTTP API](/developer/integrations/http-api/).
+`contract-call` submits a transaction and waits for inclusion. In a browser dApp, use [Dusk Connect](/developer/integrations/dusk-connect/) to discover wallet extensions, request account access, and ask the selected wallet to approve transactions. Use [W3sper](/developer/integrations/w3sper/) or the [Rusk HTTP API](/developer/integrations/http-api/) for direct node queries and contract data-driver integration.
 
 Before building a production contract, read the [native contract reference](/developer/duskds/reference/).

src/content/docs/developer/duskds/reference.md

@@ -119,4 +119,5 @@ Both deployment and contract calls submitted as transactions consume gas, whethe
 - [DuskVM source](https://github.com/dusk-network/rusk/tree/master/vm)
 - [Dusk contract ABI](https://docs.rs/dusk-core/latest/dusk_core/abi/)
 - [Rusk Wallet](/learn/rusk-wallet/)
+- [Dusk Connect](/developer/integrations/dusk-connect/)
 - [W3sper SDK](/developer/integrations/w3sper/)

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

@@ -1,50 +1,63 @@
 ---
 title: Dusk Connect
-description: Integrate Dusk wallet discovery and account connection into applications.
+description: Connect Dusk applications to compatible wallet extensions with @dusk/connect.
 ---
 
-Dusk Connect is the wallet integration layer for Dusk applications. It gives dApps a consistent way to discover compatible wallets, request accounts, and build connection flows around Dusk accounts.
+Dusk Connect (`@dusk/connect`) is the wallet integration layer for browser dApps on Dusk. It discovers compatible wallet extensions, requests profile access, tracks the active wallet and network, and sends user-approved transactions through the selected wallet.
 
-Use Dusk Connect when your application needs to:
+The SDK is framework-agnostic, typed, and has no runtime dependencies. An optional modal and `<dusk-connect-button>` are available from `@dusk/connect/ui`.
 
-- detect compatible Dusk wallet providers
-- let users select a wallet
-- request account access
-- handle public and shielded account flows in a consistent UI
-- integrate with Dusk wallet software without hardcoding one provider
+## Install
 
-## Where it fits
+Dusk Connect is published on JSR:
+
+```bash
+npx jsr add @dusk/connect
+```
+
+For Deno:
 
-Dusk applications often need two kinds of integration:
+```bash
+deno add jsr:@dusk/connect
+```
 
-- **Network integration**: read chain data, submit transactions, and observe events.
-- **Wallet integration**: ask a user to connect an account and approve actions.
+## Connect a wallet
 
-Dusk Connect is for the wallet side. For network APIs and transaction flow, see [Transaction Lifecycle](/developer/integrations/tx-lifecycle), [HTTP API](/developer/integrations/http-api), and [W3sper SDK](/developer/integrations/w3sper).
+`createDuskWallet()` starts wallet discovery and exposes a reactive view of the connection:
 
-If you are testing against the first-party browser wallet, use the [Dusk Wallet Extension](/developer/integrations/wallet-extension) as one compatible provider.
+```js
+import { createDuskWallet } from "@dusk/connect";
 
-## Typical flow
+const wallet = createDuskWallet();
+await wallet.ready();
 
-A dApp integration usually follows this shape:
+if (wallet.state.availableProviders.length > 1 && !wallet.state.providerId) {
+  await wallet.selectProvider(wallet.state.availableProviders[0].uuid);
+}
 
-1. Discover available Dusk wallet providers.
-2. Show the user the compatible wallets.
-3. Request account access from the selected wallet.
-4. Store the active account and provider for the session.
-5. Ask the wallet to approve transactions or account actions when needed.
+const profiles = await wallet.connect();
+console.log(profiles[0]);
+```
+
+`wallet.connect()` opens the selected wallet's approval flow. The wallet state updates when the user changes profile, account access, or network. Use `wallet.subscribe()` to update application state reactively.
+
+## Where it fits
 
-The exact API depends on the version of Dusk Connect you integrate.
+Use Dusk Connect for user-facing wallet flows:
 
-## Repository
+- discover one or more compatible wallet extensions
+- let the user select a wallet and grant profile access
+- access public accounts and request shielded receive addresses
+- request message signatures and user-approved transactions
+- react to profile, authorization, and network changes
 
-The Dusk Connect SDK is developed in the Dusk Network GitHub organization:
+For a native smart-contract dApp, `createDuskApp()` adds read-only contract calls, data-driver loading, and prepared contract writes to the same wallet connection. Use [W3sper](/developer/integrations/w3sper/) or the [HTTP API](/developer/integrations/http-api/) when an application or backend needs direct node access without an injected wallet.
 
-- <a href="https://github.com/dusk-network/connect" target="_blank" rel="noreferrer">dusk-network/connect</a>
+The [Dusk Wallet Extension](/developer/integrations/wallet-extension/) is the first-party wallet provider for testing this flow. Dusk Connect uses the Dusk discovery protocol instead of hardcoding a particular extension.
 
-## Read next
+## Next steps
 
-- [Dusk Wallet Extension](/developer/integrations/wallet-extension)
-- [Web Wallet](/learn/web-wallet)
-- [Transaction Lifecycle](/developer/integrations/tx-lifecycle)
-- [W3sper SDK](/developer/integrations/w3sper)
+- [Dusk Connect repository and API reference](https://github.com/dusk-network/connect)
+- [Dusk Wallet Extension](/developer/integrations/wallet-extension/)
+- [Transaction Lifecycle](/developer/integrations/tx-lifecycle/)
+- [W3sper SDK](/developer/integrations/w3sper/)

src/content/docs/developer/integrations/w3sper.md

@@ -86,7 +86,7 @@ console.log(await counter.call.get_count());
 await network.disconnect();
 ```
 
-The driver for this example is the file produced at `target/data-driver/wasm32-unknown-unknown/release/dusk_counter.wasm`. Methods under `contract.call` are read-only; submitting contract transactions also requires a synced profile and `Bookkeeper`.
+The driver for this example is the file produced at `target/data-driver/wasm32-unknown-unknown/release/dusk_counter.wasm`. Methods under `contract.call` are read-only; submitting contract transactions directly through W3sper also requires a synced profile and `Bookkeeper`. For browser dApps where the user's wallet should approve the transaction, use [Dusk Connect](/developer/integrations/dusk-connect/).
 
 ## Query GraphQL
 

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

@@ -30,27 +30,19 @@ See [Dusk Connect](/developer/integrations/dusk-connect) for the SDK-level integ
 
 If you are building the application side, start with Dusk Connect. If you are testing or documenting the wallet-provider side, use this page together with the wallet provider API.
 
-## Provider discovery
+## Connect from a dApp
 
-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.
+Use `@dusk/connect` to discover the extension and request profile access. This also handles multiple compatible Dusk wallets without binding the application to this extension:
 
 ```js
-const providers = [];
+import { createDuskWallet } from "@dusk/connect";
 
-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);
+const wallet = createDuskWallet();
+await wallet.ready();
+const profiles = await wallet.connect();
 ```
 
-For the canonical provider API, see the wallet repository:
+See [Dusk Connect](/developer/integrations/dusk-connect/) for installation, provider selection, and application integration. The extension still exposes the lower-level Dusk provider API for wallet authors and specialized integrations:
 
 - <a href="https://github.com/dusk-network/wallet/blob/main/docs/provider-api.md" target="_blank" rel="noreferrer">Dusk Wallet provider API</a>
 

src/content/docs/developer/overview.mdx

@@ -29,9 +29,9 @@ As a builder, choose the path based on what your product needs and which tooling
     description="Write general-purpose Rust/WASM contracts directly on Dusk's native execution layer."
   />
   <LinkCard
-    title="Integrate with DuskDS"
-    href="/developer/integrations/tx-lifecycle"
-    description="Use HTTP APIs, W3sper, and events to integrate wallets, exchanges, and backends."
+    title="Integrate a Dusk dApp"
+    href="/developer/integrations/dusk-connect"
+    description="Connect wallet extensions with Dusk Connect, and use W3sper or HTTP APIs for direct network access."
   />
   <LinkCard
     title="Dusk Improvement Proposals"