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

package/dist/index.cjs

@@ -125,6 +125,8 @@ var TransactionBuildingErrorCode = /* @__PURE__ */ ((TransactionBuildingErrorCod
   TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSUPPORTED_BANK"] = "TRANSFER_POSITIONS_UNSUPPORTED_BANK";
   TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSPLITTABLE"] = "TRANSFER_POSITIONS_UNSPLITTABLE";
   TransactionBuildingErrorCode2["BRIDGE_CONFLICT"] = "BRIDGE_CONFLICT";
+  TransactionBuildingErrorCode2["ORDER_INVALID_TRIGGER"] = "ORDER_INVALID_TRIGGER";
+  TransactionBuildingErrorCode2["ORDER_INVALID_SLIPPAGE"] = "ORDER_INVALID_SLIPPAGE";
   return TransactionBuildingErrorCode2;
 })(TransactionBuildingErrorCode || {});
 var TransactionBuildingError = class _TransactionBuildingError extends Error {
@@ -258,6 +260,28 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { conflictingBanks, bridgeTokenSide }
     );
   }
+  /**
+   * The order trigger can't be placed: no threshold set, a threshold not above 0, or take-profit
+   * at or below stop-loss (the program rejects all three with `InvalidOrderTakeProfitOrStopLoss`).
+   */
+  static orderInvalidTrigger(reason, takeProfitUsd, stopLossUsd) {
+    return new _TransactionBuildingError(
+      "ORDER_INVALID_TRIGGER" /* ORDER_INVALID_TRIGGER */,
+      `Invalid order trigger: ${reason}`,
+      { reason, takeProfitUsd, stopLossUsd }
+    );
+  }
+  /**
+   * The order's max slippage is outside (0, cap]. The program accepts 0, but a keeper can't
+   * execute an order that allows no slippage, so the SDK rejects it.
+   */
+  static orderInvalidSlippage(maxSlippagePercent, maxAllowedPercent) {
+    return new _TransactionBuildingError(
+      "ORDER_INVALID_SLIPPAGE" /* ORDER_INVALID_SLIPPAGE */,
+      `Max slippage percent must be in (0, ${maxAllowedPercent}], got ${maxSlippagePercent}`,
+      { maxSlippagePercent, maxAllowedPercent }
+    );
+  }
   /**
    * Generic escape hatch for custom errors
    */
