@sudobility/contracts 0.15.1 → 1.10.0

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

@@ -1,731 +1,1642 @@
 /* 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 - Stateless multi-chain messaging client
+ * OnchainMailerClient - Multi-chain messaging client for Mailer protocol
  *
- * This version uses stateless EVM and Solana clients underneath.
- * All wallet connections and chain information are passed as parameters to each method.
+ * 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
+ * @example Basic Usage
  * ```typescript
- * import { createWalletClient, createPublicClient, http } from 'viem';
- * import { RpcHelpers } from '@sudobility/configs';
- * import { Chain } from '@sudobility/types';
+ * // 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 chainInfo = RpcHelpers.getChainInfo(Chain.ETH_MAINNET);
- * const walletClient = createWalletClient({
- *   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 = new OnchainMailerClient();
- * await client.sendMessage(
- *   'Subject',
- *   'Body',
- *   { walletClient },
- *   chainInfo,
- *   { priority: true }
- * );
+ * // Send messages
+ * const result = await client.sendMessage("Hello", "World!", false);
+ * console.log('Transaction:', result.transactionHash);
  * ```
  *
- * @example Solana Usage
+ * @example Error Handling
  * ```typescript
- * import { useWallet } from '@solana/wallet-adapter-react';
- * import { Connection } from '@solana/web3.js';
- * import { RpcHelpers } from '@sudobility/configs';
- * import { Chain } from '@sudobility/types';
- *
- * const chainInfo = RpcHelpers.getChainInfo(Chain.SOLANA_MAINNET);
- * const wallet = useWallet();
- *
- * const client = new OnchainMailerClient();
- * await client.sendMessage(
- *   'Subject',
- *   'Body',
- *   { wallet },
- *   chainInfo,
- *   { priority: true }
- * );
+ * 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 a new stateless OnchainMailerClient
-     * No configuration needed in constructor
+     * Initialize OnchainMailerClient with wallet and chain configuration
+     *
+     * @param wallet - Wallet instance (EVM or Solana compatible)
+     * @param config - Chain configuration for EVM and/or Solana networks
+     *
+     * @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);
+     * ```
      */
