@flashbacktech/flashbackclient 0.1.55 → 0.1.57

package/dist/stellarv2/client/bucket.d.ts

@@ -1,5 +1,5 @@
 import { ClientContext } from '.';
-import { Bucket, BucketCreateParams, BucketUpdateBasicParams, BucketUpdateConditionsParams } from '../models';
+import { Bucket, BucketCreateParams, BucketMarketplace, BucketUpdateBasicParams, BucketUpdateConditionsParams } from '../models';
 /**
  * Bucket operations client for FlashOnStellar V2
  * Implements all bucket-related contract methods
@@ -74,7 +74,7 @@ export declare class BucketOps {
      * @param take - Number of items to take per page
      * @returns Promise resolving to an array of Bucket objects
      */
-    getBuckets(skip?: number, take?: number): Promise<Bucket[]>;
+    getBuckets(skip?: number, take?: number): Promise<BucketMarketplace[]>;
     /**
      * Retrieves all buckets owned by a specific provider
      * @param provider_id - Address of the provider

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

@@ -46,6 +46,27 @@ export interface Bucket {
     status: BucketStatus;
     locked: boolean;
 }
+export interface BucketMarketplace {
+    bucket_id: number;
+    name: string;
+    region: string;
+    provider_id: string;
+    provider_name: string;
+    provider_reputation: string;
+    fb_bucket_id: string;
+    price_per_gb_storage: bigint;
+    price_per_gb_egress: bigint;
+    versioning_enabled: boolean;
+    encryption_at_rest: boolean;
+    encryption_in_transit: boolean;
+    object_locking: boolean;
+    api_compatibility: string;
+    sla_avg_latency_ms: number;
+    sla_avg_uptime_pct: number;
+    created_ts: bigint;
+    status: BucketStatus;
+    locked: boolean;
+}
 export declare enum BucketStatus {
     Active = "Active",
     Inactive = "Inactive",
@@ -130,6 +151,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,63 +225,50 @@ 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);
                 // In SDK v14, returnValue might be directly available
                 if ('returnValue' in getResponse && getResponse.returnValue) {
-                    console.log('sendTransaction: Found returnValue directly in response:', 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 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;
                 }
                 // Try to parse the resultMetaXdr if it exists
                 try {
                     const transactionMeta = getResponse.resultMetaXdr;
-                    console.log('sendTransaction: transactionMeta type:', typeof transactionMeta);
-                    console.log('sendTransaction: transactionMeta keys:', Object.keys(transactionMeta));
                     // Try different approaches to extract the return value
                     let returnValue = null;
                     // Try the old v3 approach
@@ -314,7 +280,7 @@ const sendTransaction = async (context, signedTransactionXDR, bDebug = false) =>
                             }
                         }
                         catch (v3Error) {
-                            console.log('sendTransaction: v3 approach failed, trying alternatives...');
+                            // v3 approach failed, continue to alternatives
                         }
                     }
                     // Try direct property access
@@ -327,22 +293,29 @@ const sendTransaction = async (context, signedTransactionXDR, bDebug = false) =>
                         returnValue = transactionMeta._value.returnValue;
                     }
                     if (returnValue) {
-                        console.log('sendTransaction: returnValue extracted:', returnValue);
                         return (0, stellar_sdk_1.scValToNative)(returnValue);
                     }
-                    console.log('sendTransaction: No return value found in metadata, returning full response');
+                    // No return value found in metadata, returning full response
                     return getResponse;
                 }
                 catch (metaError) {
                     console.error('sendTransaction: Error parsing resultMetaXdr:', metaError);
-                    console.log('sendTransaction: Returning full response due to metadata parsing error');
+                    // Return full response due to metadata parsing error
                     return getResponse;
                 }
             }
             else if (String(getResponse.status).includes("NOT_FOUND")) {
-                console.log('sendTransaction: Transaction not found yet, continuing to poll...');
-                // Wait one second before the next poll
-                await (0, timing_1.sleep)(1000);
+                // 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 with unexpected status:', getResponse.status);
@@ -358,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.55",
+  "version": "0.1.57",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"