@jup-ag/lend 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/shared/lend.CS-bkwRq.mjs

@@ -0,0 +1,867 @@
+import { SYSVAR_RENT_PUBKEY, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SystemProgram } from '@solana/web3.js';
+import BN from 'bn.js';
+import { Program } from '@coral-xyz/anchor';
+import { g as getVaultsProgram, k as getAccountOwner, u as getTickIndices, p as getLiquidityProgramId, c as MIN_I128, m as getCurrentPositionState, n as getFinalPosition, z as readOraclePrice, t as getTickAtRatio, w as loadRelevantBranchesForLiquidate, y as loadRelevantTicksHasDebtArraysLiquidate, D as oracle, v as loadRelevantBranches, x as loadRelevantTicksHasDebtArrays, d as MIN_TICK, j as findNextTickWithDebt, I as INIT_TICK } from './lend.CVtn-ehf.mjs';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, NATIVE_MINT } from '@solana/spl-token';
+import { c as getOrCreateATAInstruction } from './lend.B80NmXTG.mjs';
+import { a as getPositionMetadata, c as getPositionTokenAccount, d as getPositionMint, e as getPosition, f as getVaultState, g as getVaultAdmin, h as getVaultConfig, i as getVaultMetadata, j as getLiquidity, k as getClaimAccount, l as getRateModel, m as getUserBorrowPosition, n as getUserSupplyPosition, o as getLiquidityReserve, p as getTickHasDebt, q as getTick, r as getBranch, s as getTickIdLiquidation } from './lend.a53XYkl5.mjs';
+
+const MPL_TOKEN_METADATA_PROGRAM_ID = new PublicKey(
+  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+);
+async function getOtherInstructionsOperate(vaultId, vaultState, currentPosition, finalPosition, currentTick, currentTickId, program, signer, market) {
+  const otherIxs = [];
+  const tickToRead = [currentTick];
+  let finalTickData;
+  tickToRead.push(currentPosition.tick);
+  tickToRead.push(finalPosition.tick);
+  if (tickToRead.length > 0) {
+    const tickData = await program.account.tick.fetchMultiple(
+      tickToRead.map((tick) => getTick(vaultId, tick, market))
+    );
+    tickData[0];
+    finalTickData = tickData[2];
+    for (const [i, tickDatum] of tickData.entries()) {
+      if (!tickDatum) {
+        const ix = await program.methods.initTick(vaultId, tickToRead[i]).accounts(getInitTickContext(vaultId, tickToRead[i], signer, market)).instruction();
+        otherIxs.push(ix);
+      }
+    }
+  }
+  let newBranchId;
+  if (vaultState.branchLiquidated) {
+    newBranchId = vaultState.totalBranchId + 1;
+    let newBranchData = null;
+    try {
+      newBranchData = await program.account.branch.fetch(
+        getBranch(vaultId, newBranchId, market)
+      );
+    } catch {
+    }
+    if (!newBranchData) {
+      const ix = await program.methods.initBranch(vaultId, newBranchId).accounts(getInitBranchContext(vaultId, newBranchId, signer, market)).instruction();
+      otherIxs.push(ix);
+    }
+  } else {
+    newBranchId = vaultState.currentBranchId;
+  }
+  const newBranchPda = getBranch(vaultId, newBranchId, market);
+  const currentTickIdDataPda = getTickIdLiquidation(
+    vaultId,
+    currentTick,
+    // Position tick
+    currentTickId,
+    // Position tick ID
+    market
+  );
+  const tickIdsToRead = [
+    {
+      tick: currentTick,
+      totalIds: currentTickId
+    }
+  ];
+  const finalTickIdDataPda = getTickIdLiquidation(
+    vaultId,
+    finalPosition.tick,
+    finalTickData ? finalTickData.totalIds : 0,
+    market
+  );
+  if (finalPosition.tick !== currentTick)
+    if (finalTickData) {
+      tickIdsToRead.push({
+        tick: finalPosition.tick,
+        totalIds: finalTickData.totalIds
+      });
+    } else {
+      const context = await getInitTickIdLiquidationContext(
+        vaultId,
+        finalPosition.tick,
+        signer,
+        program,
+        market
+      );
+      const ix = await program.methods.initTickIdLiquidation(vaultId, finalPosition.tick, 0).accounts(context).instruction();
+      otherIxs.push(ix);
+    }
+  const tickIdData = await program.account.tickIdLiquidation.fetchMultiple(
+    tickIdsToRead.map(
+      ({ tick, totalIds }) => getTickIdLiquidation(vaultId, tick, totalIds, market)
+    )
+  );
+  if (tickIdData.length > 0) {
+    for (const [i, tickIdDatum] of tickIdData.entries()) {
+      if (!tickIdDatum) {
+        const ix = await program.methods.initTickIdLiquidation(
+          vaultId,
+          tickIdsToRead[i].tick,
+          tickIdsToRead[i].totalIds
+        ).accounts(
+          await getInitTickIdLiquidationContext(
+            vaultId,
+            tickIdsToRead[i].tick,
+            signer,
+            program,
+            market
+          )
+        ).instruction();
+        otherIxs.push(ix);
+      }
+    }
+  }
+  return {
+    otherIxs,
+    newBranchPda,
+    currentTickIdDataPda,
+    finalTickIdDataPda
+  };
+}
+const tickHelper = (tickValue) => {
+  return tickValue === 0 ? INIT_TICK : tickValue;
+};
+async function getRemainingAccountsOperate(vaultId, vaultState, vaultConfig, finalPositionTick, existingPositionTick, liquidationStatus, postLiquidationBranchId, program, market) {
+  const remainingAccounts = [];
+  const oracleProgram = new Program(oracle, program.provider);
+  const [oracleData, branches, tickHasDebt] = await Promise.all([
+    oracleProgram.account.oracle.fetch(new PublicKey(vaultConfig.oracle)),
+    // Add branch accounts (next 10 remaining accounts)
+    loadRelevantBranches(
+      vaultId,
+      vaultState,
+      liquidationStatus,
+      postLiquidationBranchId,
+      program,
+      market
+    ),
+    loadRelevantTicksHasDebtArrays(
+      vaultId,
+      tickHelper(vaultState.topmostTick),
+      existingPositionTick,
+      finalPositionTick,
+      program,
+      market
+    )
+  ]);
+  const sourceLength = oracleData.sources.length;
+  for (const source of oracleData.sources)
+    remainingAccounts.push({
+      pubkey: new PublicKey(source.source),
+      isWritable: false,
+      isSigner: false
+    });
+  const branchLength = branches.length;
+  for (const branch of branches) {
+    remainingAccounts.push({
+      pubkey: getBranch(vaultId, branch, market),
+      isWritable: true,
+      isSigner: false
+    });
+  }
+  const tickHasDebtLength = tickHasDebt.length;
+  for (const tickHasDebtArray of tickHasDebt)
+    remainingAccounts.push({
+      pubkey: tickHasDebtArray,
+      isWritable: true,
+      isSigner: false
+    });
+  const remainingAccountsIndices = [
+    sourceLength,
+    branchLength,
+    tickHasDebtLength
+  ];
+  return {
+    remainingAccounts,
+    remainingAccountsIndices
+  };
+}
+async function getOperateContext({
+  vaultId,
+  positionId,
+  program,
+  connection,
+  signer,
+  positionOwner = signer,
+  colAmount: newCol,
+  debtAmount: newDebt,
+  recipient,
+  market
+}) {
+  program = program ?? getVaultsProgram({ connection, signer, market });
+  const [vaultState, vaultConfig, vaultMetadata] = await Promise.all([
+    program.account.vaultState.fetch(getVaultState(vaultId, market)),
+    program.account.vaultConfig.fetch(
+      getVaultConfig(vaultId, market)
+    ),
+    program.account.vaultMetadata.fetch(
+      getVaultMetadata(vaultId, market)
+    )
+  ]);
+  const [supplyTokenProgram, borrowTokenProgram] = await Promise.all([
+    getAccountOwner(vaultConfig.supplyToken, connection),
+    getAccountOwner(vaultConfig.borrowToken, connection)
+  ]);
+  const vaultSupplyDecimals = vaultMetadata.supplyMintDecimals;
+  const vaultBorrowDecimals = vaultMetadata.borrowMintDecimals;
+  if (newCol.gt(MIN_I128)) {
+    const decimalsDelta = vaultSupplyDecimals < 9 ? 9 - vaultSupplyDecimals : 0;
+    newCol = newCol.mul(new BN(10).pow(new BN(decimalsDelta)));
+  }
+  if (newDebt.gt(MIN_I128)) {
+    const decimalsDelta = vaultBorrowDecimals < 9 ? 9 - vaultBorrowDecimals : 0;
+    newDebt = newDebt.mul(new BN(10).pow(new BN(decimalsDelta)));
+  }
+  const positionData = positionId === 0 ? {
+    nftId: vaultState.nextPositionId,
+    positionMint: new PublicKey(0),
+    isSupplyOnlyPosition: 1,
+    tick: -2147483648,
+    tickId: 0,
+    lastUpdateTimestamp: new BN(0),
+    supplyAmount: new BN(0),
+    dustDebtAmount: new BN(0)} : await program.account.position.fetch(
+    getPosition(vaultId, positionId, market)
+  );
+  let existingPositionTick = positionData.tick;
+  let existingPositionTickId = positionData.tickId;
+  const currentPosition = await getCurrentPositionState({
+    vaultId,
+    position: positionData,
+    program,
+    market,
+    borrowMintDecimals: vaultBorrowDecimals
+  });
+  if (existingPositionTick === -2147483648) {
+    existingPositionTick = currentPosition.tick;
+    existingPositionTickId = 0;
+  }
+  const currentPositionTickPda = getTick(
+    vaultId,
+    existingPositionTick,
+    market
+  );
+  const finalPosition = await getFinalPosition({
+    vaultId,
+    currentPosition,
+    newColAmount: newCol,
+    newDebtAmount: newDebt,
+    program,
+    connection,
+    signer,
+    market
+  });
+  const { otherIxs, newBranchPda, currentTickIdDataPda, finalTickIdDataPda } = await getOtherInstructionsOperate(
+    vaultId,
+    vaultState,
+    currentPosition,
+    finalPosition,
+    existingPositionTick,
+    existingPositionTickId,
+    program,
+    signer,
+    market
+  );
+  const { remainingAccounts, remainingAccountsIndices } = await getRemainingAccountsOperate(
+    vaultId,
+    vaultState,
+    vaultConfig,
+    finalPosition.tick,
+    existingPositionTick,
+    currentPosition.userLiquidationStatus,
+    currentPosition.postLiquidationBranchId,
+    program,
+    market
+  );
+  const accounts = {
+    signer,
+    signerSupplyTokenAccount: getAssociatedTokenAddressSync(
+      vaultConfig.supplyToken,
+      signer,
+      true,
+      supplyTokenProgram
+    ),
+    signerBorrowTokenAccount: getAssociatedTokenAddressSync(
+      vaultConfig.borrowToken,
+      signer,
+      true,
+      borrowTokenProgram
+    ),
+    recipient: recipient ?? null,
+    recipientSupplyTokenAccount: recipient ? getAssociatedTokenAddressSync(
+      vaultConfig.supplyToken,
+      recipient,
+      true,
+      supplyTokenProgram
+    ) : null,
+    recipientBorrowTokenAccount: recipient ? getAssociatedTokenAddressSync(
+      vaultConfig.borrowToken,
+      recipient,
+      true,
+      borrowTokenProgram
+    ) : null,
+    vaultConfig: getVaultConfig(vaultId, market),
+    vaultState: getVaultState(vaultId, market),
+    supplyToken: vaultConfig.supplyToken,
+    borrowToken: vaultConfig.borrowToken,
+    oracle: new PublicKey(vaultConfig.oracle),
+    position: getPosition(vaultId, positionData.nftId, market),
+    positionTokenAccount: getPositionTokenAccount(
+      vaultId,
+      positionData.nftId,
+      positionOwner,
+      market
+    ),
+    currentPositionTick: currentPositionTickPda,
+    finalPositionTick: getTick(vaultId, finalPosition.tick, market),
+    currentPositionTickId: currentTickIdDataPda,
+    finalPositionTickId: finalTickIdDataPda,
+    newBranch: newBranchPda,
+    supplyTokenReservesLiquidity: getLiquidityReserve(
+      vaultConfig.supplyToken,
+      market
+    ),
+    borrowTokenReservesLiquidity: getLiquidityReserve(
+      vaultConfig.borrowToken,
+      market
+    ),
+    vaultSupplyPositionOnLiquidity: getUserSupplyPosition(
+      vaultConfig.supplyToken,
+      getVaultConfig(vaultId, market),
+      market
+    ),
+    vaultBorrowPositionOnLiquidity: getUserBorrowPosition(
+      vaultConfig.borrowToken,
+      getVaultConfig(vaultId, market),
+      market
+    ),
+    supplyRateModel: getRateModel(vaultConfig.supplyToken, market),
+    borrowRateModel: getRateModel(vaultConfig.borrowToken, market),
+    supplyTokenClaimAccount: null,
+    borrowTokenClaimAccount: null,
+    liquidity: getLiquidity(market),
+    liquidityProgram: getLiquidityProgramId(market),
+    vaultSupplyTokenAccount: getAssociatedTokenAddressSync(
+      vaultConfig.supplyToken,
+      getLiquidity(market),
+      true,
+      supplyTokenProgram
+    ),
+    vaultBorrowTokenAccount: getAssociatedTokenAddressSync(
+      vaultConfig.borrowToken,
+      getLiquidity(market),
+      true,
+      borrowTokenProgram
+    ),
+    oracleProgram: new PublicKey(vaultConfig.oracleProgram),
+    supplyTokenProgram,
+    borrowTokenProgram,
+    systemProgram: SystemProgram.programId
+  };
+  return {
+    nftId: positionData.nftId,
+    accounts,
+    remainingAccounts,
+    initPositionIx: positionId === 0 ? await program.methods.initPosition(vaultId, positionData.nftId).accounts(
+      getInitPositionContext(
+        vaultId,
+        positionData.nftId,
+        signer,
+        market
+      )
+    ).instruction() : null,
+    otherIxs,
+    remainingAccountsIndices,
+    lookupTable: vaultMetadata.lookupTable
+  };
+}
+async function getInitPositionIx({
+  vaultId,
+  connection,
+  signer,
+  market = "main"
+}) {
+  const program = getVaultsProgram({ connection, signer, market });
+  const vaultState = await program.account.vaultState.fetch(
+    getVaultState(vaultId, market)
+  );
+  return {
+    ix: await program.methods.initPosition(vaultId, vaultState.nextPositionId).accounts(
+      getInitPositionContext(
+        vaultId,
+        vaultState.nextPositionId,
+        signer,
+        market
+      )
+    ).instruction(),
+    nftId: vaultState.nextPositionId
+  };
+}
+function getInitPositionContext(vaultId, positionId, signer, market) {
+  return {
+    signer,
+    vaultAdmin: getVaultAdmin(market),
+    vaultState: getVaultState(vaultId, market),
+    position: getPosition(vaultId, positionId, market),
+    positionMint: getPositionMint(vaultId, positionId, market),
+    positionTokenAccount: getPositionTokenAccount(
+      vaultId,
+      positionId,
+      signer,
+      market
+    ),
+    tokenProgram: TOKEN_PROGRAM_ID,
+    metadataAccount: getPositionMetadata(vaultId, positionId, market),
+    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    sysvarInstruction: SYSVAR_INSTRUCTIONS_PUBKEY,
+    metadataProgram: MPL_TOKEN_METADATA_PROGRAM_ID,
+    rent: SYSVAR_RENT_PUBKEY
+  };
+}
+const getOperateIx = async ({
+  vaultId,
+  positionId,
+  colAmount,
+  debtAmount,
+  connection,
+  signer,
+  recipient,
+  positionOwner,
+  market = "main",
+  includeATASetup = false
+}) => {
+  const program = getVaultsProgram({ connection, signer, market });
+  const {
+    accounts,
+    remainingAccounts,
+    remainingAccountsIndices,
+    initPositionIx,
+    otherIxs,
+    lookupTable,
+    nftId
+  } = await getOperateContext({
+    vaultId,
+    positionId,
+    colAmount,
+    debtAmount,
+    signer,
+    positionOwner,
+    connection,
+    recipient,
+    program,
+    market
+  });
+  if (accounts.borrowToken.toString() !== NATIVE_MINT.toString() && debtAmount.lt(new BN(0))) {
+    try {
+      const userDebtTokenBalance = await connection.getTokenAccountBalance(
+        accounts.signerBorrowTokenAccount
+      );
+      if (userDebtTokenBalance.value.amount === debtAmount.abs().toString()) {
+        debtAmount = debtAmount.add(new BN(1));
+      }
+    } catch {
+    }
+  }
+  const [operateIx, addressLookupTable] = await Promise.all([
+    program.methods.operate(
+      colAmount,
+      debtAmount,
+      { direct: {} },
+      Buffer.from(remainingAccountsIndices)
+    ).accounts(accounts).remainingAccounts(remainingAccounts).instruction(),
+    connection.getAddressLookupTable(lookupTable)
+  ]);
+  let preIxs = [];
+  if (includeATASetup) {
+    const owners = !recipient || recipient.equals(signer) ? [signer] : [signer, recipient];
+    const mints = [accounts.supplyToken, accounts.borrowToken];
+    preIxs = await Promise.all(
+      owners.flatMap(
+        (owner) => mints.map((mint) => getOrCreateATAInstruction(owner, mint, connection))
+      )
+    ).then((ixs) => ixs.flat());
+  }
+  return {
+    nftId,
+    accounts,
+    remainingAccounts,
+    remainingAccountsIndices,
+    addressLookupTableAddresses: lookupTable ? [lookupTable] : [],
+    addressLookupTableAccounts: addressLookupTable.value ? [addressLookupTable.value] : [],
+    ixs: initPositionIx ? [initPositionIx, ...preIxs, ...otherIxs, operateIx] : [...preIxs, ...otherIxs, operateIx]
+  };
+};
+function getInitBranchContext(vaultId, branchId, signer, market) {
+  return {
+    signer,
+    vaultConfig: getVaultConfig(vaultId, market),
+    branch: getBranch(vaultId, branchId, market),
+    systemProgram: SystemProgram.programId
+  };
+}
+function getInitTickContext(vaultId, tick, signer, market) {
+  return {
+    signer,
+    vaultConfig: getVaultConfig(vaultId, market),
+    tickData: getTick(vaultId, tick, market),
+    systemProgram: SystemProgram.programId
+  };
+}
+async function getInitTickIdLiquidationContext(vaultId, tick, signer, program, market) {
+  const tickData = await program.account.tick.fetch(getTick(vaultId, tick, market)).catch(() => null);
+  if (!tickData) {
+    return {
+      signer,
+      vaultConfig: getVaultConfig(vaultId, market),
+      tickIdLiquidation: getTickIdLiquidation(
+        vaultId,
+        tick,
+        0,
+        market
+      ),
+      tickData: getTick(vaultId, tick, market),
+      systemProgram: SystemProgram.programId
+    };
+  }
+  return {
+    signer,
+    vaultConfig: getVaultConfig(vaultId, market),
+    tickIdLiquidation: getTickIdLiquidation(
+      vaultId,
+      tick,
+      tickData.totalIds,
+      market
+    ),
+    tickData: getTick(vaultId, tick, market),
+    systemProgram: SystemProgram.programId
+  };
+}
+async function getLiquidateContext({
+  vaultId,
+  to,
+  program,
+  connection,
+  signer,
+  market
+}) {
+  program = program ?? getVaultsProgram({ connection, signer, market });
+  const [vaultState, vaultConfig, vaultMetadata] = await Promise.all([
+    program.account.vaultState.fetch(getVaultState(vaultId, market)),
+    program.account.vaultConfig.fetch(
+      getVaultConfig(vaultId, market)
+    ),
+    program.account.vaultMetadata.fetch(
+      getVaultMetadata(vaultId, market)
+    )
+  ]);
+  const [supplyTokenProgram, borrowTokenProgram] = await Promise.all([
+    getAccountOwner(vaultConfig.supplyToken, connection),
+    getAccountOwner(vaultConfig.borrowToken, connection)
+  ]);
+  const { arrayIndex } = getTickIndices(vaultState.topmostTick);
+  let { otherIxs, newBranchPda } = await getOtherInstructionsLiquidate(
+    vaultId,
+    vaultState,
+    program,
+    signer,
+    market
+  );
+  const {
+    remainingAccounts,
+    remainingAccountsIndices,
+    otherIxs: finalOtherIxs
+  } = await getRemainingAccountsLiquidate(
+    vaultId,
+    vaultState,
+    vaultConfig,
+    otherIxs,
+    program,
+    connection,
+    signer,
+    market
+  );
+  return {
+    accounts: {
+      signer,
+      signerTokenAccount: getAssociatedTokenAddressSync(
+        vaultConfig.borrowToken,
+        signer,
+        false,
+        borrowTokenProgram
+      ),
+      to,
+      toTokenAccount: getAssociatedTokenAddressSync(
+        vaultConfig.supplyToken,
+        to,
+        false,
+        supplyTokenProgram
+      ),
+      vaultAdmin: getVaultAdmin(market),
+      vaultConfig: getVaultConfig(vaultId, market),
+      vaultState: getVaultState(vaultId, market),
+      supplyToken: vaultConfig.supplyToken,
+      borrowToken: vaultConfig.borrowToken,
+      oracle: new PublicKey(vaultConfig.oracle),
+      tickHasDebt: getTickHasDebt(vaultId, arrayIndex, market),
+      newBranch: newBranchPda,
+      supplyTokenReservesLiquidity: getLiquidityReserve(
+        vaultConfig.supplyToken,
+        market
+      ),
+      borrowTokenReservesLiquidity: getLiquidityReserve(
+        vaultConfig.borrowToken,
+        market
+      ),
+      vaultSupplyPositionOnLiquidity: getUserSupplyPosition(
+        vaultConfig.supplyToken,
+        getVaultConfig(vaultId, market),
+        market
+      ),
+      vaultBorrowPositionOnLiquidity: getUserBorrowPosition(
+        vaultConfig.borrowToken,
+        getVaultConfig(vaultId, market),
+        market
+      ),
+      supplyRateModel: getRateModel(vaultConfig.supplyToken, market),
+      borrowRateModel: getRateModel(vaultConfig.borrowToken, market),
+      supplyTokenClaimAccount: getClaimAccount(
+        vaultConfig.supplyToken,
+        getVaultConfig(vaultId, market),
+        market
+      ),
+      borrowTokenClaimAccount: getClaimAccount(
+        vaultConfig.borrowToken,
+        getVaultConfig(vaultId, market),
+        market
+      ),
+      liquidity: getLiquidity(market),
+      liquidityProgram: getLiquidityProgramId(market),
+      vaultSupplyTokenAccount: getAssociatedTokenAddressSync(
+        vaultConfig.supplyToken,
+        getLiquidity(market),
+        true,
+        supplyTokenProgram
+      ),
+      vaultBorrowTokenAccount: getAssociatedTokenAddressSync(
+        vaultConfig.borrowToken,
+        getLiquidity(market),
+        true,
+        borrowTokenProgram
+      ),
+      oracleProgram: new PublicKey(vaultConfig.oracleProgram),
+      supplyTokenProgram,
+      borrowTokenProgram,
+      systemProgram: SystemProgram.programId
+    },
+    remainingAccounts,
+    otherIxs: finalOtherIxs,
+    remainingAccountsIndices,
+    lookupTable: vaultMetadata.lookupTable
+  };
+}
+const getLiquidateIx = async ({
+  vaultId,
+  debtAmount,
+  colPerUnitDebt = new BN(0),
+  absorb = false,
+  signer,
+  to = signer,
+  connection,
+  market,
+  includeATASetup = false
+}) => {
+  const program = getVaultsProgram({ connection, signer, market });
+  const {
+    accounts,
+    remainingAccounts,
+    remainingAccountsIndices,
+    otherIxs,
+    lookupTable
+  } = await getLiquidateContext({
+    vaultId,
+    to,
+    program,
+    signer,
+    connection,
+    market
+  });
+  const ixs = [];
+  if (includeATASetup) {
+    const owners = !to || to.equals(signer) ? [signer] : [signer, to];
+    const mints = [accounts.supplyToken, accounts.borrowToken];
+    const preIxs = await Promise.all(
+      owners.flatMap(
+        (owner) => mints.map((mint) => getOrCreateATAInstruction(owner, mint, connection))
+      )
+    ).then((ixs2) => ixs2.flat());
+    ixs.push(...preIxs);
+  }
+  if (otherIxs.length > 0) {
+    ixs.push(...otherIxs);
+  }
+  const [ix, addressLookupTable] = await Promise.all([
+    program.methods.liquidate(
+      debtAmount,
+      colPerUnitDebt,
+      absorb,
+      { direct: {} },
+      Buffer.from(remainingAccountsIndices)
+    ).accounts(accounts).remainingAccounts(remainingAccounts).instruction(),
+    connection.getAddressLookupTable(lookupTable)
+  ]);
+  ixs.push(ix);
+  return {
+    accounts,
+    remainingAccounts,
+    remainingAccountsIndices,
+    ixs,
+    addressLookupTableAddresses: lookupTable ? [lookupTable] : [],
+    addressLookupTableAccounts: addressLookupTable.value ? [addressLookupTable.value] : []
+  };
+};
+async function getOtherInstructionsLiquidate(vaultId, vaultState, program, signer, market) {
+  const otherIxs = [];
+  let newBranchId = vaultState.branchLiquidated === 1 ? vaultState.totalBranchId + 1 : vaultState.currentBranchId;
+  let newBranchPda = getBranch(
+    vaultId,
+    newBranchId,
+    market
+  );
+  const [newBranchData, tickData] = await Promise.all([
+    program.account.branch.fetch(newBranchPda).catch(() => null),
+    // might be possible that liquidation ends on a tick that is not initialized
+    program.account.tick.fetch(getTick(vaultId, vaultState.topmostTick, market)).catch(() => null)
+  ]);
+  if (!newBranchData) {
+    const ix = await program.methods.initBranch(vaultId, newBranchId).accounts(getInitBranchContext(vaultId, newBranchId, signer, market)).instruction();
+    otherIxs.push(ix);
+  }
+  if (!tickData) {
+    const ix = await program.methods.initTick(vaultId, vaultState.topmostTick).accounts(
+      getInitTickContext(vaultId, vaultState.topmostTick, signer, market)
+    ).instruction();
+    otherIxs.push(ix);
+  }
+  return {
+    otherIxs,
+    newBranchPda
+  };
+}
+async function loadRelevantTicksForLiquidate(vaultId, vaultState, liquidationTick, program, market) {
+  const ticks = [];
+  let topTick = vaultState.topmostTick;
+  if (topTick > liquidationTick)
+    try {
+      const topTickData = await program.account.tick.fetch(
+        getTick(vaultId, topTick, market)
+      );
+      if (topTickData) ticks.push({ ...topTickData, tick: topTick });
+    } catch {
+    }
+  let nextTick = MIN_TICK;
+  try {
+    nextTick = await findNextTickWithDebt(vaultId, topTick, program, market);
+  } catch {
+  }
+  const doesTickExist = (tick) => ticks.some((t) => t.tick === tick);
+  while (nextTick > liquidationTick && !doesTickExist(nextTick)) {
+    try {
+      const nextTickData = await program.account.tick.fetch(
+        getTick(vaultId, nextTick, market)
+      );
+      if (nextTickData) ticks.push({ ...nextTickData, tick: nextTick });
+      else throw new Error("Tick not found to load");
+      nextTick = await findNextTickWithDebt(vaultId, nextTick, program, market);
+    } catch {
+    }
+  }
+  return { ticks, nextTick };
+}
+async function getRemainingAccountsLiquidate(vaultId, vaultState, vaultConfig, otherIxs, program, connection, signer, market) {
+  const remainingAccounts = [];
+  const { oraclePriceLiquidate, oracleSources } = await readOraclePrice({
+    oracle: vaultConfig.oracle,
+    connection
+    // signer,
+  });
+  const liquidationRatio = new BN(oraclePriceLiquidate).mul(new BN(281474976710656)).div(new BN(10).pow(new BN(15)));
+  const liquidationThresholdRatio = liquidationRatio.mul(new BN(vaultConfig.liquidationThreshold)).div(new BN(10).pow(new BN(3)));
+  const liquidationTick = getTickAtRatio(liquidationThresholdRatio);
+  for (const source of oracleSources) {
+    remainingAccounts.push({
+      pubkey: source.source,
+      isWritable: false,
+      isSigner: false
+    });
+  }
+  const [branches, { ticks: tickAccounts, nextTick }] = await Promise.all([
+    loadRelevantBranchesForLiquidate(vaultId, vaultState, program, market),
+    loadRelevantTicksForLiquidate(
+      vaultId,
+      vaultState,
+      liquidationTick,
+      program,
+      market
+    )
+  ]);
+  const tickHasDebt = await loadRelevantTicksHasDebtArraysLiquidate(
+    vaultId,
+    vaultState.topmostTick,
+    nextTick,
+    program,
+    market
+  );
+  for (const branch of branches) {
+    remainingAccounts.push({
+      pubkey: getBranch(vaultId, branch.branchId, market),
+      isWritable: true,
+      isSigner: false
+    });
+  }
+  const tickToInit = [];
+  const existingTicks = await Promise.all(
+    tickAccounts.map(
+      (tickData) => program.account.tick.fetch(getTick(vaultId, tickData.tick, market)).catch(() => null)
+    )
+  );
+  const initInstructions = await Promise.all(
+    tickAccounts.map(async (tickData, index) => {
+      const existingTick = existingTicks[index];
+      if (!existingTick && !tickToInit.includes(tickData.tick)) {
+        tickToInit.push(tickData.tick);
+        return program.methods.initTick(vaultId, tickData.tick).accounts(getInitTickContext(vaultId, tickData.tick, signer, market)).instruction();
+      }
+      return null;
+    })
+  );
+  for (const ix of initInstructions) {
+    if (ix) {
+      otherIxs.push(ix);
+    }
+  }
+  for (const tickData of tickAccounts) {
+    remainingAccounts.push({
+      pubkey: getTick(vaultId, tickData.tick, market),
+      isWritable: true,
+      isSigner: false
+    });
+  }
+  for (const tickHasDebtArray of tickHasDebt) {
+    remainingAccounts.push({
+      pubkey: getTickHasDebt(vaultId, tickHasDebtArray.index, market),
+      isWritable: true,
+      isSigner: false
+    });
+  }
+  const remainingAccountsIndices = [
+    oracleSources.length,
+    branches.length,
+    tickAccounts.length,
+    tickHasDebt.length
+  ];
+  return {
+    remainingAccounts,
+    otherIxs,
+    remainingAccountsIndices
+  };
+}
+
+export { getInitPositionContext as a, getInitPositionIx as b, getLiquidateContext as c, getOperateContext as d, getOperateIx as e, getLiquidateIx as g };