hedge-web3 0.1.0 → 0.1.4

package/src/index.ts

@@ -1,7 +1,5 @@
 
-export function foo (input: String): void {
-  console.log('Input', input)
-}
-
-export * from './accounts/VaultAccount'
+export * as Vaults from './Vaults'
+export * as StakingPool from './StakingPools'
 export * from './HedgeDecimal'
+export * as Constants from './Constants'

package/src/instructions/createStakingPool.ts

@@ -0,0 +1,65 @@
+import { BN, Program } from '@project-serum/anchor'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { parseAnchorErrors } from '../utils/Errors'
+import { findAssociatedTokenAddress, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function createStakingPool (
+  connection: Connection,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  hedgeTokensToBeMinted: number,
+  overrideStartTime?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const transaction = new Transaction().add(
+    await createStakingPoolInstruction(
+      payer.publicKey,
+      mintPublicKey,
+      hedgeTokensToBeMinted,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions).catch(parseAnchorErrors)
+  const [poolPublickey] = await getPoolPublicKeyForMint(mintPublicKey)
+  return poolPublickey
+}
+
+export async function createStakingPoolInstruction (
+  payerPublicKey: PublicKey,
+  mintPublicKey: PublicKey,
+  hedgeTokensToBeMinted: number,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [poolPublickey, poolBump, poolSeedPhrase] = await getPoolPublicKeyForMint(mintPublicKey)
+
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey)
+  const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey)
+
+  return program.instruction.createStakingPool(
+    poolBump,
+    poolSeedPhrase,
+    new BN(hedgeTokensToBeMinted),
+    new BN(overrideStartTime ?? Date.now() / 1000),
+    {
+      accounts: {
+        signer: payerPublicKey,
+        vaultSystemState: vaultSystemStatePublicKey,
+        pool: poolPublickey,
+        stakedTokenMintInfo: mintPublicKey,
+        usdhMint: usdhMintPublickey,
+        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+        poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+        rent: SYSVAR_RENT_PUBKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/createVault.ts

@@ -0,0 +1,66 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function createVault (
+  connection: Connection,
+  payer: Signer,
+  depositAmount: number,
+  collateralRatio: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const newVault = Keypair.generate()
+  const history = Keypair.generate()
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const transaction = new Transaction().add(
+    createVaultInstruction(
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      newVault.publicKey,
+      history.publicKey,
+      depositAmount,
+      collateralRatio
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, newVault, history], confirmOptions)
+  return newVault.publicKey
+}
+
+export function createVaultInstruction (
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  historyPublicKey: PublicKey,
+  depositAmount: number,
+  collateralRatio: number
+): TransactionInstruction {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const ix = program.instruction.createVault(
+    new BN(depositAmount),
+    new BN(collateralRatio)
+    , {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vault: vaultPublicKey,
+        history: historyPublicKey,
+        payer: payerPublicKey,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+  return ix
+}

package/src/instructions/depositStakingPool.ts

@@ -0,0 +1,61 @@
+import { BN, Program } from '@project-serum/anchor'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { parseAnchorErrors } from '../utils/Errors'
+import { findAssociatedTokenAddress, getPoolPublicKeyForMint, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function depositStakingPool (
+  connection: Connection,
+  payer: Signer,
+  mintPublicKey: PublicKey,
+  depositAmount: number,
+  overrideStartTime?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const poolPosition = Keypair.generate()
+  const transaction = new Transaction().add(
+    await depositStakingPoolInstruction(
+      payer.publicKey,
+      poolPosition.publicKey,
+      mintPublicKey,
+      depositAmount,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, poolPosition], confirmOptions).catch(parseAnchorErrors)
+  return poolPosition.publicKey
+}
+
+export async function depositStakingPoolInstruction (
+  payerPublicKey: PublicKey,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  depositAmount: number,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey)
+  const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
+
+  return program.instruction.depositStakingPool(
+    new BN(depositAmount),
+    new BN(overrideStartTime ?? Date.now() / 1000), // override current time
+    {
+      accounts: {
+        payer: payerPublicKey,
+        pool: poolPublickey,
+        poolPosition: poolPositionPublicKey,
+        stakedTokenMintInfo: stakedTokenMintPublicKey,
+        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+        payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+        rent: SYSVAR_RENT_PUBKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/depositVault.ts

@@ -0,0 +1,61 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function depositVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  depositAmount: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const transaction = new Transaction().add(
+    depositVaultInstruction(
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      vaultPublicKey,
+      history.publicKey,
+      depositAmount
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export function depositVaultInstruction (
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  historyPublicKey: PublicKey,
+  depositAmount: number
+): TransactionInstruction {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  return program.instruction.depositVault(
+    new BN(depositAmount)
+    , {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublicKey,
+        history: historyPublicKey,
+        vaultOwner: payerPublicKey,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/liquidateVault.ts

@@ -0,0 +1,67 @@
+import { BN, Program } from '@project-serum/anchor'
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function liquidateVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  chainlinkOverridePrice?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const history = Keypair.generate()
+  const newEra = Keypair.generate()
+  const transaction = new Transaction().add(
+    await liquidateVaultInstruction(
+      payer.publicKey,
+      vaultPublicKey,
+      history.publicKey,
+      newEra.publicKey,
+      chainlinkOverridePrice
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history, newEra], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function liquidateVaultInstruction (
+  payerPublicKey: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  newEraPublicKey: PublicKey,
+  chainlinkOverridePrice?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const [liquidationPoolStatePublicKey] = await getLiquidationPoolStatePublicKey()
+  const [liquidationPoolUsdhAccountPublickey] = await getLiquidationPoolUsdhAccountPublicKey()
+
+  const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
+
+  return program.instruction.liquidateVault(
+    new BN(chainlinkOverridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        poolEra: poolStateInfo.currentEra,
+        vaultAccount: vaultPublickey,
+        poolState: liquidationPoolStatePublicKey,
+        usdhMint: usdhMintPublickey,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        history: historyPublicKey,
+        payer: payerPublicKey,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        feePool: hedgeStakingPoolPublicKey,
+        poolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+        newEra: newEraPublicKey
+      },
+      signers: []
+    })
+}

package/src/instructions/loanVault.ts

@@ -0,0 +1,79 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function loanVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  loanAmount: number,
+  chainlinkOverridePrice?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await loanVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      loanAmount,
+      chainlinkOverridePrice
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function loanVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  loanAmount: number,
+  chainlinkOverridePrice?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.loanVault(
+    new BN(loanAmount),
+    new BN(chainlinkOverridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        vaultOwner: payerPublicKey,
+        ownerUsdhAccount: ownerUsdhAccount,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/redeemVault.ts

@@ -0,0 +1,83 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function redeemVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  repayAmount: number,
+  chainlinkOverridePrice?: number,
+  transactionOverrideTime?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await redeemVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      repayAmount,
+      chainlinkOverridePrice,
+      transactionOverrideTime
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function redeemVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  repayAmount: number,
+  chainlinkOverridePrice?: number,
+  transactionOverrideTime?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.redeemVault(
+    new BN(repayAmount),
+    new BN(chainlinkOverridePrice ?? 150 * LAMPORTS_PER_SOL), // override usd/sol price
+    new BN(transactionOverrideTime ?? (Date.now() / 1000)), // override start time
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        payer: payerPublicKey,
+        payerUsdhAccount: ownerUsdhAccount,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/repayVault.ts

@@ -0,0 +1,74 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function repayVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  repayAmount: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await repayVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      repayAmount
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function repayVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  repayAmount: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.repayVault(
+    new BN(repayAmount),
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        vaultOwner: payerPublicKey,
+        ownerUsdhAccount: ownerUsdhAccount,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/withdrawStakingPool.ts

@@ -0,0 +1,70 @@
+import { BN, Program } from '@project-serum/anchor'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { parseAnchorErrors } from '../utils/Errors'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function withdrawStakingPool (
+  connection: Connection,
+  payer: Signer,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  overrideStartTime?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const poolPosition = Keypair.generate()
+  const transaction = new Transaction().add(
+    await withdrawStakingPoolInstruction(
+      payer.publicKey,
+      poolPositionPublicKey,
+      stakedTokenMintPublicKey,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions).catch(parseAnchorErrors)
+  return poolPosition.publicKey
+}
+
+export async function withdrawStakingPoolInstruction (
+  payerPublicKey: PublicKey,
+  poolPositionPublicKey: PublicKey,
+  stakedTokenMintPublicKey: PublicKey,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
+  const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey)
+  const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey)
+  const payerAssociatedStakedTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
+  const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payerPublicKey, hedgeMintPublickey)
+  const payerAssociatedUsdhAccount = await findAssociatedTokenAddress(payerPublicKey, usdhMintPublickey)
+
+  return program.instruction.withdrawStakingPool(
+    new BN(overrideStartTime ?? Date.now() / 1000), // override current time
+    {
+      accounts: {
+        payer: payerPublicKey,
+        vaultSystemState: vaultSystemStatePublicKey,
+        pool: poolPublickey,
+        poolPosition: poolPositionPublicKey,
+        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+        poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+        payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
+        payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+        payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
+        hedgeMint: hedgeMintPublickey,
+        stakedTokenMint: stakedTokenMintPublicKey,
+        usdhMint: usdhMintPublickey,
+        rent: SYSVAR_RENT_PUBKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}