hedge-web3 0.1.27 → 0.1.31

package/src/instructions/loanVault.ts

@@ -1,10 +1,27 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function loanVault (
-  program: Program,
+export async function loanVault(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
@@ -13,13 +30,41 @@ export async function loanVault (
 ): 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 vaultAccount = await program.account.vault.fetch(vaultPublicKey)
   const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
   const vaultTypeAccount = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
-  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccount.collateralMint, vaultTypeAccountPublicKey, true)
-  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccount.collateralMint, vaultPublicKey, true)
+  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccount.collateralMint,
+    vaultTypeAccountPublicKey,
+    true
+  )
+  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccount.collateralMint,
+    vaultPublicKey,
+    true
+  )
+
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
+    program,
+    provider,
+    vaultTypeAccountPublicKey,
+    vaultPublicKey,
+    0,
+    loanAmount,
+    false,
+    false
+  )
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -32,16 +77,19 @@ export async function loanVault (
       history.publicKey,
       vaultTypeAccountPublicKey,
       vaultTypeAssociatedTokenAccount.address,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       loanAmount,
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }
 
-export async function loanVaultInstruction (
-  program: Program,
+export async function loanVaultInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   ownerUshAccount: PublicKey,
   vaultPublickey: PublicKey,
@@ -49,6 +97,9 @@ export async function loanVaultInstruction (
   historyPublicKey: PublicKey,
   vaultTypeAccount: PublicKey,
   vaultTypeAssociatedTokenAccount: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   loanAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -61,25 +112,28 @@ export async function loanVaultInstruction (
     ushMintPublickey
   )
 
-  return program.instruction.loanVault(
-    new BN(loanAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
-        vaultAccount: vaultPublickey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        history: historyPublicKey,
-        feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
-        ushMint: ushMintPublickey,
-        vaultOwner: payerPublicKey,
-        ownerUshAccount: ownerUshAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return program.methods
+    .loanVault(
+      new BN(loanAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      vaultAccount: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      history: historyPublicKey,
+      feePool: hedgeStakingPoolPublicKey,
+      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      ushMint: ushMintPublickey,
+      vaultOwner: payerPublicKey,
+      ownerUshAccount: ownerUshAccount,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/redeemVault.ts

@@ -1,11 +1,28 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 // import { TokenInstructions } from '@project-serum/serum'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function redeemVault (
-  program: Program,
+export async function redeemVault(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
@@ -15,16 +32,49 @@ export async function redeemVault (
   const ushMintPublickey = await getUshMintPublicKey()
 
   // Prep the user to get USH back out at some point
-  const payerUshAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  const payerUshAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
 
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
   const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
   const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
-  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, true)
+  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    vaultTypeAccountPublicKey,
+    true
+  )
 
-  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultPublicKey, true)
+  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    vaultPublicKey,
+    true
+  )
 
-  const payerTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey)
+  const payerTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    payer.publicKey
+  )
+
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
+    program,
+    provider,
+    vaultTypeAccountPublicKey,
+    vaultPublicKey,
+    0,
+    0,
+    true,
+    false
+  )
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -38,16 +88,19 @@ export async function redeemVault (
       history.publicKey,
       vaultTypeAccountPublicKey,
       vaultTypeAssociatedTokenAccount.address,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       redeemAmount,
       transactionOverrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }
 
-export async function redeemVaultInstruction (
-  program: Program,
+export async function redeemVaultInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   payerUshAccount: PublicKey,
   destinationTokenAccount: PublicKey,
@@ -56,6 +109,9 @@ export async function redeemVaultInstruction (
   historyPublicKey: PublicKey,
   vaultTypeAccount: PublicKey,
   vaultTypeAssociatedTokenAccount: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -67,26 +123,29 @@ export async function redeemVaultInstruction (
     hedgeStakingPoolPublicKey,
     ushMintPublickey
   )
-  return program.instruction.redeemVault(
-    new BN(redeemAmount),
-    new BN(transactionOverrideTime ?? (Date.now() / 1000)), // override start time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
-        vault: vaultPublickey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        history: historyPublicKey,
-        feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
-        ushMint: ushMintPublickey,
-        payer: payerPublicKey,
-        payerUshAccount: payerUshAccount,
-        destinationTokenAccount: destinationTokenAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .redeemVault(
+      new BN(redeemAmount),
+      new BN(transactionOverrideTime ?? Date.now() / 1000) // override start time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      vault: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      history: historyPublicKey,
+      feePool: hedgeStakingPoolPublicKey,
+      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      ushMint: ushMintPublickey,
+      payer: payerPublicKey,
+      payerUshAccount: payerUshAccount,
+      destinationTokenAccount: destinationTokenAccount,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/refreshOraclePrice.ts

@@ -1,9 +1,18 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  LAMPORTS_PER_SOL,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { Vault } from 'idl/vault'
 import { HEDGE_PROGRAM_PUBLICKEY } from '../Constants'
 
-export async function refreshOraclePrice (
-  program: Program,
+export async function refreshOraclePrice(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   collateralType: string,
@@ -12,63 +21,63 @@ export async function refreshOraclePrice (
   overrideTime?: number
 ): Promise<string> {
   const transaction = new Transaction().add(
-    await refreshOraclePriceInstruction(
-      program,
-      collateralType,
-      network,
-      overridePrice,
-      overrideTime
-    )
+    await refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime)
   )
-  return await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts)
+  return await sendAndConfirmTransaction(provider.connection, transaction, [payer])
 }
 
-export async function refreshOraclePriceInstruction (
-  program: Program,
+export async function refreshOraclePriceInstruction(
+  program: Program<Vault>,
   collateralType: string,
   network: Cluster,
   overridePrice?: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const enc = new TextEncoder()
-  const [oracleInfoAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
-  const [vaultTypeAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY)
+  const [oracleInfoAccount] = await PublicKey.findProgramAddress(
+    [enc.encode(collateralType), enc.encode('Oracle')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
+  const [vaultTypeAccount] = await PublicKey.findProgramAddress(
+    [enc.encode(collateralType), enc.encode('State')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
 
-  return program.instruction.refreshOraclePrice(
-    new BN(overridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)-1), // override override time
-    {
-      accounts: {
-        oracleInfoAccount: oracleInfoAccount,
-        vaultTypeAccount: vaultTypeAccount,
-        oracleChainlink: chainlinkAccunts[network],
-        oraclePyth: pythAccounts[network],
-        oracleSwitchboard: switchboardAccounts[network],
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .refreshOraclePrice(
+      new BN(overridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000) - 1) // override override time
+    )
+    .accounts({
+      oracleInfoAccount: oracleInfoAccount,
+      vaultTypeAccount: vaultTypeAccount,
+      oracleChainlink: chainlinkAccunts[network],
+      oraclePyth: pythAccounts[network],
+      oracleSwitchboard: switchboardAccounts[network],
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }
 
 enum Cluster {
   Testing = 'Testing',
   Devnet = 'Devnet',
-  MainnetBeta = 'MainnetBeta'
+  MainnetBeta = 'MainnetBeta',
 }
 
 const pythAccounts = {
   Testing: SystemProgram.programId,
   Devnet: new PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
-  MainnetBeta: new PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG')
+  MainnetBeta: new PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG'),
 }
 const chainlinkAccunts = {
   Testing: SystemProgram.programId,
   Devnet: new PublicKey('FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'),
-  MainnetBeta: SystemProgram.programId // CHAINLINK NOT ON MAINNET YET
+  MainnetBeta: SystemProgram.programId, // CHAINLINK NOT ON MAINNET YET
 }
 const switchboardAccounts = {
   Testing: SystemProgram.programId,
   // Devnet: new PublicKey('GvDMxPzN1sCj7L26YDK2HnMRXEQmQ2aemov8YBtPS7vR'),
   Devnet: new PublicKey('DpoK8Zz69APV9ntjuY9C4LZCxANYMV56M2cbXEdkjxME'),
-  MainnetBeta: SystemProgram.programId // Switchboard V2 NOT ON MAINNET YET
+  MainnetBeta: SystemProgram.programId, // Switchboard V2 NOT ON MAINNET YET
 }

package/src/instructions/repayVault.ts

@@ -1,10 +1,27 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function repayVault (
-  program: Program,
+export async function repayVault(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
@@ -14,14 +31,33 @@ export async function repayVault (
   const ushMintPublickey = await getUshMintPublicKey()
 
   // Prep the user to get USH back out at some point
-  const payerUshAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  const payerUshAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
 
   const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
   const vaultTypeAccount = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
-  const vaultTypeAssociatedTokenAccount = await findAssociatedTokenAddress(vaultTypeAccountPublicKey, vaultTypeAccount.collateralMint)
+  const vaultTypeAssociatedTokenAccount = await findAssociatedTokenAddress(
+    vaultTypeAccountPublicKey,
+    vaultTypeAccount.collateralMint
+  )
   const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, vaultTypeAccount.collateralMint)
 
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
+    program,
+    provider,
+    vaultTypeAccountPublicKey,
+    vaultPublicKey,
+    0,
+    repayAmount * -1,
+    false,
+    false
+  )
+
   const history = Keypair.generate()
   const transaction = new Transaction().add(
     await repayVaultInstruction(
@@ -33,16 +69,19 @@ export async function repayVault (
       history.publicKey,
       vaultTypeAccountPublicKey,
       vaultTypeAssociatedTokenAccount,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       repayAmount,
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }
 
-export async function repayVaultInstruction (
-  program: Program,
+export async function repayVaultInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   ownerUshAccount: PublicKey,
   vaultPublickey: PublicKey,
@@ -50,6 +89,9 @@ export async function repayVaultInstruction (
   historyPublicKey: PublicKey,
   vaultTypeAccount: PublicKey,
   vaultTypeAssociatedTokenAccount: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   repayAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -62,25 +104,28 @@ export async function repayVaultInstruction (
     ushMintPublickey
   )
 
-  return program.instruction.repayVault(
-    new BN(repayAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
-        vaultAccount: vaultPublickey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        history: historyPublicKey,
-        feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
-        ushMint: ushMintPublickey,
-        vaultOwner: payerPublicKey,
-        ownerUshAccount: ownerUshAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .repayVault(
+      new BN(repayAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      vaultAccount: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      history: historyPublicKey,
+      feePool: hedgeStakingPoolPublicKey,
+      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      ushMint: ushMintPublickey,
+      vaultOwner: payerPublicKey,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
+      ownerUshAccount: ownerUshAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/setHalted.ts

@@ -1,48 +1,56 @@
 import { BN, 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, getUshMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  findVaultAddress,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from '../Constants'
 
-import { v4 as uuidv4 } from 'uuid'
 import { parseAnchorErrors } from '../utils/Errors'
+import { Vault } from 'idl/vault'
 
-export async function setHalted (
-  program: Program,
+export async function setHalted(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   halted: boolean
 ): Promise<PublicKey> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
-
   const transaction = new Transaction().add(
-    await setHaltedInstruction(
-      program,
-      vaultSystemStatePublicKey,
-      payer.publicKey,
-      halted
-    )
+    await setHaltedInstruction(program, vaultSystemStatePublicKey, payer.publicKey, halted)
   )
 
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider?.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return vaultSystemStatePublicKey
 }
 
-export async function setHaltedInstruction (
-  program: Program,
+export async function setHaltedInstruction(
+  program: Program<Vault>,
   vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
   halted: boolean
 ): Promise<TransactionInstruction> {
-  const ix = program.instruction.setHalted(
-    halted,
-    {
-      accounts: {
-        payer: payerPublicKey,
-        vaultSystemState: vaultSystemStatePublicKey,
-      },
-      signers: []
+  return await program.methods
+    .setHalted(halted)
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
     })
-  return ix
+    .instruction()
 }