@sudobility/contracts 1.17.28 → 1.17.31

package/dist/react-native/src/unified/onchain-mailer-client.js

@@ -0,0 +1,837 @@
+/* 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 - Stateless multi-chain messaging client
+ *
+ * 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
+ * ```typescript
+ * import { createWalletClient, createPublicClient, http } from 'viem';
+ * 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 client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { walletClient },
+ *   chainInfo,
+ *   { priority: true }
+ * );
+ * ```
+ *
+ * @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 client = new OnchainMailerClient();
+ * await client.sendMessage(
+ *   'Subject',
+ *   'Body',
+ *   { wallet },
+ *   chainInfo,
+ *   { priority: true }
+ * );
+ * ```
+ */
+export class OnchainMailerClient {
+    /**
+     * Create a new stateless OnchainMailerClient
+     * No configuration needed in constructor
+     */
+    constructor() {
+        // Stateless - no initialization needed
+    }
+    // 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;
+    }
+    /**
+     * 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
+     */
+    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 resolveSenderToName = options?.resolveSenderToName ?? false;
+            const result = await solanaClient.send(solanaWallet, chainInfo, to, subject, body, priority, // revenueShareToReceiver
+            resolveSenderToName, 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}`);
+        }
+    }
+    /**
+     * Send a prepared message
+     */
+    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 resolveSenderToName = options?.resolveSenderToName ?? false;
+            const result = await solanaClient.sendPrepared(solanaWallet, chainInfo, to, mailId, priority, resolveSenderToName, 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}`);
+        }
+    }
+    /**
+     * Send through webhook
+     */
+    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(evmWallet, chainInfo, to, webhookId, account, // payer
+            priority, options?.resolveSenderToName ?? false, 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?.resolveSenderToName ?? false, 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}`);
+        }
+    }
+    /**
+     * Send to email address
+     */
+    async sendToEmailAddress(connectedWallet, chainInfo, toEmail, 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');
+        }
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const evmWallet = connectedWallet;
+            const [account] = await evmWallet.walletClient.getAddresses();
+            const result = await evmClient.sendToEmailAddress(evmWallet, chainInfo, toEmail, subject, body, account, // payer
+            options?.gasOptions);
+            return {
+                transactionHash: result.hash,
+                chainType: ChainType.EVM,
+                fee: BigInt('10000'), // Email sends use standard fee
+                gasUsed: result.gasUsed,
+                isPriority: false,
+                success: true
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const solanaWallet = connectedWallet;
+            const result = await solanaClient.sendToEmail(toEmail, subject, body, solanaWallet.wallet.publicKey.toBase58(), // payer
+            false, // revenueShareToReceiver - email sends don't share revenue
+            solanaWallet, chainInfo, options?.computeOptions);
+            return {
+                transactionHash: result.transactionHash,
+                chainType: ChainType.SOLANA,
+                fee: BigInt('10000'),
+                isPriority: false,
+                success: true
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Send prepared to email address
+     */
+    async sendPreparedToEmailAddress(connectedWallet, chainInfo, toEmail, mailId, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const evmWallet = connectedWallet;
+            const [account] = await evmWallet.walletClient.getAddresses();
+            const result = await evmClient.sendPreparedToEmailAddress(evmWallet, chainInfo, toEmail, mailId, account, // payer
+            options?.gasOptions);
+            return {
+                transactionHash: result.hash,
+                chainType: ChainType.EVM,
+                fee: BigInt('10000'),
+                gasUsed: result.gasUsed,
+                isPriority: false,
+                success: true
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const solanaWallet = connectedWallet;
+            const result = await solanaClient.sendPreparedToEmail(toEmail, mailId, solanaWallet.wallet.publicKey.toBase58(), // payer
+            false, // revenueShareToReceiver
+            solanaWallet, chainInfo, options?.computeOptions);
+            return {
+                transactionHash: result.transactionHash,
+                chainType: ChainType.SOLANA,
+                fee: BigInt('10000'),
+                isPriority: false,
+                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(connectedWallet, chainInfo, delegate, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.delegateTo(connectedWallet, chainInfo, delegate, 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(connectedWallet, chainInfo, delegate, options?.computeOptions);
+            return {
+                transactionHash: result.transactionHash,
+                chainType: ChainType.SOLANA,
+                delegate,
+                success: true
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Reject delegation
+     */
+    async rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options?.gasOptions);
+            return {
+                hash: result.hash,
+                chainType: ChainType.EVM
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.rejectDelegation(connectedWallet, chainInfo, delegatingAddress, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Claim revenue share
+     * @param wallet - Wallet connection
+     * @param chainInfo - Chain information
+     * @returns Transaction result
+     */
+    async claimRevenue(connectedWallet, chainInfo, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.claimRecipientShare(connectedWallet, chainInfo, options?.gasOptions);
+            return {
+                hash: result.hash,
+                chainType: ChainType.EVM
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.claimRecipientShare(connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.claimOwnerShare(connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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(connectedWallet, chainInfo, recipient, 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(connectedWallet, chainInfo, recipient, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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
+            };
+        }
+        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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Set fee paused state (owner only)
+     */
+    async setFeePaused(connectedWallet, chainInfo, feePaused, options) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            const result = await evmClient.setFeePaused(connectedWallet, chainInfo, feePaused, options?.gasOptions);
+            return {
+                hash: result.hash,
+                chainType: ChainType.EVM
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.setFeePaused(feePaused, connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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(target, percentage, connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.clearCustomFeePercentage(target, connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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
+            };
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const result = await solanaClient.unpause(connectedWallet, chainInfo, options?.computeOptions);
+            return {
+                hash: result.transactionHash,
+                chainType: ChainType.SOLANA
+            };
+        }
+        else {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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
+            };
+        }
+        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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    // ============= 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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) {
+            // Delegation lookup is not supported on the EVM contract
+            return null;
+        }
+        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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * 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 {
+            throw new Error(`Unsupported chain type: ${chainInfo.chainType}`);
+        }
+    }
+    /**
+     * Get contract/program owner
+     */
+    async getOwner(chainInfo, publicClient, connection) {
+        if (chainInfo.chainType === ChainType.EVM) {
+            const evmClient = await this.getEVMClient();
+            return await evmClient.getOwner(chainInfo, publicClient);
+        }
+        else if (chainInfo.chainType === ChainType.SOLANA) {
+            const solanaClient = await this.getSolanaClient();
+            const owner = await solanaClient.getOwner(chainInfo, connection);
+            return owner.toBase58();
+        }
+        else {
+            throw new Error(`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.evmClient = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+OnchainMailerClient.solanaClient = null;
+//# sourceMappingURL=onchain-mailer-client.js.map