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

package/dist/index.js

@@ -100,6 +100,9 @@ var TransactionBuildingErrorCode = /* @__PURE__ */ ((TransactionBuildingErrorCod
   TransactionBuildingErrorCode2["JUPLEND_STATE_NOT_FOUND"] = "JUPLEND_STATE_NOT_FOUND";
   TransactionBuildingErrorCode2["SWITCHBOARD_FEED_UPDATE_FAILED"] = "SWITCHBOARD_FEED_UPDATE_FAILED";
   TransactionBuildingErrorCode2["SWAP_QUOTE_FAILED"] = "SWAP_QUOTE_FAILED";
+  TransactionBuildingErrorCode2["TRANSFER_POSITIONS_INVALID_SELECTION"] = "TRANSFER_POSITIONS_INVALID_SELECTION";
+  TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSUPPORTED_BANK"] = "TRANSFER_POSITIONS_UNSUPPORTED_BANK";
+  TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSPLITTABLE"] = "TRANSFER_POSITIONS_UNSPLITTABLE";
   return TransactionBuildingErrorCode2;
 })(TransactionBuildingErrorCode || {});
 var TransactionBuildingError = class _TransactionBuildingError extends Error {
@@ -196,6 +199,40 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { provider, inputMint, outputMint, reason }
     );
   }
+  /**
+   * 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, bankAddresses) {
+    return new _TransactionBuildingError(
+      "TRANSFER_POSITIONS_INVALID_SELECTION" /* TRANSFER_POSITIONS_INVALID_SELECTION */,
+      `Invalid transfer-positions selection: ${reason}`,
+      { reason, bankAddresses }
+    );
+  }
+  /**
+   * 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, assetTag, bankSymbol) {
+    return new _TransactionBuildingError(
+      "TRANSFER_POSITIONS_UNSUPPORTED_BANK" /* TRANSFER_POSITIONS_UNSUPPORTED_BANK */,
+      `Bank ${bankSymbol ?? bankAddress} (asset tag ${assetTag}) is not supported by transfer-positions`,
+      { bankAddress, assetTag, bankSymbol }
+    );
+  }
+  /**
+   * 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, sizeBytes, accountCount) {
+    return new _TransactionBuildingError(
+      "TRANSFER_POSITIONS_UNSPLITTABLE" /* TRANSFER_POSITIONS_UNSPLITTABLE */,
+      `Transfer does not fit one transaction: ${reason}`,
+      { reason, sizeBytes, accountCount }
+    );
+  }
   /**
    * Generic escape hatch for custom errors
    */
@@ -69406,6 +69443,23 @@ var MarginfiAccount = class _MarginfiAccount {
       }
     });
   }
