diff --git a/components/connect-wallet.tsx b/components/connect-wallet.tsx
index 364b8f5..67cb2a8 100644
--- a/components/connect-wallet.tsx
+++ b/components/connect-wallet.tsx
@@ -6,10 +6,11 @@ import { Badge } from "@/components/ui/badge"
 import { Wallet, ChevronDown, AlertCircle, Shield } from "lucide-react"
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu"
 import { Alert, AlertDescription } from "@/components/ui/alert"
+import { DOMA_CHAIN_CONFIG } from "@/lib/doma-smart-contracts"
 
 interface ConnectWalletProps {
   isConnected: boolean
-  onConnect: (connected: boolean) => void
+  onConnect: (connected: boolean, address?: string) => void
 }
 
 declare global {
@@ -38,7 +39,7 @@ export function ConnectWallet({ isConnected, onConnect }: ConnectWalletProps) {
             const account = accounts[0]
             setAddress(formatAddress(account))
             setConnectedWallet("MetaMask")
-            onConnect(true)
+            onConnect(true, account)
             return
           }
         } catch (error) {
@@ -53,7 +54,7 @@ export function ConnectWallet({ isConnected, onConnect }: ConnectWalletProps) {
             const account = accounts[0]
             setAddress(formatAddress(account))
             setConnectedWallet("OKX Wallet")
-            onConnect(true)
+            onConnect(true, account)
             return
           }
         } catch (error) {
@@ -99,15 +100,32 @@ export function ConnectWallet({ isConnected, onConnect }: ConnectWalletProps) {
         const account = accounts[0]
         setAddress(formatAddress(account))
         setConnectedWallet("MetaMask")
-        onConnect(true)
+        onConnect(true, account)
 
         try {
           await window.ethereum.request({
             method: "wallet_switchEthereumChain",
-            params: [{ chainId: "0x1" }],
+            params: [{ chainId: DOMA_CHAIN_CONFIG.chainId }],
           })
         } catch (switchError: any) {
-          console.log("Network switch error:", switchError)
+          if (switchError?.code === 4902) {
+            try {
+              await window.ethereum.request({
+                method: "wallet_addEthereumChain",
+                params: [{
+                  chainId: DOMA_CHAIN_CONFIG.chainId,
+                  chainName: DOMA_CHAIN_CONFIG.chainName,
+                  nativeCurrency: DOMA_CHAIN_CONFIG.nativeCurrency,
+                  rpcUrls: DOMA_CHAIN_CONFIG.rpcUrls,
+                  blockExplorerUrls: DOMA_CHAIN_CONFIG.blockExplorerUrls,
+                }],
+              })
+            } catch (addErr) {
+              console.log("Add chain failed:", addErr)
+            }
+          } else {
+            console.log("Network switch error:", switchError)
+          }
         }
       }
     } catch (error: any) {
@@ -141,15 +159,32 @@ export function ConnectWallet({ isConnected, onConnect }: ConnectWalletProps) {
         const account = accounts[0]
         setAddress(formatAddress(account))
         setConnectedWallet("OKX Wallet")
-        onConnect(true)
+        onConnect(true, account)
 
         try {
           await window.okxwallet.request({
             method: "wallet_switchEthereumChain",
-            params: [{ chainId: "0x1" }],
+            params: [{ chainId: DOMA_CHAIN_CONFIG.chainId }],
           })
         } catch (switchError: any) {
-          console.log("Network switch error:", switchError)
+          if (switchError?.code === 4902) {
+            try {
+              await window.okxwallet.request({
+                method: "wallet_addEthereumChain",
+                params: [{
+                  chainId: DOMA_CHAIN_CONFIG.chainId,
+                  chainName: DOMA_CHAIN_CONFIG.chainName,
+                  nativeCurrency: DOMA_CHAIN_CONFIG.nativeCurrency,
+                  rpcUrls: DOMA_CHAIN_CONFIG.rpcUrls,
+                  blockExplorerUrls: DOMA_CHAIN_CONFIG.blockExplorerUrls,
+                }],
+              })
+            } catch (addErr) {
+              console.log("Add chain failed:", addErr)
+            }
+          } else {
+            console.log("Network switch error:", switchError)
+          }
         }
       }
     } catch (error: any) {
diff --git a/components/doma-analytics.tsx b/components/doma-analytics.tsx
index 8afdbdc..3a47f63 100644
--- a/components/doma-analytics.tsx
+++ b/components/doma-analytics.tsx
@@ -29,7 +29,7 @@ import {
   Clock,
   Shield
 } from "lucide-react"
-import { LineChart, Line, AreaChart, Area, BarChart, Bar, PieChart as RechartsPieChart, Cell, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts'
+import { LineChart, Line, AreaChart, Area, BarChart, Bar, Pie, PieChart as RechartsPieChart, Cell, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts'
 
 interface AnalyticsData {
   volume: number
@@ -582,7 +582,7 @@ export function DomaAnalytics({ walletAddress, isConnected }: DomaAnalyticsProps
                             {domain.name}
                           </div>
                           <div className="text-sm text-muted-foreground">
-                            {domain.registrar} • Token #{domain.tokenId}
+                            {domain.registrar} �� Token #{domain.tokenId}
                           </div>
                         </div>
                       </div>
diff --git a/components/doma-bridge.tsx b/components/doma-bridge.tsx
index c6eab59..05b1fc9 100644
--- a/components/doma-bridge.tsx
+++ b/components/doma-bridge.tsx
@@ -67,90 +67,25 @@ interface DomaBridgeProps {
 
 const SUPPORTED_CHAINS: SupportedChain[] = [
   {
-    id: 'ethereum',
-    name: 'Ethereum',
-    shortName: 'ETH',
-    chainId: 1,
-    icon: '⟠',
+    id: 'doma',
+    name: 'Doma Network',
+    shortName: 'DOMA',
+    chainId: 97476,
+    icon: '🛡️',
     nativeCurrency: 'ETH',
-    rpcUrl: 'https://mainnet.infura.io/v3/',
-    explorerUrl: 'https://etherscan.io',
-    bridgeFee: 0.005,
-    estimatedTime: '5-10 min',
-    isTestnet: false
-  },
-  {
-    id: 'sepolia',
-    name: 'Sepolia Testnet',
-    shortName: 'SEP',
-    chainId: 11155111,
-    icon: '⟠',
-    nativeCurrency: 'ETH',
-    rpcUrl: 'https://sepolia.infura.io/v3/',
-    explorerUrl: 'https://sepolia.etherscan.io',
-    bridgeFee: 0.001,
-    estimatedTime: '2-5 min',
+    rpcUrl: 'https://rpc-testnet.doma.xyz',
+    explorerUrl: 'https://explorer-testnet.doma.xyz',
+    bridgeFee: 0,
+    estimatedTime: '—',
     isTestnet: true
-  },
-  {
-    id: 'polygon',
-    name: 'Polygon',
-    shortName: 'MATIC',
-    chainId: 137,
-    icon: '🔷',
-    nativeCurrency: 'MATIC',
-    rpcUrl: 'https://polygon-rpc.com',
-    explorerUrl: 'https://polygonscan.com',
-    bridgeFee: 0.1,
-    estimatedTime: '3-7 min',
-    isTestnet: false
-  },
-  {
-    id: 'arbitrum',
-    name: 'Arbitrum One',
-    shortName: 'ARB',
-    chainId: 42161,
-    icon: '🔵',
-    nativeCurrency: 'ETH',
-    rpcUrl: 'https://arb1.arbitrum.io/rpc',
-    explorerUrl: 'https://arbiscan.io',
-    bridgeFee: 0.002,
-    estimatedTime: '2-4 min',
-    isTestnet: false
-  },
-  {
-    id: 'optimism',
-    name: 'Optimism',
-    shortName: 'OP',
-    chainId: 10,
-    icon: '🔴',
-    nativeCurrency: 'ETH',
-    rpcUrl: 'https://mainnet.optimism.io',
-    explorerUrl: 'https://optimistic.etherscan.io',
-    bridgeFee: 0.003,
-    estimatedTime: '3-6 min',
-    isTestnet: false
-  },
-  {
-    id: 'solana',
-    name: 'Solana',
-    shortName: 'SOL',
-    chainId: 0, // Solana doesn't use EVM chain IDs
-    icon: '☀️',
-    nativeCurrency: 'SOL',
-    rpcUrl: 'https://api.mainnet-beta.solana.com',
-    explorerUrl: 'https://explorer.solana.com',
-    bridgeFee: 0.01,
-    estimatedTime: '1-3 min',
-    isTestnet: false
   }
 ]
 
 export function DomaBridge({ walletAddress, isConnected }: DomaBridgeProps) {
   const [userDomains, setUserDomains] = useState<DomainToken[]>([])
   const [selectedDomain, setSelectedDomain] = useState<string>("")
-  const [fromChain, setFromChain] = useState<string>("sepolia")
-  const [toChain, setToChain] = useState<string>("polygon")
+  const [fromChain, setFromChain] = useState<string>("doma")
+  const [toChain, setToChain] = useState<string>("")
   const [toAddress, setToAddress] = useState<string>("")
   const [bridgeTransactions, setBridgeTransactions] = useState<BridgeTransaction[]>([])
   const [currentBridge, setCurrentBridge] = useState<BridgeTransaction | null>(null)
@@ -499,7 +434,7 @@ export function DomaBridge({ walletAddress, isConnected }: DomaBridgeProps) {
               <CardHeader>
                 <CardTitle>Bridge Summary</CardTitle>
                 <CardDescription>
-                  Review your bridge transaction details
+                  Doma Network only. Use the official bridge below for cross-chain actions.
                 </CardDescription>
               </CardHeader>
               <CardContent className="space-y-4">
@@ -543,6 +478,12 @@ export function DomaBridge({ walletAddress, isConnected }: DomaBridgeProps) {
                     </div>
 
                     <div className="pt-4 border-t">
+                      <Button variant="outline" asChild className="w-full mb-3">
+                        <a href="https://bridge-testnet.doma.xyz" target="_blank" rel="noopener noreferrer">
+                          <ExternalLink className="h-4 w-4 mr-2" />
+                          Open Doma Bridge
+                        </a>
+                      </Button>
                       <div className="flex items-center gap-2 p-3 bg-amber-50 dark:bg-amber-950/20 rounded-lg mb-4">
                         <Shield className="h-4 w-4 text-amber-600" />
                         <div className="text-sm">
diff --git a/components/doma-marketplace.tsx b/components/doma-marketplace.tsx
index 23ddad6..8094260 100644
--- a/components/doma-marketplace.tsx
+++ b/components/doma-marketplace.tsx
@@ -306,7 +306,7 @@ export function DomaMarketplace({ walletAddress, isConnected }: DomaMarketplaceP
                         </div>
                         <div className="flex items-center justify-between text-sm">
                           <span className="text-muted-foreground">Chain:</span>
-                          <span>Sepolia Testnet</span>
+                          <span>Doma Network</span>
                         </div>
                       </div>
 
diff --git a/components/domain-monitor.tsx b/components/domain-monitor.tsx
index 03eea23..0b074da 100644
--- a/components/domain-monitor.tsx
+++ b/components/domain-monitor.tsx
@@ -183,7 +183,7 @@ export function DomainMonitor({ walletAddress, isConnected }: DomainMonitorProps
             <Button variant="outline" asChild>
               <a href="https://start.doma.xyz" target="_blank" rel="noopener noreferrer">
                 <ExternalLink className="h-4 w-4 mr-2" />
-                Doma Testnet
+                Doma Network
               </a>
             </Button>
           </div>
@@ -262,7 +262,7 @@ export function DomainMonitor({ walletAddress, isConnected }: DomainMonitorProps
                       <TableCell>
                         <Button variant="ghost" size="sm" asChild>
                           <a
-                            href={`https://sepolia.etherscan.io/token/${domain.tokenId}`}
+                            href={`https://explorer-testnet.doma.xyz`}
                             target="_blank"
                             rel="noopener noreferrer"
                           >
diff --git a/components/domainfi-dashboard.tsx b/components/domainfi-dashboard.tsx
index d7180a5..a4b1682 100644
--- a/components/domainfi-dashboard.tsx
+++ b/components/domainfi-dashboard.tsx
@@ -74,6 +74,30 @@ export function DomanitorDashboard() {
         console.log("[DomaAPI] Enhanced simulation metrics loaded successfully:", combinedMetrics)
       } catch (error) {
         console.error("[DomaAPI] Failed to load enhanced Doma metrics:", error)
+        // Fallback to deterministic simulated metrics so the dashboard always shows values
+        const fallback = {
+          totalDomains: 12847,
+          tokenizedValue: 4200000,
+          transactions24h: 234,
+          uniqueUsers24h: 127,
+          monthlyRevenue: 28400,
+          activeListings: 842,
+          recentActivity: [
+            {
+              type: 'mint',
+              tokenId: '0x1a2b3c',
+              timestamp: new Date().toISOString(),
+              transactionHash: `0x${Math.random().toString(16).substr(2, 64)}`,
+              from: '0x0000000000000000000000000000000000000000',
+              to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+            },
+          ],
+          priceChange24h: parseFloat(((Math.random() * 4 - 2).toFixed(1))),
+          newRegistrations24h: 73,
+          totalVolume: '2850000',
+          lastUpdate: new Date().toISOString(),
+        }
+        setMetrics(fallback)
       }
     }
 
@@ -116,7 +140,7 @@ export function DomanitorDashboard() {
                     Audited
                   </Badge>
                   <Badge variant="secondary" className="bg-accent text-accent-foreground">
-                    Doma Testnet
+                    Doma Network
                   </Badge>
                   <Badge
                     variant="secondary"
@@ -128,13 +152,6 @@ export function DomanitorDashboard() {
                 </div>
               </div>
 
-              {/* Support Badge */}
-              <div className="hidden xl:flex items-center">
-                <Badge variant="outline" className="bg-gradient-to-r from-blue-500 to-purple-500 text-white border-0">
-                  <Sparkles className="h-3 w-3 mr-1" />
-                  Supporting: Ethereum (.eth) | Solana (.sol) | BNB Chain (.bnb) | Cosmos (.cosmos)
-                </Badge>
-              </div>
 
               {/* Right Side Actions */}
               <div className="flex items-center space-x-2">
@@ -202,7 +219,7 @@ export function DomanitorDashboard() {
                 Audited
               </Badge>
               <Badge variant="secondary" className="bg-accent text-accent-foreground">
-                Doma Testnet
+                Doma Network
               </Badge>
               <Badge
                 variant="secondary"
@@ -221,7 +238,7 @@ export function DomanitorDashboard() {
             <Alert className="mb-6 border-accent bg-accent/10 rounded-lg">
               <Activity className="h-4 w-4" />
               <AlertDescription className="text-sm">
-                Connect your wallet to access Domanitor features and start tokenizing domains on Doma testnet.
+                Connect your wallet to access Domanitor features and start tokenizing domains on Doma Network.
                 <strong className="text-foreground"> All transactions are on testnet - no real funds required.</strong>
               </AlertDescription>
             </Alert>
diff --git a/components/tokenization-panel.tsx b/components/tokenization-panel.tsx
index 88f340a..2477e89 100644
--- a/components/tokenization-panel.tsx
+++ b/components/tokenization-panel.tsx
@@ -27,19 +27,30 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
   const [isTokenizing, setIsTokenizing] = useState(false)
   const [fractionalize, setFractionalize] = useState(false)
   const [totalShares, setTotalShares] = useState(1000)
+  const [simulateTokenization, setSimulateTokenization] = useState(true)
   const [txHash, setTxHash] = useState("")
   const [error, setError] = useState("")
 
   const handleTokenize = async () => {
     if (!isConnected || !domain) return
 
+    const normalized = domain.trim().toLowerCase()
+    const parts = normalized.split('.')
+    const sld = parts[0]
+    const tld = parts.slice(1).join('.')
+    const domainRegex = /^[a-z0-9-]{1,63}\.[a-z0-9.-]{2,63}$/i
+    if (!sld || !tld || !domainRegex.test(normalized)) {
+      setError('Masukkan domain yang valid, mis. example.com')
+      return
+    }
+
     setIsTokenizing(true)
     setError("")
     setTokenizationProgress(0)
 
     try {
       const request: TokenizationRequest = {
-        domain,
+        domain: normalized,
         registrar: selectedRegistrar,
         walletAddress,
         fractionalize,
@@ -49,23 +60,40 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
       // Simulate progress updates
       setTokenizationProgress(25)
       setTimeout(() => setTokenizationProgress(50), 1000)
-      setTimeout(() => setTokenizationProgress(75), 2000)
 
-      const result = await DomaAPI.tokenizeDomain(request)
+      if (simulateTokenization) {
+        // Produce a simulated txHash and show success while still linking to explorer
+        const simulatedTx = `0x${Math.random().toString(16).substr(2, 64)}`
+        setTimeout(() => {
+          setTokenizationProgress(100)
+          setTxHash(simulatedTx)
+        }, 1800)
 
-      if (result.success) {
-        setTokenizationProgress(100)
-        setTxHash(result.txHash || "")
-
-        // If fractionalizing, create fractional tokens
-        if (fractionalize && result.txHash) {
-          setTimeout(async () => {
-            await DomaAPI.fractionalizeDomain(result.txHash!, totalShares)
-          }, 1000)
+        // Simulate fractionalization if enabled
+        if (fractionalize) {
+          setTimeout(() => {
+            console.log('[TokenizationPanel] Simulated fractionalization for', simulatedTx)
+          }, 2500)
         }
       } else {
-        setError(result.error || "Tokenization failed")
-        setTokenizationProgress(0)
+        setTimeout(() => setTokenizationProgress(75), 2000)
+
+        const result = await DomaAPI.tokenizeDomain(request)
+
+        if (result.success) {
+          setTokenizationProgress(100)
+          setTxHash(result.txHash || "")
+
+          // If fractionalizing, create fractional tokens
+          if (fractionalize && result.txHash) {
+            setTimeout(async () => {
+              await DomaAPI.fractionalizeDomain(result.txHash!, totalShares)
+            }, 1000)
+          }
+        } else {
+          setError(result.error || "Tokenization failed")
+          setTokenizationProgress(0)
+        }
       }
     } catch (err) {
       setError("Network error occurred")
@@ -100,7 +128,7 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
           <CardContent className="space-y-4">
             {!isConnected && (
               <Alert>
-                <AlertDescription>Connect your wallet to start tokenizing domains on Doma testnet.</AlertDescription>
+                <AlertDescription>Connect your wallet to start tokenizing domains on Doma Network.</AlertDescription>
               </Alert>
             )}
 
@@ -126,7 +154,7 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
                   <SelectValue placeholder="Select registrar" />
                 </SelectTrigger>
                 <SelectContent>
-                  <SelectItem value="D3">D3 (Doma Testnet)</SelectItem>
+                  <SelectItem value="D3">D3 (Doma Network)</SelectItem>
                   <SelectItem value="GoDaddy">GoDaddy</SelectItem>
                   <SelectItem value="Namecheap">Namecheap</SelectItem>
                   <SelectItem value="Cloudflare">Cloudflare</SelectItem>
@@ -150,7 +178,22 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
                 />
               </div>
 
-              <div className="bg-accent/10 border border-accent/20 rounded-lg p-3">
+              <div className="mt-3 flex items-center justify-between">
+                <div>
+                  <Label className="flex items-center gap-2">
+                    <Zap className="h-4 w-4" />
+                    Simulate Tokenization
+                  </Label>
+                  <p className="text-sm text-muted-foreground">Use a simulated transaction hash but link to Doma testnet explorer</p>
+                </div>
+                <Switch
+                  checked={simulateTokenization}
+                  onCheckedChange={setSimulateTokenization}
+                  disabled={!isConnected || isTokenizing}
+                />
+              </div>
+
+              <div className="bg-accent/10 border border-accent/20 rounded-lg p-3 mt-3">
                 <div className="flex items-center gap-2 mb-1">
                   <DollarSign className="h-4 w-4 text-accent" />
                   <span className="font-semibold text-sm">Domain Financing</span>
@@ -205,7 +248,7 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
                 <AlertDescription className="flex items-center gap-2">
                   <span>Transaction successful!</span>
                   <Button variant="ghost" size="sm" asChild>
-                    <a href={`https://sepolia.etherscan.io/tx/${txHash}`} target="_blank" rel="noopener noreferrer">
+                    <a href={`https://explorer-testnet.doma.xyz/tx/${txHash}`} target="_blank" rel="noopener noreferrer">
                       <ExternalLink className="h-3 w-3" />
                       View on Explorer
                     </a>
@@ -315,7 +358,7 @@ export function TokenizationPanel({ walletAddress, isConnected }: TokenizationPa
       <Card>
         <CardHeader>
           <CardTitle>Recent Doma Protocol Activity</CardTitle>
-          <CardDescription>Latest domains tokenized on the Doma testnet</CardDescription>
+          <CardDescription>Latest domains tokenized on the Doma Network</CardDescription>
         </CardHeader>
         <CardContent>
           <div className="mb-6">
diff --git a/components/wallet-assets-dashboard.tsx b/components/wallet-assets-dashboard.tsx
index 0dbc3f0..99638a0 100644
--- a/components/wallet-assets-dashboard.tsx
+++ b/components/wallet-assets-dashboard.tsx
@@ -247,10 +247,10 @@ export function WalletAssetsDashboard({ walletAddress, isConnected, provider }:
         <Alert className="border-orange-200 bg-orange-50 dark:border-orange-800 dark:bg-orange-950">
           <AlertTriangle className="h-4 w-4 text-orange-600" />
           <AlertDescription className="flex items-center justify-between">
-            <span>You are not connected to Doma Testnet (Sepolia). Switch to view real assets.</span>
+            <span>You are not connected to Doma Network. Switch to view assets.</span>
             <Button onClick={switchToDomaTestnet} size="sm" className="ml-4">
               <Network className="h-4 w-4 mr-2" />
-              Switch to Doma Testnet
+              Switch to Doma Network
             </Button>
           </AlertDescription>
         </Alert>
@@ -376,11 +376,11 @@ export function WalletAssetsDashboard({ walletAddress, isConnected, provider }:
                             </Button>
                             <Button variant="ghost" size="sm" asChild>
                               <a
-                                href={`https://sepolia.etherscan.io/token/${domain.tokenId}`}
+                                href={`https://explorer-testnet.doma.xyz`}
                                 target="_blank"
                                 rel="noopener noreferrer"
                                 className="text-muted-foreground hover:text-foreground"
-                                title="View on Etherscan"
+                                title="View on Explorer"
                               >
                                 <ExternalLink className="h-3 w-3 lg:h-4 lg:w-4" />
                               </a>
diff --git a/lib/doma-api.ts b/lib/doma-api.ts
index c0cb799..2ca4bb9 100644
--- a/lib/doma-api.ts
+++ b/lib/doma-api.ts
@@ -1,5 +1,6 @@
 // Doma Protocol Integration Layer with Official SDK and Updated APIs
 import { createDomaOrderbookClient, type DomaOrderbookClient } from '@doma-protocol/orderbook-sdk'
+import { DomaWeb3Service } from './web3-utils'
 
 export interface DomaConfig {
   testnetUrl: string
@@ -17,8 +18,8 @@ export const DOMA_CONFIG: DomaConfig = {
   testnetUrl: "https://start.doma.xyz",
   d3ApiUrl: "https://api-testnet.doma.xyz/v1",
   forgeApiUrl: "https://forge.doma.xyz/api",
-  contractAddress: "0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e",
-  chainId: 11155111, // Sepolia testnet
+  contractAddress: "0x742d35cc6634c0532925a3b8d4c9db96c4b5da5e",
+  chainId: 97476,
   websocketUrl: "wss://api-testnet.doma.xyz/ws",
   graphqlUrl: "https://api-testnet.doma.xyz/graphql",
   pollApiUrl: "https://api-testnet.doma.xyz/v1/poll",
@@ -35,8 +36,25 @@ export const DOMA_ENDPOINTS = {
   smartContracts: "https://api-testnet.doma.xyz/v1/smart-contracts"
 }
 
-// Updated API Key
-export const DOMA_API_KEY = "v1.954d51b4e76bfda49d1ef7cd3869797b005f9a8558c2c6e4c8d2c642b24e80ca"
+// Updated API Key (prefer env, fallback to demo key)
+export const DOMA_API_KEY = process.env.NEXT_PUBLIC_DOMA_API_KEY || "v1.954d51b4e76bfda49d1ef7cd3869797b005f9a8558c2c6e4c8d2c642b24e80ca";
+
+export const DOMA_USE_SIMULATION = process.env.NEXT_PUBLIC_DOMA_SIMULATION_ONLY === 'true'
+
+// Robust fetch helper with timeout and graceful failure handling
+const safeFetch = async (input: RequestInfo, init?: RequestInit, timeout = 8000): Promise<Response | null> => {
+  try {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+    const signal = controller ? controller.signal : undefined
+    const timer = controller ? setTimeout(() => controller.abort(), timeout) : null
+    const res = await fetch(input, { ...(init || {}), signal } as RequestInit)
+    if (timer) clearTimeout(timer)
+    return res
+  } catch (err) {
+    console.warn('[DomaAPI] safeFetch failed for', String(input).slice(0, 120), err)
+    return null
+  }
+}
 
 // Poll API Event Types
 export type PollEventType = 
@@ -237,8 +255,35 @@ export interface DomaSubgraphData {
 }
 
 // Enhanced API functions for Doma Protocol integration
+// In-memory marketplace state for demo
+let MARKETPLACE_LISTINGS: DomainListing[] = [
+  {
+    id: 'lst_1',
+    domain: 'ethaga.ai',
+    price: 2500,
+    currency: 'USDC',
+    seller: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+    status: 'active',
+    listedAt: new Date(Date.now() - 3600_000).toISOString(),
+    tokenId: '0x1a2b3c',
+    chainId: 97476,
+  },
+  {
+    id: 'lst_2',
+    domain: 'ethaga.io',
+    price: 1200,
+    currency: 'ETH',
+    seller: '0x9A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f',
+    status: 'active',
+    listedAt: new Date(Date.now() - 7200_000).toISOString(),
+    tokenId: '0x4d5e6f',
+    chainId: 97476,
+  }
+]
+let MARKETPLACE_OFFERS: DomainOffer[] = []
+
 export class DomaAPI {
-  
+
   // Poll API Implementation
   static async pollEvents(
     limit?: number,
@@ -374,92 +419,157 @@ export class DomaAPI {
   static async tokenizeDomain(
     request: TokenizationRequest,
   ): Promise<{ success: boolean; txHash?: string; tokenId?: string; error?: string }> {
-    console.log("[DomaAPI] Tokenizing domain via updated Doma Protocol API:", request)
+    console.log("[DomaAPI] Tokenizing domain:", request)
 
+    // Try wallet-based on-chain tokenization first (user signs tx)
     try {
-      // Step 1: Request tokenization voucher from Doma Protocol
-      const voucherResponse = await fetch(`${DOMA_CONFIG.d3ApiUrl}/tokenization/request`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${DOMA_API_KEY}`,
-        },
-        body: JSON.stringify({
-          domain: request.domain,
-          owner: request.walletAddress,
-          registrar: request.registrar,
-          fractionalize: request.fractionalize,
-          totalShares: request.totalShares,
-        }),
-      })
+      if (typeof window !== 'undefined' && (window.ethereum || (window as any).okxwallet)) {
+        const provider = (window as any).ethereum || (window as any).okxwallet
+        const web3 = new DomaWeb3Service(provider)
+        const switched = await web3.switchToDomaTestnet()
+        if (!switched) {
+          console.warn('[DomaAPI] Could not auto-switch network; please switch to Doma Network manually')
+        }
 
-      if (!voucherResponse.ok) {
-        const errorText = await voucherResponse.text()
-        throw new Error(`Tokenization request failed: ${voucherResponse.status} - ${errorText}`)
+        const result = await web3.requestTokenization([request.domain], request.walletAddress)
+        if (result.success) {
+          return {
+            success: true,
+            txHash: result.transactionHash,
+            tokenId: result.tokenId || `doma_${Math.random().toString(36).substr(2, 9)}`,
+          }
+        }
+        // If wallet path fails, return the error unless simulation is explicitly enabled
+        if (!DOMA_USE_SIMULATION) {
+          return { success: false, error: result.error || 'Tokenization failed' }
+        }
       }
+    } catch (walletError: any) {
+      if (!DOMA_USE_SIMULATION) {
+        return { success: false, error: walletError?.message || 'Wallet tokenization failed' }
+      }
+      console.warn('[DomaAPI] Wallet tokenization failed, simulation allowed:', walletError)
+    }
 
-      const voucherData = await voucherResponse.json()
-      console.log("[DomaAPI] Received tokenization voucher:", voucherData.correlationId)
-
-      // Step 2: Monitor tokenization status
-      const correlationId = voucherData.correlationId
-      let attempts = 0
-      const maxAttempts = 20
-
-      while (attempts < maxAttempts) {
-        await new Promise((resolve) => setTimeout(resolve, 6000))
-
-        const statusResponse = await fetch(`${DOMA_CONFIG.d3ApiUrl}/tokenization/status/${correlationId}`, {
+    // Optional API fallback (disabled by default)
+    const apiFallback = process.env.NEXT_PUBLIC_DOMA_API_FALLBACK === 'true'
+    if (apiFallback) {
+      try {
+        const voucherResponse = await safeFetch(`${DOMA_CONFIG.d3ApiUrl}/tokenization/request`, {
+          method: "POST",
           headers: {
+            "Content-Type": "application/json",
             "Authorization": `Bearer ${DOMA_API_KEY}`,
           },
+          body: JSON.stringify({
+            domain: request.domain,
+            owner: request.walletAddress,
+            registrar: request.registrar,
+            fractionalize: request.fractionalize,
+            totalShares: request.totalShares,
+          }),
         })
 
-        if (statusResponse.ok) {
-          const statusData = await statusResponse.json()
+        if (!voucherResponse || !voucherResponse.ok) {
+          const errorText = voucherResponse ? await voucherResponse.text() : 'network_error'
+          console.error('[DomaAPI] Tokenization request failed:', { status: voucherResponse?.status, body: errorText })
+          throw new Error(`Tokenization request failed: ${voucherResponse?.status || 'network_error'} - ${errorText}`)
+        }
 
-          if (statusData.status === 'completed') {
-            return {
-              success: true,
-              txHash: statusData.transactionHash,
-              tokenId: statusData.tokenId,
-            }
-          } else if (statusData.status === 'failed') {
-            throw new Error(statusData.error || 'Tokenization failed')
-          }
+        const voucherData = await voucherResponse.json()
+        console.log('[DomaAPI] Tokenization voucher response:', voucherData)
+        const correlationId = voucherData.correlationId
+        let attempts = 0
+        const maxAttempts = 20
 
-          console.log(`[DomaAPI] Tokenization status: ${statusData.status}`)
-        }
+        while (attempts < maxAttempts) {
+          await new Promise((resolve) => setTimeout(resolve, 6000))
 
-        attempts++
-      }
+          const statusResponse = await safeFetch(`${DOMA_CONFIG.d3ApiUrl}/tokenization/status/${correlationId}`, {
+            headers: {
+              "Authorization": `Bearer ${DOMA_API_KEY}`,
+            },
+          })
 
-      throw new Error('Tokenization timeout - please check status later')
+          if (statusResponse && statusResponse.ok) {
+            const statusData = await statusResponse.json()
 
-    } catch (error) {
-      console.warn('[DomaAPI] Real API failed, using simulation:', error)
+            if (statusData.status === 'completed') {
+              return {
+                success: true,
+                txHash: statusData.transactionHash,
+                tokenId: statusData.tokenId,
+              }
+            } else if (statusData.status === 'failed') {
+              throw new Error(statusData.error || 'Tokenization failed')
+            }
+          }
 
-      // Fallback to simulation for demo purposes
-      console.log("[DomaAPI] Using tokenization simulation as fallback")
-      await new Promise((resolve) => setTimeout(resolve, 3000))
+          attempts++
+        }
 
-      const tokenId = `doma_${Math.random().toString(36).substr(2, 9)}`
+        throw new Error('Tokenization timeout - please check status later')
+
+      } catch (error: any) {
+        if (!DOMA_USE_SIMULATION) {
+          return { success: false, error: error?.message || 'Tokenization failed' }
+        }
+        console.warn('[DomaAPI] API path failed, using simulation:', error)
+      }
+    }
 
+    // Simulation only if explicitly enabled
+    if (DOMA_USE_SIMULATION) {
+      await new Promise((resolve) => setTimeout(resolve, 1500))
       return {
-        success: Math.random() > 0.2,
+        success: true,
         txHash: `0x${Math.random().toString(16).substr(2, 64)}`,
-        tokenId: tokenId,
-        error: error instanceof Error ? `API Error (using simulation): ${error.message}` : undefined
+        tokenId: `doma_${Math.random().toString(36).substr(2, 9)}`,
       }
     }
+
+    return { success: false, error: 'On-chain tokenization not configured. Provide deployed contract addresses or enable simulation.' }
   }
 
   static async getDomainTokens(walletAddress: string): Promise<DomainToken[]> {
-    console.log('[DomaAPI] Fetching domain tokens from updated API for:', walletAddress)
+    console.log('[DomaAPI] Fetching domain tokens for:', walletAddress)
 
+    // Prepare enhanced simulation data up-front
+    const simulatedDomains: DomainToken[] = [
+      {
+        id: "doma_user_1",
+        name: "ethaga.ai",
+        owner: walletAddress,
+        tokenId: "0x1a2b3c",
+        registrar: "D3 Registrar",
+        expirationDate: "2027-07-04T00:00:00Z",
+        isTokenized: true,
+        fractionalized: false,
+        floorPrice: 0.5,
+        status: "active",
+      },
+      {
+        id: "doma_user_2",
+        name: "ethaga.io",
+        owner: walletAddress,
+        tokenId: "0x4d5e6f",
+        registrar: "D3 Registrar",
+        expirationDate: "2026-07-04T00:00:00Z",
+        isTokenized: true,
+        fractionalized: false,
+        floorPrice: 0.3,
+        status: "active",
+      },
+    ]
+
+    if (DOMA_USE_SIMULATION) {
+      console.log('[DomaAPI] Simulation enabled: returning local domain tokens')
+      return simulatedDomains
+    }
+
+    // 1) Try subgraph GraphQL endpoint
     try {
-      // Try to use the updated subgraph endpoint
-      const response = await fetch(DOMA_ENDPOINTS.subgraph, {
+      const response = await safeFetch(DOMA_ENDPOINTS.subgraph, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -473,10 +583,8 @@ export class DomaAPI {
                 name
                 tokenId
                 owner
-                registrant
-                expirationDate
-                createdAt
                 registrar
+                expirationDate
                 isTokenized
               }
             }
@@ -485,9 +593,11 @@ export class DomaAPI {
         })
       })
 
-      if (response.ok) {
+      if (response && response.ok) {
         const data = await response.json()
-        if (data.data?.domains) {
+        if (data.errors) {
+          console.warn('[DomaAPI] Subgraph returned errors for GetDomainTokens:', data.errors)
+        } else if (data.data?.domains && data.data.domains.length) {
           return data.data.domains.map((domain: any) => ({
             id: domain.id,
             name: domain.name,
@@ -503,72 +613,79 @@ export class DomaAPI {
         }
       }
     } catch (error) {
-      console.warn('[DomaAPI] Updated subgraph failed:', error)
+      console.warn('[DomaAPI] Subgraph fetch failed, will try on-chain contracts:', error)
     }
 
-    // Fallback to enhanced simulation data
-    console.log('[DomaAPI] Using enhanced simulation data for wallet:', walletAddress)
-    
-    const simulatedDomains: DomainToken[] = [
-      {
-        id: "doma_user_1",
-        name: "ethaga.ai",
-        owner: walletAddress,
-        tokenId: "0x1a2b3c",
-        registrar: "D3 Registrar",
-        expirationDate: "2027-07-04T00:00:00Z",
-        isTokenized: true,
-        fractionalized: false,
-        floorPrice: 0.5,
-        status: "active",
-      },
-      {
-        id: "doma_user_2",
-        name: "ethaga.io",
-        owner: walletAddress,
-        tokenId: "0x4d5e6f",
-        registrar: "D3 Registrar",
-        expirationDate: "2026-07-04T00:00:00Z",
-        isTokenized: true,
-        fractionalized: false,
-        floorPrice: 0.3,
-        status: "active",
-      },
-      {
-        id: "doma_user_3",
-        name: "ethaga.com",
-        owner: walletAddress,
-        tokenId: "0x7g8h9i",
-        registrar: "D3 Registrar",
-        expirationDate: "2026-07-04T00:00:00Z",
-        isTokenized: true,
-        fractionalized: false,
-        floorPrice: 0.8,
-        status: "active",
-      },
-      {
-        id: "doma_user_4",
-        name: "ethaga.ape",
-        owner: walletAddress,
-        tokenId: "0x9j0k1l",
-        registrar: "D3 Registrar",
-        expirationDate: "2026-07-04T00:00:00Z",
-        isTokenized: true,
-        fractionalized: false,
-        floorPrice: 0.2,
-        status: "active",
+    // 2) Try reading directly from on-chain contracts using DomaSmartContractsService
+    try {
+      const { DomaSmartContractsService } = await import('./doma-smart-contracts')
+      const svc = new DomaSmartContractsService()
+      const assets = await svc.getDomainAssets(walletAddress)
+      if (assets && assets.length) {
+        return assets.map(a => ({
+          id: a.tokenId,
+          name: a.name,
+          owner: a.owner,
+          tokenId: a.tokenId,
+          registrar: `Registrar #${a.registrarIanaId}`,
+          expirationDate: a.expirationDate,
+          isTokenized: a.isActive,
+          fractionalized: false,
+          floorPrice: parseFloat(a.tokenizedValue) || Math.random() * 2 + 0.1,
+          status: a.isActive ? 'active' : 'expired'
+        }))
       }
-    ]
+    } catch (contractErr) {
+      console.warn('[DomaAPI] On-chain contract fetch failed:', contractErr)
+    }
 
+    // 3) Fallback to simulated data
+    console.log('[DomaAPI] Using enhanced simulation data for wallet:', walletAddress)
     return simulatedDomains
   }
 
   // Enhanced subgraph data with updated endpoint
   static async getSubgraphData(): Promise<DomaSubgraphData> {
+    // Simulation short-circuit to avoid GraphQL 400s during development/demo
+    if (DOMA_USE_SIMULATION) {
+      const baseTime = Date.now()
+      return {
+        domains: [
+          {
+            id: 'doma_domain_1',
+            name: 'ethaga.ai',
+            tokenId: '0x1a2b3c',
+            owner: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+            registrant: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+            expirationDate: '2027-07-04T00:00:00Z',
+            createdAt: '2024-01-15T10:30:00Z',
+            registrar: 'D3 Registrar',
+            isTokenized: true
+          }
+        ],
+        transactions: [
+          {
+            id: 'doma_tx_1',
+            type: 'mint',
+            from: '0x0000000000000000000000000000000000000000',
+            to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+            tokenId: '0x1a2b3c',
+            timestamp: new Date(baseTime - 1800000).toISOString(),
+            transactionHash: '0xa1b2c3d4e5f6789a'
+          }
+        ],
+        marketMetrics: {
+          totalDomains: 1247,
+          totalVolume: '2850000',
+          floorPrice: '0.05',
+          averagePrice: '1.8'
+        }
+      }
+    }
+
     try {
       console.log('[DomaAPI] Fetching from updated subgraph endpoint')
-      
-      const response = await fetch(DOMA_ENDPOINTS.subgraph, {
+      const response = await safeFetch(DOMA_ENDPOINTS.subgraph, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -608,16 +725,20 @@ export class DomaAPI {
         })
       })
 
-      if (response.ok) {
+      if (response && response.ok) {
         const data = await response.json()
+        if (data.errors) {
+          console.warn('[DomaAPI] Subgraph returned errors for GetMarketData:', data.errors)
+          throw new Error('Subgraph errors')
+        }
         return {
           domains: data.data.domains || [],
           transactions: data.data.transactions || [],
           marketMetrics: {
             totalDomains: data.data.domains?.length || 0,
-            totalVolume: "2850000",
-            floorPrice: "0.05",
-            averagePrice: "1.8"
+            totalVolume: '2850000',
+            floorPrice: '0.05',
+            averagePrice: '1.8'
           }
         }
       }
@@ -625,7 +746,6 @@ export class DomaAPI {
       console.warn('[DomaAPI] Updated subgraph failed, using simulation:', error)
     }
 
-    // Enhanced simulation data
     const baseTime = Date.now()
     return {
       domains: [
@@ -654,13 +774,59 @@ export class DomaAPI {
       ],
       marketMetrics: {
         totalDomains: 1247,
-        totalVolume: "2850000",
-        floorPrice: "0.05",
-        averagePrice: "1.8"
+        totalVolume: '2850000',
+        floorPrice: '0.05',
+        averagePrice: '1.8'
       }
     }
   }
 
+  static async fractionalizeDomain(txHash: string, totalShares: number): Promise<{ success: boolean; sharesMinted: number }> {
+    console.log('[DomaAPI] Fractionalizing domain from tx:', txHash, 'shares:', totalShares)
+    await new Promise((r) => setTimeout(r, 800))
+    return { success: true, sharesMinted: totalShares }
+  }
+
+  static async getDomainListings(): Promise<DomainListing[]> {
+    return MARKETPLACE_LISTINGS.slice().sort((a, b) => new Date(b.listedAt).getTime() - new Date(a.listedAt).getTime())
+  }
+
+  static async createDomainListing(domain: string, price: number, currency: string, seller: string): Promise<{ success: boolean; id?: string }> {
+    const id = `lst_${Math.random().toString(36).substr(2, 6)}`
+    const listing: DomainListing = {
+      id,
+      domain,
+      price,
+      currency,
+      seller,
+      status: 'active',
+      listedAt: new Date().toISOString(),
+      tokenId: `0x${Math.random().toString(16).substr(2, 6)}`,
+      chainId: 97476,
+    }
+    MARKETPLACE_LISTINGS.unshift(listing)
+    return { success: true, id }
+  }
+
+  static async createDomainOffer(domain: string, price: number, currency: string, buyer: string): Promise<{ success: boolean; id?: string }> {
+    const id = `ofr_${Math.random().toString(36).substr(2, 6)}`
+    const expiresAt = new Date(Date.now() + 7 * 24 * 3600_000).toISOString()
+    const offer: DomainOffer = {
+      id,
+      domain,
+      price,
+      currency,
+      buyer,
+      status: 'pending',
+      createdAt: new Date().toISOString(),
+      expiresAt,
+      tokenId: undefined,
+      chainId: 97476,
+    }
+    MARKETPLACE_OFFERS.unshift(offer)
+    return { success: true, id }
+  }
+
   // Enhanced real-time polling for events
   static async startEventPolling(
     callback: (events: PollEvent[]) => void,
@@ -712,6 +878,58 @@ export class DomaAPI {
     }
   }
 
+  static async getDashboardStats() {
+    try {
+      const subgraphData = await this.getSubgraphData()
+      const now = Date.now()
+      const newRegistrations24h = subgraphData.domains.filter((d: any) => {
+        const t = Date.parse(d.createdAt || d.expirationDate || '')
+        return !isNaN(t) && now - t <= 24 * 60 * 60 * 1000
+      }).length
+
+      const recentActivity = (subgraphData.transactions || []).slice(0, 5).map((tx: any) => ({
+        type: tx.type,
+        tokenId: tx.tokenId,
+        timestamp: tx.timestamp,
+        transactionHash: tx.transactionHash,
+        from: tx.from,
+        to: tx.to,
+      }))
+
+      const totalDomains = subgraphData.marketMetrics.totalDomains
+      const activeListings = Math.max(12, Math.round(totalDomains * 0.08))
+      const priceChange24h = parseFloat(((Math.random() * 6 - 3)).toFixed(1))
+
+      return {
+        totalDomains,
+        activeListings,
+        recentActivity,
+        priceChange24h,
+        newRegistrations24h,
+        totalVolume: subgraphData.marketMetrics.totalVolume,
+      }
+    } catch (error) {
+      console.warn('[DomaAPI] getDashboardStats failed, using simulation:', error)
+      return {
+        totalDomains: 12847,
+        activeListings: 842,
+        recentActivity: [
+          {
+            type: 'mint',
+            tokenId: '0x1a2b3c',
+            timestamp: new Date().toISOString(),
+            transactionHash: `0x${Math.random().toString(16).substr(2, 64)}`,
+            from: '0x0000000000000000000000000000000000000000',
+            to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+          },
+        ],
+        priceChange24h: parseFloat(((Math.random() * 4 - 2).toFixed(1))),
+        newRegistrations24h: 73,
+        totalVolume: '2850000',
+      }
+    }
+  }
+
   static async getMarketMetrics() {
     try {
       const subgraphData = await this.getSubgraphData()
@@ -747,4 +965,93 @@ export class DomaAPI {
       }
     }
   }
+
+  static async getDomaAnalytics(timeframe: '24h' | '7d' | '30d'):
+    Promise<{
+      volume: number
+      transactions: number
+      uniqueUsers: number
+      averagePrice: number
+      floorPrice: number
+      topDomains: Array<{ name: string; tokenId: string; owner: string; registrar: string; price?: number; volume?: number }>
+      recentTransactions: Array<{ id: string; type: 'mint' | 'transfer' | 'burn'; from: string; to: string; tokenId: string; timestamp: string; transactionHash: string }>
+    }>
+  {
+    try {
+      const subgraph = await this.getSubgraphData()
+
+      // Time window in ms
+      const now = Date.now()
+      const windowMs = timeframe === '24h' ? 24 * 3600_000 : timeframe === '7d' ? 7 * 24 * 3600_000 : 30 * 24 * 3600_000
+
+      const txs = (subgraph.transactions || []).filter(tx => {
+        const t = Date.parse(tx.timestamp)
+        return !isNaN(t) && now - t <= windowMs
+      })
+
+      const uniqueUsers = new Set<string>()
+      txs.forEach(tx => { uniqueUsers.add(tx.from); uniqueUsers.add(tx.to) })
+
+      const averagePrice = parseFloat(subgraph.marketMetrics.averagePrice) || 1800
+      const floorPrice = parseFloat(subgraph.marketMetrics.floorPrice) || 50
+
+      const volume = txs.length * averagePrice
+
+      const topDomains = (subgraph.domains || [])
+        .slice(0, 10)
+        .map((d, i) => ({
+          name: d.name,
+          tokenId: d.tokenId,
+          owner: d.owner,
+          registrar: d.registrar,
+          price: Math.round((averagePrice * (1 + (10 - i) / 20)))
+        }))
+
+      return {
+        volume: Math.round(volume),
+        transactions: txs.length,
+        uniqueUsers: uniqueUsers.size,
+        averagePrice: Math.round(averagePrice),
+        floorPrice: Math.round(floorPrice),
+        topDomains,
+        recentTransactions: txs.slice(0, 20)
+      }
+    } catch (error) {
+      console.warn('[DomaAPI] getDomaAnalytics failed, using simulation:', error)
+
+      // Deterministic simulated data per timeframe
+      const base = timeframe === '24h' ? 200_000 : timeframe === '7d' ? 1_400_000 : 6_000_000
+      const txCount = timeframe === '24h' ? 750 : timeframe === '7d' ? 4_200 : 18_500
+      const avg = 1850
+      const floor = 60
+
+      const recentTransactions = Array.from({ length: 12 }).map((_, i) => ({
+        id: `sim_tx_${i}_${Date.now()}`,
+        type: (['mint','transfer','transfer','transfer','burn'] as const)[i % 5],
+        from: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
+        to: '0x9A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f',
+        tokenId: `0x${(1000 + i).toString(16)}`,
+        timestamp: new Date(Date.now() - i * 3600_000).toISOString(),
+        transactionHash: `0x${Math.random().toString(16).substr(2, 64)}`
+      }))
+
+      const topDomains = [
+        { name: 'ethaga.ai', tokenId: '0x1a2b3c', owner: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e', registrar: 'D3 Registrar', price: 45000, volume: 120000 },
+        { name: 'ethaga.io', tokenId: '0x4d5e6f', owner: '0x9A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f', registrar: 'D3 Registrar', price: 22000, volume: 80000 },
+        { name: 'ethaga.com', tokenId: '0x7g8h9i', owner: '0x5A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f', registrar: 'D3 Registrar', price: 78000, volume: 210000 },
+        { name: 'ethaga.ape', tokenId: '0x9j0k1l', owner: '0x3A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f', registrar: 'D3 Registrar', price: 8000, volume: 25000 },
+        { name: 'domalabs.xyz', tokenId: '0xabcd01', owner: '0x1A0b865f29FE8e667a1F7589eE1a9e9C5E6b2f2f', registrar: 'D3 Registrar', price: 12000, volume: 42000 }
+      ]
+
+      return {
+        volume: base,
+        transactions: txCount,
+        uniqueUsers: 1450,
+        averagePrice: avg,
+        floorPrice: floor,
+        topDomains,
+        recentTransactions
+      }
+    }
+  }
 }
diff --git a/lib/doma-smart-contracts.ts b/lib/doma-smart-contracts.ts
index 949f58e..28722eb 100644
--- a/lib/doma-smart-contracts.ts
+++ b/lib/doma-smart-contracts.ts
@@ -1,26 +1,33 @@
 import Web3 from 'web3'
 import { AbiItem } from 'web3-utils'
 
-// Doma Protocol Smart Contract Addresses on Sepolia testnet
+// Doma Protocol Smart Contract Addresses (deployed testnet values)
 export const DOMA_SMART_CONTRACTS = {
-  DOMA_RECORD: '0x742d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
-  DOMA_FORWARDER: '0x123d35Cc6634C0532925a3b8D4C9db96C4b5Da5e', 
-  DOMA_GATEWAY: '0x456d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
-  DOMA_RECORD_PROXY: '0x789d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
-  OWNERSHIP_TOKEN: '0xabcd35Cc6634C0532925a3b8D4C9db96C4b5Da5e'
+  // Primary Doma Record contract (Doma Testnet)
+  DOMA_RECORD: '0xb1508299A01c02aC3B70c7A8B0B07105aaB29E99',
+  // EIP-2771 Trusted Forwarder (if applicable)
+  DOMA_FORWARDER: '0x8420729Dc9eBb5a30dBa8CEe1392F56bfc03b1F5',
+  // Cross-chain Gateway deployed on testnets
+  DOMA_GATEWAY: '0xa40aA710F0C77DF3De6CEe7493d1FfF3715D59Da',
+  // Proxy Record used on tokenization chains
+  DOMA_RECORD_PROXY: '0xb1508299A01c02aC3B70c7A8B0B07105aaB29E99',
+  // Ownership token (ERC-721) deployed on Doma Testnet
+  OWNERSHIP_TOKEN: '0x797293E811f9C5eFa1973004B581E46d1787F929'
 }
 
+const DOMA_USE_SIMULATION = process.env.NEXT_PUBLIC_DOMA_SIMULATION_ONLY === 'true'
+
 // Doma testnet chain configuration
 export const DOMA_CHAIN_CONFIG = {
-  chainId: '0xaa36a7', // Sepolia testnet (11155111)
-  chainName: 'Doma Testnet (Sepolia)',
+  chainId: '0x17cc4',
+  chainName: 'Doma Network',
   nativeCurrency: {
-    name: 'Ethereum',
+    name: 'ETH',
     symbol: 'ETH',
     decimals: 18
   },
-  rpcUrls: ['https://sepolia.infura.io/v3/'],
-  blockExplorerUrls: ['https://sepolia.etherscan.io']
+  rpcUrls: ['https://rpc-testnet.doma.xyz'],
+  blockExplorerUrls: ['https://explorer-testnet.doma.xyz']
 }
 
 // Structs and Interfaces
@@ -307,24 +314,58 @@ export class DomaSmartContractsService {
   private web3: Web3
   private recordProxyContract: any
   private ownershipTokenContract: any
+  private initPromise: Promise<void> | null = null
+
+  private static readonly EIP1967_IMPLEMENTATION_SLOT = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc'
 
   constructor(provider?: any) {
     if (provider) {
       this.web3 = new Web3(provider)
     } else {
-      // Fallback to Sepolia RPC
-      this.web3 = new Web3('https://sepolia.infura.io/v3/your-project-id')
+      // Fallback to Doma Network RPC
+      this.web3 = new Web3('https://rpc-testnet.doma.xyz')
     }
+  }
 
-    this.recordProxyContract = new this.web3.eth.Contract(
-      DOMA_RECORD_PROXY_ABI,
-      DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY
-    )
-    
-    this.ownershipTokenContract = new this.web3.eth.Contract(
-      OWNERSHIP_TOKEN_ABI,
-      DOMA_SMART_CONTRACTS.OWNERSHIP_TOKEN
-    )
+  private async init(): Promise<void> {
+    if (this.initPromise) return this.initPromise
+    this.initPromise = (async () => {
+      // Resolve addresses from env or Smart Contracts API
+      let recordProxy = (process.env.NEXT_PUBLIC_DOMA_RECORD_PROXY || '').trim()
+      let ownershipToken = (process.env.NEXT_PUBLIC_OWNERSHIP_TOKEN || '').trim()
+
+      if (!recordProxy || !ownershipToken) {
+        try {
+          const base = 'https://api-testnet.doma.xyz/v1/smart-contracts'
+          const res = await fetch(base, {
+            headers: {
+              'Authorization': `Bearer ${process.env.NEXT_PUBLIC_DOMA_API_KEY || ''}`
+            }
+          })
+          if (res.ok) {
+            const data = await res.json()
+            const contracts: Array<{ name: string; address: string }> = data.contracts || []
+            const rec = contracts.find(c => /record/i.test(c.name) && /proxy/i.test(c.name))
+            const own = contracts.find(c => /ownership/i.test(c.name) || /erc\s*-?721/i.test(c.name))
+            if (rec?.address) recordProxy = rec.address
+            if (own?.address) ownershipToken = own.address
+          }
+        } catch {}
+      }
+
+      const rp = recordProxy || DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY
+      const ot = ownershipToken || DOMA_SMART_CONTRACTS.OWNERSHIP_TOKEN
+
+      this.recordProxyContract = new this.web3.eth.Contract(
+        DOMA_RECORD_PROXY_ABI,
+        rp
+      )
+      this.ownershipTokenContract = new this.web3.eth.Contract(
+        OWNERSHIP_TOKEN_ABI,
+        ot
+      )
+    })()
+    return this.initPromise
   }
 
   // Request tokenization of domains
@@ -334,17 +375,47 @@ export class DomaSmartContractsService {
     fromAddress: string
   ): Promise<TokenizationResult> {
     try {
+      await this.init()
       console.log('[DomaSmartContracts] Requesting tokenization:', voucher)
 
+      if (DOMA_USE_SIMULATION) {
+        await new Promise(r => setTimeout(r, 500))
+        return {
+          success: true,
+          transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}`,
+          correlationId: `corr_${Date.now()}`
+        }
+      }
+
+      // Web3 4.x requires tuple args as arrays in ABI order
+      const voucherArg = [
+        voucher.names.map(n => [n.sld, n.tld, BigInt(n.registrarIanaId)]),
+        BigInt(voucher.nonce),
+        BigInt(voucher.expiresAt),
+        voucher.ownerAddress
+      ]
+
+      const currentChainId = await this.web3.eth.getChainId()
+      if (currentChainId !== 97476) {
+        const switched = await this.switchToDomaTestnet()
+        if (!switched) {
+          return { success: false, error: 'WRONG_NETWORK' }
+        }
+      }
+      const deployed = await this.isProxyOrImplDeployed(DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY)
+      if (!deployed) {
+        return { success: false, error: 'CONTRACT_NOT_DEPLOYED' }
+      }
       const gasEstimate = await this.recordProxyContract.methods
-        .requestTokenization(voucher, signature)
-        .estimateGas({ from: fromAddress })
+        .requestTokenization(voucherArg, signature)
+        .estimateGas({ from: fromAddress, value: '0x0' })
 
       const transaction = await this.recordProxyContract.methods
-        .requestTokenization(voucher, signature)
+        .requestTokenization(voucherArg, signature)
         .send({
           from: fromAddress,
-          gas: Math.floor(gasEstimate * 1.2), // Add 20% buffer
+          gas: Math.floor(Number(gasEstimate) * 1.2),
+          value: '0x0'
         })
 
       return {
@@ -353,10 +424,10 @@ export class DomaSmartContractsService {
         correlationId: `corr_${Date.now()}`
       }
     } catch (error) {
-      console.error('[DomaSmartContracts] Tokenization failed:', error)
+      const msg = (error as any)?.message || (error as any)?.reason || (error as any)?.data?.message || 'Tokenization failed'
       return {
         success: false,
-        error: error instanceof Error ? error.message : 'Tokenization failed'
+        error: msg
       }
     }
   }
@@ -370,17 +441,45 @@ export class DomaSmartContractsService {
     fromAddress: string
   ): Promise<ClaimResult> {
     try {
+      await this.init()
       console.log('[DomaSmartContracts] Claiming ownership:', { tokenId, isSynthetic })
 
+      if (DOMA_USE_SIMULATION) {
+        await new Promise(r => setTimeout(r, 400))
+        return {
+          success: true,
+          transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}`
+        }
+      }
+
+      const pocArg = [
+        BigInt(proofOfContactsVoucher.registrantHandle),
+        Number(proofOfContactsVoucher.proofSource ?? 2),
+        BigInt(proofOfContactsVoucher.nonce),
+        BigInt(proofOfContactsVoucher.expiresAt),
+      ]
+
+      const currentChainId = await this.web3.eth.getChainId()
+      if (currentChainId !== 97476) {
+        const switched = await this.switchToDomaTestnet()
+        if (!switched) {
+          return { success: false, error: 'WRONG_NETWORK' }
+        }
+      }
+      const deployed = await this.isProxyOrImplDeployed(DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY)
+      if (!deployed) {
+        return { success: false, error: 'CONTRACT_NOT_DEPLOYED' }
+      }
       const gasEstimate = await this.recordProxyContract.methods
-        .claimOwnership(tokenId, isSynthetic, proofOfContactsVoucher, signature)
-        .estimateGas({ from: fromAddress })
+        .claimOwnership(BigInt(tokenId), isSynthetic, pocArg, signature)
+        .estimateGas({ from: fromAddress, value: '0x0' })
 
       const transaction = await this.recordProxyContract.methods
-        .claimOwnership(tokenId, isSynthetic, proofOfContactsVoucher, signature)
+        .claimOwnership(BigInt(tokenId), isSynthetic, pocArg, signature)
         .send({
           from: fromAddress,
-          gas: Math.floor(gasEstimate * 1.2),
+          gas: Math.floor(Number(gasEstimate) * 1.2),
+          value: '0x0'
         })
 
       return {
@@ -388,10 +487,10 @@ export class DomaSmartContractsService {
         transactionHash: transaction.transactionHash
       }
     } catch (error) {
-      console.error('[DomaSmartContracts] Claim ownership failed:', error)
+      const msg = (error as any)?.message || (error as any)?.reason || (error as any)?.data?.message || 'Claim ownership failed'
       return {
         success: false,
-        error: error instanceof Error ? error.message : 'Claim ownership failed'
+        error: msg
       }
     }
   }
@@ -405,12 +504,33 @@ export class DomaSmartContractsService {
     fromAddress: string
   ): Promise<BridgeResult> {
     try {
+      await this.init()
       console.log('[DomaSmartContracts] Bridging token:', {
         tokenId,
         targetChainId,
         targetOwnerAddress
       })
 
+      if (DOMA_USE_SIMULATION) {
+        await new Promise(r => setTimeout(r, 400))
+        return {
+          success: true,
+          transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}`,
+          targetChainId
+        }
+      }
+
+      const currentChainId = await this.web3.eth.getChainId()
+      if (currentChainId !== 97476) {
+        const switched = await this.switchToDomaTestnet()
+        if (!switched) {
+          return { success: false, error: 'WRONG_NETWORK' }
+        }
+      }
+      const deployed = await this.isProxyOrImplDeployed(DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY)
+      if (!deployed) {
+        return { success: false, error: 'CONTRACT_NOT_DEPLOYED' }
+      }
       const gasEstimate = await this.recordProxyContract.methods
         .bridge(tokenId, isSynthetic, targetChainId, targetOwnerAddress)
         .estimateGas({ from: fromAddress })
@@ -428,10 +548,10 @@ export class DomaSmartContractsService {
         targetChainId
       }
     } catch (error) {
-      console.error('[DomaSmartContracts] Bridge failed:', error)
+      const msg = (error as any)?.message || (error as any)?.reason || (error as any)?.data?.message || 'Bridge failed'
       return {
         success: false,
-        error: error instanceof Error ? error.message : 'Bridge failed'
+        error: msg
       }
     }
   }
@@ -443,8 +563,28 @@ export class DomaSmartContractsService {
     fromAddress: string
   ): Promise<DetokenizationResult> {
     try {
+      await this.init()
       console.log('[DomaSmartContracts] Requesting detokenization:', tokenId)
 
+      if (DOMA_USE_SIMULATION) {
+        await new Promise(r => setTimeout(r, 400))
+        return {
+          success: true,
+          transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}`
+        }
+      }
+
+      const currentChainId = await this.web3.eth.getChainId()
+      if (currentChainId !== 97476) {
+        const switched = await this.switchToDomaTestnet()
+        if (!switched) {
+          return { success: false, error: 'WRONG_NETWORK' }
+        }
+      }
+      const deployed = await this.isProxyOrImplDeployed(DOMA_SMART_CONTRACTS.DOMA_RECORD_PROXY)
+      if (!deployed) {
+        return { success: false, error: 'CONTRACT_NOT_DEPLOYED' }
+      }
       const gasEstimate = await this.recordProxyContract.methods
         .requestDetokenization(tokenId, isSynthetic)
         .estimateGas({ from: fromAddress })
@@ -461,92 +601,181 @@ export class DomaSmartContractsService {
         transactionHash: transaction.transactionHash
       }
     } catch (error) {
-      console.error('[DomaSmartContracts] Detokenization failed:', error)
+      const msg = (error as any)?.message || (error as any)?.reason || (error as any)?.data?.message || 'Detokenization failed'
       return {
         success: false,
-        error: error instanceof Error ? error.message : 'Detokenization failed'
+        error: msg
       }
     }
   }
 
   // Get domain assets for a wallet with Doma-specific information
   async getDomainAssets(walletAddress: string): Promise<DomaDomainAsset[]> {
+    const simulatedFallback = [
+      {
+        tokenId: "1",
+        name: "ethaga.ai",
+        sld: "ethaga",
+        tld: "ai",
+        owner: walletAddress,
+        registrarIanaId: 1,
+        expirationDate: "2027-07-04T00:00:00Z",
+        isActive: true,
+        isTransferLocked: false,
+        isSynthetic: false,
+        tokenizedValue: "0.5"
+      },
+      {
+        tokenId: "2",
+        name: "ethaga.io",
+        sld: "ethaga",
+        tld: "io",
+        owner: walletAddress,
+        registrarIanaId: 1,
+        expirationDate: "2026-07-04T00:00:00Z",
+        isActive: true,
+        isTransferLocked: false,
+        isSynthetic: false,
+        tokenizedValue: "0.3"
+      }
+    ]
+
     try {
-      const balance = await this.ownershipTokenContract.methods.balanceOf(walletAddress).call()
+      await this.init()
+
+      // Ensure contract instance exists and code deployed
+      if (!this.ownershipTokenContract) {
+        console.warn('[DomaSmartContracts] ownershipTokenContract not initialized, returning fallback')
+        return simulatedFallback
+      }
+
+      const contractAddress = this.ownershipTokenContract.options.address
+      try {
+        const code = await this.web3.eth.getCode(contractAddress)
+        if (!code || code === '0x' || code === '0x0') {
+          console.warn('[DomaSmartContracts] ownership token contract has no code at', contractAddress)
+          return simulatedFallback
+        }
+      } catch (codeErr) {
+        console.warn('[DomaSmartContracts] Failed to fetch contract code:', codeErr)
+        return simulatedFallback
+      }
+
+      // Balance may revert if contract ABI mismatch; catch and fallback
+      let balance = 0
+      try {
+        balance = parseInt(await this.ownershipTokenContract.methods.balanceOf(walletAddress).call())
+      } catch (balErr: any) {
+        console.warn('[DomaSmartContracts] balanceOf failed:', balErr?.message || balErr)
+        // Try to decode revert reason if available
+        const data = balErr?.data || balErr?.response?.data
+        if (data) console.warn('[DomaSmartContracts] balanceOf revert data:', data)
+        return simulatedFallback
+      }
+
+      if (!balance || balance <= 0) return []
+
       const domains: DomaDomainAsset[] = []
 
       for (let i = 0; i < balance; i++) {
         try {
-          const tokenId = await this.ownershipTokenContract.methods
-            .tokenOfOwnerByIndex(walletAddress, i).call()
-          
-          const [expirationDate, registrarIanaId, isTransferLocked] = await Promise.all([
-            this.ownershipTokenContract.methods.expirationOf(tokenId).call(),
-            this.ownershipTokenContract.methods.registrarOf(tokenId).call(),
-            this.ownershipTokenContract.methods.lockStatusOf(tokenId).call()
-          ])
-
-          // Parse domain name from token URI or metadata
-          const tokenURI = await this.ownershipTokenContract.methods.tokenURI(tokenId).call()
+          // tokenOfOwnerByIndex may not be implemented; guard each call
+          let tokenId: any
+          try {
+            tokenId = await this.ownershipTokenContract.methods.tokenOfOwnerByIndex(walletAddress, i).call()
+          } catch (indexErr) {
+            console.warn('[DomaSmartContracts] tokenOfOwnerByIndex not available or failed:', indexErr)
+            // Can't enumerate tokens; fallback to simulated result
+            return simulatedFallback
+          }
+
+          // Collect optional fields with individual try/catch to avoid aborting entire flow
+          let expirationDateRaw: any = null
+          let registrarIanaIdRaw: any = null
+          let isTransferLockedRaw: any = null
+          try {
+            expirationDateRaw = await this.ownershipTokenContract.methods.expirationOf(tokenId).call()
+          } catch (e) {
+            // expirationOf may not exist on all implementations
+            expirationDateRaw = null
+          }
+          try {
+            registrarIanaIdRaw = await this.ownershipTokenContract.methods.registrarOf(tokenId).call()
+          } catch (e) {
+            registrarIanaIdRaw = null
+          }
+          try {
+            isTransferLockedRaw = await this.ownershipTokenContract.methods.lockStatusOf(tokenId).call()
+          } catch (e) {
+            isTransferLockedRaw = false
+          }
+
+          // tokenURI is standard in ERC721, but guard it too
+          let tokenURI = ''
+          try {
+            tokenURI = await this.ownershipTokenContract.methods.tokenURI(tokenId).call()
+          } catch (e) {
+            tokenURI = ''
+          }
+
           const { sld, tld, name } = this.parseDomainFromTokenURI(tokenURI, tokenId)
 
+          const expirationDate = expirationDateRaw ? new Date(parseInt(expirationDateRaw) * 1000).toISOString() : new Date(Date.now() + 365 * 24 * 3600_000).toISOString()
+
           domains.push({
             tokenId: tokenId.toString(),
             name,
             sld,
             tld,
             owner: walletAddress,
-            registrarIanaId: parseInt(registrarIanaId),
-            expirationDate: new Date(parseInt(expirationDate) * 1000).toISOString(),
-            isActive: Date.now() < parseInt(expirationDate) * 1000,
-            isTransferLocked,
-            isSynthetic: false, // Would need additional contract call to determine
-            tokenizedValue: "0.5" // Would calculate from market data
+            registrarIanaId: registrarIanaIdRaw ? parseInt(registrarIanaIdRaw) : 0,
+            expirationDate,
+            isActive: expirationDateRaw ? Date.now() < parseInt(expirationDateRaw) * 1000 : true,
+            isTransferLocked: !!isTransferLockedRaw,
+            isSynthetic: false,
+            tokenizedValue: "0.5"
           })
-        } catch (tokenError) {
-          console.warn('[DomaSmartContracts] Error fetching token:', tokenError)
+        } catch (tokenErr) {
+          console.warn('[DomaSmartContracts] Error fetching token:', tokenErr)
+          // Continue to next token rather than failing completely
+          continue
         }
       }
 
       return domains
-    } catch (error) {
+    } catch (error: any) {
+      // Provide clearer logs for ContractExecutionError and revert data
       console.error('[DomaSmartContracts] Error fetching domain assets:', error)
-      
-      // Return simulated data for demo
-      return [
-        {
-          tokenId: "1",
-          name: "ethaga.ai",
-          sld: "ethaga",
-          tld: "ai",
-          owner: walletAddress,
-          registrarIanaId: 1,
-          expirationDate: "2027-07-04T00:00:00Z",
-          isActive: true,
-          isTransferLocked: false,
-          isSynthetic: false,
-          tokenizedValue: "0.5"
-        },
-        {
-          tokenId: "2",
-          name: "ethaga.io",
-          sld: "ethaga", 
-          tld: "io",
-          owner: walletAddress,
-          registrarIanaId: 1,
-          expirationDate: "2026-07-04T00:00:00Z",
-          isActive: true,
-          isTransferLocked: false,
-          isSynthetic: false,
-          tokenizedValue: "0.3"
+      const errData = error?.data || error?.error?.data || error?.error?.response?.data || null
+      if (errData) console.error('[DomaSmartContracts] Raw error data:', errData)
+
+      // Try to decode common solidity revert reason: Error(string) selector 0x08c379a0
+      try {
+        const hex = typeof errData === 'string' ? errData : (errData?.result || errData?.data || '')
+        if (hex && hex.startsWith && hex.startsWith('0x08c379a0')) {
+          try {
+            const reason = this.web3.eth.abi.decodeParameter('string', '0x' + hex.slice(10))
+            console.error('[DomaSmartContracts] Revert reason decoded:', reason)
+          } catch (decodeErr) {
+            console.error('[DomaSmartContracts] Failed to decode revert reason:', decodeErr)
+          }
+        } else if (hex === '0x' || hex === '0x0' || String(error?.message || '').includes('ContractExecutionError')) {
+          console.error('[DomaSmartContracts] Contract call reverted with empty data — likely ABI mismatch, wrong contract address, or call to non-existent method. Returning fallback data.')
+        } else if (hex) {
+          console.warn('[DomaSmartContracts] Revert data present but unknown selector. This may be a custom error. Hex prefix:', typeof hex === 'string' ? hex.slice(0, 10) : hex)
         }
-      ]
+      } catch (e) {
+        console.error('[DomaSmartContracts] Error while attempting to decode revert data:', e)
+      }
+
+      return simulatedFallback
     }
   }
 
   // Subscribe to Doma-specific events
   async subscribeToEvents(walletAddress: string, callback: (event: any) => void): Promise<void> {
     try {
+      await this.init()
       // Subscribe to OwnershipTokenMinted events
       this.ownershipTokenContract.events.OwnershipTokenMinted({
         filter: { to: walletAddress }
@@ -617,7 +846,7 @@ export class DomaSmartContractsService {
   async isConnectedToDomaTestnet(): Promise<boolean> {
     try {
       const chainId = await this.web3.eth.getChainId()
-      return chainId === 11155111 // Sepolia testnet
+      return chainId === 97476
     } catch (error) {
       console.error('[DomaSmartContracts] Error checking chain:', error)
       return false
@@ -627,19 +856,58 @@ export class DomaSmartContractsService {
   // Switch to Doma testnet
   async switchToDomaTestnet(): Promise<boolean> {
     try {
-      if (typeof window !== 'undefined' && window.ethereum) {
-        await window.ethereum.request({
+      if (typeof window === 'undefined') return false
+      const provider = (window as any).ethereum || (window as any).okxwallet
+      if (!provider) return false
+      try {
+        await provider.request({
           method: 'wallet_switchEthereumChain',
           params: [{ chainId: DOMA_CHAIN_CONFIG.chainId }],
         })
         return true
+      } catch (switchErr: any) {
+        if (switchErr?.code === 4902 || /unrecognized|not added/i.test(String(switchErr?.message || ''))) {
+          try {
+            await provider.request({
+              method: 'wallet_addEthereumChain',
+              params: [{
+                chainId: DOMA_CHAIN_CONFIG.chainId,
+                chainName: DOMA_CHAIN_CONFIG.chainName,
+                nativeCurrency: DOMA_CHAIN_CONFIG.nativeCurrency,
+                rpcUrls: DOMA_CHAIN_CONFIG.rpcUrls,
+                blockExplorerUrls: DOMA_CHAIN_CONFIG.blockExplorerUrls,
+              }],
+            })
+            return true
+          } catch (addErr) {
+            console.error('[DomaSmartContracts] Add chain failed:', addErr)
+            return false
+          }
+        }
+        console.error('[DomaSmartContracts] Switch network failed:', switchErr)
+        return false
       }
-      return false
     } catch (error) {
       console.error('[DomaSmartContracts] Error switching network:', error)
       return false
     }
   }
+  private async isProxyOrImplDeployed(address: string): Promise<boolean> {
+    try {
+      const code = await this.web3.eth.getCode(address)
+      if (code && code !== '0x' && code !== '0x0') return true
+      const slot = DomaSmartContractsService.EIP1967_IMPLEMENTATION_SLOT
+      const implRaw = await this.web3.eth.getStorageAt(address, slot)
+      if (implRaw && implRaw !== '0x' && implRaw !== '0x0') {
+        const impl = '0x' + implRaw.slice(-40)
+        const implCode = await this.web3.eth.getCode(impl)
+        return !!implCode && implCode !== '0x' && implCode !== '0x0'
+      }
+      return false
+    } catch {
+      return false
+    }
+  }
 }
 
 // Factory function to create service instance
diff --git a/lib/wallet-utils.ts b/lib/wallet-utils.ts
index 3dab942..b06e2c6 100644
--- a/lib/wallet-utils.ts
+++ b/lib/wallet-utils.ts
@@ -7,10 +7,11 @@ export interface WalletProvider {
   switchNetwork: (chainId: string) => Promise<void>
 }
 
+import { DOMA_CHAIN_CONFIG } from './doma-smart-contracts'
+
 export const detectWallets = (): WalletProvider[] => {
   const wallets: WalletProvider[] = []
 
-  // MetaMask detection
   if (typeof window !== "undefined" && window.ethereum && !window.ethereum.isOkxWallet) {
     wallets.push({
       name: "MetaMask",
@@ -19,19 +20,33 @@ export const detectWallets = (): WalletProvider[] => {
       connect: async () => {
         return await window.ethereum.request({ method: "eth_requestAccounts" })
       },
-      disconnect: async () => {
-        // MetaMask doesn't have a disconnect method
-      },
+      disconnect: async () => {},
       switchNetwork: async (chainId: string) => {
-        await window.ethereum.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId }],
-        })
+        try {
+          await window.ethereum.request({
+            method: "wallet_switchEthereumChain",
+            params: [{ chainId }],
+          })
+        } catch (err: any) {
+          if (err?.code === 4902) {
+            await window.ethereum.request({
+              method: "wallet_addEthereumChain",
+              params: [{
+                chainId: DOMA_CHAIN_CONFIG.chainId,
+                chainName: DOMA_CHAIN_CONFIG.chainName,
+                nativeCurrency: DOMA_CHAIN_CONFIG.nativeCurrency,
+                rpcUrls: DOMA_CHAIN_CONFIG.rpcUrls,
+                blockExplorerUrls: DOMA_CHAIN_CONFIG.blockExplorerUrls,
+              }],
+            })
+          } else {
+            throw err
+          }
+        }
       },
     })
   }
 
-  // OKX Wallet detection
   if (typeof window !== "undefined" && window.okxwallet) {
     wallets.push({
       name: "OKX Wallet",
@@ -40,14 +55,29 @@ export const detectWallets = (): WalletProvider[] => {
       connect: async () => {
         return await window.okxwallet.request({ method: "eth_requestAccounts" })
       },
-      disconnect: async () => {
-        // OKX Wallet disconnect logic
-      },
+      disconnect: async () => {},
       switchNetwork: async (chainId: string) => {
-        await window.okxwallet.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId }],
-        })
+        try {
+          await window.okxwallet.request({
+            method: "wallet_switchEthereumChain",
+            params: [{ chainId }],
+          })
+        } catch (err: any) {
+          if (err?.code === 4902) {
+            await window.okxwallet.request({
+              method: "wallet_addEthereumChain",
+              params: [{
+                chainId: DOMA_CHAIN_CONFIG.chainId,
+                chainName: DOMA_CHAIN_CONFIG.chainName,
+                nativeCurrency: DOMA_CHAIN_CONFIG.nativeCurrency,
+                rpcUrls: DOMA_CHAIN_CONFIG.rpcUrls,
+                blockExplorerUrls: DOMA_CHAIN_CONFIG.blockExplorerUrls,
+              }],
+            })
+          } else {
+            throw err
+          }
+        }
       },
     })
   }
diff --git a/lib/web3-utils.ts b/lib/web3-utils.ts
index 3f848e3..6461a3f 100644
--- a/lib/web3-utils.ts
+++ b/lib/web3-utils.ts
@@ -10,12 +10,14 @@ import {
   DOMA_CHAIN_CONFIG
 } from './doma-smart-contracts'
 
+const DOMA_USE_SIMULATION = process.env.NEXT_PUBLIC_DOMA_SIMULATION_ONLY === 'true'
+
 // Legacy contract addresses (kept for backward compatibility)
 export const DOMA_CONTRACTS = {
   DOMA_DOMAIN_REGISTRY: DOMA_SMART_CONTRACTS.DOMA_RECORD,
-  DOMA_DID_REGISTRY: '0x123d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
-  DOMA_TOKEN: '0x456d35Cc6634C0532925a3b8D4C9db96C4b5Da5e',
-  DOMA_MARKETPLACE: '0x789d35Cc6634C0532925a3b8D4C9db96C4b5Da5e'
+  DOMA_DID_REGISTRY: '0x123d35cc6634c0532925a3b8d4c9db96c4b5da5e',
+  DOMA_TOKEN: '0x456d35cc6634c0532925a3b8d4c9db96c4b5da5e',
+  DOMA_MARKETPLACE: '0x789d35cc6634c0532925a3b8d4c9db96c4b5da5e'
 }
 
 // Use Doma chain configuration from smart contracts module
@@ -162,8 +164,8 @@ export class DomaWeb3Service {
     if (provider) {
       this.web3 = new Web3(provider)
     } else {
-      // Fallback to Sepolia RPC
-      this.web3 = new Web3('https://sepolia.infura.io/v3/your-project-id')
+      // Fallback to Doma Network RPC
+      this.web3 = new Web3('https://rpc-testnet.doma.xyz')
     }
 
     // Initialize Doma Smart Contracts service
@@ -190,9 +192,18 @@ export class DomaWeb3Service {
     walletAddress: string
   ): Promise<{ success: boolean; transactionHash?: string; error?: string }> {
     try {
+      if (DOMA_USE_SIMULATION) {
+        return { success: true, transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}` }
+      }
       // Create tokenization voucher
       const names = domains.map(domain => {
-        const [sld, tld] = domain.split('.')
+        const dn = (domain || '').trim().toLowerCase()
+        const parts = dn.split('.')
+        const sld = parts[0]
+        const tld = parts.slice(1).join('.')
+        if (!sld || !tld) {
+          throw new Error('Invalid domain format. Use sld.tld (e.g., example.com)')
+        }
         return {
           sld,
           tld,
@@ -202,8 +213,18 @@ export class DomaWeb3Service {
 
       const voucher = DomaVoucherUtils.createTokenizationVoucher(names, walletAddress)
 
-      // In production, this signature would come from the registrar
-      const signature = "0x" + "0".repeat(130) // Placeholder signature
+      // In production, this signature must come from a sponsoring Registrar
+      const signature = "0x" + "0".repeat(130) // Placeholder
+
+      // Safety: prevent sending a zero-signature to on-chain contract unless explicitly allowed
+      const allowUnsigned = process.env.NEXT_PUBLIC_ALLOW_UNSIGNED_TOKENIZATION === 'true'
+      if (!allowUnsigned) {
+        // Provide actionable error so callers can fallback to API or simulation
+        return {
+          success: false,
+          error: 'REGISTRAR_SIGNATURE_REQUIRED: Tokenization requires a registrar-signed voucher. Enable API fallback (NEXT_PUBLIC_DOMA_API_FALLBACK=true) or set NEXT_PUBLIC_ALLOW_UNSIGNED_TOKENIZATION=true for local testing.'
+        }
+      }
 
       const result = await this.domaSmartContracts.requestTokenization(
         voucher,
@@ -229,6 +250,9 @@ export class DomaWeb3Service {
     walletAddress: string
   ): Promise<{ success: boolean; transactionHash?: string; error?: string }> {
     try {
+      if (DOMA_USE_SIMULATION) {
+        return { success: true, transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}` }
+      }
       const proofOfContactsVoucher = DomaVoucherUtils.createProofOfContactsVoucher(
         Date.now() // registrant handle
       )
@@ -264,6 +288,9 @@ export class DomaWeb3Service {
     walletAddress: string
   ): Promise<{ success: boolean; transactionHash?: string; error?: string }> {
     try {
+      if (DOMA_USE_SIMULATION) {
+        return { success: true, transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}` }
+      }
       const result = await this.domaSmartContracts.bridge(
         tokenId,
         false, // isSynthetic
@@ -290,6 +317,9 @@ export class DomaWeb3Service {
     walletAddress: string
   ): Promise<{ success: boolean; transactionHash?: string; error?: string }> {
     try {
+      if (DOMA_USE_SIMULATION) {
+        return { success: true, transactionHash: `0x${Math.random().toString(16).slice(2).padEnd(64, '0')}` }
+      }
       const result = await this.domaSmartContracts.requestDetokenization(
         tokenId,
         false, // isSynthetic