@sudobility/contracts 1.11.1 → 1.12.0

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

@@ -1,4 +1,4 @@
-import { PublicKey, Transaction, TransactionInstruction, SystemProgram, } from '@solana/web3.js';
+import { PublicKey, Transaction, TransactionInstruction, SystemProgram, ComputeBudgetProgram, } from '@solana/web3.js';
 import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, createAssociatedTokenAccountInstruction, } from '@solana/spl-token';
 /**
  * Native Solana Program instruction data structures
@@ -32,6 +32,23 @@ function encodeSend(to, subject, body, revenueShareToReceiver, resolveSenderToNa
     data.writeUInt8(resolveSenderToName ? 1 : 0, offset);
     return data;
 }
+function encodeSendPrepared(to, mailId, revenueShareToReceiver, resolveSenderToName = false) {
+    const mailIdBytes = Buffer.from(mailId, 'utf8');
+    const data = Buffer.alloc(1 + 32 + 4 + mailIdBytes.length + 1 + 1);
+    let offset = 0;
+    data.writeUInt8(InstructionType.SendPrepared, offset);
+    offset += 1;
+    to.toBuffer().copy(data, offset);
+    offset += 32;
+    data.writeUInt32LE(mailIdBytes.length, offset);
+    offset += 4;
+    mailIdBytes.copy(data, offset);
+    offset += mailIdBytes.length;
+    data.writeUInt8(revenueShareToReceiver ? 1 : 0, offset);
+    offset += 1;
+    data.writeUInt8(resolveSenderToName ? 1 : 0, offset);
+    return data;
+}
 function encodeSendToEmail(toEmail, subject, body) {
     const emailBytes = Buffer.from(toEmail, 'utf8');
     const subjectBytes = Buffer.from(subject, 'utf8');
@@ -69,6 +86,23 @@ function encodeSendPreparedToEmail(toEmail, mailId) {
     mailIdBytes.copy(data, offset);
     return data;
 }
+function encodeSendThroughWebhook(to, webhookId, revenueShareToReceiver, resolveSenderToName = false) {
+    const webhookBytes = Buffer.from(webhookId, 'utf8');
+    const data = Buffer.alloc(1 + 32 + 4 + webhookBytes.length + 1 + 1);
+    let offset = 0;
+    data.writeUInt8(InstructionType.SendThroughWebhook, offset);
+    offset += 1;
+    to.toBuffer().copy(data, offset);
+    offset += 32;
+    data.writeUInt32LE(webhookBytes.length, offset);
+    offset += 4;
+    webhookBytes.copy(data, offset);
+    offset += webhookBytes.length;
+    data.writeUInt8(revenueShareToReceiver ? 1 : 0, offset);
+    offset += 1;
+    data.writeUInt8(resolveSenderToName ? 1 : 0, offset);
+    return data;
+}
 function encodeSimpleInstruction(instructionType) {
     const data = Buffer.alloc(1);
     data.writeUInt8(instructionType, 0);
@@ -86,6 +120,19 @@ function encodeSetDelegationFee(newFee) {
     data.writeBigUInt64LE(newFee, 1);
     return data;
 }
+function encodeSetCustomFeePercentage(account, percentage) {
+    const data = Buffer.alloc(1 + 32 + 1);
+    data.writeUInt8(InstructionType.SetCustomFeePercentage, 0);
+    account.toBuffer().copy(data, 1);
+    data.writeUInt8(percentage, 33);
+    return data;
+}
+function encodeClearCustomFeePercentage(account) {
+    const data = Buffer.alloc(1 + 32);
+    data.writeUInt8(InstructionType.ClearCustomFeePercentage, 0);
+    account.toBuffer().copy(data, 1);
+    return data;
+}
 function encodeDelegateTo(delegate) {
     if (!delegate) {
         // Clear delegation - just send the instruction type and a null option
@@ -169,26 +216,40 @@ function parseDelegation(data) {
         bump,
     };
 }
-/**
- * Instruction types for the native Solana program
- */
+function parseFeeDiscount(data) {
+    let offset = 0;
+    const account = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const discount = data.readUInt8(offset);
+    offset += 1;
+    const bump = data.readUInt8(offset);
+    return {
+        account,
+        discount,
+        bump,
+    };
+}
 var InstructionType;
 (function (InstructionType) {
     InstructionType[InstructionType["Initialize"] = 0] = "Initialize";
     InstructionType[InstructionType["Send"] = 1] = "Send";
-    InstructionType[InstructionType["SendToEmail"] = 2] = "SendToEmail";
-    InstructionType[InstructionType["SendPreparedToEmail"] = 3] = "SendPreparedToEmail";
-    InstructionType[InstructionType["ClaimRecipientShare"] = 4] = "ClaimRecipientShare";
-    InstructionType[InstructionType["ClaimOwnerShare"] = 5] = "ClaimOwnerShare";
-    InstructionType[InstructionType["SetFee"] = 6] = "SetFee";
-    InstructionType[InstructionType["DelegateTo"] = 7] = "DelegateTo";
-    InstructionType[InstructionType["RejectDelegation"] = 8] = "RejectDelegation";
-    InstructionType[InstructionType["SetDelegationFee"] = 9] = "SetDelegationFee";
-    InstructionType[InstructionType["Pause"] = 10] = "Pause";
-    InstructionType[InstructionType["Unpause"] = 11] = "Unpause";
-    InstructionType[InstructionType["DistributeClaimableFunds"] = 12] = "DistributeClaimableFunds";
-    InstructionType[InstructionType["ClaimExpiredShares"] = 13] = "ClaimExpiredShares";
-    InstructionType[InstructionType["EmergencyUnpause"] = 14] = "EmergencyUnpause";
+    InstructionType[InstructionType["SendPrepared"] = 2] = "SendPrepared";
+    InstructionType[InstructionType["SendToEmail"] = 3] = "SendToEmail";
+    InstructionType[InstructionType["SendPreparedToEmail"] = 4] = "SendPreparedToEmail";
+    InstructionType[InstructionType["SendThroughWebhook"] = 5] = "SendThroughWebhook";
+    InstructionType[InstructionType["ClaimRecipientShare"] = 6] = "ClaimRecipientShare";
+    InstructionType[InstructionType["ClaimOwnerShare"] = 7] = "ClaimOwnerShare";
+    InstructionType[InstructionType["SetFee"] = 8] = "SetFee";
+    InstructionType[InstructionType["DelegateTo"] = 9] = "DelegateTo";
+    InstructionType[InstructionType["RejectDelegation"] = 10] = "RejectDelegation";
+    InstructionType[InstructionType["SetDelegationFee"] = 11] = "SetDelegationFee";
+    InstructionType[InstructionType["SetCustomFeePercentage"] = 12] = "SetCustomFeePercentage";
+    InstructionType[InstructionType["ClearCustomFeePercentage"] = 13] = "ClearCustomFeePercentage";
+    InstructionType[InstructionType["Pause"] = 14] = "Pause";
+    InstructionType[InstructionType["Unpause"] = 15] = "Unpause";
+    InstructionType[InstructionType["DistributeClaimableFunds"] = 16] = "DistributeClaimableFunds";
+    InstructionType[InstructionType["ClaimExpiredShares"] = 17] = "ClaimExpiredShares";
+    InstructionType[InstructionType["EmergencyUnpause"] = 18] = "EmergencyUnpause";
 })(InstructionType || (InstructionType = {}));
 /**
  * @class MailerClient
@@ -226,6 +287,7 @@ var InstructionType;
  */
 export class MailerClient {
     constructor(connection, wallet, programId, usdcMint) {
+        this.defaultComputeUnitMultiplier = 1.2; // 20% buffer by default
         this.connection = connection;
         this.wallet = wallet;
         this.programId = programId;
@@ -235,10 +297,69 @@ export class MailerClient {
         this.mailerStatePda = mailerPda;
         this.mailerBump = bump;
     }
+    /**
+     * Optimize compute units for a transaction
+     * @param transaction Transaction to optimize
+     * @param options Compute unit options
+     * @returns Optimized transaction with compute budget instructions
+     */
+    async optimizeComputeUnits(transaction, options) {
+        // Skip if explicitly disabled
+        if (options?.skipComputeUnits) {
+            return { transaction };
+        }
+        let simulatedUnits;
+        let computeUnitLimit = options?.computeUnitLimit;
+        // Auto-optimize by simulating transaction
+        if (options?.autoOptimize && !computeUnitLimit) {
+            try {
+                // Set a high limit for simulation
+                const simTransaction = new Transaction().add(...transaction.instructions);
+                simTransaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 1400000, // Max for simulation
+                }));
+                simTransaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+                simTransaction.feePayer = this.wallet.publicKey;
+                const simulation = await this.connection.simulateTransaction(simTransaction);
+                if (simulation.value.err === null && simulation.value.unitsConsumed) {
+                    simulatedUnits = simulation.value.unitsConsumed;
+                    const multiplier = options.computeUnitMultiplier ?? this.defaultComputeUnitMultiplier;
+                    computeUnitLimit = Math.min(Math.ceil(simulatedUnits * multiplier), 1400000 // Max compute units
+                    );
+                }
+            }
+            catch (error) {
+                console.warn('Failed to simulate transaction for compute unit optimization:', error);
+                // Fall back to default or specified limit
+                computeUnitLimit = computeUnitLimit ?? 200000;
+            }
+        }
+        // Create new transaction with compute budget instructions prepended
+        const optimizedTx = new Transaction();
+        // Add compute unit limit if specified or auto-optimized
+        if (computeUnitLimit) {
+            optimizedTx.add(ComputeBudgetProgram.setComputeUnitLimit({
+                units: computeUnitLimit,
+            }));
+        }
+        // Add priority fee if specified
+        if (options?.computeUnitPrice) {
+            optimizedTx.add(ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: options.computeUnitPrice,
+            }));
+        }
+        // Add original instructions
+        optimizedTx.add(...transaction.instructions);
+        return {
+            transaction: optimizedTx,
+            simulatedUnits,
+        };
+    }
     /**
      * Initialize the mailer program (owner only)
+     * @param computeOptions Compute unit optimization options
      */
