hedge-web3 0.3.0 → 0.3.2

package/src/instructions/createVault.ts

@@ -1,6 +1,10 @@
 import { BN, Program, Provider } from '@coral-xyz/anchor'
-import { TokenInstructions } from '@project-serum/serum'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getOrCreateAssociatedTokenAccount,
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID,
+} from '@solana/spl-token'
 import {
   Keypair,
   PublicKey,
@@ -24,6 +28,8 @@ import { v4 as uuidv4 } from 'uuid'
 import { Vault } from '../idl/vault'
 import { parseAnchorErrors } from '../utils/Errors'
 import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+import { createInitializeAccountInstruction } from '@solana/spl-token'
+import { createCloseAccountInstruction } from '@solana/spl-token'
 
 export async function createVault(
   program: Program<Vault>,
@@ -61,7 +67,7 @@ export async function createVault(
   const transaction = new Transaction()
   const signers = [payer, history]
 
-  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === NATIVE_MINT.toString()
 
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
     program.programId,
@@ -82,14 +88,11 @@ export async function createVault(
         programId: TOKEN_PROGRAM_ID,
         space: 165,
       }),
-      TokenInstructions.initializeAccount({
-        account: wrappedSolAccount.publicKey,
-        mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payer.publicKey,
-      })
+      createInitializeAccountInstruction(wrappedSolAccount.publicKey, NATIVE_MINT, payer.publicKey)
     )
     signers.push(wrappedSolAccount)
   }
+
   transaction.add(
     await createVaultInstruction(
       program,
@@ -108,17 +111,11 @@ export async function createVault(
       overrideTime
     )
   )
+
   if (isWrappedSol) {
-    transaction.add(
-      TokenInstructions.closeAccount({
-        source: wrappedSolAccount.publicKey,
-        destination: payer.publicKey,
-        owner: payer.publicKey,
-      })
-    )
+    transaction.add(createCloseAccountInstruction(wrappedSolAccount.publicKey, payer.publicKey, payer.publicKey))
   }
-
-  await sendAndConfirmWithDebug(provider.connection, transaction, signers).catch(parseAnchorErrors)
+  const result = await sendAndConfirmWithDebug(provider.connection, transaction, signers).catch(parseAnchorErrors)
   return newVaultPublicKey
 }
 
@@ -137,7 +134,8 @@ export async function buildCreateVaultTransaction(
   const { blockhash, lastValidBlockHeight } = await program.provider.connection.getLatestBlockhash()
   const transaction = new Transaction({
     feePayer: payerPublicKey,
-    recentBlockhash: blockhash,
+    blockhash: blockhash,
+    lastValidBlockHeight: lastValidBlockHeight,
   })
   const signers = [history]
   const wrappedSolAccount = Keypair.generate()
@@ -152,7 +150,7 @@ export async function buildCreateVaultTransaction(
   const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
   console.log('Lookup vaultTypeAccountInfo', vaultTypeAccountInfo)
 
-  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === NATIVE_MINT.toString()
 
   const payerTokenAccount = await findAssociatedTokenAddress(
     program.programId,
@@ -187,11 +185,7 @@ export async function buildCreateVaultTransaction(
         programId: TOKEN_PROGRAM_ID,
         space: 165,
       }),
-      TokenInstructions.initializeAccount({
-        account: wrappedSolAccount.publicKey,
-        mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payerPublicKey,
-      })
+      createInitializeAccountInstruction(wrappedSolAccount.publicKey, NATIVE_MINT, payerPublicKey)
     )
     signers.push(wrappedSolAccount)
   }
@@ -214,14 +208,9 @@ export async function buildCreateVaultTransaction(
       overrideTime
     )
   )
+
   if (isWrappedSol) {
-    transaction.add(
-      TokenInstructions.closeAccount({
-        source: wrappedSolAccount.publicKey,
-        destination: payerPublicKey,
-        owner: payerPublicKey,
-      })
-    )
+    transaction.add(createCloseAccountInstruction(wrappedSolAccount.publicKey, payerPublicKey, payerPublicKey))
     transaction.partialSign(wrappedSolAccount)
   }
 