-    constructor() {
-        // Stateless - no initialization needed
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(wallet, config) {
+        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)}`);
+        }
     }
-    // Performance optimization: cache client imports
-    async getEVMClient() {
-        if (!OnchainMailerClient.evmClient) {
-            const { EVMMailerClient } = await import('../evm/evm-mailer-client.js');
-            OnchainMailerClient.evmClient = new EVMMailerClient();
+    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');
+            }
+        }
+        // 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');
+            }
         }
-        return OnchainMailerClient.evmClient;
     }
-    async getSolanaClient() {
-        if (!OnchainMailerClient.solanaClient) {
-            const { SolanaMailerClient } = await import('../solana/solana-mailer-client.js');
-            OnchainMailerClient.solanaClient = new SolanaMailerClient();
+    // 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');
         }
-        return OnchainMailerClient.solanaClient;
     }
     /**
-     * Send a message on the blockchain
+     * Send a message using the appropriate chain implementation
+     *
+     * 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 wallet - Wallet connection (EVM or Solana)
-     * @param chainInfo - Chain information including RPC endpoints and contract addresses
-     * @param options - Optional parameters
-     * @returns Transaction result
+     * @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(connectedWallet, chainInfo, subject, body, options) {
-        // Validate message
-        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');
-        }
-        // Route to appropriate implementation based on chain type
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const evmWallet = connectedWallet;
-            const [account] = await evmWallet.walletClient.getAddresses();
-            const to = options?.to || account;
-            const priority = options?.priority ?? false;
-            const resolveSenderToName = options?.resolveSenderToName ?? false;
-            const result = await evmClient.send(evmWallet, chainInfo, to, subject, body, account, // payer
-            priority, // revenueShareToReceiver
-            resolveSenderToName, options?.gasOptions);
-            return {
-                transactionHash: result.hash,
-                chainType: ChainType.EVM,
-                fee: BigInt(priority ? '100000' : '10000'),
-                gasUsed: result.gasUsed,
-                isPriority: priority,
-                success: true
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const solanaWallet = connectedWallet;
-            const to = options?.to || solanaWallet.wallet.publicKey.toBase58();
-            const priority = options?.priority ?? false;
-            const result = await solanaClient.send(solanaWallet, chainInfo, to, subject, body, priority, // revenueShareToReceiver
-            options?.computeOptions);
-            return {
-                transactionHash: result.transactionHash,
-                chainType: ChainType.SOLANA,
-                fee: BigInt(priority ? '100000' : '10000'),
-                isPriority: priority,
-                success: true
-            };
+    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 {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.sendSolanaMessage(subject, body, priority, resolveSenderToName);
         }
     }
     /**
-     * Send a prepared message
+     * 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 sendPrepared(connectedWallet, chainInfo, to, mailId, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const evmWallet = connectedWallet;
-            const [account] = await evmWallet.walletClient.getAddresses();
-            const priority = options?.priority ?? false;
-            const resolveSenderToName = options?.resolveSenderToName ?? false;
-            const result = await evmClient.sendPrepared(evmWallet, chainInfo, to, mailId, account, // payer
-            priority, // revenueShareToReceiver
-            resolveSenderToName, options?.gasOptions);
-            return {
-                transactionHash: result.hash,
-                chainType: ChainType.EVM,
-                fee: BigInt(priority ? '100000' : '10000'),
-                gasUsed: result.gasUsed,
-                isPriority: priority,
-                success: true
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const solanaWallet = connectedWallet;
-            const priority = options?.priority ?? false;
-            const result = await solanaClient.sendPrepared(solanaWallet, chainInfo, to, mailId, priority, options?.computeOptions);
-            return {
-                transactionHash: result.transactionHash,
-                chainType: ChainType.SOLANA,
-                fee: BigInt(priority ? '100000' : '10000'),
-                isPriority: priority,
-                success: true
-            };
+    async registerDomain(domain, isExtension = false) {
+        if (this.chainType === 'evm') {
+            return this.registerEVMDomain(domain, isExtension);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.registerSolanaDomain(domain, isExtension);
         }
     }
     /**
-     * Send through webhook
+     * Delegate to another address using the appropriate chain implementation
+     * @param delegate - Address to delegate to
+     * @returns Delegation result
      */
-    async sendThroughWebhook(connectedWallet, chainInfo, to, webhookId, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const evmWallet = connectedWallet;
-            const [account] = await evmWallet.walletClient.getAddresses();
-            const priority = options?.priority ?? false;
-            const result = await evmClient.sendThroughWebhook(to, subject, body, webhookId, account, // payer
-            priority, evmWallet, chainInfo, options?.gasOptions);
-            return {
-                transactionHash: result.hash,
-                chainType: ChainType.EVM,
-                fee: BigInt(priority ? '100000' : '10000'),
-                gasUsed: result.gasUsed,
-                isPriority: priority,
-                success: true
-            };
+    async delegateTo(delegate) {
+        // 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})`);
         }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const solanaWallet = connectedWallet;
-            const priority = options?.priority ?? false;
-            const result = await solanaClient.sendThroughWebhook(solanaWallet, chainInfo, to, webhookId, priority, options?.computeOptions);
-            return {
-                transactionHash: result.transactionHash,
-                chainType: ChainType.SOLANA,
-                fee: BigInt(priority ? '100000' : '10000'),
-                isPriority: priority,
-                success: true
-            };
+        if (this.chainType === 'evm') {
+            return this.delegateEVM(delegate);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.delegateSolana(delegate);
         }
     }
     /**
-     * Delegate to another address
-     * @param delegate - Address to delegate to
-     * @param wallet - Wallet connection
-     * @param chainInfo - Chain information
+     * Claim revenue share using the appropriate chain implementation
      * @returns Transaction result
      */