-    async initialize() {
+    async initialize(computeOptions) {
         const instruction = new TransactionInstruction({
             keys: [
                 { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
@@ -249,7 +370,7 @@ export class MailerClient {
             data: encodeInitialize(this.usdcMint),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Send a message with optional revenue sharing
@@ -258,9 +379,10 @@ export class MailerClient {
      * @param body Message body
      * @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
-     * @returns Transaction signature
+     * @param computeOptions Compute unit optimization options
+     * @returns Transaction result with signature and compute details
      */
-    async send(to, subject, body, revenueShareToReceiver = false, resolveSenderToName = false) {
+    async send(to, subject, body, revenueShareToReceiver = false, resolveSenderToName = false, computeOptions) {
         const recipientKey = typeof to === 'string' ? new PublicKey(to) : to;
         // Derive recipient claim PDA
         const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), recipientKey.toBuffer()], this.programId);
@@ -290,13 +412,13 @@ export class MailerClient {
         });
         instructions.push(sendInstruction);
         const transaction = new Transaction().add(...instructions);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Claim recipient share of revenue
-     * @returns Transaction signature
+     * @returns Transaction result
      */
-    async claimRecipientShare() {
+    async claimRecipientShare(computeOptions) {
         const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), this.wallet.publicKey.toBuffer()], this.programId);
         const recipientTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
         const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
@@ -313,13 +435,13 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.ClaimRecipientShare),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Claim owner share of fees (owner only)
-     * @returns Transaction signature
+     * @returns Transaction result
      */
-    async claimOwnerShare() {
+    async claimOwnerShare(computeOptions) {
         const ownerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
         const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
         const instruction = new TransactionInstruction({
@@ -334,7 +456,7 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.ClaimOwnerShare),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Claim expired recipient shares and move them under owner control
@@ -342,7 +464,7 @@ export class MailerClient {
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async claimExpiredShares(recipient, options) {
+    async claimExpiredShares(recipient, options, computeOptions) {
         const recipientKey = typeof recipient === 'string' ? new PublicKey(recipient) : recipient;
         const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), recipientKey.toBuffer()], this.programId);
         const instruction = new TransactionInstruction({
@@ -355,14 +477,14 @@ export class MailerClient {
             data: encodeClaimExpiredShares(recipientKey),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction, options);
+        return await this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Delegate message handling to another address
      * @param delegate Address to delegate to, or null to clear delegation
      * @returns Transaction signature
      */
-    async delegateTo(delegate) {
+    async delegateTo(delegate, computeOptions) {
         const delegateKey = delegate
             ? typeof delegate === 'string'
                 ? new PublicKey(delegate)
@@ -385,14 +507,14 @@ export class MailerClient {
             data: encodeDelegateTo(delegateKey),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Reject a delegation made to you
      * @param delegator Address that delegated to you
      * @returns Transaction signature
      */
-    async rejectDelegation(delegator) {
+    async rejectDelegation(delegator, computeOptions) {
         const delegatorKey = typeof delegator === 'string' ? new PublicKey(delegator) : delegator;
         const [delegationPda] = PublicKey.findProgramAddressSync([Buffer.from('delegation'), delegatorKey.toBuffer()], this.programId);
         const instruction = new TransactionInstruction({
@@ -405,14 +527,15 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.RejectDelegation),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Set the send fee (owner only)
      * @param newFee New fee in USDC micro-units (6 decimals)
-     * @returns Transaction signature
+     * @param computeOptions Compute unit optimization options
+     * @returns Transaction result
      */
-    async setFee(newFee) {
+    async setFee(newFee, computeOptions) {
         const instruction = new TransactionInstruction({
             keys: [
                 { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
@@ -422,14 +545,14 @@ export class MailerClient {
             data: encodeSetFee(typeof newFee === 'bigint' ? newFee : BigInt(newFee)),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Set the delegation fee (owner only)
      * @param newFee New delegation fee in USDC micro-units (6 decimals)
      * @returns Transaction signature
      */
-    async setDelegationFee(newFee) {
+    async setDelegationFee(newFee, computeOptions) {
         const instruction = new TransactionInstruction({
             keys: [
                 { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
@@ -439,7 +562,59 @@ export class MailerClient {
             data: encodeSetDelegationFee(typeof newFee === 'bigint' ? newFee : BigInt(newFee)),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction);
+        return await this.sendTransaction(transaction, undefined, computeOptions);
+    }
+    async setCustomFeePercentage(account, percentage, payer, computeOptions) {
+        const normalizedPercentage = Math.trunc(percentage);
+        if (normalizedPercentage < 0 || normalizedPercentage > 100) {
+            throw new Error('Percentage must be between 0 and 100');
+        }
+        const accountKey = typeof account === 'string' ? new PublicKey(account) : account;
+        const payerKey = payer
+            ? typeof payer === 'string'
+                ? new PublicKey(payer)
+                : payer
+            : this.wallet.publicKey;
+        const [discountPda] = PublicKey.findProgramAddressSync([Buffer.from('discount'), accountKey.toBuffer()], this.programId);
+        const instruction = new TransactionInstruction({
+            keys: [
+                { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
+                { pubkey: this.mailerStatePda, isSigner: false, isWritable: false },
+                { pubkey: discountPda, isSigner: false, isWritable: true },
+                { pubkey: accountKey, isSigner: false, isWritable: false },
+                { pubkey: payerKey, isSigner: true, isWritable: true },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            programId: this.programId,
+            data: encodeSetCustomFeePercentage(accountKey, normalizedPercentage),
+        });
+        const transaction = new Transaction().add(instruction);
+        return this.sendTransaction(transaction, undefined, computeOptions);
+    }
+    async clearCustomFeePercentage(account, computeOptions) {
+        const accountKey = typeof account === 'string' ? new PublicKey(account) : account;
+        const [discountPda] = PublicKey.findProgramAddressSync([Buffer.from('discount'), accountKey.toBuffer()], this.programId);
+        const instruction = new TransactionInstruction({
+            keys: [
+                { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
+                { pubkey: this.mailerStatePda, isSigner: false, isWritable: false },
+                { pubkey: discountPda, isSigner: false, isWritable: true },
+            ],
+            programId: this.programId,
+            data: encodeClearCustomFeePercentage(accountKey),
+        });
+        const transaction = new Transaction().add(instruction);
+        return this.sendTransaction(transaction, undefined, computeOptions);
+    }
+    async getCustomFeePercentage(account) {
+        const accountKey = typeof account === 'string' ? new PublicKey(account) : account;
+        const [discountPda] = PublicKey.findProgramAddressSync([Buffer.from('discount'), accountKey.toBuffer()], this.programId);
+        const accountInfo = await this.connection.getAccountInfo(discountPda);
+        if (!accountInfo) {
+            return 100;
+        }
+        const discountState = parseFeeDiscount(accountInfo.data);
+        return 100 - discountState.discount;
     }
     /**
      * Get current fees from the mailer state
@@ -527,7 +702,7 @@ export class MailerClient {
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async sendToEmail(toEmail, subject, body, options) {
+    async sendToEmail(toEmail, subject, body, options, computeOptions) {
         // Get associated token accounts
         const senderTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
         const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
@@ -553,7 +728,7 @@ export class MailerClient {
             data: instructionData,
         }));
         const transaction = new Transaction().add(...instructions);
-        return this.sendTransaction(transaction, options);
+        return this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Send a prepared message to an email address (no wallet known)
@@ -563,7 +738,7 @@ export class MailerClient {
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async sendPreparedToEmail(toEmail, mailId, options) {
+    async sendPreparedToEmail(toEmail, mailId, options, computeOptions) {
         // Get associated token accounts
         const senderTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
         const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
@@ -589,7 +764,7 @@ export class MailerClient {
             data: instructionData,
         }));
         const transaction = new Transaction().add(...instructions);
-        return this.sendTransaction(transaction, options);
+        return this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Send a prepared message using a mailId (to match EVM behavior)
@@ -599,16 +774,66 @@ export class MailerClient {
      * @param resolveSenderToName If true, resolve sender address to name
      * @returns Transaction signature
      */
-    async sendPrepared(to, mailId, revenueShareToReceiver = false, resolveSenderToName = false) {
-        // For Solana, we send the mailId as both subject and body to indicate it's a prepared message
-        return this.send(to, mailId, '', revenueShareToReceiver, resolveSenderToName);
+    async sendPrepared(to, mailId, revenueShareToReceiver = false, resolveSenderToName = false, computeOptions) {
+        const recipientKey = typeof to === 'string' ? new PublicKey(to) : to;
+        const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), recipientKey.toBuffer()], this.programId);
+        const senderTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
+        const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
+        const instructions = [];
+        const mailerTokenInfo = await this.connection.getAccountInfo(mailerTokenAccount);
+        if (!mailerTokenInfo) {
+            instructions.push(createAssociatedTokenAccountInstruction(this.wallet.publicKey, mailerTokenAccount, this.mailerStatePda, this.usdcMint));
+        }
+        const sendInstruction = new TransactionInstruction({
+            keys: [
+                { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
+                { pubkey: recipientClaimPda, isSigner: false, isWritable: true },
+                { pubkey: this.mailerStatePda, isSigner: false, isWritable: false },
+                { pubkey: senderTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: mailerTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            programId: this.programId,
+            data: encodeSendPrepared(recipientKey, mailId, revenueShareToReceiver, resolveSenderToName),
+        });
+        instructions.push(sendInstruction);
+        const transaction = new Transaction().add(...instructions);
+        return this.sendTransaction(transaction, undefined, computeOptions);
+    }
+    async sendThroughWebhook(to, webhookId, revenueShareToReceiver = false, resolveSenderToName = false, computeOptions) {
+        const recipientKey = typeof to === 'string' ? new PublicKey(to) : to;
+        const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), recipientKey.toBuffer()], this.programId);
+        const senderTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
+        const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
+        const instructions = [];
+        const mailerTokenInfo = await this.connection.getAccountInfo(mailerTokenAccount);
+        if (!mailerTokenInfo) {
+            instructions.push(createAssociatedTokenAccountInstruction(this.wallet.publicKey, mailerTokenAccount, this.mailerStatePda, this.usdcMint));
+        }
+        const sendInstruction = new TransactionInstruction({
+            keys: [
+                { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
+                { pubkey: recipientClaimPda, isSigner: false, isWritable: true },
+                { pubkey: this.mailerStatePda, isSigner: false, isWritable: false },
+                { pubkey: senderTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: mailerTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            programId: this.programId,
+            data: encodeSendThroughWebhook(recipientKey, webhookId, revenueShareToReceiver, resolveSenderToName),
+        });
+        instructions.push(sendInstruction);
+        const transaction = new Transaction().add(...instructions);
+        return this.sendTransaction(transaction, undefined, computeOptions);
     }
     /**
      * Pause the contract and distribute owner claimable funds (owner only)
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async pause(options) {
+    async pause(options, computeOptions) {
         const ownerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.wallet.publicKey);
         const mailerTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, this.mailerStatePda, true);
         const instruction = new TransactionInstruction({
@@ -623,14 +848,14 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.Pause),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction, options);
+        return await this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Unpause the contract (owner only)
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async unpause(options) {
+    async unpause(options, computeOptions) {
         const instruction = new TransactionInstruction({
             keys: [
                 { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
@@ -640,14 +865,14 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.Unpause),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction, options);
+        return await this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Emergency unpause without fund distribution (owner only)
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async emergencyUnpause(options) {
+    async emergencyUnpause(options, computeOptions) {
         const instruction = new TransactionInstruction({
             keys: [
                 { pubkey: this.wallet.publicKey, isSigner: true, isWritable: false },
@@ -657,7 +882,7 @@ export class MailerClient {
             data: encodeSimpleInstruction(InstructionType.EmergencyUnpause),
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction, options);
+        return await this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Distribute claimable funds to a recipient when contract is paused
@@ -665,7 +890,7 @@ export class MailerClient {
      * @param options Transaction confirm options
      * @returns Transaction signature
      */
-    async distributeClaimableFunds(recipient, options) {
+    async distributeClaimableFunds(recipient, options, computeOptions) {
         const recipientKey = typeof recipient === 'string' ? new PublicKey(recipient) : recipient;
         const [recipientClaimPda] = PublicKey.findProgramAddressSync([Buffer.from('claim'), recipientKey.toBuffer()], this.programId);
         const recipientTokenAccount = getAssociatedTokenAddressSync(this.usdcMint, recipientKey);
@@ -687,7 +912,7 @@ export class MailerClient {
             data,
         });
         const transaction = new Transaction().add(instruction);
-        return await this.sendTransaction(transaction, options);
+        return await this.sendTransaction(transaction, options, computeOptions);
     }
     /**
      * Get the current send fee
@@ -716,17 +941,24 @@ export class MailerClient {
      * @param options Confirm options
      * @returns Transaction signature
      */
-    async sendTransaction(transaction, options) {
+    async sendTransaction(transaction, options, computeOptions) {
+        // Optimize compute units if requested
+        const { transaction: optimizedTx, simulatedUnits } = await this.optimizeComputeUnits(transaction, computeOptions);
         // Get recent blockhash
         const { blockhash } = await this.connection.getLatestBlockhash();
-        transaction.recentBlockhash = blockhash;
-        transaction.feePayer = this.wallet.publicKey;
+        optimizedTx.recentBlockhash = blockhash;
+        optimizedTx.feePayer = this.wallet.publicKey;
         // Sign transaction
-        const signedTx = await this.wallet.signTransaction(transaction);
+        const signedTx = await this.wallet.signTransaction(optimizedTx);
         // Send and confirm
         const signature = await this.connection.sendRawTransaction(signedTx.serialize());
         await this.connection.confirmTransaction(signature, options?.commitment || 'confirmed');
-        return signature;
+        return {
+            signature,
+            simulatedUnits,
+            computeUnitLimit: computeOptions?.computeUnitLimit,
+            computeUnitPrice: computeOptions?.computeUnitPrice,
+        };
     }
     /**
      * Create a simple wallet from a keypair for testing