@0dotxyz/p0-ts-sdk 2.6.0 → 2.6.1

package/dist/index.d.ts

@@ -139,12 +139,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.
@@ -927,9 +932,24 @@ interface SwapProviderConfig {
 }
 interface SwapOpts {
     swapConfig?: SwapProviderConfig;
+    /**
+     * Pin an exact, caller-reviewed swap route instead of running the swap engine.
+     *
+     * The caller owns ATA setup for the route, the route's input amount MUST equal the flow's swap
+     * input (e.g. the loop's borrow amount), and the route MUST pay out to the flow's destination
+     * token account. `quoteResponse.otherAmountThreshold` (guaranteed min-out, native units) sizes
+     * the follow-up amount — e.g. the loop's deposit byte-patch — exactly like an engine-selected
+     * route would. For dynamic caller-controlled routing (inspect/veto routes at build time),
+     * prefer `swapEngineRunner`.
+     *
+     * Note: the bridged `makeBridged*Tx` fallbacks are disabled when a pinned route is supplied —
+     * a pinned route belongs to the direct pair and cannot be spliced into SDK-composed legs.
+     */
     swapIxs?: {
         instructions: TransactionInstruction[];
         lookupTables: AddressLookupTableAccount[];
+        /** The pinned route's quote; `otherAmountThreshold` must be the route's min-out (native). */
+        quoteResponse: SwapQuoteResult;
     };
 }
 interface SwapQuoteResult {
@@ -1218,6 +1238,94 @@ interface MakeFlashLoanTxParams {
     isSync?: boolean;
     signers?: Signer[];
 }
+type TransferPositionSide = "collateral" | "debt";
+interface MakeTransferPositionsTxParams {
+    program: MarginfiProgram;
+    connection: Connection;
+    /** Source account A (positions move out of this account). */
+    marginfiAccount: MarginfiAccountType;
+    /** Banks whose A-positions to move; the side is inferred from A's balance. */
+    bankAddresses: PublicKey[];
+    /** Destination account B. Omit to create a fresh account inside the flashloan tx. */
+    destinationAccount?: MarginfiAccountType;
+    /** Only used when `destinationAccount` is omitted. */
+    createDestinationOpts?: {
+        accountIndex?: number;
+        thirdPartyId?: number;
+    };
+    bankMap: Map<string, BankType>;
+    oraclePrices: Map<string, OraclePrice>;
+    bankMetadataMap: BankIntegrationMetadataMap;
+    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    /** Token program per transferred bank (base58 bank address → token program id). */
+    tokenProgramsByBank: Map<string, PublicKey>;
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+    /** Head-room added to each borrow over the estimated debt for interest accrual. Default 10 bps. */
+    borrowPaddingBps?: number;
+    /** Max positions per transfer; a larger selection is rejected. Default 5. */
+    maxPositions?: number;
+    /** Whether the group USD rate limiter is enabled (adds an oracle to each withdraw). Default false. */
+    groupRateLimiterEnabled?: boolean;
+    crossbarUrl?: string;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+    };
+}
+interface TransferPositionsResult {
+    /** Ordered for execution: [setup/crank txs…, flashloan tx]. */
+    transactions: ExtendedV0Transaction[];
+    /** Index of the flashloan tx in `transactions`. */
+    actionTxIndex: number;
+    /** The destination account (passed-in, or the projected account created in the tx). */
+    destinationAccount: MarginfiAccountType;
+    /** Whether all transactions must land atomically in one bundle. */
+    mustBeAtomicBundle: boolean;
+}
+interface MakeBulkWithdrawTxParams {
+    program: MarginfiProgram;
+    connection: Connection;
+    marginfiAccount: MarginfiAccountType;
+    /** Banks whose FULL positions to withdraw, in execution order. */
+    bankAddresses: PublicKey[];
+    bankMap: Map<string, BankType>;
+    oraclePrices: Map<string, OraclePrice>;
+    bankMetadataMap: BankIntegrationMetadataMap;
+    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    /** Token program per withdrawn bank (base58 bank address → token program id). */
+    tokenProgramsByBank: Map<string, PublicKey>;
+    /** 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;
+        authority?: PublicKey;
+    };
+}
+interface MakeBulkRepayTxParams {
+    program: MarginfiProgram;
+    connection: Connection;
+    marginfiAccount: MarginfiAccountType;
+    /** Banks whose FULL debts to repay from the wallet. */
+    bankAddresses: PublicKey[];
+    bankMap: Map<string, BankType>;
+    /** Token program per repaid bank (base58 bank address → token program id). */
+    tokenProgramsByBank: Map<string, PublicKey>;
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+    };
+}
+interface BulkLendTxsResult {
+    /** Ordered for execution: [setup/crank txs…, action txs…]. */
+    transactions: ExtendedV0Transaction[];
+    /** Index of the first action tx in `transactions`. */
+    actionTxIndex: number;
+    /** Whether all transactions must land atomically in one bundle. */
+    mustBeAtomicBundle: boolean;
+}
 interface MakeLoopTxParams {
     program: MarginfiProgram;
     marginfiAccount: MarginfiAccountType;
@@ -1251,6 +1359,11 @@ interface MakeLoopTxParams {
      * Optional override for how the swap engine runs. Defaults to the in-process
      * `runSwapEngine`; the app injects a runner that forwards to `/api/tx/swap-engine`
      * so the multi-provider fan-out happens server-side.
+     *
+     * Also the seam for caller-controlled routing: wrap the default runner to inspect, veto, or
+     * replace the selected route before it's spliced into the flashloan (see
+     * `examples/16c-loop-pinned-route.ts`). For a fully static, pre-reviewed route use
+     * `swapOpts.swapIxs` instead.
      */
     swapEngineRunner?: SwapEngineRunner;
 }
