hedge-web3 0.1.29 → 0.1.31

package/src/instructions/claimStakingPoolPosition.ts

@@ -1,22 +1,43 @@
 import { Program, Provider } from '@project-serum/anchor'
 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 {
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { getHedgeMintPublicKey, findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  getHedgeMintPublicKey,
+  findAssociatedTokenAddress,
+  getVaultTypeAccountPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
 export async function claimStakingPoolPosition(
-  program: Program,
+  program: Program<Vault>,
   provider: Provider,
   poolPosition: PublicKey,
   payer: Signer,
-  collateralType: string,
+  collateralType: string
 ): Promise<PublicKey> {
   const vaultTypeAccount = await getVaultTypeAccountPublicKey(collateralType)
   const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccount)
   const collateralMint = vaultTypeAccountInfo.collateralMint
   const stakedTokenMint = await getHedgeMintPublicKey()
   const [feePool] = await getPoolPublicKeyForMint(stakedTokenMint)
-  const feePoolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, feePool, true)
+  const feePoolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    feePool,
+    true
+  )
   const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
     provider.connection,
     payer,
@@ -37,12 +58,12 @@ export async function claimStakingPoolPosition(
       payerAssociatedTokenAccount.address
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return payerAssociatedTokenAccount.address
 }
 
 export async function claimStakingPoolPositionInstruction(
-  program: Program,
+  program: Program<Vault>,
   feePool: PublicKey,
   feePoolAssociatedTokenAccount: PublicKey,
   stakedTokenMint: PublicKey,
@@ -54,23 +75,22 @@ export async function claimStakingPoolPositionInstruction(
 ): Promise<TransactionInstruction> {
   const vaultSystemState = await getVaultSystemStatePublicKey()
 
-  return program.instruction.claimStakingPoolPosition(
-    {
-      accounts: {
-        vaultSystemState: vaultSystemState,
-        feePool: feePool,
-        stakedTokenMint: stakedTokenMint,
-        feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
-        vaultTypeAccount: vaultTypeAccount,
-        collateralMint: collateralMint,
-        poolPosition: poolPosition,
-        payer: payer,
-        payerAssociatedTokenAccount: payerAssociatedTokenAccount,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY
-      },
-      signers: []
+  return await program.methods
+    .claimStakingPoolPosition()
+    .accounts({
+      vaultSystemState: vaultSystemState,
+      feePool: feePool,
+      stakedTokenMint: stakedTokenMint,
+      feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
+      vaultTypeAccount: vaultTypeAccount,
+      collateralMint: collateralMint,
+      poolPosition: poolPosition,
+      payer: payer,
+      payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY,
     })
+    .instruction()
 }

package/src/instructions/closeLiquidationPoolPosition.ts

@@ -1,25 +1,56 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 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 {
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUshAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  getHedgeMintPublicKey,
+  getLiquidationPoolStatePublicKey,
+  getLiquidationPoolUshAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function closeLiquidationPoolPosition (
-  program: Program,
+export async function closeLiquidationPoolPosition(
+  program: Program<Vault>,
   provider: Provider,
   poolPosition: PublicKey,
   payer: Signer,
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const ushMintPublickey = await getUshMintPublicKey()
-  const payerUshAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  const payerUshAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const liquidationPositionAccount = await program.account.liquidationPosition.fetch(poolPosition)
   const poolEra = liquidationPositionAccount.era
 
   const hedgeMint = await getHedgeMintPublicKey()
-  const payerAssociatedHedgeAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, payer.publicKey)
-  const communityAssociatedHedgeTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, vaultSystemStatePublicKey, true)
+  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(
@@ -33,12 +64,12 @@ export async function closeLiquidationPoolPosition (
       overrideStartTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return poolPosition
 }
 
-export async function closeLiquidationPoolPositionInstruction (
-  program: Program,
+export async function closeLiquidationPoolPositionInstruction(
+  program: Program<Vault>,
   poolEra: PublicKey,
   poolPosition: PublicKey,
   payerPublicKey: PublicKey,
@@ -47,33 +78,32 @@ export async function closeLiquidationPoolPositionInstruction (
   communityAssociatedHedgeTokenAccount: PublicKey,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
-
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const ushMint = await getUshMintPublicKey()
   const hedgeMint = await getHedgeMintPublicKey()
   const poolUshAccount = await getLiquidationPoolUshAccountPublicKey()
   const poolState = await getLiquidationPoolStatePublicKey()
 
-  return program.instruction.closeLiquidationPoolPosition(
-    new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)), // override current time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        poolState: poolState,
-        poolEra: poolEra,
-        poolPosition: poolPosition,
-        poolUshAccount: poolUshAccount,
-        payer: payerPublicKey,
-        ownerUshAccount: payerUshAccount,
-        hedgeMint: hedgeMint,
-        ushMint: ushMint,
-        payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
-        communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccount,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        rent: SYSVAR_RENT_PUBKEY
-      },
-      signers: []
+  return await program.methods
+    .closeLiquidationPoolPosition(
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      poolState: poolState,
+      poolEra: poolEra,
+      poolPosition: poolPosition,
+      poolUshAccount: poolUshAccount,
+      payer: payerPublicKey,
+      ownerUshAccount: payerUshAccount,
+      hedgeMint: hedgeMint,
+      ushMint: ushMint,
+      payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+      communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccount,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      rent: SYSVAR_RENT_PUBKEY,
     })
+    .instruction()
 }

package/src/instructions/createStakingPool.ts

@@ -1,11 +1,25 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getPoolPublicKeyForMint, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  findAssociatedTokenAddress,
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function createStakingPool (
-  program: Program,
+export async function createStakingPool(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   mintPublicKey: PublicKey,
@@ -13,52 +27,40 @@ export async function createStakingPool (
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const transaction = new Transaction().add(
-    await createStakingPoolInstruction(
-      program,
-      payer.publicKey,
-      mintPublicKey,
-      hedgeTokensToBeMinted,
-      overrideStartTime
-    )
+    await createStakingPoolInstruction(program, payer.publicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime)
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   const [poolPublickey] = await getPoolPublicKeyForMint(mintPublicKey)
   return poolPublickey
 }
 
-export async function createStakingPoolInstruction (
-  program: Program,
+export async function createStakingPoolInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   mintPublicKey: PublicKey,
   hedgeTokensToBeMinted: number,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
-  console.log("createStakingPoolInstruction program ID", program.programId.toString())
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
   const [poolPublickey, poolBump] = await getPoolPublicKeyForMint(mintPublicKey)
 
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey)
   const poolAssociatedUshTokenAccount = await findAssociatedTokenAddress(poolPublickey, ushMintPublickey)
-
-  return program.instruction.createStakingPool(
-    poolBump,
-    new BN(hedgeTokensToBeMinted),
-    new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)),
-    {
-      accounts: {
-        signer: payerPublicKey,
-        vaultSystemState: vaultSystemStatePublicKey,
-        pool: poolPublickey,
-        stakedTokenMintInfo: mintPublicKey,
-        ushMint: ushMintPublickey,
-        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
-        poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
-        rent: SYSVAR_RENT_PUBKEY,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .createStakingPool(poolBump, new BN(hedgeTokensToBeMinted), new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)))
+    .accounts({
+      signer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublickey,
+      stakedTokenMintInfo: mintPublicKey,
+      ushMint: ushMintPublickey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
+      rent: SYSVAR_RENT_PUBKEY,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/createVault.ts

@@ -1,10 +1,6 @@
-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 { 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,
@@ -14,7 +10,7 @@ import {
   SYSVAR_RENT_PUBKEY,
   Transaction,
   TransactionInstruction,
-} from "@solana/web3.js";
+} from '@solana/web3.js'
 import {
   findAssociatedTokenAddress,
   findVaultAddress,
@@ -23,65 +19,47 @@ import {
   getVaultSystemStatePublicKey,
   getPoolPublicKeyForMint,
   getHedgeMintPublicKey,
-} from "../Constants";
+} from '../Constants'
 
-import { v4 as uuidv4 } from "uuid";
-import { parseAnchorErrors } from "../utils/Errors";
+import { v4 as uuidv4 } from 'uuid'
+import { parseAnchorErrors } from '../utils/Errors'
+import { Vault } from 'idl/vault'
 
 export async function createVault(
-  program: Program,
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   collateralType: string,
   depositAmount: number,
   overrideTime?: number
 ): Promise<PublicKey> {
-  const ushMintPublickey = await getUshMintPublicKey();
+  const ushMintPublickey = await getUshMintPublicKey()
 
-  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 USH back out at some point
-  await getOrCreateAssociatedTokenAccount(
-    provider.connection,
-    payer,
-    ushMintPublickey,
-    payer.publicKey
-  );
+  await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
 
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
-    collateralType
-  );
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
-    vaultTypeAccountPublicKey
-  );
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
 
-  const payerTokenAccount = await findAssociatedTokenAddress(
-    payer.publicKey,
-    vaultTypeAccountInfo.collateralMint
-  );
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
   const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
     newVaultPublicKey,
     vaultTypeAccountInfo.collateralMint
-  );
+  )
 
-  const wrappedSolAccount = Keypair.generate();
+  const wrappedSolAccount = Keypair.generate()
 
-  const transaction = new Transaction();
-  const signers = [payer, history];
+  const transaction = new Transaction()
+  const signers = [payer, history]
 
-  const isWrappedSol =
-    vaultTypeAccountInfo.collateralMint.toString() ===
-    TokenInstructions.WRAPPED_SOL_MINT.toString();
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
-    await getHedgeMintPublicKey()
-  );
-  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
-  );
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, ushMintPublickey)
 
   if (isWrappedSol) {
     transaction.add(
@@ -97,8 +75,8 @@ export async function createVault(
         mint: TokenInstructions.WRAPPED_SOL_MINT,
         owner: payer.publicKey,
       })
-    );
-    signers.push(wrappedSolAccount);
+    )
+    signers.push(wrappedSolAccount)
   }
   transaction.add(
     await createVaultInstruction(
@@ -117,7 +95,7 @@ export async function createVault(
       depositAmount,
       overrideTime
     )
-  );
+  )
   if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
