@sudobility/contracts 0.14.0

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

@@ -0,0 +1,1011 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @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
+ *
+ * This version removes the UnifiedWallet abstraction and instead accepts
+ * standard wallet clients from wagmi (EVM) or wallet-adapter (Solana).
+ *
+ * @example EVM Usage with wagmi
+ * ```typescript
+ * import { createWalletClient, createPublicClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ *
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http()
+ * });
+ * const publicClient = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http()
+ * });
+ *
+ * const client = OnchainMailerClient.forEVM(
+ *   walletClient,
+ *   publicClient,
+ *   '0xMailerContractAddress',
+ *   '0xUSDCAddress'
+ * );
+ * ```
+ *
+ * @example Solana Usage with wallet-adapter
+ * ```typescript
+ * import { useWallet } from '@solana/wallet-adapter-react';
+ * import { Connection } from '@solana/web3.js';
+ *
+ * const wallet = useWallet();
+ * const connection = new Connection('https://api.mainnet-beta.solana.com');
+ *
+ * const client = OnchainMailerClient.forSolana(
+ *   wallet,
+ *   connection,
+ *   'MailerProgramId',
+ *   'USDCMintAddress'
+ * );
+ * ```
+ */
+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
+     */
+    static forEVM(walletClient, publicClient, mailerAddress, usdcAddress) {
+        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
+        client.chainType = ChainType.EVM;
+        client.evmWalletClient = walletClient;
+        client.evmPublicClient = publicClient;
+        client.evmContractAddress = mailerAddress;
+        client.evmUsdcAddress = usdcAddress;
+        return client;
+    }
+    /**
+     * Create an OnchainMailerClient for Solana using wallet-adapter
+     *
+     * @param wallet - Solana wallet adapter
+     * @param connection - Solana connection
+     * @param programId - Deployed Mailer program ID
+     * @param usdcMint - USDC mint address
+     * @returns Configured OnchainMailerClient for Solana
+     */
+    static forSolana(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    wallet, // Wallet adapter interface
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connection, // Connection
+    programId, usdcMint) {
+        const client = new OnchainMailerClient({}, { evm: undefined, solana: undefined });
+        client.chainType = ChainType.SOLANA;
+        client.solanaWallet = wallet;
+        client.solanaConnection = connection;
+        client.solanaProgramId = programId;
+        client.solanaUsdcMint = usdcMint;
+        return client;
+    }
+    /**
+     * Create an OnchainMailerClient from a generic config (backward compatibility)
+     * This constructor is provided for backward compatibility with React provider
+     */
+    // 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');
+            }
+        }
+        else {
+            throw new Error('Unable to detect wallet type from provided wallet object');
+        }
+    }
+    /**
+     * Send a message using the appropriate chain implementation
+     * Note: For backward compatibility, 'to' defaults to sender's own address
+     */
+    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);
+        }
+        else {
+            return this.sendSolanaMessage(recipient, subject, body, priority, resolveSenderToName);
+        }
+    }
+    /**
+     * Register a domain (not implemented - for backward compatibility)
+     */
+    async registerDomain(_domain) {
+        throw new Error('Domain registration not yet implemented');
+    }
+    /**
+     * Delegate to another address
+     */
+    async delegateTo(delegate) {
+        if (this.chainType === ChainType.EVM) {
+            return this.delegateEVM(delegate);
+        }
+        else {
+            return this.delegateSolana(delegate);
+        }
+    }
+    /**
+     * Claim revenue share
+     */
+    async claimRevenue() {
+        if (this.chainType === ChainType.EVM) {
+            return this.claimEVMRevenue();
+        }
+        else {
+            return this.claimSolanaRevenue();
+        }
+    }
+    // Performance optimization: cache module imports
+    async getEVMModules() {
+        if (!OnchainMailerClient.evmModules) {
+            const evmModule = await import('../evm/index.js');
+            OnchainMailerClient.evmModules = {
+                MailerClient: evmModule.MailerClient
+            };
+        }
+        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;
+    }
+    // EVM implementation methods
+    async sendEVMMessage(to, subject, body, priority, resolveSenderToName) {
+        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        // Validate message
+        if (!subject || subject.length > 200) {
+            throw new Error('Subject must be 1-200 characters');
+        }
+        if (!body || body.length > 10000) {
+            throw new Error('Body must be 1-10000 characters');
+        }
+        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();
+        }
+        else {
+            return this.getSolanaSendFee();
+        }
+    }
+    async getEVMSendFee() {
+        if (!this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        return client.getSendFee();
+    }
+    async getSolanaSendFee() {
+        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
+            throw new Error('Solana client not properly initialized');
+        }
+        const { MailerClient, PublicKey } = await this.getSolanaModules();
+        const programId = new PublicKey(this.solanaProgramId);
+        const usdcMint = new PublicKey(this.solanaUsdcMint);
+        // Create a minimal wallet object for reading
+        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
+        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
+        const fees = await client.getFees();
+        return BigInt(fees.sendFee);
+    }
+    // Additional read methods
+    async getClaimableAmount(address) {
+        const targetAddress = address || await this.getWalletAddressAsync();
+        if (this.chainType === ChainType.EVM) {
+            return this.getEVMClaimableAmount(targetAddress);
+        }
+        else {
+            return this.getSolanaClaimableAmount(targetAddress);
+        }
+    }
+    async getEVMClaimableAmount(address) {
+        if (!this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        const result = await client.getRecipientClaimable(address);
+        return result.amount;
+    }
+    async getSolanaClaimableAmount(address) {
+        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
+            throw new Error('Solana client not properly initialized');
+        }
+        const { MailerClient, PublicKey } = await this.getSolanaModules();
+        const programId = new PublicKey(this.solanaProgramId);
+        const usdcMint = new PublicKey(this.solanaUsdcMint);
+        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
+        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
+        const recipientKey = new PublicKey(address);
+        const claimInfo = await client.getRecipientClaimable(recipientKey);
+        return claimInfo ? BigInt(claimInfo.amount) : 0n;
+    }
+    async getOwnerClaimable() {
+        if (this.chainType === ChainType.EVM) {
+            return this.getEVMOwnerClaimable();
+        }
+        else {
+            return this.getSolanaOwnerClaimable();
+        }
+    }
+    async getEVMOwnerClaimable() {
+        if (!this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        return client.getOwnerClaimable();
+    }
+    async getSolanaOwnerClaimable() {
+        if (!this.solanaConnection || !this.solanaProgramId || !this.solanaUsdcMint) {
+            throw new Error('Solana client not properly initialized');
+        }
+        const { MailerClient, PublicKey } = await this.getSolanaModules();
+        const programId = new PublicKey(this.solanaProgramId);
+        const usdcMint = new PublicKey(this.solanaUsdcMint);
+        const wallet = { publicKey: PublicKey.default, signTransaction: async (tx) => tx };
+        const client = new MailerClient(this.solanaConnection, wallet, programId, usdcMint);
+        const amount = await client.getOwnerClaimable();
+        return BigInt(amount);
+    }
+    async getDelegation(address) {
+        const targetAddress = address || await this.getWalletAddressAsync();
+        if (this.chainType === ChainType.EVM) {
+            return this.getEVMDelegation(targetAddress);
+        }
+        else {
+            return this.getSolanaDelegation(targetAddress);
+        }
+    }
+    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();
+        }
+        else {
+            return this.getSolanaDelegationFee();
+        }
+    }
+    async getEVMDelegationFee() {
+        if (!this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        return client.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 {
+            return this.isPausedSolana();
+        }
+    }
+    async isPausedEVM() {
+        if (!this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        return client.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 {
+            return this.unpauseSolana();
+        }
+    }
+    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();
+        }
+        else {
+            return this.emergencyUnpauseSolana();
+        }
+    }
+    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);
+        }
+        else {
+            return this.distributeClaimableFundsSolana(recipient);
+        }
+    }
+    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);
+        }
+        else {
+            return this.sendPreparedSolana(to, mailId, priority, resolveSenderToName);
+        }
+    }
+    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);
+        }
+        else {
+            return this.sendToEmailSolana(toEmail, subject, body);
+        }
+    }
+    async sendToEmailEVM(toEmail, subject, body) {
+        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        const [account] = await this.evmWalletClient.getAddresses();
+        const payer = account;
+        const result = await client.sendToEmailAddress(toEmail, subject, body, payer, this.evmWalletClient, account);
+        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);
+        }
+        else {
+            return this.sendPreparedToEmailSolana(toEmail, mailId);
+        }
+    }
+    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();
+        }
+        else {
+            return this.claimOwnerShareSolana();
+        }
+    }
+    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);
+        }
+        else {
+            return this.claimExpiredSharesSolana(recipient);
+        }
+    }
+    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);
+        }
+        else {
+            return this.rejectDelegationSolana(delegatorAddress);
+        }
+    }
+    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);
+        }
+        else {
+            return this.setFeeSolana(newFee);
+        }
+    }
+    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);
+        }
+        else {
+            return this.setDelegationFeeSolana(newFee);
+        }
+    }
+    async setDelegationFeeEVM(newFee) {
+        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        const [account] = await this.evmWalletClient.getAddresses();
+        const result = await client.setDelegationFee(newFee, this.evmWalletClient, account);
+        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();
+        }
+        else {
+            return this.pauseSolana();
+        }
+    }
+    async pauseEVM() {
+        if (!this.evmWalletClient || !this.evmPublicClient || !this.evmContractAddress) {
+            throw new Error('EVM client not properly initialized');
+        }
+        const { MailerClient } = await this.getEVMModules();
+        const client = new MailerClient(this.evmContractAddress, this.evmPublicClient);
+        const [account] = await this.evmWalletClient.getAddresses();
+        const result = await client.pause(this.evmWalletClient, account);
+        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
+     */
+    async getWalletAddressAsync() {
+        if (this.chainType === ChainType.EVM && this.evmWalletClient) {
+            const [address] = await this.evmWalletClient.getAddresses();
+            return address;
+        }
+        else if (this.chainType === ChainType.SOLANA && this.solanaWallet) {
+            return this.solanaWallet.publicKey?.toString() || '';
+        }
+        throw new Error('Wallet not initialized');
+    }
+}
+// Cache for dynamic imports
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+OnchainMailerClient.evmModules = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+OnchainMailerClient.solanaModules = null;
+//# sourceMappingURL=onchain-mailer-client.js.map