midnight-mcp 0.1.2 → 0.1.4

package/dist/resources/content/docs-content.js

@@ -1,11 +1,19 @@
 /**
- * Embedded documentation content for offline access
- * Separated from docs.ts for better maintainability
+ * Embedded documentation content
+ *
+ * DESIGN PRINCIPLE: This file contains ONLY curated/unique content that:
+ * 1. Doesn't exist in official docs (wallet-integration guide we created)
+ * 2. Is a synthesized summary (tokenomics whitepaper)
+ * 3. Is a quick reference card (compact-reference, sdk-api)
+ * 4. Is from external sources (OpenZeppelin Compact contracts)
+ *
+ * For official Midnight docs (glossary, Zswap, Kachina concepts),
+ * use the search_docs tool which queries the Vector DB.
  */
 export const EMBEDDED_DOCS = {
-    "midnight://docs/compact-reference": `# Compact Language Reference
+    "midnight://docs/compact-reference": `# Compact Language Quick Reference
 
-Compact is a TypeScript-inspired language for writing privacy-preserving smart contracts on Midnight.
+A curated syntax reference for Compact - Midnight's smart contract language.
 
 ## Basic Structure
 
@@ -78,820 +86,647 @@ witness getCurrentPrice(): Field {
   return fetchPrice();
 }
 
-export circuit swap(amount: Field): Void {
+export circuit buyAtMarketPrice(maxPrice: Field): Void {
   const price = getCurrentPrice();
-  // Use price in circuit logic
+  assert(price <= maxPrice);
+  // ... execute purchase
 }
 \`\`\`
 
-## Built-in Functions
-
-### Cryptographic
-- \`hash(data)\` - Compute cryptographic hash
-- \`commit(value)\` - Create hiding commitment
-- \`disclose(private)\` - Reveal private data
+### Key Points:
+- Run locally, not on-chain
+- Can access external APIs, databases
+- Cannot modify ledger state directly
+- Results are private unless disclosed
 
-### State Operations
-- \`Counter.increment(n)\` - Add to counter
-- \`Counter.decrement(n)\` - Subtract from counter
-- \`Counter.value()\` - Read current value
-- \`Map.insert(k, v)\` - Add key-value
-- \`Map.get(k)\` - Retrieve value
-- \`Set.add(v)\` - Add to set
-- \`Set.contains(v)\` - Check membership
+## State Management
 
-## Privacy Annotations
+### Public State
+\`\`\`compact
+ledger {
+  publicCounter: Counter;
+  publicMap: Map<Field, Field>;
+}
+\`\`\`
 
+### Private State
 \`\`\`compact
 ledger {
-  publicData: Field;      // Visible on-chain
   @private
-  privateData: Field;     // Only owner sees
+  secretBalance: Field;
+  
+  @private
+  hiddenVotes: Map<Address, Field>;
+}
+\`\`\`
+
+## Common Patterns
+
+### Access Control
+\`\`\`compact
+ledger {
+  owner: Opaque<"address">;
+}
+
+witness getCaller(): Opaque<"address"> {
+  return context.caller;
+}
+
+export circuit ownerOnly(): Void {
+  assert(getCaller() == ledger.owner, "Not owner");
 }
 \`\`\`
+
+### Disclosure
+\`\`\`compact
+export circuit revealSecret(): Field {
+  const secret = getPrivateData();
+  return disclose(secret); // Makes private data public
+}
+\`\`\`
+
+### Assertions
+\`\`\`compact
+assert(condition);                    // Basic assertion
+assert(condition, "Error message");   // With message
+\`\`\`
 `,
-    "midnight://docs/sdk-api": `# Midnight TypeScript SDK API
+    "midnight://docs/sdk-api": `# Midnight TypeScript SDK Quick Reference
 
 ## Installation
 
 \`\`\`bash
-npm install @midnight-ntwrk/midnight-js-contracts @midnight-ntwrk/midnight-js-types
+npm install @midnight-ntwrk/midnight-js-contracts
 \`\`\`
 
-## Core Packages
+## Core Types
 
-### @midnight-ntwrk/midnight-js-contracts
-Contract interaction layer for deploying and calling Midnight smart contracts.
+### Contract Deployment
 
 \`\`\`typescript
-import { Contract, DeployedContract } from '@midnight-ntwrk/midnight-js-contracts';
+import { deployContract, ContractDeployment } from '@midnight-ntwrk/midnight-js-contracts';
 
-// Deploy a contract
-const deployed = await Contract.deploy(
-  wallet,
-  contractArtifact,
-  initialState
-);
+const deployment: ContractDeployment = await deployContract({
+  contract: compiledContract,
+  privateState: initialPrivateState,
+  args: constructorArgs,
+});
 
-// Call a circuit
-const result = await deployed.call('increment', { amount: 1n });
+const { contractAddress, initialState } = deployment;
 \`\`\`
 
-### @midnight-ntwrk/midnight-js-types
-Shared types and interfaces for the SDK.
+### Contract Interaction
 
 \`\`\`typescript
-import type { 
-  Address,
-  Transaction,
-  Proof,
-  ContractState 
-} from '@midnight-ntwrk/midnight-js-types';
-\`\`\`
+import { callContract } from '@midnight-ntwrk/midnight-js-contracts';
 
-### @midnight-ntwrk/wallet-api
-Wallet integration interface.
-
-\`\`\`typescript
-import { WalletAPI } from '@midnight-ntwrk/wallet-api';
+// Call a circuit
+const result = await callContract({
+  contractAddress,
+  circuitName: 'increment',
+  args: [amount],
+  privateState: currentPrivateState,
+});
 
-const wallet = await WalletAPI.connect();
-const address = await wallet.getAddress();
-const balance = await wallet.getBalance();
+// Result contains new state and return value
+const { newPrivateState, returnValue, proof } = result;
 \`\`\`
 
-## Common Patterns
+### Providers
 
-### Contract Deployment
 \`\`\`typescript
-import { Contract } from '@midnight-ntwrk/midnight-js-contracts';
-import counterContract from './counter.json';
-
-async function deployCounter() {
-  const deployed = await Contract.deploy(
-    wallet,
-    counterContract,
-    { counter: 0n }
-  );
-  
-  console.log('Deployed at:', deployed.address);
-  return deployed;
-}
-\`\`\`
+import { 
+  MidnightProvider,
+  createMidnightProvider 
+} from '@midnight-ntwrk/midnight-js-contracts';
 
-### Calling Circuits
-\`\`\`typescript
-async function increment(contract: DeployedContract, amount: bigint) {
-  const tx = await contract.call('increment', { amount });
-  await tx.wait();
-  
-  const newValue = await contract.query('counter');
-  return newValue;
-}
+const provider = await createMidnightProvider({
+  indexer: 'https://indexer.testnet.midnight.network',
+  node: 'https://node.testnet.midnight.network',
+  proofServer: 'https://prover.testnet.midnight.network',
+});
 \`\`\`
 
-### Querying State
+## State Management
+
 \`\`\`typescript
-async function getState(contract: DeployedContract) {
-  const publicState = await contract.query('publicField');
-  // Note: Private state requires witness functions
-  return publicState;
+interface ContractState<T> {
+  publicState: PublicState;
+  privateState: T;
 }
-\`\`\`
-`,
-    "midnight://docs/concepts/zero-knowledge": `# Zero-Knowledge Proofs in Midnight
-
-## What are Zero-Knowledge Proofs?
 
-Zero-knowledge proofs (ZKPs) allow one party (the prover) to convince another party (the verifier) that a statement is true, without revealing any information beyond the validity of the statement.
-
-## How Midnight Uses ZKPs
+// Subscribe to state changes
+provider.subscribeToContract(contractAddress, (state) => {
+  console.log('New state:', state);
+});
+\`\`\`
 
-In Midnight, every circuit execution generates a zero-knowledge proof:
+## Transaction Building
 
-1. **User calls a circuit** with private inputs
-2. **Proof is generated** off-chain
-3. **Only the proof** (not the inputs) is submitted to the blockchain
-4. **Validators verify** the proof without knowing the inputs
+\`\`\`typescript
+import { buildTransaction } from '@midnight-ntwrk/midnight-js-contracts';
 
-## Example
+const tx = await buildTransaction({
+  contractAddress,
+  circuitName: 'transfer',
+  args: [recipient, amount],
+  privateState,
+});
 
-\`\`\`compact
-export circuit proveAge(birthYear: Field): Boolean {
-  const currentYear = 2024;
-  const age = currentYear - birthYear;
-  
-  // Proves user is over 18 without revealing exact age
-  assert(age >= 18);
-  return true;
-}
+// Sign and submit
+const signedTx = await wallet.signTransaction(tx);
+const txHash = await provider.submitTransaction(signedTx);
 \`\`\`
 
-When this circuit runs:
-- Input: \`birthYear = 1990\` (private)
-- Output: \`true\` (public)
-- Proof: "I know a birthYear that makes age >= 18" (public)
-
-The verifier learns the user is over 18, but not their actual birth year.
-
-## Key Properties
+## Error Handling
 
-1. **Completeness**: Valid proofs always verify
-2. **Soundness**: Invalid proofs cannot be forged
-3. **Zero-knowledge**: Nothing beyond validity is revealed
-
-## Privacy Patterns
+\`\`\`typescript
+import { MidnightError, ContractError } from '@midnight-ntwrk/midnight-js-contracts';
 
-### Selective Disclosure
-\`\`\`compact
-export circuit verifyCredential(
-  @private credential: Credential
-): Field {
-  // Prove credential is valid
-  assert(credential.isValid());
-  
-  // Only reveal specific fields
-  return disclose(credential.issuer);
-}
-\`\`\`
-
-### Hidden Computation
-\`\`\`compact
-export circuit secretBid(
-  @private amount: Field,
-  commitment: Field
-): Void {
-  // Prove bid matches commitment without revealing amount
-  assert(commit(amount) == commitment);
+try {
+  await callContract({ ... });
+} catch (error) {
+  if (error instanceof ContractError) {
+    console.error('Contract assertion failed:', error.message);
+  } else if (error instanceof MidnightError) {
+    console.error('Network error:', error.code);
+  }
 }
 \`\`\`
 `,
-    "midnight://docs/concepts/shielded-state": `# Shielded vs Unshielded State
+    "midnight://docs/openzeppelin": `# OpenZeppelin Contracts for Compact
 
-Midnight supports two types of state: shielded (private) and unshielded (public).
+> **Official Documentation**: https://docs.openzeppelin.com/contracts-compact
+> **GitHub Repository**: https://github.com/OpenZeppelin/compact-contracts
 
-## Unshielded State
+The official OpenZeppelin library for Midnight smart contracts provides battle-tested, audited implementations of common patterns.
 
-Public state visible to everyone on the blockchain:
+## Installation
 
-\`\`\`compact
-ledger {
-  totalSupply: Counter;          // Public counter
-  balances: Map<Address, Field>; // Public mapping
-}
+\`\`\`bash
+npm install @openzeppelin/compact-contracts
 \`\`\`
 
-**Use for:**
-- Token total supply
-- Public voting tallies
-- Any data that should be transparent
-
-## Shielded State
-
-Private state only visible to the owner:
+## Available Modules
 
-\`\`\`compact
-ledger {
-  @private
-  secretKey: Bytes<32>;
-  
-  @private
-  privateBalance: Field;
-}
-\`\`\`
+### Token Standards
+- **FungibleToken** - Privacy-preserving token with shielded balances
+- **NFT** - Non-fungible tokens with optional privacy
 
-**Use for:**
-- User credentials
-- Private balances
-- Sensitive personal data
+### Access Control
+- **Ownable** - Single-owner access pattern
+- **Roles** - Role-based access control
+- **AccessControl** - Flexible permission system
 
-## Hybrid Approach
+### Security
+- **Pausable** - Emergency stop mechanism
+- **ReentrancyGuard** - Prevent reentrancy attacks
 
-Most contracts use both:
+## Usage Example
 
 \`\`\`compact
+include "std";
+include "@openzeppelin/compact-contracts/token/FungibleToken.compact";
+include "@openzeppelin/compact-contracts/access/Ownable.compact";
+
 ledger {
-  // Public: anyone can see total messages
-  messageCount: Counter;
-  
-  // Private: only owner sees message contents
-  @private
-  messages: Map<Field, Opaque<"string">>;
+  // Inherit from OpenZeppelin contracts
+  ...FungibleToken.ledger;
+  ...Ownable.ledger;
 }
 
-export circuit postMessage(content: Opaque<"string">): Void {
-  const id = ledger.messageCount.value();
-  
-  // Public increment
-  ledger.messageCount.increment(1);
-  
-  // Private storage
-  ledger.messages.insert(id, content);
+export circuit mint(to: Address, amount: Field): Void {
+  Ownable.assertOnlyOwner();
+  FungibleToken.mint(to, amount);
 }
 \`\`\`
 
-## Transitioning Between States
-
-### Disclose: Private → Public
-\`\`\`compact
-export circuit revealBalance(): Field {
-  // Reveal private balance publicly
-  return disclose(ledger.privateBalance);
-}
-\`\`\`
+## Best Practices
 
-### Commit: Public → Hidden
-\`\`\`compact
-export circuit hideValue(value: Field): Field {
-  // Create commitment (hides value but proves existence)
-  return commit(value);
-}
-\`\`\`
+1. **Always use audited contracts** - Don't reinvent token standards
+2. **Combine patterns** - Ownable + FungibleToken + Pausable
+3. **Check for updates** - Security patches are released regularly
+4. **Read the docs** - Each module has specific usage patterns
 `,
-    "midnight://docs/concepts/witnesses": `# Witness Functions
-
-Witnesses provide off-chain data to circuits in Midnight.
+    "midnight://docs/openzeppelin/token": `# OpenZeppelin FungibleToken
 
-## Why Witnesses?
+The recommended standard for privacy-preserving tokens on Midnight.
 
-Circuits run in a ZK environment with limitations:
-- Cannot make network requests
-- Cannot access system time
-- Cannot read external files
-- Must be deterministic
+## Features
 
-Witnesses bridge this gap by running off-chain.
+- Shielded balances (private by default)
+- Optional public balance disclosure
+- Transfer with ZK proofs
+- Mint/burn capabilities
 
-## Basic Witness
+## Basic Usage
 
 \`\`\`compact
-// Runs off-chain, provides data to circuits
-witness getTimestamp(): Field {
-  return getCurrentUnixTime();
-}
+include "std";
+include "@openzeppelin/compact-contracts/token/FungibleToken.compact";
 
-export circuit timedAction(): Void {
-  const timestamp = getTimestamp();
-  assert(timestamp > ledger.deadline);
-  // ... perform action
+ledger {
+  ...FungibleToken.ledger;
+  name: Opaque<"string">;
+  symbol: Opaque<"string">;
+  decimals: Uint<8>;
+}
+
+export circuit initialize(
+  name: Opaque<"string">,
+  symbol: Opaque<"string">,
+  decimals: Uint<8>,
+  initialSupply: Field,
+  owner: Address
+): Void {
+  ledger.name = name;
+  ledger.symbol = symbol;
+  ledger.decimals = decimals;
+  FungibleToken.mint(owner, initialSupply);
 }
-\`\`\`
 
-## Witness with Parameters
+// Shielded transfer
+export circuit transfer(to: Address, amount: Field): Void {
+  FungibleToken.transfer(to, amount);
+}
 
-\`\`\`compact
-witness fetchPrice(asset: Opaque<"string">): Field {
-  // Off-chain: call price oracle
-  return callPriceOracle(asset);
+// Check balance (private)
+witness myBalance(): Field {
+  return FungibleToken.balanceOf(context.caller);
 }
 
-export circuit swap(asset: Opaque<"string">, amount: Field): Void {
-  const price = fetchPrice(asset);
-  const total = amount * price;
-  // ... execute swap
+// Reveal balance publicly (optional)
+export circuit revealBalance(): Field {
+  return disclose(myBalance());
 }
 \`\`\`
 
-## Private Data Access
-
-Witnesses can access private ledger state:
+## Minting and Burning
 
 \`\`\`compact
+include "@openzeppelin/compact-contracts/access/Ownable.compact";
+
 ledger {
-  @private
-  secretNonce: Field;
+  ...FungibleToken.ledger;
+  ...Ownable.ledger;
 }
 
-witness getNextNonce(): Field {
-  const current = ledger.secretNonce;
-  return current + 1;
+export circuit mint(to: Address, amount: Field): Void {
+  Ownable.assertOnlyOwner();
+  FungibleToken.mint(to, amount);
 }
 
-export circuit signedOperation(data: Field): Field {
-  const nonce = getNextNonce();
-  return hash(data, nonce);
+export circuit burn(amount: Field): Void {
+  FungibleToken.burn(context.caller, amount);
 }
 \`\`\`
 
-## Best Practices
-
-1. **Keep witnesses simple** - Complex logic should be in circuits
-2. **Handle failures gracefully** - Witnesses can fail
-3. **Don't trust witness data blindly** - Validate in circuits
-4. **Cache when possible** - Reduce off-chain calls
+## Privacy Model
 
-## Security Considerations
+| Operation | Privacy |
+|-----------|---------|
+| Balance | Shielded (private) |
+| Transfer amount | Shielded |
+| Sender | Shielded |
+| Recipient | Shielded |
+| Transaction occurred | Public (proof exists) |
 
-⚠️ Witnesses are NOT proven in ZK:
-- Circuit verifies witness output is used correctly
-- But doesn't verify HOW witness computed the value
-- Malicious witnesses can provide false data
+## Important Notes
 
-Always add assertions to validate witness data:
-
-\`\`\`compact
-export circuit usePrice(asset: Opaque<"string">): Void {
-  const price = fetchPrice(asset);
-  
-  // Validate witness data
-  assert(price > 0);
-  assert(price < MAX_REASONABLE_PRICE);
-  
-  // ... use price
-}
-\`\`\`
+1. **No approval mechanism** - Unlike ERC20, transfers are direct
+2. **Balances are commitments** - Not stored as plain values
+3. **Privacy by default** - Explicit disclosure required to reveal
 `,
-    "midnight://docs/concepts/kachina": `# Kachina Protocol
-
-Kachina is the cryptographic protocol underlying Midnight's privacy features.
-
-## Overview
-
-Kachina enables:
-- Private smart contracts with public verifiability
-- Composable privacy across contracts
-- Efficient on-chain verification
+    "midnight://docs/openzeppelin/access": `# OpenZeppelin Access Control
 
-## Architecture
+Patterns for controlling who can call contract functions.
 
-\`\`\`
-┌─────────────────┐     ┌─────────────────┐
-│   User Wallet   │────▶│  Compact Code   │
-└─────────────────┘     └────────┬────────┘
-                                 │
-                        ┌────────▼────────┐
-                        │   ZK Circuit    │
-                        │   (Prover)      │
-                        └────────┬────────┘
-                                 │
-                        ┌────────▼────────┐
-                        │     Proof       │
-                        └────────┬────────┘
-                                 │
-                        ┌────────▼────────┐
-                        │   Midnight      │
-                        │   Validators    │
-                        └─────────────────┘
-\`\`\`
+## Ownable
 
-## Key Concepts
+Simple single-owner access control.
 
-### State Model
-- **Public State**: Stored on-chain, visible to all
-- **Private State**: Stored off-chain, encrypted
-- **Commitments**: On-chain references to private state
+\`\`\`compact
+include "@openzeppelin/compact-contracts/access/Ownable.compact";
 
-### Transaction Flow
-1. User prepares transaction locally
-2. Prover generates ZK proof
-3. Transaction + proof submitted to network
-4. Validators verify proof (not re-execute)
-5. State updates applied
+ledger {
+  ...Ownable.ledger;
+}
 
-### Composability
-Contracts can interact while preserving privacy:
+export circuit initialize(owner: Address): Void {
+  Ownable.initialize(owner);
+}
 
-\`\`\`compact
-// Contract A
-export circuit transferToken(to: Address, amount: Field): Void {
-  // Private transfer logic
+export circuit adminFunction(): Void {
+  Ownable.assertOnlyOwner();
+  // Only owner can execute this
 }
 
-// Contract B can call Contract A
-export circuit atomicSwap(
-  tokenA: Address,
-  tokenB: Address,
-  amountA: Field,
-  amountB: Field
-): Void {
-  // Both transfers happen atomically
-  // Privacy preserved for both
+export circuit transferOwnership(newOwner: Address): Void {
+  Ownable.assertOnlyOwner();
+  Ownable.transferOwnership(newOwner);
 }
 \`\`\`
 
-## Benefits
+## Role-Based Access Control
 
-1. **Privacy by Default**: All computation is private unless explicitly disclosed
-2. **Scalability**: Verification is faster than re-execution
-3. **Flexibility**: Developers choose what to reveal
-4. **Interoperability**: Works with existing blockchain infrastructure
-`,
-    "midnight://docs/openzeppelin": `# OpenZeppelin Contracts for Compact
+For more complex permission systems.
 
-> **Official Documentation**: https://docs.openzeppelin.com/contracts-compact
-> **GitHub Repository**: https://github.com/OpenZeppelin/compact-contracts
+\`\`\`compact
+include "@openzeppelin/compact-contracts/access/AccessControl.compact";
 
-OpenZeppelin Contracts for Compact is the **official and recommended** library for building secure smart contracts on Midnight. This library provides audited, battle-tested modules for common patterns.
+ledger {
+  ...AccessControl.ledger;
+}
 
-## Installation
+const ADMIN_ROLE: Bytes<32> = keccak256("ADMIN_ROLE");
+const MINTER_ROLE: Bytes<32> = keccak256("MINTER_ROLE");
 
-\`\`\`bash
-# Create project directory
-mkdir my-project && cd my-project
+export circuit initialize(admin: Address): Void {
+  AccessControl.grantRole(ADMIN_ROLE, admin);
+  AccessControl.setRoleAdmin(MINTER_ROLE, ADMIN_ROLE);
+}
 
-# Initialize git and add as submodule
-git init && git submodule add https://github.com/OpenZeppelin/compact-contracts.git
+export circuit mint(to: Address, amount: Field): Void {
+  AccessControl.assertHasRole(MINTER_ROLE);
+  // Mint tokens
+}
 
-# Install dependencies
-cd compact-contracts
-nvm install && yarn && SKIP_ZK=true yarn compact
+export circuit grantMinterRole(account: Address): Void {
+  AccessControl.assertHasRole(ADMIN_ROLE);
+  AccessControl.grantRole(MINTER_ROLE, account);
+}
 \`\`\`
 
-## Available Modules
-
-### Token
-- **FungibleToken**: Standard token implementation with transfer, mint, burn
-- Recommended for all token contracts on Midnight
-
-### Access Control
-- **Ownable**: Single owner access control
-- **AccessControl**: Role-based access control
-
-### Security
-- **Pausable**: Emergency stop mechanism
-
-## Usage Example
+## Combining Patterns
 
 \`\`\`compact
-pragma language_version >= 0.16.0;
+include "@openzeppelin/compact-contracts/access/Ownable.compact";
+include "@openzeppelin/compact-contracts/security/Pausable.compact";
 
-import CompactStandardLibrary;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/Ownable" prefix Ownable_;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/security/Pausable" prefix Pausable_;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/token/FungibleToken" prefix FungibleToken_;
-
-constructor(
-  _name: Opaque<"string">,
-  _symbol: Opaque<"string">,
-  _decimals: Uint<8>,
-  _recipient: Either<ZswapCoinPublicKey, ContractAddress>,
-  _amount: Uint<128>,
-  _initOwner: Either<ZswapCoinPublicKey, ContractAddress>,
-) {
-  Ownable_initialize(_initOwner);
-  FungibleToken_initialize(_name, _symbol, _decimals);
-  FungibleToken__mint(_recipient, _amount);
-}
-
-export circuit transfer(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  value: Uint<128>,
-): Boolean {
-  Pausable_assertNotPaused();
-  return FungibleToken_transfer(to, value);
+ledger {
+  ...Ownable.ledger;
+  ...Pausable.ledger;
 }
 
-export circuit pause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__pause();
+export circuit criticalFunction(): Void {
+  Ownable.assertOnlyOwner();
+  Pausable.assertNotPaused();
+  // Execute critical logic
 }
 
-export circuit unpause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__unpause();
+export circuit pause(): Void {
+  Ownable.assertOnlyOwner();
+  Pausable.pause();
 }
 \`\`\`
-
-## Compilation
-
-\`\`\`bash
-compact compile MyContract.compact artifacts/MyContract
-\`\`\`
-
-## Why Use OpenZeppelin?
-
-1. **Security Audited**: Contracts are professionally audited
-2. **Battle-Tested**: Used in production across the ecosystem
-3. **Official Recommendation**: Midnight's recommended library for tokens
-4. **Modularity**: Use only what you need
-5. **Best Practices**: Follows Compact language best practices
 `,
-    "midnight://docs/openzeppelin/token": `# OpenZeppelin FungibleToken
-
-> **This is the official and recommended token standard for Midnight.**
-
-The FungibleToken module provides a complete implementation for fungible tokens on Midnight.
+    "midnight://docs/openzeppelin/security": `# OpenZeppelin Security Patterns
 
-## Features
+Security utilities for Compact contracts.
 
-- ERC20-compatible interface
-- Transfer with balance tracking
-- Mint and burn operations
-- Approval and transferFrom patterns
-- Privacy-preserving by default
+## Pausable
 
-## Basic Usage
+Emergency stop mechanism for contracts.
 
 \`\`\`compact
-pragma language_version >= 0.16.0;
+include "@openzeppelin/compact-contracts/security/Pausable.compact";
+include "@openzeppelin/compact-contracts/access/Ownable.compact";
 
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/token/FungibleToken" prefix FungibleToken_;
-
-constructor(
-  _name: Opaque<"string">,
-  _symbol: Opaque<"string">,
-  _decimals: Uint<8>,
-  _recipient: Either<ZswapCoinPublicKey, ContractAddress>,
-  _initialSupply: Uint<128>,
-) {
-  FungibleToken_initialize(_name, _symbol, _decimals);
-  FungibleToken__mint(_recipient, _initialSupply);
+ledger {
+  ...Pausable.ledger;
+  ...Ownable.ledger;
 }
 
-// Transfer tokens
-export circuit transfer(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  value: Uint<128>,
-): Boolean {
-  return FungibleToken_transfer(to, value);
+export circuit transfer(to: Address, amount: Field): Void {
+  Pausable.assertNotPaused();
+  // Transfer logic
 }
 
-// Check balance (witness function for privacy)
-witness balanceOf(
-  account: Either<ZswapCoinPublicKey, ContractAddress>
-): Uint<128> {
-  return FungibleToken_balanceOf(account);
+export circuit pause(): Void {
+  Ownable.assertOnlyOwner();
+  Pausable.pause();
 }
 
-// Get total supply
-witness totalSupply(): Uint<128> {
-  return FungibleToken_totalSupply();
+export circuit unpause(): Void {
+  Ownable.assertOnlyOwner();
+  Pausable.unpause();
 }
 \`\`\`
 
-## Advanced: With Approval Pattern
+## When to Use Pausable
+
+- Token contracts handling real value
+- DeFi protocols with liquidity
+- Contracts with upgrade mechanisms
+- Any contract where bugs could cause fund loss
+
+## Implementation Details
 
 \`\`\`compact
-// Approve spender
-export circuit approve(
-  spender: Either<ZswapCoinPublicKey, ContractAddress>,
-  value: Uint<128>,
-): Boolean {
-  return FungibleToken_approve(spender, value);
+// Pausable module internals (simplified)
+ledger {
+  paused: Boolean;
 }
 
-// Transfer from approved account
-export circuit transferFrom(
-  from: Either<ZswapCoinPublicKey, ContractAddress>,
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  value: Uint<128>,
-): Boolean {
-  return FungibleToken_transferFrom(from, to, value);
+circuit Pausable_assertNotPaused(): Void {
+  assert(!ledger.paused, "Contract is paused");
 }
-\`\`\`
-
-## Mint and Burn (Owner-Only)
-
-\`\`\`compact
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/Ownable" prefix Ownable_;
 
-export circuit mint(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  amount: Uint<128>,
-): [] {
-  Ownable_assertOnlyOwner();
-  FungibleToken__mint(to, amount);
+circuit Pausable_pause(): Void {
+  ledger.paused = true;
 }
 
-export circuit burn(
-  from: Either<ZswapCoinPublicKey, ContractAddress>,
-  amount: Uint<128>,
-): [] {
-  Ownable_assertOnlyOwner();
-  FungibleToken__burn(from, amount);
+circuit Pausable_unpause(): Void {
+  ledger.paused = false;
 }
 \`\`\`
-`,
-    "midnight://docs/openzeppelin/access": `# OpenZeppelin Access Control
-
-Access control modules for managing permissions in your contracts.
 
-## Ownable
+## Best Practices
 
-Simple single-owner access control.
+1. **Always use Pausable** for contracts handling value
+2. **Combine with Ownable** for admin-only pause control
+3. **Test pause scenarios** thoroughly
+4. **Document pause conditions** for users
+5. **Consider timelock** for unpause in high-value contracts
+`,
+    "midnight://docs/tokenomics": `# Midnight Tokenomics Summary
 
-\`\`\`compact
-pragma language_version >= 0.16.0;
+A curated summary of the Midnight Tokenomics Whitepaper (June 2025).
 
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/Ownable" prefix Ownable_;
+## Dual-Token Model
 
-constructor(
-  _owner: Either<ZswapCoinPublicKey, ContractAddress>,
-) {
-  Ownable_initialize(_owner);
-}
+Midnight uses two components: **NIGHT** (token) and **DUST** (resource).
 
-// Only owner can call this
-export circuit adminFunction(): [] {
-  Ownable_assertOnlyOwner();
-  // ... admin logic
-}
+### NIGHT Token
+- **Supply**: 24 billion (fixed)
+- **Subunit**: 1 NIGHT = 1,000,000 STARs
+- **Visibility**: Unshielded (public)
+- **Function**: Generates DUST, governance, block rewards
+- **Multi-chain**: Native on both Cardano and Midnight
 
-// Transfer ownership
-export circuit transferOwnership(
-  newOwner: Either<ZswapCoinPublicKey, ContractAddress>,
-): [] {
-  Ownable_assertOnlyOwner();
-  Ownable_transferOwnership(newOwner);
-}
+### DUST Resource
+- **Type**: Shielded, non-transferable
+- **Function**: Pay transaction fees
+- **Generation**: Continuously from NIGHT holdings
+- **Decay**: When disassociated from NIGHT
+- **Privacy**: Transactions don't leak metadata
 
-// Renounce ownership (irreversible!)
-export circuit renounceOwnership(): [] {
-  Ownable_assertOnlyOwner();
-  Ownable_renounceOwnership();
-}
+## Key Insight: NIGHT Generates DUST
 
-// Check current owner
-witness owner(): Either<ZswapCoinPublicKey, ContractAddress> {
-  return Ownable_owner();
-}
+\`\`\`
+Hold NIGHT → Generates DUST → Pay for transactions
+         (continuous)      (consumed on use)
 \`\`\`
 
-## AccessControl (Role-Based)
+This means: **Hold NIGHT, transact "for free"** (no recurring token spend)
 
-For contracts needing multiple roles with different permissions.
+## Block Rewards
 
-\`\`\`compact
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/AccessControl" prefix AC_;
+**Formula**:
+\`\`\`
+Actual Reward = Base Reward × [S + (1-S) × U]
 
-// Define role identifiers
-const MINTER_ROLE: Bytes<32> = keccak256("MINTER_ROLE");
-const PAUSER_ROLE: Bytes<32> = keccak256("PAUSER_ROLE");
+Where:
+- S = Subsidy rate (95% at launch)
+- U = Block utilization (target: 50%)
+\`\`\`
 
-constructor(_admin: Either<ZswapCoinPublicKey, ContractAddress>) {
-  AC_initialize(_admin);
-  AC__grantRole(MINTER_ROLE, _admin);
-  AC__grantRole(PAUSER_ROLE, _admin);
-}
+- Full blocks: Producer gets 100% of base reward
+- Empty blocks: Producer gets only subsidy (95%)
+- Remainder goes to Treasury
 
-// Only minters can call
-export circuit mint(to: Address, amount: Uint<128>): [] {
-  AC_assertOnlyRole(MINTER_ROLE);
-  // ... mint logic
-}
+## Token Distribution
 
-// Only pausers can call
-export circuit pause(): [] {
-  AC_assertOnlyRole(PAUSER_ROLE);
-  // ... pause logic
-}
+### Phase 1: Glacier Drop (60 days)
+- Free allocation to crypto holders
+- 50% to Cardano, 20% to Bitcoin, 30% to others
+- Minimum $100 USD equivalent required
 
-// Grant role (admin only)
-export circuit grantRole(
-  role: Bytes<32>,
-  account: Either<ZswapCoinPublicKey, ContractAddress>,
-): [] {
-  AC_assertOnlyRole(AC_DEFAULT_ADMIN_ROLE());
-  AC__grantRole(role, account);
-}
-\`\`\`
-`,
-    "midnight://docs/openzeppelin/security": `# OpenZeppelin Security Patterns
+### Phase 2: Scavenger Mine (30 days)  
+- Computational puzzles (accessible to public)
+- Claims unclaimed Glacier Drop tokens
+- Seeds network constituents
 
-Security modules for protecting your contracts.
+### Phase 3: Lost-and-Found (4 years)
+- Second chance for Glacier Drop eligible
+- Fractional allocation
 
-## Pausable
+## Key Differentiators
 
-Emergency stop mechanism for your contract.
+1. **No token spend for transactions** - DUST is renewable
+2. **MEV resistant** - Shielded transactions
+3. **Cross-chain native** - Same token on Cardano + Midnight
+4. **Fair distribution** - Free, multi-phase, broad eligibility
+`,
+    "midnight://docs/wallet-integration": `# Midnight Wallet Integration Guide
 
-\`\`\`compact
-pragma language_version >= 0.16.0;
+A guide for integrating Midnight Lace wallet into your DApp.
 
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/security/Pausable" prefix Pausable_;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/Ownable" prefix Ownable_;
+## Browser Detection
 
-constructor(_owner: Either<ZswapCoinPublicKey, ContractAddress>) {
-  Ownable_initialize(_owner);
-  // Contract starts unpaused
+\`\`\`typescript
+declare global {
+  interface Window {
+    midnight?: {
+      mnLace?: MidnightProvider;
+    };
+  }
 }
 
-// Protected function - won't work when paused
-export circuit transfer(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  amount: Uint<128>,
-): Boolean {
-  Pausable_assertNotPaused();
-  // ... transfer logic
+function isWalletAvailable(): boolean {
+  return typeof window !== 'undefined' 
+    && window.midnight?.mnLace !== undefined;
 }
+\`\`\`
 
-// Owner can pause
-export circuit pause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__pause();
-}
+## DApp Connector API
 
-// Owner can unpause
-export circuit unpause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__unpause();
+\`\`\`typescript
+interface DAppConnectorAPI {
+  enable(): Promise<MidnightAPI>;
+  isEnabled(): Promise<boolean>;
+  apiVersion(): string;
+  name(): string;
+  icon(): string;
 }
 
-// Check if paused
-witness isPaused(): Boolean {
-  return Pausable_paused();
+async function connectWallet(): Promise<MidnightAPI> {
+  if (!window.midnight?.mnLace) {
+    throw new Error('Midnight Lace wallet not found');
+  }
+  return await window.midnight.mnLace.enable();
 }
 \`\`\`
 
-## Combined Example: Secure Token
-
-\`\`\`compact
-pragma language_version >= 0.16.0;
-
-import CompactStandardLibrary;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/access/Ownable" prefix Ownable_;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/security/Pausable" prefix Pausable_;
-import "./compact-contracts/node_modules/@openzeppelin-compact/contracts/src/token/FungibleToken" prefix FungibleToken_;
+## MidnightAPI Interface
 
-constructor(
-  _name: Opaque<"string">,
-  _symbol: Opaque<"string">,
-  _decimals: Uint<8>,
-  _initialSupply: Uint<128>,
-  _owner: Either<ZswapCoinPublicKey, ContractAddress>,
-) {
-  Ownable_initialize(_owner);
-  FungibleToken_initialize(_name, _symbol, _decimals);
-  FungibleToken__mint(_owner, _initialSupply);
-}
-
-// Pausable transfer
-export circuit transfer(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  value: Uint<128>,
-): Boolean {
-  Pausable_assertNotPaused();
-  return FungibleToken_transfer(to, value);
-}
-
-// Owner-only mint
-export circuit mint(
-  to: Either<ZswapCoinPublicKey, ContractAddress>,
-  amount: Uint<128>,
-): [] {
-  Ownable_assertOnlyOwner();
-  Pausable_assertNotPaused();
-  FungibleToken__mint(to, amount);
+\`\`\`typescript
+interface MidnightAPI {
+  getUsedAddresses(): Promise<string[]>;
+  getBalance(): Promise<Balance>;
+  signTx(tx: Transaction): Promise<SignedTransaction>;
+  submitTx(signedTx: SignedTransaction): Promise<TxHash>;
+  signData(address: string, payload: string): Promise<Signature>;
 }
+\`\`\`
 
-// Emergency pause
-export circuit pause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__pause();
-}
+## React Hook
 
-export circuit unpause(): [] {
-  Ownable_assertOnlyOwner();
-  Pausable__unpause();
-}
+\`\`\`typescript
+export function useWallet() {
+  const [state, setState] = useState({
+    isConnected: false,
+    address: null as string | null,
+    isLoading: false,
+    error: null as string | null,
+  });
+
+  const connect = useCallback(async () => {
+    setState(prev => ({ ...prev, isLoading: true, error: null }));
+    try {
+      if (!window.midnight?.mnLace) {
+        throw new Error('Please install Midnight Lace wallet');
+      }
+      const api = await window.midnight.mnLace.enable();
+      const addresses = await api.getUsedAddresses();
+      setState({
+        isConnected: true,
+        address: addresses[0] || null,
+        isLoading: false,
+        error: null,
+      });
+      return api;
+    } catch (error) {
+      setState(prev => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error.message : 'Failed',
+      }));
+      throw error;
+    }
+  }, []);
+
+  return { ...state, connect };
+}
+\`\`\`
+
+## Connection Flow
+
+\`\`\`
+1. User clicks "Connect Wallet"
+2. DApp calls window.midnight.mnLace.enable()
+3. Wallet popup asks user to approve
+4. User approves → DApp receives MidnightAPI
+5. DApp can now interact with wallet
 \`\`\`
 
 ## Best Practices
 
-1. **Always use Pausable** for contracts handling value
-2. **Combine with Ownable** for admin-only pause control
-3. **Test pause scenarios** thoroughly
-4. **Document pause conditions** for users
-5. **Consider timelock** for unpause in high-value contracts
+1. Always check wallet availability first
+2. Handle user rejection gracefully
+3. Store connection state in context
+4. Provide clear loading/error feedback
+5. Test with Midnight Lace extension
 `,
 };
 //# sourceMappingURL=docs-content.js.map