hedge-web3 0.1.13 → 0.1.14

package/src/instructions/createVault.ts

@@ -1,16 +1,21 @@
 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, TOKEN_PROGRAM_ID } 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 { 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
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -18,39 +23,89 @@ export async function createVault (
     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 newVault = Keypair.generate()
-  const history = Keypair.generate()
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const transaction = new Transaction().add(
+  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType)
+  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
+
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint)
+  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(newVaultPublicKey, collateralStateAccountInfo.collateralMint)
+
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+
+  const wrappedSolAccount = Keypair.generate()
+
+  const transaction = new Transaction()
+  const signers = [payer, history]
+
+  if (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 createVaultInstruction(
       program,
+      salt,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      newVault.publicKey,
+      collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
+      newVaultPublicKey,
+      vaultAssociatedCollateralAccountPublicKey,
+      collateralStateAccountPublicKey,
+      collateralStateAccountInfo.collateralMint,
       history.publicKey,
       depositAmount,
       collateralRatio
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, newVault, history], provider?.opts)
-  return newVault.publicKey
+  if (collateralType === 'SOL') {
+    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,
+  vaultAssociatedCollateralPublicKey: PublicKey,
+  collateralStateAccount: PublicKey,
+  collateralMint: PublicKey,
   historyPublicKey: PublicKey,
   depositAmount: number,
   collateralRatio: number
 ): Promise<TransactionInstruction> {
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   const ix = program.instruction.createVault(
+    salt,
     new BN(depositAmount),
     new BN(collateralRatio)
     , {
@@ -58,9 +113,15 @@ export async function createVaultInstruction (
         vaultSystemState: vaultSystemStatePublicKey,
         collateralStateAccount: collateralStateAccount,
         vault: vaultPublicKey,
+        vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
         history: historyPublicKey,
         payer: payerPublicKey,
-        systemProgram: SystemProgram.programId
+        payerTokenAccount: payerTokenAccountPublicKey,
+        collateralMint: collateralMint,
+        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,70 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { Token, 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'
+
+export async function depositLiquidationPool (
+  program: Program,
+  provider: Provider,
+  payer: Signer,
+  depositAmount: number,
+  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 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()
+
+  return program.instruction.depositLiquidationPool(
+    new BN(depositAmount),
+    new BN(overrideStartTime ?? Date.now() / 1000), // override current time
+    {
+      accounts: {
+        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

@@ -51,8 +51,8 @@ export async function depositStakingPoolInstruction (
         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,16 +1,18 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
+import { TokenInstructions } from '@project-serum/serum'
 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 { findAssociatedTokenAddress, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function depositVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
+  // collateralType: string,
   depositAmount: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -21,42 +23,96 @@ export async function depositVault (
   // Prep the user to get USDH back out at some point
   await USDH.getOrCreateAssociatedAccountInfo(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 payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint)
+  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint)
+
   const history = Keypair.generate()
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const transaction = new Transaction().add(
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+
+  const wrappedSolAccount = Keypair.generate()
+
+  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,
+      collateralStateAccountPublicKey,
+      collateralAssociatedTokenAccount,
+      collateralStateAccountInfo.collateralMint,
       depositAmount
     )
   )
-  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 (
   program: Program,
   vaultSystemStatePublicKey: PublicKey,
-  payerPublicKey: PublicKey,
+  vaultOwner: PublicKey,
+  vaultOwnerTokenAccount: PublicKey,
   vaultPublicKey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
+  collateralStateAccountPublicKey: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
+  collateralMint: PublicKey,
   depositAmount: number
 ): Promise<TransactionInstruction> {
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   return program.instruction.depositVault(
     new BN(depositAmount)
     , {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
-        collateralStateAccount: collateralStateAccount,
-        vaultAccount: vaultPublicKey,
+        collateralStateAccount: collateralStateAccountPublicKey,
+        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        collateralTokenMint: collateralMint,
+        vault: vaultPublicKey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
-        vaultOwner: payerPublicKey,
-        systemProgram: SystemProgram.programId
+        vaultOwner: vaultOwner,
+        vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID
       },
       signers: []
     })

package/src/instructions/liquidateVault.ts

@@ -1,23 +1,61 @@
 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 { ASSOCIATED_TOKEN_PROGRAM_ID, Token, TOKEN_PROGRAM_ID } 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'
 
 export async function liquidateVault (
   program: Program,
   provider: Provider,
   payer: Signer,
-  vaultPublicKey: PublicKey
+  vaultPublicKey: PublicKey,
+  preload: boolean
 ): 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 hedgeMintPublickey = await getHedgeMintPublicKey()
+  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 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,
+      liquidationPoolStatePublicKey,
+      poolStateInfo.currentEra,
+      poolAssociatedTokenAccount,
       history.publicKey,
-      newEra.publicKey
+      newEra.publicKey,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedTokenAccount,
+      collateralMint,
+      collateralAssociatedTokenAccount,
+      vaultAccount.collateralType,
+      preload
     )
   )
   await sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts)
@@ -27,37 +65,54 @@ 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,
+  collateralMint: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
+  collateralType: string,
+  preload: boolean
 ): 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 collateralStateAccount = await getCollateralStateAccountPublicKey(collateralType)
 
-  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: []
-    })
+  const payload = {
+    accounts: {
+      vaultSystemState: vaultSystemStatePublicKey,
+      collateralStateAccount: collateralStateAccount,
+      collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+      collateralMint: collateralMint,
+      poolEra: poolEra,
+      vaultAccount: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      poolState: poolState,
+      poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+      usdhMint: usdhMintPublickey,
+      history: historyPublicKey,
+      payer: payerPublicKey,
+      payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+      feePool: feePool,
+      feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
+      liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+      newEra: newEraPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY
+    },
+    signers: []
+  }
+  if (preload) {
+    return program.instruction.liquidateVaultPrepAccounts(payload)
+  }
+  return program.instruction.liquidateVault(payload)
 }

package/src/instructions/loanVault.ts

@@ -1,7 +1,7 @@
 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 { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function loanVault (
   program: Program,
@@ -10,7 +10,7 @@ export async function loanVault (
   vaultPublicKey: PublicKey,
   loanAmount: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -20,6 +20,11 @@ export async function loanVault (
 
   // 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 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 history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -28,7 +33,10 @@ export async function loanVault (
       payer.publicKey,
       payerUsdhAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount,
       history.publicKey,
+      collateralStateAccountPublicKey,
+      collateralAssociatedTokenAccount,
       loanAmount
     )
   )
@@ -41,18 +49,20 @@ export async function loanVaultInstruction (
   payerPublicKey: PublicKey,
   ownerUsdhAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
+  collateralStateAccount: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
   loanAmount: 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),
@@ -60,14 +70,16 @@ export async function loanVaultInstruction (
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
         collateralStateAccount: collateralStateAccount,
+        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
         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: []