hedge-web3 0.1.14 → 0.1.17

package/src/index.ts

@@ -13,6 +13,8 @@ export * from './instructions/repayVault'
 export * from './instructions/redeemVault'
 export * from './instructions/liquidateVault'
 export * from './instructions/refreshOraclePrice'
+export * from './instructions/initHedgeFoundation'
+export * from './instructions/setHalted'
 
 export * from './HedgeDecimal'
 export * from './Constants'

package/src/instructions/claimLiquidationPoolPosition.ts

@@ -1,8 +1,8 @@
 import { Program, Provider } from '@project-serum/anchor'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getCollateralStateAccountPublicKey, getLiquidationPoolStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getLiquidationPoolStatePublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function claimLiquidationPoolPosition (
   program: Program,
@@ -12,48 +12,56 @@ export async function claimLiquidationPoolPosition (
   collateralType: string,
   overrideStartTime?: number
 ): Promise<PublicKey> {
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralMint = collateralStateAccountInfo.collateralMint
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const collateralMint = vaultTypeAccountInfo.collateralMint
 
   const poolStatePublicKey = await getLiquidationPoolStatePublicKey()
   const poolAssociatedTokenAccount = await findAssociatedTokenAddress(poolStatePublicKey, collateralMint)
-  const payerAssociatedTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralMint)
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    payer.publicKey
+  )
 
   const transaction = new Transaction().add(
     await claimLiquidationPoolPositionInstruction(
       program,
       poolStatePublicKey,
       poolAssociatedTokenAccount,
-      collateralStateAccountPublicKey,
+      vaultTypeAccountPublicKey,
       collateralMint,
       poolPosition,
       payer.publicKey,
-      payerAssociatedTokenAccount,
+      payerAssociatedTokenAccount.address,
       overrideStartTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
-  return payerAssociatedTokenAccount
+  return payerAssociatedTokenAccount.address
 }
 
 export async function claimLiquidationPoolPositionInstruction (
   program: Program,
   poolState: PublicKey,
   poolAssociatedTokenAccount: PublicKey,
-  collateralStateAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
   collateralMint: PublicKey,
   poolPosition: PublicKey,
   payer: PublicKey,
   payerAssociatedTokenAccount: PublicKey,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
+  const vaultSystemState = await getVaultSystemStatePublicKey()
+
   return program.instruction.claimLiquidationPoolPosition(
     {
       accounts: {
+        vaultSystemState: vaultSystemState,
         poolState: poolState,
         poolAssociatedTokenAccount: poolAssociatedTokenAccount,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
         collateralMint: collateralMint,
         poolPosition: poolPosition,
         payer: payer,

package/src/instructions/closeLiquidationPoolPosition.ts

@@ -1,8 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function closeLiquidationPoolPosition (
   program: Program,
@@ -12,13 +12,7 @@ export async function closeLiquidationPoolPosition (
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const poolState = await getLiquidationPoolStatePublicKey()
   const liquidationPositionAccount = await program.account.liquidationPosition.fetch(poolPosition)
@@ -27,8 +21,8 @@ export async function closeLiquidationPoolPosition (
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const poolUsdhAccount = await getLiquidationPoolUsdhAccountPublicKey()
   const hedgeMint = await getHedgeMintPublicKey()
-  const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payer.publicKey, hedgeMint)
-  const communityAssociatedHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMint)
+  const payerAssociatedHedgeAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, payer.publicKey)
+  const communityAssociatedHedgeTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, vaultSystemStatePublicKey, true)
 
   const transaction = new Transaction().add(
     await closeLiquidationPoolPositionInstruction(
@@ -41,8 +35,8 @@ export async function closeLiquidationPoolPosition (
       payer.publicKey,
       payerUsdhAccount.address,
       hedgeMint,
-      payerAssociatedHedgeAccount,
-      communityAssociatedHedgeTokenAccount,
+      payerAssociatedHedgeAccount.address,
+      communityAssociatedHedgeTokenAccount.address,
       overrideStartTime
     )
   )

package/src/instructions/createVault.ts

@@ -1,129 +1,296 @@
-import { BN, Program, Provider } from '@project-serum/anchor'
-import { TokenInstructions } from '@project-serum/serum'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, findVaultAddress, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { BN, Idl, Program, Provider } from "@project-serum/anchor";
+import { TokenInstructions } from "@project-serum/serum";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  getOrCreateAssociatedTokenAccount,
+} from "@solana/spl-token";
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import {
+  findAssociatedTokenAddress,
+  findVaultAddress,
+  getVaultTypeAccountPublicKey,
+  getUsdhMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from "../Constants";
 
-import { v4 as uuidv4 } from 'uuid'
-import { parseAnchorErrors } from '../utils/Errors'
+import { v4 as uuidv4 } from "uuid";
+import { parseAnchorErrors } from "../utils/Errors";
 
-export async function createVault (
+export async function createVault(
   program: Program,
   provider: Provider,
   payer: Signer,
   collateralType: string,
   depositAmount: number,
-  collateralRatio: number
+  overrideTime?: number
 ): Promise<PublicKey> {
-  const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
+  const usdhMintPublickey = await getUsdhMintPublicKey();
 
-  const salt = uuidv4().substring(0, 8)
-  const newVaultPublicKey = await findVaultAddress(salt)
-  const history = Keypair.generate()
+  const salt = uuidv4().substring(0, 8);
+  const newVaultPublicKey = await findVaultAddress(salt);
+  const history = Keypair.generate();
 
   // Prep the user to get USDH back out at some point
-  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    usdhMintPublickey,
+    payer.publicKey
+  );
+
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    collateralType
+  );
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  );
 
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
+  const payerTokenAccount = await findAssociatedTokenAddress(
+    payer.publicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
+    newVaultPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
 
-  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint)
-  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(newVaultPublicKey, collateralStateAccountInfo.collateralMint)
+  const wrappedSolAccount = Keypair.generate();
 
-  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const transaction = new Transaction();
+  const signers = [payer, history];
 
-  const wrappedSolAccount = Keypair.generate()
+  const isWrappedSol =
+    vaultTypeAccountInfo.collateralMint.toString() ===
+    TokenInstructions.WRAPPED_SOL_MINT.toString();
 
-  const transaction = new Transaction()
-  const signers = [payer, history]
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    await getHedgeMintPublicKey()
+  );
+  const feePoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  );
 
-  if (collateralType === 'SOL') {
+  if (isWrappedSol) {
     transaction.add(
       SystemProgram.createAccount({
         fromPubkey: payer.publicKey,
         lamports: depositAmount + 2.04e6,
         newAccountPubkey: wrappedSolAccount.publicKey,
         programId: TOKEN_PROGRAM_ID,
-        space: 165
+        space: 165,
       }),
       TokenInstructions.initializeAccount({
         account: wrappedSolAccount.publicKey,
         mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payer.publicKey
+        owner: payer.publicKey,
       })
-    )
-    signers.push(wrappedSolAccount)
+    );
+    signers.push(wrappedSolAccount);
   }
   transaction.add(
     await createVaultInstruction(
       program,
       salt,
-      vaultSystemStatePublicKey,
       payer.publicKey,
-      collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
+      isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
       newVaultPublicKey,
-      vaultAssociatedCollateralAccountPublicKey,
-      collateralStateAccountPublicKey,
-      collateralStateAccountInfo.collateralMint,
+      vaultAssociatedTokenAccount,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAccountInfo.collateralMint,
       history.publicKey,
+      usdhMintPublickey,
       depositAmount,
-      collateralRatio
+      overrideTime
     )
-  )
-  if (collateralType === 'SOL') {
+  );
+  if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
         source: wrappedSolAccount.publicKey,
         destination: payer.publicKey,
-        owner: payer.publicKey
+        owner: payer.publicKey,
+      })
+    );
+  }
+
+  await sendAndConfirmTransaction(
+    provider.connection,
+    transaction,
+    signers,
+    provider?.opts
+  ).catch(parseAnchorErrors);
+  return newVaultPublicKey;
+}
+
+export async function buildCreateVaultTransaction(
+  program: Program,
+  collateralType: string,
+  depositAmount: number,
+  overrideTime?: number
+): Promise<[Transaction, Signer[], PublicKey]> {
+
+  console.log("HEDGE SDK: buildCreateVaultTransaction")
+  const usdhMintPublickey = await getUsdhMintPublicKey();
+  const payerPublicKey = program.provider.wallet.publicKey;
+
+  const salt = uuidv4().substring(0, 8);
+  const newVaultPublicKey = await findVaultAddress(salt);
+  const history = Keypair.generate() as Signer;
+  const { blockhash } = await program.provider.connection.getLatestBlockhash()
+  const transaction = new Transaction({
+    feePayer: payerPublicKey,
+    recentBlockhash: blockhash,
+  })
+  const signers = [history];
+  const wrappedSolAccount = Keypair.generate();
+
+  console.log('Lookup getVaultTypeAccountPublicKey', collateralType)
+
+  // Lookup the vault type info
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    collateralType
+  );
+
+  console.log('Lookup vaultTypeAccountPublicKey', vaultTypeAccountPublicKey.toString())
+
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  );
+  console.log('Lookup vaultTypeAccountInfo', vaultTypeAccountInfo)
+
+  const isWrappedSol =
+    vaultTypeAccountInfo.collateralMint.toString() ===
+    TokenInstructions.WRAPPED_SOL_MINT.toString();
+
+  const payerTokenAccount = await findAssociatedTokenAddress(
+    payerPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
+    newVaultPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    await getHedgeMintPublicKey()
+  );
+  const feePoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  );
+
+  console.log('about to start building transaction')
+
+  // If wrapped SOL collateral, we convert the SOL to wSOL to use in the instruction
+  if (isWrappedSol) {
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: payerPublicKey,
+        lamports: depositAmount + 2.04e6,
+        newAccountPubkey: wrappedSolAccount.publicKey,
+        programId: TOKEN_PROGRAM_ID,
+        space: 165,
+      }),
+      TokenInstructions.initializeAccount({
+        account: wrappedSolAccount.publicKey,
+        mint: TokenInstructions.WRAPPED_SOL_MINT,
+        owner: payerPublicKey,
       })