-    async delegateTo(connectedWallet, chainInfo, delegate, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.delegateTo(delegate, connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                transactionHash: result.hash,
-                chainType: ChainType.EVM,
-                delegate,
-                success: true
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.delegateTo(delegate, connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                transactionHash: result.transactionHash,
-                chainType: ChainType.SOLANA,
-                delegate,
-                success: true
-            };
+    async claimRevenue() {
+        if (this.chainType === 'evm') {
+            return this.claimEVMRevenue();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.claimSolanaRevenue();
         }
     }
-    /**
-     * Reject delegation
-     */
-    async rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options?.computeOptions);
+    // Performance optimization: cache module imports
+    async getEVMModules() {
+        if (!OnchainMailerClient.evmModules) {
+            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) {
+            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;
+    }
+    // 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 {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
+                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
             };
         }
-        else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        catch (error) {
+            throw new Error(`EVM message sending failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    /**
-     * Claim revenue share
-     * @param wallet - Wallet connection
-     * @param chainInfo - Chain information
-     * @returns Transaction result
-     */
-    async claimRevenue(connectedWallet, chainInfo, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.claimRecipientShare(connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.claimRecipientShare(connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    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) {
+        const { viem } = await this.getEVMModules();
+        if (!this.config.evm) {
+            throw new Error('EVM configuration not provided');
         }
-        else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        // 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');
     }
-    /**
-     * Claim owner share (owner only)
-     */
-    async claimOwnerShare(connectedWallet, chainInfo, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.claimOwnerShare(connectedWallet, chainInfo, options?.gasOptions);
+    async claimEVMRevenue() {
+        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: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    // 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 {
-                hash: result.hash,
-                chainType: ChainType.EVM
+                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
             };
         }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.claimOwnerShare(connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+        catch (error) {
+            throw new Error(`Solana message sending failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+    }
+    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.config.solana) {
+            throw new Error('Solana configuration not provided');
         }
+        // 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() {
+        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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
     }
     /**
-     * Claim expired shares (owner only)
+     * Get send fee using the appropriate chain implementation
+     * @returns Send fee in USDC micro-units (6 decimals)
      */
