@0dotxyz/p0-ts-sdk 2.8.4 → 2.9.0-alpha.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, AddressLookupTableAccount, Transaction, TransactionInstruction, Keypair, StakeProgram, LAMPORTS_PER_SOL, StakeAuthorizationLayout, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1 } from '@solana/web3.js';
 import { object, string, enums, array, assert } from 'superstruct';
+import { sha256 } from '@noble/hashes/sha2';
 import BigNumber3, { BigNumber } from 'bignumber.js';
 import BN8, { BN } from 'bn.js';
 import Decimal3, { Decimal } from 'decimal.js';
@@ -258,6 +259,7 @@ var PDA_BANK_FEE_STATE_SEED = Buffer.from("feestate");
 var PDA_BANK_EMISSIONS_AUTH_SEED = Buffer.from("emissions_auth_seed");
 var PDA_BANK_EMISSIONS_VAULT_SEED = Buffer.from("emissions_vault");
 var PDA_MARGINFI_ACCOUNT_SEED = Buffer.from("marginfi_account");
+var PDA_ORDER_SEED = Buffer.from("order");
 function deriveBankLiquidityVaultAuthority(programId, bank) {
   return PublicKey.findProgramAddressSync(
     [PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, bank.toBuffer()],
@@ -322,6 +324,14 @@ function deriveMarginfiAccount(programId, group, authority, accountIndex, thirdP
     programId
   );
 }
+function deriveOrderPda(programId, marginfiAccount, bankKeys) {
+  const sortedBankKeys = bankKeys.map((key) => key.toBuffer()).sort(Buffer.compare);
+  const bankKeysHash = Buffer.from(sha256(Buffer.concat(sortedBankKeys)));
+  return PublicKey.findProgramAddressSync(
+    [PDA_ORDER_SEED, marginfiAccount.toBuffer(), bankKeysHash],
+    programId
+  );
+}
 var PYTH_PUSH_ORACLE_ID = new PublicKey("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
 var PYTH_SPONSORED_SHARD_ID = 0;
 var MARGINFI_SPONSORED_SHARD_ID = 3301;
@@ -493,6 +503,19 @@ function shortenAddress(pubkey, chars = 4) {
 function bpsToPercentile(bps) {
   return bps / 1e4;
 }
+var U32_MAX = 4294967295;
+var MAX_ORDER_SLIPPAGE_PERCENT = 10;
+function percentToMaxSlippageU32(percent) {
+  if (!(percent > 0) || percent > MAX_ORDER_SLIPPAGE_PERCENT) {
+    throw new Error(
+      `Max slippage percent must be in (0, ${MAX_ORDER_SLIPPAGE_PERCENT}], got ${percent}`
+    );
+  }
+  return Math.floor(percent / 100 * U32_MAX);
+}
+function maxSlippageU32ToPercent(maxSlippage) {
+  return maxSlippage / U32_MAX * 100;
+}
 var composeRemainingAccounts = (banksAndOracles) => {
   banksAndOracles.sort((a, b) => {
     const A = a[0].toBytes();
@@ -21432,6 +21455,9 @@ var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
   TransactionType2["UNSTAKE_LST"] = "UNSTAKE_LST";
   TransactionType2["WITHDRAW_EMISSIONS"] = "WITHDRAW_EMISSIONS";
   TransactionType2["LIQUIDATE_ACCOUNT"] = "LIQUIDATE_ACCOUNT";
+  TransactionType2["PLACE_ORDER"] = "PLACE_ORDER";
+  TransactionType2["CLOSE_ORDER"] = "CLOSE_ORDER";
+  TransactionType2["UPDATE_ORDER"] = "UPDATE_ORDER";
   TransactionType2["CREATE_PERM_BANK"] = "CREATE_PERM_BANK";
   TransactionType2["CREATE_GROUP"] = "CREATE_GROUP";
   TransactionType2["JUPITER_SWAP"] = "JUPITER_SWAP";
@@ -21518,6 +21544,14 @@ var TransactionConfigMap = {
   ["WITHDRAW_EMISSIONS" /* WITHDRAW_EMISSIONS */]: { label: () => "Withdraw emissions" },
   // LIQUIDATE
   ["LIQUIDATE_ACCOUNT" /* LIQUIDATE_ACCOUNT */]: { label: () => "Liquidate account" },
+  // ORDERS (TP/SL)
+  ["PLACE_ORDER" /* PLACE_ORDER */]: {
+    label: ({ collateralToken, debtToken } = {}) => collateralToken && debtToken ? `Place TP/SL order on ${collateralToken}/${debtToken}` : "Place TP/SL order"
+  },
+  ["CLOSE_ORDER" /* CLOSE_ORDER */]: { label: () => "Close TP/SL order" },
+  ["UPDATE_ORDER" /* UPDATE_ORDER */]: {
+    label: ({ collateralToken, debtToken } = {}) => collateralToken && debtToken ? `Update TP/SL order on ${collateralToken}/${debtToken}` : "Update TP/SL order"
+  },
   // BANK and GROUPS
   ["CREATE_PERM_BANK" /* CREATE_PERM_BANK */]: { label: () => "Create permissionless bank" },
   ["CREATE_GROUP" /* CREATE_GROUP */]: { label: () => "Create marginfi group" },
@@ -22634,6 +22668,10 @@ var AccountFlags = /* @__PURE__ */ ((AccountFlags2) => {
   AccountFlags2[AccountFlags2["ACCOUNT_IN_FLASHLOAN"] = 2] = "ACCOUNT_IN_FLASHLOAN";
   AccountFlags2[AccountFlags2["ACCOUNT_FLAG_DEPRECATED"] = 4] = "ACCOUNT_FLAG_DEPRECATED";
   AccountFlags2[AccountFlags2["ACCOUNT_TRANSFER_AUTHORITY_ALLOWED"] = 8] = "ACCOUNT_TRANSFER_AUTHORITY_ALLOWED";
+  AccountFlags2[AccountFlags2["ACCOUNT_IN_RECEIVERSHIP"] = 16] = "ACCOUNT_IN_RECEIVERSHIP";
+  AccountFlags2[AccountFlags2["ACCOUNT_IN_DELEVERAGE"] = 32] = "ACCOUNT_IN_DELEVERAGE";
+  AccountFlags2[AccountFlags2["ACCOUNT_FROZEN"] = 64] = "ACCOUNT_FROZEN";
+  AccountFlags2[AccountFlags2["ACCOUNT_IN_ORDER_EXECUTION"] = 128] = "ACCOUNT_IN_ORDER_EXECUTION";
   return AccountFlags2;
 })(AccountFlags || {});
 var MarginRequirementType = /* @__PURE__ */ ((MarginRequirementType5) => {
@@ -71294,13 +71332,13 @@ function computeInterestRates(bank) {
   const borrowingRate = baseInterestRate.times(new BigNumber3(1).plus(rateFee)).plus(fixedFee);
   return { lendingRate, borrowingRate };
 }
-var U32_MAX = 4294967295;
+var U32_MAX2 = 4294967295;
 function rateFromU32(rate) {
-  const ratio = new BigNumber3(rate).div(U32_MAX);
+  const ratio = new BigNumber3(rate).div(U32_MAX2);
   return ratio.times(10);
 }
 function utilFromU32(util) {
-  return new BigNumber3(util).div(U32_MAX);
+  return new BigNumber3(util).div(U32_MAX2);
 }
 function calculateRateBetweenPoints(startX, startY, endX, endY, targetX) {
   if (endX.lte(startX)) return startY;
@@ -71909,6 +71947,22 @@ async function makePulseHealthIx(mfProgram, accounts, remainingAccounts = []) {
     marginfiAccount: accounts.marginfiAccount
   }).remainingAccounts(remainingAccounts).instruction();
 }
+async function makePlaceOrderIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { marginfiAccount, feePayer, authority, order, globalFeeWallet, ...optionalAccounts } = accounts;
+  return mfProgram.methods.marginfiAccountPlaceOrder(args.bankKeys, args.trigger).accounts({
+    marginfiAccount,
+    feePayer,
+    order
+  }).accountsPartial({ authority, globalFeeWallet, ...optionalAccounts }).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeCloseOrderIx(mfProgram, accounts, remainingAccounts = []) {
+  const { marginfiAccount, authority, order, feeRecipient, ...optionalAccounts } = accounts;
+  return mfProgram.methods.marginfiAccountCloseOrder().accounts({
+    authority,
+    order,
+    feeRecipient
+  }).accountsPartial({ marginfiAccount, ...optionalAccounts }).remainingAccounts(remainingAccounts).instruction();
+}
 var instructions = {
   makeDepositIx,
   makeJuplendDepositIx,
@@ -71934,7 +71988,9 @@ var instructions = {
   makeLendingPoolConfigureBankOracleIx,
   makeLendingPoolConfigureBankOracleScopeIx,
   makeLendingPoolSetOraclePriceIx,
-  makePulseHealthIx
+  makePulseHealthIx,
+  makePlaceOrderIx,
+  makeCloseOrderIx
 };
 var instructions_default3 = instructions;
 
@@ -72100,9 +72156,25 @@ function decodeAccountRaw(encoded, idl) {
   const coder = new BorshCoder(idl);
   return coder.accounts.decode("marginfiAccount" /* MarginfiAccount */, encoded);
 }
+function parseOrderRaw(orderAddress, orderRaw) {
+  let trigger = "stopLoss";
+  if ("takeProfit" in orderRaw.trigger) trigger = "takeProfit";
+  if ("both" in orderRaw.trigger) trigger = "both";
+  return {
+    address: orderAddress,
+    marginfiAccount: orderRaw.marginfiAccount,
+    trigger,
+    stopLoss: trigger === "takeProfit" ? null : wrappedI80F48toBigNumber(orderRaw.stopLoss),
+    takeProfit: trigger === "stopLoss" ? null : wrappedI80F48toBigNumber(orderRaw.takeProfit),
+    tags: [orderRaw.tags[0], orderRaw.tags[1]],
+    createdAt: orderRaw.createdAt.toNumber(),
+    maxSlippagePercent: maxSlippageU32ToPercent(orderRaw.maxSlippage)
+  };
+}
 function parseBalanceRaw(balanceRaw) {
   const active = typeof balanceRaw.active === "number" ? balanceRaw.active === 1 : balanceRaw.active;
   const bankPk = balanceRaw.bankPk;
+  const tag = balanceRaw.tag;
   const assetShares = wrappedI80F48toBigNumber(balanceRaw.assetShares);
   const liabilityShares = wrappedI80F48toBigNumber(balanceRaw.liabilityShares);
   const emissionsOutstanding = wrappedI80F48toBigNumber(balanceRaw.emissionsOutstanding);
@@ -72110,6 +72182,7 @@ function parseBalanceRaw(balanceRaw) {
   return {
     active,
     bankPk,
+    tag,
     assetShares,
     liabilityShares,
     emissionsOutstanding,
@@ -72156,7 +72229,8 @@ function parseMarginfiAccountRaw(marginfiAccountPk, accountData) {
     balances,
     accountFlags,
     emissionsDestinationAccount,
-    healthCache
+    healthCache,
+    activeOrders: accountData.activeOrders
   };
 }
 function getActiveAccountFlags(flags) {
@@ -72212,13 +72286,15 @@ function dtoToMarginfiAccount(marginfiAccountDto) {
     balances: marginfiAccountDto.balances.map(dtoToBalance),
     accountFlags: marginfiAccountDto.accountFlags,
     emissionsDestinationAccount: new PublicKey(marginfiAccountDto.emissionsDestinationAccount),
-    healthCache: dtoToHealthCache(marginfiAccountDto.healthCache)
+    healthCache: dtoToHealthCache(marginfiAccountDto.healthCache),
+    activeOrders: marginfiAccountDto.activeOrders ?? 0
   };
 }
 function dtoToBalance(balanceDto) {
   return {
     active: balanceDto.active,
     bankPk: new PublicKey(balanceDto.bankPk),
+    tag: balanceDto.tag ?? 0,
     assetShares: new BigNumber3(balanceDto.assetShares),
     liabilityShares: new BigNumber3(balanceDto.liabilityShares),
     emissionsOutstanding: new BigNumber3(balanceDto.emissionsOutstanding),
@@ -72250,13 +72326,15 @@ function marginfiAccountToDto(marginfiAccount) {
     balances: marginfiAccount.balances.map(balanceToDto),
     accountFlags: marginfiAccount.accountFlags,
     emissionsDestinationAccount: marginfiAccount.emissionsDestinationAccount.toBase58(),
-    healthCache: healthCacheToDto(marginfiAccount.healthCache)
+    healthCache: healthCacheToDto(marginfiAccount.healthCache),
+    activeOrders: marginfiAccount.activeOrders
   };
 }
 function balanceToDto(balance) {
   return {
     active: balance.active,
     bankPk: balance.bankPk.toBase58(),
+    tag: balance.tag,
     assetShares: balance.assetShares.toString(),
     liabilityShares: balance.liabilityShares.toString(),
     emissionsOutstanding: balance.emissionsOutstanding.toString(),
@@ -72565,6 +72643,23 @@ function getBalanceUsdValueWithPriceBias(params) {
   });
   return { assets: assetsValue, liabilities: liabilitiesValue };
 }
+function computeOrderPairNetValue(params) {
+  const { collateral, debt } = params;
+  const { assets: collateralUsd } = getBalanceUsdValueWithPriceBias({
+    balance: collateral.balance,
+    bank: collateral.bank,
+    oraclePrice: collateral.oraclePrice,
+    marginRequirement: 2 /* Equity */,
+    assetShareValueMultiplier: collateral.assetShareValueMultiplier
+  });
+  const { liabilities: debtUsd } = getBalanceUsdValueWithPriceBias({
+    balance: debt.balance,
+    bank: debt.bank,
+    oraclePrice: debt.oraclePrice,
+    marginRequirement: 2 /* Equity */
+  });
+  return { collateralUsd, debtUsd, netUsd: collateralUsd.minus(debtUsd) };
+}
 function computeQuantity(balance, bank) {
   const assetsQuantity = getAssetQuantity(bank, balance.assetShares);
   const liabilitiesQuantity = getLiabilityQuantity(bank, balance.liabilityShares);
@@ -72774,6 +72869,7 @@ function createEmptyBalance(bankPk) {
   const balance = {
     active: false,
     bankPk,
+    tag: 0,
     assetShares: new BigNumber3(0),
     liabilityShares: new BigNumber3(0),
     emissionsOutstanding: new BigNumber3(0),
@@ -73076,6 +73172,7 @@ function computeProjectedActiveBalancesNoCpi({
   const projectedBalances = account.balances.map((b) => ({
     active: b.active,
     bankPk: b.bankPk,
+    tag: b.tag,
     assetShares: new BigNumber3(b.assetShares),
     liabilityShares: new BigNumber3(b.liabilityShares),
     emissionsOutstanding: new BigNumber3(b.emissionsOutstanding),
@@ -73349,6 +73446,49 @@ var fetchMarginfiAccountData = async (program, marginfiAccountPk, banksMap, bank
     return { marginfiAccount };
   }
 };
+var fetchOrder = async (program, orderAddress) => {
+  const orderRaw = await program.account.order.fetchNullable(orderAddress);
+  if (!orderRaw) return null;
+  return parseOrderRaw(orderAddress, orderRaw);
+};
+var fetchOrdersForAccount = async (program, marginfiAccount) => {
+  const orders = await program.account.order.all([
+    {
+      memcmp: {
+        bytes: marginfiAccount.toBase58(),
+        offset: 8
+        // first field after the discriminator
+      }
+    }
+  ]);
+  return orders.map(({ publicKey: publicKey5, account }) => parseOrderRaw(publicKey5, account));
+};
+var resolveOrderLegs = (marginfiAccount, order) => {
+  const taggedBalances = marginfiAccount.balances.filter(
+    (balance) => balance.active && balance.tag !== 0 && order.tags.includes(balance.tag)
+  );
+  return {
+    collateralBank: taggedBalances.find((balance) => balance.assetShares.gt(0))?.bankPk ?? null,
+    debtBank: taggedBalances.find((balance) => balance.liabilityShares.gt(0))?.bankPk ?? null
+  };
+};
+var resolveOrderBanks = (marginfiAccount, order) => {
+  const { collateralBank, debtBank } = resolveOrderLegs(marginfiAccount, order);
+  if (!collateralBank || !debtBank) {
+    throw new Error(
+      `Could not resolve banks for order ${order.address.toBase58()}: tagged balances are missing or closed`
+    );
+  }
+  return { collateralBank, debtBank };
+};
+var fetchOrderFees = async (program) => {
+  const [feeStateAddress] = deriveFeeState(program.programId);
+  const feeState = await program.account.feeState.fetch(feeStateAddress);
+  return {
+    placementFeeLamports: feeState.orderInitFlatSolFee,
+    executionMaxFee: wrappedI80F48toBigNumber(feeState.orderExecutionMaxFee)
+  };
+};
 function randomDistinctIndices(count, maxExclusive) {
   const chosen = /* @__PURE__ */ new Set();
   while (chosen.size < count) {
@@ -78073,6 +78213,7 @@ function generateDummyAccount(group, authority, accountKey) {
   const dummyBalances = Array(15).fill({
     active: false,
     bankPk: new PublicKey("11111111111111111111111111111111"),
+    tag: 0,
     assetShares: dummyWrappedI80F48,
     liabilityShares: dummyWrappedI80F48,
     emissionsOutstanding: dummyWrappedI80F48,
@@ -78081,7 +78222,7 @@ function generateDummyAccount(group, authority, accountKey) {
   const rawAccount = {
     group,
     authority,
-    lendingAccount: { balances: dummyBalances },
+    lendingAccount: { balances: dummyBalances, lastTagUsed: 0 },
     healthCache: {
       assetValue: {
         value: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
@@ -78103,20 +78244,22 @@ function generateDummyAccount(group, authority, accountKey) {
       mrgnErr: 0
     },
     emissionsDestinationAccount: new PublicKey("11111111111111111111111111111111"),
-    accountFlags: new BN8([0, 0, 0])
+    accountFlags: new BN8([0, 0, 0]),
+    activeOrders: 0
   };
   return parseMarginfiAccountRaw(accountKey, rawAccount);
 }
 
 // src/models/balance.ts
 var Balance = class _Balance {
-  constructor(active, bankPk, assetShares, liabilityShares, emissionsOutstanding, lastUpdate) {
+  constructor(active, bankPk, assetShares, liabilityShares, emissionsOutstanding, lastUpdate, tag) {
     this.active = active;
     this.bankPk = bankPk;
     this.assetShares = assetShares;
     this.liabilityShares = liabilityShares;
     this.emissionsOutstanding = emissionsOutstanding;
     this.lastUpdate = lastUpdate;
+    this.tag = tag;
   }
   static from(balanceRaw) {
     const props = parseBalanceRaw(balanceRaw);
@@ -78126,7 +78269,8 @@ var Balance = class _Balance {
       props.assetShares,
       props.liabilityShares,
       props.emissionsOutstanding,
-      props.lastUpdate
+      props.lastUpdate,
+      props.tag
     );
   }
   static fromBalanceType(balance) {
@@ -78136,7 +78280,8 @@ var Balance = class _Balance {
       balance.assetShares,
       balance.liabilityShares,
       balance.emissionsOutstanding,
-      balance.lastUpdate
+      balance.lastUpdate,
+      balance.tag
     );
   }
   static createEmpty(bankPk) {
@@ -78212,7 +78357,7 @@ var HealthCache = class _HealthCache {
 
 // src/models/account.ts
 var MarginfiAccount = class _MarginfiAccount {
-  constructor(address, group, authority, balances, accountFlags, emissionsDestinationAccount, healthCache) {
+  constructor(address, group, authority, balances, accountFlags, emissionsDestinationAccount, healthCache, activeOrders = 0) {
     this.address = address;
     this.group = group;
     this.authority = authority;
@@ -78220,6 +78365,7 @@ var MarginfiAccount = class _MarginfiAccount {
     this.accountFlags = accountFlags;
     this.emissionsDestinationAccount = emissionsDestinationAccount;
     this.healthCache = healthCache;
+    this.activeOrders = activeOrders;
   }
   /**
    * Fetches a marginfi account from on-chain data.
@@ -78244,7 +78390,8 @@ var MarginfiAccount = class _MarginfiAccount {
       account.balances.map((b) => Balance.fromBalanceType(b)),
       account.accountFlags,
       account.emissionsDestinationAccount,
-      account.healthCache
+      account.healthCache,
+      account.activeOrders
     );
   }
   /**
@@ -78264,7 +78411,8 @@ var MarginfiAccount = class _MarginfiAccount {
       props.balances.map((b) => Balance.fromBalanceType(b)),
       props.accountFlags,
       props.emissionsDestinationAccount,
-      HealthCache.fromHealthCacheType(props.healthCache)
+      HealthCache.fromHealthCacheType(props.healthCache),
+      props.activeOrders
     );
   }
   /**
@@ -79100,6 +79248,41 @@ var MarginfiAccount = class _MarginfiAccount {
       }
     });
   }
+  // ----------------------------------------------------------------------------
+  // Orders (take-profit / stop-loss)
+  // ----------------------------------------------------------------------------
+  /**
+   * Creates a place-order instruction for this marginfi account.
+   *
+   * @see {@link makePlaceOrderIx} for detailed implementation
+   */
+  async makePlaceOrderIx(params) {
+    return makePlaceOrderIx2({ ...params, marginfiAccount: this });
+  }
+  /**
+   * Creates a transaction placing a take-profit / stop-loss order on a collateral/debt pair.
+   *
+   * @see {@link makePlaceOrderTx} for detailed implementation
+   */
+  async makePlaceOrderTx(params) {
+    return makePlaceOrderTx({ ...params, marginfiAccount: this });
+  }
+  /**
+   * Creates a transaction closing an existing order.
+   *
+   * @see {@link makeCloseOrderTx} for detailed implementation
+   */
+  async makeCloseOrderTx(params) {
+    return makeCloseOrderTx({ ...params, marginfiAccount: this });
+  }
+  /**
+   * Creates a transaction replacing the pair's existing order with new thresholds.
+   *
+   * @see {@link makeUpdateOrderTx} for detailed implementation
+   */
+  async makeUpdateOrderTx(params) {
+    return makeUpdateOrderTx({ ...params, marginfiAccount: this });
+  }
   /**
    * Creates a repay transaction.
    *
@@ -79257,7 +79440,8 @@ function projectAccountAfterFirstLeg(account, firstLegFlashloanTxs, program, ban
     projectedBalances.map((b) => Balance.fromBalanceType(b)),
     account.accountFlags,
     account.emissionsDestinationAccount,
-    account.healthCache
+    account.healthCache,
+    account.activeOrders
   );
 }
 function composeBundle(firstLegTxs, secondLegTxs, payer, blockhash, maxBundleTxs) {
@@ -81660,6 +81844,100 @@ async function makeBulkRepayTx(params) {
   );
   return { transactions, actionTxIndex: 0, mustBeAtomicBundle: false };
 }
+function buildOrderTrigger(params) {
+  const { stopLossUsd, takeProfitUsd } = params;
+  const maxSlippage = percentToMaxSlippageU32(params.maxSlippagePercent);
+  if (stopLossUsd && takeProfitUsd) {
+    if (takeProfitUsd.lte(stopLossUsd)) {
+      throw new Error(
+        `Take-profit threshold (${takeProfitUsd}) must be above stop-loss threshold (${stopLossUsd})`
+      );
+    }
+    return {
+      both: {
+        stopLoss: bigNumberToWrappedI80F48(stopLossUsd),
+        takeProfit: bigNumberToWrappedI80F48(takeProfitUsd),
+        maxSlippage
+      }
+    };
+  }
+  if (stopLossUsd) {
+    return { stopLoss: { threshold: bigNumberToWrappedI80F48(stopLossUsd), maxSlippage } };
+  }
+  if (takeProfitUsd) {
+    return { takeProfit: { threshold: bigNumberToWrappedI80F48(takeProfitUsd), maxSlippage } };
+  }
+  throw new Error("An order needs a stop-loss threshold, a take-profit threshold, or both");
+}
+async function makePlaceOrderIx2(params) {
+  const { program, marginfiAccount, collateralBank, debtBank, trigger, feePayer } = params;
+  const [order] = deriveOrderPda(program.programId, marginfiAccount.address, [
+    collateralBank,
+    debtBank
+  ]);
+  const globalFeeWallet = params.globalFeeWallet ?? (await program.account.feeState.fetch(deriveFeeState(program.programId)[0])).globalFeeWallet;
+  const placeOrderIx = await instructions_default3.makePlaceOrderIx(
+    program,
+    {
+      marginfiAccount: marginfiAccount.address,
+      feePayer: feePayer ?? marginfiAccount.authority,
+      authority: marginfiAccount.authority,
+      order,
+      globalFeeWallet,
+      group: marginfiAccount.group
+    },
+    { bankKeys: [collateralBank, debtBank], trigger: buildOrderTrigger(trigger) }
+  );
+  return { instructions: [placeOrderIx], keys: [] };
+}
+async function makeCloseOrderIx2(params) {
+  const { program, marginfiAccount, order, feeRecipient } = params;
+  const closeOrderIx = await instructions_default3.makeCloseOrderIx(program, {
+    marginfiAccount: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    order,
+    feeRecipient: feeRecipient ?? marginfiAccount.authority,
+    group: marginfiAccount.group
+  });
+  return { instructions: [closeOrderIx], keys: [] };
+}
+async function compileOrderTx(params, payerKey, ixs, type) {
+  const blockhash = params.blockhash ?? (await params.connection.getLatestBlockhashAndContext("confirmed")).value.blockhash;
+  return addTransactionMetadata(
+    new VersionedTransaction(
+      new TransactionMessage({
+        instructions: ixs.flatMap((ix) => ix.instructions),
+        payerKey,
+        recentBlockhash: blockhash
+      }).compileToV0Message(params.luts)
+    ),
+    { type, signers: ixs.flatMap((ix) => ix.keys), addressLookupTables: params.luts }
+  );
+}
+async function makePlaceOrderTx(params) {
+  const placeIxs = await makePlaceOrderIx2(params);
+  const payerKey = params.feePayer ?? params.marginfiAccount.authority;
+  return compileOrderTx(params, payerKey, [placeIxs], "PLACE_ORDER" /* PLACE_ORDER */);
+}
+async function makeCloseOrderTx(params) {
+  const closeIxs = await makeCloseOrderIx2(params);
+  return compileOrderTx(
+    params,
+    params.marginfiAccount.authority,
+    [closeIxs],
+    "CLOSE_ORDER" /* CLOSE_ORDER */
+  );
+}
+async function makeUpdateOrderTx(params) {
+  const [order] = deriveOrderPda(params.program.programId, params.marginfiAccount.address, [
+    params.collateralBank,
+    params.debtBank
+  ]);
+  const closeIxs = await makeCloseOrderIx2({ ...params, order, feeRecipient: params.feePayer });
+  const placeIxs = await makePlaceOrderIx2(params);
+  const payerKey = params.feePayer ?? params.marginfiAccount.authority;
+  return compileOrderTx(params, payerKey, [closeIxs, placeIxs], "UPDATE_ORDER" /* UPDATE_ORDER */);
+}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -84520,6 +84798,52 @@ var MarginfiAccountWrapper = class {
       opts
     });
   }
+  // ----------------------------------------------------------------------------
+  // Orders (take-profit / stop-loss)
+  // ----------------------------------------------------------------------------
+  /**
+   * Creates a transaction placing a take-profit / stop-loss order on a collateral/debt pair.
+   *
+   * @param collateralBank - Bank of the asset-side balance
+   * @param debtBank - Bank of the liability-side balance
+   * @param trigger - USD pair-equity thresholds and max slippage
+   */
+  async makePlaceOrderTx(collateralBank, debtBank, trigger) {
+    return this.account.makePlaceOrderTx({
+      program: this.client.program,
+      collateralBank,
+      debtBank,
+      trigger,
+      luts: this.client.addressLookupTables,
+      connection: this.client.program.provider.connection
+    });
+  }
+  /**
+   * Creates a transaction replacing the pair's existing order with new thresholds.
+   */
+  async makeUpdateOrderTx(collateralBank, debtBank, trigger) {
+    return this.account.makeUpdateOrderTx({
+      program: this.client.program,
+      collateralBank,
+      debtBank,
+      trigger,
+      luts: this.client.addressLookupTables,
+      connection: this.client.program.provider.connection
+    });
+  }
+  /**
+   * Creates a transaction closing an existing order.
+   *
+   * @param order - The order PDA (from `fetchOrdersForAccount` or `deriveOrderPda`)
+   */
+  async makeCloseOrderTx(order) {
+    return this.account.makeCloseOrderTx({
+      program: this.client.program,
+      order,
+      luts: this.client.addressLookupTables,
+      connection: this.client.program.provider.connection
+    });
+  }
   /**
    * Creates a repay transaction with auto-injected client data.
    *
@@ -85204,6 +85528,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_BRIDGE_MINTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SECONDS_PER_YEAR, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, U64_MAX2 as U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkJupiterFeeAccount, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeAccrualProjectionSeconds, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeOracleMultiplier, computeOracleMultipliers, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computePtMultiplier, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, configureScopeOracleIx, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decodeMultiplierAccount, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchGammaLpVault, fetchGammaWithdrawReceipt, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchMultiplierAccountStates, fetchMultiplierAccountStatesFromAPI, fetchNativeStakeAccounts, fetchOracleData, fetchOracleMultipliers, fetchOracleMultipliersFromAPI, fetchOracleMultipliersFromChain, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchScopeOracleData, fetchScopeOraclePricesFromAPI, fetchScopeOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEffectiveDepositLimit, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleMultiplierBankInput, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBorrowLimitActive, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isDepositLimitActive, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx3 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, patchDepositAmount, requireBank, requireTokenProgram, resolveAmount, resolveBridgeCandidateBanks, resolvePinnedSwapRoute, resolveTokenProgramForMint, resolveVaultTokenProgram, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, setOraclePriceIx, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
+export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_BRIDGE_MINTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PDA_ORDER_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SECONDS_PER_YEAR, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, U64_MAX2 as U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, buildOrderTrigger, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkJupiterFeeAccount, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeAccrualProjectionSeconds, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeOracleMultiplier, computeOracleMultipliers, computeOrderPairNetValue, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computePtMultiplier, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, configureScopeOracleIx, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decodeMultiplierAccount, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deriveOrderPda, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchGammaLpVault, fetchGammaWithdrawReceipt, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchMultiplierAccountStates, fetchMultiplierAccountStatesFromAPI, fetchNativeStakeAccounts, fetchOracleData, fetchOracleMultipliers, fetchOracleMultipliersFromAPI, fetchOracleMultipliersFromChain, fetchOrder, fetchOrderFees, fetchOrdersForAccount, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchScopeOracleData, fetchScopeOraclePricesFromAPI, fetchScopeOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEffectiveDepositLimit, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleMultiplierBankInput, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBorrowLimitActive, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isDepositLimitActive, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCloseOrderIx2 as makeCloseOrderIx, makeCloseOrderTx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePlaceOrderIx2 as makePlaceOrderIx, makePlaceOrderTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx3 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateOrderTx, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, marginfiAccountToDto, maxSlippageU32ToPercent, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOrderRaw, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, patchDepositAmount, percentToMaxSlippageU32, requireBank, requireTokenProgram, resolveAmount, resolveBridgeCandidateBanks, resolveOrderBanks, resolveOrderLegs, resolvePinnedSwapRoute, resolveTokenProgramForMint, resolveVaultTokenProgram, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, setOraclePriceIx, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map