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

package/dist/index.cjs

@@ -128,6 +128,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 {
@@ -224,6 +227,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
    */
@@ -69434,6 +69471,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.
    *
@@ -69893,6 +69947,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 = () => [
+  web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
+  web3_js.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 BigNumber3.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 web3_js.TransactionMessage({
+    payerKey: accountA.authority,
+    recentBlockhash: blockhash,
+    instructions: [...preIxs, ...begin.instructions, ...innerIxs, ...end.instructions]
+  }).compileToV0Message(luts);
+  return addTransactionMetadata(new web3_js.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 web3_js.TransactionMessage({
+      payerKey: accountA.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.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) {
@@ -70302,7 +70849,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;
@@ -70310,7 +70857,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) => {
@@ -74341,6 +74888,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.
    *
@@ -75285,6 +75862,7 @@ exports.bankRateLimiterRawToDto = bankRateLimiterRawToDto;
 exports.bankRawToDto = bankRawToDto;
 exports.bigNumberToWrappedI80F48 = bigNumberToWrappedI80F48;
 exports.bpsToPercentile = bpsToPercentile;
+exports.buildCollateralLegIxs = buildCollateralLegIxs;
 exports.calculateApyFromInterest = calculateApyFromInterest;
 exports.calculateInterestFromApy = calculateInterestFromApy;
 exports.capConfidenceInterval = capConfidenceInterval;
@@ -75296,6 +75874,7 @@ exports.checkTitanFeeAccount = checkTitanFeeAccount;
 exports.chunkedGetRawMultipleAccountInfoOrdered = chunkedGetRawMultipleAccountInfoOrdered;
 exports.chunkedGetRawMultipleAccountInfoOrderedWithNulls = chunkedGetRawMultipleAccountInfoOrderedWithNulls;
 exports.chunkedGetRawMultipleAccountInfos = chunkedGetRawMultipleAccountInfos;
+exports.classifyAndValidate = classifyAndValidate;
 exports.compileFlashloanPrecheck = compileFlashloanPrecheck;
 exports.composeBridgedSwap = composeBridgedSwap;
 exports.composeRemainingAccounts = composeRemainingAccounts;
@@ -75530,6 +76109,7 @@ exports.makeSetupIx = makeSetupIx;
 exports.makeSmartCrankSwbFeedIx = makeSmartCrankSwbFeedIx;
 exports.makeSwapCollateralTx = makeSwapCollateralTx;
 exports.makeSwapDebtTx = makeSwapDebtTx;
+exports.makeTransferPositionsTx = makeTransferPositionsTx;
 exports.makeTxPriorityIx = makeTxPriorityIx;
 exports.makeUnwrapSolIx = makeUnwrapSolIx;
 exports.makeUpdateDriftMarketIxs = makeUpdateDriftMarketIxs;