+    );
+    signers.push(wrappedSolAccount);
+  }
+  console.log("hedgeStakingPoolPublicKey", hedgeStakingPoolPublicKey.toString())
+  transaction.add(
+    await createVaultInstruction(
+      program,
+      salt,
+      payerPublicKey,
+      isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
+      newVaultPublicKey,
+      vaultAssociatedTokenAccount,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAccountInfo.collateralMint,
+      history.publicKey,
+      usdhMintPublickey,
+      depositAmount,
+      overrideTime
     )
+  );
+  if (isWrappedSol) {
+    transaction.add(
+      TokenInstructions.closeAccount({
+        source: wrappedSolAccount.publicKey,
+        destination: payerPublicKey,
+        owner: payerPublicKey,
+      })
+    );
   }
+  transaction.partialSign(wrappedSolAccount)
+  transaction.partialSign(history)
+  console.log("transaction", transaction)
 
-  await sendAndConfirmTransaction(provider.connection, transaction, signers, provider?.opts).catch(parseAnchorErrors)
-  return newVaultPublicKey
+  return [transaction, signers, newVaultPublicKey];
 }
 
-export async function createVaultInstruction (
+export async function createVaultInstruction(
   program: Program,
   salt: string,
-  vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
   payerTokenAccountPublicKey: PublicKey,
   vaultPublicKey: PublicKey,
-  vaultAssociatedCollateralPublicKey: PublicKey,
-  collateralStateAccount: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
+  feePool: PublicKey,
+  feePoolAssociatedUsdhTokenAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
   collateralMint: PublicKey,
   historyPublicKey: PublicKey,
+  usdhMintPublickey: PublicKey,
   depositAmount: number,
-  collateralRatio: number
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+
   const ix = program.instruction.createVault(
     salt,
     new BN(depositAmount),
-    new BN(collateralRatio)
-    , {
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
+    {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
         vault: vaultPublicKey,
-        vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+        feePool: feePool,
+        feePoolAssociatedUsdhTokenAccount: feePoolAssociatedUsdhTokenAccount,
         history: historyPublicKey,
         payer: payerPublicKey,
         payerTokenAccount: payerTokenAccountPublicKey,
         collateralMint: collateralMint,
+        usdhMint: usdhMintPublickey,
         systemProgram: SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID,
         associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY
+        rent: SYSVAR_RENT_PUBKEY,
       },
-      signers: []
-    })
-  return ix
+      signers: [],
+    }
+  );
+  return ix;
 }

