@sudobility/contracts 1.12.0 → 1.13.0

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

@@ -1,1806 +1,731 @@
 /* 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 - Multi-chain messaging client for Mailer protocol
+ * OnchainMailerClient - Stateless multi-chain messaging client
  *
- * 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.
+ * This version uses stateless EVM and Solana clients underneath.
+ * All wallet connections and chain information are passed as parameters to each method.
  *
- * @example Basic Usage
+ * @example EVM Usage
  * ```typescript
- * // 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);
+ * import { createWalletClient, createPublicClient, http } from 'viem';
+ * import { RpcHelpers } from '@sudobility/configs';
+ * import { Chain } from '@sudobility/types';
  *
- * // 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 chainInfo = RpcHelpers.getChainInfo(Chain.ETH_MAINNET);
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http()
+ * });
  *
- * // Send messages
- * const result = await client.sendMessage("Hello", "World!", false);
- * console.log('Transaction:', result.transactionHash);
+ * const client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { walletClient },
+ *   chainInfo,
+ *   { priority: true }
+ * );
  * ```
  *
- * @example Error Handling
+ * @example Solana Usage
  * ```typescript
- * 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);
- *   }
- * }
- * ```
+ * 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();
  *
- * @author Mailer Protocol Team
- * @version 1.5.2
- * @since 1.0.0
+ * const client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { wallet },
+ *   chainInfo,
+ *   { priority: true }
+ * );
+ * ```
  */
 export class OnchainMailerClient {
     /**
-     * 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);
-     * ```
+     * Create a new stateless OnchainMailerClient
+     * No configuration needed in constructor
      */
-    // 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)}`);
-        }
+    constructor() {
+        // Stateless - no initialization needed
     }
-    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');
-            }
+    // Performance optimization: cache client imports
+    async getEVMClient() {
+        if (!OnchainMailerClient.evmClient) {
+            const { EVMMailerClient } = await import('../evm/evm-mailer-client.js');
+            OnchainMailerClient.evmClient = new EVMMailerClient();
         }
+        return OnchainMailerClient.evmClient;
     }
-    // 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');
+    async getSolanaClient() {
+        if (!OnchainMailerClient.solanaClient) {
+            const { SolanaMailerClient } = await import('../solana/solana-mailer-client.js');
+            OnchainMailerClient.solanaClient = new SolanaMailerClient();
         }
+        return OnchainMailerClient.solanaClient;
     }
     /**
-     * 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.
-     *
+     * Send a message on the blockchain
      * @param subject - Message subject (1-200 characters)
      * @param body - Message body (1-10000 characters)
-     * @param priority - Whether to use priority sending with revenue share
-     *                   - Priority: Full fee paid, 90% claimable by recipient
-     *                   - Standard: 10% fee only, no revenue share
-     * @param resolveSenderToName - If true, resolve sender address to name via off-chain service
-     *
-     * @returns Promise resolving to MessageResult with transaction details
-     *
-     * @throws {Error} When subject/body validation fails
-     * @throws {Error} When insufficient USDC balance
-     * @throws {Error} When user rejects transaction
-     * @throws {Error} When network connection fails
-     *
-     * @example Standard Message
-     * ```typescript
-     * const result = await client.sendMessage(
-     *   "Meeting Reminder",
-     *   "Don't forget our 3pm call today!",
-     *   false, // Standard fee (10% of sendFee)
-     *   false  // Don't resolve sender to name
-     * );
-     * console.log('Sent in tx:', result.transactionHash);
-     * ```
-     *
-     * @example Priority Message with Revenue Share
-     * ```typescript
-     * const result = await client.sendMessage(
-     *   "Important Update",
-     *   "Urgent: Please review the attached proposal",
-     *   true, // Priority fee (100% paid, 90% claimable by recipient)
-     *   true  // Resolve sender to name
-     * );
-     * console.log('Priority message fee:', result.fee);
-     * ```
+     * @param wallet - Wallet connection (EVM or Solana)
+     * @param chainInfo - Chain information including RPC endpoints and contract addresses
+     * @param options - Optional parameters
+     * @returns Transaction result
      */