@@ -125,74 +103,53 @@ export async function createVault(
         destination: payer.publicKey,
         owner: payer.publicKey,
       })
-    );
+    )
   }
 
-  await sendAndConfirmTransaction(
-    provider.connection,
-    transaction,
-    signers,
-    provider?.opts
-  ).catch(parseAnchorErrors);
-  return newVaultPublicKey;
+  await sendAndConfirmTransaction(provider.connection, transaction, signers).catch(parseAnchorErrors)
+  return newVaultPublicKey
 }
 
 export async function buildCreateVaultTransaction(
-  program: Program,
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
   collateralType: string,
   depositAmount: number,
   overrideTime?: number
 ): Promise<[Transaction, Signer[], PublicKey]> {
-
-  console.log("HEDGE SDK: buildCreateVaultTransaction")
-  const ushMintPublickey = await getUshMintPublicKey();
-  const payerPublicKey = program.provider.wallet.publicKey;
-
-  const salt = uuidv4().substring(0, 8);
-  const newVaultPublicKey = await findVaultAddress(salt);
-  const history = Keypair.generate() as Signer;
+  console.log('HEDGE SDK: buildCreateVaultTransaction')
+  const ushMintPublickey = await getUshMintPublicKey()
+  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();
+  const signers = [history]
+  const wrappedSolAccount = Keypair.generate()
 
   console.log('Lookup getVaultTypeAccountPublicKey', collateralType)
 
   // Lookup the vault type info
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
-    collateralType
-  );
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
 
   console.log('Lookup vaultTypeAccountPublicKey', vaultTypeAccountPublicKey.toString())
 
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
-    vaultTypeAccountPublicKey
-  );
+  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() === TokenInstructions.WRAPPED_SOL_MINT.toString()
 
