hedge-web3 0.1.14 → 0.1.17

package/src/instructions/depositVault.ts

@@ -1,41 +1,41 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { TokenInstructions } from '@project-serum/serum'
-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, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
 
-export async function depositVault (
+export async function depositVault(
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  // collateralType: string,
-  depositAmount: number
+  depositAmount: number,
+  overrideTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
 
   // Prep the user to get USDH back out at some point
-  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint)
+  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 payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint)
-  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint)
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
+  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(vaultPublicKey, vaultTypeAccountInfo.collateralMint)
 
   const history = Keypair.generate()
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
   const wrappedSolAccount = Keypair.generate()
 
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
   const transaction = new Transaction()
   const signers = [payer, history]
 
@@ -65,10 +65,14 @@ export async function depositVault (
       vaultPublicKey,
       vaultAssociatedCollateralAccountPublicKey,
       history.publicKey,
-      collateralStateAccountPublicKey,
-      collateralAssociatedTokenAccount,
-      collateralStateAccountInfo.collateralMint,
-      depositAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
+      hedgeStakingPoolPublicKey,
+      hedgeStakingPoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountInfo.collateralMint,
+      usdhMintPublickey,
+      depositAmount,
+      overrideTime
     )
   )
   if (vaultAccount.collateralType === 'SOL') {
@@ -85,7 +89,7 @@ export async function depositVault (
   return vaultPublicKey
 }
 
-export async function depositVaultInstruction (
+export async function depositVaultInstruction(
   program: Program,
   vaultSystemStatePublicKey: PublicKey,
   vaultOwner: PublicKey,
@@ -93,24 +97,32 @@ export async function depositVaultInstruction (
   vaultPublicKey: PublicKey,
   vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  collateralStateAccountPublicKey: PublicKey,
-  collateralAssociatedTokenAccount: PublicKey,
+  vaultTypeAccountPublicKey: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  hedgeStakingPoolPublicKey: PublicKey,
+  hedgeStakingPoolAssociatedUsdhTokenAccount: PublicKey,
   collateralMint: PublicKey,
-  depositAmount: number
+  usdhMintPublickey: PublicKey,
+  depositAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
   return program.instruction.depositVault(
-    new BN(depositAmount)
-    , {
+    new BN(depositAmount),
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
+    {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccountPublicKey,
-        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vaultTypeAccount: vaultTypeAccountPublicKey,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         collateralTokenMint: collateralMint,
         vault: vaultPublicKey,
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         history: historyPublicKey,
         vaultOwner: vaultOwner,
         vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+        usdhMint: usdhMintPublickey,
         systemProgram: SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID
       },

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/liquidateVault.ts

@@ -1,38 +1,33 @@
-import { Program, Provider } from '@project-serum/anchor'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+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, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey, findAssociatedTokenAddress } from '../Constants'
+import { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function liquidateVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  preload: boolean
+  overrideTime?: number
 ): Promise<PublicKey> {
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
 
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralMint = collateralStateAccountInfo.collateralMint
-
-  const token = new Token(
-    provider.connection,
-    collateralMint,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
+  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 token.getOrCreateAssociatedAccountInfo(payer.publicKey)
-  const feePoolAssociatedTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, collateralMint)
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralMint)
-  const poolAssociatedTokenAccount = await findAssociatedTokenAddress(liquidationPoolStatePublicKey, collateralMint)
-  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralMint)
+  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()
@@ -44,18 +39,19 @@ export async function liquidateVault (
       payer.publicKey,
       payerAssociatedTokenAccount.address,
       vaultPublicKey,
-      vaultAssociatedTokenAccount,
+      vaultAssociatedTokenAccount.address,
       liquidationPoolStatePublicKey,
       poolStateInfo.currentEra,
-      poolAssociatedTokenAccount,
+      poolAssociatedTokenAccount.address,
       history.publicKey,
       newEra.publicKey,
       hedgeStakingPoolPublicKey,
-      feePoolAssociatedTokenAccount,
+      feePoolAssociatedTokenAccount.address,
+      hedgeStakingPoolAssociatedUsdhTokenAccount.address,
       collateralMint,
-      collateralAssociatedTokenAccount,
+      vaultTypeAssociatedTokenAccount.address,
       vaultAccount.collateralType,
-      preload
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts)
@@ -75,21 +71,22 @@ export async function liquidateVaultInstruction (
   newEraPublicKey: PublicKey,
   feePool: PublicKey,
   feePoolAssociatedTokenAccount: PublicKey,
+  hedgeStakingPoolAssociatedUsdhTokenAccount: PublicKey,
   collateralMint: PublicKey,
-  collateralAssociatedTokenAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
   collateralType: string,
-  preload: boolean
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const usdhMintPublickey = await getUsdhMintPublicKey()
   const liquidationPoolUsdhAccountPublickey = await getLiquidationPoolUsdhAccountPublicKey()
-  const collateralStateAccount = await getCollateralStateAccountPublicKey(collateralType)
+  const vaultTypeAccount = await getVaultTypeAccountPublicKey(collateralType)
 
   const payload = {
     accounts: {
       vaultSystemState: vaultSystemStatePublicKey,
-      collateralStateAccount: collateralStateAccount,
-      collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
       collateralMint: collateralMint,
       poolEra: poolEra,
       vaultAccount: vaultPublickey,
@@ -102,6 +99,7 @@ export async function liquidateVaultInstruction (
       payerAssociatedTokenAccount: payerAssociatedTokenAccount,
       feePool: feePool,
       feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
+      feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
       liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
       newEra: newEraPublicKey,
       tokenProgram: TOKEN_PROGRAM_ID,
@@ -111,8 +109,7 @@ export async function liquidateVaultInstruction (
     },
     signers: []
   }
-  if (preload) {
-    return program.instruction.liquidateVaultPrepAccounts(payload)
-  }
-  return program.instruction.liquidateVault(payload)
+  return program.instruction.liquidateVault(
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
+    payload)
 }

package/src/instructions/loanVault.ts

@@ -1,30 +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, getCollateralStateAccountPublicKey, 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
-  )
 
-  // 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 collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
-  const collateralStateAccount = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccount.collateralMint)
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccount.collateralMint)
+  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(
@@ -33,11 +28,12 @@ export async function loanVault (
       payer.publicKey,
       payerUsdhAccount.address,
       vaultPublicKey,
-      vaultAssociatedTokenAccount,
+      vaultAssociatedTokenAccount.address,
       history.publicKey,
-      collateralStateAccountPublicKey,
-      collateralAssociatedTokenAccount,
-      loanAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
+      loanAmount,
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
@@ -51,9 +47,10 @@ export async function loanVaultInstruction (
   vaultPublickey: PublicKey,
   vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  collateralStateAccount: PublicKey,
-  collateralAssociatedTokenAccount: PublicKey,
-  loanAmount: number
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  loanAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const usdhMintPublickey = await getUsdhMintPublicKey()
@@ -66,11 +63,12 @@ export async function loanVaultInstruction (
 
   return program.instruction.loanVault(
     new BN(loanAmount),
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         vaultAccount: vaultPublickey,
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,

package/src/instructions/redeemVault.ts

@@ -1,8 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 // import { TokenInstructions } from '@project-serum/serum'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function redeemVault (
   program: Program,
@@ -13,31 +13,18 @@ export async function redeemVault (
   transactionOverrideTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.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 payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint)
-
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint)
+  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 token = new Token(
-    provider.connection,
-    collateralStateAccountInfo.collateralMint,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
+  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultPublicKey, true)
 
-  const payerTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey)
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -47,10 +34,10 @@ export async function redeemVault (
       payerUsdhAccount.address,
       payerTokenAccount.address,
       vaultPublicKey,
-      vaultAssociatedTokenAccount,
+      vaultAssociatedTokenAccount.address,
       history.publicKey,
-      collateralStateAccountPublicKey,
-      collateralAssociatedTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
       redeemAmount,
       transactionOverrideTime
     )
@@ -67,8 +54,8 @@ export async function redeemVaultInstruction (
   vaultPublickey: PublicKey,
   vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  collateralStateAccount: PublicKey,
-  collateralAssociatedTokenAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
   redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -86,8 +73,8 @@ export async function redeemVaultInstruction (
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         vault: vaultPublickey,
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,

package/src/instructions/refreshOraclePrice.ts

@@ -32,7 +32,7 @@ export async function refreshOraclePriceInstruction (
 ): Promise<TransactionInstruction> {
   const enc = new TextEncoder()
   const [oracleInfoAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
-  const [collateralStateAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], 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
@@ -40,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,31 +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, getCollateralStateAccountPublicKey, 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
-  )
 
   // 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 collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
-  const collateralStateAccount = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccount.collateralMint)
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccount.collateralMint)
+  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(
@@ -36,9 +31,10 @@ export async function repayVault (
       vaultPublicKey,
       vaultAssociatedTokenAccount,
       history.publicKey,
-      collateralStateAccountPublicKey,
-      collateralAssociatedTokenAccount,
-      repayAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount,
+      repayAmount,
+      overrideTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
@@ -52,9 +48,10 @@ export async function repayVaultInstruction (
   vaultPublickey: PublicKey,
   vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  collateralStateAccount: PublicKey,
-  collateralAssociatedTokenAccount: PublicKey,
-  repayAmount: number
+  vaultTypeAccount: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  repayAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const usdhMintPublickey = await getUsdhMintPublicKey()
@@ -67,11 +64,12 @@ export async function repayVaultInstruction (
 
   return program.instruction.repayVault(
     new BN(repayAmount),
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vaultTypeAccount: vaultTypeAccount,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
         vaultAccount: vaultPublickey,
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,

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
+}