hedge-web3 0.2.27 → 0.2.31

package/src/index.ts

@@ -24,6 +24,15 @@ export * from './instructions/refreshOraclePrice'
 export * from './instructions/repayVault'
 export * from './instructions/setHalted'
 export * from './instructions/transferVault'
+export * from './instructions/createCompoundStakingPool'
+export * from './instructions/createCompoundStakingPoolPosition'
+export * from './instructions/depositCompoundStakingPoolPosition'
+export * from './instructions/withdrawCompoundStakingPoolPosition'
+export * from './instructions/setDelegateWallet'
+export * from './instructions/setCompoundPoolActive'
+export * from './instructions/adminWithdrawCol'
+export * from './instructions/adminWithdrawUsh'
+export * from './instructions/depositRewardsToCompoundPool'
 export * from './instructions/updateReferralAccount'
 export * from './instructions/updateReferralState'
 export * from './instructions/updateVaultType'
@@ -37,5 +46,3 @@ export * from './state/StakingPoolPosition'
 export * from './state/VaultAccount'
 export * from './state/VaultHistoryEvent'
 export * from './utils/getLinkedListAccounts'
-
-

package/src/instructions/adminWithdrawCol.ts

@@ -0,0 +1,87 @@
+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, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getPoolPublicKeyForMint,
+  getVaultSystemStatePublicKey,
+  getVaultTypeAccountPublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function adminWithdrawCollateral(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  collateralType: string
+): Promise<PublicKey> {
+  const [poolPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(program.programId, collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const stakingPoolAccountObject = await program.account.stakingPool.fetch(poolPublickey)
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    stakingPoolAccountObject.compoundPoolDelegateWallet
+  )
+
+  const poolAssociatedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    vaultTypeAccountInfo.collateralMint
+  )
+
+  const transaction = new Transaction().add(
+    await adminWithdrawCollateralInstruction(program, payer.publicKey, mintPublicKey, vaultTypeAccountPublicKey)
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+
+  return poolPublickey
+}
+
+export async function adminWithdrawCollateralInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  vaultTypeAccountPublicKey: PublicKey
+): Promise<TransactionInstruction> {
+  const [poolPublickey] = await getPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
+
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const stakingPoolAccountObject = await program.account.stakingPool.fetch(poolPublickey)
+
+  const poolAssociatedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    vaultTypeAccountInfo.collateralMint
+  )
+
+  const delegateAssociatedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    stakingPoolAccountObject.compoundPoolDelegateWallet,
+    vaultTypeAccountInfo.collateralMint
+  )
+
+  const vaultSystemState = await getVaultSystemStatePublicKey(program.programId)
+
+  return await program.methods
+    .adminWithdrawColAta()
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemState,
+      pool: poolPublickey,
+      vaultTypeAccount: vaultTypeAccountPublicKey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+      poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+      delegateAssociatedColAccount: delegateAssociatedTokenAccount,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}

package/src/instructions/adminWithdrawUsh.ts

@@ -0,0 +1,78 @@
+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, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function adminWithdrawUsh(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey
+): Promise<PublicKey> {
+  const [poolPublickey] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
+
+  const stakingPoolAccountObject = await program.account.stakingPool.fetch(poolPublickey)
+
+  const ushMintPublickey = await getUshMintPublicKey(program.programId)
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    stakingPoolAccountObject.compoundPoolDelegateWallet
+  )
+
+  const transaction = new Transaction().add(
+    await adminWithdrawUshInstruction(program, payer.publicKey, mintPublicKey, poolPublickey)
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return poolPublickey
+}
+
+export async function adminWithdrawUshInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  poolPublickey: PublicKey
+): Promise<TransactionInstruction> {
+  const ushMintPublickey = await getUshMintPublicKey(program.programId)
+  const vaultSystemState = await getVaultSystemStatePublicKey(program.programId)
+
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    poolPublickey,
+    ushMintPublickey
+  )
+
+  const stakingPoolAccountObject = await program.account.stakingPool.fetch(poolPublickey)
+
+  const delegateWalletAssociatedStakedTokenAccount = await findAssociatedTokenAddress(
+    program.programId,
+    stakingPoolAccountObject.compoundPoolDelegateWallet,
+    ushMintPublickey
+  )
+
+  return await program.methods
+    .adminWithdrawUshAta()
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemState,
+      pool: poolPublickey,
+      ushMint: ushMintPublickey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+      poolAssociatedTokenAccount: poolAssociatedStakedTokenAccount,
+      delegateAssociatedUshAccount: delegateWalletAssociatedStakedTokenAccount,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}

package/src/instructions/createCompoundStakingPool.ts