@@ -253,20 +242,20 @@ export async function createVaultInstruction(
     .createVault(
       salt,
       new BN(depositAmount),
-      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override time
     )
     .accounts({
       vaultSystemState: vaultSystemStatePublicKey,
       vaultTypeAccount: vaultTypeAccount,
       vault: vaultPublicKey,
       vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-      feePool: feePool,
-      feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
+      // feePool: feePool,
+      // feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
       history: historyPublicKey,
       payer: payerPublicKey,
       payerTokenAccount: payerTokenAccountPublicKey,
       collateralMint: collateralMint,
-      ushMint: ushMintPublickey,
+      // ushMint: ushMintPublickey,
       systemProgram: SystemProgram.programId,
       tokenProgram: TOKEN_PROGRAM_ID,
       associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,

package/src/instructions/depositVault.ts

@@ -1,7 +1,12 @@
 import { BN, Program, Provider } from '@coral-xyz/anchor'
-import { TokenInstructions } from '@project-serum/serum'
-import { WRAPPED_SOL_MINT } from '@project-serum/serum/lib/token-instructions'
-import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { 
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID,
+  getOrCreateAssociatedTokenAccount,
+  createInitializeAccountInstruction,
+  createCloseAccountInstruction
+} from '@solana/spl-token'
+
 import {
   Keypair,
   PublicKey, Signer,
@@ -80,7 +85,7 @@ export async function depositVault(
     false
   )
 
-  if (vaultTypeAccountInfo.collateralMint.toString() === WRAPPED_SOL_MINT.toString()) {
+  if (vaultTypeAccountInfo.collateralMint.toString() === NATIVE_MINT.toString()) {
     transaction.add(
       SystemProgram.createAccount({
         fromPubkey: payer.publicKey,
@@ -89,11 +94,11 @@ export async function depositVault(
         programId: TOKEN_PROGRAM_ID,
         space: 165,
       }),
-      TokenInstructions.initializeAccount({
-        account: wrappedSolAccount.publicKey,
-        mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payer.publicKey,
-      })
+      createInitializeAccountInstruction(
+        wrappedSolAccount.publicKey,
+        NATIVE_MINT,
+        payer.publicKey
+      )
     )
     signers.push(wrappedSolAccount)
   }
@@ -102,7 +107,7 @@ export async function depositVault(
       program,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      vaultTypeAccountInfo.collateralMint.toString() === WRAPPED_SOL_MINT.toString()
+      vaultTypeAccountInfo.collateralMint.toString() === NATIVE_MINT.toString()
         ? wrappedSolAccount.publicKey
         : payerTokenAccount,
       vaultPublicKey,
@@ -121,13 +126,14 @@ export async function depositVault(
       overrideTime
     )
   )
-  if (vaultTypeAccountInfo.collateralMint.toString() === WRAPPED_SOL_MINT.toString()) {
+  if (vaultTypeAccountInfo.collateralMint.toString() === NATIVE_MINT.toString()) {
     transaction.add(
-      TokenInstructions.closeAccount({
-        source: wrappedSolAccount.publicKey,
-        destination: payer.publicKey,
-        owner: payer.publicKey,
-      })
+      createCloseAccountInstruction(
+        wrappedSolAccount.publicKey,
+        payer.publicKey,
+        payer.publicKey,
+        []
+      )
     )
   }
 

package/src/instructions/initHedgeFoundation.ts

@@ -21,12 +21,27 @@ import { parseAnchorErrors } from '../utils/Errors'
 import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
 
 export async function initHedgeFoundation(program: Program<Vault>, provider: Provider, payer: Signer): Promise<PublicKey> {
+  console.log('Initializing Hedge Foundation...')
   const poolEra = Keypair.generate()
-  const transaction = new Transaction().add(
+  console.log('Generated poolEra:', poolEra.publicKey.toBase58())
+  
+  const transaction = new Transaction()
+  transaction.feePayer = payer.publicKey
+  
+  transaction.add(
     await initHedgeFoundationInstruction(program, poolEra.publicKey, payer.publicKey)
   )
+  console.log('Created transaction with initHedgeFoundationInstruction')
+  console.log('Payer public key:', payer.publicKey.toBase58())
 
-  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, poolEra]).catch(parseAnchorErrors)
+  console.log('Sending transaction...')
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, poolEra])
+    .catch(err => {
+      console.error('Failed to initialize Hedge Foundation:', err)
+      throw parseAnchorErrors(err)
+    })
+  
+  console.log('Successfully initialized Hedge Foundation')
   return payer.publicKey
 }
 

package/src/instructions/loanVault.ts

@@ -90,7 +90,7 @@ export async function loanVault(
       overrideTime
     )
   )
-  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history])
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history], 300000)
   return vaultPublicKey
 }
 

package/src/instructions/redeemVault.ts

