hedge-web3 0.1.13 → 0.1.16

package/src/instructions/initHedgeFoundation.ts

@@ -0,0 +1,64 @@
+import { 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, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function initHedgeFoundation(
+  program: Program,
+  provider: Provider,
+  payer: Signer
+): Promise<PublicKey> {
+
+  const poolEra = Keypair.generate()
+  const transaction = new Transaction().add(
+    await initHedgeFoundationInstruction(
+      program,
+      poolEra.publicKey,
+      payer.publicKey,
+    )
+  )
+
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolEra], provider.opts).catch(parseAnchorErrors)
+  return payer.publicKey
+}
+
+export async function initHedgeFoundationInstruction (
+  program: Program,
+  poolEraPublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const poolStatePublickey = await getLiquidationPoolStatePublicKey()
+  const poolUsdhTokenAccount = await getLiquidationPoolUsdhAccountPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
+  const founderHedgeTokenAccount = await findAssociatedTokenAddress(
+    payerPublicKey,
+    hedgeMintPublickey
+  )
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(
+    vaultSystemStatePublicKey,
+    hedgeMintPublickey
+  )
+
+  return program.instruction.initHedgeFoundation(
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        poolState: poolStatePublickey,
+        poolEra: poolEraPublicKey,
+        poolUsdhAccount: poolUsdhTokenAccount,
+        founder: payerPublicKey,
+        usdhMint: usdhMintPublickey,
+        hedgeMint: hedgeMintPublickey,
+        founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
+        communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+        rent: SYSVAR_RENT_PUBKEY,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/initHedgeFoundationTokens.ts

@@ -0,0 +1,55 @@
+import { 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, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function initHedgeFoundationTokens(
+  program: Program,
+  provider: Provider,
+  payer: Signer
+): Promise<PublicKey> {
+
+  const poolEra = Keypair.generate()
+  const transaction = new Transaction().add(
+    await initHedgeFoundationTokensInstruction(
+      program,
+      payer.publicKey,
+    )
+  )
+
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  return payer.publicKey
+}
+
+export async function initHedgeFoundationTokensInstruction (
+  program: Program,
+  payerPublicKey: PublicKey,
+): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
+  const founderHedgeTokenAccount = await findAssociatedTokenAddress(
+    payerPublicKey,
+    hedgeMintPublickey
+  )
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(
+    vaultSystemStatePublicKey,
+    hedgeMintPublickey
+  )
+
+  return program.instruction.initHedgeFoundationTokens(
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        founder: payerPublicKey,
+        hedgeMint: hedgeMintPublickey,
+        founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
+        communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+        rent: SYSVAR_RENT_PUBKEY,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/liquidateVault.ts

@@ -1,23 +1,57 @@
-import { Program, Provider } from '@project-serum/anchor'
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { BN, Program, Provider } from '@project-serum/anchor'
+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 { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function liquidateVault (
   program: Program,
   provider: Provider,
   payer: Signer,
-  vaultPublicKey: PublicKey
+  vaultPublicKey: PublicKey,
+  overrideTime?: number
 ): Promise<PublicKey> {
+  const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
+
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const collateralMint = vaultTypeAccountInfo.collateralMint
+
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey()
+  const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, payer.publicKey, true)
+  const feePoolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, hedgeStakingPoolPublicKey, true)
+  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, vaultPublicKey, true)
+  const poolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, liquidationPoolStatePublicKey, true)
+  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, collateralMint, vaultTypeAccountPublicKey, true)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, hedgeStakingPoolPublicKey, true)
+
   const history = Keypair.generate()
   const newEra = Keypair.generate()
-  const transaction = new Transaction().add(
+  const transaction = new Transaction()
+
+  transaction.add(
     await liquidateVaultInstruction(
       program,
       payer.publicKey,
+      payerAssociatedTokenAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount.address,
+      liquidationPoolStatePublicKey,
+      poolStateInfo.currentEra,
+      poolAssociatedTokenAccount.address,
       history.publicKey,
-      newEra.publicKey
+      newEra.publicKey,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedTokenAccount.address,
+      hedgeStakingPoolAssociatedUsdhTokenAccount.address,
+      collateralMint,
+      vaultTypeAssociatedTokenAccount.address,
+      vaultAccount.collateralType,
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts)
@@ -27,37 +61,55 @@ export async function liquidateVault (
 export async function liquidateVaultInstruction (
   program: Program,
   payerPublicKey: PublicKey,
+  payerAssociatedTokenAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
+  poolState: PublicKey,
+  poolEra: PublicKey,
+  poolAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  newEraPublicKey: PublicKey
+  newEraPublicKey: PublicKey,
+  feePool: PublicKey,
+  feePoolAssociatedTokenAccount: PublicKey,
+  hedgeStakingPoolAssociatedUsdhTokenAccount: PublicKey,
+  collateralMint: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  collateralType: string,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
-  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 collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
-  const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const liquidationPoolUsdhAccountPublickey = await getLiquidationPoolUsdhAccountPublicKey()
+  const vaultTypeAccount = await getVaultTypeAccountPublicKey(collateralType)
 
+  const payload = {
+    accounts: {
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      collateralMint: collateralMint,
+      poolEra: poolEra,
+      vaultAccount: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      poolState: poolState,
+      poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+      usdhMint: usdhMintPublickey,
+      history: historyPublicKey,
+      payer: payerPublicKey,
+      payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+      feePool: feePool,
+      feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
+      feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+      liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+      newEra: newEraPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY
+    },
+    signers: []
+  }
   return program.instruction.liquidateVault(
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        poolEra: poolStateInfo.currentEra,
-        vaultAccount: vaultPublickey,
-        poolState: liquidationPoolStatePublicKey,
-        usdhMint: usdhMintPublickey,
-        history: historyPublicKey,
-        payer: payerPublicKey,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        feePool: hedgeStakingPoolPublicKey,
-        liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
-        newEra: newEraPublicKey
-      },
-      signers: []
-    })
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
+    payload)
 }

