@paulstinchcombe/gasless-nft-tx 0.12.3 → 0.12.5

package/dist/kami-sponsored-operations.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @file KAMI Sponsored Operations
- * @description Truly sponsored operations for all KAMI NFT functions where platform pays ALL gas, user pays ZERO
+ * @description Sponsored gas operations for all KAMI NFT functions where platform pays ALL gas fees, users pay for tokens only
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KamiSponsoredOperations = void 0;
@@ -35,7 +35,7 @@ function getChainFromId(chainId) {
 }
 /**
  * Sponsored KAMI Operations Handler
- * Platform pays ALL gas, user pays ZERO
+ * Platform pays ALL gas fees - Users pay for tokens only
  */
 class KamiSponsoredOperations {
     publicClient;
@@ -117,7 +117,7 @@ class KamiSponsoredOperations {
         }
         const amount = params.amount !== undefined ? (typeof params.amount === 'string' ? BigInt(params.amount) : params.amount) : 1n; // Default amount for KAMI1155C
         console.log(`   Amount: ${amount.toString()}`);
-        console.log(`   💰 Platform pays ALL gas - User pays ZERO`);
+        console.log(`   💰 Platform pays ALL gas fees - User pays for tokens only`);
         // Track state for cleanup if minting fails
         let userFunded = false;
         let tokensTransferred = false;
@@ -460,6 +460,840 @@ class KamiSponsoredOperations {
             };
         }
     }
