@0dotxyz/p0-ts-sdk 2.5.5-alpha.3 → 2.5.5-alpha.5

package/dist/index.d.cts

@@ -136,12 +136,17 @@ declare function isFlashloan(tx: SolanaTransaction): boolean;
 declare function makeVersionedTransaction(blockhash: Blockhash, transaction: Transaction, payer: PublicKey, addressLookupTables?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
 /**
  * Splits your instructions into as many VersionedTransactions as needed
- * so that none exceed MAX_TX_SIZE.
+ * so that none exceed MAX_TX_SIZE (minus `sizeMargin`, if given) nor
+ * `maxAccountLocks` account locks (if given).
  */
 declare function splitInstructionsToFitTransactions(mandatoryIxs: TransactionInstruction[], ixs: TransactionInstruction[], opts: {
     blockhash: string;
     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 per transaction (e.g. MAX_ACCOUNT_LOCKS). */
+    maxAccountLocks?: number;
 }): VersionedTransaction[];
 /**
  * Enhances a given transaction with additional metadata.
@@ -1269,9 +1274,7 @@ interface MakeBulkWithdrawTxParams {
     assetShareValueMultiplierByBank: Map<string, BigNumber>;
     /** Token program per withdrawn bank (base58 bank address → token program id). */
     tokenProgramsByBank: Map<string, PublicKey>;
-    addressLookupTableAccounts?: AddressLookupTableAccount[];
-    /** Whether the group USD rate limiter is enabled (adds an oracle to each withdraw). Default false. */
-    groupRateLimiterEnabled?: boolean;
+    luts: AddressLookupTableAccount[];
     crossbarUrl?: string;
     overrideInferAccounts?: {
         group?: PublicKey;
@@ -2578,7 +2581,7 @@ declare function computeTotalOutstandingEmissions(balance: BalanceType, bank: Ba
  * - Including all active banks (excluding any in the exclusion list)
  * - Reserving inactive slots for mandatory banks that aren't currently active
  *
- * @param balances - Current account balances
+ * @param account - The marginfi account whose balances are evaluated
  * @param banksMap - Map of bank addresses to bank data
  * @param mandatoryBanks - Banks that must be included (e.g., for pending transactions)
  * @param excludedBanks - Banks to exclude from health checks
@@ -2586,15 +2589,20 @@ declare function computeTotalOutstandingEmissions(balance: BalanceType, bank: Ba
  *
  * @example
  * ```typescript
- * const healthCheckBanks = computeHealthCheckAccounts(
- *   account.balances,
+ * const healthCheckBanks = computeHealthCheckAccounts({
+ *   account,
  *   banksMap,
- *   [newBankToDeposit], // Mandatory: not active yet but will be
- *   [closingBank]       // Excluded: being closed in this transaction
- * );
+ *   mandatoryBanks: [newBankToDeposit], // Not active yet but will be
+ *   excludedBanks: [closingBank],       // Being closed in this transaction
+ * });
  * ```
  */
-declare function computeHealthCheckAccounts(balances: BalanceType[], banksMap: Map<string, BankType>, mandatoryBanks?: PublicKey[], excludedBanks?: PublicKey[]): BankType[];
+declare function computeHealthCheckAccounts({ account, banksMap, mandatoryBanks, excludedBanks, }: {
+    account: MarginfiAccountType;
+    banksMap: Map<string, BankType>;
+    mandatoryBanks?: PublicKey[];
+    excludedBanks?: PublicKey[];
+}): BankType[];
 /**
  * Converts bank objects to health check account metas (public keys).
  *
@@ -2616,14 +2624,17 @@ declare function computeHealthCheckAccounts(balances: BalanceType[], banksMap: M
  *
  * @example
  * ```typescript
- * const healthAccounts = computeHealthAccountMetas(
- *   [usdcBank, solBank, kaminoUsdcBank],
- *   true // Enable sorting for optimal transaction size
- * );
+ * const healthAccounts = computeHealthAccountMetas({
+ *   banksToInclude: [usdcBank, solBank, kaminoUsdcBank],
+ * });
  * // Returns: [bank1, oracle1, bank2, oracle2, bank3, oracle3, kaminoReserve3, ...]
  * ```
  */
-declare function computeHealthAccountMetas(banksToInclude: BankType[], enableSorting?: boolean, trailingBanks?: BankType[]): PublicKey[];
+declare function computeHealthAccountMetas({ banksToInclude, enableSorting, trailingBanks, }: {
+    banksToInclude: BankType[];
+    enableSorting?: boolean;
+    trailingBanks?: BankType[];
+}): PublicKey[];
 /**
  * Projects which banks will be active after a series of instructions execute.
  *
@@ -2632,7 +2643,8 @@ declare function computeHealthAccountMetas(banksToInclude: BankType[], enableSor
  * health check account inclusion by predicting which banks are relevant.
  *
  * **Note**: This does NOT simulate Cross-Program Invocations (CPI). Only direct
- * marginfi instructions are considered.
+ * marginfi instructions are considered. Instructions operating on a different
+ * marginfi account than `account` are ignored.
  *
  * Supported instructions:
  * - Deposits: `lendingAccountDeposit`, `kaminoDeposit`, `driftDeposit`, `solendDeposit`
@@ -2640,22 +2652,26 @@ declare function computeHealthAccountMetas(banksToInclude: BankType[], enableSor
  * - Repays: `lendingAccountRepay`
  * - Withdrawals: `lendingAccountWithdraw`, `kaminoWithdraw`, `driftWithdraw`, `solendWithdraw`
  *
- * @param balances - Current account balances
+ * @param account - The marginfi account whose balances are projected
  * @param instructions - Instructions to simulate
  * @param program - Marginfi program for instruction decoding
  * @returns Array of bank public keys that will be active after instruction execution
  *
  * @example
  * ```typescript
- * const projectedBanks = computeProjectedActiveBanksNoCpi(
- *   account.balances,
- *   [depositIx, borrowIx],
- *   marginfiProgram
- * );
+ * const projectedBanks = computeProjectedActiveBanksNoCpi({
+ *   account,
+ *   instructions: [depositIx, borrowIx],
+ *   program: marginfiProgram,
+ * });
  * // Use projectedBanks for health check account selection
  * ```
  */
-declare function computeProjectedActiveBanksNoCpi(balances: BalanceType[], instructions: TransactionInstruction[], program: MarginfiProgram): PublicKey[];
+declare function computeProjectedActiveBanksNoCpi({ account, instructions, program, }: {
+    account: MarginfiAccountType;
+    instructions: TransactionInstruction[];
+    program: MarginfiProgram;
+}): PublicKey[];
 /**
  * Computes projected balances after applying a series of instructions.
  *
@@ -2664,12 +2680,13 @@ declare function computeProjectedActiveBanksNoCpi(balances: BalanceType[], instr
  * than `computeProjectedActiveBanksNoCpi` which only tracks active banks.
  *
  * **Note**: This does NOT simulate Cross-Program Invocations (CPI). Only direct
- * marginfi instructions are considered.
+ * marginfi instructions are considered. Instructions operating on a different
+ * marginfi account than `account` are ignored.
  *
  * **Integrated Protocols**: For Kamino/Drift deposits, the `assetShareValueMultiplierByBank`
  * is used to convert cToken amounts to actual asset quantities before computing shares.
  *
- * @param balances - Current account balances
+ * @param account - The marginfi account whose balances are projected
  * @param instructions - Instructions to simulate
  * @param program - Marginfi program for instruction decoding
  * @param banksMap - Map of bank addresses to bank data (needed for share value conversion)
@@ -2681,18 +2698,24 @@ declare function computeProjectedActiveBanksNoCpi(balances: BalanceType[], instr
  *
  * @example
  * ```typescript
- * const result = computeProjectedActiveBalancesNoCpi(
- *   account.balances,
- *   [depositIx, borrowIx],
- *   marginfiProgram,
+ * const result = computeProjectedActiveBalancesNoCpi({
+ *   account,
+ *   instructions: [depositIx, borrowIx],
+ *   program: marginfiProgram,
  *   banksMap,
- *   { [driftBankAddress]: driftMultiplier }
- * );
+ *   assetShareValueMultiplierByBank,
+ * });
  * console.log(`Projected ${result.projectedBalances.length} balances`);
  * console.log(`Impacted ${result.impactedAssetsBanks.length} asset banks`);
  * ```
  */
-declare function computeProjectedActiveBalancesNoCpi(balances: BalanceType[], instructions: TransactionInstruction[], program: MarginfiProgram, banksMap: Map<string, BankType>, assetShareValueMultiplierByBank: Map<string, BigNumber$1>): {
+declare function computeProjectedActiveBalancesNoCpi({ account, instructions, program, banksMap, assetShareValueMultiplierByBank, }: {
+    account: MarginfiAccountType;
+    instructions: TransactionInstruction[];
+    program: MarginfiProgram;
+    banksMap: Map<string, BankType>;
+    assetShareValueMultiplierByBank: Map<string, BigNumber$1>;
+}): {
     projectedBalances: BalanceType[];
     impactedAssetsBanks: string[];
     impactedLiabilityBanks: string[];
@@ -3019,11 +3042,7 @@ interface FlashloanSwapConstraints {
  */
 declare function computeFlashLoanNonSwapBudget({ program, marginfiAccount, ixs, bankMap, addressLookupTableAccounts, }: {
     program: MarginfiProgram;
-    marginfiAccount: {
-        address: PublicKey;
-        authority: PublicKey;
-        balances: BalanceType[];
-    };
+    marginfiAccount: MarginfiAccountType;
     ixs: TransactionInstruction[];
     bankMap: Map<string, BankType>;
     addressLookupTableAccounts: AddressLookupTableAccount[];
@@ -3109,46 +3128,141 @@ declare function isDepositIx(ix: TransactionInstruction): boolean;
 declare function patchDepositAmount(ix: TransactionInstruction, amountNative: BN): void;
 
 /**
- * Which side of a bridged (double-hop) swap touches the bridge token:
- * - `deposit` — the bridge is *deposited* (e.g. collateral-swap: source → bridge → dest).
- * - `borrow`  — the bridge is *borrowed* (e.g. debt-swap / loop: borrow bridge, then repay it).
- */
-type BridgeSide = "deposit" | "borrow";
-/**
- * Whether routing through `bankPk` as the bridge would conflict with an existing position on the
- * account. marginfi forbids holding an asset and a liability on the same bank, so the conflict is
- * always *opposite-side*: a deposit-side bridge conflicts with an existing liability there, a
- * borrow-side bridge with an existing asset. Same-side positions are fine (partial-withdraw /
- * exact-repay handle them).
- */
-declare function accountConflictsWithBridge(account: MarginfiAccountType, bankPk: PublicKey, side: BridgeSide): boolean;
-interface ResolveBridgeBanksParams {
-    /** Candidate bridge mints in priority order (caller-owned product policy). */
-    orderedBridgeMints: PublicKey[];
-    /** Banks to resolve mints against (e.g. all of the group's banks). */
-    banks: BankType[];
-    /** The account the bridge legs run against (for the conflict check). */
+ * Bridge-token candidate filtering for bridged (double-hop) swaps.
+ *
+ * A **bridge token** is NOT a cross-chain bridge: it is the high-liquidity intermediate token
+ * (e.g. USDC or wSOL) that a swap `A → C` is routed *through* — as `A → bridge` + `bridge → C` in
+ * one atomic bundle — when the direct swap can't fit a single transaction or has no route. This
+ * module owns the mechanical filtering of bridge-token candidates; ordering (product policy) and
+ * the one-call builders live in `bridge-routing.utils.ts` and the `makeBridged*Tx` actions.
+ */
+/**
+ * The side of the marginfi account the bridge token sits on while the bridged bundle executes:
+ * - `deposit` — the bridge token is held as *collateral* (a collateral-swap deposits it between
+ *   the two legs: withdraw source → deposit bridge, then withdraw bridge → deposit destination).
+ * - `borrow`  — the bridge token is held as *debt* (a debt-swap or loop borrows it in the first
+ *   leg and repays it exactly in the second).
+ */
+type BridgeTokenSide = "deposit" | "borrow";
+/**
+ * Whether routing through `bridgeBankPk` as the bridge token would conflict with a position the
+ * account already holds on that bank. marginfi forbids holding an asset and a liability on the
+ * same bank, so the conflict is always *opposite-side*: a deposit-side bridge conflicts with an
+ * existing liability there, a borrow-side bridge with an existing asset. Same-side positions are
+ * fine (partial-withdraw / exact-repay handle them).
+ */
+declare function accountConflictsWithBridgeBank(marginfiAccount: MarginfiAccountType, bridgeBankPk: PublicKey, bridgeTokenSide: BridgeTokenSide): boolean;
+interface ResolveBridgeCandidateBanksParams {
+    /** Candidate bridge-token mints, highest priority first (product policy — see
+     *  `bridge-routing.utils.ts` for the default ordering and the per-call override). */
+    prioritizedBridgeCandidateMints: PublicKey[];
+    /** Banks to resolve the candidate mints against — typically all banks in the marginfi group. */
+    groupBanks: BankType[];
+    /** The account the bridged legs run against (for the conflict check). */
     marginfiAccount: MarginfiAccountType;
-    /** Which side the bridge is used on — picks the standard-bank filter and the conflict rule. */
-    side: BridgeSide;
+    /** Which side the bridge token is held on — picks the standard-bank filter and the conflict
+     *  rule. */
+    bridgeTokenSide: BridgeTokenSide;
 }
 /**
- * Resolve an ordered list of candidate bridge *mints* into usable bridge *banks*, partitioned into
- * those safe to route through and those that conflict with an existing position.
+ * Resolve prioritized bridge-token candidate *mints* into candidate *banks*, partitioned into
+ * those safe to route through and those blocked by an existing account position.
  *
  * For each mint (deduped, in priority order) it picks the standard bank that fits the side
  * ({@link isStandardBorrowable} for `borrow`, {@link isStandardDepositable} for `deposit`) — this
  * skips integration wrappers (`6200`) and `ReduceOnly` banks (`6017`) — then splits by
- * {@link accountConflictsWithBridge}. The caller supplies the ordered mint list (product policy);
- * this owns only the mechanical filtering.
+ * {@link accountConflictsWithBridgeBank}. The caller supplies the prioritized mint list (product
+ * policy); this owns only the mechanical filtering.
  *
- * @returns `bridges` (usable, in priority order) and `conflicts` (resolvable but blocked by an
- *   opposite-side position — useful for surfacing a "close that position" message).
+ * @returns `usableBridgeBanks` (safe to route through, in priority order) and
+ *   `conflictingBridgeBanks` (resolvable but blocked by an opposite-side position — useful for
+ *   surfacing a "close that position" message).
  */
-declare function resolveBridgeBanks(params: ResolveBridgeBanksParams): {
-    bridges: BankType[];
-    conflicts: BankType[];
+declare function resolveBridgeCandidateBanks(params: ResolveBridgeCandidateBanksParams): {
+    usableBridgeBanks: BankType[];
+    conflictingBridgeBanks: BankType[];
+};
+
+/**
+ * Shared support for the bridged (double-hop) one-call builders.
+ *
+ * A **bridge token** is NOT a cross-chain bridge: it is the high-liquidity intermediate token
+ * (e.g. USDC or wSOL) a swap is routed *through*. When a direct collateral-swap / debt-swap /
+ * loop `A → C` can't be built — the swap doesn't fit one tx (size / account-locks) or has no
+ * route — it can still succeed decomposed into `A → bridge` + `bridge → C`, submitted as ONE
+ * atomic Jito bundle. The per-flow builders live next to their direct builders
+ * (`makeBridgedLoopTx` in `../actions/loop.ts`, `makeBridgedSwapCollateralTx` in
+ * `../actions/swap-collateral.ts`, `makeBridgedSwapDebtTx` in `../actions/swap-debt.ts`); this
+ * module owns the flow-agnostic routing support: candidate ordering/selection, the
+ * candidate-iteration loop (abort / skip-on-failure / conflict surfacing), token-program
+ * resolution, and the shared leg context.
+ *
+ * Candidate *ordering* is product policy: it defaults to {@link DEFAULT_BRIDGE_MINTS} and can be
+ * overridden per call via {@link BridgeOpts.bridgeCandidateMints} (e.g. a correlation-aware
+ * ordering). Candidate *filtering* (standard-bank resolution, opposite-side conflicts) is
+ * mechanical and lives in {@link resolveBridgeCandidateBanks}.
+ */
+/** Default bridge-token candidates, most-liquid first. */
+declare const DEFAULT_BRIDGE_MINTS: PublicKey[];
+/** Per-call knobs for the bridged fallback of the `makeBridged*Tx` builders. */
+interface BridgeOpts {
+    /**
+     * Candidate bridge-token mints, highest priority first. Defaults to
+     * {@link DEFAULT_BRIDGE_MINTS} (USDC, wSOL, USDT). Source/destination mints are always skipped.
+     */
+    bridgeCandidateMints?: PublicKey[];
+    /** Known token programs by mint (base58) — skips the per-mint RPC owner lookup. */
+    tokenProgramByMint?: Map<string, PublicKey>;
+    /** Override the bundle-size ceiling (see `composeBridgedSwap`). */
+    maxBundleTxs?: number;
+    abortSignal?: AbortSignal;
+}
+/** Result of a `makeBridged*Tx` builder — the direct build's result, or the bridged bundle. */
+interface BridgedTxResult {
+    transactions: SolanaTransaction[];
+    /** Index of the tx that completes the action (the direct action tx, or the bundle's last leg). */
+    actionTxIndex: number;
+    quoteResponse: SwapQuoteResult | undefined;
+    /** The bridge token's mint — set only when the bridged double-hop path was used. */
+    bridgeMint?: PublicKey;
+}
+/** A mint's token program: the cache (seedable by the caller), else the mint account's owner. */
+declare function resolveTokenProgramForMint(mint: PublicKey, connection: Connection, tokenProgramCacheByMint: Map<string, PublicKey>): Promise<PublicKey>;
+/**
+ * Bridge-token candidate banks for routing `source → bridge → destination`, in priority order,
+ * partitioned into usable and conflict-blocked. Source/destination mints are excluded from the
+ * candidates (a token can't bridge itself).
+ */
+declare function selectSwapBridges(args: {
+    sourceMint: PublicKey;
+    destinationMint: PublicKey;
+    bankMap: Map<string, BankType>;
+    marginfiAccount: MarginfiAccountType;
+    bridgeTokenSide: BridgeTokenSide;
+    bridgeCandidateMints?: PublicKey[];
+}): {
+    usableBridgeBanks: BankType[];
+    conflictingBridgeBanks: BankType[];
 };
+/**
+ * Try each usable bridge-token candidate in priority order until one composes a bundle. A
+ * `buildBundleThroughBridge` that returns null or throws (build failure) moves on to the next
+ * candidate; abort errors always propagate. When NO candidate is usable but some were dropped
+ * solely for an existing opposite-side position, throws
+ * `TransactionBuildingError.bridgeConflict` (the caller-facing "close that position" signal);
+ * otherwise resolves null and the caller rethrows the direct build's error.
+ */
+declare function tryBridgeCandidates(args: {
+    usableBridgeBanks: BankType[];
+    conflictingBridgeBanks: BankType[];
+    bridgeTokenSide: BridgeTokenSide;
+    abortSignal?: AbortSignal;
+    /** Build the two-leg bundle through one candidate bank; null = didn't work, try the next. */
+    buildBundleThroughBridge: (bridgeBank: BankType) => Promise<BridgedTxResult | null>;
+}): Promise<BridgedTxResult | null>;
+/** The flow context shared verbatim by both legs of every bridged build. */
+type SharedBridgeLegContext = Pick<MakeSwapDebtTxParams, "program" | "marginfiAccount" | "connection" | "bankMap" | "oraclePrices" | "bankMetadataMap" | "assetShareValueMultiplierByBank" | "swapOpts" | "addressLookupTableAccounts" | "overrideInferAccounts" | "crossbarUrl" | "swapEngineRunner">;
+declare function sharedBridgeLegContext(params: SharedBridgeLegContext): SharedBridgeLegContext;
 
 /**
  * Creates an instruction to close a Marginfi account.
@@ -3247,7 +3361,7 @@ declare function makeCreateAccountIxWithProjection(props: {
 declare function makeCreateMarginfiAccountTx(program: MarginfiProgram, authority: PublicKey, groupAddress: PublicKey, addressLookupTables: AddressLookupTableAccount[], accountIndex: number, thirdPartyId?: number): Promise<SolanaTransaction>;
 declare function makeCreateMarginfiAccountIx(program: MarginfiProgram, authority: PublicKey, groupAddress: PublicKey, accountIndex: number, thirdPartyId?: number): Promise<TransactionInstruction>;
 declare function makeSetupIx({ connection, authority, tokens }: MakeSetupIxParams): Promise<TransactionInstruction[]>;
-declare function makePulseHealthIx(program: MarginfiProgram, marginfiAccountPk: PublicKey, banks: Map<string, BankType>, balances: BalanceType[], mandatoryBanks: PublicKey[], excludedBanks: PublicKey[]): Promise<{
+declare function makePulseHealthIx(program: MarginfiProgram, marginfiAccount: MarginfiAccountType, banks: Map<string, BankType>, mandatoryBanks: PublicKey[], excludedBanks: PublicKey[]): Promise<{
     instructions: TransactionInstruction[];
     keys: never[];
 }>;
@@ -3508,6 +3622,19 @@ declare function makeLoopTx(params: MakeLoopTxParams): Promise<{
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
 }>;
+interface MakeBridgedLoopTxParams extends MakeLoopTxParams {
+    bridgeOpts?: BridgeOpts;
+}
+/**
+ * {@link makeLoopTx} with a transparent bridged fallback: if the direct loop's borrow→deposit swap
+ * can't fit one tx or has no route, loop P borrowing a value-equivalent amount of a bridge token,
+ * then debt-swap the bridge debt → X, as one atomic bundle.
+ *
+ * Intended for existing accounts — a fresh account's loop has a minimal footprint and fits the
+ * direct path, so callers creating the account in the same flow should call {@link makeLoopTx}
+ * directly.
+ */
+declare function makeBridgedLoopTx(params: MakeBridgedLoopTxParams): Promise<BridgedTxResult>;
 
 /**
  * Creates a repay instruction for repaying borrowed assets to a Marginfi bank.
@@ -3597,6 +3724,15 @@ declare function makeSwapCollateralTx(params: MakeSwapCollateralTxParams): Promi
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
 }>;
+interface MakeBridgedSwapCollateralTxParams extends MakeSwapCollateralTxParams {
+    bridgeOpts?: BridgeOpts;
+}
+/**
+ * {@link makeSwapCollateralTx} with a transparent bridged fallback: if the direct swap `A → C`
+ * can't fit one tx or has no route, decompose it into `A → bridge` + `bridge → C` through a
+ * high-liquidity bridge collateral, composed into one atomic bundle.
+ */
+declare function makeBridgedSwapCollateralTx(params: MakeBridgedSwapCollateralTxParams): Promise<BridgedTxResult>;
 
 /**
  * Creates transactions to swap one debt position to another using a flash loan.
@@ -3622,6 +3758,17 @@ declare function makeSwapDebtTx(params: MakeSwapDebtTxParams): Promise<{
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
 }>;
+interface MakeBridgedSwapDebtTxParams extends MakeSwapDebtTxParams {
+    bridgeOpts?: BridgeOpts;
+}
+/**
+ * {@link makeSwapDebtTx} with a transparent bridged fallback: if the direct debt swap `A → C`
+ * (repay A by borrowing C) can't fit one tx or has no route, decompose it into `A → bridge` +
+ * `bridge → C` through a borrowable bridge debt, as one atomic bundle. The first leg repays A by
+ * borrowing the bridge; the second leg repays exactly the bridge the first leg borrowed and
+ * borrows C.
+ */
+declare function makeBridgedSwapDebtTx(params: MakeBridgedSwapDebtTxParams): Promise<BridgedTxResult>;
 
 /**
  * Roll a matured Exponent PT collateral position into its next-maturity PT, so the **full
@@ -3787,8 +3934,14 @@ declare function makeTransferPositionsTx(params: MakeTransferPositionsTxParams):
  * withdraws before it — across the whole ordered batch — because the on-chain
  * health check runs against the account's live (shrinking) balance set.
  *
- * Returns `[ATA setup txs…, crank tx?, withdraw txs…]` ordered for sequential
- * execution; `actionTxIndex` points at the first withdraw tx.
+ * The returned transactions MUST land as one atomic Jito bundle (same slot,
+ * sequential): the integration refreshes (Kamino reserves + obligations, rate
+ * cranks) live in a single prelude tx rather than in each withdraw tx, and
+ * Klend's slot-based staleness checks only stay satisfied when the withdraws
+ * execute in the refresh's slot.
+ *
+ * Returns `[ATA setup txs…, crank tx?, refresh tx?, withdraw txs…]`;
+ * `actionTxIndex` points at the first withdraw tx.
  */
 declare function makeBulkWithdrawTx(params: MakeBulkWithdrawTxParams): Promise<BulkLendTxsResult>;
 /**
@@ -3818,6 +3971,25 @@ declare function makeSmartCrankSwbFeedIx(params: MakeSmartCrankSwbFeedIxParams):
     instructions: TransactionInstruction[];
     luts: AddressLookupTableAccount[];
 }>;
+type MakeSmartCrankSwbFeedIxForAccountsParams = Omit<MakeSmartCrankSwbFeedIxParams, "marginfiAccount"> & {
+    /**
+     * Accounts targeted by instructions in the set. Each account is projected against
+     * the instructions that operate on it (the projection filters by account), so the
+     * same full instruction list serves every account. The first account's authority
+     * pays the feed updates.
+     */
+    marginfiAccounts: MarginfiAccountType[];
+};
+/**
+ * Multi-account variant of {@link makeSmartCrankSwbFeedIx} for instruction sets that
+ * span several marginfi accounts (e.g. transferring positions: the source is cranked
+ * against its withdraws, the destination against its projected post-transfer
+ * deposits). Overlapping feeds across accounts are cranked once.
+ */
+declare function makeSmartCrankSwbFeedIxForAccounts(params: MakeSmartCrankSwbFeedIxForAccountsParams): Promise<{
+    instructions: TransactionInstruction[];
+    luts: AddressLookupTableAccount[];
+}>;
 declare const DEFAULT_CROSSBAR_URL = "https://crossbar.0.xyz";
 declare const DEFAULT_FALLBACK_CROSSBAR_URL = "https://crossbar.switchboard.xyz";
 declare function makeCrankSwbFeedIx(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, newBanksPk: PublicKey[], provider: AnchorProvider, crossbarUrl?: string): Promise<{
@@ -3888,6 +4060,23 @@ declare function makeUpdateDriftMarketIxs(marginfiAccount: MarginfiAccountType,
  */
 declare function makeUpdateJupLendRateIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, banksToExclude: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap): InstructionsWrapper;
 
+/**
+ * Groups the per-integration refresh/update instructions (Kamino reserve refresh,
+ * Drift spot market update, JupLend rate update) into a single wrapper.
+ *
+ * JupLend and Drift action instructions update their own bank via CPI, so the bank
+ * being acted on is excluded from those updates. Kamino has no such CPI, so the
+ * action bank must be explicitly included in the refresh set instead.
+ *
+ * @param marginfiAccount - The marginfi account containing active bank balances
+ * @param bankMap - Map of bank addresses (base58) to bank instances
+ * @param banksToExclude - Banks skipped for the JupLend/Drift updates (their CPI already updates them)
+ * @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
+ */
+declare function makeRefreshIntegrationBanksIxs(marginfiAccount: MarginfiAccountType, bankMap: Map<string, BankType>, banksToExclude: PublicKey[], bankMetadataMap: BankIntegrationMetadataMap, kaminoNewBanksPk?: PublicKey[]): InstructionsWrapper;
+
 type ValidatorVoteAccountByBank = {
     [address: string]: string;
 };
@@ -4820,7 +5009,8 @@ declare enum TransactionBuildingErrorCode {
     SWAP_QUOTE_FAILED = "SWAP_QUOTE_FAILED",
     TRANSFER_POSITIONS_INVALID_SELECTION = "TRANSFER_POSITIONS_INVALID_SELECTION",
     TRANSFER_POSITIONS_UNSUPPORTED_BANK = "TRANSFER_POSITIONS_UNSUPPORTED_BANK",
-    TRANSFER_POSITIONS_UNSPLITTABLE = "TRANSFER_POSITIONS_UNSPLITTABLE"
+    TRANSFER_POSITIONS_UNSPLITTABLE = "TRANSFER_POSITIONS_UNSPLITTABLE",
+    BRIDGE_CONFLICT = "BRIDGE_CONFLICT"
 }
 /**
  * Typed details for each error code
@@ -4894,6 +5084,16 @@ interface TransactionBuildingErrorDetails {
         sizeBytes?: number;
         accountCount?: number;
     };
+    [TransactionBuildingErrorCode.BRIDGE_CONFLICT]: {
+        /** Bridge-token candidate banks blocked by an existing opposite-side account position. */
+        conflictingBanks: Array<{
+            bankAddress: string;
+            mint: string;
+            symbol?: string;
+        }>;
+        /** Whether the bridge token would have been held as collateral ("deposit") or debt ("borrow"). */
+        bridgeTokenSide: "deposit" | "borrow";
+    };
 }
 /**
  * Error thrown during transaction building in the SDK.
@@ -4957,6 +5157,16 @@ declare class TransactionBuildingError<T extends TransactionBuildingErrorCode =
      * Retry with fewer positions in the selection.
      */
     static transferPositionsUnsplittable(reason: string, sizeBytes?: number, accountCount?: number): TransactionBuildingError<TransactionBuildingErrorCode.TRANSFER_POSITIONS_UNSPLITTABLE>;
+    /**
+     * A bridged (double-hop) swap could not route because every bridge-token candidate bank
+     * conflicts with an existing opposite-side position on the account (marginfi forbids holding an
+     * asset and a liability on the same bank).
+     */
+    static bridgeConflict(conflictingBanks: Array<{
+        bankAddress: string;
+        mint: string;
+        symbol?: string;
+    }>, bridgeTokenSide: "deposit" | "borrow"): TransactionBuildingError<TransactionBuildingErrorCode.BRIDGE_CONFLICT>;
     /**
      * Generic escape hatch for custom errors
      */
@@ -4973,6 +5183,13 @@ declare class TransactionBuildingError<T extends TransactionBuildingErrorCode =
  * (which would otherwise throw a raw serialization `RangeError`) as `SWAP_SIZE_EXCEEDED_LOOP`.
  */
 declare function isDecomposableSwapError(e: unknown): e is TransactionBuildingError;
+/**
+ * Whether a build failure is a bridged-swap conflict: the direct build failed AND every
+ * bridge-token candidate was blocked by an existing opposite-side position on the account.
+ * Narrows to the typed details (`conflictingBanks`, `bridgeTokenSide`) so callers can surface a
+ * "close that position or pick a different pair" message.
+ */
+declare function isBridgeConflictError(e: unknown): e is TransactionBuildingError<TransactionBuildingErrorCode.BRIDGE_CONFLICT>;
 
 declare const PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED: Buffer<ArrayBuffer>;
 declare const PDA_BANK_INSURANCE_VAULT_AUTH_SEED: Buffer<ArrayBuffer>;
@@ -5156,6 +5373,7 @@ declare const PRIORITY_TX_SIZE: number;
 declare const WSOL_MINT: PublicKey;
 declare const LST_MINT: PublicKey;
 declare const USDC_MINT: PublicKey;
+declare const USDT_MINT: PublicKey;
 declare const USDC_DECIMALS = 6;
 
 declare class Balance implements BalanceType {
@@ -5653,6 +5871,56 @@ declare class MarginfiAccount implements MarginfiAccountType {
      * @see {@link makeTransferPositionsTx} for detailed implementation
      */
     makeTransferPositionsTx(params: Omit<MakeTransferPositionsTxParams, "marginfiAccount">): Promise<TransferPositionsResult>;
+    /**
+     * Creates a loop transaction with a transparent bridged (double-hop) fallback.
+     *
+     * One call: tries the direct {@link makeLoopTx} first; if its borrow→deposit swap can't fit one
+     * transaction (size / account-locks) or has no route, it loops the deposit asset against a
+     * value-equivalent borrow of a high-liquidity bridge token, then debt-swaps the bridge debt to
+     * the requested borrow asset — both legs composed into ONE atomic Jito bundle.
+     *
+     * Bridge candidates default to USDC → wSOL → USDT and can be reordered/overridden via
+     * `params.bridgeOpts.bridgeCandidateMints`; `bridgeOpts` also accepts known token programs (skips RPC
+     * lookups), a bundle-size ceiling, and an abort signal. `result.bridgeMint` is set only when the
+     * bridged path was used.
+     *
+     * Intended for existing accounts — a fresh account's loop fits the direct path, so flows that
+     * create the account in the same action should call {@link makeLoopTx} directly.
+     *
+     * @param params - Loop transaction parameters plus optional `bridgeOpts`
+     * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+     *
+     * @see {@link makeBridgedLoopTx} for detailed implementation
+     */
+    makeBridgedLoopTx(params: Omit<MakeBridgedLoopTxParams, "marginfiAccount">): Promise<BridgedTxResult>;
+    /**
+     * Creates a collateral-swap transaction with a transparent bridged (double-hop) fallback.
+     *
+     * One call: tries the direct {@link makeSwapCollateralTx} first; if the swap `A → C` can't fit
+     * one transaction or has no route, it decomposes into `A → bridge` + `bridge → C` through a
+     * high-liquidity bridge collateral, both legs composed into ONE atomic Jito bundle. See
+     * {@link makeBridgedLoopTx} for the `bridgeOpts` knobs.
+     *
+     * @param params - Swap collateral transaction parameters plus optional `bridgeOpts`
+     * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+     *
+     * @see {@link makeBridgedSwapCollateralTx} for detailed implementation
+     */
+    makeBridgedSwapCollateralTx(params: Omit<MakeBridgedSwapCollateralTxParams, "marginfiAccount">): Promise<BridgedTxResult>;
+    /**
+     * Creates a debt-swap transaction with a transparent bridged (double-hop) fallback.
+     *
+     * One call: tries the direct {@link makeSwapDebtTx} first; if the swap `A → C` can't fit one
+     * transaction or has no route, the first leg repays A by borrowing a bridge token and the second
+     * leg repays exactly that bridge debt while borrowing C — both legs composed into ONE atomic
+     * Jito bundle. See {@link makeBridgedLoopTx} for the `bridgeOpts` knobs.
+     *
+     * @param params - Swap debt transaction parameters plus optional `bridgeOpts`
+     * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+     *
+     * @see {@link makeBridgedSwapDebtTx} for detailed implementation
+     */
+    makeBridgedSwapDebtTx(params: Omit<MakeBridgedSwapDebtTxParams, "marginfiAccount">): Promise<BridgedTxResult>;
     /**
      * Creates a transaction to repay debt using collateral.
      *
@@ -6190,6 +6458,52 @@ declare class MarginfiAccountWrapper {
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
     }>;
+    /**
+     * Creates a loop (leverage) transaction with a transparent bridged (double-hop) fallback and
+     * auto-injected client data.
+     *
+     * One call: tries the direct {@link makeLoopTx} first; if its borrow→deposit swap can't fit one
+     * transaction or has no route, it loops the deposit asset against a value-equivalent borrow of a
+     * bridge token (USDC/wSOL/USDT by default, override via `bridgeOpts.bridgeCandidateMints`) and
+     * debt-swaps that bridge debt to the requested borrow asset — one atomic Jito bundle.
+     * `result.bridgeMint` is set only when the bridged path was used.
+     *
+     * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+     * addressLookupTables, assetShareValueMultiplierByBank
+     *
+     * @param params - Loop parameters (user provides: connection, depositOpts, borrowOpts, swapOpts, bridgeOpts?, etc.)
+     */
+    makeBridgedLoopTx(params: Omit<MakeBridgedLoopTxParams, "program" | "marginfiAccount" | "bankMap" | "oraclePrices" | "bankMetadataMap" | "addressLookupTableAccounts" | "assetShareValueMultiplierByBank">): Promise<BridgedTxResult>;
+    /**
+     * Creates a collateral-swap transaction with a transparent bridged (double-hop) fallback and
+     * auto-injected client data.
+     *
+     * One call: tries the direct {@link makeSwapCollateralTx} first; if the swap `A → C` can't fit
+     * one transaction or has no route, it decomposes into `A → bridge` + `bridge → C` through a
+     * bridge token, composed as one atomic Jito bundle. `result.bridgeMint` is set only when the
+     * bridged path was used.
+     *
+     * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+     * addressLookupTables, assetShareValueMultiplierByBank
+     *
+     * @param params - Swap collateral parameters (user provides: connection, withdrawOpts, depositOpts, swapOpts, bridgeOpts?, etc.)
+     */
+    makeBridgedSwapCollateralTx(params: Omit<MakeBridgedSwapCollateralTxParams, "program" | "marginfiAccount" | "bankMap" | "oraclePrices" | "bankMetadataMap" | "addressLookupTableAccounts" | "assetShareValueMultiplierByBank">): Promise<BridgedTxResult>;
+    /**
+     * Creates a debt-swap transaction with a transparent bridged (double-hop) fallback and
+     * auto-injected client data.
+     *
+     * One call: tries the direct {@link makeSwapDebtTx} first; if the swap `A → C` can't fit one
+     * transaction or has no route, the first leg repays A by borrowing a bridge token and the second
+     * leg repays exactly that bridge debt while borrowing C — one atomic Jito bundle.
+     * `result.bridgeMint` is set only when the bridged path was used.
+     *
+     * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+     * addressLookupTables, assetShareValueMultiplierByBank
+     *
+     * @param params - Swap debt parameters (user provides: connection, repayOpts, borrowOpts, swapOpts, bridgeOpts?, etc.)
+     */
+    makeBridgedSwapDebtTx(params: Omit<MakeBridgedSwapDebtTxParams, "program" | "marginfiAccount" | "bankMap" | "oraclePrices" | "bankMetadataMap" | "addressLookupTableAccounts" | "assetShareValueMultiplierByBank">): Promise<BridgedTxResult>;
     /**
      * Creates a deposit transaction with auto-injected client data.
      *
@@ -6394,4 +6708,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 BridgeSide, type BridgedSwapLeg, 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 ComputeMaxWithdrawForBankParams, type ComputeNetApyParams, ConfigRaw, type CrankCombination, type CrankabilityResult, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, type DriftBankInput, type DriftMetadata, type DriftStateByBank, type DriftStateJsonByBank, EMPTY_HEALTH_CACHE, 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 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 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, OperationalState, OperationalStateRaw, 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, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, type PanicStateCache, PriceBias, PriceWithConfidence, Project0Client, Project0Config, Project0ConfigRaw, type ProviderSwapRoute, type PythOracleServiceOpts, type RateLimitWindowDto, type RateLimitWindowRawDto, type RatePointDto, type ResolveBridgeBanksParams, RiskTier, RiskTierRaw, type RollPtOpts, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, type SerializedInstruction, type SerializedLut, type SerializedSwapEngineRequest, type SerializedSwapEngineResult, type SerializedTxFootprint, type SimulateAccountHealthCacheWithFallbackParams, type SimulationResultRaw, type SmartCrankParams, type SmartCrankResult, 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, type SwbOracleAiDataByKey, type SwbOracleServiceOpts, TRANSFER_ACCOUNT_AUTHORITY_FLAG, type TitanQuoteParams, TransactionArenaKeyMap, type TransactionBuilderResult, TransactionBuildingError, TransactionBuildingErrorCode, type TransactionBuildingErrorDetails, TransactionConfigMap, TransactionType, type TransferPositionSide, type TransferPositionsResult, type TxFootprint, TypedAmount, USDC_DECIMALS, USDC_MINT, type ValidatorRateData, type ValidatorStakeGroup, type ValidatorStakeGroupDto, WSOL_MINT, type WithdrawWindowCache, WrappedI80F48, ZERO_ORACLE_KEY, accountConflictsWithBridge, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeBalanceUsdValue, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiquidationPriceForBank, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isDecomposableSwapError, isDepositIx, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx, makeBorrowIx, makeBorrowTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, 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, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveBridgeBanks, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, 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, 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 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 ComputeMaxWithdrawForBankParams, type ComputeNetApyParams, ConfigRaw, type CrankCombination, type CrankabilityResult, DEFAULT_BRIDGE_MINTS, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, type DriftBankInput, type DriftMetadata, type DriftStateByBank, type DriftStateJsonByBank, EMPTY_HEALTH_CACHE, 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 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, OperationalState, OperationalStateRaw, 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, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, type PanicStateCache, PriceBias, PriceWithConfidence, Project0Client, Project0Config, Project0ConfigRaw, type ProviderSwapRoute, type PythOracleServiceOpts, type RateLimitWindowDto, type RateLimitWindowRawDto, type RatePointDto, type ResolveBridgeCandidateBanksParams, RiskTier, RiskTierRaw, type RollPtOpts, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, type SerializedInstruction, type SerializedLut, type SerializedSwapEngineRequest, type SerializedSwapEngineResult, type SerializedTxFootprint, type SharedBridgeLegContext, type SimulateAccountHealthCacheWithFallbackParams, type SimulationResultRaw, type SmartCrankParams, type SmartCrankResult, 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, type SwbOracleAiDataByKey, type SwbOracleServiceOpts, TRANSFER_ACCOUNT_AUTHORITY_FLAG, type TitanQuoteParams, TransactionArenaKeyMap, type TransactionBuilderResult, TransactionBuildingError, TransactionBuildingErrorCode, type TransactionBuildingErrorDetails, TransactionConfigMap, TransactionType, type TransferPositionSide, type TransferPositionsResult, type TxFootprint, TypedAmount, USDC_DECIMALS, USDC_MINT, USDT_MINT, 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, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeBalanceUsdValue, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiquidationPriceForBank, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx, makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, 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, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSmartCrankSwbFeedIxForAccounts, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveBridgeCandidateBanks, resolveTokenProgramForMint, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };