add pending work towards Helius integration

Author: georgedonnelly

components/QuickBuy/Sell.tsx

@@ -30,6 +30,7 @@ const Sell = ({ lists, updateLists, onSeeOptions, onLoading }: SellProps) => {
   const [creatingAd, setCreatingAd] = useState(false);
   const [loading, setLoading] = useState(false);
   const { user } = useUserProfile({});
+  const isWalletConnected = !!user?.contract_address;
 
   // const [fee,setFee] = useState<bigint>();
 
@@ -47,17 +48,19 @@ const Sell = ({ lists, updateLists, onSeeOptions, onLoading }: SellProps) => {
   // }	, [token]);
 
   //@ts-ignore
-  // Use the useEscrowFee hook to get the fee data
-  const {fee, loadingContract } = useContractRead(
-	user?.contract_address ||'',
-	"fee",
-	false
+  // Always call the hook, but pass null if wallet isn't connected
+  const { fee, loadingContract } = useContractRead(
+    isWalletConnected ? user.contract_address : null,
+  'escrowState'
 );
-console.log(fee,loadingContract);
+
+  console.log("fee, loadingContract from Sell.tsx", fee, loadingContract);
+
   // Fallback fee calculation
-  const fallbackFee = tokenAmount
-    ? (BigInt(tokenAmount * 10 ** (token?.decimals || 0)) * BigInt(10 ** (token?.decimals || 0)) * BigInt(5)) /
-      BigInt(10000)
+  const fallbackFee = tokenAmount && token?.decimals
+    ? (BigInt(tokenAmount * 10 ** token.decimals) * 
+       BigInt(10 ** token.decimals) * 
+       BigInt(5)) / BigInt(10000)
     : null;
 
   const updateLoading = (l: boolean) => {
@@ -135,6 +138,9 @@ console.log(fee,loadingContract);
     }
   };
 
+  // Add null check for fee calculation
+  const finalFee = (fee || fallbackFee || BigInt(0)) / BigInt(LAMPORTS_PER_SOL);
+
   return (
     <>
       <div className={`${creatingAd ? "hidden" : ""}`}>
@@ -207,12 +213,12 @@ console.log(fee,loadingContract);
 
         <div className="text-center mt-4">
           {/* Display the fee if available, otherwise use the fallback fee */}
-          {!!(fee || (fallbackFee)) && !!token && (
+          {!!(fee || fallbackFee) && token?.decimals && (
             <span className="text-xs text-gray-600 text-center">
-              Total fee: {(formatUnits((fee || fallbackFee) / BigInt(LAMPORTS_PER_SOL), token.decimals))}{" "}
+              Total fee: {formatUnits((fee || fallbackFee || BigInt(0)) / BigInt(LAMPORTS_PER_SOL), token.decimals)}{" "}
               {token.symbol}
-            </span>
-          )}
+    </span>
+  )}
         </div>
       </div>
       <div className={`${!creatingAd ? "hidden" : ""}`}>

contexts/ConnectionContext.tsx

@@ -0,0 +1,58 @@
+import { Connection } from "@solana/web3.js";
+import React, { createContext, useContext, useEffect, useRef, useState } from "react";
+import { NEXT_PUBLIC_SOLANA_RPC } from 'utils';
+
+interface ConnectionContextType {
+  connection: Connection | null;
+  getConnection: () => Connection;
+}
+
+const ConnectionContext = createContext<ConnectionContextType | null>(null);
+
+let cachedConnection: Connection | null = null;
+
+export function ConnectionProvider({ children }: { children: React.ReactNode }) {
+  const connectionRef = useRef<Connection | null>(null);
+
+  useEffect(() => {
+    const initializeConnection = async () => {
+      if (!cachedConnection) {
+        const apiKey = process.env.NEXT_PUBLIC_HELIUS_API_KEY;
+        const rpcUrl = `${NEXT_PUBLIC_SOLANA_RPC}?api-key=${apiKey}`;
+        
+        cachedConnection = new Connection(rpcUrl, {
+          commitment: 'confirmed',
+          confirmTransactionInitialTimeout: 60000
+        });
+      }
+      connectionRef.current = cachedConnection;
+    };
+
+    initializeConnection();
+    
+    return () => {
+      connectionRef.current = null;
+    };
+  }, []);
+
+  const getConnection = () => {
+    if (!connectionRef.current) {
+      throw new Error("Connection not initialized");
+    }
+    return connectionRef.current;
+  };
+
+  return (
+    <ConnectionContext.Provider value={{ connection: connectionRef.current, getConnection }}>
+      {children}
+    </ConnectionContext.Provider>
+  );
+}
+
+export const useConnection = () => {
+  const context = useContext(ConnectionContext);
+  if (!context) {
+    throw new Error("useConnection must be used within a ConnectionProvider");
+  }
+  return context;
+};

hooks/transactions/useContractRead.ts

@@ -1,56 +1,121 @@
-// hooks/transactions/useContractRead.ts
-
 import { useState, useEffect } from "react";
 import { PublicKey } from "@solana/web3.js";
 import useLocalSolana from "./useLocalSolana";
+import { BN } from "@coral-xyz/anchor";
+
+interface ContractReadResult {
+  data: any;
+  fee: bigint | null;
+  loadingContract: boolean;
+}
 
 export const useContractRead = (
-  contractAddress: string,
+  contractAddress: string | null,
   method: string
-) => {
+): ContractReadResult => {
+  const [fee, setFee] = useState<bigint | null>(null);
   const [data, setData] = useState<any>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const { program, connection, getConnection } = useLocalSolana();
+  const [loadingContract, setLoading] = useState(true);
+  const { program, getConnection, getEscrowStatePDA, isConnectionReady } = useLocalSolana();
 
   useEffect(() => {
     const fetchData = async () => {
+
+      // If contractAddress is null, skip fetching
+      if (!contractAddress) {
+        setLoading(false);
+        return;
+      }
+
+      // Check if connection is ready
+      if (!isConnectionReady) {
+      console.warn("Connection is not ready");
+      setLoading(false);
+      return;
+    }
+
+      // Check if connection and program are available
+      if (!program) {
+        console.warn("Program not established");
+        setLoading(false);
+        return;
+      }
+
+      // Check if contract address is provided
+      if (!contractAddress) {
+        console.warn("Contract address is required");
+        setLoading(false);
+        return;
+      }
+
       try {
         setLoading(true);
 
-        if (!connection) {
-          throw new Error("Connection not established");
+        let publicKey: PublicKey;
+        if (method === "escrowState") {
+          // Get the PDA for the escrow state
+          const escrowStateAddress = getEscrowStatePDA(contractAddress);
+          if (!escrowStateAddress) {
+            console.warn("Unable to find LocalSolana account");
+            setLoading(false);
+            return;
+          }
+          publicKey = escrowStateAddress;
+        } else {
+          publicKey = new PublicKey(contractAddress);
         }
 
-        if (!contractAddress) {
-          throw new Error("Contract address is required");
-        }
+        console.log("Fetching account info for publicKey:", publicKey.toBase58());
 
-        const publicKey = new PublicKey(contractAddress);
+        // Fetch account information
         const accountInfo = await getConnection().getAccountInfo(publicKey);
-
         if (!accountInfo?.data) {
-          throw new Error("Unable to retrieve account information");
+          console.warn("Unable to retrieve account information");
+          setLoading(false);
+          return;
         }
 
-        // Decode data using the Anchor program
-        const decodedData = program?.account[method]?.coder?.accounts.decode(
-          method,
-          accountInfo.data
-        );
+        // Decode data based on the method
+        let decodedData;
+        switch (method) {
+          case "escrow":
+            decodedData = program.account.escrow.coder.accounts.decode(
+              "escrow",
+              accountInfo.data
+            );
+            if (decodedData?.fee) {
+              setFee(BigInt(decodedData.fee.toString()));
+            }
+            break;
 
-        setData(decodedData || null);
+          case "escrowState":
+            decodedData = program.account.escrowState.coder.accounts.decode(
+              "escrowState",
+              accountInfo.data
+            );
+
+            if (decodedData?.fee) {
+              setFee(BigInt(decodedData.fee.toString()));
+            }
+
+            setData(decodedData);
+
+          default:
+            console.warn(`Unsupported method: ${method}`);
+            setLoading(false);
+            return;
+        }
       } catch (err: any) {
         console.error("Error fetching contract data:", err.message);
-        setError(err.message);
+        setFee(null);
         setData(null);
       } finally {
         setLoading(false);
       }
     };
 
     fetchData();
-  }, [contractAddress, method, connection]);
+  }, [contractAddress, method, program, isConnectionReady]);
 
-  return { data, loading, error };
-};
+  return { fee, data, loadingContract };
+};