hedge-web3 0.1.13 → 0.1.16

package/src/index.ts

@@ -2,6 +2,9 @@
 export * from './instructions/createStakingPool'
 export * from './instructions/depositStakingPool'
 export * from './instructions/withdrawStakingPool'
+export * from './instructions/depositLiquidationPool'
+export * from './instructions/closeLiquidationPoolPosition'
+export * from './instructions/claimLiquidationPoolPosition'
 export * from './instructions/createVault'
 export * from './instructions/depositVault'
 export * from './instructions/withdrawVault'
@@ -10,6 +13,9 @@ export * from './instructions/repayVault'
 export * from './instructions/redeemVault'
 export * from './instructions/liquidateVault'
 export * from './instructions/refreshOraclePrice'
+export * from './instructions/initHedgeFoundation'
+export * from './instructions/initHedgeFoundationTokens'
+export * from './instructions/setHalted'
 
 export * from './HedgeDecimal'
 export * from './Constants'

package/src/instructions/claimLiquidationPoolPosition.ts

@@ -0,0 +1,76 @@
+import { Program, Provider } from '@project-serum/anchor'
+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, getVaultTypeAccountPublicKey, getLiquidationPoolStatePublicKey, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function claimLiquidationPoolPosition (
+  program: Program,
+  provider: Provider,
+  poolPosition: PublicKey,
+  payer: Signer,
+  collateralType: string,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  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 getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    payer.publicKey
+  )
+
+  const transaction = new Transaction().add(
+    await claimLiquidationPoolPositionInstruction(
+      program,
+      poolStatePublicKey,
+      poolAssociatedTokenAccount,
+      vaultTypeAccountPublicKey,
+      collateralMint,
+      poolPosition,
+      payer.publicKey,
+      payerAssociatedTokenAccount.address,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  return payerAssociatedTokenAccount.address
+}
+
+export async function claimLiquidationPoolPositionInstruction (
+  program: Program,
+  poolState: PublicKey,
+  poolAssociatedTokenAccount: 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,
+        vaultTypeAccount: vaultTypeAccount,
+        collateralMint: collateralMint,
+        poolPosition: poolPosition,
+        payer: payer,
+        payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_PUBKEY
+      },
+      signers: []
+    })
+}

package/src/instructions/closeLiquidationPoolPosition.ts