@@ -535,9 +559,7 @@ 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}`
-    );
+    throw TransactionBuildingError.orderInvalidSlippage(percent, MAX_ORDER_SLIPPAGE_PERCENT);
   }
   return Math.floor(percent / 100 * U32_MAX);
 }
@@ -72911,6 +72933,18 @@ function getActiveBalances(balances) {
 function getBalance(bankAddress, balances) {
   return balances.filter((b) => b.active).find((b) => b.bankPk.equals(bankAddress)) ?? createEmptyBalance(bankAddress);
 }
+var EMPTY_BALANCE_THRESHOLD = 1;
+function 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.liabilityShares.lt(EMPTY_BALANCE_THRESHOLD) && balance.assetShares.gte(EMPTY_BALANCE_THRESHOLD)
+    )?.bankPk ?? null,
+    debtBank: taggedBalances.find((balance) => balance.liabilityShares.gte(EMPTY_BALANCE_THRESHOLD))?.bankPk ?? null
+  };
+}
 function computeAccountValue(marginfiAccount) {
   const { assets, liabilities } = computeHealthComponentsFromCache(
     marginfiAccount,
@@ -73474,11 +73508,6 @@ 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([
     {
@@ -73491,24 +73520,6 @@ var fetchOrdersForAccount = async (program, marginfiAccount) => {
   ]);
   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);
@@ -73640,18 +73651,27 @@ function computeMaxBorrowForBank(params) {
     BigNumber3__default.default.min(healthMaxBorrow, borrowCapRemaining, availableLiquidity, rateLimitRemaining)
   );
 }
-function computeOutflowRateLimitRemaining(bank, oraclePrice, groupRateLimiter, assetShareValueMultiplier) {
+function computeBankOutflowRateLimit(bank, assetShareValueMultiplier) {
+  if (!bank.rateLimiter) return null;
   const nowSeconds = Date.now() / 1e3;
-  let remaining = new BigNumber3__default.default(Infinity);
-  let bankRemaining = computeBankRateLimitRemaining(bank, nowSeconds);
-  if (bankRemaining !== null) {
-    const limiterInBankMintUnits = bank.config.assetTag === 3 /* KAMINO */ || bank.config.assetTag === 2 /* STAKED */;
-    if (limiterInBankMintUnits && assetShareValueMultiplier?.gt(0)) {
-      bankRemaining = bankRemaining.times(assetShareValueMultiplier);
-    }
-    remaining = BigNumber3__default.default.min(remaining, bankRemaining);
+  const limiterToUnderlying = bank.config.assetTag === 2 /* STAKED */ && assetShareValueMultiplier?.gt(0) ? assetShareValueMultiplier : new BigNumber3__default.default(1);
+  let tightest = null;
+  for (const window of ["hourly", "daily"]) {
+    const remainingNative = computeRateLimitWindowRemainingCapacity(
+      bank.rateLimiter[window],
+      nowSeconds
+    );
+    if (!remainingNative) continue;
+    const remaining = BigNumber3__default.default.max(0, nativeToUi(remainingNative, bank.mintDecimals)).times(
+      limiterToUnderlying
+    );
+    if (!tightest || remaining.lt(tightest.remaining)) tightest = { window, remaining };
   }
-  const groupRemainingUsd = computeGroupRateLimitRemainingUsd(groupRateLimiter, nowSeconds);
+  return tightest;
+}
+function computeOutflowRateLimitRemaining(bank, oraclePrice, groupRateLimiter, assetShareValueMultiplier) {
+  let remaining = computeBankOutflowRateLimit(bank, assetShareValueMultiplier)?.remaining ?? new BigNumber3__default.default(Infinity);
+  const groupRemainingUsd = computeGroupRateLimitRemainingUsd(groupRateLimiter);
   if (groupRemainingUsd !== null) {
     const price = getPrice(oraclePrice, 1 /* None */, false);
     if (price.gt(0)) remaining = BigNumber3__default.default.min(remaining, groupRemainingUsd.div(price));
@@ -79295,6 +79315,14 @@ var MarginfiAccount = class _MarginfiAccount {
   async makePlaceOrderTx(params) {
     return makePlaceOrderTx({ ...params, marginfiAccount: this });
   }
+  /**
+   * Creates a close-order instruction for this marginfi account.
+   *
+   * @see {@link makeCloseOrderIx} for detailed implementation
+   */
+  async makeCloseOrderIx(params) {
+    return makeCloseOrderIx2({ ...params, marginfiAccount: this });
+  }
   /**
    * Creates a transaction closing an existing order.
    *
@@ -81875,10 +81903,21 @@ async function makeBulkRepayTx(params) {
 function buildOrderTrigger(params) {
   const { stopLossUsd, takeProfitUsd } = params;
   const maxSlippage = percentToMaxSlippageU32(params.maxSlippagePercent);
+  const invalidTrigger = (reason) => TransactionBuildingError.orderInvalidTrigger(
+    reason,
+    takeProfitUsd?.toString(),
+    stopLossUsd?.toString()
+  );
+  if (stopLossUsd && !stopLossUsd.gt(0)) {
+    throw invalidTrigger(`stop-loss threshold (${stopLossUsd}) must be above 0`);
+  }
+  if (takeProfitUsd && !takeProfitUsd.gt(0)) {
+    throw invalidTrigger(`take-profit threshold (${takeProfitUsd}) must be above 0`);
+  }
   if (stopLossUsd && takeProfitUsd) {
     if (takeProfitUsd.lte(stopLossUsd)) {
-      throw new Error(
-        `Take-profit threshold (${takeProfitUsd}) must be above stop-loss threshold (${stopLossUsd})`
+      throw invalidTrigger(
+        `take-profit threshold (${takeProfitUsd}) must be above stop-loss threshold (${stopLossUsd})`
       );
     }
     return {
@@ -81895,7 +81934,7 @@ function buildOrderTrigger(params) {
   if (takeProfitUsd) {
     return { takeProfit: { threshold: bigNumberToWrappedI80F48(takeProfitUsd), maxSlippage } };
   }
-  throw new Error("An order needs a stop-loss threshold, a take-profit threshold, or both");
+  throw invalidTrigger("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;
@@ -84829,6 +84868,29 @@ var MarginfiAccountWrapper = class {
   // ----------------------------------------------------------------------------
   // Orders (take-profit / stop-loss)
   // ----------------------------------------------------------------------------
+  /**
+   * Creates a place-order instruction, for composing into a larger transaction.
+   *
+   * @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 makePlaceOrderIx(collateralBank, debtBank, trigger) {
+    return this.account.makePlaceOrderIx({
+      program: this.client.program,
+      collateralBank,
+      debtBank,
+      trigger
+    });
+  }
+  /**
+   * Creates a close-order instruction, for composing into a larger transaction.
+   *
+   * @param order - The order PDA (from `fetchOrdersForAccount` or `deriveOrderPda`)
+   */
+  async makeCloseOrderIx(order) {
+    return this.account.makeCloseOrderIx({ program: this.client.program, order });
+  }
   /**
    * Creates a transaction placing a take-profit / stop-loss order on a collateral/debt pair.
    *
@@ -85689,6 +85751,7 @@ exports.computeBankBorrowApy = computeBankBorrowApy;
 exports.computeBankBorrowCapRemaining = computeBankBorrowCapRemaining;
 exports.computeBankDepositCapRemaining = computeBankDepositCapRemaining;
 exports.computeBankMetrics = computeBankMetrics;
+exports.computeBankOutflowRateLimit = computeBankOutflowRateLimit;
 exports.computeBankPoolSize = computeBankPoolSize;
 exports.computeBankProjectedAvailableLiquidity = computeBankProjectedAvailableLiquidity;
 exports.computeBankRateLimitRemaining = computeBankRateLimitRemaining;
@@ -85800,7 +85863,6 @@ exports.fetchOracleData = fetchOracleData;
 exports.fetchOracleMultipliers = fetchOracleMultipliers;
 exports.fetchOracleMultipliersFromAPI = fetchOracleMultipliersFromAPI;
 exports.fetchOracleMultipliersFromChain = fetchOracleMultipliersFromChain;
-exports.fetchOrder = fetchOrder;
 exports.fetchOrderFees = fetchOrderFees;
 exports.fetchOrdersForAccount = fetchOrdersForAccount;
 exports.fetchProgramForMints = fetchProgramForMints;
@@ -85991,7 +86053,6 @@ exports.requireBank = requireBank;
 exports.requireTokenProgram = requireTokenProgram;
 exports.resolveAmount = resolveAmount;
 exports.resolveBridgeCandidateBanks = resolveBridgeCandidateBanks;
-exports.resolveOrderBanks = resolveOrderBanks;
 exports.resolveOrderLegs = resolveOrderLegs;
 exports.resolvePinnedSwapRoute = resolvePinnedSwapRoute;
 exports.resolveTokenProgramForMint = resolveTokenProgramForMint;