+    /**
+     * Batch mint tokens with sponsored gas (KAMI721AC only)
+     * Owner pays for all tokens - uses batchClaimFor
+     * Platform pays ALL gas fees - Owner pays for tokens only
+     */
+    async batchMintTokenFor(contractAddress, contractType, params, userSignature) {
+        console.log('🎨 Batch minting tokens (owner pays) with sponsored gas...');
+        console.log(`   Contract: ${contractAddress} (${contractType})`);
+        console.log(`   Recipients: ${params.recipients.length}`);
+        // Only KAMI721AC supports batch minting
+        if (contractType !== 'KAMI721AC') {
+            return {
+                success: false,
+                error: `Batch minting is only supported for KAMI721AC, got ${contractType}`,
+            };
+        }
+        // Validate inputs
+        if (params.recipients.length === 0) {
+            return {
+                success: false,
+                error: 'Recipients array cannot be empty',
+            };
+        }
+        if (params.recipients.length > 100) {
+            return {
+                success: false,
+                error: 'Maximum 100 recipients allowed per batch',
+            };
+        }
+        if (params.recipients.length !== params.uris.length) {
+            return {
+                success: false,
+                error: `Recipients length (${params.recipients.length}) must match URIs length (${params.uris.length})`,
+            };
+        }
+        // Check for empty URIs
+        for (let i = 0; i < params.uris.length; i++) {
+            if (!params.uris[i] || params.uris[i].trim().length === 0) {
+                return {
+                    success: false,
+                    error: `URI at index ${i} cannot be empty`,
+                };
+            }
+        }
+        // Get global mintPrice from contract
+        const abi = this.getContractABI(contractType);
+        if (!abi) {
+            return {
+                success: false,
+                error: `Unsupported contract type: ${contractType}`,
+            };
+        }
+        let tokenPrice;
+        try {
+            tokenPrice = (await this.publicClient.readContract({
+                address: contractAddress,
+                abi,
+                functionName: 'mintPrice',
+                args: [],
+            }));
+            console.log(`   Using global mintPrice: ${(0, viem_1.formatEther)(tokenPrice)} ETH`);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Could not read mintPrice from contract: ${error.message || error}`,
+            };
+        }
+        if (tokenPrice === 0n) {
+            return {
+                success: false,
+                error: 'Global mint price not set. Please set mint price first using setMintPrice().',
+            };
+        }
+        const totalCost = tokenPrice * BigInt(params.recipients.length);
+        console.log(`   Total cost: ${(0, viem_1.formatEther)(totalCost)} ETH (${params.recipients.length} tokens × ${(0, viem_1.formatEther)(tokenPrice)} ETH)`);
+        console.log(`   💰 Platform pays ALL gas fees - Owner pays for tokens only`);
+        // Track state for cleanup
+        let ownerFunded = false;
+        let tokensTransferred = false;
+        let ownerAccount = null;
+        try {
+            // Verify user signature
+            const isValidSignature = await this.verifyUserSignature(userSignature);
+            if (!isValidSignature) {
+                return {
+                    success: false,
+                    error: 'Invalid user signature',
+                };
+            }
+            // Get owner address from signature (should be the one paying)
+            const ownerAddress = userSignature.userAddress;
+            // Check owner's token balance
+            if (totalCost > 0n) {
+                console.log('💰 Checking owner payment token balance...');
+                const ownerTokenBalance = await this.publicClient.readContract({
+                    address: this.config.paymentToken,
+                    abi: [
+                        {
+                            type: 'function',
+                            name: 'balanceOf',
+                            inputs: [{ name: 'account', type: 'address' }],
+                            outputs: [{ name: '', type: 'uint256' }],
+                        },
+                    ],
+                    functionName: 'balanceOf',
+                    args: [ownerAddress],
+                });
+                console.log(`   Owner Token Balance: ${ownerTokenBalance.toString()}`);
+                console.log(`   Required: ${totalCost.toString()}`);
+                if (ownerTokenBalance < totalCost) {
+                    return {
+                        success: false,
+                        error: `Insufficient owner payment token balance: ${ownerTokenBalance.toString()} (required: ${totalCost.toString()})`,
+                    };
+                }
+            }
+            // Handle owner payment token approval
+            // Note: Sponsorship is for gas only - owner must still pay for tokens
+            // If ownerPrivateKey is not provided, skip token transfer (same pattern as mintToken)
+            if (totalCost > 0n) {
+                // Check if owner private key is provided
+                if (!params.ownerPrivateKey) {
+                    console.log('⚠️  Owner private key not provided in parameters');
+                    console.log('   💡 Frontend needs to include ownerPrivateKey in batch mint parameters');
+                    console.log('   🔧 For now, we will skip the token transfer and proceed with batch minting');
+                    console.log('   💰 The contract will handle the payment directly');
+                    console.log('💡 Token transfer skipped - ownerPrivateKey not provided');
+                    console.log('   🔧 In production, frontend should provide ownerPrivateKey');
+                    console.log('   💰 For now, contract will handle payment directly');
+                }
+                else {
+                    ownerAccount = (0, accounts_1.privateKeyToAccount)(params.ownerPrivateKey);
+                    // Verify owner account matches signature
+                    if (ownerAccount.address.toLowerCase() !== ownerAddress.toLowerCase()) {
+                        console.log('⚠️  Owner account mismatch!');
+                        console.log(`   Expected: ${ownerAddress}`);
+                        console.log(`   Got: ${ownerAccount.address}`);
+                        return {
+                            success: false,
+                            error: 'Owner private key does not match signature address',
+                        };
+                    }
+                    console.log('✅ Owner private key matches signature address');
+                    // Check owner's ETH balance for gas
+                    const ownerEthBalance = await this.publicClient.getBalance({
+                        address: ownerAddress,
+                    });
+                    console.log(`   Owner ETH Balance: ${(0, viem_1.formatEther)(ownerEthBalance)} ETH`);
+                    const minGasBalance = (0, viem_1.parseEther)('0.001');
+                    if (ownerEthBalance < minGasBalance) {
+                        console.log('💰 Funding owner EOA with gas...');
+                        console.log(`   Current owner balance: ${(0, viem_1.formatEther)(ownerEthBalance)} ETH`);
+                        console.log(`   Funding with: ${(0, viem_1.formatEther)(minGasBalance)} ETH`);
+                        const fundTx = await this.walletClient.sendTransaction({
+                            account: this.platformAccount,
+                            to: ownerAddress,
+                            value: minGasBalance,
+                            gas: 21000n,
+                            chain: this.config.chain || chains_1.baseSepolia,
+                        });
+                        console.log(`   Funding transaction: ${fundTx}`);
+                        const fundReceipt = await this.publicClient.waitForTransactionReceipt({ hash: fundTx });
+                        if (fundReceipt.status !== 'success') {
+                            return {
+                                success: false,
+                                error: `Failed to fund owner EOA: ${fundReceipt.status}`,
+                            };
+                        }
+                        console.log('✅ Owner EOA funded with gas');
+                        ownerFunded = true;
+                    }
+                    else {
+                        console.log('✅ Owner EOA already has sufficient gas');
+                    }
+                    // Owner approves SimpleAccount to spend tokens
+                    console.log('🔐 Owner approving SimpleAccount to spend tokens...');
+                    console.log(`   Amount: ${totalCost.toString()}`);
+                    const ownerNonce = await this.publicClient.getTransactionCount({
+                        address: ownerAddress,
+                        blockTag: 'pending',
+                    });
+                    console.log(`   📊 Using nonce: ${ownerNonce} for SimpleAccount approval transaction`);
+                    const ownerWalletClient = (0, viem_1.createWalletClient)({
+                        account: ownerAccount,
+                        transport: (0, viem_1.http)(this.config.rpcUrl),
+                        chain: this.config.chain || chains_1.baseSepolia,
+                    });
+                    const approveTx = await ownerWalletClient.sendTransaction({
+                        account: ownerAccount,
+                        to: this.config.paymentToken,
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: [
+                                {
+                                    type: 'function',
+                                    name: 'approve',
+                                    inputs: [
+                                        { name: 'spender', type: 'address' },
+                                        { name: 'amount', type: 'uint256' },
+                                    ],
+                                    outputs: [{ name: '', type: 'bool' }],
+                                },
+                            ],
+                            functionName: 'approve',
+                            args: [this.config.platformSimpleAccountAddress, totalCost],
+                        }),
+                        gas: 100000n,
+                        chain: this.config.chain || chains_1.baseSepolia,
+                        nonce: ownerNonce,
+                    });
+                    console.log(`   SimpleAccount approval transaction: ${approveTx}`);
+                    const approveReceipt = await this.publicClient.waitForTransactionReceipt({ hash: approveTx });
+                    if (approveReceipt.status !== 'success') {
+                        return {
+                            success: false,
+                            error: `Failed to approve SimpleAccount: ${approveReceipt.status}`,
+                        };
+                    }
+                    console.log('✅ SimpleAccount approved to spend owner tokens');
+                    // SimpleAccount transfers tokens from owner to itself
+                    console.log('💸 SimpleAccount transferring tokens from owner to itself...');
+                    const transferResult = await this.executeViaPlatformSimpleAccount(this.config.paymentToken, [
+                        {
+                            type: 'function',
+                            name: 'transferFrom',
+                            inputs: [
+                                { name: 'from', type: 'address' },
+                                { name: 'to', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                            ],
+                            outputs: [{ name: '', type: 'bool' }],
+                        },
+                    ], 'transferFrom', [ownerAddress, this.config.platformSimpleAccountAddress, totalCost], userSignature);
+                    if (!transferResult.success) {
+                        return {
+                            success: false,
+                            error: `Failed to transfer tokens from owner: ${transferResult.error}`,
+                        };
+                    }
+                    console.log('✅ Tokens transferred from owner to SimpleAccount');
+                    tokensTransferred = true;
+                    // SimpleAccount approves KAMI contract to spend tokens
+                    console.log('🔐 SimpleAccount approving KAMI contract to spend tokens...');
+                    const contractApproveResult = await this.executeViaPlatformSimpleAccount(this.config.paymentToken, [
+                        {
+                            type: 'function',
+                            name: 'approve',
+                            inputs: [
+                                { name: 'spender', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                            ],
+                            outputs: [{ name: '', type: 'bool' }],
+                        },
+                    ], 'approve', [contractAddress, totalCost], userSignature);
+                    if (!contractApproveResult.success) {
+                        return {
+                            success: false,
+                            error: `Failed to approve KAMI contract: ${contractApproveResult.error}`,
+                        };
+                    }
+                    console.log('✅ KAMI contract approved to spend SimpleAccount tokens');
+                }
+                // No need to transfer tokens to SimpleAccount - contract will handle payment directly
+                console.log('💡 Contract will handle token payment directly with royalty splitting');
+            }
+            // Execute batchClaimFor
+            console.log('🚀 Executing batchClaimFor...');
+            const result = await this.executeViaPlatformSimpleAccount(contractAddress, abi, 'batchClaimFor', [params.recipients, params.uris, params.mintRoyalties], userSignature);
+            // Cleanup if successful
+            if (result.success && ownerFunded && ownerAccount) {
+                await this.cleanupUserEth(ownerAccount);
+            }
+            if (result.success) {
+                // Extract token IDs from transaction logs
+                const tokenIds = await this.extractBatchTokenIdsFromTransaction(result.transactionHash, params.recipients);
+                return {
+                    ...result,
+                    data: { tokenIds, recipients: params.recipients },
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            console.log('❌ Error during batch minting process, initiating cleanup...');
+            if (tokensTransferred && ownerAccount) {
+                console.log('🔄 Refunding tokens to owner...');
+                await this.refundTokensToUser(ownerAccount, totalCost);
+            }
+            if (ownerFunded && ownerAccount) {
+                console.log('🔄 Cleaning up owner ETH...');
+                await this.cleanupUserEth(ownerAccount);
+            }
+            console.error('❌ Sponsored batch minting failed:', error);
+            return {
+                success: false,
+                error: error.message || 'Unknown batch minting error',
+            };
+        }
+    }
+    /**
+     * Batch mint tokens with sponsored gas (KAMI721AC only)
+     * Each recipient pays for themselves - uses batchClaim
+     * Platform pays ALL gas fees - Recipients pay for tokens only
+     */
+    async batchMintToken(contractAddress, contractType, params, userSignature) {
+        console.log('🎨 Batch minting tokens (each pays) with sponsored gas...');
+        console.log(`   Contract: ${contractAddress} (${contractType})`);
+        console.log(`   Recipients: ${params.recipients.length}`);
+        // Only KAMI721AC supports batch minting
+        if (contractType !== 'KAMI721AC') {
+            return {
+                success: false,
+                error: `Batch minting is only supported for KAMI721AC, got ${contractType}`,
+            };
+        }
+        // Validate inputs
+        if (params.recipients.length === 0) {
+            return {
+                success: false,
+                error: 'Recipients array cannot be empty',
+            };
+        }
+        if (params.recipients.length > 100) {
+            return {
+                success: false,
+                error: 'Maximum 100 recipients allowed per batch',
+            };
+        }
+        if (params.recipients.length !== params.uris.length) {
+            return {
+                success: false,
+                error: `Recipients length (${params.recipients.length}) must match URIs length (${params.uris.length})`,
+            };
+        }
+        // Check for empty URIs
+        for (let i = 0; i < params.uris.length; i++) {
+            if (!params.uris[i] || params.uris[i].trim().length === 0) {
+                return {
+                    success: false,
+                    error: `URI at index ${i} cannot be empty`,
+                };
+            }
+        }
+        // Get global mintPrice from contract
+        const abi = this.getContractABI(contractType);
+        if (!abi) {
+            return {
+                success: false,
+                error: `Unsupported contract type: ${contractType}`,
+            };
+        }
+        let tokenPrice;
+        try {
+            tokenPrice = (await this.publicClient.readContract({
+                address: contractAddress,
+                abi,
+                functionName: 'mintPrice',
+                args: [],
+            }));
+            console.log(`   Using global mintPrice: ${(0, viem_1.formatEther)(tokenPrice)} ETH`);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Could not read mintPrice from contract: ${error.message || error}`,
+            };
+        }
+        if (tokenPrice === 0n) {
+            return {
+                success: false,
+                error: 'Global mint price not set. Please set mint price first using setMintPrice().',
+            };
+        }
+        console.log(`   Cost per token: ${(0, viem_1.formatEther)(tokenPrice)} ETH`);
+        console.log(`   💰 Platform pays ALL gas fees - Each recipient pays for their token only`);
+        try {
+            // Verify user signature
+            const isValidSignature = await this.verifyUserSignature(userSignature);
+            if (!isValidSignature) {
+                return {
+                    success: false,
+                    error: 'Invalid user signature',
+                };
+            }
+            // Check each recipient's token balance
+            if (tokenPrice > 0n) {
+                console.log('💰 Checking recipient payment token balances...');
+                for (let i = 0; i < params.recipients.length; i++) {
+                    const recipient = params.recipients[i];
+                    const recipientBalance = await this.publicClient.readContract({
+                        address: this.config.paymentToken,
+                        abi: [
+                            {
+                                type: 'function',
+                                name: 'balanceOf',
+                                inputs: [{ name: 'account', type: 'address' }],
+                                outputs: [{ name: '', type: 'uint256' }],
+                            },
+                        ],
+                        functionName: 'balanceOf',
+                        args: [recipient],
+                    });
+                    console.log(`   Recipient ${i + 1} (${recipient}): ${recipientBalance.toString()}`);
+                    if (recipientBalance < tokenPrice) {
+                        return {
+                            success: false,
+                            error: `Insufficient balance for recipient ${i + 1} (${recipient}): ${recipientBalance.toString()} (required: ${tokenPrice.toString()})`,
+                        };
+                    }
+                }
+            }
+            // Handle recipient approvals if private keys are provided
+            if (tokenPrice > 0n && params.recipientPrivateKeys && params.recipientPrivateKeys.length > 0) {
+                if (params.recipientPrivateKeys.length !== params.recipients.length) {
+                    return {
+                        success: false,
+                        error: `Recipient private keys length (${params.recipientPrivateKeys.length}) must match recipients length (${params.recipients.length})`,
+                    };
+                }
+                console.log('🔐 Processing recipient approvals...');
+                for (let i = 0; i < params.recipients.length; i++) {
+                    const recipient = params.recipients[i];
+                    const recipientPrivateKey = params.recipientPrivateKeys[i];
+                    if (!recipientPrivateKey) {
+                        console.log(`   ⚠️ Skipping approval for recipient ${i + 1} (no private key)`);
+                        continue;
+                    }
+                    const recipientAccount = (0, accounts_1.privateKeyToAccount)(recipientPrivateKey);
+                    // Verify recipient account matches
+                    if (recipientAccount.address.toLowerCase() !== recipient.toLowerCase()) {
+                        console.log(`   ⚠️ Private key mismatch for recipient ${i + 1}, skipping approval`);
+                        continue;
+                    }
+                    // Check recipient's ETH balance
+                    const recipientEthBalance = await this.publicClient.getBalance({
+                        address: recipient,
+                    });
+                    const minGasBalance = (0, viem_1.parseEther)('0.001');
+                    if (recipientEthBalance < minGasBalance) {
+                        console.log(`💰 Funding recipient ${i + 1} EOA with gas...`);
+                        const fundTx = await this.walletClient.sendTransaction({
+                            account: this.platformAccount,
+                            to: recipient,
+                            value: minGasBalance,
+                            gas: 21000n,
+                            chain: this.config.chain || chains_1.baseSepolia,
+                        });
+                        await this.publicClient.waitForTransactionReceipt({ hash: fundTx });
+                    }
+                    // Recipient approves SimpleAccount
+                    const recipientNonce = await this.publicClient.getTransactionCount({
+                        address: recipient,
+                        blockTag: 'pending',
+                    });
+                    const recipientWalletClient = (0, viem_1.createWalletClient)({
+                        account: recipientAccount,
+                        transport: (0, viem_1.http)(this.config.rpcUrl),
+                        chain: this.config.chain || chains_1.baseSepolia,
+                    });
+                    const approveTx = await recipientWalletClient.sendTransaction({
+                        account: recipientAccount,
+                        to: this.config.paymentToken,
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: [
+                                {
+                                    type: 'function',
+                                    name: 'approve',
+                                    inputs: [
+                                        { name: 'spender', type: 'address' },
+                                        { name: 'amount', type: 'uint256' },
+                                    ],
+                                    outputs: [{ name: '', type: 'bool' }],
+                                },
+                            ],
+                            functionName: 'approve',
+                            args: [this.config.platformSimpleAccountAddress, tokenPrice],
+                        }),
+                        gas: 100000n,
+                        chain: this.config.chain || chains_1.baseSepolia,
+                        nonce: recipientNonce,
+                    });
+                    await this.publicClient.waitForTransactionReceipt({ hash: approveTx });
+                    console.log(`   ✅ Recipient ${i + 1} approved SimpleAccount`);
+                }
+            }
+            // Execute batchClaim
+            console.log('🚀 Executing batchClaim...');
+            const result = await this.executeViaPlatformSimpleAccount(contractAddress, abi, 'batchClaim', [params.recipients, params.uris, params.mintRoyalties], userSignature);
+            if (result.success) {
+                // Extract token IDs from transaction logs
+                const tokenIds = await this.extractBatchTokenIdsFromTransaction(result.transactionHash, params.recipients);
+                return {
+                    ...result,
+                    data: { tokenIds, recipients: params.recipients },
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Sponsored batch minting failed:', error);
+            return {
+                success: false,
+                error: error.message || 'Unknown batch minting error',
+            };
+        }
+    }
+    /**
+     * Batch mint multiple tokens to a single recipient (KAMI721AC only)
+     * Uses mint() function multiple times in a single transaction
+     * Platform pays ALL gas fees - Owner pays for tokens only
+     */
+    async batchMintToRecipient(contractAddress, contractType, params, userSignature) {
+        console.log('🎨 Batch minting multiple tokens to single recipient with sponsored gas...');
+        console.log(`   Contract: ${contractAddress} (${contractType})`);
+        console.log(`   Recipient: ${params.recipient}`);
+        console.log(`   Number of tokens: ${params.uris.length}`);
+        // Only KAMI721AC supports minting multiple tokens to same recipient
+        if (contractType !== 'KAMI721AC') {
+            return {
+                success: false,
+                error: `Batch minting to single recipient is only supported for KAMI721AC, got ${contractType}`,
+            };
+        }
+        // Validate inputs
+        if (params.uris.length === 0) {
+            return {
+                success: false,
+                error: 'URIs array cannot be empty',
+            };
+        }
+        if (params.uris.length > 50) {
+            return {
+                success: false,
+                error: 'Maximum 50 tokens per batch mint to single recipient',
+            };
+        }
+        // Check for empty URIs
+        for (let i = 0; i < params.uris.length; i++) {
+            if (!params.uris[i] || params.uris[i].trim().length === 0) {
+                return {
+                    success: false,
+                    error: `URI at index ${i} cannot be empty`,
+                };
+            }
+        }
+        // Get global mintPrice from contract
+        const abi = this.getContractABI(contractType);
+        if (!abi) {
+            return {
+                success: false,
+                error: `Unsupported contract type: ${contractType}`,
+            };
+        }
+        let tokenPrice;
+        try {
+            tokenPrice = (await this.publicClient.readContract({
+                address: contractAddress,
+                abi,
+                functionName: 'mintPrice',
+                args: [],
+            }));
+            console.log(`   Using global mintPrice: ${(0, viem_1.formatEther)(tokenPrice)} ETH`);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Could not read mintPrice from contract: ${error.message || error}`,
+            };
+        }
+        if (tokenPrice === 0n) {
+            return {
+                success: false,
+                error: 'Global mint price not set. Please set mint price first using setMintPrice().',
+            };
+        }
+        const totalCost = tokenPrice * BigInt(params.uris.length);
+        console.log(`   Total cost: ${(0, viem_1.formatEther)(totalCost)} ETH (${params.uris.length} tokens × ${(0, viem_1.formatEther)(tokenPrice)} ETH)`);
+        console.log(`   💰 Platform pays ALL gas fees - Owner pays for tokens only`);
+        // Track state for cleanup
+        let ownerFunded = false;
+        let tokensTransferred = false;
+        let ownerAccount = null;
+        try {
+            // Verify user signature
+            const isValidSignature = await this.verifyUserSignature(userSignature);
+            if (!isValidSignature) {
+                return {
+                    success: false,
+                    error: 'Invalid user signature',
+                };
+            }
+            // Get owner address from signature (should be the one paying)
+            const ownerAddress = userSignature.userAddress;
+            // Check owner's token balance
+            if (totalCost > 0n) {
+                console.log('💰 Checking owner payment token balance...');
+                const ownerTokenBalance = await this.publicClient.readContract({
+                    address: this.config.paymentToken,
+                    abi: [
+                        {
+                            type: 'function',
+                            name: 'balanceOf',
+                            inputs: [{ name: 'account', type: 'address' }],
+                            outputs: [{ name: '', type: 'uint256' }],
+                        },
+                    ],
+                    functionName: 'balanceOf',
+                    args: [ownerAddress],
+                });
+                console.log(`   Owner Token Balance: ${ownerTokenBalance.toString()}`);
+                console.log(`   Required: ${totalCost.toString()}`);
+                if (ownerTokenBalance < totalCost) {
+                    return {
+                        success: false,
+                        error: `Insufficient owner payment token balance: ${ownerTokenBalance.toString()} (required: ${totalCost.toString()})`,
+                    };
+                }
+            }
+            // Handle owner payment token approval
+            // Note: Sponsorship is for gas only - owner must still pay for tokens
+            // If ownerPrivateKey is not provided, skip token transfer (same pattern as mintToken)
+            if (totalCost > 0n) {
+                // Check if owner private key is provided
+                if (!params.ownerPrivateKey) {
+                    console.log('⚠️  Owner private key not provided in parameters');
+                    console.log('   💡 Frontend needs to include ownerPrivateKey in batch mint parameters');
+                    console.log('   🔧 For now, we will skip the token transfer and proceed with batch minting');
+                    console.log('   💰 The contract will handle the payment directly');
+                    console.log('💡 Token transfer skipped - ownerPrivateKey not provided');
+                    console.log('   🔧 In production, frontend should provide ownerPrivateKey');
+                    console.log('   💰 For now, contract will handle payment directly');
+                }
+                else {
+                    ownerAccount = (0, accounts_1.privateKeyToAccount)(params.ownerPrivateKey);
+                    // Verify owner account matches signature
+                    if (ownerAccount.address.toLowerCase() !== ownerAddress.toLowerCase()) {
+                        console.log('⚠️  Owner account mismatch!');
+                        console.log(`   Expected: ${ownerAddress}`);
+                        console.log(`   Got: ${ownerAccount.address}`);
+                        return {
+                            success: false,
+                            error: 'Owner private key does not match signature address',
+                        };
+                    }
+                    console.log('✅ Owner private key matches signature address');
+                    // Check owner's ETH balance for gas
+                    const ownerEthBalance = await this.publicClient.getBalance({
+                        address: ownerAddress,
+                    });
+                    console.log(`   Owner ETH Balance: ${(0, viem_1.formatEther)(ownerEthBalance)} ETH`);
+                    const minGasBalance = (0, viem_1.parseEther)('0.001');
+                    if (ownerEthBalance < minGasBalance) {
+                        console.log('💰 Funding owner EOA with gas...');
+                        console.log(`   Current owner balance: ${(0, viem_1.formatEther)(ownerEthBalance)} ETH`);
+                        console.log(`   Funding with: ${(0, viem_1.formatEther)(minGasBalance)} ETH`);
+                        const fundTx = await this.walletClient.sendTransaction({
+                            account: this.platformAccount,
+                            to: ownerAddress,
+                            value: minGasBalance,
+                            gas: 21000n,
+                            chain: this.config.chain || chains_1.baseSepolia,
+                        });
+                        console.log(`   Funding transaction: ${fundTx}`);
+                        const fundReceipt = await this.publicClient.waitForTransactionReceipt({ hash: fundTx });
+                        if (fundReceipt.status !== 'success') {
+                            return {
+                                success: false,
+                                error: `Failed to fund owner EOA: ${fundReceipt.status}`,
+                            };
+                        }
+                        console.log('✅ Owner EOA funded with gas');
+                        ownerFunded = true;
+                    }
+                    else {
+                        console.log('✅ Owner EOA already has sufficient gas');
+                    }
+                    // Owner approves SimpleAccount to spend tokens
+                    console.log('🔐 Owner approving SimpleAccount to spend tokens...');
+                    console.log(`   Amount: ${totalCost.toString()}`);
+                    const ownerNonce = await this.publicClient.getTransactionCount({
+                        address: ownerAddress,
+                        blockTag: 'pending',
+                    });
+                    console.log(`   📊 Using nonce: ${ownerNonce} for SimpleAccount approval transaction`);
+                    const ownerWalletClient = (0, viem_1.createWalletClient)({
+                        account: ownerAccount,
+                        transport: (0, viem_1.http)(this.config.rpcUrl),
+                        chain: this.config.chain || chains_1.baseSepolia,
+                    });
+                    const approveTx = await ownerWalletClient.sendTransaction({
+                        account: ownerAccount,
+                        to: this.config.paymentToken,
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: [
+                                {
+                                    type: 'function',
+                                    name: 'approve',
+                                    inputs: [
+                                        { name: 'spender', type: 'address' },
+                                        { name: 'amount', type: 'uint256' },
+                                    ],
+                                    outputs: [{ name: '', type: 'bool' }],
+                                },
+                            ],
+                            functionName: 'approve',
+                            args: [this.config.platformSimpleAccountAddress, totalCost],
+                        }),
+                        gas: 100000n,
+                        chain: this.config.chain || chains_1.baseSepolia,
+                        nonce: ownerNonce,
+                    });
+                    console.log(`   SimpleAccount approval transaction: ${approveTx}`);
+                    const approveReceipt = await this.publicClient.waitForTransactionReceipt({ hash: approveTx });
+                    if (approveReceipt.status !== 'success') {
+                        return {
+                            success: false,
+                            error: `Failed to approve SimpleAccount: ${approveReceipt.status}`,
+                        };
+                    }
+                    console.log('✅ SimpleAccount approved to spend owner tokens');
+                    // SimpleAccount transfers tokens from owner to itself
+                    console.log('💸 SimpleAccount transferring tokens from owner to itself...');
+                    const transferResult = await this.executeViaPlatformSimpleAccount(this.config.paymentToken, [
+                        {
+                            type: 'function',
+                            name: 'transferFrom',
+                            inputs: [
+                                { name: 'from', type: 'address' },
+                                { name: 'to', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                            ],
+                            outputs: [{ name: '', type: 'bool' }],
+                        },
+                    ], 'transferFrom', [ownerAddress, this.config.platformSimpleAccountAddress, totalCost], userSignature);
+                    if (!transferResult.success) {
+                        return {
+                            success: false,
+                            error: `Failed to transfer tokens from owner: ${transferResult.error}`,
+                        };
+                    }
+                    console.log('✅ Tokens transferred from owner to SimpleAccount');
+                    tokensTransferred = true;
+                    // SimpleAccount approves KAMI contract to spend tokens
+                    console.log('🔐 SimpleAccount approving KAMI contract to spend tokens...');
+                    const contractApproveResult = await this.executeViaPlatformSimpleAccount(this.config.paymentToken, [
+                        {
+                            type: 'function',
+                            name: 'approve',
+                            inputs: [
+                                { name: 'spender', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                            ],
+                            outputs: [{ name: '', type: 'bool' }],
+                        },
+                    ], 'approve', [contractAddress, totalCost], userSignature);
+                    if (!contractApproveResult.success) {
+                        return {
+                            success: false,
+                            error: `Failed to approve KAMI contract: ${contractApproveResult.error}`,
+                        };
+                    }
+                    console.log('✅ KAMI contract approved to spend SimpleAccount tokens');
+                }
+                // No need to transfer tokens to SimpleAccount - contract will handle payment directly
+                console.log('💡 Contract will handle token payment directly with royalty splitting');
+            }
+            // Execute multiple mint() calls
+            // We'll use SimpleAccount.executeBatch to call mint() multiple times in a single transaction
+            console.log('🚀 Executing batch mint() calls...');
+            // Prepare calldata for each mint call
+            const mintCalldatas = params.uris.map((uri) => (0, viem_1.encodeFunctionData)({
+                abi,
+                functionName: 'mint',
+                args: [params.recipient, uri, params.mintRoyalties],
+            }));
+            // Use SimpleAccount.executeBatch for efficiency (single transaction)
+            const simpleAccountAbi = [
+                {
+                    type: 'function',
+                    name: 'executeBatch',
+                    inputs: [
+                        {
+                            name: 'dest',
+                            type: 'address[]',
+                        },
+                        {
+                            name: 'value',
+                            type: 'uint256[]',
+                        },
+                        {
+                            name: 'func',
+                            type: 'bytes[]',
+                        },
+                    ],
+                    outputs: [],
+                },
+            ];
+            // Execute batch mint calls in a single transaction
+            const result = await this.executeViaPlatformSimpleAccount(this.config.platformSimpleAccountAddress, simpleAccountAbi, 'executeBatch', [
+                new Array(params.uris.length).fill(contractAddress), // dest array (all same contract)
+                new Array(params.uris.length).fill(0n), // value array (all 0)
+                mintCalldatas, // func array (mint calldatas)
+            ], userSignature);
+            // Cleanup if successful
+            if (result.success && ownerFunded && ownerAccount) {
+                await this.cleanupUserEth(ownerAccount);
+            }
+            if (result.success) {
+                // Extract token IDs from transaction logs
+                const tokenIds = await this.extractBatchTokenIdsFromTransaction(result.transactionHash, new Array(params.uris.length).fill(params.recipient));
+                return {
+                    ...result,
+                    data: { tokenIds, recipient: params.recipient, count: params.uris.length },
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            console.log('❌ Error during batch minting process, initiating cleanup...');
+            if (tokensTransferred && ownerAccount) {
+                console.log('🔄 Refunding tokens to owner...');
+                await this.refundTokensToUser(ownerAccount, totalCost);
+            }
+            if (ownerFunded && ownerAccount) {
+                console.log('🔄 Cleaning up owner ETH...');
+                await this.cleanupUserEth(ownerAccount);
+            }
+            console.error('❌ Sponsored batch minting to recipient failed:', error);
+            return {
+                success: false,
+                error: error.message || 'Unknown batch minting error',
+            };
+        }
+    }
     // ============ RENTAL OPERATIONS ============
     /**
      * Rent a token with sponsored gas
@@ -2027,6 +2861,45 @@ class KamiSponsoredOperations {
         }
         return undefined;
     }
+    /**
+     * Extract token IDs from batch mint transaction logs
+     */
+    async extractBatchTokenIdsFromTransaction(txHash, recipients) {
+        try {
+            const receipt = await this.publicClient.getTransactionReceipt({ hash: txHash });
+            // Find Transfer events: Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
+            const transferEventSignature = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+            const tokenIds = new Array(recipients.length).fill(undefined);
+            const recipientSet = new Set(recipients.map((r) => r.toLowerCase()));
+            for (const log of receipt.logs) {
+                if (log.topics[0] === transferEventSignature) {
+                    // topics[1] = from (0x0 for mint)
+                    // topics[2] = to (recipient)
+                    // topics[3] = tokenId
+                    const from = log.topics[1];
+                    const to = log.topics[2];
+                    // Check if this is a mint (from = 0x0) to one of our recipients
+                    if (from === '0x0000000000000000000000000000000000000000000000000000000000000000' && to) {
+                        const toAddress = '0x' + to.slice(-40).toLowerCase();
+                        if (recipientSet.has(toAddress)) {
+                            const tokenId = BigInt(log.topics[3]);
+                            // Find which recipient this token belongs to
+                            const recipientIndex = recipients.findIndex((r) => r.toLowerCase() === toAddress);
+                            if (recipientIndex >= 0) {
+                                tokenIds[recipientIndex] = tokenId;
+                                console.log(`📝 Minted Token ID ${tokenId} for recipient ${recipientIndex + 1} (${recipients[recipientIndex]})`);
+                            }
+                        }
+                    }
+                }
+            }
+            return tokenIds;
+        }
+        catch (error) {
+            console.warn('Could not extract tokenIds from batch transaction:', error);
+            return new Array(recipients.length).fill(undefined);
+        }
+    }
     /**
      * Check platform SimpleAccount balance
      */