@@ -0,0 +1,82 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+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 { getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUsdhAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function closeLiquidationPoolPosition (
+  program: Program,
+  provider: Provider,
+  poolPosition: PublicKey,
+  payer: Signer,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
+
+  const poolState = await getLiquidationPoolStatePublicKey()
+  const liquidationPositionAccount = await program.account.liquidationPosition.fetch(poolPosition)
+  const poolEra = liquidationPositionAccount.era
+
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const poolUsdhAccount = await getLiquidationPoolUsdhAccountPublicKey()
+  const hedgeMint = await getHedgeMintPublicKey()
+  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(
+      program,
+      vaultSystemStatePublicKey,
+      poolState,
+      poolEra,
+      poolPosition,
+      poolUsdhAccount,
+      payer.publicKey,
+      payerUsdhAccount.address,
+      hedgeMint,
+      payerAssociatedHedgeAccount.address,
+      communityAssociatedHedgeTokenAccount.address,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  return poolPosition
+}
+
+export async function closeLiquidationPoolPositionInstruction (
+  program: Program,
+  vaultSystemState: PublicKey,
+  poolState: PublicKey,
+  poolEra: PublicKey,
+  poolPosition: PublicKey,
+  poolUsdhAccount: PublicKey,
+  payerPublicKey: PublicKey,
+  payerUsdhAccount: PublicKey,
+  hedgeMint: PublicKey,
+  payerAssociatedHedgeAccount: PublicKey,
+  communityAssociatedHedgeTokenAccount: PublicKey,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  return program.instruction.closeLiquidationPoolPosition(
+    new BN(overrideStartTime ?? Date.now() / 1000), // override current time
+    {
+      accounts: {
+        vaultSystemState: vaultSystemState,
+        poolState: poolState,
+        poolEra: poolEra,
+        poolPosition: poolPosition,
+        poolUsdhAccount: poolUsdhAccount,
+        payer: payerPublicKey,
+        ownerUsdhAccount: payerUsdhAccount,
+        hedgeMint: hedgeMint,
+        payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+        communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccount,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_PUBKEY
+      },
+      signers: []
+    })
+}

package/src/instructions/createStakingPool.ts

@@ -33,8 +33,8 @@ export async function createStakingPoolInstruction (
   hedgeTokensToBeMinted: number,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const [poolPublickey, poolBump, poolSeedPhrase] = await getPoolPublicKeyForMint(mintPublicKey)
 
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey)
@@ -55,8 +55,8 @@ export async function createStakingPoolInstruction (
         poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
         poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
         rent: SYSVAR_RENT_PUBKEY,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
-        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/createVault.ts

@@ -1,66 +1,137 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+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 createVault (
   program: Program,
   provider: Provider,
   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 usdhMintPublickey = await getUsdhMintPublicKey()
+
+  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)
+  await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
 
-  const newVault = Keypair.generate()
-  const history = Keypair.generate()
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const transaction = new Transaction().add(
+  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()
+
+  const transaction = new Transaction()
+  const signers = [payer, history]
+
+  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,
+        lamports: depositAmount + 2.04e6,
+        newAccountPubkey: wrappedSolAccount.publicKey,
+        programId: TOKEN_PROGRAM_ID,
+        space: 165
+      }),
+      TokenInstructions.initializeAccount({
+        account: wrappedSolAccount.publicKey,
+        mint: TokenInstructions.WRAPPED_SOL_MINT,
+        owner: payer.publicKey
+      })
+    )
+    signers.push(wrappedSolAccount)
+  }
+  transaction.add(
     await createVaultInstruction(
       program,
+      salt,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      newVault.publicKey,
+      isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
+      newVaultPublicKey,
+      vaultAssociatedTokenAccount,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAccountInfo.collateralMint,
       history.publicKey,
+      usdhMintPublickey,
       depositAmount,
-      collateralRatio
+      overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, newVault, history], provider?.opts)
-  return newVault.publicKey
+  if (isWrappedSol) {
+    transaction.add(
+      TokenInstructions.closeAccount({
+        source: wrappedSolAccount.publicKey,
+        destination: payer.publicKey,
+        owner: payer.publicKey
+      })
+    )
+  }
+
+  await sendAndConfirmTransaction(provider.connection, transaction, signers, provider?.opts).catch(parseAnchorErrors)
+  return newVaultPublicKey
 }
 
 export async function createVaultInstruction (
   program: Program,
+  salt: string,
   vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
+  payerTokenAccountPublicKey: PublicKey,
   vaultPublicKey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
+  feePool: PublicKey,
+  feePoolAssociatedUsdhTokenAccount: PublicKey,
+  vaultTypeAccount: PublicKey,
+  collateralMint: PublicKey,
   historyPublicKey: PublicKey,
+  usdhMintPublickey: PublicKey,
   depositAmount: number,
-  collateralRatio: number
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   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: vaultAssociatedTokenAccount,
+        feePool: feePool,
+        feePoolAssociatedUsdhTokenAccount: feePoolAssociatedUsdhTokenAccount,
         history: historyPublicKey,
         payer: payerPublicKey,
-        systemProgram: SystemProgram.programId
+        payerTokenAccount: payerTokenAccountPublicKey,
+        collateralMint: collateralMint,
+        usdhMint: usdhMintPublickey,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        rent: SYSVAR_RENT_PUBKEY
       },
       signers: []
     })

package/src/instructions/depositLiquidationPool.ts

