@sudobility/contracts 0.14.0 → 1.9.0

package/dist/unified-esm/src/unified/onchain-mailer-client.js

@@ -1,157 +1,226 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - Suppress false TypeScript errors with ESNext modules accessing class properties
 import { ChainType } from '@sudobility/types';
+import { WalletDetector } from './wallet-detector.js';
 /**
- * OnchainMailerClient v2 - Refactored to use standard wallet libraries
+ * OnchainMailerClient - Multi-chain messaging client for Mailer protocol
  *
- * This version removes the UnifiedWallet abstraction and instead accepts
- * standard wallet clients from wagmi (EVM) or wallet-adapter (Solana).
+ * This class provides a unified interface for interacting with Mailer contracts
+ * across different blockchain networks (EVM and Solana). It automatically detects
+ * wallet types and routes operations to the appropriate chain implementation.
  *
- * @example EVM Usage with wagmi
+ * @example Basic Usage
  * ```typescript
- * import { createWalletClient, createPublicClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
+ * // EVM wallet (MetaMask, etc.)
+ * const evmWallet = window.ethereum;
+ * const evmConfig = {
+ *   evm: {
+ *     rpc: 'https://eth-mainnet.alchemyapi.io/v2/your-key',
+ *     chainId: 1,
+ *     contracts: {
+ *       mailer: '0x456...',
+ *       usdc: '0x789...'
+ *     }
+ *   }
+ * };
+ * const evmClient = new OnchainMailerClient(evmWallet, evmConfig);
  *
- * const walletClient = createWalletClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- * const publicClient = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * });
+ * // Solana wallet (Phantom, etc.)
+ * const solanaWallet = window.solana;
+ * const solanaConfig = {
+ *   solana: {
+ *     rpc: 'https://api.mainnet-beta.solana.com',
+ *     programs: {
+ *       mailer: '9FLkBDGpZBcR8LMsQ7MwwV6X9P4TDFgN3DeRh5qYyHJF'
+ *     },
+ *     usdcMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
+ *   }
+ * };
+ * const solanaClient = new OnchainMailerClient(solanaWallet, solanaConfig);
  *
- * const client = OnchainMailerClient.forEVM(
- *   walletClient,
- *   publicClient,
- *   '0xMailerContractAddress',
- *   '0xUSDCAddress'
- * );
+ * // Send messages
+ * const result = await client.sendMessage("Hello", "World!", false);
+ * console.log('Transaction:', result.transactionHash);
  * ```
  *
- * @example Solana Usage with wallet-adapter
+ * @example Error Handling
  * ```typescript
- * import { useWallet } from '@solana/wallet-adapter-react';
- * import { Connection } from '@solana/web3.js';
- *
- * const wallet = useWallet();
- * const connection = new Connection('https://api.mainnet-beta.solana.com');
- *
- * const client = OnchainMailerClient.forSolana(
- *   wallet,
- *   connection,
- *   'MailerProgramId',
- *   'USDCMintAddress'
- * );
+ * try {
+ *   const result = await client.sendMessage("Subject", "Body", true);
+ *   console.log('Success:', result);
+ * } catch (error) {
+ *   if (error.message.includes('insufficient funds')) {
+ *     console.log('User needs more USDC');
+ *   } else if (error.message.includes('user rejected')) {
+ *     console.log('User cancelled transaction');
+ *   } else {
+ *     console.log('Unknown error:', error);
+ *   }
+ * }
  * ```
+ *
+ * @author Mailer Protocol Team
+ * @version 1.5.2
+ * @since 1.0.0
  */
 export class OnchainMailerClient {
     /**
-     * Create an OnchainMailerClient for EVM chains using wagmi clients
+     * Initialize OnchainMailerClient with wallet and chain configuration
      *
-     * @param walletClient - wagmi WalletClient for signing transactions
-     * @param publicClient - wagmi PublicClient for reading chain data
-     * @param mailerAddress - Deployed Mailer contract address
-     * @param usdcAddress - USDC token contract address
-     * @returns Configured OnchainMailerClient for EVM
-     */
-    static forEVM(walletClient, publicClient, mailerAddress, usdcAddress) {
-        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
-        client.chainType = ChainType.EVM;
-        client.evmWalletClient = walletClient;
-        client.evmPublicClient = publicClient;
-        client.evmContractAddress = mailerAddress;
-        client.evmUsdcAddress = usdcAddress;
-        return client;
-    }
-    /**
-     * Create an OnchainMailerClient for Solana using wallet-adapter
+     * @param wallet - Wallet instance (EVM or Solana compatible)
+     * @param config - Chain configuration for EVM and/or Solana networks
      *
-     * @param wallet - Solana wallet adapter
-     * @param connection - Solana connection
-     * @param programId - Deployed Mailer program ID
-     * @param usdcMint - USDC mint address
-     * @returns Configured OnchainMailerClient for Solana
-     */
-    static forSolana(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    wallet, // Wallet adapter interface
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    connection, // Connection
-    programId, usdcMint) {
-        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
-        client.chainType = ChainType.SOLANA;
-        client.solanaWallet = wallet;
-        client.solanaConnection = connection;
-        client.solanaProgramId = programId;
-        client.solanaUsdcMint = usdcMint;
-        return client;
-    }
-    /**
-     * Create an OnchainMailerClient from a generic config (backward compatibility)
-     * This constructor is provided for backward compatibility with React provider
+     * @throws {Error} When wallet type cannot be detected
+     * @throws {Error} When required configuration is missing
+     * @throws {Error} When wallet doesn't implement required methods
+     *
+     * @example
+     * ```typescript
+     * // EVM wallet initialization
+     * const wallet = window.ethereum;
+     * const config = {
+     *   evm: { rpc: '...', chainId: 1, contracts: {...} }
+     * };
+     * const client = new OnchainMailerClient(wallet, config);
+     * ```
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(wallet, config) {
-        // Simple chain detection based on wallet properties
-        const hasEthereumProperties = wallet && (wallet.address || wallet.request || wallet.selectedAddress);
-        const hasSolanaProperties = wallet && wallet.publicKey && typeof wallet.signTransaction === 'function';
-        if (hasEthereumProperties) {
-            this.chainType = ChainType.EVM;
-            if (config.evm) {
-                // Store config for lazy initialization
-                this.evmContractAddress = config.evm.contracts.mailer;
-                this.evmUsdcAddress = config.evm.contracts.usdc;
-                // Wallet and public clients will be created on first use
-                // Store raw wallet for backward compatibility
-                // @ts-ignore
-                this._rawEvmWallet = wallet;
-            }
-            else {
-                throw new Error('EVM configuration required for EVM wallet');
-            }
-        }
-        else if (hasSolanaProperties) {
-            this.chainType = ChainType.SOLANA;
-            if (config.solana) {
-                this.solanaWallet = wallet;
-                // Connection will be created on first use
-                this.solanaProgramId = config.solana.programs.mailer;
-                this.solanaUsdcMint = config.solana.usdcMint;
-            }
-            else {
-                throw new Error('Solana configuration required for Solana wallet');
+        try {
+            // Automatically detect whether this is an EVM or Solana wallet
+            this.chainType = WalletDetector.detectWalletType(wallet);
+            // Normalize wallet interface for internal use
+            this.wallet = {
+                address: wallet.address || wallet.publicKey?.toString() || '',
+                chainType: this.chainType,
+                signTransaction: wallet.signTransaction?.bind(wallet),
+                publicKey: wallet.publicKey?.toString()
+            };
+            this.config = config;
+            // Ensure we have valid configuration for the detected chain type
+            this.validateConfiguration();
+            // Ensure wallet implements required methods for its chain type
+            this.validateWallet(wallet);
+        }
+        catch (error) {
+            throw new Error(`OnchainMailerClient initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    validateConfiguration() {
+        if (this.chainType === 'evm' && !this.config.evm) {
+            throw new Error('EVM configuration required for EVM wallet');
+        }
+        if (this.chainType === 'solana' && !this.config.solana) {
+            throw new Error('Solana configuration required for Solana wallet');
+        }
+        // Validate EVM configuration
+        if (this.config.evm) {
+            if (!this.config.evm.rpc || !this.config.evm.chainId) {
+                throw new Error('EVM configuration missing required fields (rpc, chainId)');
+            }
+            if (!this.config.evm.contracts || !this.config.evm.contracts.mailer) {
+                console.warn('EVM contract addresses not configured - some functionality may fail');
             }
         }
-        else {
-            throw new Error('Unable to detect wallet type from provided wallet object');
+        // Validate Solana configuration  
+        if (this.config.solana) {
+            if (!this.config.solana.rpc || !this.config.solana.usdcMint) {
+                throw new Error('Solana configuration missing required fields (rpc, usdcMint)');
+            }
+            if (!this.config.solana.programs || !this.config.solana.programs.mailer) {
+                console.warn('Solana program addresses not configured - some functionality may fail');
+            }
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    validateWallet(wallet) {
+        if (!wallet.signTransaction && typeof wallet.signTransaction !== 'function') {
+            throw new Error('Wallet must have signTransaction method');
+        }
+        if (this.chainType === 'evm' && !wallet.address) {
+            throw new Error('EVM wallet must have address property');
+        }
+        if (this.chainType === 'solana' && !wallet.publicKey) {
+            throw new Error('Solana wallet must have publicKey property');
         }
     }
     /**
      * Send a message using the appropriate chain implementation
-     * Note: For backward compatibility, 'to' defaults to sender's own address
+     *
+     * This method automatically routes to EVM or Solana based on the detected wallet type.
+     * Priority messages cost more but include revenue sharing for recipients.
+     *
+     * @param subject - Message subject (1-200 characters)
+     * @param body - Message body (1-10000 characters)
+     * @param priority - Whether to use priority sending with revenue share
+     *                   - Priority: Full fee paid, 90% claimable by recipient
+     *                   - Standard: 10% fee only, no revenue share
+     * @param resolveSenderToName - If true, resolve sender address to name via off-chain service
+     *
+     * @returns Promise resolving to MessageResult with transaction details
+     *
+     * @throws {Error} When subject/body validation fails
+     * @throws {Error} When insufficient USDC balance
+     * @throws {Error} When user rejects transaction
+     * @throws {Error} When network connection fails
+     *
+     * @example Standard Message
+     * ```typescript
+     * const result = await client.sendMessage(
+     *   "Meeting Reminder",
+     *   "Don't forget our 3pm call today!",
+     *   false, // Standard fee (10% of sendFee)
+     *   false  // Don't resolve sender to name
+     * );
+     * console.log('Sent in tx:', result.transactionHash);
+     * ```
+     *
+     * @example Priority Message with Revenue Share
+     * ```typescript
+     * const result = await client.sendMessage(
+     *   "Important Update",
+     *   "Urgent: Please review the attached proposal",
+     *   true, // Priority fee (100% paid, 90% claimable by recipient)
+     *   true  // Resolve sender to name
+     * );
+     * console.log('Priority message fee:', result.fee);
+     * ```
      */
-    async sendMessage(subject, body, priority = false, resolveSenderToName = false, to) {
-        // For backward compatibility, default to sending to self
-        const recipient = to || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
-            return this.sendEVMMessage(recipient, subject, body, priority, resolveSenderToName);
+    async sendMessage(subject, body, priority = false, resolveSenderToName = false) {
+        // Route to appropriate chain implementation based on wallet type
+        if (this.chainType === 'evm') {
+            return this.sendEVMMessage(subject, body, priority, resolveSenderToName);
         }
         else {
-            return this.sendSolanaMessage(recipient, subject, body, priority, resolveSenderToName);
+            return this.sendSolanaMessage(subject, body, priority, resolveSenderToName);
         }
     }
     /**
-     * Register a domain (not implemented - for backward compatibility)
+     * Register a domain using the appropriate chain implementation
+     * @param domain - Domain name to register
+     * @param isExtension - Whether this is extending an existing domain
+     * @returns Domain registration result
      */
-    async registerDomain(_domain) {
-        throw new Error('Domain registration not yet implemented');
+    async registerDomain(domain, isExtension = false) {
+        if (this.chainType === 'evm') {
+            return this.registerEVMDomain(domain, isExtension);
+        }
+        else {
+            return this.registerSolanaDomain(domain, isExtension);
+        }
     }
     /**
-     * Delegate to another address
+     * Delegate to another address using the appropriate chain implementation
+     * @param delegate - Address to delegate to
+     * @returns Delegation result
      */
     async delegateTo(delegate) {
-        if (this.chainType === ChainType.EVM) {
+        // Validate delegate address format
+        const delegateChainType = WalletDetector.detectChainFromAddress(delegate);
+        if (delegateChainType !== this.chainType) {
+            throw new Error(`Delegate address format doesn't match wallet chain type (${this.chainType})`);
+        }
+        if (this.chainType === 'evm') {
             return this.delegateEVM(delegate);
         }
         else {
@@ -159,10 +228,11 @@ export class OnchainMailerClient {
         }
     }
     /**
-     * Claim revenue share
+     * Claim revenue share using the appropriate chain implementation
+     * @returns Transaction result
      */
     async claimRevenue() {
-        if (this.chainType === ChainType.EVM) {
+        if (this.chainType === 'evm') {
             return this.claimEVMRevenue();
         }
         else {
@@ -172,799 +242,1385 @@ export class OnchainMailerClient {
     // Performance optimization: cache module imports
     async getEVMModules() {
         if (!OnchainMailerClient.evmModules) {
-            const evmModule = await import('../evm/index.js');
-            OnchainMailerClient.evmModules = {
-                MailerClient: evmModule.MailerClient
-            };
+            try {
+                const [viemModule, evmModule] = await Promise.all([
+                    import('viem'),
+                    import('../evm')
+                ]);
+                OnchainMailerClient.evmModules = {
+                    viem: viemModule,
+                    MailerClient: evmModule.MailerClient
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to load EVM modules: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         return OnchainMailerClient.evmModules;
     }
     async getSolanaModules() {
         if (!OnchainMailerClient.solanaModules) {
-            const [solanaModule, web3Module] = await Promise.all([
-                import('../solana/index.js'),
-                import('@solana/web3.js')
-            ]);
-            OnchainMailerClient.solanaModules = {
-                MailerClient: solanaModule.MailerClient,
-                PublicKey: web3Module.PublicKey,
-                Connection: web3Module.Connection
-            };
+            try {
+                const [solanaModule, web3Module] = await Promise.all([
+                    import('../solana'),
+                    import('@solana/web3.js')
+                ]);
+                OnchainMailerClient.solanaModules = {
+                    MailerClient: solanaModule.MailerClient,
+                    PublicKey: web3Module.PublicKey,
+                    Connection: web3Module.Connection
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to load Solana modules: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         return OnchainMailerClient.solanaModules;
     }
-    // EVM implementation methods
-    async sendEVMMessage(to, subject, body, priority, resolveSenderToName) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        // Validate message
-        if (!subject || subject.length > 200) {
-            throw new Error('Subject must be 1-200 characters');
+    // Private methods for EVM implementation
+    async sendEVMMessage(subject, body, priority, resolveSenderToName = false) {
+        try {
+            const { viem, MailerClient } = await this.getEVMModules();
+            if (!this.config.evm) {
+                throw new Error('EVM configuration not provided');
+            }
+            if (!this.config.evm.contracts.mailer) {
+                throw new Error('EVM Mailer contract address not configured');
+            }
+            // Create clients
+            const publicClient = viem.createPublicClient({
+                transport: viem.http(this.config.evm.rpc),
+                chain: {
+                    id: this.config.evm.chainId,
+                    name: 'Custom Chain',
+                    nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                    rpcUrls: {
+                        default: { http: [this.config.evm.rpc] }
+                    }
+                }
+            });
+            const walletClient = viem.createWalletClient({
+                transport: viem.http(this.config.evm.rpc),
+                chain: {
+                    id: this.config.evm.chainId,
+                    name: 'Custom Chain',
+                    nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                    rpcUrls: {
+                        default: { http: [this.config.evm.rpc] }
+                    }
+                }
+            });
+            // Test connection
+            try {
+                await Promise.race([
+                    publicClient.getChainId(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 10000))
+                ]);
+            }
+            catch (error) {
+                throw new Error(`Failed to connect to EVM network: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+            // Validate message before sending
+            if (!subject || subject.length > 200) {
+                throw new Error('Subject must be 1-200 characters');
+            }
+            if (!body || body.length > 10000) {
+                throw new Error('Body must be 1-10000 characters');
+            }
+            let txHash;
+            try {
+                txHash = await client.send(this.wallet.address, subject, body, priority, resolveSenderToName, walletClient, this.wallet.address);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('insufficient funds')) {
+                    throw new Error('Insufficient USDC balance to send message');
+                }
+                if (errorMessage.includes('user rejected')) {
+                    throw new Error('Transaction rejected by user');
+                }
+                throw new Error(`Transaction failed: ${errorMessage}`);
+            }
+            // Wait for confirmation with timeout
+            const receipt = await Promise.race([
+                publicClient.waitForTransactionReceipt({ hash: txHash }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Transaction confirmation timeout')), 60000))
+            ]);
+            return {
+                transactionHash: txHash,
+                chainType: ChainType.EVM,
+                messageId: undefined, // Could extract from logs if needed
+                fee: BigInt(priority ? '100000' : '10000'), // 0.1 or 0.01 USDC in micro-USDC
+                gasUsed: receipt.gasUsed,
+                isPriority: priority,
+                success: true
+            };
         }
-        if (!body || body.length > 10000) {
-            throw new Error('Body must be 1-10000 characters');
+        catch (error) {
+            throw new Error(`EVM message sending failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.send(to, subject, body, payer, priority, resolveSenderToName, this.evmWalletClient, account);
-        // Convert to MessageResult format
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            fee: BigInt(priority ? '100000' : '10000'),
-            gasUsed: result.gasUsed,
-            isPriority: priority,
-            success: true
-        };
+    }
+    async registerEVMDomain(_domain, _isExtension) {
+        // Domain registration not implemented in current EVM version (delegation-only)
+        throw new Error('Domain registration not yet implemented in EVM version - use delegation instead');
     }
     async delegateEVM(delegate) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+        const { viem } = await this.getEVMModules();
+        if (!this.config.evm) {
+            throw new Error('EVM configuration not provided');
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.delegateTo(delegate, this.evmWalletClient, account);
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            delegate,
-            success: true
-        };
+        // Validate EVM address format
+        if (!viem.isAddress(delegate)) {
+            throw new Error('Invalid EVM address format for delegate');
+        }
+        // Note: Domain functionality is now integrated into the Mailer contract
+        throw new Error('Domain delegation is now handled through the Mailer contract - use MailerClient instead');
     }
     async claimEVMRevenue() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimRecipientShare(this.evmWalletClient, account);
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm) {
+            throw new Error('EVM configuration not provided');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.claimRecipientShare(walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            hash: result.hash,
+            hash: txHash,
             chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    // Solana implementation methods
-    async sendSolanaMessage(to, subject, body, priority, resolveSenderToName) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.send(to, subject, body, priority, resolveSenderToName);
-        // Get current fees
-        const fees = await client.getFees();
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: priority ? fees.sendFee : fees.sendFee / 10,
-            isPriority: priority,
-            success: true
-        };
+    // Private methods for Solana implementation
+    async sendSolanaMessage(subject, body, priority, resolveSenderToName = false) {
+        try {
+            const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+            if (!this.config.solana) {
+                throw new Error('Solana configuration not provided');
+            }
+            if (!this.config.solana.programs.mailer) {
+                throw new Error('Solana Mailer program address not configured');
+            }
+            const connection = new Connection(this.config.solana.rpc, 'confirmed');
+            // Test connection
+            try {
+                await Promise.race([
+                    connection.getSlot(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 10000))
+                ]);
+            }
+            catch (error) {
+                throw new Error(`Failed to connect to Solana RPC: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            // Create wallet adapter for native client  
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const wallet = MailerClient.createWallet(this.wallet);
+            const programId = new PublicKey(this.config.solana.programs.mailer);
+            const usdcMint = new PublicKey(this.config.solana.usdcMint);
+            // For now, send to the wallet itself (self-messaging)
+            const recipientKey = new PublicKey(this.wallet.address);
+            const client = new MailerClient(connection, wallet, programId, usdcMint);
+            // Get current fees
+            const fees = await client.getFees();
+            let txHash;
+            txHash = await client.send(recipientKey.toBase58(), subject, body, priority, resolveSenderToName);
+            // Get transaction details
+            const tx = await connection.getTransaction(txHash, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
+            // Get current slot for transaction info
+            const slot = await connection.getSlot();
+            return {
+                transactionHash: txHash,
+                chainType: ChainType.SOLANA,
+                fee: priority ? fees.sendFee : fees.sendFee / 10,
+                recipient: recipientKey.toBase58(),
+                subject,
+                body,
+                slot,
+                timestamp: tx?.blockTime ? tx.blockTime * 1000 : Date.now(),
+                isPriority: priority,
+                success: true
+            };
+        }
+        catch (error) {
+            throw new Error(`Solana message sending failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async registerSolanaDomain(_domain, _isExtension) {
+        // Domain registration not implemented in current Solana version
+        throw new Error('Domain registration not yet implemented in Solana version - use delegation instead');
     }
-    async delegateSolana(delegate) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
+    async delegateSolana(_delegate) {
+        if (!this.config.solana) {
+            throw new Error('Solana configuration not provided');
         }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.delegateTo(delegate);
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            delegate,
-            success: true
-        };
+        // Note: Domain functionality is now integrated into the Mailer contract
+        throw new Error('Domain delegation is now handled through the Mailer contract - use MailerClient instead');
     }
     async claimSolanaRevenue() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimRecipientShare();
-        const slot = await this.solanaConnection.getSlot();
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana) {
+            throw new Error('Solana configuration not provided');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.claimRecipientShare();
+        const slot = await connection.getSlot();
         return {
-            hash: result.signature,
+            hash: txHash,
             chainType: ChainType.SOLANA,
             slot,
             timestamp: Date.now()
         };
     }
-    // Read methods
+    /**
+     * Get send fee using the appropriate chain implementation
+     * @returns Send fee in USDC micro-units (6 decimals)
+     */
     async getSendFee() {
-        if (this.chainType === ChainType.EVM) {
+        if (this.chainType === 'evm') {
             return this.getEVMSendFee();
         }
         else {
             return this.getSolanaSendFee();
         }
     }
-    async getEVMSendFee() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getSendFee();
-    }
-    async getSolanaSendFee() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        // Create a minimal wallet object for reading
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const fees = await client.getFees();
-        return BigInt(fees.sendFee);
-    }
-    // Additional read methods
+    /**
+     * Get claimable amount for an address
+     * @param address - Address to check claimable balance for (defaults to connected wallet)
+     * @returns Claimable amount in USDC micro-units
+     */
     async getClaimableAmount(address) {
-        const targetAddress = address || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
+        const targetAddress = address || this.wallet.address;
+        if (this.chainType === 'evm') {
             return this.getEVMClaimableAmount(targetAddress);
         }
         else {
             return this.getSolanaClaimableAmount(targetAddress);
         }
     }
-    async getEVMClaimableAmount(address) {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const result = await client.getRecipientClaimable(address);
-        return result.amount;
-    }
-    async getSolanaClaimableAmount(address) {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const recipientKey = new PublicKey(address);
-        const claimInfo = await client.getRecipientClaimable(recipientKey);
-        return claimInfo ? BigInt(claimInfo.amount) : 0n;
-    }
+    /**
+     * Get owner's claimable fee balance
+     * @returns Owner claimable amount in USDC micro-units
+     */
     async getOwnerClaimable() {
-        if (this.chainType === ChainType.EVM) {
+        if (this.chainType === 'evm') {
             return this.getEVMOwnerClaimable();
         }
         else {
             return this.getSolanaOwnerClaimable();
         }
     }
-    async getEVMOwnerClaimable() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getOwnerClaimable();
-    }
-    async getSolanaOwnerClaimable() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const amount = await client.getOwnerClaimable();
-        return BigInt(amount);
-    }
+    /**
+     * Get delegation information for an address
+     * @param address - Address to check delegation for (defaults to connected wallet)
+     * @returns Delegation address or null if no delegation
+     */
     async getDelegation(address) {
-        const targetAddress = address || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
+        const targetAddress = address || this.wallet.address;
+        if (this.chainType === 'evm') {
             return this.getEVMDelegation(targetAddress);
         }
         else {
             return this.getSolanaDelegation(targetAddress);
         }
     }
+    // EVM read methods
+    async getEVMSendFee() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        return client.getSendFee();
+    }
+    async getEVMClaimableAmount(address) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const result = await client.getRecipientClaimable(address);
+        return result.amount;
+    }
+    async getEVMOwnerClaimable() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        return client.getOwnerClaimable();
+    }
     async getEVMDelegation(_address) {
         // Delegation read not implemented in EVM client yet
+        // Would need to add getDelegation method to EVM MailerClient
         throw new Error('getDelegation not yet implemented for EVM');
     }
+    // Solana read methods
+    async getSolanaSendFee() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const fees = await client.getFees();
+        return BigInt(fees.sendFee);
+    }
+    async getSolanaClaimableAmount(address) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const recipientKey = new PublicKey(address);
+        const claimInfo = await client.getRecipientClaimable(recipientKey);
+        return claimInfo ? BigInt(claimInfo.amount) : 0n;
+    }
+    async getSolanaOwnerClaimable() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const amount = await client.getOwnerClaimable();
+        return BigInt(amount);
+    }
     async getSolanaDelegation(address) {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
         const delegatorKey = new PublicKey(address);
         const delegationInfo = await client.getDelegation(delegatorKey);
         return delegationInfo?.delegate || null;
     }
-    async getDelegationFee() {
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMDelegationFee();
+    /**
+     * Send a prepared message using mail ID (to match cross-chain behavior)
+     * @param to - Recipient address
+     * @param mailId - Pre-prepared message identifier
+     * @param priority - Whether to use priority sending with revenue share
+     * @param resolveSenderToName - If true, resolve sender address to name
+     * @returns Promise resolving to MessageResult
+     */
+    async sendPrepared(to, mailId, priority = false, resolveSenderToName = false) {
+        if (this.chainType === 'evm') {
+            return this.sendPreparedEVM(to, mailId, priority, resolveSenderToName);
         }
         else {
-            return this.getSolanaDelegationFee();
+            return this.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
         }
     }
-    async getEVMDelegationFee() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Send message to email address (no wallet known)
+     * @param toEmail - Email address of the recipient
+     * @param subject - Message subject
+     * @param body - Message body
+     * @returns Promise resolving to MessageResult
+     */
+    async sendToEmail(toEmail, subject, body) {
+        if (this.chainType === 'evm') {
+            return this.sendToEmailEVM(toEmail, subject, body);
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getDelegationFee();
-    }
-    async getSolanaDelegationFee() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
+        else {
+            return this.sendToEmailSolana(toEmail, subject, body);
         }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const fees = await client.getFees();
-        return BigInt(fees.delegationFee);
     }
-    async isPaused() {
-        if (this.chainType === ChainType.EVM) {
-            return this.isPausedEVM();
+    /**
+     * Send prepared message to email address (no wallet known)
+     * @param toEmail - Email address of the recipient
+     * @param mailId - Pre-prepared message identifier
+     * @returns Promise resolving to MessageResult
+     */
+    async sendPreparedToEmail(toEmail, mailId) {
+        if (this.chainType === 'evm') {
+            return this.sendPreparedToEmailEVM(toEmail, mailId);
         }
         else {
-            return this.isPausedSolana();
+            return this.sendPreparedToEmailSolana(toEmail, mailId);
         }
     }
-    async isPausedEVM() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Set the send fee (owner only)
+     * @param newFee - New fee amount in USDC micro-units (6 decimals)
+     * @returns Promise resolving to transaction details
+     */
+    async setFee(newFee) {
+        if (this.chainType === 'evm') {
+            return this.setFeeEVM(newFee);
+        }
+        else {
+            return this.setFeeSolana(newFee);
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.isPaused();
     }
-    async isPausedSolana() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        return client.isPaused();
+    /**
+     * Get the current send fee
+     * @returns Current send fee in USDC micro-units (6 decimals)
+     */
+    async getFee() {
+        return this.getSendFee();
     }
-    // Write methods for contract management
-    async unpause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.unpauseEVM();
+    /**
+     * Set the delegation fee (owner only)
+     * @param newFee - New delegation fee in USDC micro-units
+     * @returns Promise resolving to transaction details
+     */
+    async setDelegationFee(newFee) {
+        if (this.chainType === 'evm') {
+            return this.setDelegationFeeEVM(newFee);
         }
         else {
-            return this.unpauseSolana();
+            return this.setDelegationFeeSolana(newFee);
         }
     }
-    async unpauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Get the current delegation fee
+     * @returns Current delegation fee in USDC micro-units
+     */
+    async getDelegationFee() {
+        if (this.chainType === 'evm') {
+            return this.getDelegationFeeEVM();
+        }
+        else {
+            return this.getDelegationFeeSolana();
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.unpause(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
     }
-    async unpauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.unpause();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
+    /**
+     * Reject a delegation made to you by another address
+     * @param delegatorAddress - Address that delegated to you
+     * @returns Promise resolving to transaction details
+     */
+    async rejectDelegation(delegatorAddress) {
+        if (this.chainType === 'evm') {
+            return this.rejectDelegationEVM(delegatorAddress);
+        }
+        else {
+            return this.rejectDelegationSolana(delegatorAddress);
+        }
     }
-    async emergencyUnpause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.emergencyUnpauseEVM();
+    /**
+     * Claim owner share of fees (owner only)
+     * @returns Promise resolving to transaction details
+     */
+    async claimOwnerShare() {
+        if (this.chainType === 'evm') {
+            return this.claimOwnerShareEVM();
         }
         else {
-            return this.emergencyUnpauseSolana();
+            return this.claimOwnerShareSolana();
         }
     }
-    async emergencyUnpauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Claim expired shares (owner only, EVM only)
+     * @param recipient - Address to claim expired shares for
+     * @returns Promise resolving to transaction details
+     */
+    async claimExpiredShares(recipient) {
+        if (this.chainType === 'evm') {
+            return this.claimExpiredSharesEVM(recipient);
+        }
+        else {
+            throw new Error('claimExpiredShares not available on Solana');
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.emergencyUnpause(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
     }
-    async emergencyUnpauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.emergencyUnpause();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
+    /**
+     * Pause the contract and distribute funds (owner only)
+     * @returns Promise resolving to transaction details
+     */
+    async pause() {
+        if (this.chainType === 'evm') {
+            return this.pauseEVM();
+        }
+        else {
+            return this.pauseSolana();
+        }
     }
-    async distributeClaimableFunds(recipient) {
-        if (this.chainType === ChainType.EVM) {
-            return this.distributeClaimableFundsEVM(recipient);
+    /**
+     * Unpause the contract (owner only)
+     * @returns Promise resolving to transaction details
+     */
+    async unpause() {
+        if (this.chainType === 'evm') {
+            return this.unpauseEVM();
         }
         else {
-            return this.distributeClaimableFundsSolana(recipient);
+            return this.unpauseSolana();
         }
     }
-    async distributeClaimableFundsEVM(recipient) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Emergency unpause without fund distribution (owner only)
+     * @returns Promise resolving to transaction details
+     */
+    async emergencyUnpause() {
+        if (this.chainType === 'evm') {
+            return this.emergencyUnpauseEVM();
+        }
+        else {
+            return this.emergencyUnpauseSolana();
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.distributeClaimableFunds(recipient, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
     }
-    async distributeClaimableFundsSolana(recipient) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.distributeClaimableFunds(recipient);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
+    /**
+     * Check if contract is currently paused
+     * @returns True if contract is paused, false otherwise
+     */
+    async isPaused() {
+        if (this.chainType === 'evm') {
+            return this.isPausedEVM();
+        }
+        else {
+            return this.isPausedSolana();
+        }
     }
-    // Additional methods for complete API compatibility
-    async sendPrepared(to, mailId, priority = false, resolveSenderToName = false) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendPreparedEVM(to, mailId, priority, resolveSenderToName);
+    /**
+     * Distribute claimable funds to a recipient when contract is paused
+     * @param recipient - Address to distribute funds for
+     * @returns Promise resolving to transaction details
+     */
+    async distributeClaimableFunds(recipient) {
+        if (this.chainType === 'evm') {
+            return this.distributeClaimableFundsEVM(recipient);
         }
         else {
-            return this.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
+            return this.distributeClaimableFundsSolana(recipient);
         }
     }
+    // EVM Implementation Methods
     async sendPreparedEVM(to, mailId, priority, resolveSenderToName) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendPrepared(to, mailId, payer, priority, resolveSenderToName, this.evmWalletClient, account);
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.sendPrepared(to, mailId, priority, resolveSenderToName, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return {
-            transactionHash: result.hash,
+            transactionHash: txHash,
             chainType: ChainType.EVM,
             fee: BigInt(priority ? '100000' : '10000'),
-            gasUsed: result.gasUsed,
+            gasUsed: receipt.gasUsed,
             isPriority: priority,
             success: true
         };
     }
-    async sendPreparedSolana(to, mailId, priority, resolveSenderToName) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const recipientKey = new PublicKey(to);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendPrepared(recipientKey, mailId, priority, resolveSenderToName);
-        const fees = await client.getFees();
+    async sendToEmailEVM(toEmail, subject, body) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.sendToEmailAddress(toEmail, subject, body, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: priority ? fees.sendFee : fees.sendFee / 10,
-            isPriority: priority,
+            transactionHash: txHash,
+            chainType: ChainType.EVM,
+            fee: BigInt('10000'), // 10% fee only
+            gasUsed: receipt.gasUsed,
+            isPriority: false,
             success: true
         };
     }
-    async sendToEmail(toEmail, subject, body) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendToEmailEVM(toEmail, subject, body);
-        }
-        else {
-            return this.sendToEmailSolana(toEmail, subject, body);
-        }
-    }
-    async sendToEmailEVM(toEmail, subject, body) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendToEmailAddress(toEmail, subject, body, payer, this.evmWalletClient, account);
+    async sendPreparedToEmailEVM(toEmail, mailId) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.sendPreparedToEmailAddress(toEmail, mailId, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return {
-            transactionHash: result.hash,
+            transactionHash: txHash,
             chainType: ChainType.EVM,
             fee: BigInt('10000'), // 10% fee only
-            gasUsed: result.gasUsed,
+            gasUsed: receipt.gasUsed,
             isPriority: false,
             success: true
         };
     }
-    async sendToEmailSolana(toEmail, subject, body) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendToEmail(toEmail, subject, body);
-        const fees = await client.getFees();
+    async setFeeEVM(newFee) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.setFee(newFee, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: fees.sendFee / 10, // 10% fee only
-            isPriority: false,
-            success: true
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async sendPreparedToEmail(toEmail, mailId) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendPreparedToEmailEVM(toEmail, mailId);
-        }
-        else {
-            return this.sendPreparedToEmailSolana(toEmail, mailId);
-        }
+    async setDelegationFeeEVM(newFee) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.setDelegationFee(newFee, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
+        return {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
     }
-    async sendPreparedToEmailEVM(toEmail, mailId) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendPreparedToEmailAddress(toEmail, mailId, payer, this.evmWalletClient, account);
+    async getDelegationFeeEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        return client.getDelegationFee();
+    }
+    async rejectDelegationEVM(delegatorAddress) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.rejectDelegation(delegatorAddress, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            transactionHash: result.hash,
+            hash: txHash,
             chainType: ChainType.EVM,
-            fee: BigInt('10000'), // 10% fee only
-            gasUsed: result.gasUsed,
-            isPriority: false,
-            success: true
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async sendPreparedToEmailSolana(toEmail, mailId) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendPreparedToEmail(toEmail, mailId);
-        const fees = await client.getFees();
+    async claimOwnerShareEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.claimOwnerShare(walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: fees.sendFee / 10, // 10% fee only
-            isPriority: false,
-            success: true
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async claimOwnerShare() {
-        if (this.chainType === ChainType.EVM) {
-            return this.claimOwnerShareEVM();
-        }
-        else {
-            return this.claimOwnerShareSolana();
-        }
+    async claimExpiredSharesEVM(recipient) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.claimExpiredShares(recipient, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
+        return {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
     }
-    async claimOwnerShareEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimOwnerShare(this.evmWalletClient, account);
+    async pauseEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.pause(walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            hash: result.hash,
+            hash: txHash,
             chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async claimOwnerShareSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimOwnerShare();
-        const slot = await this.solanaConnection.getSlot();
+    async unpauseEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.unpause(walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async claimExpiredShares(recipient) {
-        if (this.chainType === ChainType.EVM) {
-            return this.claimExpiredSharesEVM(recipient);
-        }
-        else {
-            return this.claimExpiredSharesSolana(recipient);
-        }
+    async emergencyUnpauseEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.emergencyUnpause(walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
+        return {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
     }
-    async claimExpiredSharesEVM(recipient) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimExpiredShares(recipient, this.evmWalletClient, account);
+    async isPausedEVM() {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        return client.isPaused();
+    }
+    async distributeClaimableFundsEVM(recipient) {
+        const { viem, MailerClient } = await this.getEVMModules();
+        if (!this.config.evm?.contracts.mailer) {
+            throw new Error('EVM Mailer contract address not configured');
+        }
+        const publicClient = viem.createPublicClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const walletClient = viem.createWalletClient({
+            transport: viem.http(this.config.evm.rpc),
+            chain: {
+                id: this.config.evm.chainId,
+                name: 'Custom Chain',
+                nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+                rpcUrls: {
+                    default: { http: [this.config.evm.rpc] }
+                }
+            }
+        });
+        const client = new MailerClient(this.config.evm.contracts.mailer, publicClient);
+        const txHash = await client.distributeClaimableFunds(recipient, walletClient, this.wallet.address);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
         return {
-            hash: result.hash,
+            hash: txHash,
             chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
         };
     }
-    async claimExpiredSharesSolana(recipient) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const recipientKey = new PublicKey(recipient);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimExpiredShares(recipientKey);
-        const slot = await this.solanaConnection.getSlot();
+    // Solana Implementation Methods
+    async sendPreparedSolana(to, mailId, priority, resolveSenderToName) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const recipientKey = new PublicKey(to);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.sendPrepared(recipientKey, mailId, priority, resolveSenderToName);
+        const fees = await client.getFees();
+        const slot = await connection.getSlot();
+        const tx = await connection.getTransaction(txHash, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
         return {
-            hash: result.signature,
+            transactionHash: txHash,
             chainType: ChainType.SOLANA,
+            fee: priority ? fees.sendFee : fees.sendFee / 10,
             slot,
-            timestamp: Date.now()
+            timestamp: tx?.blockTime ? tx.blockTime * 1000 : Date.now(),
+            isPriority: priority,
+            success: true
         };
     }
-    async rejectDelegation(delegatorAddress) {
-        if (this.chainType === ChainType.EVM) {
-            return this.rejectDelegationEVM(delegatorAddress);
-        }
-        else {
-            return this.rejectDelegationSolana(delegatorAddress);
-        }
+    async sendToEmailSolana(toEmail, subject, body) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.sendToEmail(toEmail, subject, body);
+        const fees = await client.getFees();
+        const slot = await connection.getSlot();
+        const tx = await connection.getTransaction(txHash, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
+        return {
+            transactionHash: txHash,
+            chainType: ChainType.SOLANA,
+            fee: fees.sendFee / 10, // 10% fee only
+            slot,
+            timestamp: tx?.blockTime ? tx.blockTime * 1000 : Date.now(),
+            isPriority: false,
+            success: true
+        };
     }
-    async rejectDelegationEVM(delegatorAddress) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.rejectDelegation(delegatorAddress, this.evmWalletClient, account);
+    async sendPreparedToEmailSolana(toEmail, mailId) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.sendPreparedToEmail(toEmail, mailId);
+        const fees = await client.getFees();
+        const slot = await connection.getSlot();
+        const tx = await connection.getTransaction(txHash, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
         return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
+            transactionHash: txHash,
+            chainType: ChainType.SOLANA,
+            fee: fees.sendFee / 10, // 10% fee only
+            slot,
+            timestamp: tx?.blockTime ? tx.blockTime * 1000 : Date.now(),
+            isPriority: false,
+            success: true
+        };
+    }
+    async setFeeSolana(newFee) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.setFee(newFee);
+        const slot = await connection.getSlot();
+        return {
+            hash: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
             timestamp: Date.now()
         };
     }
-    async rejectDelegationSolana(delegatorAddress) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.rejectDelegation(delegatorAddress);
-        const slot = await this.solanaConnection.getSlot();
+    async setDelegationFeeSolana(newFee) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.setDelegationFee(newFee);
+        const slot = await connection.getSlot();
         return {
-            hash: result.signature,
+            hash: txHash,
             chainType: ChainType.SOLANA,
             slot,
             timestamp: Date.now()
         };
     }
-    async setFee(newFee) {
-        if (this.chainType === ChainType.EVM) {
-            return this.setFeeEVM(newFee);
-        }
-        else {
-            return this.setFeeSolana(newFee);
-        }
+    async getDelegationFeeSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const fees = await client.getFees();
+        return BigInt(fees.delegationFee);
     }
-    async setFeeEVM(newFee) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.setFee(newFee, this.evmWalletClient, account);
+    async rejectDelegationSolana(delegatorAddress) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.rejectDelegation(delegatorAddress);
+        const slot = await connection.getSlot();
         return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
+            hash: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
             timestamp: Date.now()
         };
     }
-    async setFeeSolana(newFee) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.setFee(newFee);
-        const slot = await this.solanaConnection.getSlot();
+    async claimOwnerShareSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.claimOwnerShare();
+        const slot = await connection.getSlot();
         return {
-            hash: result.signature,
+            hash: txHash,
             chainType: ChainType.SOLANA,
             slot,
             timestamp: Date.now()
         };
     }
-    async setDelegationFee(newFee) {
-        if (this.chainType === ChainType.EVM) {
-            return this.setDelegationFeeEVM(newFee);
-        }
-        else {
-            return this.setDelegationFeeSolana(newFee);
-        }
-    }
-    async setDelegationFeeEVM(newFee) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.setDelegationFee(newFee, this.evmWalletClient, account);
+    async pauseSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.pause();
+        const slot = await connection.getSlot();
         return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
+            hash: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
             timestamp: Date.now()
         };
     }
-    async setDelegationFeeSolana(newFee) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.setDelegationFee(newFee);
-        const slot = await this.solanaConnection.getSlot();
+    async unpauseSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.unpause();
+        const slot = await connection.getSlot();
         return {
-            hash: result.signature,
+            hash: txHash,
             chainType: ChainType.SOLANA,
             slot,
             timestamp: Date.now()
         };
     }
-    async pause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.pauseEVM();
-        }
-        else {
-            return this.pauseSolana();
-        }
-    }
-    async pauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.pause(this.evmWalletClient, account);
+    async emergencyUnpauseSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.emergencyUnpause();
+        const slot = await connection.getSlot();
         return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
+            hash: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
             timestamp: Date.now()
         };
     }
-    async pauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.pause();
-        const slot = await this.solanaConnection.getSlot();
+    async isPausedSolana() {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        return client.isPaused();
+    }
+    async distributeClaimableFundsSolana(recipient) {
+        const { MailerClient, PublicKey, Connection } = await this.getSolanaModules();
+        if (!this.config.solana?.programs.mailer) {
+            throw new Error('Solana Mailer program address not configured');
+        }
+        const connection = new Connection(this.config.solana.rpc, 'confirmed');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wallet = MailerClient.createWallet(this.wallet);
+        const programId = new PublicKey(this.config.solana.programs.mailer);
+        const usdcMint = new PublicKey(this.config.solana.usdcMint);
+        const client = new MailerClient(connection, wallet, programId, usdcMint);
+        const txHash = await client.distributeClaimableFunds(recipient);
+        const slot = await connection.getSlot();
         return {
-            hash: result.signature,
+            hash: txHash,
             chainType: ChainType.SOLANA,
             slot,
             timestamp: Date.now()
@@ -975,35 +1631,10 @@ export class OnchainMailerClient {
         return this.chainType;
     }
     getWalletAddress() {
-        if (this.chainType === ChainType.EVM) {
-            // Try to get address from raw wallet for backward compatibility
-            // @ts-ignore
-            if (this._rawEvmWallet) {
-                // @ts-ignore
-                return this._rawEvmWallet.address || this._rawEvmWallet.selectedAddress || '';
-            }
-            return ''; // Caller should use getWalletAddressAsync() for accurate address
-        }
-        else if (this.chainType === ChainType.SOLANA && this.solanaWallet) {
-            return this.solanaWallet.publicKey?.toString() || '';
-        }
-        return '';
-    }
-    /**
-     * Get wallet address asynchronously
-     */
-    async getWalletAddressAsync() {
-        if (this.chainType === ChainType.EVM && this.evmWalletClient) {
-            const [address] = await this.evmWalletClient.getAddresses();
-            return address;
-        }
-        else if (this.chainType === ChainType.SOLANA && this.solanaWallet) {
-            return this.solanaWallet.publicKey?.toString() || '';
-        }
-        throw new Error('Wallet not initialized');
+        return this.wallet.address;
     }
 }
-// Cache for dynamic imports
+// Performance optimization: cache imported modules
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 OnchainMailerClient.evmModules = null;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any