hedge-web3 0.1.27 → 0.1.28

package/lib/utils/getLinkedListAccounts.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkedListAccounts = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+const VaultAccount_1 = require("../state/VaultAccount");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, depositAmount, loanAmount, redeem, liquidate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        // Default for null is the vault itself, so set them all to this vault
+        let oldSmallerPublicKey = vaultPublicKey;
+        let newSmallerPublicKey = vaultPublicKey;
+        let newLargerPublicKey = vaultPublicKey;
+        const thisVaultData = yield program.account.vault.fetch(vaultPublicKey);
+        const thisVault = new VaultAccount_1.VaultAccount(thisVaultData, vaultPublicKey);
+        // Load all the vaults
+        let allVaults = (yield program.account.vault
+            .all([
+        // {
+        //   memcmp: { bytes: bs58.encode(inputCollateralType), offset: 8 + 32 + 8 },
+        // },
+        ])
+            .catch((error) => {
+            console.log('error', error);
+        })) || [];
+        // Load them into our account objects
+        let vaults = allVaults.map((vault) => {
+            return new VaultAccount_1.VaultAccount(vault.account, vault.publicKey);
+        });
+        // Filter out the account that are not the same vault type
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.collateralType === vaultTypeAccount.collateralType;
+        });
+        // Filter out the accounts that are not open
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.vaultStatus === 'open';
+        });
+        // Sort them
+        vaults.sort(sortVaults);
+        // Find the location of the vault before the operation
+        let indexBefore = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexBefore = index;
+            }
+        });
+        // If we found it before, set the old smaller vault the one to the left
+        if (indexBefore > 0) {
+            oldSmallerPublicKey = vaults[indexBefore - 1].publicKey;
+        }
+        // Pretty print all the vaults before the operation
+        // console.log('Sorted open vaults before')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // If it wasn't in the list, add it now
+        if (indexBefore < 0) {
+            vaults.push(thisVault);
+            indexBefore = vaults.length - 1;
+        }
+        // Now that we know it's def in the list, iterate the list and update
+        // this vault with the opeation we're going to apply
+        const newNormalizedDebt = new decimal_js_1.default(loanAmount);
+        const vaultTypeCompoundedInterest = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccount.cumulativeRate.toString());
+        vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest);
+        vaults[indexBefore].addDeposit(depositAmount);
+        if (liquidate) {
+            vaults[indexBefore].liquidate();
+        }
+        if (redeem) {
+            vaults[indexBefore].redeem();
+        }
+        vaults[indexBefore].redistribution(vaultTypeAccount);
+        if (vaults[indexBefore].denormalizedDebt === 0) {
+            vaults.splice(indexBefore, 1);
+        }
+        // Sort it again since we've changed one vault
+        vaults = vaults.sort(sortVaults);
+        // Pretty print the list again
+        // console.log('Sorted open vaults with new debt added')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // Search for the vaults new position
+        let indexAfter = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexAfter = index;
+            }
+        });
+        // Print where it moved from / to
+        // console.log('Index Before', indexBefore)
+        // console.log('Index After', indexAfter)
+        // Save references to the new left and right
+        if (indexAfter > 0) {
+            newSmallerPublicKey = vaults[indexAfter - 1].publicKey;
+        }
+        if (indexAfter < vaults.length - 1 && indexAfter >= 0) {
+            newLargerPublicKey = vaults[indexAfter + 1].publicKey;
+        }
+        // Print out the new left/right
+        // console.log('oldSmallerPublicKey', oldSmallerPublicKey.toString())
+        // console.log('newSmallerPublicKey', newSmallerPublicKey.toString())
+        // console.log('newLargerPublicKey', newLargerPublicKey.toString())
+        return [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey];
+    });
+}
+exports.getLinkedListAccounts = getLinkedListAccounts;
+// Sort function we can use to sort the vaults
+// Sorted by collateral ratio. If two are the same, newer vault first
+function sortVaults(a, b) {
+    const aRatio = a.deposited / a.denormalizedDebt;
+    const bRatio = b.deposited / b.denormalizedDebt;
+    if (aRatio === bRatio) {
+        return b.vaultNumber - a.vaultNumber;
+    }
+    return aRatio - bRatio;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedge-web3",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Hedge Javascript Web3 API",
   "main": "lib/index.js",
   "types": "declarations/index.d.ts",
@@ -21,6 +21,7 @@
     "@solana/spl-token": "^0.2.0",
     "@solana/web3.js": "^1.37.0",
     "@types/bn.js": "^5.1.0",
+    "@types/underscore": "^1.11.4",
     "@types/uuid": "^8.3.4",
     "bn.js": "^5.2.0",
     "decimal.js": "^10.3.1",
@@ -28,6 +29,7 @@
     "ts-standard": "^11.0.0",
     "typedoc": "^0.22.10",
     "typescript": "^4.5.5",
+    "underscore": "^1.13.2",
     "uuid": "^8.3.2"
   }
 }

package/src/Constants.ts

