@flashbacktech/flashbackclient 0.1.51 → 0.1.53

package/dist/stellarv2/wallet/transaction.js

@@ -71,47 +71,80 @@ const getHorizonServer = (network) => {
 };
 exports.getHorizonServer = getHorizonServer;
 const executeWalletTransaction = async (context, wallet_address, method, additionalArgs = []) => {
-    const response = await prepareTransaction(context, wallet_address, {
-        method,
-        args: [{ value: wallet_address, type: "address" }, ...additionalArgs],
-    });
-    if (response.isSuccess) {
-        if (response.isReadOnly) {
-            return response;
+    try {
+        console.log('executeWalletTransaction: Starting execution', { method, wallet_address, additionalArgs });
+        console.log('executeWalletTransaction: Calling prepareTransaction...');
+        const response = await prepareTransaction(context, wallet_address, {
+            method,
+            args: [{ value: wallet_address, type: "address" }, ...additionalArgs],
+        });
+        console.log('executeWalletTransaction: prepareTransaction response:', { isSuccess: response.isSuccess, isReadOnly: response.isReadOnly });
+        if (response.isSuccess) {
+            if (response.isReadOnly) {
+                console.log('executeWalletTransaction: Transaction is read-only, returning response');
+                return response;
+            }
+            console.log('executeWalletTransaction: Transaction is not read-only, signing...');
+            const signedTxXDR = await context.signTransaction(response.result);
+            console.log('executeWalletTransaction: Transaction signed successfully');
+            console.log('executeWalletTransaction: Sending transaction...');
+            const sendResponse = await sendTransaction(context, signedTxXDR);
+            console.log('executeWalletTransaction: Transaction sent successfully:', sendResponse);
+            return {
+                isSuccess: true,
+                isReadOnly: false,
+                result: sendResponse,
+            };
         }
-        const signedTxXDR = await context.signTransaction(response.result);
-        const sendResponse = await sendTransaction(context, signedTxXDR);
-        return {
-            isSuccess: true,
-            isReadOnly: false,
-            result: sendResponse,
-        };
+        console.log('executeWalletTransaction: prepareTransaction failed, returning response');
+        return response;
+    }
+    catch (error) {
+        console.error('executeWalletTransaction: Error occurred:', error);
+        console.error('executeWalletTransaction: Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+        throw error;
     }
-    return response;
 };
 exports.executeWalletTransaction = executeWalletTransaction;
 const executeMultiWalletTransactions = async (context, wallet_address, methods, extraOperations = []) => {
-    const contractCalls = methods.map(({ method, additionalArgs = [] }) => ({
-        method,
-        args: [
-            { value: wallet_address, type: "address" },
-            ...additionalArgs,
-        ],
-    }));
-    const response = await prepareTransaction(context, wallet_address, contractCalls, extraOperations);
-    if (response.isSuccess) {
-        if (response.isReadOnly) {
-            return response;
+    try {
+        console.log('executeMultiWalletTransactions: Starting execution', { wallet_address, methodsCount: methods.length, extraOperationsCount: extraOperations.length });
+        const contractCalls = methods.map(({ method, additionalArgs = [] }) => ({
+            method,
+            args: [
+                { value: wallet_address, type: "address" },
+                ...additionalArgs,
+            ],
+        }));
+        console.log('executeMultiWalletTransactions: Contract calls prepared:', contractCalls);
+        console.log('executeMultiWalletTransactions: Calling prepareTransaction...');
+        const response = await prepareTransaction(context, wallet_address, contractCalls, extraOperations);
+        console.log('executeMultiWalletTransactions: prepareTransaction response:', { isSuccess: response.isSuccess, isReadOnly: response.isReadOnly });
+        if (response.isSuccess) {
+            if (response.isReadOnly) {
+                console.log('executeMultiWalletTransactions: Transaction is read-only, returning response');
+                return response;
+            }
+            console.log('executeMultiWalletTransactions: Transaction is not read-only, signing...');
+            const signedTxXDR = await context.signTransaction(response.result);
+            console.log('executeMultiWalletTransactions: Transaction signed successfully');
+            console.log('executeMultiWalletTransactions: Sending transaction...');
+            const sendResponse = await sendTransaction(context, signedTxXDR);
+            console.log('executeMultiWalletTransactions: Transaction sent successfully:', sendResponse);
+            return {
+                isSuccess: true,
+                isReadOnly: false,
+                result: sendResponse,
+            };
         }
-        const signedTxXDR = await context.signTransaction(response.result);
-        const sendResponse = await sendTransaction(context, signedTxXDR);
-        return {
-            isSuccess: true,
-            isReadOnly: false,
-            result: sendResponse,
-        };
+        console.log('executeMultiWalletTransactions: prepareTransaction failed, returning response');
+        return response;
+    }
+    catch (error) {
+        console.error('executeMultiWalletTransactions: Error occurred:', error);
+        console.error('executeMultiWalletTransactions: Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+        throw error;
     }
-    return response;
 };
 exports.executeMultiWalletTransactions = executeMultiWalletTransactions;
 const prepareTransaction = async (context, address, contractCalls, extraOperations = []) => {
@@ -212,43 +245,98 @@ const signTransaction = async (context, xdrToSign, privateKey) => {
 };
 exports.signTransaction = signTransaction;
 const sendTransaction = async (context, signedTransactionXDR, bDebug = false) => {
-    const server = getServer(context.network);
-    const signedTransaction = stellar_sdk_1.TransactionBuilder.fromXDR(signedTransactionXDR, context.network.networkPassphrase);
-    // Submit the transaction to the Stellar-RPC server. The RPC server will
-    // then submit the transaction into the network for us. Then we will have to
-    // wait, polling `getTransaction` until the transaction completes.
     try {
+        console.log('sendTransaction: Starting transaction submission');
+        console.log('sendTransaction: Network:', context.network.networkPassphrase);
+        const server = getServer(context.network);
+        console.log('sendTransaction: Server obtained');
+        const signedTransaction = stellar_sdk_1.TransactionBuilder.fromXDR(signedTransactionXDR, context.network.networkPassphrase);
+        console.log('sendTransaction: Transaction parsed from XDR');
+        // Submit the transaction to the Stellar-RPC server. The RPC server will
+        // then submit the transaction into the network for us. Then we will have to
+        // wait, polling `getTransaction` until the transaction completes.
+        console.log('sendTransaction: Submitting transaction to server...');
         const sendResponse = await server.sendTransaction(signedTransaction);
+        console.log('sendTransaction: Server response received:', sendResponse);
         if (sendResponse.status === "PENDING") {
+            console.log('sendTransaction: Transaction is pending, hash:', sendResponse.hash);
+            console.log('sendTransaction: Starting to poll for transaction completion...');
             let getResponse = await server.getTransaction(sendResponse.hash);
+            console.log('sendTransaction: Initial getTransaction response:', getResponse);
+            let pollCount = 0;
             while (getResponse.status === "NOT_FOUND") {
+                pollCount++;
+                console.log(`sendTransaction: Polling attempt ${pollCount}, transaction not found yet...`);
                 // See if the transaction is complete
                 getResponse = await server.getTransaction(sendResponse.hash);
                 // Wait one second
                 await (0, timing_1.sleep)(1000);
             }
+            console.log('sendTransaction: Final getTransaction response:', getResponse);
             if (getResponse.status === "SUCCESS") {
+                console.log('sendTransaction: Transaction succeeded!');
+                console.log('sendTransaction: Full getResponse object:', JSON.stringify(getResponse, null, 2));
+                console.log('sendTransaction: getResponse keys:', Object.keys(getResponse));
+                console.log('sendTransaction: getResponse.resultMetaXdr exists:', !!getResponse.resultMetaXdr);
+                console.log('sendTransaction: getResponse.resultMetaXdr type:', typeof getResponse.resultMetaXdr);
                 // Make sure the transaction's resultMetaXDR is not empty
                 if (!getResponse.resultMetaXdr) {
-                    throw new Error("Empty resultMetaXDR in getTransaction response");
+                    console.error('sendTransaction: Empty resultMetaXDR in getTransaction response');
+                    console.error('sendTransaction: This might indicate a network response format change');
+                    console.error('sendTransaction: Available fields:', Object.keys(getResponse));
+                    // Try alternative response formats that might have been introduced
+                    if ('result' in getResponse && getResponse.result) {
+                        console.log('sendTransaction: Found result field:', getResponse.result);
+                        return getResponse.result;
+                    }
+                    if ('returnValue' in getResponse && getResponse.returnValue) {
+                        console.log('sendTransaction: Found returnValue field:', getResponse.returnValue);
+                        return getResponse.returnValue;
+                    }
+                    // If we still can't find the return value, return the full response instead of throwing
+                    console.log('sendTransaction: No return value found, returning full response');
+                    return getResponse;
                 }
                 // Find the return value from the contract and return it
                 const transactionMeta = getResponse.resultMetaXdr;
+                console.log('sendTransaction: transactionMeta type:', typeof transactionMeta);
+                console.log('sendTransaction: transactionMeta keys:', Object.keys(transactionMeta));
                 const returnValue = transactionMeta.v3().sorobanMeta()?.returnValue();
+                console.log('sendTransaction: returnValue extracted:', returnValue);
                 if (returnValue) {
+                    console.log('sendTransaction: Returning contract return value');
                     return (0, stellar_sdk_1.scValToNative)(returnValue);
                 }
+                console.log('sendTransaction: Returning full transaction response');
                 return getResponse; // Return the full transaction response
             }
             else {
+                console.error('sendTransaction: Transaction failed:', getResponse.resultXdr);
                 throw new Error(`Transaction failed: ${getResponse.resultXdr}`);
             }
         }
         else {
+            console.error('sendTransaction: Send response status not PENDING:', sendResponse.status);
+            console.error('sendTransaction: Error result:', sendResponse.errorResult);
             throw new Error(sendResponse.errorResult?.toString() || "Unknown error");
         }
     }
     catch (err) {
+        console.error('sendTransaction: Caught error:', err);
+        console.error('sendTransaction: Error type:', typeof err);
+        console.error('sendTransaction: Error constructor:', err?.constructor?.name);
+        // Type guard to safely access error properties
+        if (err instanceof Error) {
+            console.error('sendTransaction: Error message:', err.message);
+            console.error('sendTransaction: Error stack:', err.stack);
+        }
+        else {
+            console.error('sendTransaction: Error is not an Error instance, value:', err);
+        }
+        // If it's already our wrapped error, don't wrap it again
+        if (err instanceof Error && err.message.startsWith('Transaction sending error:')) {
+            throw err;
+        }
         // Catch and report any errors we've thrown
         throw new Error(`Transaction sending error: ${JSON.stringify(err)}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flashbacktech/flashbackclient",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"