+  /**
+   * 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
+   */
+  async makeTransferPositionsTx(params) {
+    return makeTransferPositionsTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
   /**
    * Creates a transaction to repay debt using collateral.
    *
@@ -69865,6 +69919,499 @@ async function composeBridgedSwap(params) {
   if (!transactions) return null;
   return { transactions, firstLegQuote: firstLeg.quoteResponse, secondLegQuote: secondLeg.quoteResponse };
 }
+var MAX_BALANCES = 16;
+var DEFAULT_MAX_TRANSFER_POSITIONS = 5;
+var DEFAULT_BORROW_PADDING_BPS = 10;
+var CU_IXS = () => [
+  ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
+  ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+];
+function requireBank(bankMap, address) {
+  const bank = bankMap.get(address.toBase58());
+  if (!bank) {
+    throw TransactionBuildingError.transferPositionsInvalidSelection(
+      `bank ${address.toBase58()} not found`,
+      [address.toBase58()]
+    );
+  }
+  return bank;
+}
+function requireTokenProgram(tokenProgramsByBank, address) {
+  const tp = tokenProgramsByBank.get(address.toBase58());
+  if (!tp) {
+    throw TransactionBuildingError.transferPositionsInvalidSelection(
+      `token program for bank ${address.toBase58()} not provided`,
+      [address.toBase58()]
+    );
+  }
+  return tp;
+}
+function classifyAndValidate(params) {
+  const {
+    marginfiAccount: accountA,
+    destinationAccount: accountB,
+    bankAddresses,
+    bankMap,
+    tokenProgramsByBank,
+    assetShareValueMultiplierByBank
+  } = params;
+  const maxPositions = params.maxPositions ?? DEFAULT_MAX_TRANSFER_POSITIONS;
+  if (bankAddresses.length === 0) {
+    throw TransactionBuildingError.transferPositionsInvalidSelection("no positions selected", []);
+  }
+  if (bankAddresses.length > maxPositions) {
+    throw TransactionBuildingError.transferPositionsInvalidSelection(
+      `cannot transfer ${bankAddresses.length} positions in one transaction (max ${maxPositions}); select fewer and transfer in batches`,
+      bankAddresses.map((b) => b.toBase58())
+    );
+  }
+  const activeBalancesA = accountA.balances.filter((b) => b.active);
+  const positions = [];
+  for (const bankAddress of bankAddresses) {
+    const bank = requireBank(bankMap, bankAddress);
+    const tokenProgram = requireTokenProgram(tokenProgramsByBank, bankAddress);
+    const balance = activeBalancesA.find((b) => b.bankPk.equals(bankAddress));
+    if (!balance) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        `source account has no active position in bank ${bankAddress.toBase58()}`,
+        [bankAddress.toBase58()]
+      );
+    }
+    const side = balance.assetShares.gt(0) ? "collateral" : "debt";
+    const multiplier = assetShareValueMultiplierByBank.get(bankAddress.toBase58());
+    const qty = computeQuantityUi(balance, bank, multiplier);
+    positions.push({
+      bankAddress,
+      side,
+      uiAmount: side === "collateral" ? qty.assets : qty.liabilities,
+      bank,
+      tokenProgram
+    });
+  }
+  const isolatedDebts = positions.filter(
+    (p) => p.side === "debt" && p.bank.config.riskTier === "Isolated" /* Isolated */
+  );
+  if (isolatedDebts.length > 0) {
+    const otherDebts = positions.filter((p) => p.side === "debt").length > 1;
+    const destHasLiabilities = (accountB?.balances ?? []).some(
+      (b) => b.active && b.liabilityShares.gt(0)
+    );
+    if (isolatedDebts.length > 1 || otherDebts || destHasLiabilities) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        "an isolated-tier debt can only be transferred as the destination account's sole liability",
+        isolatedDebts.map((p) => p.bankAddress.toBase58())
+      );
+    }
+  }
+  if (accountB) {
+    if (!accountB.group.equals(accountA.group)) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        "destination account is in a different group",
+        [accountB.address.toBase58()]
+      );
+    }
+    if (!accountB.authority.equals(accountA.authority)) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        "destination account has a different authority",
+        [accountB.address.toBase58()]
+      );
+    }
+    const overlap = positions.filter(
+      (p) => accountB.balances.some((b) => b.active && b.bankPk.equals(p.bankAddress))
+    );
+    if (overlap.length > 0) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        "destination account already holds a position in a transferred bank",
+        overlap.map((p) => p.bankAddress.toBase58())
+      );
+    }
+    const activeCountB = accountB.balances.filter((b) => b.active).length;
+    if (activeCountB + positions.length > MAX_BALANCES) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        `destination account cannot hold ${activeCountB + positions.length} positions (max ${MAX_BALANCES})`,
+        positions.map((p) => p.bankAddress.toBase58())
+      );
+    }
+  }
+  return positions;
+}
+function buildIntegrationRefreshIxs(args) {
+  const { accountA, destinationAccount, positions, bankMap, bankMetadataMap } = args;
+  const transferredKaminoPks = positions.filter((p) => p.bank.config.assetTag === 3 /* KAMINO */).map((p) => p.bankAddress);
+  const transferredJupPks = positions.filter((p) => p.bank.config.assetTag === 6 /* JUPLEND */).map((p) => p.bankAddress);
+  const ixs = [];
+  ixs.push(
+    ...makeRefreshKaminoBanksIxs(accountA, bankMap, transferredKaminoPks, bankMetadataMap).instructions
+  );
+  if (destinationAccount) {
+    ixs.push(
+      ...makeRefreshKaminoBanksIxs(destinationAccount, bankMap, [], bankMetadataMap).instructions
+    );
+  }
+  ixs.push(
+    ...makeUpdateJupLendRateIxs(accountA, bankMap, transferredJupPks, bankMetadataMap).instructions
+  );
+  if (destinationAccount) {
+    ixs.push(
+      ...makeUpdateJupLendRateIxs(destinationAccount, bankMap, transferredJupPks, bankMetadataMap).instructions
+    );
+  }
+  return ixs;
+}
+function dedupeBanks(banks) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const bank of banks) seen.set(bank.address.toBase58(), bank);
+  return [...seen.values()];
+}
+async function buildCollateralLegIxs(ctx, position, isSync, observationBanksOverride) {
+  const { bank, tokenProgram, uiAmount } = position;
+  const tag = bank.config.assetTag;
+  const key = bank.address.toBase58();
+  if (tag === 3 /* KAMINO */) {
+    const reserve = ctx.bankMetadataMap[key]?.kaminoStates?.reserveState;
+    if (!reserve) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        `kamino reserve state missing for bank ${key} (populate bankMetadataMap.kaminoStates)`,
+        [key]
+      );
+    }
+    const multiplier = ctx.assetShareValueMultiplierByBank.get(key) ?? new BigNumber(1);
+    const cTokenAmount = uiAmount.div(multiplier);
+    const withdraw2 = await makeKaminoWithdrawIx3({
+      program: ctx.program,
+      bank,
+      bankMap: ctx.bankMap,
+      tokenProgram,
+      cTokenAmount,
+      marginfiAccount: ctx.accountA,
+      authority: ctx.accountA.authority,
+      reserve,
+      bankMetadataMap: ctx.bankMetadataMap,
+      withdrawAll: true,
+      isSync,
+      opts: {
+        createAtas: false,
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts: ctx.overrideInferAccounts,
+        observationBanksOverride
+      }
+    });
+    const deposit2 = await makeKaminoDepositIx3({
+      program: ctx.program,
+      bank,
+      tokenProgram,
+      amount: uiAmount,
+      accountAddress: ctx.accountB.address,
+      authority: ctx.accountA.authority,
+      group: ctx.accountB.group,
+      reserve,
+      isSync,
+      opts: { wrapAndUnwrapSol: false, overrideInferAccounts: ctx.overrideInferAccounts }
+    });
+    return { withdrawIxs: withdraw2.instructions, depositIxs: deposit2.instructions };
+  }
+  if (tag === 6 /* JUPLEND */) {
+    const jupLendingState = ctx.bankMetadataMap[key]?.jupLendStates?.jupLendingState;
+    if (!jupLendingState) {
+      throw TransactionBuildingError.transferPositionsInvalidSelection(
+        `juplend lending state missing for bank ${key} (populate bankMetadataMap.jupLendStates)`,
+        [key]
+      );
+    }
+    const withdraw2 = await makeJuplendWithdrawIx2({
+      program: ctx.program,
+      bank,
+      bankMap: ctx.bankMap,
+      tokenProgram,
+      amount: uiAmount,
+      marginfiAccount: ctx.accountA,
+      authority: ctx.accountA.authority,
+      jupLendingState,
+      bankMetadataMap: ctx.bankMetadataMap,
+      withdrawAll: true,
+      opts: {
+        createAtas: false,
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts: ctx.overrideInferAccounts,
+        observationBanksOverride
+      }
+    });
+    const deposit2 = await makeJuplendDepositIx2({
+      program: ctx.program,
+      bank,
+      tokenProgram,
+      amount: uiAmount,
+      accountAddress: ctx.accountB.address,
+      authority: ctx.accountA.authority,
+      group: ctx.accountB.group,
+      isSync,
+      opts: { wrapAndUnwrapSol: false, overrideInferAccounts: ctx.overrideInferAccounts }
+    });
+    return { withdrawIxs: withdraw2.instructions, depositIxs: deposit2.instructions };
+  }
+  if (tag !== 0 /* DEFAULT */ && tag !== 1 /* SOL */ && tag !== 2 /* STAKED */) {
+    throw TransactionBuildingError.transferPositionsUnsupportedBank(key, tag, bank.tokenSymbol);
+  }
+  const withdraw = await makeWithdrawIx3({
+    program: ctx.program,
+    bank,
+    bankMap: ctx.bankMap,
+    tokenProgram,
+    amount: uiAmount,
+    marginfiAccount: ctx.accountA,
+    authority: ctx.accountA.authority,
+    withdrawAll: true,
+    bankMetadataMap: ctx.bankMetadataMap,
+    isSync,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts: ctx.overrideInferAccounts,
+      observationBanksOverride
+    }
+  });
+  const deposit = await makeDepositIx3({
+    program: ctx.program,
+    bank,
+    tokenProgram,
+    amount: uiAmount,
+    accountAddress: ctx.accountB.address,
+    authority: ctx.accountA.authority,
+    group: ctx.accountB.group,
+    isSync,
+    opts: { wrapAndUnwrapSol: false, overrideInferAccounts: ctx.overrideInferAccounts }
+  });
+  return { withdrawIxs: withdraw.instructions, depositIxs: deposit.instructions };
+}
+async function buildInnerIxs(ctx, positions, isSync) {
+  const collateral = positions.filter((p) => p.side === "collateral");
+  const debts = positions.filter((p) => p.side === "debt");
+  const collateralBanks = collateral.map((p) => p.bank);
+  const withdrawIxs = [];
+  const depositIxs = [];
+  const borrowIxs = [];
+  const repayIxs = [];
+  for (const position of collateral) {
+    const observationBanksOverride = ctx.groupRateLimiterEnabled ? computeHealthAccountMetas([], true, [position.bank]) : [];
+    const legs = await buildCollateralLegIxs(ctx, position, isSync, observationBanksOverride);
+    withdrawIxs.push(...legs.withdrawIxs);
+    depositIxs.push(...legs.depositIxs);
+  }
+  const transferredKaminoPks = collateral.filter((p) => p.bank.config.assetTag === 3 /* KAMINO */).map((p) => p.bankAddress);
+  const kaminoReRefreshIxs = transferredKaminoPks.length > 0 ? makeRefreshKaminoBanksIxs(
+    ctx.accountA,
+    ctx.bankMap,
+    transferredKaminoPks,
+    ctx.bankMetadataMap
+  ).instructions : [];
+  const borrowedSoFar = [];
+  for (const position of debts) {
+    const { bank, tokenProgram } = position;
+    borrowedSoFar.push(bank);
+    const activeBanks = dedupeBanks([
+      ...ctx.destPreexistingBanks,
+      ...collateralBanks,
+      ...borrowedSoFar
+    ]);
+    const observationBanksOverride = computeHealthAccountMetas(activeBanks);
+    const borrowUi = position.uiAmount.times(1 + ctx.borrowPaddingBps / 1e4);
+    const borrow = await makeBorrowIx3({
+      program: ctx.program,
+      bank,
+      bankMap: ctx.bankMap,
+      tokenProgram,
+      amount: borrowUi,
+      marginfiAccount: ctx.accountB,
+      authority: ctx.accountA.authority,
+      isSync,
+      opts: {
+        createAtas: false,
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts: ctx.overrideInferAccounts,
+        observationBanksOverride
+      }
+    });
+    borrowIxs.push(...borrow.instructions);
+    const repay = await makeRepayIx3({
+      program: ctx.program,
+      bank,
+      tokenProgram,
+      amount: position.uiAmount,
+      accountAddress: ctx.accountA.address,
+      authority: ctx.accountA.authority,
+      repayAll: true,
+      isSync,
+      opts: {
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts: ctx.overrideInferAccounts
+      }
+    });
+    repayIxs.push(...repay.instructions);
+  }
+  return [
+    ...CU_IXS(),
+    ...withdrawIxs,
+    ...kaminoReRefreshIxs,
+    ...depositIxs,
+    ...borrowIxs,
+    ...repayIxs
+  ];
+}
+async function buildTransferFlashloanTx(args) {
+  const { program, accountA, projectedActiveBanksA, innerIxs, preIxs, blockhash, luts } = args;
+  const endIndex = preIxs.length + innerIxs.length + 1;
+  const begin = await makeBeginFlashLoanIx3(program, accountA.address, endIndex, accountA.authority);
+  const end = await makeEndFlashLoanIx3(
+    program,
+    accountA.address,
+    projectedActiveBanksA,
+    accountA.authority
+  );
+  const message = new TransactionMessage({
+    payerKey: accountA.authority,
+    recentBlockhash: blockhash,
+    instructions: [...preIxs, ...begin.instructions, ...innerIxs, ...end.instructions]
+  }).compileToV0Message(luts);
+  return addTransactionMetadata(new VersionedTransaction(message), {
+    addressLookupTables: luts,
+    type: "FLASHLOAN" /* FLASHLOAN */
+  });
+}
+function destPreexistingBanksOf(account, bankMap) {
+  if (!account) return [];
+  return dedupeBanks(
+    account.balances.filter((b) => b.active).map((b) => bankMap.get(b.bankPk.toBase58())).filter((b) => Boolean(b))
+  );
+}
+async function makeTransferPositionsTx(params) {
+  const {
+    program,
+    connection,
+    marginfiAccount: accountA,
+    bankMap,
+    bankMetadataMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    addressLookupTableAccounts,
+    crossbarUrl,
+    overrideInferAccounts
+  } = params;
+  const luts = addressLookupTableAccounts ?? [];
+  const borrowPaddingBps = params.borrowPaddingBps ?? DEFAULT_BORROW_PADDING_BPS;
+  const groupRateLimiterEnabled = params.groupRateLimiterEnabled ?? false;
+  const positions = classifyAndValidate(params);
+  let accountB = params.destinationAccount;
+  let createIx;
+  if (!accountB) {
+    const accountIndex = params.createDestinationOpts?.accountIndex ?? await findRandomAvailableAccountIndex(
+      connection,
+      program.programId,
+      accountA.group,
+      accountA.authority
+    );
+    const created = await makeCreateAccountIxWithProjection({
+      program,
+      authority: accountA.authority,
+      group: accountA.group,
+      accountIndex,
+      thirdPartyId: params.createDestinationOpts?.thirdPartyId
+    });
+    accountB = created.account;
+    createIx = created.ix;
+  }
+  const ctx = {
+    program,
+    accountA,
+    accountB,
+    bankMap,
+    bankMetadataMap,
+    assetShareValueMultiplierByBank,
+    borrowPaddingBps,
+    groupRateLimiterEnabled,
+    overrideInferAccounts,
+    destPreexistingBanks: destPreexistingBanksOf(params.destinationAccount, bankMap)
+  };
+  const innerIxs = await buildInnerIxs(ctx, positions, false);
+  const transferred = new Set(positions.map((p) => p.bankAddress.toBase58()));
+  const projectedActiveBanksA = dedupeBanks(
+    accountA.balances.filter((b) => b.active && !transferred.has(b.bankPk.toBase58())).map((b) => requireBank(bankMap, b.bankPk))
+  );
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const preIxs = createIx ? [createIx] : [];
+  const flashloanTx = await buildTransferFlashloanTx({
+    program,
+    accountA,
+    projectedActiveBanksA,
+    innerIxs,
+    preIxs,
+    blockhash,
+    luts
+  });
+  const size = getTxSize(flashloanTx);
+  const keys = getTotalAccountKeys(flashloanTx);
+  if (size > MAX_TX_SIZE || keys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.transferPositionsUnsplittable(
+      `built transaction exceeds size limits (${size} bytes, ${keys} accounts); transfer fewer positions`,
+      size,
+      keys
+    );
+  }
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: accountA.authority,
+    tokens: positions.map((p) => ({ mint: p.bank.mint, tokenProgram: p.tokenProgram }))
+  });
+  const refreshIxs = buildIntegrationRefreshIxs({
+    accountA,
+    destinationAccount: params.destinationAccount,
+    positions,
+    bankMap,
+    bankMetadataMap
+  });
+  const additionalTxs = [];
+  const preludeIxs = [...setupIxs, ...refreshIxs];
+  if (preludeIxs.length > 0) {
+    const txs = splitInstructionsToFitTransactions([], preludeIxs, {
+      blockhash,
+      payerKey: accountA.authority,
+      luts
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, { type: "CREATE_ATA" /* CREATE_ATA */, addressLookupTables: luts })
+      )
+    );
+  }
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount: accountA,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: innerIxs,
+    program,
+    connection,
+    crossbarUrl
+  });
+  if (updateFeedIxs.length > 0) {
+    const message = new TransactionMessage({
+      payerKey: accountA.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: additionalTxs.length,
+    destinationAccount: accountB
+  };
+}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -70274,7 +70821,7 @@ var GROUP_OFFSET = 8;
 var BALANCES_OFFSET = 72;
 var BALANCE_SIZE = 104;
 var BANK_PK_OFFSET_IN_BALANCE = 1;
-var MAX_BALANCES = 16;
+var MAX_BALANCES2 = 16;
 var scanBankSlots = async (program, group, bank, options) => {
   const connection = program.provider.connection;
   const programId = program.programId;
@@ -70282,7 +70829,7 @@ var scanBankSlots = async (program, group, bank, options) => {
   const groupBytes = group.toBase58();
   const bankBytes = bank.toBase58();
   const slotOffsets = Array.from(
-    { length: MAX_BALANCES },
+    { length: MAX_BALANCES2 },
     (_, n) => BALANCES_OFFSET + BANK_PK_OFFSET_IN_BALANCE + n * BALANCE_SIZE
   );
   const scanSlot = (offset) => {
@@ -74313,6 +74860,36 @@ var MarginfiAccountWrapper = class {
     };
     return this.account.makeLoopTx(fullParams);
   }
+  /**
+   * 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.
+   */
+  async makeTransferPositionsTx(params) {
+    const tokenProgramsByBank = /* @__PURE__ */ new Map();
+    for (const bankAddress of params.bankAddresses) {
+      const bank = this.client.bankMap.get(bankAddress.toBase58());
+      if (!bank) throw new Error(`Bank ${bankAddress.toBase58()} not found`);
+      const mintData = await this.getMintDataFromBank(bank);
+      tokenProgramsByBank.set(bankAddress.toBase58(), mintData.tokenProgram);
+    }
+    const fullParams = {
+      ...params,
+      program: this.client.program,
+      connection: this.client.program.provider.connection,
+      marginfiAccount: this.account,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      assetShareValueMultiplierByBank: this.client.assetShareValueMultiplierByBank,
+      addressLookupTableAccounts: this.client.addressLookupTables,
+      tokenProgramsByBank,
+      groupRateLimiterEnabled: isGroupRateLimiterEnabled(this.client.group.rateLimiter)
+    };
+    return this.account.makeTransferPositionsTx(fullParams);
+  }
   /**
    * Creates a repay with collateral transaction with auto-injected client data.
    *
@@ -75154,6 +75731,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, 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, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, 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, PriceBias, Project0Client, RiskTier, 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, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, 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, computeAssetUsdValue, 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, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, 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, getAssetWeight, 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, getLiabilityWeight, 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, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as 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, resolveAmount, 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, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, 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, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, 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, PriceBias, Project0Client, RiskTier, 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, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, 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, computeAssetUsdValue, 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, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, 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, getAssetWeight, 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, getLiabilityWeight, 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, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as 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, resolveAmount, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map