@@ -4,7 +4,7 @@ import {
 } from '@solana/spl-token'
 import { PublicKey } from '@solana/web3.js'
 
-export const HEDGE_PROGRAM_ID = 'HDG2DRczYGkTuYTwTYy1UUhXXucT2Ujede2j4bWEoE6p'
+export const HEDGE_PROGRAM_ID = 'HDG3uyafYaKxSYRW37ZBTdxaUCoyzaqbuirYucAeaPFY'
 export const HEDGE_PROGRAM_PUBLICKEY = new PublicKey(HEDGE_PROGRAM_ID)
 
 export const CHAINLINK_SOL_USD_ID =

package/src/index.ts

@@ -17,6 +17,7 @@ export * from './instructions/refreshOraclePrice'
 export * from './instructions/initHedgeFoundation'
 export * from './instructions/initHedgeFoundationTokens'
 export * from './instructions/setHalted'
+export * from './instructions/setVaultTypeStatus'
 
 export * from './HedgeDecimal'
 export * from './Constants'
@@ -28,3 +29,5 @@ export * from './state/StakingPoolPosition'
 export * from './state/LiquidationPoolEra'
 export * from './state/LiquidationPoolState'
 export * from './state/LiquidationPosition'
+
+export * from './utils/getLinkedListAccounts'

package/src/instructions/createStakingPool.ts

@@ -36,14 +36,13 @@ export async function createStakingPoolInstruction (
   console.log("createStakingPoolInstruction program ID", program.programId.toString())
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
-  const [poolPublickey, poolBump, poolSeedPhrase] = await getPoolPublicKeyForMint(mintPublicKey)
+  const [poolPublickey, poolBump] = await getPoolPublicKeyForMint(mintPublicKey)
 
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey)
   const poolAssociatedUshTokenAccount = await findAssociatedTokenAddress(poolPublickey, ushMintPublickey)
 
   return program.instruction.createStakingPool(
     poolBump,
-    poolSeedPhrase,
     new BN(hedgeTokensToBeMinted),
     new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)),
     {

package/src/instructions/depositVault.ts

@@ -1,8 +1,27 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 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 { findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
+import {
+  getOrCreateAssociatedTokenAccount,
+  TOKEN_PROGRAM_ID,
+} from '@solana/spl-token'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  findAssociatedTokenAddress,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from '../Constants'
 
 export async function depositVault(
   program: Program,
@@ -15,30 +34,68 @@ export async function depositVault(
   const ushMintPublickey = await getUshMintPublicKey()
 
   // Prep the user to get USH back out at some point
-  await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    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 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 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 hedgeStakingPoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    await getHedgeMintPublicKey()
   )
+  const hedgeStakingPoolAssociatedUshTokenAccount =
+    await findAssociatedTokenAddress(
+      hedgeStakingPoolPublicKey,
+      ushMintPublickey
+    )
 
   const transaction = new Transaction()
   const signers = [payer, history]
 
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] =
+    await getLinkedListAccounts(
+      program,
+      provider,
+      vaultTypeAccountPublicKey,
+      vaultPublicKey,
+      depositAmount,
+      0,
+      false,
+      false
+    )
+
   if (vaultAccount.collateralType === 'SOL') {
     transaction.add(
       SystemProgram.createAccount({
@@ -46,12 +103,12 @@ export async function depositVault(
         lamports: depositAmount + 2.04e6,
         newAccountPubkey: wrappedSolAccount.publicKey,
         programId: TOKEN_PROGRAM_ID,
-        space: 165
+        space: 165,
       }),
       TokenInstructions.initializeAccount({
         account: wrappedSolAccount.publicKey,
         mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payer.publicKey
+        owner: payer.publicKey,
       })
     )
     signers.push(wrappedSolAccount)
@@ -61,7 +118,9 @@ export async function depositVault(
       program,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      vaultAccount.collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
+      vaultAccount.collateralType === 'SOL'
+        ? wrappedSolAccount.publicKey
+        : payerTokenAccount,
       vaultPublicKey,
       vaultAssociatedCollateralAccountPublicKey,
       history.publicKey,
@@ -71,6 +130,9 @@ export async function depositVault(
       hedgeStakingPoolAssociatedUshTokenAccount,
       vaultTypeAccountInfo.collateralMint,
       ushMintPublickey,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       depositAmount,
       overrideTime
     )
@@ -80,12 +142,17 @@ export async function depositVault(
       TokenInstructions.closeAccount({
         source: wrappedSolAccount.publicKey,
         destination: payer.publicKey,
-        owner: payer.publicKey
+        owner: payer.publicKey,
       })
     )
   }
 
-  await sendAndConfirmTransaction(provider.connection, transaction, signers, provider.opts)
+  await sendAndConfirmTransaction(
+    provider.connection,
+    transaction,
+    signers,
+    provider.opts
+  )
   return vaultPublicKey
 }
 
@@ -103,6 +170,9 @@ export async function depositVaultInstruction(
   hedgeStakingPoolAssociatedUshTokenAccount: PublicKey,
   collateralMint: PublicKey,
   ushMintPublickey: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   depositAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -118,14 +188,19 @@ export async function depositVaultInstruction(
         vault: vaultPublicKey,
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+        feePoolAssociatedUshTokenAccount:
+          hedgeStakingPoolAssociatedUshTokenAccount,
         history: historyPublicKey,
         vaultOwner: vaultOwner,
         vaultOwnerTokenAccount: vaultOwnerTokenAccount,
         ushMint: ushMintPublickey,
+        oldSmallerVaultInfo: oldSmallerPublicKey,
+        newSmallerVaultInfo: newSmallerPublicKey,
+        newLargerVaultInfo: newLargerPublicKey,
         systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID
+        tokenProgram: TOKEN_PROGRAM_ID,
       },
-      signers: []
-    })
+      signers: [],
+    }
+  )
 }

