@jup-ag/lend 0.1.10 → 0.2.0-beta.2

package/dist/shared/{lend.B03stRz0.mjs → lend.DcHJFKzT.mjs}

@@ -1,9 +1,8 @@
-import { PublicKey, Transaction, SYSVAR_RENT_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SystemProgram } from '@solana/web3.js';
-import BN from 'bn.js';
 import { Program, AnchorProvider } from '@coral-xyz/anchor';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, NATIVE_MINT } from '@solana/spl-token';
-import { a as getTickHasDebt, c as getPosition, d as getTick, e as getTickIdLiquidation, f as getVaultConfig, h as getBranch, i as getVaultState, j as getPositionMetadata, k as getPositionTokenAccount, l as getPositionMint, g as getVaultAdmin, m as getVaultMetadata, n as getLiquidity, o as getClaimAccount, p as getRateModel, q as getUserBorrowPosition, r as getUserSupplyPosition, s as getLiquidityReserve } from './lend.ByiEG4eI.mjs';
-import { e as getReserve } from './lend.BhQGaP3o.mjs';
+import BN from 'bn.js';
+import { p as getTickHasDebt, e as getPosition, q as getTick, s as getTickIdLiquidation, h as getVaultConfig, r as getBranch, f as getVaultState } from './lend.a53XYkl5.mjs';
+import { PublicKey, Transaction } from '@solana/web3.js';
+import { e as getReserve } from './lend.C3XdrR6R.mjs';
 
 const address$1 = "jupnw4B6Eqs7ft6rxpzYLJZYSnrpRgPcr589n5Kv4oc";
 const metadata$1 = {
@@ -7055,6 +7054,26 @@ async function loadRelevantBranchesForLiquidate(vaultId, vaultState, program, ma
   if (!doesBranchExist(0)) branches.push({ branchId: 0 });
   return branches;
 }
+async function getOracleSources({
+  connection,
+  signer,
+  oracle: oracle$1
+}) {
+  const program = new Program(
+    oracle,
+    new AnchorProvider(connection, {
+      signTransaction() {
+        throw new Error("Not implemented");
+      },
+      signAllTransactions() {
+        throw new Error("Not implemented");
+      },
+      publicKey: signer ?? new PublicKey("HEyJLdMfZhhQ7FHCtjD5DWDFNFQhaeAVAsHeWqoY6dSD")
+    })
+  );
+  const oracleData = await program.account.oracle.fetch(oracle$1);
+  return oracleData.sources;
+}
 async function readOraclePrice({
   connection,
   signer,
@@ -7095,841 +7114,4 @@ const getLiquidityProgramId = (market) => {
   return market === "ethena" ? new PublicKey("jup6QF1sNDGpkkcu6F4qaFHcRBmnSS1VgyB4uFbBvNS") : new PublicKey("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC");
 };
 
-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
-  });
-  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,
-    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-    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"
-}) => {
-  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)
-  ]);
-  return {
-    nftId,
-    accounts,
-    remainingAccounts,
-    remainingAccountsIndices,
-    addressLookupTableAddresses: lookupTable ? [lookupTable] : [],
-    addressLookupTableAccounts: addressLookupTable.value ? [addressLookupTable.value] : [],
-    ixs: initPositionIx ? [initPositionIx, ...otherIxs, operateIx] : [...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,
-      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID
-    },
-    remainingAccounts,
-    otherIxs: finalOtherIxs,
-    remainingAccountsIndices,
-    lookupTable: vaultMetadata.lookupTable
-  };
-}
-const getLiquidateIx = async ({
-  vaultId,
-  debtAmount,
-  colPerUnitDebt = new BN(0),
-  absorb = false,
-  signer,
-  to = signer,
-  connection,
-  market
-}) => {
-  const program = getVaultsProgram({ connection, signer, market });
-  const {
-    accounts,
-    remainingAccounts,
-    remainingAccountsIndices,
-    otherIxs,
-    lookupTable
-  } = await getLiquidateContext({
-    vaultId,
-    to,
-    program,
-    signer,
-    connection,
-    market
-  });
-  const ixs = [];
-  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$1;
-  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 { loadRelevantBranchesForLiquidate as A, loadRelevantTicksHasDebtArrays as B, loadRelevantTicksHasDebtArraysLiquidate as C, readOraclePrice as D, readTickHasDebtArray as E, vaultsIdl as F, INIT_TICK as I, MAX_REPAY_AMOUNT as M, TICKS_PER_TICK_HAS_DEBT as T, ZERO_TICK_SCALED_RATIO$1 as Z, getLiquidateIx as a, MAX_TICK$1 as b, MAX_WITHDRAW_AMOUNT as c, MIN_I128 as d, MIN_TICK$1 as e, TICK_HAS_DEBT_ARRAY_SIZE as f, getVaultsProgram as g, TICK_HAS_DEBT_CHILDREN_SIZE as h, TICK_HAS_DEBT_CHILDREN_SIZE_IN_BITS as i, TOTAL_INDICES_NEEDED as j, findNextTickWithDebt as k, getAccountOwner as l, getCurrentPosition as m, getCurrentPositionState as n, getFinalPosition as o, getFirstTickForIndex as p, getInitPositionContext as q, getInitPositionIx as r, getLiquidateContext as s, getLiquidityProgramId as t, getOperateContext as u, getOperateIx as v, getRatioAtTick as w, getTickAtRatio as x, getTickIndices as y, loadRelevantBranches as z };
+export { vaultsIdl as A, oracle as B, INIT_TICK as I, MAX_REPAY_AMOUNT as M, TICKS_PER_TICK_HAS_DEBT as T, ZERO_TICK_SCALED_RATIO$1 as Z, MAX_TICK$1 as a, MAX_WITHDRAW_AMOUNT as b, MIN_I128 as c, MIN_TICK$1 as d, TICK_HAS_DEBT_ARRAY_SIZE as e, TICK_HAS_DEBT_CHILDREN_SIZE as f, getVaultsProgram as g, TICK_HAS_DEBT_CHILDREN_SIZE_IN_BITS as h, TOTAL_INDICES_NEEDED as i, findNextTickWithDebt as j, getAccountOwner as k, getCurrentPosition as l, getCurrentPositionState as m, getFinalPosition as n, getFirstTickForIndex as o, getLiquidityProgramId as p, getOracleSources as q, getRatioAtTick as r, getTickAtRatio as s, getTickIndices as t, loadRelevantBranches as u, loadRelevantBranchesForLiquidate as v, loadRelevantTicksHasDebtArrays as w, loadRelevantTicksHasDebtArraysLiquidate as x, readOraclePrice as y, readTickHasDebtArray as z };