hedge-web3 0.1.14 → 0.1.15

package/src/index.ts

@@ -13,6 +13,8 @@ export * from './instructions/repayVault'
 export * from './instructions/redeemVault'
 export * from './instructions/liquidateVault'
 export * from './instructions/refreshOraclePrice'
+export * from './instructions/initHedgeFoundation'
+export * from './instructions/setHalted'
 
 export * from './HedgeDecimal'
 export * from './Constants'

package/src/instructions/claimLiquidationPoolPosition.ts

@@ -1,8 +1,8 @@
 import { Program, Provider } from '@project-serum/anchor'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getCollateralStateAccountPublicKey, getLiquidationPoolStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getLiquidationPoolStatePublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function claimLiquidationPoolPosition (
   program: Program,
@@ -12,48 +12,56 @@ export async function claimLiquidationPoolPosition (
   collateralType: string,
   overrideStartTime?: number
 ): Promise<PublicKey> {
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
-  const collateralMint = collateralStateAccountInfo.collateralMint
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const collateralMint = vaultTypeAccountInfo.collateralMint
 
   const poolStatePublicKey = await getLiquidationPoolStatePublicKey()
   const poolAssociatedTokenAccount = await findAssociatedTokenAddress(poolStatePublicKey, collateralMint)
-  const payerAssociatedTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralMint)
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    payer.publicKey
+  )
 
   const transaction = new Transaction().add(
     await claimLiquidationPoolPositionInstruction(
       program,
       poolStatePublicKey,
       poolAssociatedTokenAccount,
-      collateralStateAccountPublicKey,
+      vaultTypeAccountPublicKey,
       collateralMint,
       poolPosition,
       payer.publicKey,
-      payerAssociatedTokenAccount,
+      payerAssociatedTokenAccount.address,
       overrideStartTime
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
-  return payerAssociatedTokenAccount
+  return payerAssociatedTokenAccount.address
 }
 
 export async function claimLiquidationPoolPositionInstruction (
   program: Program,
   poolState: PublicKey,
   poolAssociatedTokenAccount: PublicKey,
-  collateralStateAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
   collateralMint: PublicKey,
   poolPosition: PublicKey,
   payer: PublicKey,
   payerAssociatedTokenAccount: PublicKey,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
+  const vaultSystemState = await getVaultSystemStatePublicKey()
+
   return program.instruction.claimLiquidationPoolPosition(
     {
       accounts: {
+        vaultSystemState: vaultSystemState,
         poolState: poolState,
         poolAssociatedTokenAccount: poolAssociatedTokenAccount,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
         collateralMint: collateralMint,
         poolPosition: poolPosition,
         payer: payer,

package/src/instructions/closeLiquidationPoolPosition.ts

@@ -1,8 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function closeLiquidationPoolPosition (
   program: Program,
@@ -12,13 +12,7 @@ export async function closeLiquidationPoolPosition (
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const poolState = await getLiquidationPoolStatePublicKey()
   const liquidationPositionAccount = await program.account.liquidationPosition.fetch(poolPosition)
@@ -27,8 +21,8 @@ export async function closeLiquidationPoolPosition (
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const poolUsdhAccount = await getLiquidationPoolUsdhAccountPublicKey()
   const hedgeMint = await getHedgeMintPublicKey()
-  const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payer.publicKey, hedgeMint)
-  const communityAssociatedHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMint)
+  const payerAssociatedHedgeAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, payer.publicKey)
+  const communityAssociatedHedgeTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, hedgeMint, vaultSystemStatePublicKey, true)
 
   const transaction = new Transaction().add(
     await closeLiquidationPoolPositionInstruction(
@@ -41,8 +35,8 @@ export async function closeLiquidationPoolPosition (
       payer.publicKey,
       payerUsdhAccount.address,
       hedgeMint,
-      payerAssociatedHedgeAccount,
-      communityAssociatedHedgeTokenAccount,
+      payerAssociatedHedgeAccount.address,
+      communityAssociatedHedgeTokenAccount.address,
       overrideStartTime
     )
   )

package/src/instructions/createVault.ts

@@ -1,8 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { TokenInstructions } from '@project-serum/serum'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+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, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, findVaultAddress, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
 
 import { v4 as uuidv4 } from 'uuid'
 import { parseAnchorErrors } from '../utils/Errors'
@@ -13,29 +13,22 @@ export async function createVault (
   payer: Signer,
   collateralType: string,
   depositAmount: number,
-  collateralRatio: number
+  overrideTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
 
   const salt = uuidv4().substring(0, 8)
   const newVaultPublicKey = await findVaultAddress(salt)
   const history = Keypair.generate()
 
   // Prep the user to get USDH back out at some point
-  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
-
-  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType)
-  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
+  await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
-  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint)
-  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(newVaultPublicKey, collateralStateAccountInfo.collateralMint)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
 
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(newVaultPublicKey, vaultTypeAccountInfo.collateralMint)
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
   const wrappedSolAccount = Keypair.generate()
@@ -43,7 +36,15 @@ export async function createVault (
   const transaction = new Transaction()
   const signers = [payer, history]
 
-  if (collateralType === 'SOL') {
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
+
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const feePoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  if (isWrappedSol) {
     transaction.add(
       SystemProgram.createAccount({
         fromPubkey: payer.publicKey,
@@ -66,17 +67,20 @@ export async function createVault (
       salt,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
+      isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
       newVaultPublicKey,
-      vaultAssociatedCollateralAccountPublicKey,
-      collateralStateAccountPublicKey,
-      collateralStateAccountInfo.collateralMint,
+      vaultAssociatedTokenAccount,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAccountInfo.collateralMint,
       history.publicKey,
+      usdhMintPublickey,
       depositAmount,
-      collateralRatio
+      overrideTime
     )
   )
-  if (collateralType === 'SOL') {
+  if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
         source: wrappedSolAccount.publicKey,
@@ -97,27 +101,33 @@ export async function createVaultInstruction (
   payerPublicKey: PublicKey,
   payerTokenAccountPublicKey: PublicKey,
   vaultPublicKey: PublicKey,
-  vaultAssociatedCollateralPublicKey: PublicKey,
-  collateralStateAccount: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
+  feePool: PublicKey,
+  feePoolAssociatedUsdhTokenAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
   collateralMint: PublicKey,
   historyPublicKey: PublicKey,
+  usdhMintPublickey: PublicKey,
   depositAmount: number,
-  collateralRatio: number
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
   const ix = program.instruction.createVault(
     salt,
     new BN(depositAmount),
-    new BN(collateralRatio)
-    , {
+    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
+    {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
+        vaultTypeAccount: vaultTypeAccount,
         vault: vaultPublicKey,
-        vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+        feePool: feePool,
+        feePoolAssociatedUsdhTokenAccount: feePoolAssociatedUsdhTokenAccount,
         history: historyPublicKey,
         payer: payerPublicKey,
         payerTokenAccount: payerTokenAccountPublicKey,
         collateralMint: collateralMint,
+        usdhMint: usdhMintPublickey,
         systemProgram: SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID,
         associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,

package/src/instructions/depositLiquidationPool.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 { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey } from '../Constants'
+import { getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function depositLiquidationPool (
   program: Program,
@@ -12,13 +12,7 @@ export async function depositLiquidationPool (
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const usdhMintPublickey = await getUsdhMintPublicKey()
-  const USDH = new Token(
-    provider.connection,
-    usdhMintPublickey,
-    TOKEN_PROGRAM_ID,
-    payer
-  )
-  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
   const poolPosition = Keypair.generate()
   const transaction = new Transaction().add(
@@ -49,11 +43,14 @@ export async function depositLiquidationPoolInstruction (
   const poolUSDHAccount = await getLiquidationPoolUsdhAccountPublicKey()
   const usdhMint = await getUsdhMintPublicKey()
 
+  const vaultSystemState = await getVaultSystemStatePublicKey()
+
   return program.instruction.depositLiquidationPool(
     new BN(depositAmount),
     new BN(overrideStartTime ?? Date.now() / 1000), // override current time
     {
       accounts: {
+        vaultSystemState: vaultSystemState,
         poolState: liquidationPoolStatePublicKey,
         poolEra: liquidationPoolState.currentEra,
         poolPosition: poolPositionPublicKey,

package/src/instructions/depositStakingPool.ts

@@ -2,7 +2,7 @@ import { BN, 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, getPoolPublicKeyForMint } from '../Constants'
+import { findAssociatedTokenAddress, getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function depositStakingPool (
   program: Program,
@@ -38,6 +38,7 @@ export async function depositStakingPoolInstruction (
   const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey)
   const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
+  const vaultSystemState = await getVaultSystemStatePublicKey()
 
   return program.instruction.depositStakingPool(
     new BN(depositAmount),
@@ -45,6 +46,7 @@ export async function depositStakingPoolInstruction (
     {
       accounts: {
         payer: payerPublicKey,
+        vaultSystemState: vaultSystemState,
         pool: poolPublickey,
         poolPosition: poolPositionPublicKey,
         stakedTokenMintInfo: stakedTokenMintPublicKey,

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