coinley-checkout 1.1.9 → 1.2.0

package/dist/coinley-checkout.es.js

@@ -18628,34 +18628,68 @@ const sendNativeTransaction = async (walletConnection, toAddress, amount) => {
         if (!phantomProvider || !phantomProvider.isConnected) {
           throw new Error("Phantom wallet not connected");
         }
-        const { Connection, PublicKey, Transaction: Transaction2, SystemProgram, LAMPORTS_PER_SOL } = await import("./index.browser.esm-0402aa17.mjs").then((n2) => n2.i);
-        const connection = new Connection(NETWORK_CONFIG[NETWORK_TYPES.SOLANA].rpcUrl);
-        const fromPubkey = walletConnection.publicKey;
-        const toPubkey = new PublicKey(toAddress);
         const amountFloat = parseFloat(amount);
-        const lamports = Math.floor(amountFloat * LAMPORTS_PER_SOL);
-        console.log("Sending SOL:", {
-          from: fromPubkey.toString(),
-          to: toAddress,
-          amount: amountFloat,
-          lamports,
-          debug: `${amountFloat} SOL = ${lamports} lamports`
+        console.log("Phantom SOL Transaction Debug:", {
+          originalAmount: amount,
+          amountFloat,
+          walletType: "Phantom Native SOL"
         });
-        if (lamports <= 0) {
-          throw new Error(`Invalid amount: ${amount} SOL converts to ${lamports} lamports`);
+        try {
+          if (phantomProvider.request) {
+            const result = await phantomProvider.request({
+              method: "transfer",
+              params: {
+                to: toAddress,
+                amount: amountFloat
+                // Send in SOL, not lamports
+              }
+            });
+            console.log("Phantom transfer result:", result);
+            transaction = result;
+          } else {
+            let Connection, PublicKey, Transaction2, SystemProgram, LAMPORTS_PER_SOL;
+            try {
+              const solanaWeb3 = await import("./index.browser.esm-f4fd5f63.mjs").then((n2) => n2.l);
+              Connection = solanaWeb3.Connection;
+              PublicKey = solanaWeb3.PublicKey;
+              Transaction2 = solanaWeb3.Transaction;
+              SystemProgram = solanaWeb3.SystemProgram;
+              LAMPORTS_PER_SOL = solanaWeb3.LAMPORTS_PER_SOL;
+            } catch (importError) {
+              console.error("Failed to import Solana libraries:", importError);
+              throw new Error("Solana libraries not available. Please ensure @solana/web3.js is installed.");
+            }
+            const connection = new Connection(NETWORK_CONFIG[NETWORK_TYPES.SOLANA].rpcUrl);
+            const fromPubkey = walletConnection.publicKey;
+            const toPubkey = new PublicKey(toAddress);
+            const lamports = Math.floor(amountFloat * LAMPORTS_PER_SOL);
+            console.log("Manual Solana transaction:", {
+              from: fromPubkey.toString(),
+              to: toAddress,
+              amountSOL: amountFloat,
+              lamports,
+              conversionCheck: `${amountFloat} SOL = ${lamports} lamports`
+            });
+            if (lamports <= 0) {
+              throw new Error(`Invalid amount: ${amountFloat} SOL converts to ${lamports} lamports`);
+            }
+            const transferTransaction = new Transaction2().add(
+              SystemProgram.transfer({
+                fromPubkey,
+                toPubkey,
+                lamports
+              })
+            );
+            const { blockhash } = await connection.getLatestBlockhash();
+            transferTransaction.recentBlockhash = blockhash;
+            transferTransaction.feePayer = fromPubkey;
+            const signedTransaction = await phantomProvider.signAndSendTransaction(transferTransaction);
+            transaction = signedTransaction;
+          }
+        } catch (phantomError) {
+          console.error("Phantom transaction error:", phantomError);
+          throw new Error(`Phantom transaction failed: ${phantomError.message || "Unknown error"}`);
         }
-        const transferTransaction = new Transaction2().add(
-          SystemProgram.transfer({
-            fromPubkey,
-            toPubkey,
-            lamports
-          })
-        );
-        const { blockhash } = await connection.getLatestBlockhash();
-        transferTransaction.recentBlockhash = blockhash;
-        transferTransaction.feePayer = fromPubkey;
-        const signedTransaction = await phantomProvider.signAndSendTransaction(transferTransaction);
-        transaction = signedTransaction;
         break;
       default:
         throw new Error(`Unsupported wallet type: ${walletConnection.walletType}`);
@@ -18715,7 +18749,9 @@ const sendTokenTransaction = async (walletConnection, tokenConfig, toAddress, am
   }
 };
 const sendSolanaTokenTransaction = async (walletConnection, tokenConfig, toAddress, amount) => {
-  console.log("Sending Solana token transaction with:", { tokenConfig, toAddress, amount });
+  console.log("=== SOLANA TOKEN TRANSACTION DEBUG ===");
+  console.log("Input params:", { tokenConfig, toAddress, amount });
+  console.log("Wallet connection:", walletConnection);
   if (!walletConnection || !walletConnection.provider) {
     throw new Error("Phantom wallet not connected");
   }
@@ -18729,26 +18765,51 @@ const sendSolanaTokenTransaction = async (walletConnection, tokenConfig, toAddre
   const { contractAddress, decimals, symbol } = tokenConfig;
   const tokenAmount = parseFloat(amount);
   const tokenDecimals = parseInt(decimals);
+  console.log("Token config details:", {
+    symbol,
+    contractAddress,
+    decimals: tokenDecimals,
+    inputAmount: tokenAmount
+  });
   const amountInSmallestUnit = Math.floor(tokenAmount * Math.pow(10, tokenDecimals));
-  console.log(`Sending ${tokenAmount} ${symbol}:`, {
+  console.log("Amount calculation:", {
     tokenAmount,
     decimals: tokenDecimals,
+    calculation: `${tokenAmount} * 10^${tokenDecimals}`,
     amountInSmallestUnit,
-    debug: `${tokenAmount} ${symbol} = ${amountInSmallestUnit} base units (10^${tokenDecimals})`
+    humanReadable: `${tokenAmount} ${symbol} = ${amountInSmallestUnit} micro-${symbol}`
   });
   if (amountInSmallestUnit <= 0) {
     throw new Error(`Invalid amount: ${tokenAmount} ${symbol} converts to ${amountInSmallestUnit} base units`);
   }
   if (tokenAmount < 1 && amountInSmallestUnit === 0) {
-    throw new Error(`Amount too small: ${tokenAmount} ${symbol} is smaller than the minimum unit (1/${Math.pow(10, tokenDecimals)})`);
+    throw new Error(`Amount too small: ${tokenAmount} ${symbol} is smaller than the minimum unit (1/${Math.pow(10, tokenDecimals)} ${symbol})`);
   }
   try {
-    const { Connection, PublicKey, Transaction: Transaction2 } = await import("./index.browser.esm-0402aa17.mjs").then((n2) => n2.i);
-    const { createTransferInstruction, getAssociatedTokenAddress, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } = await import("./index-8e44c7ca.mjs");
+    let Connection, PublicKey, Transaction2, createTransferInstruction, getAssociatedTokenAddress, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID;
+    try {
+      const solanaWeb3 = await import("./index.browser.esm-f4fd5f63.mjs").then((n2) => n2.l);
+      const splToken = await import("./index-0fb9796c.mjs");
+      Connection = solanaWeb3.Connection;
+      PublicKey = solanaWeb3.PublicKey;
+      Transaction2 = solanaWeb3.Transaction;
+      createTransferInstruction = splToken.createTransferInstruction;
+      getAssociatedTokenAddress = splToken.getAssociatedTokenAddress;
+      TOKEN_PROGRAM_ID = splToken.TOKEN_PROGRAM_ID;
+      ASSOCIATED_TOKEN_PROGRAM_ID = splToken.ASSOCIATED_TOKEN_PROGRAM_ID;
+    } catch (importError) {
+      console.error("Failed to import Solana libraries:", importError);
+      throw new Error("Solana libraries not available. Please ensure @solana/web3.js and @solana/spl-token are installed.");
+    }
     const connection = new Connection(NETWORK_CONFIG[NETWORK_TYPES.SOLANA].rpcUrl);
     const fromPubkey = walletConnection.publicKey;
     const toPubkey = new PublicKey(toAddress);
     const mintPubkey = new PublicKey(contractAddress);
+    console.log("Public keys:", {
+      from: fromPubkey.toString(),
+      to: toPubkey.toString(),
+      mint: mintPubkey.toString()
+    });
     const fromTokenAccount = await getAssociatedTokenAddress(
       mintPubkey,
       fromPubkey,
@@ -18764,16 +18825,15 @@ const sendSolanaTokenTransaction = async (walletConnection, tokenConfig, toAddre
       ASSOCIATED_TOKEN_PROGRAM_ID
     );
     console.log("Token accounts:", {
-      from: fromTokenAccount.toString(),
-      to: toTokenAccount.toString(),
-      mint: mintPubkey.toString()
+      fromTokenAccount: fromTokenAccount.toString(),
+      toTokenAccount: toTokenAccount.toString()
     });
+    console.log("Creating transfer instruction with amount:", amountInSmallestUnit);
     const transferInstruction = createTransferInstruction(
       fromTokenAccount,
       toTokenAccount,
       fromPubkey,
       amountInSmallestUnit,
-      // This should be the correct amount now
       [],
       TOKEN_PROGRAM_ID
     );
@@ -18781,19 +18841,24 @@ const sendSolanaTokenTransaction = async (walletConnection, tokenConfig, toAddre
     const { blockhash } = await connection.getLatestBlockhash();
     transaction.recentBlockhash = blockhash;
     transaction.feePayer = fromPubkey;
+    console.log("Transaction created, sending to Phantom...");
     const signedTransaction = await phantomProvider.signAndSendTransaction(transaction);
-    console.log("Solana token transaction sent:", signedTransaction);
+    console.log("✅ Solana token transaction sent successfully:", signedTransaction);
+    console.log("=== END SOLANA TOKEN TRANSACTION DEBUG ===");
     return signedTransaction.signature || signedTransaction;
   } catch (error) {
-    console.error("Solana token transaction error:", error);
+    console.error("❌ Solana token transaction error:", error);
+    console.log("=== END SOLANA TOKEN TRANSACTION DEBUG (ERROR) ===");
     if (error.message && error.message.includes("User rejected")) {
       throw new Error("Transaction rejected by user");
     } else if (error.message && error.message.includes("Insufficient")) {
       throw new Error("Insufficient token balance");
-    } else if (error.message && error.message.includes("Invalid amount")) {
+    } else if (error.message && error.message.includes("Invalid amount") || error.message && error.message.includes("Amount too small")) {
       throw error;
-    } else {
+    } else if (error.message && error.message.includes("Solana libraries not available")) {
       throw error;
+    } else {
+      throw new Error(`Token transaction failed: ${error.message || "Unknown error"}`);
     }
   }
 };