-    async claimExpiredShares(connectedWallet, chainInfo, recipient, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.claimExpiredShares(recipient, connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.claimExpiredShares(recipient, connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async getSendFee() {
+        if (this.chainType === 'evm') {
+            return this.getEVMSendFee();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.getSolanaSendFee();
         }
     }
     /**
-     * Set fees (owner only)
+     * 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 setFees(connectedWallet, chainInfo, sendFee, delegationFee, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            // EVM client uses separate methods
-            await evmClient.setFee(connectedWallet, chainInfo, sendFee, options?.gasOptions);
-            const result2 = await evmClient.setDelegationFee(connectedWallet, chainInfo, delegationFee, options?.gasOptions);
-            return {
-                hash: result2.hash, // Return last transaction
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.setFees(connectedWallet, chainInfo, sendFee, delegationFee, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async getClaimableAmount(address) {
+        const targetAddress = address || this.wallet.address;
+        if (this.chainType === 'evm') {
+            return this.getEVMClaimableAmount(targetAddress);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.getSolanaClaimableAmount(targetAddress);
         }
     }
     /**
-     * Set custom fee percentage
+     * Get owner's claimable fee balance
+     * @returns Owner claimable amount in USDC micro-units
      */
-    async setCustomFeePercentage(connectedWallet, chainInfo, target, percentage, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.setCustomFeePercentage(connectedWallet, chainInfo, target, percentage, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.setCustomFeePercentage(connectedWallet, chainInfo, target, percentage, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async getOwnerClaimable() {
+        if (this.chainType === 'evm') {
+            return this.getEVMOwnerClaimable();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.getSolanaOwnerClaimable();
         }
     }
     /**
-     * Clear custom fee percentage
+     * 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 clearCustomFeePercentage(connectedWallet, chainInfo, target, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.clearCustomFeePercentage(connectedWallet, chainInfo, target, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.clearCustomFeePercentage(connectedWallet, chainInfo, target, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async getDelegation(address) {
+        const targetAddress = address || this.wallet.address;
+        if (this.chainType === 'evm') {
+            return this.getEVMDelegation(targetAddress);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            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) {
+        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;
+    }
     /**
-     * Pause the contract/program (owner only)
+     * 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 pause(connectedWallet, chainInfo, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.pause(connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.pause(connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async sendPrepared(to, mailId, priority = false, resolveSenderToName = false) {
+        if (this.chainType === 'evm') {
+            return this.sendPreparedEVM(to, mailId, priority, resolveSenderToName);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
         }
     }
     /**
-     * Unpause the contract/program (owner only)
+     * 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 unpause(connectedWallet, chainInfo, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.unpause(connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.unpause(connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async sendToEmail(toEmail, subject, body) {
+        if (this.chainType === 'evm') {
+            return this.sendToEmailEVM(toEmail, subject, body);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.sendToEmailSolana(toEmail, subject, body);
         }
     }
     /**
-     * Emergency unpause (owner only)
+     * 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 emergencyUnpause(connectedWallet, chainInfo, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.emergencyUnpause(connectedWallet, chainInfo, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const result = await solanaClient.emergencyUnpause(connectedWallet, chainInfo, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async sendPreparedToEmail(toEmail, mailId) {
+        if (this.chainType === 'evm') {
+            return this.sendPreparedToEmailEVM(toEmail, mailId);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.sendPreparedToEmailSolana(toEmail, mailId);
         }
     }
     /**
-     * Distribute claimable funds when paused
-     * Note: EVM supports single recipient, Solana supports multiple
+     * Set the send fee (owner only)
+     * @param newFee - New fee amount in USDC micro-units (6 decimals)
+     * @returns Promise resolving to transaction details
      */
-    async distributeClaimableFunds(connectedWallet, chainInfo, recipient, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            // EVM only supports single recipient
-            const singleRecipient = Array.isArray(recipient) ? recipient[0] : recipient;
-            const result = await evmClient.distributeClaimableFunds(connectedWallet, chainInfo, singleRecipient, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            // Solana supports multiple recipients
-            const recipients = Array.isArray(recipient) ? recipient : [recipient];
-            const result = await solanaClient.distributeClaimableFunds(connectedWallet, chainInfo, recipients, options?.computeOptions);
-            return {
-                hash: result.transactionHash,
-                chainType: ChainType.SOLANA
-            };
+    async setFee(newFee) {
+        if (this.chainType === 'evm') {
+            return this.setFeeEVM(newFee);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.setFeeSolana(newFee);
         }
     }
     /**
-     * Set permission for a contract to use caller's USDC for sending messages
-     * Note: Only supported on EVM chains
+     * Get the current send fee
+     * @returns Current send fee in USDC micro-units (6 decimals)
      */
-    async setPermission(connectedWallet, chainInfo, contractAddress, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.setPermission(connectedWallet, chainInfo, contractAddress, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            throw new Error('Permission system is not supported on Solana');
-        }
-        else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
-        }
+    async getFee() {
+        return this.getSendFee();
     }
     /**
-     * Remove permission from a contract
-     * Note: Only supported on EVM chains
+     * Set the delegation fee (owner only)
+     * @param newFee - New delegation fee in USDC micro-units
+     * @returns Promise resolving to transaction details
      */
-    async removePermission(connectedWallet, chainInfo, contractAddress, options) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const result = await evmClient.removePermission(connectedWallet, chainInfo, contractAddress, options?.gasOptions);
-            return {
-                hash: result.hash,
-                chainType: ChainType.EVM
-            };
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            throw new Error('Permission system is not supported on Solana');
+    async setDelegationFee(newFee) {
+        if (this.chainType === 'evm') {
+            return this.setDelegationFeeEVM(newFee);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.setDelegationFeeSolana(newFee);
         }
     }
     /**
-     * Check if permission exists for a contract/wallet pair
-     * Note: Only supported on EVM chains
+     * Get the current delegation fee
+     * @returns Current delegation fee in USDC micro-units
      */
-    async hasPermission(chainInfo, contractAddress, walletAddress, publicClient) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.hasPermission(chainInfo, contractAddress, walletAddress, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            // Solana doesn't have permission system, always return false
-            return false;
+    async getDelegationFee() {
+        if (this.chainType === 'evm') {
+            return this.getDelegationFeeEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.getDelegationFeeSolana();
         }
     }
-    // ============= Read Methods =============
     /**
-     * Get the send fee for messages
-     * @param chainInfo - Chain information with RPC endpoint
-     * @param publicClient - Optional public client for EVM (will create if not provided)
-     * @param connection - Optional connection for Solana (will create if not provided)
-     * @returns Fee amount in USDC micro-units
+     * Reject a delegation made to you by another address
+     * @param delegatorAddress - Address that delegated to you
+     * @returns Promise resolving to transaction details
      */
-    async getSendFee(chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getSendFee(chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            return await solanaClient.getSendFee(chainInfo, connection);
+    async rejectDelegation(delegatorAddress) {
+        if (this.chainType === 'evm') {
+            return this.rejectDelegationEVM(delegatorAddress);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.rejectDelegationSolana(delegatorAddress);
         }
     }
     /**
-     * Get delegation fee
+     * Claim owner share of fees (owner only)
+     * @returns Promise resolving to transaction details
      */
-    async getDelegationFee(chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getDelegationFee(chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            return await solanaClient.getDelegationFee(chainInfo, connection);
+    async claimOwnerShare() {
+        if (this.chainType === 'evm') {
+            return this.claimOwnerShareEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.claimOwnerShareSolana();
         }
     }
     /**
-     * Get delegation for an address
-     * @param address - Address to check
-     * @param chainInfo - Chain information with RPC endpoint
-     * @param publicClient - Optional public client for EVM
-     * @param connection - Optional connection for Solana
-     * @returns Delegated address or null
+     * Claim expired shares (owner only, EVM only)
+     * @param recipient - Address to claim expired shares for
+     * @returns Promise resolving to transaction details
      */
-    async getDelegation(address, chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            const delegation = await evmClient.getDelegation(address, chainInfo, publicClient);
-            return delegation === '0x0000000000000000000000000000000000000000' ? null : delegation;
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const delegation = await solanaClient.getDelegation(address, chainInfo, connection);
-            return delegation ? delegation.toBase58() : null;
+    async claimExpiredShares(recipient) {
+        if (this.chainType === 'evm') {
+            return this.claimExpiredSharesEVM(recipient);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            throw new Error('claimExpiredShares not available on Solana');
         }
     }
     /**
-     * Get recipient claimable info
+     * Pause the contract and distribute funds (owner only)
+     * @returns Promise resolving to transaction details
      */
-    async getRecipientClaimable(recipient, chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getRecipientClaimable(recipient, chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const info = await solanaClient.getRecipientClaimable(recipient, chainInfo, connection);
-            if (!info)
-                return null;
-            return {
-                amount: BigInt(info.amount),
-                expiresAt: BigInt(info.expiresAt),
-                isExpired: info.isExpired
-            };
+    async pause() {
+        if (this.chainType === 'evm') {
+            return this.pauseEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.pauseSolana();
         }
     }
     /**
-     * Get owner claimable amount
+     * Unpause the contract (owner only)
+     * @returns Promise resolving to transaction details
      */
-    async getOwnerClaimable(chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getOwnerClaimable(chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const amount = await solanaClient.getOwnerClaimable(chainInfo, connection);
-            return BigInt(amount);
+    async unpause() {
+        if (this.chainType === 'evm') {
+            return this.unpauseEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.unpauseSolana();
         }
     }
     /**
-     * Get custom fee percentage
+     * Emergency unpause without fund distribution (owner only)
+     * @returns Promise resolving to transaction details
      */
-    async getCustomFeePercentage(target, chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getCustomFeePercentage(target, chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            return await solanaClient.getCustomFeePercentage(target, chainInfo, connection);
+    async emergencyUnpause() {
+        if (this.chainType === 'evm') {
+            return this.emergencyUnpauseEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.emergencyUnpauseSolana();
         }
     }
     /**
-     * Check if contract/program is paused
+     * Check if contract is currently paused
+     * @returns True if contract is paused, false otherwise
      */
-    async isPaused(chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.isPaused(chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            return await solanaClient.isPaused(chainInfo, connection);
+    async isPaused() {
+        if (this.chainType === 'evm') {
+            return this.isPausedEVM();
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.isPausedSolana();
         }
     }
     /**
-     * Get contract/program owner
+     * Distribute claimable funds to a recipient when contract is paused
+     * @param recipient - Address to distribute funds for
+     * @returns Promise resolving to transaction details
      */
-    async getOwner(chainInfo, publicClient, connection) {
-        if (chainInfo.chainType === ChainType.EVM) {
-            const evmClient = await this.getEVMClient();
-            return await evmClient.getOwner(chainInfo, publicClient);
-        }
-        else if (chainInfo.chainType === ChainType.SOLANA) {
-            const solanaClient = await this.getSolanaClient();
-            const owner = await solanaClient.getOwner(chainInfo, connection);
-            return owner.toBase58();
+    async distributeClaimableFunds(recipient) {
+        if (this.chainType === 'evm') {
+            return this.distributeClaimableFundsEVM(recipient);
         }
         else {
-            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+            return this.distributeClaimableFundsSolana(recipient);
         }
     }
-    /**
-     * Register a domain (not implemented - for backward compatibility)
-     */
-    async registerDomain(_domain) {
-        throw new Error('Domain registration not yet implemented');
+    // EVM Implementation Methods
+    async sendPreparedEVM(to, mailId, priority, resolveSenderToName) {
+        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: txHash,
+            chainType: ChainType.EVM,
+            fee: BigInt(priority ? '100000' : '10000'),
+            gasUsed: receipt.gasUsed,
+            isPriority: priority,
+            success: true
+        };
+    }
+    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: txHash,
+            chainType: ChainType.EVM,
+            fee: BigInt('10000'), // 10% fee only
+            gasUsed: receipt.gasUsed,
+            isPriority: false,
+            success: true
+        };
+    }
+    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: txHash,
+            chainType: ChainType.EVM,
+            fee: BigInt('10000'), // 10% fee only
+            gasUsed: receipt.gasUsed,
+            isPriority: false,
+            success: true
+        };
+    }
+    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 {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    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 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 {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    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 {
+            hash: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    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 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: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    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: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    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 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: txHash,
+            chainType: ChainType.EVM,
+            blockNumber: receipt.blockNumber,
+            timestamp: Number(block.timestamp) * 1000
+        };
+    }
+    // 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 {
+            transactionHash: txHash,
+            chainType: ChainType.SOLANA,
+            fee: priority ? fees.sendFee : fees.sendFee / 10,
+            slot,
+            timestamp: tx?.blockTime ? tx.blockTime * 1000 : Date.now(),
+            isPriority: priority,
+            success: true
+        };
+    }
+    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 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 {
+            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 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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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 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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    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: txHash,
+            chainType: ChainType.SOLANA,
+            slot,
+            timestamp: Date.now()
+        };
+    }
+    // Utility methods
+    getChainType() {
+        return this.chainType;
+    }
+    getWalletAddress() {
+        return this.wallet.address;
     }
 }
-// Cache for dynamic imports
+// Performance optimization: cache imported modules
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-OnchainMailerClient.evmClient = null;
+OnchainMailerClient.evmModules = null;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-OnchainMailerClient.solanaClient = null;
+OnchainMailerClient.solanaModules = null;
 //# sourceMappingURL=onchain-mailer-client.js.map