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

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var web3_js = require('@solana/web3.js');
 var superstruct = require('superstruct');
+var sha2 = require('@noble/hashes/sha2');
 var BigNumber3 = require('bignumber.js');
 var BN8 = require('bn.js');
 var Decimal3 = require('decimal.js');
@@ -286,6 +287,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 web3_js.PublicKey.findProgramAddressSync(
     [PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, bank.toBuffer()],
@@ -350,6 +352,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(sha2.sha256(Buffer.concat(sortedBankKeys)));
+  return web3_js.PublicKey.findProgramAddressSync(
+    [PDA_ORDER_SEED, marginfiAccount.toBuffer(), bankKeysHash],
+    programId
+  );
+}
 var PYTH_PUSH_ORACLE_ID = new web3_js.PublicKey("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
 var PYTH_SPONSORED_SHARD_ID = 0;
 var MARGINFI_SPONSORED_SHARD_ID = 3301;
@@ -521,6 +531,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();
@@ -21460,6 +21483,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";
@@ -21546,6 +21572,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" },
@@ -22662,6 +22696,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) => {
@@ -71322,13 +71360,13 @@ function computeInterestRates(bank) {
   const borrowingRate = baseInterestRate.times(new BigNumber3__default.default(1).plus(rateFee)).plus(fixedFee);
   return { lendingRate, borrowingRate };
 }
-var U32_MAX = 4294967295;
+var U32_MAX2 = 4294967295;
 function rateFromU32(rate) {
-  const ratio = new BigNumber3__default.default(rate).div(U32_MAX);
+  const ratio = new BigNumber3__default.default(rate).div(U32_MAX2);
   return ratio.times(10);
 }
 function utilFromU32(util) {
-  return new BigNumber3__default.default(util).div(U32_MAX);
+  return new BigNumber3__default.default(util).div(U32_MAX2);
 }
 function calculateRateBetweenPoints(startX, startY, endX, endY, targetX) {
   if (endX.lte(startX)) return startY;
@@ -71937,6 +71975,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,
@@ -71962,7 +72016,9 @@ var instructions = {
   makeLendingPoolConfigureBankOracleIx,
   makeLendingPoolConfigureBankOracleScopeIx,
   makeLendingPoolSetOraclePriceIx,
-  makePulseHealthIx
+  makePulseHealthIx,
+  makePlaceOrderIx,
+  makeCloseOrderIx
 };
 var instructions_default3 = instructions;
 
@@ -72128,9 +72184,25 @@ function decodeAccountRaw(encoded, idl) {
   const coder = new anchor.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);
@@ -72138,6 +72210,7 @@ function parseBalanceRaw(balanceRaw) {
   return {
     active,
     bankPk,
+    tag,
     assetShares,
     liabilityShares,
     emissionsOutstanding,
@@ -72184,7 +72257,8 @@ function parseMarginfiAccountRaw(marginfiAccountPk, accountData) {
     balances,
     accountFlags,
     emissionsDestinationAccount,
-    healthCache
+    healthCache,
+    activeOrders: accountData.activeOrders
   };
 }
 function getActiveAccountFlags(flags) {
@@ -72240,13 +72314,15 @@ function dtoToMarginfiAccount(marginfiAccountDto) {
     balances: marginfiAccountDto.balances.map(dtoToBalance),
     accountFlags: marginfiAccountDto.accountFlags,
     emissionsDestinationAccount: new web3_js.PublicKey(marginfiAccountDto.emissionsDestinationAccount),
-    healthCache: dtoToHealthCache(marginfiAccountDto.healthCache)
+    healthCache: dtoToHealthCache(marginfiAccountDto.healthCache),
+    activeOrders: marginfiAccountDto.activeOrders ?? 0
   };
 }
 function dtoToBalance(balanceDto) {
   return {
     active: balanceDto.active,
     bankPk: new web3_js.PublicKey(balanceDto.bankPk),
+    tag: balanceDto.tag ?? 0,
     assetShares: new BigNumber3__default.default(balanceDto.assetShares),
     liabilityShares: new BigNumber3__default.default(balanceDto.liabilityShares),
     emissionsOutstanding: new BigNumber3__default.default(balanceDto.emissionsOutstanding),
@@ -72278,13 +72354,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(),
@@ -72593,6 +72671,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);
@@ -72802,6 +72897,7 @@ function createEmptyBalance(bankPk) {
   const balance = {
     active: false,
     bankPk,
+    tag: 0,
     assetShares: new BigNumber3__default.default(0),
     liabilityShares: new BigNumber3__default.default(0),
     emissionsOutstanding: new BigNumber3__default.default(0),
@@ -73104,6 +73200,7 @@ function computeProjectedActiveBalancesNoCpi({
   const projectedBalances = account.balances.map((b) => ({
     active: b.active,
     bankPk: b.bankPk,
+    tag: b.tag,
     assetShares: new BigNumber3__default.default(b.assetShares),
     liabilityShares: new BigNumber3__default.default(b.liabilityShares),
     emissionsOutstanding: new BigNumber3__default.default(b.emissionsOutstanding),
@@ -73377,6 +73474,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) {
@@ -78101,6 +78241,7 @@ function generateDummyAccount(group, authority, accountKey) {
   const dummyBalances = Array(15).fill({
     active: false,
     bankPk: new web3_js.PublicKey("11111111111111111111111111111111"),
+    tag: 0,
     assetShares: dummyWrappedI80F48,
     liabilityShares: dummyWrappedI80F48,
     emissionsOutstanding: dummyWrappedI80F48,
@@ -78109,7 +78250,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]
@@ -78131,20 +78272,22 @@ function generateDummyAccount(group, authority, accountKey) {
       mrgnErr: 0
     },
     emissionsDestinationAccount: new web3_js.PublicKey("11111111111111111111111111111111"),
-    accountFlags: new BN8__default.default([0, 0, 0])
+    accountFlags: new BN8__default.default([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);
@@ -78154,7 +78297,8 @@ var Balance = class _Balance {
       props.assetShares,
       props.liabilityShares,
       props.emissionsOutstanding,
-      props.lastUpdate
+      props.lastUpdate,
+      props.tag
     );
   }
   static fromBalanceType(balance) {
@@ -78164,7 +78308,8 @@ var Balance = class _Balance {
       balance.assetShares,
       balance.liabilityShares,
       balance.emissionsOutstanding,
-      balance.lastUpdate
+      balance.lastUpdate,
+      balance.tag
     );
   }
   static createEmpty(bankPk) {
@@ -78240,7 +78385,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;
@@ -78248,6 +78393,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.
@@ -78272,7 +78418,8 @@ var MarginfiAccount = class _MarginfiAccount {
       account.balances.map((b) => Balance.fromBalanceType(b)),
       account.accountFlags,
       account.emissionsDestinationAccount,
-      account.healthCache
+      account.healthCache,
+      account.activeOrders
     );
   }
   /**
@@ -78292,7 +78439,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
     );
   }
   /**
@@ -79128,6 +79276,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.
    *
@@ -79285,7 +79468,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) {
@@ -81688,6 +81872,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 web3_js.VersionedTransaction(
+      new web3_js.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) {
@@ -84548,6 +84826,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.
    *
@@ -85290,6 +85614,7 @@ exports.PDA_BANK_INSURANCE_VAULT_SEED = PDA_BANK_INSURANCE_VAULT_SEED;
 exports.PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED = PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED;
 exports.PDA_BANK_LIQUIDITY_VAULT_SEED = PDA_BANK_LIQUIDITY_VAULT_SEED;
 exports.PDA_MARGINFI_ACCOUNT_SEED = PDA_MARGINFI_ACCOUNT_SEED;
+exports.PDA_ORDER_SEED = PDA_ORDER_SEED;
 exports.PRIORITY_TX_SIZE = PRIORITY_TX_SIZE;
 exports.PYTH_PRICE_CONF_INTERVALS = PYTH_PRICE_CONF_INTERVALS;
 exports.PYTH_PUSH_ORACLE_ID = PYTH_PUSH_ORACLE_ID;
@@ -85339,6 +85664,7 @@ exports.bankRawToDto = bankRawToDto;
 exports.bigNumberToWrappedI80F48 = bigNumberToWrappedI80F48;
 exports.bpsToPercentile = bpsToPercentile;
 exports.buildCollateralLegIxs = buildCollateralLegIxs;
+exports.buildOrderTrigger = buildOrderTrigger;
 exports.calculateApyFromInterest = calculateApyFromInterest;
 exports.calculateInterestFromApy = calculateInterestFromApy;
 exports.capConfidenceInterval = capConfidenceInterval;
@@ -85399,6 +85725,7 @@ exports.computeMaxWithdrawForBank = computeMaxWithdrawForBank;
 exports.computeNetApy = computeNetApy;
 exports.computeOracleMultiplier = computeOracleMultiplier;
 exports.computeOracleMultipliers = computeOracleMultipliers;
+exports.computeOrderPairNetValue = computeOrderPairNetValue;
 exports.computeProjectedActiveBalancesNoCpi = computeProjectedActiveBalancesNoCpi;
 exports.computeProjectedActiveBanksNoCpi = computeProjectedActiveBanksNoCpi;
 exports.computePtMultiplier = computePtMultiplier;
@@ -85433,6 +85760,7 @@ exports.deriveBankLiquidityVault = deriveBankLiquidityVault;
 exports.deriveBankLiquidityVaultAuthority = deriveBankLiquidityVaultAuthority;
 exports.deriveFeeState = deriveFeeState;
 exports.deriveMarginfiAccount = deriveMarginfiAccount;
+exports.deriveOrderPda = deriveOrderPda;
 exports.deserializeInstruction = deserializeInstruction;
 exports.deserializeLut = deserializeLut;
 exports.deserializeSwapEngineRequest = deserializeSwapEngineRequest;
@@ -85472,6 +85800,9 @@ exports.fetchOracleData = fetchOracleData;
 exports.fetchOracleMultipliers = fetchOracleMultipliers;
 exports.fetchOracleMultipliersFromAPI = fetchOracleMultipliersFromAPI;
 exports.fetchOracleMultipliersFromChain = fetchOracleMultipliersFromChain;
+exports.fetchOrder = fetchOrder;
+exports.fetchOrderFees = fetchOrderFees;
+exports.fetchOrdersForAccount = fetchOrdersForAccount;
 exports.fetchProgramForMints = fetchProgramForMints;
 exports.fetchPythOracleData = fetchPythOracleData;
 exports.fetchPythOraclePricesFromAPI = fetchPythOraclePricesFromAPI;
@@ -85570,6 +85901,8 @@ exports.makeBulkWithdrawTx = makeBulkWithdrawTx;
 exports.makeBundleTipIx = makeBundleTipIx;
 exports.makeCloseMarginfiAccountIx = makeCloseMarginfiAccountIx;
 exports.makeCloseMarginfiAccountTx = makeCloseMarginfiAccountTx;
+exports.makeCloseOrderIx = makeCloseOrderIx2;
+exports.makeCloseOrderTx = makeCloseOrderTx;
 exports.makeCreateAccountIxWithProjection = makeCreateAccountIxWithProjection;
 exports.makeCreateAccountTxWithProjection = makeCreateAccountTxWithProjection;
 exports.makeCreateMarginfiAccountIx = makeCreateMarginfiAccountIx;
@@ -85594,6 +85927,8 @@ exports.makeLoopTx = makeLoopTx;
 exports.makeMergeStakeAccountsTx = makeMergeStakeAccountsTx;
 exports.makeMintStakedLstIx = makeMintStakedLstIx;
 exports.makeMintStakedLstTx = makeMintStakedLstTx;
+exports.makePlaceOrderIx = makePlaceOrderIx2;
+exports.makePlaceOrderTx = makePlaceOrderTx;
 exports.makePoolAddBankIx = makePoolAddBankIx3;
 exports.makePoolConfigureBankIx = makePoolConfigureBankIx3;
 exports.makePriorityFeeIx = makePriorityFeeIx;
@@ -85615,6 +85950,7 @@ exports.makeTxPriorityIx = makeTxPriorityIx;
 exports.makeUnwrapSolIx = makeUnwrapSolIx;
 exports.makeUpdateDriftMarketIxs = makeUpdateDriftMarketIxs;
 exports.makeUpdateJupLendRateIxs = makeUpdateJupLendRateIxs;
+exports.makeUpdateOrderTx = makeUpdateOrderTx;
 exports.makeVaultCompleteWithdrawalIx = makeVaultCompleteWithdrawalIx;
 exports.makeVaultCompleteWithdrawalTx = makeVaultCompleteWithdrawalTx;
 exports.makeVaultDepositIx = makeVaultDepositIx;
@@ -85629,6 +85965,7 @@ exports.makeWrapSolIxs = makeWrapSolIxs;
 exports.mapJupiterQuoteToSwapQuoteResult = mapJupiterQuoteToSwapQuoteResult;
 exports.mapPythBanksToOraclePrices = mapPythBanksToOraclePrices;
 exports.marginfiAccountToDto = marginfiAccountToDto;
+exports.maxSlippageU32ToPercent = maxSlippageU32ToPercent;
 exports.mergeBridgeQuotes = mergeBridgeQuotes;
 exports.mergeBridgeQuotesDebt = mergeBridgeQuotesDebt;
 exports.mergeBridgeQuotesLoop = mergeBridgeQuotesLoop;
@@ -85644,14 +85981,18 @@ exports.parseHealthCacheRaw = parseHealthCacheRaw;
 exports.parseMarginfiAccountRaw = parseMarginfiAccountRaw;
 exports.parseOperationalState = parseOperationalState;
 exports.parseOracleSetup = parseOracleSetup;
+exports.parseOrderRaw = parseOrderRaw;
 exports.parsePriceInfo = parseOraclePriceData;
 exports.parseRiskTier = parseRiskTier;
 exports.parseRpcPythPriceData = parseRpcPythPriceData;
 exports.patchDepositAmount = patchDepositAmount;
+exports.percentToMaxSlippageU32 = percentToMaxSlippageU32;
 exports.requireBank = requireBank;
 exports.requireTokenProgram = requireTokenProgram;
 exports.resolveAmount = resolveAmount;
 exports.resolveBridgeCandidateBanks = resolveBridgeCandidateBanks;
+exports.resolveOrderBanks = resolveOrderBanks;
+exports.resolveOrderLegs = resolveOrderLegs;
 exports.resolvePinnedSwapRoute = resolvePinnedSwapRoute;
 exports.resolveTokenProgramForMint = resolveTokenProgramForMint;
 exports.resolveVaultTokenProgram = resolveVaultTokenProgram;