@sudobility/contracts 0.14.0 → 1.9.0

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

@@ -1,615 +1,413 @@
-import { getAddress, EstimateGasExecutionError, } from 'viem';
-import { Mailer__factory } from '../../typechain-types/factories/Mailer__factory.js';
+import { getAddress } from "viem";
+import { Mailer__factory } from "../../typechain-types/factories/Mailer__factory.js";
+// Get ABI from typechain-generated factories
 const MAILER_ABI = Mailer__factory.abi;
+// Get bytecode from typechain-generated factories
 const MAILER_BYTECODE = Mailer__factory.bytecode;
 /**
- * Normalize any Address-like input (string with checksum or lowercase) to checksum format.
- */
-function normalizeAddress(value) {
-    return getAddress(value);
-}
-/**
- * High-level client for interacting with the EVM Mailer contract.
- * Exposes every callable contract function with type-safe wrappers.
- * Includes automatic gas estimation with configurable buffer for all transactions.
+ * @class MailerClient
+ * @description High-level TypeScript client for the Mailer contract using viem
+ * @notice Provides easy-to-use methods for sending messages with USDC fees and revenue sharing
+ *
+ * ## Key Features:
+ * - **Delegation Management**: Delegate mail handling with rejection capability
+ * - **Priority Messages**: Full fee (0.1 USDC) with 90% revenue share to recipient
+ * - **Standard Messages**: 10% fee only (0.01 USDC) with no revenue share
+ * - **Revenue Claims**: 60-day claim period for priority message revenue shares
+ *
+ * ## Usage Examples:
+ * ```typescript
+ * // Connect to existing contract
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ *
+ * const publicClient = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http()
+ * });
+ *
+ * const mailer = new MailerClient('CONTRACT_ADDRESS', publicClient);
+ *
+ * // Send message with revenue sharing to recipient
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http()
+ * });
+ *
+ * await mailer.send('0x...', 'Subject', 'Body', true, walletClient, account);
+ *
+ * // Claim your revenue share (as recipient)
+ * await mailer.claimRecipientShare(walletClient, account);
+ * ```
  */
 export class MailerClient {
-    constructor(contractAddress, publicClient) {
-        this.defaultGasMultiplier = 1.2; // 20% buffer by default
-        this.contractAddress = normalizeAddress(contractAddress);
-        this.publicClient = publicClient;
-    }
-    /**
-     * Helper method to estimate gas for a transaction with optional buffer
-     */
-    async estimateGasWithBuffer(estimateFn, gasOptions) {
-        // If gas limit is explicitly provided, use it
-        if (gasOptions?.gasLimit) {
-            return gasOptions.gasLimit;
-        }
-        try {
-            // Estimate gas for the transaction
-            const estimatedGas = await estimateFn();
-            // Apply multiplier for safety buffer
-            const multiplier = gasOptions?.gasMultiplier ?? this.defaultGasMultiplier;
-            const gasWithBuffer = BigInt(Math.ceil(Number(estimatedGas) * multiplier));
-            // Apply max gas limit if specified
-            if (gasOptions?.maxGasLimit) {
-                return gasWithBuffer > gasOptions.maxGasLimit ? gasOptions.maxGasLimit : gasWithBuffer;
-            }
-            return gasWithBuffer;
-        }
-        catch (error) {
-            // If estimation fails, throw with helpful message
-            if (error instanceof EstimateGasExecutionError) {
-                throw new Error(`Gas estimation failed: ${error.message}`);
-            }
-            throw error;
-        }
-    }
     /**
-     * Helper method to build transaction parameters with gas options
+     * @description Creates a new MailerClient instance
+     * @param contractAddress The deployed Mailer contract address
+     * @param publicClient Viem public client for reading blockchain state
      */
-    buildTxParams(gasLimit, gasOptions) {
-        const params = { gas: gasLimit };
-        if (gasOptions?.maxFeePerGas) {
-            params.maxFeePerGas = gasOptions.maxFeePerGas;
-        }
-        if (gasOptions?.maxPriorityFeePerGas) {
-            params.maxPriorityFeePerGas = gasOptions.maxPriorityFeePerGas;
-        }
-        return params;
+    constructor(contractAddress, publicClient) {
+        this.contractAddress = getAddress(contractAddress);
+        this.publicClient = publicClient;
     }
     /**
-     * Deploy a fresh Mailer contract instance with gas estimation.
+     * @description Deploy a new Mailer contract and return a client instance
+     * @param walletClient Viem wallet client with deployment permissions
+     * @param account Account to deploy from
+     * @param usdcTokenAddress Address of the USDC token contract
+     * @param ownerAddress Address that will own the deployed contract
+     * @returns Promise resolving to a MailerClient instance
      */
-    static async deploy(walletClient, publicClient, account, usdcTokenAddress, ownerAddress, gasOptions) {
-        // For deployment, we need to estimate gas differently
-        // Use a reasonable default for deployment gas
-        const estimatedGas = BigInt(3000000); // Default deployment gas
-        // Apply gas buffer
-        const multiplier = gasOptions?.gasMultiplier ?? 1.5; // Higher multiplier for deployment
-        const gasLimit = gasOptions?.gasLimit ?? BigInt(Math.ceil(Number(estimatedGas) * multiplier));
-        // Deploy with estimated gas
+    static async deploy(walletClient, publicClient, account, usdcTokenAddress, ownerAddress) {
         const hash = await walletClient.deployContract({
             abi: MAILER_ABI,
             bytecode: MAILER_BYTECODE,
-            args: [normalizeAddress(usdcTokenAddress), normalizeAddress(ownerAddress)],
+            args: [getAddress(usdcTokenAddress), getAddress(ownerAddress)],
             account,
             chain: walletClient.chain,
-            gas: gasLimit,
-            ...(gasOptions?.maxFeePerGas && { maxFeePerGas: gasOptions.maxFeePerGas }),
-            ...(gasOptions?.maxPriorityFeePerGas && { maxPriorityFeePerGas: gasOptions.maxPriorityFeePerGas }),
         });
         const receipt = await publicClient.waitForTransactionReceipt({ hash });
         if (!receipt.contractAddress) {
-            throw new Error('Contract deployment failed');
+            throw new Error("Contract deployment failed");
         }
-        return {
-            client: new MailerClient(receipt.contractAddress, publicClient),
-            result: { hash, estimatedGas, gasLimit }
-        };
-    }
-    getAddress() {
-        return this.contractAddress;
+        return new MailerClient(receipt.contractAddress, publicClient);
     }
     /**
-     * Core message send with explicit payer control and gas estimation.
+     * @description Send a message with optional revenue sharing
+     * @notice Two modes:
+     *   - revenueShareToReceiver=true: Sender pays 0.1 USDC, recipient gets 90% claimable
+     *   - revenueShareToReceiver=false: Sender pays 0.01 USDC only
+     * @param to Recipient address who receives the message and potential revenue share
+     * @param subject Message subject line
+     * @param body Message content
+     * @param revenueShareToReceiver If true, recipient gets 90% revenue share; if false, no revenue share
+     * @param resolveSenderToName If true, resolve sender address to name via off-chain service
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from
+     * @returns Promise resolving to transaction hash
+     * @example
+     * ```typescript
+     * // Send with revenue share to recipient
+     * const hash = await mailer.send('0x...', 'Subject', 'Priority message', true, false, walletClient, account);
+     * // Send standard message (no revenue share)
+     * const hash2 = await mailer.send('0x...', 'Subject', 'Standard message', false, false, walletClient, account);
+     * await publicClient.waitForTransactionReceipt({ hash });
+     * ```
      */
-    async send(to, subject, body, payer, revenueShareToReceiver, resolveSenderToName, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
+    async send(to, subject, body, revenueShareToReceiver, resolveSenderToName = false, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'send',
-            args: [
-                normalizeAddress(to),
-                subject,
-                body,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'send',
-            args: [
-                normalizeAddress(to),
-                subject,
-                body,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
+            args: [to, subject, body, revenueShareToReceiver, resolveSenderToName],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async sendPrepared(to, mailId, payer, revenueShareToReceiver, resolveSenderToName, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendPrepared',
-            args: [
-                normalizeAddress(to),
-                mailId,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * @description Send a message using a pre-prepared mail ID with optional revenue sharing
+     * @notice Two modes:
+     *   - revenueShareToReceiver=true: Sender pays 0.1 USDC, recipient gets 90% claimable
+     *   - revenueShareToReceiver=false: Sender pays 0.01 USDC only
+     * @param to Recipient address who receives the message and potential revenue share
+     * @param mailId Pre-prepared message identifier
+     * @param revenueShareToReceiver If true, recipient gets 90% revenue share; if false, no revenue share
+     * @param resolveSenderToName If true, resolve sender address to name via off-chain service
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from
+     * @returns Promise resolving to transaction hash
+     */
+    async sendPrepared(to, mailId, revenueShareToReceiver, resolveSenderToName = false, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'sendPrepared',
-            args: [
-                normalizeAddress(to),
-                mailId,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
+            args: [to, mailId, revenueShareToReceiver, resolveSenderToName],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
-    }
-    async sendThroughWebhook(to, webhookId, payer, revenueShareToReceiver, resolveSenderToName, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendThroughWebhook',
-            args: [
-                normalizeAddress(to),
-                webhookId,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendThroughWebhook',
-            args: [
-                normalizeAddress(to),
-                webhookId,
-                normalizeAddress(payer),
-                revenueShareToReceiver,
-                resolveSenderToName,
-            ],
-            account,
-            chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
-        });
-        return { hash, estimatedGas: gasLimit, gasLimit };
-    }
-    async sendToEmailAddress(toEmail, subject, body, payer, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendToEmailAddress',
-            args: [toEmail, subject, body, normalizeAddress(payer)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendToEmailAddress',
-            args: [toEmail, subject, body, normalizeAddress(payer)],
-            account,
-            chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
-        });
-        return { hash, estimatedGas: gasLimit, gasLimit };
-    }
-    async sendPreparedToEmailAddress(toEmail, mailId, payer, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendPreparedToEmailAddress',
-            args: [toEmail, mailId, normalizeAddress(payer)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'sendPreparedToEmailAddress',
-            args: [toEmail, mailId, normalizeAddress(payer)],
-            account,
-            chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
-        });
-        return { hash, estimatedGas: gasLimit, gasLimit };
-    }
-    async getFee() {
-        return (await this.publicClient.readContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'getFee',
-        }));
     }
     async getSendFee() {
-        return (await this.publicClient.readContract({
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'sendFee',
-        }));
-    }
-    async setFee(newFee, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'setFee',
-            args: [newFee],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'setFee',
-            args: [newFee],
-            account,
-            chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
     async getUsdcToken() {
-        return (await this.publicClient.readContract({
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'usdcToken',
-        }));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
     }
-    async getOwner() {
-        return (await this.publicClient.readContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'owner',
-        }));
+    getAddress() {
+        return this.contractAddress;
     }
-    async claimRecipientShare(walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'claimRecipientShare',
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    async claimRecipientShare(walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'claimRecipientShare',
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async claimOwnerShare(walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'claimOwnerShare',
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    async claimOwnerShare(walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'claimOwnerShare',
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async claimExpiredShares(recipient, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'claimExpiredShares',
-            args: [normalizeAddress(recipient)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    async claimExpiredShares(recipient, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'claimExpiredShares',
-            args: [normalizeAddress(recipient)],
+            args: [getAddress(recipient)],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
     async getRecipientClaimable(recipient) {
-        const [amount, expiresAt, isExpired] = (await this.publicClient.readContract({
+        const result = await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'getRecipientClaimable',
-            args: [normalizeAddress(recipient)],
-        }));
-        return { amount, expiresAt, isExpired };
+            args: [getAddress(recipient)],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+        return {
+            amount: result[0],
+            expiresAt: result[1],
+            isExpired: result[2]
+        };
     }
     async getOwnerClaimable() {
-        return (await this.publicClient.readContract({
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
-            functionName: 'getOwnerClaimable',
-        }));
+            functionName: 'getOwnerClaimable'
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
     }
-    async delegateTo(delegate, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'delegateTo',
-            args: [normalizeAddress(delegate)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    // Delegation functionality
+    /**
+     * Delegate mail handling to another address
+     * @param delegate Address to delegate to (or 0x0 to clear delegation)
+     * @param walletClient Connected wallet client
+     * @param account Account to send transaction from
+     * @returns Transaction hash
+     */
+    async delegateTo(delegate, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'delegateTo',
-            args: [normalizeAddress(delegate)],
+            args: [getAddress(delegate)],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async rejectDelegation(delegatingAddress, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'rejectDelegation',
-            args: [normalizeAddress(delegatingAddress)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Reject a delegation made to you by another address
+     * @param delegatingAddress Address that delegated to you
+     * @param walletClient Connected wallet client
+     * @param account Account to send transaction from
+     * @returns Transaction hash
+     */
+    async rejectDelegation(delegatingAddress, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'rejectDelegation',
-            args: [normalizeAddress(delegatingAddress)],
+            args: [getAddress(delegatingAddress)],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
+    /**
+     * Get current delegation fee in USDC (6 decimals)
+     * @returns Delegation fee amount
+     */
     async getDelegationFee() {
-        return (await this.publicClient.readContract({
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'getDelegationFee',
-        }));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
     }
-    async setDelegationFee(newFee, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'setDelegationFee',
-            args: [newFee],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Update delegation fee (owner only)
+     * @param newFee New fee amount in USDC (6 decimals)
+     * @param walletClient Connected wallet client
+     * @param account Account to send transaction from
+     * @returns Transaction hash
+     */
+    async setDelegationFee(newFee, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'setDelegationFee',
             args: [newFee],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async setCustomFeePercentage(target, percentage, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'setCustomFeePercentage',
-            args: [normalizeAddress(target), BigInt(percentage)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * @description Send a message to an email address (no wallet known)
+     * @notice Charges only 10% owner fee since recipient wallet is unknown
+     * @param toEmail Email address of the recipient
+     * @param subject Message subject line
+     * @param body Message content
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from
+     * @returns Promise resolving to transaction hash
+     * @example
+     * ```typescript
+     * // Send to email address
+     * const hash = await mailer.sendToEmailAddress('user@example.com', 'Subject', 'Body', walletClient, account);
+     * await publicClient.waitForTransactionReceipt({ hash });
+     * ```
+     */
+    async sendToEmailAddress(toEmail, subject, body, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
-            functionName: 'setCustomFeePercentage',
-            args: [normalizeAddress(target), BigInt(percentage)],
+            functionName: 'sendToEmailAddress',
+            args: [toEmail, subject, body],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async clearCustomFeePercentage(target, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'clearCustomFeePercentage',
-            args: [normalizeAddress(target)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * @description Send a pre-prepared message to an email address (no wallet known)
+     * @notice Charges only 10% owner fee since recipient wallet is unknown
+     * @param toEmail Email address of the recipient
+     * @param mailId Pre-prepared message identifier
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from
+     * @returns Promise resolving to transaction hash
+     */
+    async sendPreparedToEmailAddress(toEmail, mailId, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
-            functionName: 'clearCustomFeePercentage',
-            args: [normalizeAddress(target)],
+            functionName: 'sendPreparedToEmailAddress',
+            args: [toEmail, mailId],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
-    }
-    async getCustomFeePercentage(target) {
-        const percentage = (await this.publicClient.readContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'getCustomFeePercentage',
-            args: [normalizeAddress(target)],
-        }));
-        return Number(percentage);
-    }
-    async getCustomFeeDiscount(target) {
-        const discount = (await this.publicClient.readContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'customFeeDiscount',
-            args: [normalizeAddress(target)],
-        }));
-        return Number(discount);
     }
-    async setPermission(contractAddress, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'setPermission',
-            args: [normalizeAddress(contractAddress)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Set the send fee (owner only)
+     * @param newFee New fee amount in USDC (6 decimals)
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from (must be owner)
+     * @returns Promise resolving to transaction hash
+     */
+    async setFee(newFee, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
-            functionName: 'setPermission',
-            args: [normalizeAddress(contractAddress)],
+            functionName: 'setFee',
+            args: [newFee],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async removePermission(contractAddress, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'removePermission',
-            args: [normalizeAddress(contractAddress)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Get the current send fee
+     * @returns Current send fee in USDC (6 decimals)
+     */
+    async getFee() {
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
-            functionName: 'removePermission',
-            args: [normalizeAddress(contractAddress)],
-            account,
-            chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
+            functionName: 'getFee',
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async hasPermission(contractAddress, wallet) {
-        const permitted = (await this.publicClient.readContract({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'permissions',
-            args: [normalizeAddress(contractAddress), normalizeAddress(wallet)],
-        }));
-        return permitted;
-    }
-    async pause(walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'pause',
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Pause the contract and distribute all claimable funds (owner only)
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from (must be owner)
+     * @returns Promise resolving to transaction hash
+     */
+    async pause(walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'pause',
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async unpause(walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'unpause',
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Unpause the contract (owner only)
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from (must be owner)
+     * @returns Promise resolving to transaction hash
+     */
+    async unpause(walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'unpause',
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
-    async emergencyUnpause(walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'emergencyUnpause',
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Emergency unpause without fund distribution (owner only)
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from (must be owner)
+     * @returns Promise resolving to transaction hash
+     */
+    async emergencyUnpause(walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'emergencyUnpause',
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
+    /**
+     * Check if contract is currently paused
+     * @returns True if contract is paused, false otherwise
+     */
     async isPaused() {
-        return (await this.publicClient.readContract({
+        return await this.publicClient.readContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'isPaused',
-        }));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
     }
-    async distributeClaimableFunds(recipient, walletClient, account, gasOptions) {
-        // Estimate gas for the transaction
-        const gasLimit = await this.estimateGasWithBuffer(() => this.publicClient.estimateContractGas({
-            address: this.contractAddress,
-            abi: MAILER_ABI,
-            functionName: 'distributeClaimableFunds',
-            args: [normalizeAddress(recipient)],
-            account,
-        }), gasOptions);
-        const hash = await walletClient.writeContract({
+    /**
+     * Distribute a specific recipient's claimable funds during pause
+     * Anyone can call this function when contract is paused
+     * @param recipient Address to distribute funds for
+     * @param walletClient Viem wallet client for transaction
+     * @param account Account to send from
+     * @returns Promise resolving to transaction hash
+     */
+    async distributeClaimableFunds(recipient, walletClient, account) {
+        return await walletClient.writeContract({
             address: this.contractAddress,
             abi: MAILER_ABI,
             functionName: 'distributeClaimableFunds',
-            args: [normalizeAddress(recipient)],
+            args: [getAddress(recipient)],
             account,
             chain: walletClient.chain,
-            ...this.buildTxParams(gasLimit, gasOptions),
         });
-        return { hash, estimatedGas: gasLimit, gasLimit };
     }
 }
-MailerClient.abi = MAILER_ABI;
-MailerClient.bytecode = MAILER_BYTECODE;
 //# sourceMappingURL=mailer-client.js.map