@0dotxyz/p0-ts-sdk 2.10.0-alpha.0 → 2.10.0

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import * as superstruct from 'superstruct';
 import { Infer } from 'superstruct';
-import { b as BankType, R as RiskTier, A as AssetTag, c as BankConfigFlag, O as OperationalState, d as OracleSetup, E as EmodeTag, e as EmodeEntryFlags, f as EmodeFlags, W as WrappedI80F48, I as InterestRateConfigRaw, g as OperationalStateRaw, h as OracleSetupRaw, i as RiskTierRaw, M as MarginfiProgram, j as BankConfigOpt, k as InterestRateConfig, l as BankConfigType, m as BankConfigRaw, a as BankConfigOptRaw, n as EmodeSettingsType, o as BankRateLimiterType, p as BankRaw, q as BankRateLimiterRaw, r as EmodeSettingsRaw, s as MarginfiIdlType, H as HealthCacheFlags, t as HealthCacheStatus, u as AccountFlags, v as MarginfiAccountType, w as OraclePrice, P as PriceWithConfidence, x as PriceBias, y as OraclePriceDto, z as BankIntegrationMetadataMap, C as BalanceType, D as HealthCacheType, F as EmodePair, G as ActiveEmodePair, J as ActionEmodeImpact, K as MarginRequirementType, L as Amount, N as EmodeImpactStatus, T as TypedAmount, Q as BankVaultType, S as RateLimitWindowType, U as BankIntegrationMetadataMapDto, V as BankIntegrationMetadataDto, X as BankIntegrationMetadata, Y as Bank, Z as Environment, _ as Project0Config, $ as MintData } from './types-Cj6aaTuh.js';
-export { ax as AccountType, aC as AmountType, aw as BankAddress, a0 as BankConfig, B as BankConfigCompactRaw, az as BankMap, av as BankMetadata, a3 as BankMetadataRaw, ao as ComputeAssetUsdValueParams, am as ComputeLiabilityUsdValueParams, ak as ComputeUsdValueParams, a8 as EmodeConfigRaw, ab as EmodeEntry, ad as EmodeImpact, a1 as EmodeSettings, af as GetAssetWeightParams, a5 as InterestRateConfigCompactRaw, aa as InterestRateConfigOpt, a6 as InterestRateConfigOptRaw, ay as KaminoStates, as as MARGINFI_IDL, aB as MintDataMap, ac as OracleConfigOpt, a7 as OracleConfigOptRaw, aA as OraclePriceMap, ar as PriceWithConfidenceDto, at as Program, a2 as RateLimitWindowRaw, a9 as RatePoint, a4 as RatePointRaw, au as Wallet, ap as computeAssetUsdValue, an as computeLiabilityUsdValue, aj as computeLoopingParams, ai as computeMaxLeverage, aq as computeTvl, al as computeUsdValue, ag as getAssetWeight, ah as getLiabilityWeight, ae as isWeightedPrice, aD as resolveAmount } from './types-Cj6aaTuh.js';
+import { c as BankType, R as RiskTier, A as AssetTag, d as BankConfigFlag, e as OperationalState, f as OracleSetup, E as EmodeTag, g as EmodeEntryFlags, h as EmodeFlags, W as WrappedI80F48, I as InterestRateConfigRaw, i as OperationalStateRaw, j as OracleSetupRaw, k as RiskTierRaw, M as MarginfiProgram, l as InterestRateConfig, m as BankConfigType, n as BankConfigRaw, o as BankConfigOpt, p as BankConfigOptRaw, q as EmodeSettingsType, r as BankRateLimiterType, s as BankRaw, t as BankRateLimiterRaw, u as EmodeSettingsRaw, v as MarginfiIdlType, H as HealthCacheFlags, w as HealthCacheStatus, x as AccountFlags, y as MarginfiAccountType, z as OraclePrice, P as PriceWithConfidence, C as PriceBias, D as OraclePriceDto, F as BankIntegrationMetadataMap, G as OrderType, J as BalanceType, K as HealthCacheType, L as EmodePair, N as ActiveEmodePair, Q as ActionEmodeImpact, S as MarginRequirementType, a as BankConfigFastRaw, b as BankConfigGovRaw, T as Amount, U as EmodeImpactStatus, O as OrderTrigger, V as TypedAmount, X as BankVaultType, Y as RateLimitWindowType, Z as BankIntegrationMetadataMapDto, _ as BankIntegrationMetadataDto, $ as BankIntegrationMetadata, a0 as Bank, a1 as Environment, a2 as Project0Config, a3 as MintData } from './types--m9sTr2x.js';
+export { aC as AccountType, aH as AmountType, aB as BankAddress, a4 as BankConfig, B as BankConfigCompactRaw, aE as BankMap, aA as BankMetadata, a7 as BankMetadataRaw, as as ComputeAssetUsdValueParams, aq as ComputeLiabilityUsdValueParams, ao as ComputeUsdValueParams, ac as EmodeConfigRaw, af as EmodeEntry, ah as EmodeImpact, a5 as EmodeSettings, aj as GetAssetWeightParams, a9 as InterestRateConfigCompactRaw, ae as InterestRateConfigOpt, aa as InterestRateConfigOptRaw, aD as KaminoStates, ax as MARGINFI_IDL, aG as MintDataMap, ag as OracleConfigOpt, ab as OracleConfigOptRaw, aF as OraclePriceMap, av as OrderTriggerKind, aw as PriceWithConfidenceDto, ay as Program, a6 as RateLimitWindowRaw, ad as RatePoint, a8 as RatePointRaw, az as Wallet, at as computeAssetUsdValue, ar as computeLiabilityUsdValue, an as computeLoopingParams, am as computeMaxLeverage, au as computeTvl, ap as computeUsdValue, ak as getAssetWeight, al as getLiabilityWeight, ai as isWeightedPrice, aI as resolveAmount } from './types--m9sTr2x.js';
 import * as _solana_web3_js from '@solana/web3.js';
 import { VersionedTransaction, Transaction, PublicKey, TransactionError, TransactionInstruction, Keypair, Signer, AddressLookupTableAccount, Blockhash, TransactionMessage, Connection, AccountInfo } from '@solana/web3.js';
 import { Idl, Instruction, Address } from '@coral-xyz/anchor';
 import BigNumber$1 from 'bignumber.js';
 import BN from 'bn.js';
-import { K as KaminoReserve, D as DriftSpotMarket, d as DriftRewards, J as JupLendingState, f as JupTokenReserve, i as KaminoReserveJSON, j as KaminoObligationJSON, k as KaminoFarmStateJSON, a as KaminoObligation, b as KaminoFarmState, l as DriftSpotMarketJSON, m as DriftUserJSON, n as DriftRewardsJSON, o as DriftUserStatsJSON, c as DriftUser, e as DriftUserStats, p as JupLendingStateJSON, q as JupTokenReserveJSON, r as JupLendingRewardsRateModelJSON, s as JupRateModelJSON, g as JupLendingRewardsRateModel, h as JupRateModel } from './dto-farm.types-BAA9xrey.js';
+import { K as KaminoReserve, D as DriftSpotMarket, d as DriftRewards, J as JupLendingState, f as JupTokenReserve, i as KaminoReserveJSON, j as KaminoObligationJSON, k as KaminoFarmStateJSON, a as KaminoObligation, b as KaminoFarmState, l as DriftSpotMarketJSON, m as DriftUserJSON, n as DriftRewardsJSON, o as DriftUserStatsJSON, c as DriftUser, e as DriftUserStats, p as JupLendingStateJSON, q as JupTokenReserveJSON, r as JupLendingRewardsRateModelJSON, s as JupRateModelJSON, g as JupLendingRewardsRateModel, h as JupRateModel } from './dto-farm.types-6lrPBcZr.js';
 import { JupiterClientConfig, QuoteGetRequest, QuoteResponse } from './jupiter.js';
 import { E as ExponentVault, G as GammaLpVaultRaw, e as GammaWithdrawReceiptRaw } from './types-Pjhu5XMK.js';
 import { Buffer as Buffer$1 } from 'buffer';