@@ -0,0 +1,67 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+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, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function depositLiquidationPool (
+  program: Program,
+  provider: Provider,
+  payer: Signer,
+  depositAmount: number,
+  overrideStartTime?: number
+): Promise<PublicKey> {
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const payerUsdhAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
+
+  const poolPosition = Keypair.generate()
+  const transaction = new Transaction().add(
+    await depositLiquidationPoolInstruction(
+      program,
+      payer.publicKey,
+      payerUsdhAccount.address,
+      poolPosition.publicKey,
+      depositAmount,
+      overrideStartTime
+    )
+  )
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors)
+  return poolPosition.publicKey
+}
+
+export async function depositLiquidationPoolInstruction (
+  program: Program,
+  payerPublicKey: PublicKey,
+  payerUsdhAccount: PublicKey,
+  poolPositionPublicKey: PublicKey,
+  depositAmount: number,
+  overrideStartTime?: number
+): Promise<TransactionInstruction> {
+  const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey()
+  const liquidationPoolState = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
+
+  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,
+        poolUsdhAccount: poolUSDHAccount,
+        usdhMint: usdhMint,
+        payer: payerPublicKey,
+        ownerUsdhAccount: payerUsdhAccount,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_PUBKEY
+      },
+      signers: []
+    })
+}

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,14 +46,15 @@ export async function depositStakingPoolInstruction (
     {
       accounts: {
         payer: payerPublicKey,
+        vaultSystemState: vaultSystemState,
         pool: poolPublickey,
         poolPosition: poolPositionPublicKey,
         stakedTokenMintInfo: stakedTokenMintPublicKey,
         poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
         payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
         rent: SYSVAR_RENT_PUBKEY,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
-        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/depositVault.ts

@@ -1,62 +1,130 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { TokenInstructions } from '@project-serum/serum'
+import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { getSolCollateralStateAccountPublicKey, 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,
-  depositAmount: number
+  depositAmount: 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
-  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  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 payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
+  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(vaultPublicKey, vaultTypeAccountInfo.collateralMint)
 
   const history = Keypair.generate()
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const transaction = new Transaction().add(
+  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]
+
+  if (vaultAccount.collateralType === 'SOL') {
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: payer.publicKey,
+        lamports: depositAmount + 2.04e6,
+        newAccountPubkey: wrappedSolAccount.publicKey,
+        programId: TOKEN_PROGRAM_ID,
+        space: 165
+      }),
+      TokenInstructions.initializeAccount({
+        account: wrappedSolAccount.publicKey,
+        mint: TokenInstructions.WRAPPED_SOL_MINT,
+        owner: payer.publicKey
+      })
+    )
+    signers.push(wrappedSolAccount)
+  }
+  transaction.add(
     await depositVaultInstruction(
       program,
       vaultSystemStatePublicKey,
       payer.publicKey,
+      vaultAccount.collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
       vaultPublicKey,
+      vaultAssociatedCollateralAccountPublicKey,
       history.publicKey,
-      depositAmount
+      vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount.address,
+      hedgeStakingPoolPublicKey,
+      hedgeStakingPoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountInfo.collateralMint,
+      usdhMintPublickey,
+      depositAmount,
+      overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  if (vaultAccount.collateralType === 'SOL') {
+    transaction.add(
+      TokenInstructions.closeAccount({
+        source: wrappedSolAccount.publicKey,
+        destination: payer.publicKey,
+        owner: payer.publicKey
+      })
+    )
+  }
+
+  await sendAndConfirmTransaction(provider.connection, transaction, signers, provider.opts)
   return vaultPublicKey
 }
 
-export async function depositVaultInstruction (
+export async function depositVaultInstruction(
   program: Program,
   vaultSystemStatePublicKey: PublicKey,
-  payerPublicKey: PublicKey,
+  vaultOwner: PublicKey,
+  vaultOwnerTokenAccount: PublicKey,
   vaultPublicKey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  depositAmount: number
+  vaultTypeAccountPublicKey: PublicKey,
+  vaultTypeAssociatedTokenAccount: PublicKey,
+  hedgeStakingPoolPublicKey: PublicKey,
+  hedgeStakingPoolAssociatedUsdhTokenAccount: PublicKey,
+  collateralMint: PublicKey,
+  usdhMintPublickey: PublicKey,
+  depositAmount: number,
+  overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   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: collateralStateAccount,
-        vaultAccount: vaultPublicKey,
+        vaultTypeAccount: vaultTypeAccountPublicKey,
+        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+        collateralTokenMint: collateralMint,
+        vault: vaultPublicKey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         history: historyPublicKey,
-        vaultOwner: payerPublicKey,
-        systemProgram: SystemProgram.programId
+        vaultOwner: vaultOwner,
+        vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+        usdhMint: usdhMintPublickey,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID
       },
       signers: []
     })