@flashbacktech/flashbackclient 0.1.54 → 0.1.56

package/dist/stellarv2/client/bucket.js

@@ -99,6 +99,8 @@ class BucketOps {
         this.updateBucketConditions = (0, decorator_1.withSignature)(async (provider_id, bucket_id, params) => {
             await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "update_bucket_conditions", [
                 { value: bucket_id, type: 'u32' },
+                { value: params.name || null, type: 'string' },
+                { value: params.region || null, type: 'string' },
                 { value: params.price_per_gb_storage || null, type: 'u128' },
                 { value: params.price_per_gb_egress || null, type: 'u128' },
                 { value: params.sla_avg_latency_ms || null, type: 'u32' },

package/dist/stellarv2/models.d.ts

@@ -130,6 +130,8 @@ export interface BucketUpdateBasicParams {
     country?: string;
 }
 export interface BucketUpdateConditionsParams {
+    name?: string;
+    region?: string;
     price_per_gb_storage?: bigint;
     price_per_gb_egress?: bigint;
     sla_avg_latency_ms?: number;

package/dist/stellarv2/wallet/transaction.js

@@ -72,43 +72,32 @@ const getHorizonServer = (network) => {
 exports.getHorizonServer = getHorizonServer;
 const executeWalletTransaction = async (context, wallet_address, method, additionalArgs = []) => {
     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,
             };
         }
-        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;
     }
 };
 exports.executeWalletTransaction = executeWalletTransaction;
 const executeMultiWalletTransactions = async (context, wallet_address, methods, extraOperations = []) => {
     try {
-        console.log('executeMultiWalletTransactions: Starting execution', { wallet_address, methodsCount: methods.length, extraOperationsCount: extraOperations.length });
         const contractCalls = methods.map(({ method, additionalArgs = [] }) => ({
             method,
             args: [
@@ -116,33 +105,23 @@ const executeMultiWalletTransactions = async (context, wallet_address, methods,
                 ...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,
             };
         }
-        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;
     }
 };
@@ -246,72 +225,101 @@ const signTransaction = async (context, xdrToSign, privateKey) => {
 exports.signTransaction = signTransaction;
 const sendTransaction = async (context, signedTransactionXDR, bDebug = false) => {
     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);
+                try {
+                    getResponse = await server.getTransaction(sendResponse.hash);
+                }
+                catch (pollError) {
+                    console.error(`sendTransaction: Error during polling attempt ${pollCount}:`, pollError);
+                    // If we get an XDR parsing error during polling, wait a bit longer and retry
+                    if (pollError instanceof Error && pollError.message.includes('Bad union switch')) {
+                        await (0, timing_1.sleep)(2000); // Wait 2 seconds instead of 1
+                        continue;
+                    }
+                    throw pollError;
+                }
                 // 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
+                // In SDK v14, returnValue might be directly available
+                if ('returnValue' in getResponse && getResponse.returnValue) {
+                    return getResponse.returnValue;
+                }
+                // Make sure the transaction's resultMetaXdr is not empty
                 if (!getResponse.resultMetaXdr) {
-                    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);
+                // Try to parse the resultMetaXdr if it exists
+                try {
+                    const transactionMeta = getResponse.resultMetaXdr;
+                    // Try different approaches to extract the return value
+                    let returnValue = null;
+                    // Try the old v3 approach
+                    if (transactionMeta.v3 && typeof transactionMeta.v3 === 'function') {
+                        try {
+                            const sorobanMeta = transactionMeta.v3().sorobanMeta();
+                            if (sorobanMeta) {
+                                returnValue = sorobanMeta.returnValue();
+                            }
+                        }
+                        catch (v3Error) {
+                            // v3 approach failed, continue to alternatives
+                        }
+                    }
+                    // Try direct property access
+                    if (!returnValue && 'returnValue' in transactionMeta && transactionMeta.returnValue) {
+                        returnValue = transactionMeta.returnValue;
+                    }
+                    // Try nested access
+                    if (!returnValue && '_value' in transactionMeta && transactionMeta._value &&
+                        typeof transactionMeta._value === 'object' && 'returnValue' in transactionMeta._value) {
+                        returnValue = transactionMeta._value.returnValue;
+                    }
+                    if (returnValue) {
+                        return (0, stellar_sdk_1.scValToNative)(returnValue);
+                    }
+                    // No return value found in metadata, returning full response
+                    return getResponse;
+                }
+                catch (metaError) {
+                    console.error('sendTransaction: Error parsing resultMetaXdr:', metaError);
+                    // Return full response due to metadata parsing error
+                    return getResponse;
                 }
-                console.log('sendTransaction: Returning full transaction response');
-                return getResponse; // Return the full transaction response
+            }
+            else if (String(getResponse.status).includes("NOT_FOUND")) {
+                // If we get NOT_FOUND after polling, the transaction might have succeeded but we can't parse the response
+                // This could happen due to XDR format changes in the network
+                console.warn('sendTransaction: Transaction status indicates NOT_FOUND after polling - this might indicate XDR parsing issues');
+                console.warn('sendTransaction: Since the transaction was submitted successfully, we will assume it succeeded');
+                // Return a success response with the transaction hash
+                return {
+                    status: "SUCCESS",
+                    hash: sendResponse.hash,
+                    message: "Transaction submitted successfully (XDR parsing issue prevented detailed response)",
+                    transactionHash: sendResponse.hash
+                };
             }
             else {
-                console.error('sendTransaction: Transaction failed:', getResponse.resultXdr);
+                console.error('sendTransaction: Transaction failed with unexpected status:', getResponse.status);
+                console.error('sendTransaction: Error result:', getResponse.resultXdr);
                 throw new Error(`Transaction failed: ${getResponse.resultXdr}`);
             }
         }
@@ -323,16 +331,6 @@ const sendTransaction = async (context, signedTransactionXDR, bDebug = false) =>
     }
     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;

package/package.json

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