package/src/instructions/depositLiquidationPool.ts

@@ -1,8 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey } from '../Constants'
+import { getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function depositLiquidationPool (
   program: Program,
@@ -12,13 +12,7 @@ export async function depositLiquidationPool (
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const poolPosition = Keypair.generate()
   const transaction = new Transaction().add(
@@ -49,11 +43,14 @@ export async function depositLiquidationPoolInstruction (
   const poolUSDHAccount = await getLiquidationPoolUsdhAccountPublicKey()
   const usdhMint = await getUsdhMintPublicKey()
 
+  const vaultSystemState = await getVaultSystemStatePublicKey()
+
   return program.instruction.depositLiquidationPool(
     new BN(depositAmount),
     new BN(overrideStartTime ?? Date.now() / 1000), // override current time
     {
       accounts: {
+        vaultSystemState: vaultSystemState,
         poolState: liquidationPoolStatePublicKey,
         poolEra: liquidationPoolState.currentEra,
         poolPosition: poolPositionPublicKey,

package/src/instructions/depositStakingPool.ts

@@ -2,7 +2,7 @@ import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getPoolPublicKeyForMint } from '../Constants'
+import { findAssociatedTokenAddress, getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function depositStakingPool (
   program: Program,
@@ -38,6 +38,7 @@ export async function depositStakingPoolInstruction (
   const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey)
   const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
+  const vaultSystemState = await getVaultSystemStatePublicKey()
 
   return program.instruction.depositStakingPool(
     new BN(depositAmount),
@@ -45,6 +46,7 @@ export async function depositStakingPoolInstruction (
     {
       accounts: {
         payer: payerPublicKey,
+        vaultSystemState: vaultSystemState,
         pool: poolPublickey,
         poolPosition: poolPositionPublicKey,
         stakedTokenMintInfo: stakedTokenMintPublicKey,