-    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);
+    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
+            };
         }
         else {
-            return this.sendSolanaMessage(subject, body, priority, resolveSenderToName);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * 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
+     * Send a prepared message
      */
-    async registerDomain(domain, isExtension = false) {
-        if (this.chainType === 'evm') {
-            return this.registerEVMDomain(domain, isExtension);
+    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
+            };
         }
         else {
-            return this.registerSolanaDomain(domain, isExtension);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Delegate to another address using the appropriate chain implementation
-     * @param delegate - Address to delegate to
-     * @returns Delegation result
+     * Send through webhook
      */
-    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})`);
+    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
+            };
         }
-        if (this.chainType === 'evm') {
-            return this.delegateEVM(delegate);
+        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
+            };
         }
         else {
-            return this.delegateSolana(delegate);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Claim revenue share using the appropriate chain implementation
+     * Delegate to another address
+     * @param delegate - Address to delegate to
+     * @param wallet - Wallet connection
+     * @param chainInfo - Chain information
      * @returns Transaction result
      */
-    async claimRevenue() {
-        if (this.chainType === 'evm') {
-            return this.claimEVMRevenue();
-        }
-        else {
-            return this.claimSolanaRevenue();
-        }
-    }
-    // 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 {
-                const payer = this.wallet.address;
-                txHash = await client.send(this.wallet.address, subject, body, payer, 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))
-            ]);
+    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: txHash,
+                transactionHash: result.hash,
                 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,
+                delegate,
                 success: true
             };
         }
-        catch (error) {
-            throw new Error(`EVM message sending failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    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');
-        }
-        // Validate EVM address format
-        if (!viem.isAddress(delegate)) {
-            throw new Error('Invalid EVM address format for delegate');
-        }
-        // Note: Domain functionality is now integrated into the Mailer contract
-        throw new Error('Domain delegation is now handled through the Mailer contract - use MailerClient instead');
-    }
-    async claimEVMRevenue() {
-        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();
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.delegateTo(delegate, connectedWallet, chainInfo, options?.computeOptions);
             return {
-                transactionHash: txHash,
+                transactionHash: result.transactionHash,
                 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,
+                delegate,
                 success: true
             };
         }
