feat: add Web3 integration and enhance browser functionality (#78)

- Add web3-injection.js for Web3 provider injection into webpages
- Implement LiquidWebView for Web3-enabled browsing
- Add NativeWebBrowserView with enhanced browser features
- Create EnhancedSafariNavigationBar for improved navigation
- Update Web3MessageHandler for wallet interactions
- Enhance WebBrowserView with Web3 capabilities
- Improve WebNavigationBar and WebViewTransition
- Add WebPage model for better state management
- Remove deprecated WebSearchOverlay component

This enables Web3 dApp interactions directly within the app
with seamless wallet integration.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: ardaerturk <ardaerturk@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: ardaerturk

Interspace/Models/WebPage.swift

@@ -0,0 +1,110 @@
+import Foundation
+import Combine
+import WebKit
+
+// MARK: - WebPage
+/// Observable model for managing web page state and navigation
+/// Implements iOS 26 WebPage pattern for SwiftUI integration
+class WebPage: ObservableObject {
+    // MARK: - Published Properties
+    
+    @Published var url: URL?
+    @Published var title: String = ""
+    @Published var isLoading: Bool = false
+    @Published var estimatedProgress: Double = 0.0
+    @Published var canGoBack: Bool = false
+    @Published var canGoForward: Bool = false
+    @Published var error: Error?
+    
+    // MARK: - Navigation Actions
+    
+    var onLoadRequest: ((URLRequest) -> Void)?
+    var onLoadURL: ((URL) -> Void)?
+    var onGoBack: (() -> Void)?
+    var onGoForward: (() -> Void)?
+    var onReload: (() -> Void)?
+    var onStopLoading: (() -> Void)?
+    var onEvaluateJavaScript: ((String, @escaping (Any?, Error?) -> Void) -> Void)?
+    
+    // MARK: - Initialization
+    
+    init(url: URL? = nil) {
+        self.url = url
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Load a URL
+    func load(_ url: URL) {
+        self.url = url
+        onLoadURL?(url)
+    }
+    
+    /// Load a URL request
+    func load(_ request: URLRequest) {
+        self.url = request.url
+        onLoadRequest?(request)
+    }
+    
+    /// Navigate back
+    func goBack() {
+        onGoBack?()
+    }
+    
+    /// Navigate forward
+    func goForward() {
+        onGoForward?()
+    }
+    
+    /// Reload the current page
+    func reload() {
+        onReload?()
+    }
+    
+    /// Stop loading the current page
+    func stopLoading() {
+        onStopLoading?()
+    }
+    
+    /// Execute JavaScript on the page
+    func evaluateJavaScript(_ script: String, completion: @escaping (Any?, Error?) -> Void) {
+        onEvaluateJavaScript?(script, completion)
+    }
+    
+    /// Reset error state
+    func clearError() {
+        error = nil
+    }
+}
+
+// MARK: - WebPage Extensions for iOS 26
+extension WebPage {
+    /// Create a web page for a bookmarked app
+    static func from(app: BookmarkedApp) -> WebPage {
+        guard let appURL = URL(string: app.url) else {
+            return WebPage()
+        }
+        return WebPage(url: appURL)
+    }
+    
+    /// Check if the page is secure (HTTPS)
+    var isSecure: Bool {
+        url?.scheme == "https"
+    }
+    
+    /// Get the host name for display
+    var displayHost: String {
+        url?.host ?? ""
+    }
+    
+    /// Get a short display title
+    var displayTitle: String {
+        if !title.isEmpty {
+            return title
+        } else if let host = url?.host {
+            return host
+        } else {
+            return "New Page"
+        }
+    }
+}

Interspace/Resources/web3-injection.js

@@ -0,0 +1,193 @@
+// Interspace Web3 Provider Injection Script
+(function() {
+    'use strict';
+    
+    // Check if already injected
+    if (window.ethereum && window.ethereum.isInterspace) {
+        console.log('Interspace Web3 provider already injected');
+        return;
+    }
+    
+    // Create message handler
+    function sendMessage(type, data) {
+        if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.interspaceWeb3) {
+            window.webkit.messageHandlers.interspaceWeb3.postMessage({
+                type: type,
+                ...data
+            });
+        }
+    }
+    
+    // Response handler
+    let responseHandlers = {};
+    let requestId = 0;
+    
+    window.__handleInterspaceMessage = function(response) {
+        if (response.type === 'web3_response' && responseHandlers[response.id]) {
+            const handler = responseHandlers[response.id];
+            delete responseHandlers[response.id];
+            
+            if (response.error) {
+                handler.reject(new Error(response.error.message || 'Unknown error'));
+            } else {
+                handler.resolve(response.result);
+            }
+        } else if (response.type === 'initial_state') {
+            // Handle initial state
+            if (response.result) {
+                ethereum._chainId = response.result.chainId;
+                ethereum._accounts = response.result.accounts || [];
+                ethereum._isConnected = response.result.isConnected || false;
+                
+                // Emit connect event if connected
+                if (ethereum._isConnected && ethereum._accounts.length > 0) {
+                    ethereum.emit('connect', { chainId: ethereum._chainId });
+                    ethereum.emit('accountsChanged', ethereum._accounts);
+                }
+            }
+        } else if (response.type === 'web3_event') {
+            // Handle events
+            ethereum.emit(response.event, response.data);
+        }
+    };
+    
+    // Event emitter
+    class EventEmitter {
+        constructor() {
+            this.events = {};
+        }
+        
+        on(event, callback) {
+            if (!this.events[event]) {
+                this.events[event] = [];
+            }
+            this.events[event].push(callback);
+            return this;
+        }
+        
+        once(event, callback) {
+            const onceWrapper = (...args) => {
+                callback(...args);
+                this.removeListener(event, onceWrapper);
+            };
+            return this.on(event, onceWrapper);
+        }
+        
+        removeListener(event, callback) {
+            if (this.events[event]) {
+                this.events[event] = this.events[event].filter(cb => cb !== callback);
+            }
+            return this;
+        }
+        
+        emit(event, ...args) {
+            if (this.events[event]) {
+                this.events[event].forEach(callback => {
+                    try {
+                        callback(...args);
+                    } catch (error) {
+                        console.error('Event handler error:', error);
+                    }
+                });
+            }
+        }
+    }
+    
+    // Ethereum provider
+    class InterspaceProvider extends EventEmitter {
+        constructor() {
+            super();
+            this.isInterspace = true;
+            this.isMetaMask = true; // For compatibility
+            this._chainId = '0x1';
+            this._accounts = [];
+            this._isConnected = false;
+            
+            // Request initial state
+            sendMessage('get_initial_state', {});
+        }
+        
+        isConnected() {
+            return this._isConnected;
+        }
+        
+        async request(args) {
+            if (!args || typeof args !== 'object' || typeof args.method !== 'string') {
+                throw new Error('Invalid request');
+            }
+            
+            const id = ++requestId;
+            
+            return new Promise((resolve, reject) => {
+                responseHandlers[id] = { resolve, reject };
+                
+                // Send request to native
+                sendMessage('web3_request', {
+                    id: id,
+                    method: args.method,
+                    params: args.params || []
+                });
+                
+                // Timeout after 60 seconds
+                setTimeout(() => {
+                    if (responseHandlers[id]) {
+                        delete responseHandlers[id];
+                        reject(new Error('Request timeout'));
+                    }
+                }, 60000);
+            });
+        }
+        
+        // Legacy methods for compatibility
+        async enable() {
+            return this.request({ method: 'eth_requestAccounts' });
+        }
+        
+        async send(method, params = []) {
+            return this.request({ method, params });
+        }
+        
+        sendAsync(payload, callback) {
+            this.request({
+                method: payload.method,
+                params: payload.params
+            }).then(result => {
+                callback(null, {
+                    id: payload.id,
+                    jsonrpc: '2.0',
+                    result
+                });
+            }).catch(error => {
+                callback(error, null);
+            });
+        }
+    }
+    
+    // Create and inject provider
+    const ethereum = new InterspaceProvider();
+    
+    // Define as non-configurable to prevent overwriting
+    Object.defineProperty(window, 'ethereum', {
+        value: ethereum,
+        writable: false,
+        configurable: false
+    });
+    
+    // For compatibility with older dApps
+    window.web3 = {
+        currentProvider: ethereum,
+        eth: {
+            accounts: ethereum._accounts
+        }
+    };
+    
+    // Notify that injection is complete
+    sendMessage('injection_complete', {
+        url: window.location.href
+    });
+    
+    console.log('✅ Interspace Web3 provider injected successfully');
+    
+    // Dispatch ethereum provider event
+    window.dispatchEvent(new Event('ethereum#initialized'));
+})();