@@ -82,6 +82,9 @@ declare enum TransactionType {
     UNSTAKE_LST = "UNSTAKE_LST",
     WITHDRAW_EMISSIONS = "WITHDRAW_EMISSIONS",
     LIQUIDATE_ACCOUNT = "LIQUIDATE_ACCOUNT",
+    PLACE_ORDER = "PLACE_ORDER",
+    CLOSE_ORDER = "CLOSE_ORDER",
+    UPDATE_ORDER = "UPDATE_ORDER",
     CREATE_PERM_BANK = "CREATE_PERM_BANK",
     CREATE_GROUP = "CREATE_GROUP",
     JUPITER_SWAP = "JUPITER_SWAP"
@@ -138,6 +141,18 @@ declare function selectLutsForAccountAction(luts: AddressLookupTableAccount[], t
 declare function isV0Tx(tx: Transaction | VersionedTransaction): tx is VersionedTransaction;
 declare function isFlashloan(tx: SolanaTransaction): boolean;
 declare function makeVersionedTransaction(blockhash: Blockhash, transaction: Transaction, payer: PublicKey, addressLookupTables?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
+/**
+ * Whether the instructions compile into one v0 transaction within MAX_TX_SIZE (minus
+ * `sizeMargin`, if given) and `maxAccountLocks` account locks (if given).
+ */
+declare function fitsInOneTransaction(ixs: TransactionInstruction[], opts: {
+    payerKey: PublicKey;
+    luts: AddressLookupTableAccount[];
+    /** Bytes reserved below MAX_TX_SIZE, e.g. for compute-budget ixs appended at send time. */
+    sizeMargin?: number;
+    /** Also cap the total account locks (e.g. MAX_ACCOUNT_LOCKS). */
+    maxAccountLocks?: number;
+}): boolean;
 /**
  * Splits your instructions into as many VersionedTransactions as needed
  * so that none exceed MAX_TX_SIZE (minus `sizeMargin`, if given) nor
@@ -152,6 +167,15 @@ declare function splitInstructionsToFitTransactions(mandatoryIxs: TransactionIns
     /** Also cap the total account locks per transaction (e.g. MAX_ACCOUNT_LOCKS). */
     maxAccountLocks?: number;
 }): VersionedTransaction[];
+/**
+ * Builds the transactions that run before an action: setup (ATA creation and the like) tagged
+ * `CREATE_ATA`, then venue refreshes tagged `CRANK`, each split to fit.
+ */
+declare function makePreludeTxs(setupIxs: TransactionInstruction[], refreshIxs: TransactionInstruction[], opts: {
+    blockhash: string;
+    payerKey: PublicKey;
+    luts: AddressLookupTableAccount[];
+}): ExtendedV0Transaction[];
 /**
  * Enhances a given transaction with additional metadata.
  *
@@ -302,6 +326,7 @@ interface BankTypeDto {
     premiumTag?: number;
     premiumActive?: boolean;
     premiumActivatedAt?: number;
+    kaminoEmergency?: boolean;
     rateLimiter?: BankRateLimiterDto;
     feesDestinationAccount?: string;
     lendingPositionCount?: string;
@@ -412,7 +437,15 @@ interface EmodeEntryRawDto {
     assetWeightMaint: WrappedI80F48;
 }
 
-declare function freezeBankConfigIx(program: MarginfiProgram, bankAddress: PublicKey, bankConfigOpt: BankConfigOpt): Promise<InstructionsWrapper>;
+/**
+ * Freezes a bank's settings so they can no longer be changed. Signed by the group's governance
+ * admin.
+ *
+ * @param program - The marginfi program
+ * @param bankAddress - The bank to freeze
+ * @returns The `lending_pool_configure_bank_gov` instruction
+ */
+declare function freezeBankConfigIx(program: MarginfiProgram, bankAddress: PublicKey): Promise<InstructionsWrapper>;
 type AddOracleToBanksIxArgs = {
     program: MarginfiProgram;
     bankAddress: PublicKey;
@@ -423,9 +456,9 @@ type AddOracleToBanksIxArgs = {
     oracleAccounts?: PublicKey[];
     setup: OracleSetup;
     groupAddress?: PublicKey;
-    adminAddress?: PublicKey;
+    governanceAdminAddress?: PublicKey;
 };
-declare function addOracleToBanksIx({ program, bankAddress, feedId, oracleKey, oracleAccounts, setup, groupAddress, adminAddress, }: AddOracleToBanksIxArgs): Promise<InstructionsWrapper>;
+declare function addOracleToBanksIx({ program, bankAddress, feedId, oracleKey, oracleAccounts, setup, groupAddress, governanceAdminAddress, }: AddOracleToBanksIxArgs): Promise<InstructionsWrapper>;
 type SetOraclePriceIxArgs = {
     program: MarginfiProgram;
     bankAddress: PublicKey;
@@ -434,19 +467,24 @@ type SetOraclePriceIxArgs = {
     /** Fixed venue account, [Pyth, Exponent vault], or [Exponent vault], depending on setup. */
     oracleAccounts?: PublicKey[];
     groupAddress?: PublicKey;
-    adminAddress?: PublicKey;
+    governanceAdminAddress?: PublicKey;
 };
-/** Configure a flat fixed price or an Exponent PT price using the 0.1.11 instruction. */
-declare function setOraclePriceIx({ program, bankAddress, price, setup, oracleAccounts, groupAddress, adminAddress, }: SetOraclePriceIxArgs): Promise<InstructionsWrapper>;
+/** Configure a flat fixed price or an Exponent PT price, signed by the group's governance admin. */
+declare function setOraclePriceIx({ program, bankAddress, price, setup, oracleAccounts, groupAddress, governanceAdminAddress, }: SetOraclePriceIxArgs): Promise<InstructionsWrapper>;
 type ConfigureScopeOracleIxArgs = {
     program: MarginfiProgram;
-    bankAddress: PublicKey;
+    bank: BankType;
     oracle: PublicKey;
     entryIndex: number;
     groupAddress?: PublicKey;
-    adminAddress?: PublicKey;
+    governanceAdminAddress?: PublicKey;
 };
-declare function configureScopeOracleIx({ program, bankAddress, oracle, entryIndex, groupAddress, adminAddress, }: ConfigureScopeOracleIxArgs): Promise<InstructionsWrapper>;
+/**
+ * Point a bank at an entry in a Scope OraclePrices account, signed by the group's governance admin.
+ * The program picks Scope, ScopeKamino or ScopeJuplend from the bank's asset tag; for Kamino and
+ * JupLend banks the reserve / lending account it validates is taken from `bank.config.oracleKeys[1]`.
+ */
+declare function configureScopeOracleIx({ program, bank, oracle, entryIndex, groupAddress, governanceAdminAddress, }: ConfigureScopeOracleIxArgs): Promise<InstructionsWrapper>;
 
 declare function serializeBankConfigOpt(bankConfigOpt: BankConfigOpt): BankConfigOptRaw;
 declare function serializeInterestRateConfig(interestRateConfig: InterestRateConfig): InterestRateConfigRaw;
@@ -573,6 +611,7 @@ declare function getLiabilityShares(bank: BankType, liabilityQuantity: BigNumber
 interface BalanceRaw {
     active: boolean | number;
     bankPk: PublicKey;
+    tag: number;
     assetShares: WrappedI80F48;
     liabilityShares: WrappedI80F48;
     premiumRateSnapshot: number;
@@ -600,12 +639,31 @@ interface MarginfiAccountRaw {
     authority: PublicKey;
     lendingAccount: {
         balances: BalanceRaw[];
+        lastTagUsed: number;
     };
     accountFlags: BN;
     emissionsDestinationAccount: PublicKey;
     healthCache: HealthCacheRaw;
+    activeOrders: number;
     padding0?: BN[];
 }
+type OrderTriggerTypeRaw = {
+    stopLoss: Record<string, never>;
+} | {
+    takeProfit: Record<string, never>;
+} | {
+    both: Record<string, never>;
+};
+interface OrderRaw {
+    marginfiAccount: PublicKey;
+    stopLoss: WrappedI80F48;
+    takeProfit: WrappedI80F48;
+    createdAt: BN;
+    maxSlippage: number;
+    tags: number[];
+    trigger: OrderTriggerTypeRaw;
+    bump: number;
+}
 type MarginRequirementTypeRaw = {
     initial: Record<string, never>;
 } | {
@@ -617,6 +675,8 @@ type MarginRequirementTypeRaw = {
 interface BalanceTypeDto {
     active: boolean;
     bankPk: string;
+    /** Optional for backwards compatibility with DTOs serialized before order tags existed. */
+    tag?: number;
     assetShares: string;
     liabilityShares: string;
     premiumRate: string;
@@ -643,6 +703,8 @@ interface MarginfiAccountTypeDto {
     accountFlags: AccountFlags[];
     emissionsDestinationAccount: string;
     healthCache: HealthCacheTypeDto;
+    /** Optional so DTOs cached before the field existed still parse (defaults to 0). */
+    activeOrders?: number;
 }
 
 interface SimulationResultRaw {
@@ -1170,6 +1232,7 @@ declare function runSwapEngine(req: SwapEngineRequest): Promise<SwapEngineResult
 
 declare const EMPTY_HEALTH_CACHE: HealthCacheRaw;
 declare function decodeAccountRaw(encoded: Buffer, idl: MarginfiIdlType): MarginfiAccountRaw;
+declare function parseOrderRaw(orderAddress: PublicKey, orderRaw: OrderRaw): OrderType;
 declare function parseBalanceRaw(balanceRaw: BalanceRaw): BalanceType;
 declare function parseHealthCacheRaw(healthCacheRaw: HealthCacheRaw): HealthCacheType;
 declare function parseMarginfiAccountRaw(marginfiAccountPk: PublicKey, accountData: MarginfiAccountRaw): MarginfiAccountType;
@@ -1637,6 +1700,31 @@ declare function getBalanceUsdValueWithPriceBias(params: GetBalanceUsdValueWithP
     assets: BigNumber$1;
     liabilities: BigNumber$1;
 };
+interface OrderPairLegValueInput {
+    balance: BalanceType;
+    bank: BankType;
+    oraclePrice: OraclePrice;
+    assetShareValueMultiplier?: BigNumber$1;
+}
+/**
+ * Values an order's collateral/debt pair the way the program's trigger does
+ * (`get_tagged_account_health_components`): Equity requirement, so the time-weighted (EMA) price
+ * at weight 1, with the collateral at the low end of the confidence band and the debt at the high
+ * end. Isolated-tier collateral counts as 0. Take-profit fires at `netUsd >= takeProfit`, stop-loss
+ * at `netUsd <= stopLoss`.
+ *
+ * @param params.collateral - The order's asset-side balance with its bank and oracle price
+ * @param params.debt - The order's liability-side balance with its bank and oracle price
+ * @returns USD values of both legs and the net value the trigger compares against
+ */
+declare function computeOrderPairNetValue(params: {
+    collateral: OrderPairLegValueInput;
+    debt: OrderPairLegValueInput;
+}): {
+    collateralUsd: BigNumber$1;
+    debtUsd: BigNumber$1;
+    netUsd: BigNumber$1;
+};
 /**
  * Computes the native token quantities for a balance.
  *
@@ -1748,6 +1836,19 @@ declare function getActiveBalances(balances: BalanceType[]): BalanceType[];
  * ```
  */
 declare function getBalance(bankAddress: PublicKey, balances: BalanceType[]): BalanceType;
+/**
+ * Maps an order's balance tags to the collateral (asset) and debt (liability) banks of the
+ * account that owns it, without throwing: a leg whose tagged balance was closed comes back null
+ * (the order is orphaned and can no longer execute). The tag order in `order.tags` follows the
+ * caller-supplied bank key order at placement time, so the side is inferred from the balances.
+ *
+ * @param marginfiAccount - The parsed marginfi account that owns the order
+ * @param order - The order whose bank pair to resolve
+ */
+declare function resolveOrderLegs(marginfiAccount: MarginfiAccountType, order: Pick<OrderType, "tags">): {
+    collateralBank: PublicKey | null;
+    debtBank: PublicKey | null;
+};
 
 /**
  * Account-Level Metrics
@@ -1966,13 +2067,13 @@ interface MarginfiGroupRaw {
      */
     rateLimiter?: BankRateLimiterRaw;
     /** Variable borrow premium table header; the first `entryCount` of `premiumEntries` are live */
-    premiumSettings?: {
+    premiumSettings: {
         timestamp: BN;
         entryCount: number;
         entryCapacity: number;
     };
     /** Premium rate per (collateral tag, liability tag), sorted by that pair */
-    premiumEntries?: {
+    premiumEntries: {
         collateralTag: number;
         liabilityTag: number;
         rate: number;
@@ -2016,10 +2117,20 @@ type MarginfiGroupTypeDto = {
  */
 declare function isGroupRateLimiterEnabled(rateLimiter?: BankRateLimiterType): boolean;
 
-declare function makePoolConfigureBankIx(program: MarginfiProgram, bank: PublicKey, args: BankConfigOptRaw): Promise<InstructionsWrapper>;
+declare function makePoolConfigureBankIx(program: MarginfiProgram, bank: PublicKey, args: BankConfigFastRaw): Promise<InstructionsWrapper>;
+/**
+ * Configures a bank's governance settings (weights, risk tier, asset tag, oracle limits,
+ * tokenless repayments, freezing, returning to operational). Signed by the group's governance admin.
+ *
+ * @param program - The marginfi program
+ * @param bank - The bank to configure
+ * @param args - The settings to change; `null` leaves a setting unchanged
+ * @returns The `lending_pool_configure_bank_gov` instruction
+ */
+declare function makePoolConfigureBankGovIx(program: MarginfiProgram, bank: PublicKey, args: BankConfigGovRaw): Promise<InstructionsWrapper>;
 declare function makeAddPermissionlessStakedBankIx(program: MarginfiProgram, group: PublicKey, voteAccountAddress: PublicKey, feePayer: PublicKey, pythOracle: PublicKey): Promise<InstructionsWrapper>;
 declare function makePoolAddBankIx(program: MarginfiProgram, group: PublicKey, bank: PublicKey, feePayer: PublicKey, bankMint: PublicKey, bankConfig: BankConfigOpt, tokenProgram?: PublicKey, overrideOpt?: {
-    admin?: PublicKey;
+    governanceAdmin?: PublicKey;
     globalFeeWallet?: PublicKey;
 }): Promise<InstructionsWrapper>;
 
@@ -2079,6 +2190,31 @@ interface ComputePremiumRatesParams {
  * @returns Rate by bank address, for every premium-active bank in `banksMap`
  */
 declare function computePremiumRatesByBank(params: ComputePremiumRatesParams): Map<string, BigNumber>;
+/**
+ * One collateral's part in a liability's premium rate
+ */
+interface PremiumCollateralBreakdown {
+    /** Collateral bank address */
+    bank: PublicKey;
+    /** The collateral bank's premium tag (0 = untagged) */
+    tag: number;
+    /** Collateral USD counted toward the rate: unweighted, at the Initial-requirement low price */
+    usd: BigNumber;
+    /** Rate of this collateral's tag against the liability's tag (APR fraction); 0 without a pair */
+    pairRate: BigNumber;
+    /** usd x pairRate / total collateral USD; the rows sum to the liability's rate */
+    contributionApr: BigNumber;
+}
+/**
+ * Per-collateral breakdown of the rate {@link computePremiumRatesByBank} gives `liabilityBank`:
+ * one row per collateral that counts toward premium. Isolated, zero-maintenance-weight and unpriced
+ * collateral are left out, as on-chain.
+ *
+ * @param params - Account state and the group's premium table
+ * @param liabilityBank - The premium-active bank borrowed from (or to be borrowed from)
+ * @returns Rows whose `contributionApr` sums to the rate; empty when the bank has no premium
+ */
+declare function computePremiumBreakdown(params: ComputePremiumRatesParams, liabilityBank: PublicKey): PremiumCollateralBreakdown[];
 /**
  * An action whose effect on premium rates is previewed by {@link computePremiumImpact}
  */
@@ -2100,11 +2236,13 @@ interface PremiumImpact {
     refreshes: boolean;
     /**
      * Every premium-active debt after the actions, by bank address: the stored rate before (absent
-     * for a new borrow) and the refreshed rate after. APR fractions.
+     * for a new borrow), the refreshed rate after (APR fractions), and the per-collateral breakdown
+     * of the rate after.
      */
     liabilities: Map<string, {
         before?: BigNumber;
         after: BigNumber;
+        breakdown: PremiumCollateralBreakdown[];
     }>;
     /** Yearly premium in USD across those debts: principal x rate, before and after */
     annualPremiumUsd: {
@@ -2330,6 +2468,25 @@ declare const fetchMarginfiAccountData: (program: MarginfiProgram, marginfiAccou
     marginfiAccount: MarginfiAccountType;
     error?: HealthCacheSimulationError;
 }>;
+/**
+ * Fetches all open orders for a marginfi account.
+ *
+ * @param program - The marginfi Anchor program (connection is taken from its provider)
+ * @param marginfiAccount - The marginfi account public key
+ */
+declare const fetchOrdersForAccount: (program: MarginfiProgram, marginfiAccount: PublicKey) => Promise<OrderType[]>;
+/**
+ * Fetches the order fees from the program's global `FeeState`.
+ *
+ * - `placementFeeLamports`: flat SOL fee charged by `place_order` (and again on every update).
+ * - `executionMaxFee`: the share of the pair's net value a keeper may keep on a take-profit.
+ *
+ * @param program - The marginfi Anchor program
+ */
+declare const fetchOrderFees: (program: MarginfiProgram) => Promise<{
+    placementFeeLamports: number;
+    executionMaxFee: BigNumber$1;
+}>;
 /**
  * Generates a random available account index that doesn't collide with existing accounts.
  * Account indices are 0-255 (u8 range).
@@ -2423,6 +2580,27 @@ interface ComputeMaxBorrowForBankParams {
  * ```
  */
 declare function computeMaxBorrowForBank(params: ComputeMaxBorrowForBankParams): BigNumber$1;
+/**
+ * The binding window of a bank's own outflow (withdraws + borrows) rate limiter.
+ */
+interface BankOutflowRateLimit {
+    window: "hourly" | "daily";
+    /** Remaining outflow in underlying UI units, clamped at 0 */
+    remaining: BigNumber$1;
+}
+/**
+ * The tighter of a bank's hourly and daily outflow windows, in the underlying UI units that
+ * {@link computeMaxWithdrawForBank} and {@link computeMaxBorrowForBank} clamp to.
+ *
+ * Every venue's withdraw records the underlying token amount on the bank limiter (Kamino and
+ * Solend the redeemed liquidity, Drift `token_amount`, JupLend `native_outflow`), except STAKED
+ * banks, which record the LST amount — multiplied here by the LST→SOL rate to reach the SDK's
+ * SOL-equivalent space.
+ *
+ * @returns The window with the least remaining capacity, or `null` when the bank has no rate
+ * limiter enabled
+ */
+declare function computeBankOutflowRateLimit(bank: BankType, assetShareValueMultiplier?: BigNumber$1): BankOutflowRateLimit | null;
 /**
  * Configuration for computing maximum withdraw amount for a bank
  */
@@ -2656,6 +2834,25 @@ declare function isWholePosition(position: {
     amount: number;
     isLending: boolean;
 }, amount: number, mintDecimals: number): boolean;
+/**
+ * Whether a position in `bank` counts toward the program's per-account limit on integration
+ * (Kamino, Drift, Solend, JupLend) and staked positions.
+ *
+ * @param bank - The bank to check
+ * @returns True for integration and staked banks
+ */
+declare function isCostlyBank(bank: BankType): boolean;
+/**
+ * Whether depositing into `bank` opens a position past the program's limit of
+ * {@link MAX_COSTLY_POSITIONS} integration and staked positions. Topping up an existing position
+ * never does.
+ *
+ * @param balances - The account's balances before the deposit
+ * @param bankMap - Map of bank addresses to bank data
+ * @param bank - The bank deposited into
+ * @returns True when the program would reject the deposit (6073)
+ */
+declare function exceedsCostlyPositionLimit(balances: BalanceType[], bankMap: Map<string, BankType>, bank: BankType): boolean;
 
 /**
  * Synchronous flashloan TX size estimator.
@@ -2968,6 +3165,7 @@ declare function makeCloseMarginfiAccountTx({ connection, program, marginfiAccou
  *   wallet adapter; a `Keypair` is a separate fee payer that signs directly.
  *   Defaults to the account's current authority.
  * @returns Versioned transaction to transfer the account
+ * @throws TransactionBuildingError (ACCOUNT_DISABLED) when the account is disabled, e.g. already transferred
  */
 declare function makeAccountTransferToNewAccountTx({ connection, program, marginfiAccount, newMarginfiAccount, newAuthority, feePayer, }: MakeAccountTransferToNewAccountTxParams): Promise<ExtendedV0Transaction>;
 /**
@@ -3028,6 +3226,9 @@ declare function makePulseHealthIx(program: MarginfiProgram, marginfiAccount: Ma
  * rewrites the account's variable borrow premium rates from its collateral after the action.
  * See {@link needsPremiumRefresh} for when it's needed.
  *
+ * Best-effort: returns no instructions when a bank to refresh has no venue state in
+ * `bankMetadataMap`, since `pulse_health` skips the premium write when a leg can't be priced.
+ *
  * @param program - The Marginfi program instance
  * @param state - The account (before the action), bank map and venue state
  * @param mandatoryBanks - Banks the action opens (the deposited bank)
@@ -3035,6 +3236,31 @@ declare function makePulseHealthIx(program: MarginfiProgram, marginfiAccount: Ma
  * @returns Instructions to append after the action
  */
 declare function makePremiumRefreshIxs(program: MarginfiProgram, { marginfiAccount, bankMap, bankMetadataMap }: PremiumRefreshParams, mandatoryBanks: PublicKey[], excludedBanks: PublicKey[]): Promise<TransactionInstruction[]>;
+/**
+ * Appends the premium refresh ({@link makePremiumRefreshIxs}) to a deposit or repay that lands in
+ * one transaction, and picks the lookup tables to compile it with. The refresh is left out when
+ * `opts.skipPremiumRefresh` is set, no premium-bearing debt remains, venue state is missing, or
+ * it would push the transaction past MAX_TX_SIZE / MAX_ACCOUNT_LOCKS.
+ *
+ * @param params - The builder's params: account (before the action), bank map, venue state,
+ * acted-on bank, authority and lookup tables
+ * @param actionIxs - The action's instructions
+ * @param mandatoryBanks - Banks the action opens (the deposited bank)
+ * @param excludedBanks - Banks the action closes (fully repaid banks)
+ * @returns The transaction's instructions and lookup tables
+ */
+declare function appendPremiumRefresh(params: PremiumRefreshParams & {
+    program: MarginfiProgram;
+    bank: BankType;
+    authority: PublicKey;
+    luts: AddressLookupTableAccount[];
+    opts?: {
+        skipPremiumRefresh?: boolean;
+    };
+}, actionIxs: TransactionInstruction[], mandatoryBanks: PublicKey[], excludedBanks: PublicKey[]): Promise<{
+    instructions: TransactionInstruction[];
+    luts: AddressLookupTableAccount[];
+}>;
 declare function generateDummyAccount(group: PublicKey, authority: PublicKey, accountKey: PublicKey): MarginfiAccountType;
 
 declare function makeDriftWithdrawIx({ program, bank, bankMap, tokenProgram, amount, marginfiAccount, driftSpotMarket, userRewards, authority, withdrawAll, isSync, opts, }: MakeDriftWithdrawIxParams): Promise<InstructionsWrapper>;
@@ -3469,6 +3695,8 @@ declare function makeRollPtTx(params: MakeRollPtTxParams): Promise<{
     transactions: ExtendedV0Transaction[];
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
+    /** true → send as ONE atomic Jito bundle (integration refreshes go stale within a slot) */
+    mustBeAtomicBundle: boolean;
 }>;
 
 /** A single built swap leg (its txs + the swap-engine quote). */
@@ -3627,11 +3855,55 @@ declare function makeTransferPositionsTx(params: MakeTransferPositionsTxParams):
 declare function makeBulkWithdrawTx(params: MakeBulkWithdrawTxParams): Promise<BulkLendTxsResult>;
 /**
  * Repay the FULL debt of every given bank from the wallet, packing as many
- * repays per transaction as fit. Repays carry no health pack and need no
- * oracle cranks, so most batches are a single transaction.
+ * repays per transaction as fit, followed by the premium refresh while
+ * premium-bearing debt remains. Most batches are a single transaction; one
+ * that splits with a premium refresh in it must land as one bundle.
  */
 declare function makeBulkRepayTx(params: MakeBulkRepayTxParams): Promise<BulkLendTxsResult>;
 
+/**
+ * Converts USD-equity thresholds into the on-chain `OrderTrigger` argument.
+ *
+ * @throws {TransactionBuildingError} `ORDER_INVALID_TRIGGER` if neither threshold is set, a
+ *   threshold is not above 0, or take-profit ≤ stop-loss; `ORDER_INVALID_SLIPPAGE` via
+ *   {@link percentToMaxSlippageU32}
+ */
+declare function buildOrderTrigger(params: OrderTriggerParams): OrderTrigger;
+/**
+ * Creates the instruction that places a take-profit / stop-loss order on a collateral/debt pair.
+ * The order PDA is derived from the pair, so placing a second order on the same pair fails;
+ * use {@link makeUpdateOrderTx} to change an existing order.
+ *
+ * The account must already hold (or, when bundled after a borrow/loop, will hold) an asset
+ * balance in `collateralBank` and a liability balance in `debtBank`. The flat anti-spam fee from
+ * the program's fee state is charged to `feePayer`.
+ */
+declare function makePlaceOrderIx(params: MakePlaceOrderIxParams): Promise<InstructionsWrapper>;
+/**
+ * Creates the instruction that closes an order and returns its rent to `feeRecipient`.
+ */
+declare function makeCloseOrderIx(params: MakeCloseOrderIxParams): Promise<InstructionsWrapper>;
+/**
+ * Builds a transaction that places a new order on a collateral/debt pair.
+ *
+ * @see {@link makePlaceOrderIx}
+ */
+declare function makePlaceOrderTx(params: MakePlaceOrderTxParams): Promise<ExtendedV0Transaction>;
+/**
+ * Builds a transaction that closes an existing order.
+ *
+ * @see {@link makeCloseOrderIx}
+ */
+declare function makeCloseOrderTx(params: MakeCloseOrderTxParams): Promise<ExtendedV0Transaction>;
+/**
+ * Builds a transaction that replaces the pair's existing order with new thresholds.
+ *
+ * There is no update instruction on-chain: the existing order (same PDA) is closed and re-placed
+ * in one transaction. Balance tags are preserved across the close, so other orders sharing a
+ * balance are unaffected. The flat anti-spam fee is charged again.
+ */
+declare function makeUpdateOrderTx(params: MakePlaceOrderTxParams): Promise<ExtendedV0Transaction>;
+
 /**
  * Creates instructions to refresh Kamino lending protocol reserves and obligations.
  *
@@ -3644,6 +3916,7 @@ declare function makeBulkRepayTx(params: MakeBulkRepayTxParams): Promise<BulkLen
  * @param newBanksPk - Public keys of new banks being added to the account
  * @param bankMetadataMap - Map containing Bank-specific metadata (reserve states, lending markets)
  * @returns InstructionsWrapper containing refresh reserve and obligation instructions
+ * @throws TransactionBuildingError (KAMINO_RESERVE_NOT_FOUND) when a Kamino bank has no reserve state in `bankMetadataMap`
  */
 declare function makeRefreshKaminoBanksIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, newBanksPk: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap): InstructionsWrapper;
 
@@ -3660,6 +3933,7 @@ declare function makeRefreshKaminoBanksIxs(marginfiAccount: MarginfiAccountType,
  * @param banksToExclude - Public keys of banks to exclude from the update
  * @param bankMetadataMap - Map containing Bank-specific metadata (Drift spot market states)
  * @returns InstructionsWrapper containing Drift spot market update instructions
+ * @throws TransactionBuildingError (DRIFT_STATE_NOT_FOUND) when a Drift bank has no spot market state in `bankMetadataMap`
  */
 declare function makeUpdateDriftMarketIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, banksToExclude: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap): InstructionsWrapper;
 
@@ -3679,6 +3953,7 @@ declare function makeUpdateDriftMarketIxs(marginfiAccount: MarginfiAccountType,
  * @param banksToExclude - Public keys of banks to exclude from the update
  * @param bankMetadataMap - Map containing Bank-specific metadata (JupLend lending states)
  * @returns InstructionsWrapper containing update_rate instructions
+ * @throws TransactionBuildingError (JUPLEND_STATE_NOT_FOUND) when a JupLend bank has no lending state in `bankMetadataMap`
  */
 declare function makeUpdateJupLendRateIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, banksToExclude: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap): InstructionsWrapper;
 
@@ -3696,6 +3971,7 @@ declare function makeUpdateJupLendRateIxs(marginfiAccount: MarginfiAccountType,
  * @param bankMetadataMap - Map containing Bank-specific metadata (integration states)
  * @param kaminoNewBanksPk - Banks to union into the Kamino refresh set, defaults to `banksToExclude`
  * @returns InstructionsWrapper with instructions ordered kamino -> drift -> juplend
+ * @throws TransactionBuildingError (KAMINO_RESERVE_NOT_FOUND, DRIFT_STATE_NOT_FOUND, JUPLEND_STATE_NOT_FOUND) when a bank to refresh has no venue state in `bankMetadataMap`
  */
 declare function makeRefreshIntegrationBanksIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, banksToExclude: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap, kaminoNewBanksPk?: PublicKey[]): InstructionsWrapper;
 
@@ -3987,7 +4263,8 @@ interface MakeKaminoDepositIxParams {
  * Account state the deposit and repay transaction builders use to add `pulse_health` after the
  * action while the account has premium-bearing debt, so the program rewrites its variable borrow
  * premium rates as the transaction lands (deposits and repays don't refresh them on their own).
- * Opt out with `opts.skipPremiumRefresh`.
+ * Opt out with `opts.skipPremiumRefresh`. The single-transaction builders leave it out when it
+ * doesn't fit next to the action.
  */
 interface PremiumRefreshParams {
     /** The account before the action */
@@ -4107,14 +4384,14 @@ interface MakeWithdrawIxParams {
 interface MakeWithdrawTxParams extends MakeWithdrawIxParams {
     connection: Connection;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     luts: AddressLookupTableAccount[];
 }
 interface MakeKaminoWithdrawTxParams extends Omit<MakeKaminoWithdrawIxParams, "cTokenAmount"> {
     amount: Amount | TypedAmount;
     connection: Connection;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     luts: AddressLookupTableAccount[];
 }
 interface MakeBorrowIxOpts {
@@ -4146,20 +4423,20 @@ interface MakeBorrowIxParams {
 interface MakeBorrowTxParams extends MakeBorrowIxParams {
     connection: Connection;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     bankMetadataMap: BankIntegrationMetadataMap;
     luts: AddressLookupTableAccount[];
 }
 interface MakeJuplendWithdrawTxParams extends MakeJuplendWithdrawIxParams {
     connection: Connection;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     luts: AddressLookupTableAccount[];
 }
 interface MakeDriftWithdrawTxParams extends MakeDriftWithdrawIxParams {
     connection: Connection;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     luts: AddressLookupTableAccount[];
 }
 interface MakeCloseAccountIxParams {
@@ -4220,7 +4497,7 @@ interface MakeTransferPositionsTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     /** Token program per transferred bank (base58 bank address → token program id). */
     tokenProgramsByBank: Map<string, PublicKey>;
     addressLookupTableAccounts?: AddressLookupTableAccount[];
@@ -4254,7 +4531,7 @@ interface MakeBulkWithdrawTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     /** Token program per withdrawn bank (base58 bank address → token program id). */
     tokenProgramsByBank: Map<string, PublicKey>;
     luts: AddressLookupTableAccount[];
@@ -4297,7 +4574,7 @@ interface MakeLoopTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     depositOpts: {
         inputDepositAmount: number;
         depositBank: BankType;
@@ -4358,7 +4635,7 @@ interface MakeRepayWithCollatTxParams {
     connection: Connection;
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     bankMetadataMap: BankIntegrationMetadataMap;
     withdrawOpts: {
         totalPositionAmount: number;
@@ -4389,7 +4666,7 @@ interface MakeSwapCollateralTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     withdrawOpts: {
         totalPositionAmount: number;
         withdrawAmount?: number;
@@ -4430,7 +4707,7 @@ interface MakeRollPtTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     withdrawOpts: {
         totalPositionAmount: number;
         withdrawAmount?: number;
@@ -4514,7 +4791,7 @@ interface MakeSwapDebtTxParams {
     bankMap: Map<string, BankType>;
     oraclePrices: Map<string, OraclePrice>;
     bankMetadataMap: BankIntegrationMetadataMap;
-    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
     repayOpts: {
         totalPositionAmount: number;
         repayAmount?: number;
@@ -4545,6 +4822,50 @@ interface MakeSetupIxParams {
         tokenProgram: PublicKey;
     }[];
 }
+/**
+ * Trigger thresholds for a take-profit / stop-loss order. Thresholds are the pair's net equity in
+ * USD (collateral value − debt value of the two tagged balances), not a token price. At least one
+ * of `stopLossUsd` / `takeProfitUsd` must be set; both makes a `Both` order.
+ */
+interface OrderTriggerParams {
+    /** Pair net equity (USD) at or below which the stop-loss fires. */
+    stopLossUsd?: BigNumber$1;
+    /** Pair net equity (USD) at or above which the take-profit fires. */
+    takeProfitUsd?: BigNumber$1;
+    /** Max slippage the keeper may incur when executing, in percent (protocol cap: 10). */
+    maxSlippagePercent: number;
+}
+interface MakePlaceOrderIxParams {
+    program: MarginfiProgram;
+    marginfiAccount: MarginfiAccountType;
+    /** Bank of the asset-side (collateral) balance. */
+    collateralBank: PublicKey;
+    /** Bank of the liability-side (debt) balance. */
+    debtBank: PublicKey;
+    trigger: OrderTriggerParams;
+    /** Pays the order rent and the flat anti-spam fee. Defaults to the account authority. */
+    feePayer?: PublicKey;
+    /** Global fee wallet from the program's `FeeState`; fetched from chain when omitted. */
+    globalFeeWallet?: PublicKey;
+}
+interface MakePlaceOrderTxParams extends MakePlaceOrderIxParams {
+    connection: Connection;
+    luts: AddressLookupTableAccount[];
+    blockhash?: string;
+}
+interface MakeCloseOrderIxParams {
+    program: MarginfiProgram;
+    marginfiAccount: MarginfiAccountType;
+    /** The order PDA to close (see `deriveOrderPda`). */
+    order: PublicKey;
+    /** Receives the order's rent. Defaults to the account authority. */
+    feeRecipient?: PublicKey;
+}
+interface MakeCloseOrderTxParams extends MakeCloseOrderIxParams {
+    connection: Connection;
+    luts: AddressLookupTableAccount[];
+    blockhash?: string;
+}
 
 /**
  * Vault PDA Utilities
@@ -5260,6 +5581,17 @@ declare function getKaminoMetadata(options: FetchKaminoMetadataOptions): Promise
 declare function getKaminoStatesDto(connection: Connection, kaminoBanks: KaminoBankInput[]): Promise<KaminoStateJsonByBank>;
 
 declare function getKaminoCTokenMultiplier(reserve: KaminoReserve): BigNumber$1;
+/**
+ * Joins a Kamino bank with its reserve's emergency mode. Decoding a bank or converting its DTO
+ * only sees the market's emergency (bank flags bit 14), so call this wherever a Kamino bank meets
+ * its reserve; otherwise initial health, max borrow and max withdraw overstate borrowing power
+ * while the reserve is in emergency.
+ *
+ * @param bank - The Kamino bank
+ * @param reserve - The bank's Kamino reserve
+ * @returns The bank, with `kaminoEmergency` also set when the reserve is in emergency mode
+ */
+declare function withKaminoReserveEmergency(bank: BankType, reserve: KaminoReserve): BankType;
 
 type DriftStateJsonByBank = Record<string, {
     driftSpotMarketState: DriftSpotMarketJSON;
@@ -5430,7 +5762,11 @@ declare enum TransactionBuildingErrorCode {
     TRANSFER_POSITIONS_INVALID_SELECTION = "TRANSFER_POSITIONS_INVALID_SELECTION",
     TRANSFER_POSITIONS_UNSUPPORTED_BANK = "TRANSFER_POSITIONS_UNSUPPORTED_BANK",
     TRANSFER_POSITIONS_UNSPLITTABLE = "TRANSFER_POSITIONS_UNSPLITTABLE",
-    BRIDGE_CONFLICT = "BRIDGE_CONFLICT"
+    BRIDGE_CONFLICT = "BRIDGE_CONFLICT",
+    ORDER_INVALID_TRIGGER = "ORDER_INVALID_TRIGGER",
+    ORDER_INVALID_SLIPPAGE = "ORDER_INVALID_SLIPPAGE",
+    COSTLY_POSITION_LIMIT_EXCEEDED = "COSTLY_POSITION_LIMIT_EXCEEDED",
+    ACCOUNT_DISABLED = "ACCOUNT_DISABLED"
 }
 /**
  * Typed details for each error code
@@ -5510,6 +5846,24 @@ interface TransactionBuildingErrorDetails {
         /** Whether the bridge token would have been held as collateral ("deposit") or debt ("borrow"). */
         bridgeTokenSide: "deposit" | "borrow";
     };
+    [TransactionBuildingErrorCode.ORDER_INVALID_TRIGGER]: {
+        reason: string;
+        takeProfitUsd?: string;
+        stopLossUsd?: string;
+    };
+    [TransactionBuildingErrorCode.ORDER_INVALID_SLIPPAGE]: {
+        maxSlippagePercent: number;
+        maxAllowedPercent: number;
+    };
+    [TransactionBuildingErrorCode.COSTLY_POSITION_LIMIT_EXCEEDED]: {
+        /** Integration/staked bank the action would open a position in */
+        bankAddress: string;
+        /** Max integration + staked positions per account */
+        limit: number;
+    };
+    [TransactionBuildingErrorCode.ACCOUNT_DISABLED]: {
+        accountAddress: string;
+    };
 }
 /**
  * Error thrown during transaction building in the SDK.
@@ -5579,6 +5933,25 @@ declare class TransactionBuildingError<T extends TransactionBuildingErrorCode =
         mint: string;
         symbol?: string;
     }>, bridgeTokenSide: "deposit" | "borrow"): TransactionBuildingError<TransactionBuildingErrorCode.BRIDGE_CONFLICT>;
+    /**
+     * 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: string, takeProfitUsd?: string, stopLossUsd?: string): TransactionBuildingError<TransactionBuildingErrorCode.ORDER_INVALID_TRIGGER>;
+    /**
+     * The action would open an integration (Kamino, Drift, Solend, JupLend) or staked position
+     * beyond the per-account limit on such positions.
+     */
+    static costlyPositionLimitExceeded(bankAddress: string): TransactionBuildingError<TransactionBuildingErrorCode.COSTLY_POSITION_LIMIT_EXCEEDED>;
+    /**
+     * 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: number, maxAllowedPercent: number): TransactionBuildingError<TransactionBuildingErrorCode.ORDER_INVALID_SLIPPAGE>;
+    /**
+     * The marginfi account is disabled (e.g. already transferred to a new account), so it can't act.
+     */
+    static accountDisabled(accountAddress: string): TransactionBuildingError<TransactionBuildingErrorCode.ACCOUNT_DISABLED>;
     /**
      * Generic escape hatch for custom errors
      */
@@ -5613,6 +5986,7 @@ declare const PDA_BANK_FEE_STATE_SEED: Buffer<ArrayBuffer>;
 declare const PDA_BANK_EMISSIONS_AUTH_SEED: Buffer<ArrayBuffer>;
 declare const PDA_BANK_EMISSIONS_VAULT_SEED: Buffer<ArrayBuffer>;
 declare const PDA_MARGINFI_ACCOUNT_SEED: Buffer<ArrayBuffer>;
+declare const PDA_ORDER_SEED: Buffer<ArrayBuffer>;
 declare const PDA_REBALANCE_FEE_POOL_SEED: Buffer<ArrayBuffer>;
 /**
  * Derives the liquidity vault authority PDA for a bank
@@ -5664,6 +6038,14 @@ declare function deriveBankEmissionsVault(programId: PublicKey, bank: PublicKey,
  * Seeds: ["marginfi_account", group, authority, accountIndex, thirdPartyId]
  */
 declare function deriveMarginfiAccount(programId: PublicKey, group: PublicKey, authority: PublicKey, accountIndex: number, thirdPartyId?: number): [PublicKey, number];
+/**
+ * Derives the order PDA for a marginfi account and bank pair
+ * Seeds: ["order", marginfiAccount, sha256(bank keys sorted by raw bytes, concatenated)]
+ *
+ * Matches the on-chain `keys_sha256_hash`: the bank keys are sorted in ascending byte-wise
+ * lexicographical order before hashing, so the caller may pass them in any order.
+ */
+declare function deriveOrderPda(programId: PublicKey, marginfiAccount: PublicKey, bankKeys: PublicKey[]): [PublicKey, number];
 /**
  * Derives the auto-rebalance fee pool PDA of a marginfi account (required by account close since 0.1.12)
  * Seeds: ["rebalance_fee_pool", marginfiAccount]
@@ -5714,6 +6096,20 @@ declare function shortenAddress(pubkey: Address, chars?: number): string;
  * Converts basis points (bps) to a decimal percentage value.
  */
 declare function bpsToPercentile(bps: number): number;
+/**
+ * Converts a slippage tolerance in percent to the on-chain u32 representation
+ * (a fraction of `u32::MAX`, where 100% = `u32::MAX`).
+ *
+ * @param percent - Slippage in percent, must be in (0, 10] (protocol cap). The program accepts 0,
+ *   but a keeper can't execute an order that allows no slippage, so 0 is rejected.
+ * @throws {TransactionBuildingError} `ORDER_INVALID_SLIPPAGE` if `percent` is outside (0, 10]
+ */
+declare function percentToMaxSlippageU32(percent: number): number;
+/**
+ * Inverse of {@link percentToMaxSlippageU32}: converts the on-chain u32 slippage
+ * representation back to a percent value.
+ */
+declare function maxSlippageU32ToPercent(maxSlippage: number): number;
 /**
  * Prepares transaction remaining accounts by processing bank-oracle groups:
  * 1. Sorts groups in descending order by bank public key (pushes inactive accounts to end)
@@ -5748,6 +6144,10 @@ declare const STAKED_ORACLE_DISABLED_FLAG: number;
 declare const STAKED_ORACLE_USES_ONRAMP_FLAG: number;
 /** Bank flags bit 13: liabilities in this bank accrue the variable borrow premium */
 declare const PREMIUM_ACTIVE_FLAG: number;
+/** Bank flags bit 14: the Kamino bank's lending market is in emergency mode (zero initial weight) */
+declare const KAMINO_MARKET_EMERGENCY_FLAG: number;
+/** Max integration (Kamino, Drift, Solend, JupLend) + staked positions one account can open (0.1.12) */
+declare const MAX_COSTLY_POSITIONS = 4;
 declare const MARGINFI_PROGRAM: PublicKey;
 declare const MARGINFI_PROGRAM_STAGING: PublicKey;
 declare const MARGINFI_PROGRAM_STAGING_ALT: PublicKey;
@@ -5803,7 +6203,8 @@ declare class Balance implements BalanceType {
     premiumRate: BigNumber$1;
     premiumOutstanding: BigNumber$1;
     lastUpdate: number;
-    constructor(active: boolean, bankPk: PublicKey, assetShares: BigNumber$1, liabilityShares: BigNumber$1, premiumRate: BigNumber$1, premiumOutstanding: BigNumber$1, lastUpdate: number);
+    tag: number;
+    constructor(active: boolean, bankPk: PublicKey, assetShares: BigNumber$1, liabilityShares: BigNumber$1, premiumRate: BigNumber$1, premiumOutstanding: BigNumber$1, lastUpdate: number, tag: number);
     static from(balanceRaw: BalanceRaw): Balance;
     static fromBalanceType(balance: BalanceType): Balance;
     static createEmpty(bankPk: PublicKey): Balance;
@@ -5852,7 +6253,7 @@ declare class MarginfiGroup implements MarginfiGroupType {
     static fromBuffer(address: PublicKey, rawData: Buffer, idl: MarginfiIdlType): MarginfiGroup;
     static decode(encoded: Buffer, idl: MarginfiIdlType): MarginfiGroupRaw;
     static encode(decoded: MarginfiGroupRaw, idl: MarginfiIdlType): Promise<Buffer>;
-    makePoolConfigureBankIx(program: MarginfiProgram, bank: PublicKey, args: BankConfigOptRaw): Promise<InstructionsWrapper>;
+    makePoolConfigureBankIx(program: MarginfiProgram, bank: PublicKey, args: BankConfigFastRaw): Promise<InstructionsWrapper>;
     makeAddPermissionlessStakedBankIx(program: MarginfiProgram, voteAccountAddress: PublicKey, feePayer: PublicKey, pythOracle: PublicKey): Promise<InstructionsWrapper>;
     makePoolAddBankIx(program: MarginfiProgram, bankPubkey: PublicKey, bankMint: PublicKey, bankConfig: BankConfigOpt, feePayer?: PublicKey): Promise<InstructionsWrapper>;
 }
@@ -5881,7 +6282,8 @@ declare class MarginfiAccount implements MarginfiAccountType {
     readonly accountFlags: AccountFlags[];
     readonly emissionsDestinationAccount: PublicKey;
     healthCache: HealthCache;
-    constructor(address: PublicKey, group: PublicKey, authority: PublicKey, balances: Balance[], accountFlags: AccountFlags[], emissionsDestinationAccount: PublicKey, healthCache: HealthCache);
+    readonly activeOrders: number;
+    constructor(address: PublicKey, group: PublicKey, authority: PublicKey, balances: Balance[], accountFlags: AccountFlags[], emissionsDestinationAccount: PublicKey, healthCache: HealthCache, activeOrders?: number);
     /**
      * Fetches a marginfi account from on-chain data.
      *
@@ -6438,6 +6840,7 @@ declare class MarginfiAccount implements MarginfiAccountType {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a transaction to swap one debt position to another using a flash loan.
@@ -6510,6 +6913,36 @@ declare class MarginfiAccount implements MarginfiAccountType {
      * @see {@link makeBorrowTx} for detailed implementation
      */
     makeBorrowTx(params: Omit<MakeBorrowTxParams, "marginfiAccount">): Promise<TransactionBuilderResult>;
+    /**
+     * Creates a place-order instruction for this marginfi account.
+     *
+     * @see {@link makePlaceOrderIx} for detailed implementation
+     */
+    makePlaceOrderIx(params: Omit<MakePlaceOrderIxParams, "marginfiAccount">): Promise<InstructionsWrapper>;
+    /**
+     * Creates a transaction placing a take-profit / stop-loss order on a collateral/debt pair.
+     *
+     * @see {@link makePlaceOrderTx} for detailed implementation
+     */
+    makePlaceOrderTx(params: Omit<MakePlaceOrderTxParams, "marginfiAccount">): Promise<ExtendedV0Transaction>;
+    /**
+     * Creates a close-order instruction for this marginfi account.
+     *
+     * @see {@link makeCloseOrderIx} for detailed implementation
+     */
+    makeCloseOrderIx(params: Omit<MakeCloseOrderIxParams, "marginfiAccount">): Promise<InstructionsWrapper>;
+    /**
+     * Creates a transaction closing an existing order.
+     *
+     * @see {@link makeCloseOrderTx} for detailed implementation
+     */
+    makeCloseOrderTx(params: Omit<MakeCloseOrderTxParams, "marginfiAccount">): Promise<ExtendedV0Transaction>;
+    /**
+     * Creates a transaction replacing the pair's existing order with new thresholds.
+     *
+     * @see {@link makeUpdateOrderTx} for detailed implementation
+     */
+    makeUpdateOrderTx(params: Omit<MakePlaceOrderTxParams, "marginfiAccount">): Promise<ExtendedV0Transaction>;
     /**
      * Creates a repay transaction.
      *
@@ -6891,6 +7324,7 @@ declare class MarginfiAccountWrapper {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a swap debt transaction with auto-injected client data.
@@ -7002,6 +7436,38 @@ declare class MarginfiAccountWrapper {
      * @returns Promise resolving to a TransactionBuilderResult
      */
     makeBorrowTx(bankAddress: PublicKey, amount: Amount, opts?: MakeBorrowIxOpts): Promise<TransactionBuilderResult>;
+    /**
+     * 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
+     */
+    makePlaceOrderIx(collateralBank: PublicKey, debtBank: PublicKey, trigger: OrderTriggerParams): Promise<InstructionsWrapper>;
+    /**
+     * Creates a close-order instruction, for composing into a larger transaction.
+     *
+     * @param order - The order PDA (from `fetchOrdersForAccount` or `deriveOrderPda`)
+     */
+    makeCloseOrderIx(order: PublicKey): Promise<InstructionsWrapper>;
+    /**
+     * 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
+     */
+    makePlaceOrderTx(collateralBank: PublicKey, debtBank: PublicKey, trigger: OrderTriggerParams): Promise<ExtendedV0Transaction>;
+    /**
+     * Creates a transaction replacing the pair's existing order with new thresholds.
+     */
+    makeUpdateOrderTx(collateralBank: PublicKey, debtBank: PublicKey, trigger: OrderTriggerParams): Promise<ExtendedV0Transaction>;
+    /**
+     * Creates a transaction closing an existing order.
+     *
+     * @param order - The order PDA (from `fetchOrdersForAccount` or `deriveOrderPda`)
+     */
+    makeCloseOrderTx(order: PublicKey): Promise<ExtendedV0Transaction>;
     /**
      * Creates a repay transaction with auto-injected client data.
      *
@@ -7082,6 +7548,11 @@ declare class MarginfiAccountWrapper {
      * given its current collateral, by bank address. See {@link computePremiumRatesByBank}.
      */
     getPremiumRatesByBank(): Map<string, BigNumber$1>;
+    /**
+     * Per-collateral breakdown of the premium rate `liabilityBank` would charge this account.
+     * See {@link computePremiumBreakdown}.
+     */
+    getPremiumBreakdown(liabilityBank: PublicKey): PremiumCollateralBreakdown[];
     /**
      * How `actions` would change this account's premium rates and yearly premium.
      * See {@link computePremiumImpact}.
@@ -7186,4 +7657,4 @@ declare class MarginfiAccountWrapper {
     getClient(): Project0Client;
 }
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, type AccountActiveBalanceForBank, AccountFlags, ActionEmodeImpact, ActiveEmodePair, type ActiveStakePoolMap, Amount, AssetTag, BUNDLE_TX_SIZE, Balance, type BalanceRaw, BalanceType, type BalanceTypeDto, Bank, type BankConfigDto, BankConfigFlag, BankConfigOpt, BankConfigOptRaw, BankConfigRaw, type BankConfigRawDto, BankConfigType, BankIntegrationMetadata, BankIntegrationMetadataDto, BankIntegrationMetadataMap, BankIntegrationMetadataMapDto, type BankMetrics, type BankRateLimiterDto, BankRateLimiterRaw, type BankRateLimiterRawDto, BankRateLimiterType, BankRaw, type BankRawDto, BankType, type BankTypeDto, BankVaultType, type BankVenueStates, type BridgeOpts, type BridgeTokenSide, type BridgedSwapLeg, type BridgedTxResult, type BuildContext, type BulkLendTxsResult, type ClassifiedPosition, type ComposeBridgedSwapParams, type ComposeBridgedSwapResult, type ComputeAssetHealthComponentParams, type ComputeBalanceUsdValueParams, type ComputeBankMetricsParams, type ComputeFreeCollateralFromBalancesParams, type ComputeHealthCacheStatusParams, type ComputeHealthComponentsFromBalancesParams, type ComputeLiabilityHealthComponentParams, type ComputeLiquidationPriceForBankParams, type ComputeMaxBorrowForBankParams, type ComputeMaxDepositForBankParams, type ComputeMaxWithdrawForBankParams, type ComputeNetApyParams, type ComputePremiumRatesParams, ConfigRaw, DEFAULT_BRIDGE_MINTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, type DriftBankInput, type DriftMetadata, type DriftStateByBank, type DriftStateJsonByBank, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, type EmodeConfigRawDto, type EmodeEntryDto, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodePair, type EmodeSettingsDto, EmodeSettingsRaw, type EmodeSettingsRawDto, EmodeSettingsType, EmodeTag, Environment, type ExactOutEstimateResult, type ExtendedTransaction, type ExtendedTransactionProperties, type ExtendedV0Transaction, FLASHLOAN_ENABLED_FLAG, type FeeStateCache, type FetchBankIntegrationMetadataOptions, type FetchDriftMetadataOptions, type FetchJupLendMetadataOptions, type FetchKaminoMetadataOptions, type FlashloanActionResult, type FlashloanBudgetIx, type FlashloanPrecheckResult, type FlashloanSwapConstraints, type GetBalanceUsdValueWithPriceBiasParams, type GetExactOutEstimateParams, type GetSwapIxsForFlashloanParams, type GetTitanExactOutEstimateParams, type GetTitanSwapIxsParams, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, type HealthCacheRaw, HealthCacheSimulationError, HealthCacheStatus, HealthCacheType, type HealthCacheTypeDto, type InstructionsWrapper, type IntegrationType, InterestRateConfig, type InterestRateConfigDto, InterestRateConfigRaw, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, type JupLendBankInput, type JupLendMetadata, type JupLendStateByBank, type JupLendStateJsonByBank, type KaminoBankInput, type KaminoMetadata, type KaminoStateByBank, type KaminoStateJsonByBank, LST_MINT, type LoopFlashloanDescriptor, 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, type MakeAccountTransferToNewAccountTxParams, type MakeBorrowIxOpts, type MakeBorrowIxParams, type MakeBorrowTxParams, type MakeBridgedLoopTxParams, type MakeBridgedSwapCollateralTxParams, type MakeBridgedSwapDebtTxParams, type MakeBulkRepayTxParams, type MakeBulkWithdrawTxParams, type MakeCloseAccountIxParams, type MakeCloseAccountTxParams, type MakeDepositIxOpts, type MakeDepositIxParams, type MakeDepositTxParams, type MakeDriftDepositIxParams, type MakeDriftDepositTxParams, type MakeDriftWithdrawIxParams, type MakeDriftWithdrawTxParams, type MakeFlashLoanTxParams, type MakeJuplendDepositIxParams, type MakeJuplendDepositTxParams, type MakeJuplendWithdrawIxParams, type MakeJuplendWithdrawTxParams, type MakeKaminoDepositIxParams, type MakeKaminoDepositTxParams, type MakeKaminoWithdrawIxParams, type MakeKaminoWithdrawTxParams, type MakeLoopTxParams, type MakeMergeStakeAccountsTxParams, type MakeMintStakedLstIxParams, type MakeMintStakedLstTxParams, type MakeRedeemStakedLstIxParams, type MakeRedeemStakedLstTxParams, type MakeRepayIxOpts, type MakeRepayIxParams, type MakeRepayTxParams, type MakeRepayWithCollatTxParams, type MakeRollPtTxParams, type MakeSetupIxParams, type MakeSwapCollateralTxParams, type MakeSwapDebtTxParams, type MakeTransferPositionsTxParams, type MakeVaultCompleteWithdrawalIxParams, type MakeVaultCompleteWithdrawalTxParams, type MakeVaultDepositIxParams, type MakeVaultDepositTxParams, type MakeVaultDepositWithSwapTxParams, type MakeVaultWithdrawIxParams, type MakeVaultWithdrawTxParams, type MakeWithdrawIxOpts, type MakeWithdrawIxParams, type MakeWithdrawTxParams, MarginRequirementType, type MarginRequirementTypeRaw, MarginfiAccount, type MarginfiAccountRaw, MarginfiAccountType, type MarginfiAccountTypeDto, MarginfiAccountWrapper, MarginfiGroup, type MarginfiGroupRaw, type MarginfiGroupType, type MarginfiGroupTypeDto, MarginfiIdlType, MarginfiProgram, type MintAuthorityBalance, MintData, type MultiplierAccountState, type MultiplierAccountStates, OperationalState, OperationalStateRaw, type OracleMultiplierBankInput, type OracleMultiplierServiceOpts, OraclePrice, OraclePriceDto, OracleSetup, OracleSetupRaw, type OracleSourceKey, 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_REBALANCE_FEE_POOL_SEED, PREMIUM_ACTIVE_FLAG, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, type PanicStateCache, type PremiumAction, type PremiumEntry, type PremiumImpact, type PremiumRefreshParams, PriceBias, PriceWithConfidence, Project0Client, Project0Config, Project0ConfigRaw, type ProviderSwapRoute, type PythOracleServiceOpts, type RateLimitWindowDto, type RateLimitWindowRawDto, RateLimitWindowType, type RatePointDto, type ResolveBridgeCandidateBanksParams, type ResolvedPinnedSwapRoute, RiskTier, RiskTierRaw, type RollPtOpts, type RollQuoteSimResult, type RollQuoteSimulator, type RollQuoteTokenBalance, 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, type ScopeOracleServiceOpts, type SerializedInstruction, type SerializedLut, type SerializedSwapEngineRequest, type SerializedSwapEngineResult, type SerializedTxFootprint, type SharedBridgeLegContext, type SimulateAccountHealthCacheWithFallbackParams, type SimulationResultRaw, type SolanaTransaction, type StakeAccount, type StakePoolMevMap, type StakedBankMetadata, type SwapAdapter, type SwapApiConfig, type SwapCandidate, type SwapEngineRequest, type SwapEngineResult, type SwapEngineRunner, type SwapIxsResult, type SwapOpts, SwapProvider, type SwapProviderConfig, type SwapProviderEntry, type SwapQuoteResult, TRANSFER_ACCOUNT_AUTHORITY_FLAG, type TitanQuoteParams, TransactionArenaKeyMap, type TransactionBuilderResult, TransactionBuildingError, TransactionBuildingErrorCode, type TransactionBuildingErrorDetails, TransactionConfigMap, TransactionType, type TransferPositionSide, type TransferPositionsResult, type TxFootprint, TypedAmount, U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, type ValidatorRateData, type ValidatorStakeGroup, type ValidatorStakeGroupDto, WSOL_MINT, type WithdrawWindowCache, WrappedI80F48, 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, computeBalancePremium, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiquidationPriceForBank, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxWithdrawForBank, computeNetApy, computeOracleMultiplier, computeOracleMultipliers, computePremiumImpact, computePremiumRatesByBank, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computePtMultiplier, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeStakedBankMultipliers, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, configureScopeOracleIx, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decodeMultiplierAccount, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deriveRebalanceFeePool, 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, 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, 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, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx, makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx, makeDepositTx, makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx, makePoolConfigureBankIx, makePremiumRefreshIxs, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, needsPremiumRefresh, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, patchDepositAmount, rateFromU32, requireBank, requireTokenProgram, 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, type AccountActiveBalanceForBank, AccountFlags, ActionEmodeImpact, ActiveEmodePair, type ActiveStakePoolMap, Amount, AssetTag, BUNDLE_TX_SIZE, Balance, type BalanceRaw, BalanceType, type BalanceTypeDto, Bank, type BankConfigDto, BankConfigFastRaw, BankConfigFlag, BankConfigGovRaw, BankConfigOpt, BankConfigOptRaw, BankConfigRaw, type BankConfigRawDto, BankConfigType, BankIntegrationMetadata, BankIntegrationMetadataDto, BankIntegrationMetadataMap, BankIntegrationMetadataMapDto, type BankMetrics, type BankOutflowRateLimit, type BankRateLimiterDto, BankRateLimiterRaw, type BankRateLimiterRawDto, BankRateLimiterType, BankRaw, type BankRawDto, BankType, type BankTypeDto, BankVaultType, type BankVenueStates, type BridgeOpts, type BridgeTokenSide, type BridgedSwapLeg, type BridgedTxResult, type BuildContext, type BulkLendTxsResult, type ClassifiedPosition, type ComposeBridgedSwapParams, type ComposeBridgedSwapResult, type ComputeAssetHealthComponentParams, type ComputeBalanceUsdValueParams, type ComputeBankMetricsParams, type ComputeFreeCollateralFromBalancesParams, type ComputeHealthCacheStatusParams, type ComputeHealthComponentsFromBalancesParams, type ComputeLiabilityHealthComponentParams, type ComputeLiquidationPriceForBankParams, type ComputeMaxBorrowForBankParams, type ComputeMaxDepositForBankParams, type ComputeMaxWithdrawForBankParams, type ComputeNetApyParams, type ComputePremiumRatesParams, ConfigRaw, DEFAULT_BRIDGE_MINTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, type DriftBankInput, type DriftMetadata, type DriftStateByBank, type DriftStateJsonByBank, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, type EmodeConfigRawDto, type EmodeEntryDto, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodePair, type EmodeSettingsDto, EmodeSettingsRaw, type EmodeSettingsRawDto, EmodeSettingsType, EmodeTag, Environment, type ExactOutEstimateResult, type ExtendedTransaction, type ExtendedTransactionProperties, type ExtendedV0Transaction, FLASHLOAN_ENABLED_FLAG, type FeeStateCache, type FetchBankIntegrationMetadataOptions, type FetchDriftMetadataOptions, type FetchJupLendMetadataOptions, type FetchKaminoMetadataOptions, type FlashloanActionResult, type FlashloanBudgetIx, type FlashloanPrecheckResult, type FlashloanSwapConstraints, type GetBalanceUsdValueWithPriceBiasParams, type GetExactOutEstimateParams, type GetSwapIxsForFlashloanParams, type GetTitanExactOutEstimateParams, type GetTitanSwapIxsParams, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, type HealthCacheRaw, HealthCacheSimulationError, HealthCacheStatus, HealthCacheType, type HealthCacheTypeDto, type InstructionsWrapper, type IntegrationType, InterestRateConfig, type InterestRateConfigDto, InterestRateConfigRaw, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, type JupLendBankInput, type JupLendMetadata, type JupLendStateByBank, type JupLendStateJsonByBank, KAMINO_MARKET_EMERGENCY_FLAG, type KaminoBankInput, type KaminoMetadata, type KaminoStateByBank, type KaminoStateJsonByBank, LST_MINT, type LoopFlashloanDescriptor, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_COSTLY_POSITIONS, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, type MakeAccountTransferToNewAccountTxParams, type MakeBorrowIxOpts, type MakeBorrowIxParams, type MakeBorrowTxParams, type MakeBridgedLoopTxParams, type MakeBridgedSwapCollateralTxParams, type MakeBridgedSwapDebtTxParams, type MakeBulkRepayTxParams, type MakeBulkWithdrawTxParams, type MakeCloseAccountIxParams, type MakeCloseAccountTxParams, type MakeCloseOrderIxParams, type MakeCloseOrderTxParams, type MakeDepositIxOpts, type MakeDepositIxParams, type MakeDepositTxParams, type MakeDriftDepositIxParams, type MakeDriftDepositTxParams, type MakeDriftWithdrawIxParams, type MakeDriftWithdrawTxParams, type MakeFlashLoanTxParams, type MakeJuplendDepositIxParams, type MakeJuplendDepositTxParams, type MakeJuplendWithdrawIxParams, type MakeJuplendWithdrawTxParams, type MakeKaminoDepositIxParams, type MakeKaminoDepositTxParams, type MakeKaminoWithdrawIxParams, type MakeKaminoWithdrawTxParams, type MakeLoopTxParams, type MakeMergeStakeAccountsTxParams, type MakeMintStakedLstIxParams, type MakeMintStakedLstTxParams, type MakePlaceOrderIxParams, type MakePlaceOrderTxParams, type MakeRedeemStakedLstIxParams, type MakeRedeemStakedLstTxParams, type MakeRepayIxOpts, type MakeRepayIxParams, type MakeRepayTxParams, type MakeRepayWithCollatTxParams, type MakeRollPtTxParams, type MakeSetupIxParams, type MakeSwapCollateralTxParams, type MakeSwapDebtTxParams, type MakeTransferPositionsTxParams, type MakeVaultCompleteWithdrawalIxParams, type MakeVaultCompleteWithdrawalTxParams, type MakeVaultDepositIxParams, type MakeVaultDepositTxParams, type MakeVaultDepositWithSwapTxParams, type MakeVaultWithdrawIxParams, type MakeVaultWithdrawTxParams, type MakeWithdrawIxOpts, type MakeWithdrawIxParams, type MakeWithdrawTxParams, MarginRequirementType, type MarginRequirementTypeRaw, MarginfiAccount, type MarginfiAccountRaw, MarginfiAccountType, type MarginfiAccountTypeDto, MarginfiAccountWrapper, MarginfiGroup, type MarginfiGroupRaw, type MarginfiGroupType, type MarginfiGroupTypeDto, MarginfiIdlType, MarginfiProgram, type MintAuthorityBalance, MintData, type MultiplierAccountState, type MultiplierAccountStates, OperationalState, OperationalStateRaw, type OracleMultiplierBankInput, type OracleMultiplierServiceOpts, OraclePrice, OraclePriceDto, OracleSetup, OracleSetupRaw, type OracleSourceKey, type OrderRaw, OrderTrigger, type OrderTriggerParams, type OrderTriggerTypeRaw, OrderType, 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, PDA_REBALANCE_FEE_POOL_SEED, PREMIUM_ACTIVE_FLAG, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, type PanicStateCache, type PremiumAction, type PremiumCollateralBreakdown, type PremiumEntry, type PremiumImpact, type PremiumRefreshParams, PriceBias, PriceWithConfidence, Project0Client, Project0Config, Project0ConfigRaw, type ProviderSwapRoute, type PythOracleServiceOpts, type RateLimitWindowDto, type RateLimitWindowRawDto, RateLimitWindowType, type RatePointDto, type ResolveBridgeCandidateBanksParams, type ResolvedPinnedSwapRoute, RiskTier, RiskTierRaw, type RollPtOpts, type RollQuoteSimResult, type RollQuoteSimulator, type RollQuoteTokenBalance, 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, type ScopeOracleServiceOpts, type SerializedInstruction, type SerializedLut, type SerializedSwapEngineRequest, type SerializedSwapEngineResult, type SerializedTxFootprint, type SharedBridgeLegContext, type SimulateAccountHealthCacheWithFallbackParams, type SimulationResultRaw, type SolanaTransaction, type StakeAccount, type StakePoolMevMap, type StakedBankMetadata, type SwapAdapter, type SwapApiConfig, type SwapCandidate, type SwapEngineRequest, type SwapEngineResult, type SwapEngineRunner, type SwapIxsResult, type SwapOpts, SwapProvider, type SwapProviderConfig, type SwapProviderEntry, type SwapQuoteResult, TRANSFER_ACCOUNT_AUTHORITY_FLAG, type TitanQuoteParams, TransactionArenaKeyMap, type TransactionBuilderResult, TransactionBuildingError, TransactionBuildingErrorCode, type TransactionBuildingErrorDetails, TransactionConfigMap, TransactionType, type TransferPositionSide, type TransferPositionsResult, type TxFootprint, TypedAmount, U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, type ValidatorRateData, type ValidatorStakeGroup, type ValidatorStakeGroupDto, WSOL_MINT, type WithdrawWindowCache, WrappedI80F48, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, appendPremiumRefresh, 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, computeBalancePremium, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankOutflowRateLimit, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiquidationPriceForBank, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxWithdrawForBank, computeNetApy, computeOracleMultiplier, computeOracleMultipliers, computeOrderPairNetValue, computePremiumBreakdown, computePremiumImpact, computePremiumRatesByBank, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computePtMultiplier, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeStakedBankMultipliers, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, configureScopeOracleIx, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decodeMultiplierAccount, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deriveOrderPda, deriveRebalanceFeePool, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, exceedsCostlyPositionLimit, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchGammaLpVault, fetchGammaWithdrawReceipt, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchMultiplierAccountStates, fetchMultiplierAccountStatesFromAPI, fetchNativeStakeAccounts, fetchOracleData, fetchOracleMultipliers, fetchOracleMultipliersFromAPI, fetchOracleMultipliersFromChain, fetchOrderFees, fetchOrdersForAccount, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchScopeOracleData, fetchScopeOraclePricesFromAPI, fetchScopeOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, findRandomAvailableAccountIndex, fitsInOneTransaction, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, 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, 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, isCostlyBank, isDecomposableSwapError, isDepositIx, isDepositLimitActive, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx, makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCloseOrderIx, makeCloseOrderTx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx, makeDepositTx, makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePlaceOrderIx, makePlaceOrderTx, makePoolAddBankIx, makePoolConfigureBankGovIx, makePoolConfigureBankIx, makePreludeTxs, makePremiumRefreshIxs, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateOrderTx, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, marginfiAccountToDto, maxSlippageU32ToPercent, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, needsPremiumRefresh, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOrderRaw, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, patchDepositAmount, percentToMaxSlippageU32, rateFromU32, requireBank, requireTokenProgram, resolveBridgeCandidateBanks, 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, withKaminoReserveEmergency, wrappedI80F48toBigNumber };