-        catch (error) {
-            throw new Error(`Solana message sending failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async registerSolanaDomain(_domain, _isExtension) {
-        // Domain registration not implemented in current Solana version
-        throw new Error('Domain registration not yet implemented in Solana version - use delegation instead');
-    }
-    async delegateSolana(_delegate) {
-        if (!this.config.solana) {
-            throw new Error('Solana configuration not provided');
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
-        // 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()
-        };
     }
     /**
-     * Get send fee using the appropriate chain implementation
-     * @returns Send fee in USDC micro-units (6 decimals)
+     * Reject delegation
      */
-    async getSendFee() {
-        if (this.chainType === 'evm') {
-            return this.getEVMSendFee();
+    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);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
         }
         else {
-            return this.getSolanaSendFee();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * 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
+     * Claim revenue share
+     * @param wallet - Wallet connection
+     * @param chainInfo - Chain information
+     * @returns Transaction result
      */
-    async getClaimableAmount(address) {
-        const targetAddress = address || this.wallet.address;
-        if (this.chainType === 'evm') {
-            return this.getEVMClaimableAmount(targetAddress);
+    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
+            };
         }
         else {
-            return this.getSolanaClaimableAmount(targetAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Get owner's claimable fee balance
-     * @returns Owner claimable amount in USDC micro-units
+     * Claim owner share (owner only)
      */
-    async getOwnerClaimable() {
-        if (this.chainType === 'evm') {
-            return this.getEVMOwnerClaimable();
+    async claimOwnerShare(connectedWallet, chainInfo, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.claimOwnerShare(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.claimOwnerShare(connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
         }
         else {
-            return this.getSolanaOwnerClaimable();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * 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
+     * Claim expired shares (owner only)
      */
-    async getDelegation(address) {
-        const targetAddress = address || this.wallet.address;
-        if (this.chainType === 'evm') {
-            return this.getEVMDelegation(targetAddress);
+    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
+            };
         }
         else {
-            return this.getSolanaDelegation(targetAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    // 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;
-    }
     /**
-     * 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
+     * Set fees (owner only)
      */
-    async sendPrepared(to, mailId, priority = false, resolveSenderToName = false) {
-        if (this.chainType === 'evm') {
-            return this.sendPreparedEVM(to, mailId, priority, resolveSenderToName);
+    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
+            };
         }
         else {
-            return this.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * 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
+     * Set custom fee percentage
      */
-    async sendToEmail(toEmail, subject, body) {
-        if (this.chainType === 'evm') {
-            return this.sendToEmailEVM(toEmail, subject, body);
+    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
+            };
         }
         else {
-            return this.sendToEmailSolana(toEmail, subject, body);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * 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
+     * Clear custom fee percentage
      */
-    async sendPreparedToEmail(toEmail, mailId) {
-        if (this.chainType === 'evm') {
-            return this.sendPreparedToEmailEVM(toEmail, mailId);
+    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
+            };
         }
         else {
-            return this.sendPreparedToEmailSolana(toEmail, mailId);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Set the send fee (owner only)
-     * @param newFee - New fee amount in USDC micro-units (6 decimals)
-     * @returns Promise resolving to transaction details
+     * Pause the contract/program (owner only)
      */
-    async setFee(newFee) {
-        if (this.chainType === 'evm') {
-            return this.setFeeEVM(newFee);
+    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
+            };
         }
         else {
-            return this.setFeeSolana(newFee);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Get the current send fee
-     * @returns Current send fee in USDC micro-units (6 decimals)
+     * Unpause the contract/program (owner only)
      */
-    async getFee() {
-        return this.getSendFee();
+    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
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
     }
     /**
-     * Set the delegation fee (owner only)
-     * @param newFee - New delegation fee in USDC micro-units
-     * @returns Promise resolving to transaction details
+     * Emergency unpause (owner only)
      */
-    async setDelegationFee(newFee) {
-        if (this.chainType === 'evm') {
-            return this.setDelegationFeeEVM(newFee);
+    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
+            };
         }
         else {
-            return this.setDelegationFeeSolana(newFee);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Get the current delegation fee
-     * @returns Current delegation fee in USDC micro-units
+     * Distribute claimable funds when paused
+     * Note: EVM supports single recipient, Solana supports multiple
      */
-    async getDelegationFee() {
-        if (this.chainType === 'evm') {
-            return this.getDelegationFeeEVM();
+    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
+            };
         }
         else {
-            return this.getDelegationFeeSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Reject a delegation made to you by another address
-     * @param delegatorAddress - Address that delegated to you
-     * @returns Promise resolving to transaction details
+     * Set permission for a contract to use caller's USDC for sending messages
+     * Note: Only supported on EVM chains
      */
-    async rejectDelegation(delegatorAddress) {
-        if (this.chainType === 'evm') {
-            return this.rejectDelegationEVM(delegatorAddress);
+    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 {
-            return this.rejectDelegationSolana(delegatorAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Claim owner share of fees (owner only)
-     * @returns Promise resolving to transaction details
+     * Remove permission from a contract
+     * Note: Only supported on EVM chains
      */
-    async claimOwnerShare() {
-        if (this.chainType === 'evm') {
-            return this.claimOwnerShareEVM();
+    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');
         }
         else {
-            return this.claimOwnerShareSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Claim expired shares (owner only)
-     * @param recipient - Address to claim expired shares for
-     * @returns Promise resolving to transaction details
+     * Check if permission exists for a contract/wallet pair
+     * Note: Only supported on EVM chains
      */
-    async claimExpiredShares(recipient) {
-        if (this.chainType === 'evm') {
-            return this.claimExpiredSharesEVM(recipient);
+    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;
         }
         else {
-            return this.claimExpiredSharesSolana(recipient);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
+    // ============= Read Methods =============
     /**
-     * Pause the contract and distribute funds (owner only)
-     * @returns Promise resolving to transaction details
+     * 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
      */
-    async pause() {
-        if (this.chainType === 'evm') {
-            return this.pauseEVM();
+    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);
         }
         else {
-            return this.pauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Unpause the contract (owner only)
-     * @returns Promise resolving to transaction details
+     * Get delegation fee
      */
-    async unpause() {
-        if (this.chainType === 'evm') {
-            return this.unpauseEVM();
+    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);
         }
         else {
-            return this.unpauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Emergency unpause without fund distribution (owner only)
-     * @returns Promise resolving to transaction details
+     * 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
      */
-    async emergencyUnpause() {
-        if (this.chainType === 'evm') {
-            return this.emergencyUnpauseEVM();
+    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;
         }
         else {
-            return this.emergencyUnpauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Check if contract is currently paused
-     * @returns True if contract is paused, false otherwise
+     * Get recipient claimable info
      */
-    async isPaused() {
-        if (this.chainType === 'evm') {
-            return this.isPausedEVM();
+    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
+            };
         }
         else {
-            return this.isPausedSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Distribute claimable funds to a recipient when contract is paused
-     * @param recipient - Address to distribute funds for
-     * @returns Promise resolving to transaction details
+     * Get owner claimable amount
      */
-    async distributeClaimableFunds(recipient) {
-        if (this.chainType === 'evm') {
-            return this.distributeClaimableFundsEVM(recipient);
+    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);
         }
         else {
-            return this.distributeClaimableFundsSolana(recipient);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    // 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 payer = this.wallet.address;
-        const txHash = await client.sendPrepared(to, mailId, payer, 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 payer = this.wallet.address;
-        const txHash = await client.sendToEmailAddress(toEmail, subject, body, payer, 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 payer = this.wallet.address;
-        const txHash = await client.sendPreparedToEmailAddress(toEmail, mailId, payer, 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 claimExpiredSharesSolana(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 recipientKey = new PublicKey(recipient);
-        const client = new MailerClient(connection, wallet, programId, usdcMint);
-        const txHash = await client.claimExpiredShares(recipientKey);
-        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()
-        };
-    }
     /**
-     * Set permission for a contract to use your wallet as payer (EVM only)
-     * @param contractAddress - Contract address to grant permission to
-     * @returns Promise resolving to transaction details
-     * @throws {Error} When called on Solana (not supported)
+     * Get custom fee percentage
      */
-    async setPermission(contractAddress) {
-        if (this.chainType === 'evm') {
-            return this.setPermissionEVM(contractAddress);
+    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);
         }
         else {
-            throw new Error('Permission management is only available on EVM chains');
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Remove permission for a contract to use your wallet as payer (EVM only)
-     * @param contractAddress - Contract address to revoke permission from
-     * @returns Promise resolving to transaction details
-     * @throws {Error} When called on Solana (not supported)
+     * Check if contract/program is paused
      */
-    async removePermission(contractAddress) {
-        if (this.chainType === 'evm') {
-            return this.removePermissionEVM(contractAddress);
+    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);
         }
         else {
-            throw new Error('Permission management is only available on EVM chains');
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Check if a contract has permission to use a wallet as payer (EVM only)
-     * @param contractAddress - Contract address to check
-     * @param wallet - Wallet address to check permission for (defaults to connected wallet)
-     * @returns Promise resolving to true if permission exists, false otherwise
-     * @throws {Error} When called on Solana (not supported)
+     * Get contract/program owner
      */
-    async hasPermission(contractAddress, wallet) {
-        if (this.chainType === 'evm') {
-            return this.hasPermissionEVM(contractAddress, wallet || this.wallet.address);
+    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();
         }
         else {
-            throw new Error('Permission management is only available on EVM chains');
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    // EVM Permission Management Implementation
-    async setPermissionEVM(contractAddress) {
-        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.setPermission(contractAddress, 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 removePermissionEVM(contractAddress) {
-        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.removePermission(contractAddress, 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 hasPermissionEVM(contractAddress, wallet) {
-        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.hasPermission(contractAddress, wallet);
-    }
-    // Utility methods
-    getChainType() {
-        return this.chainType;
-    }
-    getWalletAddress() {
-        return this.wallet.address;
+    /**
+     * Register a domain (not implemented - for backward compatibility)
+     */
+    async registerDomain(_domain) {
+        throw new Error('Domain registration not yet implemented');
     }
 }
-// Performance optimization: cache imported modules
+// Cache for dynamic imports
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-OnchainMailerClient.evmModules = null;
+OnchainMailerClient.evmClient = null;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-OnchainMailerClient.solanaModules = null;
+OnchainMailerClient.solanaClient = null;
 //# sourceMappingURL=onchain-mailer-client.js.map