package/src/instructions/liquidateVault.ts

@@ -1,9 +1,31 @@
 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, getLiquidationPoolUshAccountPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+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 { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  getHedgeMintPublicKey,
+  getLiquidationPoolStatePublicKey,
+  getLiquidationPoolUshAccountPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
 
-export async function liquidateVault (
+export async function liquidateVault(
   program: Program,
   provider: Provider,
   payer: Signer,
@@ -12,22 +34,80 @@ export async function liquidateVault (
 ): Promise<PublicKey> {
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
 
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    vaultAccount.collateralType
+  )
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  )
   const collateralMint = vaultTypeAccountInfo.collateralMint
 
   const hedgeMintPublickey = await getHedgeMintPublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    hedgeMintPublickey
+  )
   const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey()
-  const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey)
+  const poolStateInfo = await program.account.liquidationPoolState.fetch(
+    liquidationPoolStatePublicKey
+  )
+
+  const payerAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    payer.publicKey,
+    true
+  )
+  const feePoolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    hedgeStakingPoolPublicKey,
+    true
+  )
+  const vaultAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    vaultPublicKey,
+    true
+  )
+  const poolAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    collateralMint,
+    liquidationPoolStatePublicKey,
+    true
+  )
+  const vaultTypeAssociatedTokenAccount =
+    await getOrCreateAssociatedTokenAccount(
+      provider.connection,
+      payer,
+      collateralMint,
+      vaultTypeAccountPublicKey,
+      true
+    )
+  const hedgeStakingPoolAssociatedUshTokenAccount =
+    await getOrCreateAssociatedTokenAccount(
+      provider.connection,
+      payer,
+      ushMintPublickey,
+      hedgeStakingPoolPublicKey,
+      true
+    )
 
-  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 hedgeStakingPoolAssociatedUshTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, hedgeStakingPoolPublicKey, true)
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] =
+    await getLinkedListAccounts(
+      program,
+      provider,
+      vaultTypeAccountPublicKey,
+      vaultPublicKey,
+      0,
+      0,
+      false,
+      true
+    )
 
   const history = Keypair.generate()
   const newEra = Keypair.generate()
@@ -50,15 +130,23 @@ export async function liquidateVault (
       hedgeStakingPoolAssociatedUshTokenAccount.address,
       collateralMint,
       vaultTypeAssociatedTokenAccount.address,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       vaultAccount.collateralType,
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts)
+  await sendAndConfirmTransaction(
+    provider.connection,
+    transaction,
+    [payer, history, newEra],
+    provider.opts
+  )
   return vaultPublicKey
 }
 
-export async function liquidateVaultInstruction (
+export async function liquidateVaultInstruction(
   program: Program,
   payerPublicKey: PublicKey,
   payerAssociatedTokenAccount: PublicKey,
@@ -74,12 +162,16 @@ export async function liquidateVaultInstruction (
   hedgeStakingPoolAssociatedUshTokenAccount: PublicKey,
   collateralMint: PublicKey,
   vaultTypeAssociatedTokenAccount: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   collateralType: string,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
-  const liquidationPoolUshAccountPublickey = await getLiquidationPoolUshAccountPublicKey()
+  const liquidationPoolUshAccountPublickey =
+    await getLiquidationPoolUshAccountPublicKey()
   const vaultTypeAccount = await getVaultTypeAccountPublicKey(collateralType)
 
   const payload = {
@@ -99,17 +191,22 @@ export async function liquidateVaultInstruction (
       payerAssociatedTokenAccount: payerAssociatedTokenAccount,
       feePool: feePool,
       feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
-      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      feePoolAssociatedUshTokenAccount:
+        hedgeStakingPoolAssociatedUshTokenAccount,
       liquidationPoolUshAccount: liquidationPoolUshAccountPublickey,
       newEra: newEraPublicKey,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
       tokenProgram: TOKEN_PROGRAM_ID,
       systemProgram: SystemProgram.programId,
       associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-      rent: SYSVAR_RENT_PUBKEY
+      rent: SYSVAR_RENT_PUBKEY,
     },
-    signers: []
+    signers: [],
   }
   return program.instruction.liquidateVault(
     new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    payload)
+    payload
+  )
 }