-  const payerTokenAccount = await findAssociatedTokenAddress(
-    payerPublicKey,
-    vaultTypeAccountInfo.collateralMint
-  );
+  const payerTokenAccount = await findAssociatedTokenAddress(payerPublicKey, vaultTypeAccountInfo.collateralMint)
   const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
     newVaultPublicKey,
     vaultTypeAccountInfo.collateralMint
-  );
+  )
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
-    await getHedgeMintPublicKey()
-  );
-  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
-  );
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, ushMintPublickey)
 
   console.log('about to start building transaction')
 
@@ -211,10 +168,10 @@ export async function buildCreateVaultTransaction(
         mint: TokenInstructions.WRAPPED_SOL_MINT,
         owner: payerPublicKey,
       })
-    );
-    signers.push(wrappedSolAccount);
+    )
+    signers.push(wrappedSolAccount)
   }
-  console.log("hedgeStakingPoolPublicKey", hedgeStakingPoolPublicKey.toString())
+  console.log('hedgeStakingPoolPublicKey', hedgeStakingPoolPublicKey.toString())
   transaction.add(
     await createVaultInstruction(
       program,
@@ -232,7 +189,7 @@ export async function buildCreateVaultTransaction(
       depositAmount,
       overrideTime
     )
-  );
+  )
   if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
@@ -240,18 +197,18 @@ export async function buildCreateVaultTransaction(
         destination: payerPublicKey,
         owner: payerPublicKey,
       })
-    );
+    )
     transaction.partialSign(wrappedSolAccount)
   }
-  
+
   transaction.partialSign(history)
-  console.log("transaction", transaction)
+  console.log('transaction', transaction)
 
-  return [transaction, signers, newVaultPublicKey];
+  return [transaction, signers, newVaultPublicKey]
 }
 
 export async function createVaultInstruction(
-  program: Program,
+  program: Program<Vault>,
   salt: string,
   payerPublicKey: PublicKey,
   payerTokenAccountPublicKey: PublicKey,
@@ -266,32 +223,31 @@ export async function createVaultInstruction(
   depositAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
-  const ix = program.instruction.createVault(
-    salt,
-    new BN(depositAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vault: vaultPublicKey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        feePool: feePool,
-        feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
-        history: historyPublicKey,
-        payer: payerPublicKey,
-        payerTokenAccount: payerTokenAccountPublicKey,
-        collateralMint: collateralMint,
-        ushMint: ushMintPublickey,
-        systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY,
-      },
-      signers: [],
-    }
-  );
-  return ix;
+  const ix = program.methods
+    .createVault(
+      salt,
+      new BN(depositAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vault: vaultPublicKey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      feePool: feePool,
+      feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
+      history: historyPublicKey,
+      payer: payerPublicKey,
+      payerTokenAccount: payerTokenAccountPublicKey,
+      collateralMint: collateralMint,
+      ushMint: ushMintPublickey,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY,
+    })
+    .instruction()
+  return ix
 }