@@ -0,0 +1,63 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { PublicKey, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  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 createCompoundStakingPool(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const transaction = new Transaction().add(
+    await createCompoundStakingPoolInstruction(program, payer.publicKey, mintPublicKey, overrideStartTime)
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  const [poolPublickey] = await getCompoundPoolPublicKeyForMint(program.programId, mintPublicKey)
+  return poolPublickey
+}
+
+export async function createCompoundStakingPoolInstruction(
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
+  mintPublicKey: PublicKey,
+  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, mintPublicKey)
+
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(program.programId, poolPublickey, mintPublicKey)
+  const poolAssociatedUshTokenAccount = await findAssociatedTokenAddress(program.programId, poolPublickey, ushMintPublickey)
+
+  return await program.methods
+    .createCompoundStakingPool(new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)))
+    .accounts({
+      signer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublickey,
+      stakedTokenMint: mintPublicKey,
+      ushMint: ushMintPublickey,
+      hedgeMint: hedgeMintPublickey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
+      rent: SYSVAR_RENT_PUBKEY,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction()
+}

package/src/instructions/createCompoundStakingPoolPosition.ts

@@ -0,0 +1,85 @@
+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,
+  getPoolPublicKeyForMint,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from '../idl/vault'
+import { parseAnchorErrors } from '../utils/Errors'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+
+export async function createCompoundStakingPoolPosition(
+  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 payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    mintPublicKey,
+    payer.publicKey
+  )
+
+  const transaction = new Transaction().add(
+    await createCompoundStakingPoolPositionInstruction(
+      program,
+      payer.publicKey,
+      poolPosition,
+      mintPublicKey,
+      new BN(depositAmount),
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return poolPosition
+}
+export async function createCompoundStakingPoolPositionInstruction(
+  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
+    .createCompoundStakingPoolPosition(
+      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/createReferralAccount.ts

@@ -1,15 +1,13 @@
 import { BN, 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, getReferralAccountPublicKey, getReferralStatePublicKey,
-  getUserReferralAccountPublicKey, getVaultSystemStatePublicKey
+  getCompoundPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+  getReferralAccountPublicKey,
+  getReferralStatePublicKey,
+  getUserReferralAccountPublicKey,
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 
 import { Vault } from '../idl/vault'
@@ -33,6 +31,7 @@ export async function createReferralAccount(
   provider: Provider,
   payer: Signer,
   poolPosition: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
   overrideTime?: number
 ): Promise<PublicKey> {
   // setup transaction
@@ -68,6 +67,7 @@ export async function createReferralAccount(
       program,
       payer.publicKey,
       poolPosition,
+      stakedTokenMintPublicKey,
       referralAccountPublicKey,
       referallStatePublicKey,
       hedgeMintPublicKey,
@@ -85,6 +85,7 @@ export async function createReferralAccountInstruction(
   program: Program<Vault>,
   payerPublicKey: PublicKey,
   poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
   referralAccountPublicKey: PublicKey,
   referralStatePublicKey: PublicKey,
   hedgeMintPublicKey: PublicKey,
@@ -93,6 +94,7 @@ export async function createReferralAccountInstruction(
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
+  const [poolPublickey] = await getCompoundPoolPublicKeyForMint(program.programId, stakedTokenMintPublicKey)
 
   return await program.methods
     .createReferralAccount(
@@ -105,6 +107,8 @@ export async function createReferralAccountInstruction(
       referralAccount: referralAccountPublicKey,
       userReferralAccount: userReferralAccountPublicKey,
       poolPosition: poolPositionPublicKey,
+      pool: poolPublickey,
+      stakedTokenMint: stakedTokenMintPublicKey,
       hedgeMint: hedgeMintPublicKey,
       hdgAta: hdgAssociatedTokenAccountPublicKey,
       systemProgram: SystemProgram.programId,

package/src/instructions/createStakingPool.ts

@@ -1,17 +1,11 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, 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 {
   findAssociatedTokenAddress,
   getPoolPublicKeyForMint,
   getUshMintPublicKey,
-  getVaultSystemStatePublicKey
+  getVaultSystemStatePublicKey,
 } from '../Constants'
 import { Vault } from '../idl/vault'
 import { parseAnchorErrors } from '../utils/Errors'
@@ -43,7 +37,6 @@ export async function createStakingPoolInstruction(
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey(program.programId)
   const ushMintPublickey = await getUshMintPublicKey(program.programId)
   const [poolPublickey, poolBump] = await getPoolPublicKeyForMint(program.programId, mintPublicKey)
-
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(program.programId, poolPublickey, mintPublicKey)
   const poolAssociatedUshTokenAccount = await findAssociatedTokenAddress(program.programId, poolPublickey, ushMintPublickey)
   return await program.methods

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