hedge-web3 0.2.27 → 0.2.31

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,14 @@
 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
+  getCompoundPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getReferralAccountPublicKey,
+  getReferralStatePublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 
 import { Vault } from '../idl/vault'
@@ -31,7 +30,8 @@ export async function referralClaimFees(
   program: Program<Vault>,
   provider: Provider,
   payer: Signer,
-  poolPosition: PublicKey
+  poolPosition: PublicKey,
+  stakedTokenMintPublicKey: PublicKey
 ): Promise<PublicKey> {
   // setup transaction
   const transaction = new Transaction()
@@ -91,6 +91,7 @@ export async function referralClaimFees(
       payer.publicKey,
       vaultSystemStatePublicKey,
       poolPosition,
+      stakedTokenMintPublicKey,
       referralAccountPublicKey,
       referallStatePublicKey,
       hedgeMintPublicKey,
@@ -112,6 +113,7 @@ export async function referralClaimFeesInstruction(
   payerPublicKey: PublicKey,
   vaultSystemStatePublicKey: PublicKey,
   poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
   referralAccountPublicKey: PublicKey,
   referralStatePublicKey: PublicKey,
   hedgeMintPublicKey: PublicKey,
@@ -122,6 +124,8 @@ export async function referralClaimFeesInstruction(
   feePoolPublicKey: PublicKey,
   feePoolAssociatedUshTokenAccountPublicKey: PublicKey
 ): Promise<TransactionInstruction> {
+  const [poolPublickey] = await getCompoundPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
+
   return await program.methods
     .referralClaimFees()
     .accounts({
@@ -135,6 +139,8 @@ export async function referralClaimFeesInstruction(
       ushMint: ushMintPublicKey,
       signerUshAta: ushAssociatedTokenAccountPublicKey,
       communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccountPublicKey,
+      pool: poolPublickey,
+      stakedTokenMint: stakedTokenMintPublicKey,
       feePool: feePoolPublicKey,
       feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccountPublicKey,
       systemProgram: SystemProgram.programId,

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()
+}

package/src/utils/getLinkedListAccounts.ts

@@ -22,6 +22,7 @@ import VaultType from '../state/VaultType'
  * @param {boolean} redeem - True if vault is going to be redeemed fully
  * @param {boolean} liquidate - True if vault is going to be liquidated fully
  * @param {VaultAccount[]} cachedVaults - Optional list of cached vaults. Saves a request to the on-chain data.
+ * @param {VaultAccount} preLoadedVault - Optional vault to use as target vault. Overrides the need to load the vault from on-chain data.
  */
 export async function getLinkedListAccounts(
   program: Program<Vault>,
@@ -33,7 +34,8 @@ export async function getLinkedListAccounts(
   repayAmount: BN,
   redeem: boolean,
   liquidate: boolean,
-  cachedVaults?: VaultAccount[]
+  cachedVaults?: VaultAccount[],
+  preLoadedVault?: VaultAccount
 ): Promise<[PublicKey, PublicKey, PublicKey, VaultAccount[]]> {
   const vaultTypeRaw = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
   const vaultType = new VaultType(vaultTypeRaw, vaultTypeAccountPublicKey)
@@ -45,25 +47,9 @@ export async function getLinkedListAccounts(
   let newSmallerPublicKey = vaultPublicKey
   let newLargerPublicKey = vaultPublicKey
 
-  const thisVaultData = await program.account.vault.fetch(vaultPublicKey)
-  .catch((e) => {
-    console.log('Error fetching vault account. Assuming it does not exist yet')
-    return {
-      vaultOwner: new PublicKey('11111111111111111111111111111111'),
-      pdaSalt: 'foo',
-      deposited: new BN(0),
-      denormalizedDebt: new BN(0),
-      vaultNumber: new BN(0),
-      debtProductSnapshotBytes: new BN(1),
-      collateralAccumulatorSnapshotBytes: new BN(1),
-      vaultTypeName: vaultType.name,
-      nextVaultToRedeem: new PublicKey('11111111111111111111111111111111'),
-      vaultStatus: {open: true},
-      vaultType: vaultTypeAccountPublicKey
-    }
-  })
-  // const accountInfo =  await program.provider.connection.getAccountInfo(vaultPublicKey)
-  const thisVault = new VaultAccount(thisVaultData, vaultPublicKey)
+  const thisVault = preLoadedVault
+    ? preLoadedVault
+    : new VaultAccount(await program.account.vault.fetch(vaultPublicKey), vaultPublicKey)
 
   // Load all the vaults
   let vaults