@@ -1,6 +1,5 @@
 import { BN, Program, Provider } from '@coral-xyz/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-// import { TokenInstructions } from '@project-serum/serum'
 import {
   Keypair,
   PublicKey, Signer,

package/src/instructions/refreshOraclePrice.ts

@@ -23,7 +23,7 @@ export async function refreshOraclePrice(
   const transaction = new Transaction().add(
     await refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime)
   )
-  return await sendAndConfirmWithDebug(provider.connection, transaction, [payer])
+  return await sendAndConfirmWithDebug(provider.connection, transaction, [payer], 800000)
 }
 
 export async function refreshOraclePriceInstruction(

package/src/instructions/withdrawVault.ts

@@ -1,6 +1,6 @@
 import { BN, Program, Provider } from '@coral-xyz/anchor'
-import { TokenInstructions } from '@project-serum/serum'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { NATIVE_MINT } from '@solana/spl-token'
 import {
   Keypair,
   PublicKey, Signer,
@@ -35,7 +35,7 @@ export async function withdrawVault(
   const vaultAssociatedCollateralAccount = await getOrCreateAssociatedTokenAccount(
     provider.connection,
     payer,
-    TokenInstructions.WRAPPED_SOL_MINT,
+    NATIVE_MINT,
     vaultPublicKey,
     true
   )

package/src/state/VaultAccount.ts

@@ -2,7 +2,7 @@ import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
 
-import * as borsh from '@project-serum/borsh'
+import * as borsh from '@coral-xyz/borsh'
 import BN from 'bn.js'
 import VaultType from './VaultType'
 

package/src/utils/sendAndConfirmWithDebug.ts

@@ -1,27 +1,76 @@
-import { Connection, Keypair, Signer, Transaction, TransactionSignature } from '@solana/web3.js'
+import { 
+  Connection, 
+  Signer, 
+  Transaction, 
+  TransactionSignature,
+  VersionedTransaction,
+  ComputeBudgetProgram,
+  Keypair,
+  LAMPORTS_PER_SOL
+} from '@solana/web3.js'
 
 export default async function sendAndConfirmWithDebug(
   connection: Connection,
-  transaction: Transaction,
-  signers: Signer[]
+  transaction: Transaction | VersionedTransaction,
+  signers: Signer[],
+  computeUnits?: number
 ): Promise<TransactionSignature | void> {
-  return connection
-    .sendTransaction(transaction, signers)
-    .then((signature) => {
-      return connection
-        .confirmTransaction(signature)
-        .then((signatureContext) => {
-          return signature
-        })
-        .catch((error) => {
-          console.log('There was an error confirming the transaction', error)
-          console.trace()
-          throw error
-        })
-    })
-    .catch((error) => {
-      console.log('There was an error sending the transaction', error)
-      console.trace()
-      throw error
-    })
-}
+  try {
+    // Get the latest blockhash before sending
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+
+    // Set blockhash AND feePayer BEFORE converting to VersionedTransaction
+    if (transaction instanceof Transaction) {
+      // Add compute unit instruction FIRST if requested
+      if (computeUnits) {
+        const computeIx = ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits });
+        transaction.instructions.unshift(computeIx);
+      }
+      transaction.recentBlockhash = blockhash;
+      // Ensure feePayer is explicitly set on legacy transaction
+      if (!transaction.feePayer) {
+          transaction.feePayer = signers[0].publicKey;
+      }
+    } else if (computeUnits) {
+      throw new Error('Compute units must be added before creating VersionedTransaction');
+    }
+
+    // Convert legacy Transaction to VersionedTransaction if needed
+    const versionedTx = transaction instanceof Transaction 
+      ? new VersionedTransaction(transaction.compileMessage())
+      : transaction;
+
+    // For VersionedTransaction, verify blockhash is set
+    if (!(transaction instanceof Transaction) && !versionedTx.message.recentBlockhash) {
+      throw new Error('Versioned transaction requires recent blockhash');
+    }
+
+    // Sign the transaction if signers are provided
+    if (signers.length > 0) {
+      versionedTx.sign(signers);
+    }
+
+    // Send the transaction
+    const signature = await connection.sendTransaction(versionedTx);
+
+    // Confirm using the newer confirmation strategy
+    const confirmationStrategy = {
+      signature,
+      blockhash,
+      lastValidBlockHeight
+    };
+
+    try {
+      await connection.confirmTransaction(confirmationStrategy);
+      return signature;
+    } catch (error) {
+      console.log('There was an error confirming the transaction', error);
+      console.trace();
+      throw error;
+    }
+  } catch (error) {
+    console.log('There was an error sending the transaction', error);
+    console.trace();
+    throw error;
+  }
+}