@@ -2497,7 +2610,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
@@ -2505,15 +2618,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).
  *
@@ -2535,14 +2653,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.
  *
@@ -2551,7 +2672,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`
@@ -2559,22 +2681,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.
  *
@@ -2583,12 +2709,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)
@@ -2600,18 +2727,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[];
@@ -2858,6 +2991,28 @@ declare const getTitanExactOutEstimate: (params: GetTitanExactOutEstimateParams)
     quoteResult: SwapQuoteResult;
 }>;
 
+/** The canonical shape a resolved pinned route yields — mirrors an engine-selected route. */
+interface ResolvedPinnedSwapRoute {
+    swapInstructions: TransactionInstruction[];
+    setupInstructions: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    quoteResponse: SwapQuoteResult;
+    /** The route's guaranteed min-out (native) — what sizes the follow-up amount (deposit patch). */
+    outputAmountNative: BN;
+}
+/**
+ * Resolve a caller-pinned swap route (`swapOpts.swapIxs`) into the engine-result shape, validating
+ * the quote so a pinned route can never silently size a zero follow-up amount:
+ *
+ * - `otherAmountThreshold` (min-out) must be a positive integer — it becomes the loop's deposit
+ *   byte-patch, exactly like an engine-selected route's min-out.
+ * - `inAmount` must equal the flow's swap input (e.g. the loop's borrow, native units) — a
+ *   mismatch means the route was quoted for a different size than the flow will actually swap.
+ *
+ * Throws plain `Error`s (not `TransactionBuildingError`) so caller-input mistakes are never
+ * classified as decomposable swap failures (which would wrongly engage the bridged fallback).
+ */
+declare function resolvePinnedSwapRoute(swapIxs: NonNullable<SwapOpts["swapIxs"]>, expectedInAmountNative: BN | number): ResolvedPinnedSwapRoute;
 type GetSwapIxsForFlashloanParams = {
     inputMint: string;
     outputMint: string;
@@ -2938,11 +3093,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[];
@@ -3028,47 +3179,146 @@ 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;
+    /** true → send as ONE atomic Jito bundle (bridged legs are one operation / integration
+     *  refreshes go stale within a slot); false → sequential sends are safe (cranked oracles
+     *  allow ≥ ~1 min staleness). */
+    mustBeAtomicBundle: boolean;
+}
+/** 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.
  *
@@ -3166,7 +3416,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[];
 }>;
@@ -3426,7 +3676,23 @@ declare function makeLoopTx(params: MakeLoopTxParams): Promise<{
     transactions: ExtendedV0Transaction[];
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
+    /** true → send as ONE atomic Jito bundle (integration refreshes go stale within a slot);
+     *  false → sequential sends are safe (cranked oracles allow ≥ ~1 min staleness). */
+    mustBeAtomicBundle: boolean;
 }>;
+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.
@@ -3486,6 +3752,7 @@ declare function makeRepayWithCollatTx(params: MakeRepayWithCollatTxParams): Pro
     transactions: ExtendedV0Transaction[];
     swapQuote: SwapQuoteResult | undefined;
     amountToRepay: number;
+    mustBeAtomicBundle: boolean;
 }>;
 
 declare function makeBeginFlashLoanIx(program: MarginfiProgram, marginfiAccountPk: PublicKey, endIndex: number, authority?: PublicKey, isSync?: boolean): Promise<InstructionsWrapper>;
@@ -3515,7 +3782,19 @@ declare function makeSwapCollateralTx(params: MakeSwapCollateralTxParams): Promi
     transactions: ExtendedV0Transaction[];
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
+    /** true → send as ONE atomic Jito bundle (integration refreshes go stale within a slot);
+     *  false → sequential sends are safe (cranked oracles allow ≥ ~1 min staleness). */
+    mustBeAtomicBundle: boolean;
 }>;
+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.
@@ -3540,7 +3819,21 @@ declare function makeSwapDebtTx(params: MakeSwapDebtTxParams): Promise<{
     transactions: ExtendedV0Transaction[];
     actionTxIndex: number;
     quoteResponse: SwapQuoteResult | undefined;
+    /** true → send as ONE atomic Jito bundle (integration refreshes go stale within a slot);
+     *  false → sequential sends are safe (cranked oracles allow ≥ ~1 min staleness). */
+    mustBeAtomicBundle: boolean;
 }>;
+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
@@ -3622,6 +3915,108 @@ declare function mergeBridgeQuotesLoop(firstLeg: SwapQuoteResult, secondLeg: Swa
  */
 declare function composeBridgedSwap(params: ComposeBridgedSwapParams): Promise<ComposeBridgedSwapResult | null>;
 
+interface ClassifiedPosition {
+    bankAddress: PublicKey;
+    side: TransferPositionSide;
+    /** UI amount of the position (collateral: withdrawn from A / deposited to B; debt: repaid on A). */
+    uiAmount: BigNumber;
+    bank: BankType;
+    tokenProgram: PublicKey;
+}
+/**
+ * Validate the selection, infer each position's side, and resolve its UI amount. Correctness of the
+ * transfer itself (both accounts staying healthy) is enforced on-chain by the flashloan's end health
+ * check on A and each borrow's health check on B — so no client-side health/USD math is needed.
+ */
+declare function classifyAndValidate(params: MakeTransferPositionsTxParams): ClassifiedPosition[];
+interface BuildContext {
+    program: MarginfiProgram;
+    accountA: MarginfiAccountType;
+    accountB: MarginfiAccountType;
+    bankMap: Map<string, BankType>;
+    bankMetadataMap: BankIntegrationMetadataMap;
+    assetShareValueMultiplierByBank: Map<string, BigNumber>;
+    borrowPaddingBps: number;
+    groupRateLimiterEnabled: boolean;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+    };
+    /** Banks the destination account already holds before the transfer starts. */
+    destPreexistingBanks: BankType[];
+}
+/**
+ * Build one collateral position's withdraw-from-A + deposit-into-B instructions, dispatching to the
+ * right builder for the bank's asset tag. This is the single place that defines which banks the
+ * action supports: `DEFAULT`/`SOL`/`STAKED` use the standard withdraw/deposit; `KAMINO`/`JUPLEND`
+ * use their dedicated builders (which lock the integration's reserve/vault accounts and, for Kamino,
+ * convert the underlying UI amount to cToken units); anything else throws
+ * `TRANSFER_POSITIONS_UNSUPPORTED_BANK`. The reserve/rate state each integration builder needs is
+ * read from `bankMetadataMap`; the on-chain refresh those reads depend on is emitted separately in
+ * `buildIntegrationRefreshIxs`.
+ *
+ * `observationBanksOverride` controls the withdraw leg's health pack (empty while A is flashloaned
+ * with the group limiter off; the withdrawn bank's oracle when it is on). The deposit leg runs no
+ * health check, so it needs none.
+ */
+declare function buildCollateralLegIxs(ctx: BuildContext, position: ClassifiedPosition, isSync: boolean, observationBanksOverride: ReturnType<typeof computeHealthAccountMetas>): Promise<{
+    withdrawIxs: TransactionInstruction[];
+    depositIxs: TransactionInstruction[];
+}>;
+/**
+ * Atomically move a selected set of positions from account A to account B in a single flashloan.
+ * Per position: collateral → `withdraw(A)` + `deposit(B)`; debt → `borrow(B)` + `repay(A)`. Returns
+ * unsigned transactions ordered for sequential execution (setup/refresh + crank first, then the
+ * flashloan); the caller signs and sends them.
+ *
+ * The whole transfer must fit one v0 transaction — the selection is capped at `maxPositions`
+ * (default 5), and the built flashloan is size-checked, throwing `TRANSFER_POSITIONS_UNSPLITTABLE`
+ * if it still overflows (possible with several integration positions). Transfer larger sets in
+ * batches. Correctness (both accounts staying healthy) is enforced on-chain: `endFL(A)` checks A's
+ * remainder and each `borrow(B)` checks B — no client-side health prediction.
+ *
+ * Supported asset tags: `DEFAULT`/`SOL`/`STAKED` on either leg, and the collateral-only integrations
+ * `KAMINO`/`JUPLEND` on the collateral leg (dedicated builders + a preceding reserve/rate refresh).
+ * `DRIFT`/`SOLEND` are rejected.
+ *
+ * Runtime notes:
+ *  - Each borrow-before-repay transiently spikes the debt bank's rate-limit window; a bank near its
+ *    cap can revert with `BankHourly/DailyRateLimitExceeded`. The whole flashloan reverts atomically,
+ *    so this is safe and retryable — treat it as such.
+ *  - Integration (Kamino/JupLend) reserve/rate refresh rides in the prelude transaction and requires
+ *    `bankMetadataMap` to carry fresh `kaminoStates`/`jupLendStates`.
+ *  - All transactions share one blockhash; execute them in order within its validity window. When
+ *    `mustBeAtomicBundle` is true, they must also land atomically in one bundle.
+ *  - Dust (borrow padding minus accrued interest; withdraw-all/cToken-conversion excess) remains in
+ *    the wallet ATAs.
+ */
+declare function makeTransferPositionsTx(params: MakeTransferPositionsTxParams): Promise<TransferPositionsResult>;
+
+/**
+ * Withdraw the FULL position of every given bank, packing as many withdraws
+ * per transaction as fit the size/lock limits. Venue dispatch (Kamino /
+ * JupLend / Drift / standard) and the per-instruction health packs live here:
+ * each withdraw's remaining accounts exclude every bank already closed by the
+ * withdraws before it — across the whole ordered batch — because the on-chain
+ * health check runs against the account's live (shrinking) balance set.
+ *
+ * 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>;
+/**
+ * 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.
+ */
+declare function makeBulkRepayTx(params: MakeBulkRepayTxParams): Promise<BulkLendTxsResult>;
+
 type MakeSmartCrankSwbFeedIxParams = {
     marginfiAccount: MarginfiAccountType;
     bankMap: Map<string, BankType>;
@@ -3642,6 +4037,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<{
@@ -3712,6 +4126,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;
 };
@@ -4016,6 +4447,14 @@ declare function computeBankBorrowApy(bank: BankType): number;
  */
 declare function computeBankMetrics(params: ComputeBankMetricsParams): BankMetrics;
 
+/**
+ * Lookup-or-throw helpers for action-builder inputs. The optional `makeError`
+ * lets callers throw their own typed error (e.g. a TransactionBuildingError
+ * with user-facing copy) instead of a plain Error.
+ */
+declare function requireBank(bankMap: Map<string, BankType>, address: PublicKey, makeError?: (message: string) => Error): BankType;
+declare function requireTokenProgram(tokenProgramsByBank: Map<string, PublicKey>, address: PublicKey, makeError?: (message: string) => Error): PublicKey;
+
 /**
  * Fee state cache - stores information from the global FeeState
  * so the FeeState can be omitted on certain instructions
@@ -4745,7 +5184,11 @@ declare enum TransactionBuildingErrorCode {
     DRIFT_STATE_NOT_FOUND = "DRIFT_STATE_NOT_FOUND",
     JUPLEND_STATE_NOT_FOUND = "JUPLEND_STATE_NOT_FOUND",
     SWITCHBOARD_FEED_UPDATE_FAILED = "SWITCHBOARD_FEED_UPDATE_FAILED",
-    SWAP_QUOTE_FAILED = "SWAP_QUOTE_FAILED"
+    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",
+    BRIDGE_CONFLICT = "BRIDGE_CONFLICT"
 }
 /**
  * Typed details for each error code
@@ -4805,6 +5248,30 @@ interface TransactionBuildingErrorDetails {
         outputMint: string;
         reason: string;
     };
+    [TransactionBuildingErrorCode.TRANSFER_POSITIONS_INVALID_SELECTION]: {
+        reason: string;
+        bankAddresses: string[];
+    };
+    [TransactionBuildingErrorCode.TRANSFER_POSITIONS_UNSUPPORTED_BANK]: {
+        bankAddress: string;
+        assetTag: number;
+        bankSymbol?: string;
+    };
+    [TransactionBuildingErrorCode.TRANSFER_POSITIONS_UNSPLITTABLE]: {
+        reason: string;
+        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.
@@ -4852,6 +5319,32 @@ declare class TransactionBuildingError<T extends TransactionBuildingErrorCode =
      * Failed to get a swap quote from any provider
      */
     static swapQuoteFailed(provider: string, inputMint: string, outputMint: string, reason: string): TransactionBuildingError<TransactionBuildingErrorCode.SWAP_QUOTE_FAILED>;
+    /**
+     * The requested set of positions to transfer is invalid (inactive bank on the source,
+     * destination overlap, capacity/slot conflict, group/authority mismatch, etc.).
+     */
+    static transferPositionsInvalidSelection(reason: string, bankAddresses: string[]): TransactionBuildingError<TransactionBuildingErrorCode.TRANSFER_POSITIONS_INVALID_SELECTION>;
+    /**
+     * A selected position lives in a bank whose asset tag is not supported by transfer-positions
+     * (v1 supports DEFAULT and STAKED only).
+     */
+    static transferPositionsUnsupportedBank(bankAddress: string, assetTag: number, bankSymbol?: string): TransactionBuildingError<TransactionBuildingErrorCode.TRANSFER_POSITIONS_UNSUPPORTED_BANK>;
+    /**
+     * The built transfer transaction exceeds the v0 size / account-lock limits even at the position
+     * cap (most likely several integration positions whose reserve accounts overflow the 64-lock cap).
+     * 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
      */
@@ -4868,6 +5361,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>;
@@ -5051,6 +5551,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 {
@@ -5540,7 +6041,67 @@ declare class MarginfiAccount implements MarginfiAccountType {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
+    /**
+     * Atomically move a selected set of positions from this account to a destination account
+     * (same authority, same group) using flashloans, auto-splitting across transactions as needed.
+     *
+     * @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.
      *
@@ -5573,6 +6134,9 @@ declare class MarginfiAccount implements MarginfiAccountType {
         transactions: ExtendedV0Transaction[];
         swapQuote: SwapQuoteResult | undefined;
         amountToRepay: number;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a transaction to swap one collateral position to another using a flash loan.
@@ -5607,6 +6171,9 @@ declare class MarginfiAccount implements MarginfiAccountType {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a transaction to roll a matured Exponent PT collateral position into its
@@ -5653,6 +6220,9 @@ declare class MarginfiAccount implements MarginfiAccountType {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a deposit transaction.
@@ -6013,7 +6583,18 @@ declare class MarginfiAccountWrapper {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
+    /**
+     * Atomically move a selected set of positions from this account to a destination account with
+     * auto-injected client data.
+     *
+     * Auto-injects: program, connection, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+     * assetShareValueMultiplierByBank, addressLookupTables, tokenProgramsByBank, groupRateLimiterEnabled.
+     */
+    makeTransferPositionsTx(params: Omit<MakeTransferPositionsTxParams, "program" | "connection" | "marginfiAccount" | "bankMap" | "oraclePrices" | "bankMetadataMap" | "assetShareValueMultiplierByBank" | "addressLookupTableAccounts" | "tokenProgramsByBank" | "groupRateLimiterEnabled">): Promise<TransferPositionsResult>;
     /**
      * Creates a repay with collateral transaction with auto-injected client data.
      *
@@ -6025,6 +6606,9 @@ declare class MarginfiAccountWrapper {
         transactions: ExtendedV0Transaction[];
         swapQuote: SwapQuoteResult | undefined;
         amountToRepay: number;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Creates a swap collateral transaction with auto-injected client data.
@@ -6040,6 +6624,9 @@ declare class MarginfiAccountWrapper {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
     /**
      * Rolls a matured Exponent PT collateral position into its next-maturity PT, with
@@ -6069,7 +6656,56 @@ declare class MarginfiAccountWrapper {
         transactions: ExtendedV0Transaction[];
         actionTxIndex: number;
         quoteResponse: SwapQuoteResult | undefined;
+        /** true → send as ONE atomic Jito bundle (bridged legs / integration refreshes);
+         *  false → sequential sends are safe. */
+        mustBeAtomicBundle: boolean;
     }>;
+    /**
+     * 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.
      *
@@ -6274,4 +6910,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 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 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 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, 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 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, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, 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, fetchGammaLpVault, fetchGammaWithdrawReceipt, 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, 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, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, 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, resolveBridgeBanks, resolveVaultTokenProgram, 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 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, 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, type ResolvedPinnedSwapRoute, 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, fetchGammaLpVault, fetchGammaWithdrawReceipt, 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, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, 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, resolvePinnedSwapRoute, resolveTokenProgramForMint, resolveVaultTokenProgram, 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 };