package/src/instructions/loanVault.ts

@@ -1,25 +1,25 @@
 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, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function loanVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  loanAmount: number
+  loanAmount: 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 payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
-  // Prep the user to get USDH back out at some point
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(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 history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -28,8 +28,12 @@ export async function loanVault (
       payer.publicKey,
       payerUsdhAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount.address,
       history.publicKey,
-      loanAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
+      loanAmount,
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
@@ -41,33 +45,39 @@ export async function loanVaultInstruction (
   payerPublicKey: PublicKey,
   ownerUsdhAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  loanAmount: number
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  loanAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
   const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
   )
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
 
   return program.instruction.loanVault(
     new BN(loanAmount),
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         vaultAccount: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
         feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         usdhMint: usdhMintPublickey,
         vaultOwner: payerPublicKey,
         ownerUsdhAccount: ownerUsdhAccount,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/redeemVault.ts

@@ -1,26 +1,30 @@
 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 { TokenInstructions } from '@project-serum/serum'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function redeemVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  repayAmount: number,
+  redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
+  const usdhMintPublickey = await getUsdhMintPublicKey()
 
   // Prep the user to get USDH back out at some point
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, 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 vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultPublicKey, true)
+
+  const payerTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey)
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -28,9 +32,13 @@ export async function redeemVault (
       program,
       payer.publicKey,
       payerUsdhAccount.address,
+      payerTokenAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount.address,
       history.publicKey,
-      repayAmount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
+      redeemAmount,
       transactionOverrideTime
     )
   )
@@ -41,37 +49,42 @@ export async function redeemVault (
 export async function redeemVaultInstruction (
   program: Program,
   payerPublicKey: PublicKey,
-  ownerUsdhAccount: PublicKey,
+  payerUsdhAccount: PublicKey,
+  destinationTokenAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  repayAmount: number,
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
   const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
   )
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   return program.instruction.redeemVault(
-    new BN(repayAmount),
+    new BN(redeemAmount),
     new BN(transactionOverrideTime ?? (Date.now() / 1000)), // override start time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        vaultAccount: vaultPublickey,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+        vault: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
         feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         usdhMint: usdhMintPublickey,
         payer: payerPublicKey,
-        payerUsdhAccount: ownerUsdhAccount,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        payerUsdhAccount: payerUsdhAccount,
+        destinationTokenAccount: destinationTokenAccount,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/refreshOraclePrice.ts

@@ -6,6 +6,7 @@ export async function refreshOraclePrice (
   program: Program,
   provider: Provider,
   payer: Signer,
+  collateralType: string,
   network: Cluster,
   overridePrice?: number,
   overrideTime?: number
@@ -13,6 +14,7 @@ export async function refreshOraclePrice (
   const transaction = new Transaction().add(
     await refreshOraclePriceInstruction(
       program,
+      collateralType,
       network,
       overridePrice,
       overrideTime
@@ -23,13 +25,14 @@ export async function refreshOraclePrice (
 
 export async function refreshOraclePriceInstruction (
   program: Program,
+  collateralType: string,
   network: Cluster,
   overridePrice?: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const enc = new TextEncoder()
-  const [oracleInfoAccount] = await PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
-  const [collateralStateAccount] = await PublicKey.findProgramAddress([enc.encode('SOL'), 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
@@ -37,7 +40,7 @@ export async function refreshOraclePriceInstruction (
     {
       accounts: {
         oracleInfoAccount: oracleInfoAccount,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
         oracleChainlink: chainlinkAccunts[network],
         oraclePyth: pythAccounts[network],
         oracleSwitchboard: switchboardAccounts[network],

package/src/instructions/repayVault.ts

@@ -1,25 +1,26 @@
 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, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function repayVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  repayAmount: number
+  repayAmount: number,
+  overrideTime?: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
+  const usdhMintPublickey = await getUsdhMintPublicKey()
 
   // Prep the user to get USDH back out at some point
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, 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 vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, vaultTypeAccount.collateralMint)
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -28,8 +29,12 @@ export async function repayVault (
       payer.publicKey,
       payerUsdhAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount,
       history.publicKey,
-      repayAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount,
+      repayAmount,
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
@@ -41,34 +46,39 @@ export async function repayVaultInstruction (
   payerPublicKey: PublicKey,
   ownerUsdhAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  repayAmount: number
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  repayAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
   const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
   )
 
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   return program.instruction.repayVault(
     new BN(repayAmount),
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         vaultAccount: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
         feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         usdhMint: usdhMintPublickey,
         vaultOwner: payerPublicKey,
         ownerUsdhAccount: ownerUsdhAccount,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/setHalted.ts

@@ -0,0 +1,48 @@
+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, getUsdhMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
+
+import { v4 as uuidv4 } from 'uuid'
+import { parseAnchorErrors } from '../utils/Errors'
+
+export async function setHalted (
+  program: Program,
+  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 sendAndConfirmTransaction(provider.connection, transaction, [payer], provider?.opts).catch(parseAnchorErrors)
+  return vaultSystemStatePublicKey
+}
+
+export async function setHaltedInstruction (
+  program: Program,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  halted: boolean
+): Promise<TransactionInstruction> {
+  const ix = program.instruction.setHalted(
+    halted,
+    {
+      accounts: {
+        payer: payerPublicKey,
+        vaultSystemState: vaultSystemStatePublicKey,
+      },
+      signers: []
+    })
+  return ix
+}