@sudobility/contracts 0.14.0 → 0.15.1

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

@@ -2,1010 +2,730 @@
 // @ts-nocheck - Suppress false TypeScript errors with ESNext modules accessing class properties
 import { ChainType } from '@sudobility/types';
 /**
- * OnchainMailerClient v2 - Refactored to use standard wallet libraries
+ * OnchainMailerClient - Stateless multi-chain messaging client
  *
- * This version removes the UnifiedWallet abstraction and instead accepts
- * standard wallet clients from wagmi (EVM) or wallet-adapter (Solana).
+ * This version uses stateless EVM and Solana clients underneath.
+ * All wallet connections and chain information are passed as parameters to each method.
  *
- * @example EVM Usage with wagmi
+ * @example EVM Usage
  * ```typescript
  * import { createWalletClient, createPublicClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
+ * import { RpcHelpers } from '@sudobility/configs';
+ * import { Chain } from '@sudobility/types';
  *
+ * const chainInfo = RpcHelpers.getChainInfo(Chain.ETH_MAINNET);
  * const walletClient = createWalletClient({
  *   chain: mainnet,
  *   transport: http()
  * });
- * const publicClient = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * });
  *
- * const client = OnchainMailerClient.forEVM(
- *   walletClient,
- *   publicClient,
- *   '0xMailerContractAddress',
- *   '0xUSDCAddress'
+ * const client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { walletClient },
+ *   chainInfo,
+ *   { priority: true }
  * );
  * ```
  *
- * @example Solana Usage with wallet-adapter
+ * @example Solana Usage
  * ```typescript
  * import { useWallet } from '@solana/wallet-adapter-react';
  * import { Connection } from '@solana/web3.js';
+ * import { RpcHelpers } from '@sudobility/configs';
+ * import { Chain } from '@sudobility/types';
  *
+ * const chainInfo = RpcHelpers.getChainInfo(Chain.SOLANA_MAINNET);
  * const wallet = useWallet();
- * const connection = new Connection('https://api.mainnet-beta.solana.com');
  *
- * const client = OnchainMailerClient.forSolana(
- *   wallet,
- *   connection,
- *   'MailerProgramId',
- *   'USDCMintAddress'
+ * const client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { wallet },
+ *   chainInfo,
+ *   { priority: true }
  * );
  * ```
  */
 export class OnchainMailerClient {
     /**
-     * Create an OnchainMailerClient for EVM chains using wagmi clients
-     *
-     * @param walletClient - wagmi WalletClient for signing transactions
-     * @param publicClient - wagmi PublicClient for reading chain data
-     * @param mailerAddress - Deployed Mailer contract address
-     * @param usdcAddress - USDC token contract address
-     * @returns Configured OnchainMailerClient for EVM
+     * Create a new stateless OnchainMailerClient
+     * No configuration needed in constructor
      */
-    static forEVM(walletClient, publicClient, mailerAddress, usdcAddress) {
-        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
-        client.chainType = ChainType.EVM;
-        client.evmWalletClient = walletClient;
-        client.evmPublicClient = publicClient;
-        client.evmContractAddress = mailerAddress;
-        client.evmUsdcAddress = usdcAddress;
-        return client;
+    constructor() {
+        // Stateless - no initialization needed
     }
-    /**
-     * Create an OnchainMailerClient for Solana using wallet-adapter
-     *
-     * @param wallet - Solana wallet adapter
-     * @param connection - Solana connection
-     * @param programId - Deployed Mailer program ID
-     * @param usdcMint - USDC mint address
-     * @returns Configured OnchainMailerClient for Solana
-     */
-    static forSolana(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    wallet, // Wallet adapter interface
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    connection, // Connection
-    programId, usdcMint) {
-        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
-        client.chainType = ChainType.SOLANA;
-        client.solanaWallet = wallet;
-        client.solanaConnection = connection;
-        client.solanaProgramId = programId;
-        client.solanaUsdcMint = usdcMint;
-        return client;
+    // 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;
+    }
+    async getSolanaClient() {
+        if (!OnchainMailerClient.solanaClient) {
+            const { SolanaMailerClient } = await import('../solana/solana-mailer-client.js');
+            OnchainMailerClient.solanaClient = new SolanaMailerClient();
+        }
+        return OnchainMailerClient.solanaClient;
     }
     /**
-     * Create an OnchainMailerClient from a generic config (backward compatibility)
-     * This constructor is provided for backward compatibility with React provider
+     * Send a message on the blockchain
+     * @param subject - Message subject (1-200 characters)
+     * @param body - Message body (1-10000 characters)
+     * @param wallet - Wallet connection (EVM or Solana)
+     * @param chainInfo - Chain information including RPC endpoints and contract addresses
+     * @param options - Optional parameters
+     * @returns Transaction result
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    constructor(wallet, config) {
-        // Simple chain detection based on wallet properties
-        const hasEthereumProperties = wallet && (wallet.address || wallet.request || wallet.selectedAddress);
-        const hasSolanaProperties = wallet && wallet.publicKey && typeof wallet.signTransaction === 'function';
-        if (hasEthereumProperties) {
-            this.chainType = ChainType.EVM;
-            if (config.evm) {
-                // Store config for lazy initialization
-                this.evmContractAddress = config.evm.contracts.mailer;
-                this.evmUsdcAddress = config.evm.contracts.usdc;
-                // Wallet and public clients will be created on first use
-                // Store raw wallet for backward compatibility
-                // @ts-ignore
-                this._rawEvmWallet = wallet;
-            }
-            else {
-                throw new Error('EVM configuration required for EVM wallet');
-            }
-        }
-        else if (hasSolanaProperties) {
-            this.chainType = ChainType.SOLANA;
-            if (config.solana) {
-                this.solanaWallet = wallet;
-                // Connection will be created on first use
-                this.solanaProgramId = config.solana.programs.mailer;
-                this.solanaUsdcMint = config.solana.usdcMint;
-            }
-            else {
-                throw new Error('Solana configuration required for Solana wallet');
-            }
+    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 {
-            throw new Error('Unable to detect wallet type from provided wallet object');
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Send a message using the appropriate chain implementation
-     * Note: For backward compatibility, 'to' defaults to sender's own address
+     * Send a prepared message
      */
-    async sendMessage(subject, body, priority = false, resolveSenderToName = false, to) {
-        // For backward compatibility, default to sending to self
-        const recipient = to || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
-            return this.sendEVMMessage(recipient, subject, body, priority, resolveSenderToName);
+    async 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.sendSolanaMessage(recipient, subject, body, priority, resolveSenderToName);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Register a domain (not implemented - for backward compatibility)
+     * Send through webhook
      */
-    async registerDomain(_domain) {
-        throw new Error('Domain registration not yet implemented');
+    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
+            };
+        }
+        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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
     }
     /**
      * Delegate to another address
+     * @param delegate - Address to delegate to
+     * @param wallet - Wallet connection
+     * @param chainInfo - Chain information
+     * @returns Transaction result
      */
-    async delegateTo(delegate) {
-        if (this.chainType === ChainType.EVM) {
-            return this.delegateEVM(delegate);
+    async delegateTo(connectedWallet, chainInfo, delegate, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.delegateTo(delegate, connectedWallet, chainInfo, options?.gasOptions);
+            return {
+                transactionHash: result.hash,
+                chainType: ChainType.EVM,
+                delegate,
+                success: true
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.delegateTo(delegate, connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                transactionHash: result.transactionHash,
+                chainType: ChainType.SOLANA,
+                delegate,
+                success: true
+            };
         }
         else {
-            return this.delegateSolana(delegate);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
     /**
-     * Claim revenue share
+     * Reject delegation
      */
-    async claimRevenue() {
-        if (this.chainType === ChainType.EVM) {
-            return this.claimEVMRevenue();
+    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.claimSolanaRevenue();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    // Performance optimization: cache module imports
-    async getEVMModules() {
-        if (!OnchainMailerClient.evmModules) {
-            const evmModule = await import('../evm/index.js');
-            OnchainMailerClient.evmModules = {
-                MailerClient: evmModule.MailerClient
+    /**
+     * Claim revenue share
+     * @param wallet - Wallet connection
+     * @param chainInfo - Chain information
+     * @returns Transaction result
+     */
+    async claimRevenue(connectedWallet, chainInfo, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.claimRecipientShare(connectedWallet, chainInfo, options?.gasOptions);
+            return {
+                hash: result.hash,
+                chainType: ChainType.EVM
             };
         }
-        return OnchainMailerClient.evmModules;
-    }
-    async getSolanaModules() {
-        if (!OnchainMailerClient.solanaModules) {
-            const [solanaModule, web3Module] = await Promise.all([
-                import('../solana/index.js'),
-                import('@solana/web3.js')
-            ]);
-            OnchainMailerClient.solanaModules = {
-                MailerClient: solanaModule.MailerClient,
-                PublicKey: web3Module.PublicKey,
-                Connection: web3Module.Connection
-            };
-        }
-        return OnchainMailerClient.solanaModules;
+        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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
     }
-    // EVM implementation methods
-    async sendEVMMessage(to, subject, body, priority, resolveSenderToName) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Claim owner share (owner only)
+     */
+    async claimOwnerShare(connectedWallet, chainInfo, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.claimOwnerShare(connectedWallet, chainInfo, options?.gasOptions);
+            return {
+                hash: result.hash,
+                chainType: ChainType.EVM
+            };
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        // Validate message
-        if (!subject || subject.length > 200) {
-            throw new Error('Subject must be 1-200 characters');
+        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
+            };
         }
-        if (!body || body.length > 10000) {
-            throw new Error('Body must be 1-10000 characters');
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.send(to, subject, body, payer, priority, resolveSenderToName, this.evmWalletClient, account);
-        // Convert to MessageResult format
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            fee: BigInt(priority ? '100000' : '10000'),
-            gasUsed: result.gasUsed,
-            isPriority: priority,
-            success: true
-        };
     }
-    async delegateEVM(delegate) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.delegateTo(delegate, this.evmWalletClient, account);
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            delegate,
-            success: true
-        };
-    }
-    async claimEVMRevenue() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimRecipientShare(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    // Solana implementation methods
-    async sendSolanaMessage(to, subject, body, priority, resolveSenderToName) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.send(to, subject, body, priority, resolveSenderToName);
-        // Get current fees
-        const fees = await client.getFees();
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: priority ? fees.sendFee : fees.sendFee / 10,
-            isPriority: priority,
-            success: true
-        };
-    }
-    async delegateSolana(delegate) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.delegateTo(delegate);
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            delegate,
-            success: true
-        };
-    }
-    async claimSolanaRevenue() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimRecipientShare();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    // Read methods
-    async getSendFee() {
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMSendFee();
+    /**
+     * Claim expired shares (owner only)
+     */
+    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.getSolanaSendFee();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async getEVMSendFee() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Set fees (owner only)
+     */
+    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
+            };
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getSendFee();
-    }
-    async getSolanaSendFee() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        // Create a minimal wallet object for reading
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const fees = await client.getFees();
-        return BigInt(fees.sendFee);
-    }
-    // Additional read methods
-    async getClaimableAmount(address) {
-        const targetAddress = address || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMClaimableAmount(targetAddress);
+        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.getSolanaClaimableAmount(targetAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async getEVMClaimableAmount(address) {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const result = await client.getRecipientClaimable(address);
-        return result.amount;
-    }
-    async getSolanaClaimableAmount(address) {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const recipientKey = new PublicKey(address);
-        const claimInfo = await client.getRecipientClaimable(recipientKey);
-        return claimInfo ? BigInt(claimInfo.amount) : 0n;
-    }
-    async getOwnerClaimable() {
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMOwnerClaimable();
+    /**
+     * Set custom fee percentage
+     */
+    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.getSolanaOwnerClaimable();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async getEVMOwnerClaimable() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Clear custom fee percentage
+     */
+    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
+            };
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getOwnerClaimable();
-    }
-    async getSolanaOwnerClaimable() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const amount = await client.getOwnerClaimable();
-        return BigInt(amount);
-    }
-    async getDelegation(address) {
-        const targetAddress = address || await this.getWalletAddressAsync();
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMDelegation(targetAddress);
+        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.getSolanaDelegation(targetAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async getEVMDelegation(_address) {
-        // Delegation read not implemented in EVM client yet
-        throw new Error('getDelegation not yet implemented for EVM');
-    }
-    async getSolanaDelegation(address) {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const delegatorKey = new PublicKey(address);
-        const delegationInfo = await client.getDelegation(delegatorKey);
-        return delegationInfo?.delegate || null;
-    }
-    async getDelegationFee() {
-        if (this.chainType === ChainType.EVM) {
-            return this.getEVMDelegationFee();
+    /**
+     * Pause the contract/program (owner only)
+     */
+    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.getSolanaDelegationFee();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async getEVMDelegationFee() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Unpause the contract/program (owner only)
+     */
+    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
+            };
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.getDelegationFee();
-    }
-    async getSolanaDelegationFee() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        const fees = await client.getFees();
-        return BigInt(fees.delegationFee);
-    }
-    async isPaused() {
-        if (this.chainType === ChainType.EVM) {
-            return this.isPausedEVM();
+        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 {
-            return this.isPausedSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async isPausedEVM() {
-        if (!this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
+    /**
+     * Emergency unpause (owner only)
+     */
+    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
+            };
         }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        return client.isPaused();
-    }
-    async isPausedSolana() {
-        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
-        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
-        return client.isPaused();
-    }
-    // Write methods for contract management
-    async unpause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.unpauseEVM();
+        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.unpauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async unpauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.unpause(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async unpauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.unpause();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async emergencyUnpause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.emergencyUnpauseEVM();
+    /**
+     * Distribute claimable funds when paused
+     * Note: EVM supports single recipient, Solana supports multiple
+     */
+    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.emergencyUnpauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async emergencyUnpauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.emergencyUnpause(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async emergencyUnpauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.emergencyUnpause();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async distributeClaimableFunds(recipient) {
-        if (this.chainType === ChainType.EVM) {
-            return this.distributeClaimableFundsEVM(recipient);
+    /**
+     * Set permission for a contract to use caller's USDC for sending messages
+     * Note: Only supported on EVM chains
+     */
+    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.distributeClaimableFundsSolana(recipient);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async distributeClaimableFundsEVM(recipient) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.distributeClaimableFunds(recipient, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async distributeClaimableFundsSolana(recipient) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.distributeClaimableFunds(recipient);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    // Additional methods for complete API compatibility
-    async sendPrepared(to, mailId, priority = false, resolveSenderToName = false) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendPreparedEVM(to, mailId, priority, resolveSenderToName);
+    /**
+     * Remove permission from a contract
+     * Note: Only supported on EVM chains
+     */
+    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.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async sendPreparedEVM(to, mailId, priority, resolveSenderToName) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendPrepared(to, mailId, payer, priority, resolveSenderToName, this.evmWalletClient, account);
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            fee: BigInt(priority ? '100000' : '10000'),
-            gasUsed: result.gasUsed,
-            isPriority: priority,
-            success: true
-        };
-    }
-    async sendPreparedSolana(to, mailId, priority, resolveSenderToName) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const recipientKey = new PublicKey(to);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendPrepared(recipientKey, mailId, priority, resolveSenderToName);
-        const fees = await client.getFees();
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: priority ? fees.sendFee : fees.sendFee / 10,
-            isPriority: priority,
-            success: true
-        };
-    }
-    async sendToEmail(toEmail, subject, body) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendToEmailEVM(toEmail, subject, body);
+    /**
+     * Check if permission exists for a contract/wallet pair
+     * Note: Only supported on EVM chains
+     */
+    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.sendToEmailSolana(toEmail, subject, body);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async sendToEmailEVM(toEmail, subject, body) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendToEmailAddress(toEmail, subject, body, payer, this.evmWalletClient, account);
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            fee: BigInt('10000'), // 10% fee only
-            gasUsed: result.gasUsed,
-            isPriority: false,
-            success: true
-        };
-    }
-    async sendToEmailSolana(toEmail, subject, body) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendToEmail(toEmail, subject, body);
-        const fees = await client.getFees();
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: fees.sendFee / 10, // 10% fee only
-            isPriority: false,
-            success: true
-        };
-    }
-    async sendPreparedToEmail(toEmail, mailId) {
-        if (this.chainType === ChainType.EVM) {
-            return this.sendPreparedToEmailEVM(toEmail, mailId);
+    // ============= Read Methods =============
+    /**
+     * Get the send fee for messages
+     * @param chainInfo - Chain information with RPC endpoint
+     * @param publicClient - Optional public client for EVM (will create if not provided)
+     * @param connection - Optional connection for Solana (will create if not provided)
+     * @returns Fee amount in USDC micro-units
+     */
+    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.sendPreparedToEmailSolana(toEmail, mailId);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async sendPreparedToEmailEVM(toEmail, mailId) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const payer = account;
-        const result = await client.sendPreparedToEmailAddress(toEmail, mailId, payer, this.evmWalletClient, account);
-        return {
-            transactionHash: result.hash,
-            chainType: ChainType.EVM,
-            fee: BigInt('10000'), // 10% fee only
-            gasUsed: result.gasUsed,
-            isPriority: false,
-            success: true
-        };
-    }
-    async sendPreparedToEmailSolana(toEmail, mailId) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.sendPreparedToEmail(toEmail, mailId);
-        const fees = await client.getFees();
-        return {
-            transactionHash: result.signature,
-            chainType: ChainType.SOLANA,
-            fee: fees.sendFee / 10, // 10% fee only
-            isPriority: false,
-            success: true
-        };
-    }
-    async claimOwnerShare() {
-        if (this.chainType === ChainType.EVM) {
-            return this.claimOwnerShareEVM();
+    /**
+     * Get delegation fee
+     */
+    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.claimOwnerShareSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async claimOwnerShareEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimOwnerShare(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async claimOwnerShareSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimOwnerShare();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async claimExpiredShares(recipient) {
-        if (this.chainType === ChainType.EVM) {
-            return this.claimExpiredSharesEVM(recipient);
+    /**
+     * 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 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.claimExpiredSharesSolana(recipient);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async claimExpiredSharesEVM(recipient) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.claimExpiredShares(recipient, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async claimExpiredSharesSolana(recipient) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const recipientKey = new PublicKey(recipient);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.claimExpiredShares(recipientKey);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async rejectDelegation(delegatorAddress) {
-        if (this.chainType === ChainType.EVM) {
-            return this.rejectDelegationEVM(delegatorAddress);
+    /**
+     * Get recipient claimable info
+     */
+    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.rejectDelegationSolana(delegatorAddress);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async rejectDelegationEVM(delegatorAddress) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.rejectDelegation(delegatorAddress, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async rejectDelegationSolana(delegatorAddress) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.rejectDelegation(delegatorAddress);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async setFee(newFee) {
-        if (this.chainType === ChainType.EVM) {
-            return this.setFeeEVM(newFee);
+    /**
+     * Get owner claimable amount
+     */
+    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.setFeeSolana(newFee);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async setFeeEVM(newFee) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.setFee(newFee, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async setFeeSolana(newFee) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.setFee(newFee);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async setDelegationFee(newFee) {
-        if (this.chainType === ChainType.EVM) {
-            return this.setDelegationFeeEVM(newFee);
+    /**
+     * Get custom fee percentage
+     */
+    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 {
-            return this.setDelegationFeeSolana(newFee);
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async setDelegationFeeEVM(newFee) {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.setDelegationFee(newFee, this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async setDelegationFeeSolana(newFee) {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.setDelegationFee(newFee);
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    async pause() {
-        if (this.chainType === ChainType.EVM) {
-            return this.pauseEVM();
+    /**
+     * Check if contract/program is paused
+     */
+    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 {
-            return this.pauseSolana();
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
         }
     }
-    async pauseEVM() {
-        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
-            throw new Error('EVM client not properly initialized');
-        }
-        const { MailerClient } = await this.getEVMModules();
-        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
-        const [account] = await this.evmWalletClient.getAddresses();
-        const result = await client.pause(this.evmWalletClient, account);
-        return {
-            hash: result.hash,
-            chainType: ChainType.EVM,
-            blockNumber: result.blockNumber,
-            timestamp: Date.now()
-        };
-    }
-    async pauseSolana() {
-        if (!this.solanaWallet || !this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
-            throw new Error('Solana client not properly initialized');
-        }
-        const { MailerClient, PublicKey } = await this.getSolanaModules();
-        const programId = new PublicKey(this.solanaProgramId);
-        const usdcMint = new PublicKey(this.solanaUsdcMint);
-        const client = new MailerClient(this.solanaConnection, this.solanaWallet, programId, usdcMint);
-        const result = await client.pause();
-        const slot = await this.solanaConnection.getSlot();
-        return {
-            hash: result.signature,
-            chainType: ChainType.SOLANA,
-            slot,
-            timestamp: Date.now()
-        };
-    }
-    // Utility methods
-    getChainType() {
-        return this.chainType;
-    }
-    getWalletAddress() {
-        if (this.chainType === ChainType.EVM) {
-            // Try to get address from raw wallet for backward compatibility
-            // @ts-ignore
-            if (this._rawEvmWallet) {
-                // @ts-ignore
-                return this._rawEvmWallet.address || this._rawEvmWallet.selectedAddress || '';
-            }
-            return ''; // Caller should use getWalletAddressAsync() for accurate address
-        }
-        else if (this.chainType === ChainType.SOLANA && this.solanaWallet) {
-            return this.solanaWallet.publicKey?.toString() || '';
-        }
-        return '';
-    }
     /**
-     * Get wallet address asynchronously
+     * Get contract/program owner
      */
-    async getWalletAddressAsync() {
-        if (this.chainType === ChainType.EVM && this.evmWalletClient) {
-            const [address] = await this.evmWalletClient.getAddresses();
-            return address;
+    async getOwner(chainInfo, publicClient, connection) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            return await evmClient.getOwner(chainInfo, publicClient);
         }
-        else if (this.chainType === ChainType.SOLANA && this.solanaWallet) {
-            return this.solanaWallet.publicKey?.toString() || '';
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const owner = await solanaClient.getOwner(chainInfo, connection);
+            return owner.toBase58();
         }
-        throw new Error('Wallet not initialized');
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Register a domain (not implemented - for backward compatibility)
+     */
+    async registerDomain(_domain) {
+        throw new Error('Domain registration not yet implemented');
     }
 }
 // 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