hedge-web3 0.2.28 → 0.2.33

package/src/instructions/depositCompoundStakingPoolPosition.ts

@@ -0,0 +1,78 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { Keypair, PublicKey, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getCompoundPoolPositionAddress,
+  getCompoundPoolPublicKeyForMint,
+  getPoolPublicKeyForMint,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function depositCompoundStakingPoolPosition(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  depositAmount: number,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const [poolPublickey, poolBump] = await getCompoundPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const poolPosition = await getCompoundPoolPositionAddress(program.programId, poolPublickey, payer.publicKey)
+  const transaction = new Transaction().add(
+    await depositCompoundStakingPoolPositionInstruction(
+      program,
+      payer.publicKey,
+      poolPosition,
+      mintPublicKey,
+      new BN(depositAmount),
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return poolPosition
+}
+
+export async function depositCompoundStakingPoolPositionInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  depositAmount: BN,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const [poolPublickey] = await getCompoundPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    stakedTokenMintPublicKey
+  )
+  const payersArbitraryTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    payerPublicKey,
+    stakedTokenMintPublicKey
+  )
+  const vaultSystemState = await getVaultSystemStatePublicKey(program.programId)
+
+  return await program.methods
+    .depositCompoundStakingPoolPosition(
+      depositAmount,
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemState,
+      pool: poolPublickey,
+      poolPosition: poolPositionPublicKey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}

package/src/instructions/depositRewardsToCompoundPool.ts

@@ -0,0 +1,110 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import {
+  Keypair,
+  PublicKey,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getCompoundPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getVaultTypeAccountPublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function depositRewardsToCompoundStakingPool(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  depositAmount: number,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const history = Keypair.generate()
+
+  const [poolPublickey] = await getCompoundPoolPublicKeyForMint(program.programId, mintPublicKey)
+  const [poolStakingPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const hedgeMintPublickey = await getHedgeMintPublicKey(program.programId)
+
+  const stakingPoolAccountObject = await program.account.stakingPool.fetch(poolStakingPublickey)
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    hedgeMintPublickey,
+    stakingPoolAccountObject.compoundPoolDelegateWallet
+  )
+
+  const transaction = new Transaction().add(
+    await depositRewardsToCompoundStakingPoolInstruction(
+      program,
+      payer.publicKey,
+      mintPublicKey,
+      history.publicKey,
+      new BN(depositAmount),
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history]).catch(parseAnchorErrors)
+  return poolPublickey
+}
+
+export async function depositRewardsToCompoundStakingPoolInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  mintPublicKey: PublicKey,
+  historyPublicKey: PublicKey,
+  amount: BN,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
+  const hedgeMintPublickey = await getHedgeMintPublicKey(program.programId)
+
+  const [poolPublickey, poolBump] = await getCompoundPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const [poolStakingPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const poolAssociatedHedgeTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    hedgeMintPublickey
+  )
+
+  const payerAssociatedHedgeTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    payerPublicKey,
+    hedgeMintPublickey
+  )
+
+  return await program.methods
+    .depositRewardsToCompoundPool(
+      amount,
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      history: historyPublicKey,
+      compoundPool: poolPublickey,
+      pool: poolStakingPublickey,
+      stakedTokenMint: mintPublicKey,
+      hedgeMint: hedgeMintPublickey,
+      poolAssociatedHedgeAccount: poolAssociatedHedgeTokenAccount,
+      payerAssociatedHedgeAccount: payerAssociatedHedgeTokenAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}

package/src/instructions/liquidateVault.ts

@@ -1,19 +1,22 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import {
+  ComputeBudgetProgram,
   Keypair,
-  PublicKey, Signer,
+  PublicKey,
+  Signer,
   SystemProgram,
   SYSVAR_RENT_PUBKEY,
   Transaction,
-  TransactionInstruction
+  TransactionInstruction,
 } from '@solana/web3.js'
 import {
   getHedgeMintPublicKey,
   getLiquidationPoolStatePublicKey,
   getLiquidationPoolUshAccountPublicKey,
-  getPoolPublicKeyForMint, getUshMintPublicKey,
-  getVaultSystemStatePublicKey
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 import { Vault } from '../idl/vault'
 import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
@@ -37,6 +40,11 @@ export async function liquidateVault(
   const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey(program.programId)
   const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
 
+  const additionalComputationBudget = ComputeBudgetProgram.requestUnits({
+    units: 300000,
+    additionalFee: 0,
+  })
+
   const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
     provider.connection,
     payer,
@@ -96,30 +104,32 @@ export async function liquidateVault(
   const newEra = Keypair.generate()
   const transaction = new Transaction()
 
-  transaction.add(
-    await liquidateVaultInstruction(
-      program,
-      payer.publicKey,
-      payerAssociatedTokenAccount.address,
-      vaultPublicKey,
-      vaultAssociatedTokenAccount.address,
-      liquidationPoolStatePublicKey,
-      poolStateInfo.currentEra,
-      poolAssociatedTokenAccount.address,
-      history.publicKey,
-      newEra.publicKey,
-      hedgeStakingPoolPublicKey,
-      feePoolAssociatedTokenAccount.address,
-      hedgeStakingPoolAssociatedUshTokenAccount.address,
-      collateralMint,
-      vaultTypeAssociatedTokenAccount.address,
-      oldSmallerPublicKey,
-      newSmallerPublicKey,
-      newLargerPublicKey,
-      vaultAccount.vaultType,
-      overrideTime
+  transaction
+    .add(additionalComputationBudget)
+    .add(
+      await liquidateVaultInstruction(
+        program,
+        payer.publicKey,
+        payerAssociatedTokenAccount.address,
+        vaultPublicKey,
+        vaultAssociatedTokenAccount.address,
+        liquidationPoolStatePublicKey,
+        poolStateInfo.currentEra,
+        poolAssociatedTokenAccount.address,
+        history.publicKey,
+        newEra.publicKey,
+        hedgeStakingPoolPublicKey,
+        feePoolAssociatedTokenAccount.address,
+        hedgeStakingPoolAssociatedUshTokenAccount.address,
+        collateralMint,
+        vaultTypeAssociatedTokenAccount.address,
+        oldSmallerPublicKey,
+        newSmallerPublicKey,
+        newLargerPublicKey,
+        vaultAccount.vaultType,
+        overrideTime
+      )
     )
-  )
 
   await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history, newEra])
   return vaultPublicKey

package/src/instructions/loanVault.ts

@@ -1,17 +1,23 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import {
+  ComputeBudgetProgram,
   Keypair,
-  PublicKey, Signer,
+  PublicKey,
+  Signer,
   SystemProgram,
   Transaction,
-  TransactionInstruction
+  TransactionInstruction,
 } from '@solana/web3.js'
 import {
   findAssociatedTokenAddress,
   getHedgeMintPublicKey,
-  getPoolPublicKeyForMint, getReferralAccountPublicKey, getReferralStatePublicKey, getUserReferralAccountPublicKey, getUshMintPublicKey,
-  getVaultSystemStatePublicKey
+  getPoolPublicKeyForMint,
+  getReferralAccountPublicKey,
+  getReferralStatePublicKey,
+  getUserReferralAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 import { Vault } from '../idl/vault'
 import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
@@ -26,6 +32,11 @@ export async function loanVault(
   overrideTime?: number,
   referrer?: PublicKey
 ): Promise<PublicKey> {
+  const additionalComputationBudget = ComputeBudgetProgram.requestUnits({
+    units: 300000,
+    additionalFee: 0,
+  })
+
   const ushMintPublickey = await getUshMintPublicKey(program.programId)
 
   const payerUshAccount = await getOrCreateAssociatedTokenAccount(
@@ -72,24 +83,26 @@ export async function loanVault(
   }
 
   const history = Keypair.generate()
-  const transaction = new Transaction().add(
-    await loanVaultInstruction(
-      program,
-      payer.publicKey,
-      payerUshAccount.address,
-      vaultPublicKey,
-      vaultAssociatedTokenAccount.address,
-      history.publicKey,
-      vaultAccount.vaultType,
-      vaultTypeAssociatedTokenAccount.address,
-      oldSmallerPublicKey,
-      newSmallerPublicKey,
-      newLargerPublicKey,
-      new BN(loanAmount),
-      referralAccountPublicKey,
-      overrideTime
+  const transaction = new Transaction()
+    .add(additionalComputationBudget)
+    .add(
+      await loanVaultInstruction(
+        program,
+        payer.publicKey,
+        payerUshAccount.address,
+        vaultPublicKey,
+        vaultAssociatedTokenAccount.address,
+        history.publicKey,
+        vaultAccount.vaultType,
+        vaultTypeAssociatedTokenAccount.address,
+        oldSmallerPublicKey,
+        newSmallerPublicKey,
+        newLargerPublicKey,
+        new BN(loanAmount),
+        referralAccountPublicKey,
+        overrideTime
+      )
     )
-  )
   await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }

package/src/instructions/referralClaimFees.ts

@@ -1,15 +1,13 @@
 import { Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { PublicKey, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import {
-  PublicKey, Signer,
-  SystemProgram,
-  SYSVAR_RENT_PUBKEY,
-  Transaction,
-  TransactionInstruction
-} from '@solana/web3.js'
-import {
-  getHedgeMintPublicKey, getPoolPublicKeyForMint, getReferralAccountPublicKey, getReferralStatePublicKey,
-  getUshMintPublicKey, getVaultSystemStatePublicKey
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getReferralAccountPublicKey,
+  getReferralStatePublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 
 import { Vault } from '../idl/vault'

package/src/instructions/setCompoundPoolActive.ts

@@ -0,0 +1,51 @@
+import { Program, Provider } from '@project-serum/anchor'
+import { PublicKey, Signer, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
+
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function setCompoundPoolActive(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  setActive: boolean
+): Promise<PublicKey> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
+  const [poolPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const transaction = new Transaction().add(
+    await setCompoundPoolActiveInstruction(
+      program,
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      poolPublickey,
+      mintPublicKey,
+      setActive
+    )
+  )
+
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return poolPublickey
+}
+
+export async function setCompoundPoolActiveInstruction(
+  program: Program<Vault>,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  poolPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  setActive: boolean
+): Promise<TransactionInstruction> {
+  return await program.methods
+    .setCompoundPoolActive(setActive)
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublicKey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+    })
+    .instruction()
+}

package/src/instructions/setDelegateWallet.ts

@@ -0,0 +1,51 @@
+import { Program, Provider } from '@project-serum/anchor'
+import { PublicKey, Signer, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
+
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function setDelegateWallet(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  delegateWallet: PublicKey
+): Promise<PublicKey> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
+  const [poolPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const transaction = new Transaction().add(
+    await setDelegateWalletInstruction(
+      program,
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      poolPublickey,
+      mintPublicKey,
+      delegateWallet
+    )
+  )
+
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return delegateWallet
+}
+
+export async function setDelegateWalletInstruction(
+  program: Program<Vault>,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  poolPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  delegateWallet: PublicKey
+): Promise<TransactionInstruction> {
+  return await program.methods
+    .setDelegateWallet(delegateWallet)
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublicKey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+    })
+    .instruction()
+}

package/src/instructions/withdrawCompoundStakingPoolPosition.ts

@@ -0,0 +1,100 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { Keypair, PublicKey, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getCompoundPoolPositionAddress,
+  getCompoundPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function withdrawCompoundStakingPoolPosition(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  claimAmount: number,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const [poolPublickey, poolBump] = await getCompoundPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
+
+  const poolPosition = await getCompoundPoolPositionAddress(program.programId, poolPublickey, payer.publicKey)
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    stakedTokenMintPublicKey,
+    payer.publicKey
+  )
+  const transaction = new Transaction().add(
+    await withdrawCompoundStakingPoolPositionInstruction(
+      program,
+      payer.publicKey,
+      poolPositionPublicKey,
+      stakedTokenMintPublicKey,
+      new BN(claimAmount),
+      overrideStartTime
+    )
+  )
+
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return payerAssociatedTokenAccount.address
+}
+
+export async function withdrawCompoundStakingPoolPositionInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  claimAmount: BN,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
+  const ushMintPublickey = await getUshMintPublicKey(program.programId)
+  const hedgeMintPublickey = await getHedgeMintPublicKey(program.programId)
+  const [poolPublickey, poolBump] = await getCompoundPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    stakedTokenMintPublicKey
+  )
+  const poolAssociatedUshTokenAccount = await findAssociatedTokenAddress(program.programId, poolPublickey, ushMintPublickey)
+  const payerAssociatedStakedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    payerPublicKey,
+    stakedTokenMintPublicKey
+  )
+  const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(program.programId, payerPublicKey, hedgeMintPublickey)
+  const payerAssociatedUshAccount = await findAssociatedTokenAddress(program.programId, payerPublicKey, ushMintPublickey)
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    vaultSystemStatePublicKey,
+    hedgeMintPublickey
+  )
+
+  return await program.methods
+    .withdrawCompoundStakingPoolPosition(
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)), // override current time
+      claimAmount //amount to be claimed
+    )
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublickey,
+      poolPosition: poolPositionPublicKey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
+      hedgeMint: hedgeMintPublickey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}