@0dotxyz/p0-ts-sdk 2.9.0-alpha.0 → 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,11 +559,9 @@ 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.round(percent / 100 * U32_MAX);
+  return Math.floor(percent / 100 * U32_MAX);
 }
 function maxSlippageU32ToPercent(maxSlippage) {
   return maxSlippage / U32_MAX * 100;
@@ -22696,6 +22718,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) => {
@@ -72253,7 +72279,8 @@ function parseMarginfiAccountRaw(marginfiAccountPk, accountData) {
     balances,
     accountFlags,
     emissionsDestinationAccount,
-    healthCache
+    healthCache,
+    activeOrders: accountData.activeOrders
   };
 }
 function getActiveAccountFlags(flags) {
@@ -72309,7 +72336,8 @@ 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) {
@@ -72348,7 +72376,8 @@ 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) {
@@ -72664,6 +72693,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);
@@ -72887,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,
@@ -73450,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([
     {
@@ -73467,18 +73520,13 @@ var fetchOrdersForAccount = async (program, marginfiAccount) => {
   ]);
   return orders.map(({ publicKey: publicKey5, account }) => parseOrderRaw(publicKey5, account));
 };
-var resolveOrderBanks = (marginfiAccount, order) => {
-  const taggedBalances = marginfiAccount.balances.filter(
-    (balance) => balance.tag !== 0 && order.tags.includes(balance.tag)
-  );
-  const collateral = taggedBalances.find((balance) => balance.assetShares.gt(0));
-  const debt = taggedBalances.find((balance) => balance.liabilityShares.gt(0));
-  if (!collateral || !debt) {
-    throw new Error(
-      `Could not resolve banks for order ${order.address.toBase58()}: tagged balances are missing or closed`
-    );
-  }
-  return { collateralBank: collateral.bankPk, debtBank: debt.bankPk };
+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();
@@ -73603,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));
@@ -78235,7 +78292,9 @@ 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);
 }
 
@@ -78346,7 +78405,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;
@@ -78354,6 +78413,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.
@@ -78378,7 +78438,8 @@ var MarginfiAccount = class _MarginfiAccount {
       account.balances.map((b) => Balance.fromBalanceType(b)),
       account.accountFlags,
       account.emissionsDestinationAccount,
-      account.healthCache
+      account.healthCache,
+      account.activeOrders
     );
   }
   /**
@@ -78398,7 +78459,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
     );
   }
   /**
@@ -79253,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.
    *
@@ -79426,7 +79496,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) {
@@ -81832,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 {
@@ -81852,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;
@@ -84786,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.
    *
@@ -85646,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;
@@ -85682,6 +85788,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;
@@ -85756,7 +85863,7 @@ 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;
@@ -85946,7 +86053,7 @@ 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;