chore: fix deployment issue

Joshua-Ogbonna · Joshua-Ogbonna · commit 8b5bd305e41a · 2025-01-15T20:33:10.000+01:00
diff --git a/src/components/BrandForm.tsx b/src/components/BrandForm.tsx
@@ -38,6 +38,20 @@ import { useWallet } from "@solana/wallet-adapter-react";
 import { Metaplex, walletAdapterIdentity, toBigNumber } from "@metaplex-foundation/js";
 import { WalletMultiButton } from "@solana/wallet-adapter-react-ui";
 
+const MAX_RETRIES = 5;
+const RETRY_DELAY = 2000;
+
+const waitForAccountCreation = async (connection: Connection, address: PublicKey, maxAttempts = 10) => {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const account = await connection.getAccountInfo(address);
+    if (account) {
+      return account;
+    }
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+  return null;
+};
+
 interface BrandFormProps {
   mode: "create" | "edit";
   initialData?: BrandData | null;
@@ -259,8 +273,14 @@ export default function CreateBrand({
     }
 
     try {
+      // Create a new connection with confirmed commitment
+      const confirmedConnection = new Connection(
+        clusterApiUrl("devnet"),
+        'confirmed'
+      );
+
       // Check SOL balance
-      const balance = await connection.getBalance(publicKey);
+      const balance = await confirmedConnection.getBalance(publicKey);
       const MINIMUM_BALANCE = LAMPORTS_PER_SOL * 0.05; // 0.05 SOL
       if (balance < MINIMUM_BALANCE) {
         toast.error("Insufficient SOL balance. Need at least 0.05 SOL");
@@ -294,20 +314,23 @@ export default function CreateBrand({
       const metadataUri = `${process.env.NEXT_PUBLIC_GATEWAY_URL}/ipfs/${IpfsHash}`;
 
       // Create Brand Collection with retries
-      let retries = 3;
+      let retries = MAX_RETRIES;
       let lastError;
       
       while (retries > 0) {
         try {
+          // Create a new Metaplex instance with the confirmed connection
+          const confirmedMetaplex = new Metaplex(confirmedConnection).use(walletAdapterIdentity(wallet));
+          
           // Create the NFT collection
-          const { nft: collectionNft, response: createResponse } = await metaplex.nfts().create({
+          const { nft: collectionNft, response: createResponse } = await confirmedMetaplex.nfts().create({
             uri: metadataUri,
             name: form.getValues("name"),
             sellerFeeBasisPoints: 500, // 5% royalty
             symbol: "BRAND",
             isCollection: true,
             maxSupply: null,
-            updateAuthority: metaplex.identity(),
+            updateAuthority: confirmedMetaplex.identity(),
             creators: [
               {
                 address: publicKey,
@@ -316,25 +339,39 @@ export default function CreateBrand({
             ],
           });
 
-          // Wait for transaction confirmation with increased commitment
-          const confirmResponse = await connection.confirmTransaction(
-            createResponse.signature,
-            'finalized'
-          );
-          
-          if (confirmResponse.value.err) {
-            throw new Error(`Transaction failed: ${confirmResponse.value.err.toString()}`);
+          console.log("NFT creation transaction submitted:", createResponse.signature);
+
+          // Wait for transaction confirmation with retry mechanism
+          let confirmationAttempts = 3;
+          while (confirmationAttempts > 0) {
+            try {
+              const confirmResponse = await confirmedConnection.confirmTransaction(
+                createResponse.signature,
+                'confirmed'
+              );
+              
+              if (confirmResponse.value.err) {
+                throw new Error(`Transaction failed: ${confirmResponse.value.err.toString()}`);
+              }
+              break;
+            } catch (error) {
+              console.warn(`Confirmation attempt ${3 - confirmationAttempts + 1} failed:`, error);
+              confirmationAttempts--;
+              if (confirmationAttempts === 0) throw error;
+              await new Promise(resolve => setTimeout(resolve, 2000));
+            }
           }
 
-          // Add longer delay for network propagation
-          await new Promise(resolve => setTimeout(resolve, 5000));
-
-          // Verify the NFT exists
-          const nftAccount = await connection.getAccountInfo(collectionNft.address);
+          // Wait for account to be queryable
+          console.log("Waiting for NFT account to be queryable...");
+          const nftAccount = await waitForAccountCreation(confirmedConnection, collectionNft.address);
+          
           if (!nftAccount) {
-            throw new Error("NFT account not found after creation");
+            throw new Error("NFT account not found after multiple attempts");
           }
 
+          console.log("NFT account found:", collectionNft.address.toString());
+
           // Store collection address for future reference
           setIsDeployed(true);
           return collectionNft.address.toString();
@@ -343,8 +380,9 @@ export default function CreateBrand({
           lastError = error;
           retries--;
           if (retries > 0) {
-            console.warn(`NFT creation failed, retrying... (${retries} attempts left)`);
-            await new Promise(resolve => setTimeout(resolve, 5000)); // Increased wait time between retries
+            const delay = RETRY_DELAY * (MAX_RETRIES - retries); // Exponential backoff
+            console.warn(`NFT creation failed, retrying in ${delay}ms... (${retries} attempts left)`);
+            await new Promise(resolve => setTimeout(resolve, delay));
           }
         }
       }
@@ -367,6 +405,15 @@ export default function CreateBrand({
     }
 
     try {
+      // Create a new connection with confirmed commitment
+      const confirmedConnection = new Connection(
+        clusterApiUrl("devnet"),
+        'confirmed'
+      );
+
+      // Create a new Metaplex instance with the confirmed connection
+      const confirmedMetaplex = new Metaplex(confirmedConnection).use(walletAdapterIdentity(wallet));
+
       const metadata = {
         name: memory_name,
         symbol: "TRADE",
@@ -397,23 +444,73 @@ export default function CreateBrand({
       const data = await response.json();
       const metadataUri = `${process.env.NEXT_PUBLIC_GATEWAY_URL}/ipfs/${data.IpfsHash}`;
 
-      const { nft: tradingCollection } = await metaplex.nfts().create({
-        uri: metadataUri,
-        name: memory_name,
-        sellerFeeBasisPoints: platformFee * 100,
-        symbol: "TRADE",
-        isCollection: true,
-        updateAuthority: metaplex.identity(),
-      });
+      let retries = MAX_RETRIES;
+      let lastError;
 
-      setIsDeployed(true);
-      return {
-        mintAddress: tradingCollection.address.toString(),
-        metadataAddress: tradingCollection.metadataAddress.toString(),
-        // tokenAddress: tradingCollection.tokenAddress?.toString() || null,
-      };
+      while (retries > 0) {
+        try {
+          const { nft: tradingCollection, response: createResponse } = await confirmedMetaplex.nfts().create({
+            uri: metadataUri,
+            name: memory_name,
+            sellerFeeBasisPoints: platformFee * 100,
+            symbol: "TRADE",
+            isCollection: true,
+            maxSupply: null,
+            updateAuthority: confirmedMetaplex.identity(),
+          });
+
+          console.log("Trading collection creation submitted:", createResponse.signature);
+
+          // Wait for transaction confirmation with retry mechanism
+          let confirmationAttempts = 3;
+          while (confirmationAttempts > 0) {
+            try {
+              const confirmResponse = await confirmedConnection.confirmTransaction(
+                createResponse.signature,
+                'confirmed'
+              );
+              
+              if (confirmResponse.value.err) {
+                throw new Error(`Transaction failed: ${confirmResponse.value.err.toString()}`);
+              }
+              break;
+            } catch (error) {
+              console.warn(`Confirmation attempt ${3 - confirmationAttempts + 1} failed:`, error);
+              confirmationAttempts--;
+              if (confirmationAttempts === 0) throw error;
+              await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+          }
+
+          // Wait for account to be queryable
+          console.log("Waiting for trading collection account to be queryable...");
+          const nftAccount = await waitForAccountCreation(confirmedConnection, tradingCollection.address);
+          
+          if (!nftAccount) {
+            throw new Error("Trading collection account not found after multiple attempts");
+          }
+
+          console.log("Trading collection account found:", tradingCollection.address.toString());
+
+          return {
+            mintAddress: tradingCollection.address.toString(),
+            metadataAddress: tradingCollection.metadataAddress.toString(),
+          };
+        } catch (error) {
+          console.error("Trading collection creation error:", error);
+          lastError = error;
+          retries--;
+          if (retries > 0) {
+            const delay = RETRY_DELAY * (MAX_RETRIES - retries); // Exponential backoff
+            console.warn(`Trading collection creation failed, retrying in ${delay}ms... (${retries} attempts left)`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+          }
+        }
+      }
+
+      throw lastError;
     } catch (error) {
-      console.error("Deployment error:", error);
+      console.error("Trading collection deployment error:", error);
       toast.error("Error deploying trading collection: " + error);
       throw error;
     }
@@ -601,12 +698,6 @@ export default function CreateBrand({
           "TradehubMetadataAddress",
           tradingCollectionAddresses.metadataAddress
         );
-        // if (tradingCollectionAddresses.tokenAddress) {
-        //   localStorage.setItem(
-        //     "TradehubTokenAddress",
-        //     tradingCollectionAddresses.tokenAddress
-        //   );
-        // }
         console.log(
           "Trading collection deployed at:",
           tradingCollectionAddresses.mintAddress
