@0dotxyz/p0-ts-sdk 2.3.0-alpha.3 → 2.3.0-alpha.4

package/dist/index.js

@@ -36191,7 +36191,7 @@ async function makeSetupIx({ connection, authority, tokens }) {
     let ixs = [];
     const userAtaAis = await connection.getMultipleAccountsInfo(userAtas);
     for (const [i, userAta] of userAtaAis.entries()) {
-      const token = tokens[i];
+      const token = uniqueTokens[i];
       const userAtaAddress = userAtas[i];
       if (userAta === null && token && userAtaAddress) {
         ixs.push(
@@ -44608,11 +44608,13 @@ function selectBestRoute(quotes, swapMode) {
 }
 function buildSwapQuoteResult(route, swapMode) {
   const slippageBps = route.slippageBps;
+  const outAmount = Number(route.outAmount);
+  const inAmount = Number(route.inAmount);
   let otherAmountThreshold;
   if (swapMode === "ExactIn") {
-    otherAmountThreshold = String(Math.floor(route.outAmount * (1 - slippageBps / 1e4)));
+    otherAmountThreshold = String(Math.floor(outAmount * (1 - slippageBps / 1e4)));
   } else {
-    otherAmountThreshold = String(Math.ceil(route.inAmount * (1 + slippageBps / 1e4)));
+    otherAmountThreshold = String(Math.ceil(inAmount * (1 + slippageBps / 1e4)));
   }
   return {
     inAmount: String(route.inAmount),
@@ -52005,6 +52007,59 @@ function deriveExponentEventAuthority() {
     EXPONENT_CORE_PROGRAM_ID
   )[0];
 }
+Buffer.from([5]);
+Buffer.from([17]);
+Buffer.from([4]);
+var WRAPPER_MERGE_DISCRIMINATOR = Buffer.from([39]);
+function makeExponentWrapperMergeIx(accounts, args) {
+  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const eventAuthority = deriveExponentEventAuthority();
+  const data = Buffer.alloc(WRAPPER_MERGE_DISCRIMINATOR.length + 9);
+  WRAPPER_MERGE_DISCRIMINATOR.copy(data, 0);
+  data.writeBigUInt64LE(args.amountPyNative, WRAPPER_MERGE_DISCRIMINATOR.length);
+  data.writeUInt8(args.redeemSyAccountsUntil, WRAPPER_MERGE_DISCRIMINATOR.length + 8);
+  const keys = [
+    { pubkey: accounts.owner, isSigner: true, isWritable: true },
+    { pubkey: accounts.syAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.vault, isSigner: false, isWritable: true },
+    { pubkey: accounts.escrowSy, isSigner: false, isWritable: true },
+    { pubkey: accounts.ytAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.ptAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.mintYt, isSigner: false, isWritable: true },
+    { pubkey: accounts.mintPt, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: false, isWritable: true },
+    { pubkey: accounts.addressLookupTable, isSigner: false, isWritable: false },
+    { pubkey: tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.yieldPosition, isSigner: false, isWritable: true },
+    { pubkey: accounts.syProgram, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: eventAuthority, isSigner: false, isWritable: false },
+    { pubkey: EXPONENT_CORE_PROGRAM_ID, isSigner: false, isWritable: false },
+    // [...redeem (flavor SY-redeem accounts), ...cpi (withdraw_sy ++ get_sy_state)]
+    ...accounts.remainingAccounts
+  ];
+  return new TransactionInstruction({ keys, programId: EXPONENT_CORE_PROGRAM_ID, data });
+}
+var SPL_STAKE_POOL_UPDATE_BALANCE_TAG = Buffer.from([7]);
+function makeSplStakePoolUpdateBalanceIx(accounts) {
+  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const keys = [
+    { pubkey: accounts.stakePool, isSigner: false, isWritable: true },
+    { pubkey: accounts.withdrawAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.validatorList, isSigner: false, isWritable: true },
+    { pubkey: accounts.reserveStake, isSigner: false, isWritable: false },
+    { pubkey: accounts.managerFeeAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.poolMint, isSigner: false, isWritable: true },
+    { pubkey: tokenProgram, isSigner: false, isWritable: false }
+  ];
+  return new TransactionInstruction({
+    keys,
+    programId: accounts.stakePoolProgram,
+    data: Buffer.from(SPL_STAKE_POOL_UPDATE_BALANCE_TAG)
+  });
+}
+
+// src/vendor/exponent/utils/resolve.utils.ts
 function resolveCpiMetas(contexts, altAddresses, altKey) {
   return contexts.map((ctx) => {
     const pubkey = altAddresses[ctx.altIndex];
@@ -52016,10 +52071,46 @@ function resolveCpiMetas(contexts, altAddresses, altKey) {
     return { pubkey, isSigner: false, isWritable: ctx.isWritable };
   });
 }
-async function resolveExponentMergeContext(params) {
-  const { connection, owner } = params;
+function uniqueRemainingAccounts(metas) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const m of metas) {
+    const key = m.pubkey.toBase58();
+    const prev = seen.get(key);
+    if (prev) prev.isWritable = prev.isWritable || m.isWritable;
+    else seen.set(key, { ...m });
+  }
+  return [...seen.values()];
+}
+var STAKE_POOL_OFFSETS = {
+  validatorList: 98,
+  reserveStake: 130,
+  poolMint: 162,
+  managerFeeAccount: 194
+};
+async function resolveSplStakePoolRefreshIx(connection, stakePool) {
+  const info = await connection.getAccountInfo(stakePool);
+  if (!info) throw new Error(`SPL stake pool account not found: ${stakePool.toBase58()}`);
+  const stakePoolProgram = info.owner;
+  const at = (off) => new PublicKey(info.data.subarray(off, off + 32));
+  const [withdrawAuthority] = PublicKey.findProgramAddressSync(
+    [stakePool.toBuffer(), Buffer.from("withdraw")],
+    stakePoolProgram
+  );
+  return makeSplStakePoolUpdateBalanceIx({
+    stakePoolProgram,
+    stakePool,
+    withdrawAuthority,
+    validatorList: at(STAKE_POOL_OFFSETS.validatorList),
+    reserveStake: at(STAKE_POOL_OFFSETS.reserveStake),
+    managerFeeAccount: at(STAKE_POOL_OFFSETS.managerFeeAccount),
+    poolMint: at(STAKE_POOL_OFFSETS.poolMint)
+  });
+}
+async function resolveExponentWrapperMergeContext(params) {
+  const { connection, owner, baseMint } = params;
   const ptYtTokenProgram = params.ptYtTokenProgram ?? TOKEN_PROGRAM_ID;
   const syTokenProgram = params.syTokenProgram ?? TOKEN_PROGRAM_ID;
+  const baseTokenProgram = params.baseTokenProgram ?? TOKEN_PROGRAM_ID;
   let vaultAddress;
   let vault;
   if (params.vault) {
@@ -52030,11 +52121,8 @@ async function resolveExponentMergeContext(params) {
     vaultAddress = res.vault;
     vault = res.account;
   } else {
-    throw new Error("resolveExponentMergeContext: one of `vault` or `market` is required");
+    throw new Error("resolveExponentWrapperMergeContext: one of `vault` or `market` is required");
   }
-  const ptSrcAta = getAssociatedTokenAddressSync(vault.mintPt, owner, true, ptYtTokenProgram);
-  const ytSrcAta = getAssociatedTokenAddressSync(vault.mintYt, owner, true, ptYtTokenProgram);
-  const sySrcDstAta = getAssociatedTokenAddressSync(vault.mintSy, owner, true, syTokenProgram);
   const altResult = await connection.getAddressLookupTable(vault.addressLookupTable);
   const alt = altResult.value;
   if (!alt) {
@@ -52042,169 +52130,75 @@ async function resolveExponentMergeContext(params) {
       `Exponent vault address lookup table not found: ${vault.addressLookupTable.toBase58()}`
     );
   }
-  const remainingAccounts = [
-    ...resolveCpiMetas(vault.cpiAccounts.getSyState, alt.state.addresses, vault.addressLookupTable),
-    ...resolveCpiMetas(vault.cpiAccounts.withdrawSy, alt.state.addresses, vault.addressLookupTable)
-  ];
-  const mergeAccounts = {
-    owner,
-    authority: vault.authority,
-    vault: vaultAddress,
-    sySrcDstAta,
-    escrowSy: vault.escrowSy,
-    ytSrcAta,
-    ptSrcAta,
-    mintYt: vault.mintYt,
-    mintPt: vault.mintPt,
-    syProgram: vault.syProgram,
-    addressLookupTable: vault.addressLookupTable,
-    yieldPosition: vault.yieldPosition,
-    tokenProgram: ptYtTokenProgram,
-    remainingAccounts
-  };
-  const decimals = await getMintDecimals(connection, vault.mintSy);
-  return {
-    vaultAddress,
-    vault,
-    mergeAccounts,
-    addressLookupTable: alt,
-    underlying: { mint: vault.mintSy, decimals, tokenProgram: syTokenProgram },
-    computeRedeemedAmountNative(ptAmountNative) {
-      if (vault.ptSupply === 0n) return 0n;
-      const sy = new BigNumber(ptAmountNative.toString()).times(vault.syForPt.toString()).div(vault.ptSupply.toString()).integerValue(BigNumber.ROUND_FLOOR);
-      return BigInt(sy.toFixed(0));
-    }
-  };
-}
-async function resolveExponentStripContext(params) {
-  const { connection, owner } = params;
-  const ptYtTokenProgram = params.ptYtTokenProgram ?? TOKEN_PROGRAM_ID;
-  const syTokenProgram = params.syTokenProgram ?? TOKEN_PROGRAM_ID;
-  let vaultAddress;
-  let vault;
-  if (params.vault) {
-    vaultAddress = params.vault;
-    vault = await fetchExponentVault(connection, vaultAddress);
-  } else if (params.market) {
-    const res = await fetchExponentVaultFromMarket(connection, params.market);
-    vaultAddress = res.vault;
-    vault = res.account;
-  } else {
-    throw new Error("resolveExponentStripContext: one of `vault` or `market` is required");
-  }
-  const altResult = await connection.getAddressLookupTable(vault.addressLookupTable);
-  const alt = altResult.value;
-  if (!alt) {
+  const altKey = vault.addressLookupTable;
+  const getSyState = resolveCpiMetas(vault.cpiAccounts.getSyState, alt.state.addresses, altKey);
+  const withdrawSy = resolveCpiMetas(vault.cpiAccounts.withdrawSy, alt.state.addresses, altKey);
+  if (getSyState.length < 4) {
     throw new Error(
-      `Exponent vault address lookup table not found: ${vault.addressLookupTable.toBase58()}`
+      "resolveExponentWrapperMergeContext: unexpected get_sy_state shape (expected the generic SPL-stake-pool flavor: [syState, mintSy, tokenSyEscrow, stakePool])"
     );
   }
-  const remainingAccounts = resolveCpiMetas(
-    vault.cpiAccounts.depositSy,
-    alt.state.addresses,
-    vault.addressLookupTable
-  );
-  const sySrc = getAssociatedTokenAddressSync(vault.mintSy, owner, true, syTokenProgram);
-  const ptDst = getAssociatedTokenAddressSync(vault.mintPt, owner, true, ptYtTokenProgram);
-  const ytDst = getAssociatedTokenAddressSync(vault.mintYt, owner, true, ptYtTokenProgram);
-  const stripAccounts = {
-    depositor: owner,
-    authority: vault.authority,
+  const syState = getSyState[0].pubkey;
+  const stakePool = getSyState[3].pubkey;
+  const syAta = getAssociatedTokenAddressSync(vault.mintSy, owner, true, syTokenProgram);
+  const ptAta = getAssociatedTokenAddressSync(vault.mintPt, owner, true, ptYtTokenProgram);
+  const ytAta = getAssociatedTokenAddressSync(vault.mintYt, owner, true, ptYtTokenProgram);
+  const baseAta = getAssociatedTokenAddressSync(baseMint, owner, true, baseTokenProgram);
+  const baseEscrow = getAssociatedTokenAddressSync(baseMint, syState, true, baseTokenProgram);
+  const redeem = [
+    { pubkey: owner, isSigner: true, isWritable: true },
+    { pubkey: syState, isSigner: false, isWritable: true },
+    { pubkey: baseAta, isSigner: false, isWritable: true },
+    { pubkey: baseEscrow, isSigner: false, isWritable: true },
+    { pubkey: syAta, isSigner: false, isWritable: true },
+    { pubkey: vault.mintSy, isSigner: false, isWritable: true },
+    { pubkey: baseMint, isSigner: false, isWritable: false },
+    { pubkey: syTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: baseTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: stakePool, isSigner: false, isWritable: true }
+  ];
+  const cpi = uniqueRemainingAccounts([...withdrawSy, ...getSyState]);
+  const wrapperMergeAccounts = {
+    owner,
+    syAta,
     vault: vaultAddress,
-    sySrc,
     escrowSy: vault.escrowSy,
-    ytDst,
-    ptDst,
+    ytAta,
+    ptAta,
     mintYt: vault.mintYt,
     mintPt: vault.mintPt,
-    syProgram: vault.syProgram,
+    authority: vault.authority,
     addressLookupTable: vault.addressLookupTable,
     yieldPosition: vault.yieldPosition,
+    syProgram: vault.syProgram,
     tokenProgram: ptYtTokenProgram,
-    remainingAccounts
+    remainingAccounts: [...redeem, ...cpi],
+    redeemSyAccountsUntil: redeem.length
   };
-  const [syDecimals, ptDecimals] = await Promise.all([
-    getMintDecimals(connection, vault.mintSy),
-    getMintDecimals(connection, vault.mintPt)
+  const [baseDecimals, stakePoolRefreshIx] = await Promise.all([
+    getMintDecimals(connection, baseMint),
+    resolveSplStakePoolRefreshIx(connection, stakePool)
   ]);
-  const syExchangeRate = vault.lastSeenSyExchangeRate.toNumber();
   return {
     vaultAddress,
     vault,
-    stripAccounts,
+    wrapperMergeAccounts,
+    preInstructions: [stakePoolRefreshIx],
     addressLookupTable: alt,
-    sy: { mint: vault.mintSy, decimals: syDecimals, tokenProgram: syTokenProgram },
-    pt: { mint: vault.mintPt, decimals: ptDecimals, tokenProgram: ptYtTokenProgram },
-    yt: { mint: vault.mintYt, tokenProgram: ptYtTokenProgram },
-    syExchangeRate,
-    computeStrippedPtNative(syInNative) {
-      const pt = vault.lastSeenSyExchangeRate.times(syInNative.toString()).integerValue(BigNumber.ROUND_FLOOR);
-      return BigInt(pt.toFixed(0));
+    baseToken: { mint: baseMint, decimals: baseDecimals, tokenProgram: baseTokenProgram },
+    setupMints: [
+      { mint: baseMint, tokenProgram: baseTokenProgram },
+      { mint: vault.mintSy, tokenProgram: syTokenProgram },
+      { mint: vault.mintPt, tokenProgram: ptYtTokenProgram },
+      { mint: vault.mintYt, tokenProgram: ptYtTokenProgram }
+    ],
+    computeRedeemedBaseNative(ptAmountNative) {
+      if (vault.ptSupply === 0n) return 0n;
+      const base = new BigNumber(ptAmountNative.toString()).times(vault.syForPt.toString()).div(vault.ptSupply.toString()).integerValue(BigNumber.ROUND_FLOOR);
+      return BigInt(base.toFixed(0));
     }
   };
 }
-var MERGE_DISCRIMINATOR = Buffer.from([5]);
-function makeExponentMergeIx(accounts, amountNative) {
-  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
-  const eventAuthority = deriveExponentEventAuthority();
-  const data = Buffer.alloc(MERGE_DISCRIMINATOR.length + 8);
-  MERGE_DISCRIMINATOR.copy(data, 0);
-  data.writeBigUInt64LE(amountNative, MERGE_DISCRIMINATOR.length);
-  const keys = [
-    { pubkey: accounts.owner, isSigner: true, isWritable: true },
-    { pubkey: accounts.authority, isSigner: false, isWritable: true },
-    { pubkey: accounts.vault, isSigner: false, isWritable: true },
-    { pubkey: accounts.sySrcDstAta, isSigner: false, isWritable: true },
-    { pubkey: accounts.escrowSy, isSigner: false, isWritable: true },
-    { pubkey: accounts.ytSrcAta, isSigner: false, isWritable: true },
-    { pubkey: accounts.ptSrcAta, isSigner: false, isWritable: true },
-    { pubkey: accounts.mintYt, isSigner: false, isWritable: true },
-    { pubkey: accounts.mintPt, isSigner: false, isWritable: true },
-    { pubkey: tokenProgram, isSigner: false, isWritable: false },
-    { pubkey: accounts.syProgram, isSigner: false, isWritable: false },
-    { pubkey: accounts.addressLookupTable, isSigner: false, isWritable: false },
-    { pubkey: accounts.yieldPosition, isSigner: false, isWritable: true },
-    { pubkey: eventAuthority, isSigner: false, isWritable: false },
-    { pubkey: EXPONENT_CORE_PROGRAM_ID, isSigner: false, isWritable: false },
-    // SY-program CPI accounts (getSyState ++ withdrawSy), ALT-resolved (post-maturity merge
-    // still CPIs into the SY program to move SY out of escrow).
-    ...accounts.remainingAccounts ?? []
-  ];
-  return new TransactionInstruction({
-    keys,
-    programId: EXPONENT_CORE_PROGRAM_ID,
-    data
-  });
-}
-Buffer.from([17]);
-var STRIP_DISCRIMINATOR = Buffer.from([4]);
-function makeExponentStripIx(accounts, amountNative) {
-  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
-  const eventAuthority = deriveExponentEventAuthority();
-  const data = Buffer.alloc(STRIP_DISCRIMINATOR.length + 8);
-  STRIP_DISCRIMINATOR.copy(data, 0);
-  data.writeBigUInt64LE(amountNative, STRIP_DISCRIMINATOR.length);
-  const keys = [
-    { pubkey: accounts.depositor, isSigner: true, isWritable: true },
-    { pubkey: accounts.authority, isSigner: false, isWritable: true },
-    { pubkey: accounts.vault, isSigner: false, isWritable: true },
-    { pubkey: accounts.sySrc, isSigner: false, isWritable: true },
-    { pubkey: accounts.escrowSy, isSigner: false, isWritable: true },
-    { pubkey: accounts.ytDst, isSigner: false, isWritable: true },
-    { pubkey: accounts.ptDst, isSigner: false, isWritable: true },
-    { pubkey: accounts.mintYt, isSigner: false, isWritable: true },
-    { pubkey: accounts.mintPt, isSigner: false, isWritable: true },
-    { pubkey: tokenProgram, isSigner: false, isWritable: false },
-    { pubkey: accounts.addressLookupTable, isSigner: false, isWritable: false },
-    { pubkey: accounts.syProgram, isSigner: false, isWritable: false },
-    { pubkey: accounts.yieldPosition, isSigner: false, isWritable: true },
-    { pubkey: eventAuthority, isSigner: false, isWritable: false },
-    { pubkey: EXPONENT_CORE_PROGRAM_ID, isSigner: false, isWritable: false },
-    // SY-program CPI accounts (depositSy), ALT-resolved.
-    ...accounts.remainingAccounts ?? []
-  ];
-  return new TransactionInstruction({ keys, programId: EXPONENT_CORE_PROGRAM_ID, data });
-}
 
 // src/vendor/klend/utils/klend/interest-rate.utils.ts
 function getKaminoTotalSupply(reserve) {
@@ -57834,93 +57828,6 @@ async function buildSwapDebtFlashloanTx({
     repayIxs
   };
 }
-var DEFAULT_ROLL_SLIPPAGE_BPS = 10;
-async function resolveRoll(params) {
-  const { connection, marginfiAccount, withdrawOpts, rollOpts } = params;
-  const owner = marginfiAccount.authority;
-  const slippageBps = rollOpts.slippageBps ?? DEFAULT_ROLL_SLIPPAGE_BPS;
-  const keepBps = BigInt(1e4 - slippageBps);
-  if (withdrawOpts.withdrawAmount !== void 0 && withdrawOpts.withdrawAmount <= 0) {
-    throw new Error("withdrawAmount must be greater than 0");
-  }
-  const actualWithdrawAmount = Math.min(
-    withdrawOpts.withdrawAmount ?? withdrawOpts.totalPositionAmount,
-    withdrawOpts.totalPositionAmount
-  );
-  const isFullWithdraw = isWholePosition(
-    { amount: withdrawOpts.totalPositionAmount, isLending: true },
-    actualWithdrawAmount,
-    withdrawOpts.withdrawBank.mintDecimals
-  );
-  if (!rollOpts.maturedMarket && !rollOpts.maturedVault) {
-    throw new Error("roll-pt: rollOpts.maturedMarket or maturedVault is required");
-  }
-  const merge = await resolveExponentMergeContext({
-    connection,
-    owner,
-    market: rollOpts.maturedMarket,
-    vault: rollOpts.maturedVault
-  });
-  const withdrawNative = BigInt(
-    uiToNative(actualWithdrawAmount, withdrawOpts.withdrawBank.mintDecimals).toString()
-  );
-  const redeemedSy = merge.computeRedeemedAmountNative(withdrawNative);
-  const syToken = { mint: merge.underlying.mint, tokenProgram: merge.underlying.tokenProgram };
-  let buyInstructions;
-  let buySetupInstructions;
-  let buyLuts;
-  let ptOutNative;
-  if (rollOpts.buy) {
-    buyInstructions = rollOpts.buy.instructions;
-    buySetupInstructions = rollOpts.buy.setupInstructions ?? [];
-    buyLuts = rollOpts.buy.lookupTables ?? [];
-    ptOutNative = rollOpts.buy.ptOutNative;
-  } else {
-    if (!rollOpts.successorVault && !rollOpts.successorMarket) {
-      throw new Error(
-        "roll-pt: rollOpts.successorVault or successorMarket is required (or pass rollOpts.buy)"
-      );
-    }
-    const strip = await resolveExponentStripContext({
-      connection,
-      owner,
-      vault: rollOpts.successorVault,
-      market: rollOpts.successorMarket
-    });
-    const syIn = redeemedSy * keepBps / 10000n;
-    buyInstructions = [makeExponentStripIx(strip.stripAccounts, syIn)];
-    const ytAta = getAssociatedTokenAddressSync(strip.yt.mint, owner, true, strip.yt.tokenProgram);
-    buySetupInstructions = [
-      createAssociatedTokenAccountIdempotentInstruction(
-        owner,
-        ytAta,
-        owner,
-        strip.yt.mint,
-        strip.yt.tokenProgram
-      )
-    ];
-    buyLuts = [strip.addressLookupTable];
-    ptOutNative = strip.computeStrippedPtNative(syIn) * keepBps / 10000n;
-  }
-  const rollLuts = [merge.addressLookupTable, ...buyLuts];
-  if (rollOpts.lookupTable) {
-    const fetched = (await connection.getAddressLookupTable(rollOpts.lookupTable)).value;
-    if (!fetched) {
-      throw new Error(`roll-pt: PT-roll lookup table not found: ${rollOpts.lookupTable.toBase58()}`);
-    }
-    rollLuts.push(fetched);
-  }
-  return {
-    actualWithdrawAmount,
-    isFullWithdraw,
-    mergeAccounts: merge.mergeAccounts,
-    syToken,
-    buyInstructions,
-    buySetupInstructions,
-    ptOutNative,
-    rollLuts
-  };
-}
 async function makeRollPtTx(params) {
   const {
     program,
@@ -57930,30 +57837,46 @@ async function makeRollPtTx(params) {
     oraclePrices,
     withdrawOpts,
     depositOpts,
+    rollOpts,
     assetShareValueMultiplierByBank,
     addressLookupTableAccounts,
     crossbarUrl
   } = params;
-  const resolved = await resolveRoll(params);
+  if (!rollOpts.maturedMarket && !rollOpts.maturedVault) {
+    throw new Error("roll-pt: rollOpts.maturedMarket or maturedVault is required");
+  }
+  const wrapper = await resolveExponentWrapperMergeContext({
+    connection,
+    owner: marginfiAccount.authority,
+    market: rollOpts.maturedMarket,
+    vault: rollOpts.maturedVault,
+    baseMint: rollOpts.baseMint,
+    baseTokenProgram: rollOpts.baseTokenProgram,
+    ptYtTokenProgram: withdrawOpts.tokenProgram
+  });
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
     connection,
     authority: marginfiAccount.authority,
     tokens: [
       { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
-      { mint: resolved.syToken.mint, tokenProgram: resolved.syToken.tokenProgram },
-      { mint: resolved.mergeAccounts.mintYt, tokenProgram: TOKEN_PROGRAM_ID },
+      ...wrapper.setupMints,
       { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
     ]
   });
-  if (resolved.buySetupInstructions.length) {
-    setupIxs.push(...resolved.buySetupInstructions);
-  }
-  const { flashloanTx, withdrawIxs, depositIxs } = await buildRollPtFlashloanTx({
-    params,
-    resolved,
-    blockhash
+  setupIxs.push(...wrapper.preInstructions);
+  const { flashloanTx, setupInstructions, swapQuote, withdrawIxs, depositIxs } = await buildRollPtFlashloanTx({ params, wrapper, blockhash });
+  const swapSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(ComputeBudgetProgram.programId)) return false;
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(depositOpts.depositBank.mint)) {
+        return false;
+      }
+    }
+    return true;
   });
+  setupIxs.push(...swapSetupInstructions);
   const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
     marginfiAccount,
     bankMap,
@@ -57997,12 +57920,12 @@ async function makeRollPtTx(params) {
   return {
     transactions,
     actionTxIndex: transactions.length - 1,
-    quoteResponse: void 0
+    quoteResponse: swapQuote
   };
 }
 async function buildRollPtFlashloanTx({
   params,
-  resolved,
+  wrapper,
   blockhash
 }) {
   const {
@@ -58011,27 +57934,29 @@ async function buildRollPtFlashloanTx({
     bankMap,
     withdrawOpts,
     depositOpts,
+    swapOpts,
     bankMetadataMap,
+    connection,
     addressLookupTableAccounts,
-    overrideInferAccounts
+    overrideInferAccounts,
+    rollOpts,
+    swapEngineRunner
   } = params;
-  const {
-    actualWithdrawAmount,
-    isFullWithdraw,
-    mergeAccounts,
-    buyInstructions,
-    ptOutNative,
-    rollLuts
-  } = resolved;
-  const { withdrawBank, tokenProgram: withdrawTokenProgram } = withdrawOpts;
+  const { withdrawBank, tokenProgram: withdrawTokenProgram, totalPositionAmount, withdrawAmount } = withdrawOpts;
   const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
   const authority = marginfiAccount.authority;
-  if (ptOutNative <= 0n) {
-    throw new Error("roll-pt: ptOutNative (PT to buy) must be greater than 0");
-  }
-  if (buyInstructions.length === 0) {
-    throw new Error("roll-pt: buy leg (SY \u2192 PT_new) must not be empty");
+  if (withdrawAmount !== void 0 && withdrawAmount <= 0) {
+    throw new Error("withdrawAmount must be greater than 0");
   }
+  const actualWithdrawAmount = Math.min(withdrawAmount ?? totalPositionAmount, totalPositionAmount);
+  const isFullWithdraw = isWholePosition(
+    { amount: totalPositionAmount, isLending: true },
+    actualWithdrawAmount,
+    withdrawBank.mintDecimals
+  );
+  const withdrawNative = BigInt(
+    uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toString()
+  );
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
@@ -58048,10 +57973,11 @@ async function buildRollPtFlashloanTx({
     isSync: false,
     opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
   });
-  const mergeIx = makeExponentMergeIx(
-    mergeAccounts,
-    BigInt(uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toString())
-  );
+  const wrapperMergeIx = makeExponentWrapperMergeIx(wrapper.wrapperMergeAccounts, {
+    amountPyNative: withdrawNative,
+    redeemSyAccountsUntil: wrapper.wrapperMergeAccounts.redeemSyAccountsUntil
+  });
+  const redeemIxs = [wrapperMergeIx];
   const depositIxs = await makeDepositIx3({
     program,
     bank: depositBank,
@@ -58062,19 +57988,77 @@ async function buildRollPtFlashloanTx({
     group: marginfiAccount.group,
     opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
   });
+  let baseLuts;
+  if (rollOpts.lookupTable) {
+    const fetched = (await connection.getAddressLookupTable(rollOpts.lookupTable)).value;
+    if (!fetched) {
+      throw new Error(`roll-pt: PT-roll lookup table not found: ${rollOpts.lookupTable.toBase58()}`);
+    }
+    baseLuts = [fetched];
+  } else {
+    baseLuts = [...addressLookupTableAccounts ?? [], wrapper.addressLookupTable];
+  }
+  const nonSwapFootprint = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    ...redeemIxs,
+    ...depositIxs.instructions
+  ];
+  const { sizeConstraint, maxSwapTotalAccounts } = computeFlashLoanNonSwapBudget({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: baseLuts,
+    ixs: nonSwapFootprint
+  });
+  const destinationTokenAccount = getAssociatedTokenAddressSync(
+    depositBank.mint,
+    authority,
+    true,
+    depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+  );
+  const baseAmountNative = wrapper.computeRedeemedBaseNative(withdrawNative);
+  const runEngine = swapEngineRunner ?? runSwapEngine;
+  const engineResult = await runEngine({
+    inputMint: wrapper.baseToken.mint.toBase58(),
+    outputMint: depositBank.mint.toBase58(),
+    amountNative: Number(baseAmountNative),
+    inputDecimals: wrapper.baseToken.decimals,
+    outputDecimals: depositBank.mintDecimals,
+    ...swapEngineQuoteFieldsFromOpts(swapOpts),
+    taker: authority,
+    destinationTokenAccount,
+    connection,
+    footprint: {
+      instructions: nonSwapFootprint,
+      luts: baseLuts,
+      payer: authority,
+      sizeConstraint,
+      maxSwapTotalAccounts
+    },
+    providers: swapEngineProvidersFromOpts(swapOpts)
+  });
   const depositIxToPatch = depositIxs.instructions.find(isDepositIx);
   if (!depositIxToPatch) {
     throw new Error("roll-pt: could not locate deposit instruction for amount patching");
   }
-  patchDepositAmount(depositIxToPatch, new BN11(ptOutNative.toString()));
-  const luts = [...addressLookupTableAccounts ?? [], ...rollLuts];
+  patchDepositAmount(depositIxToPatch, engineResult.outputAmountNative);
+  const luts = [...baseLuts, ...engineResult.swapLuts];
   const allNonFlIxs = [
     ...cuRequestIxs,
     ...withdrawIxs.instructions,
-    mergeIx,
-    ...buyInstructions,
+    ...redeemIxs,
+    ...engineResult.swapInstructions,
     ...depositIxs.instructions
   ];
+  compileFlashloanPrecheck({
+    allIxs: allNonFlIxs,
+    payer: authority,
+    luts,
+    sizeConstraint,
+    swapIxCount: engineResult.swapInstructions.length,
+    swapLutCount: engineResult.swapLuts.length
+  });
   const flashloanTx = await makeFlashLoanTx({
     program,
     marginfiAccount,
@@ -58087,10 +58071,16 @@ async function buildRollPtFlashloanTx({
   const txSize = getTxSize(flashloanTx);
   const totalKeys = getTotalAccountKeys(flashloanTx);
   if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededPositionSwap(txSize, totalKeys);
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
   }
   return {
     flashloanTx,
+    setupInstructions: engineResult.setupInstructions,
+    swapQuote: engineResult.quoteResponse,
     withdrawIxs,
     depositIxs
   };
@@ -62881,9 +62871,10 @@ var MarginfiAccount = class _MarginfiAccount {
   /**
    * Creates a transaction to roll a matured Exponent PT collateral position into its
    * next-maturity PT, in one flash-loan-wrapped bundle
-   * (withdraw PT_old → merge → buy PT_new → deposit). See {@link makeRollPtTx}.
+   * (withdraw PT_old → `wrapper_merge` to base → swap-engine buy PT_new → deposit).
+   * See {@link makeRollPtTx}.
    *
-   * @param params - Roll-PT parameters (`withdrawOpts`/`depositOpts`/`rollOpts`).
+   * @param params - Roll-PT parameters (`withdrawOpts`/`depositOpts`/`swapOpts`/`rollOpts`).
    */
   async makeRollPtTx(params) {
     return makeRollPtTx({
@@ -63415,12 +63406,12 @@ var MarginfiAccountWrapper = class {
   }
   /**
    * Rolls a matured Exponent PT collateral position into its next-maturity PT, with
-   * auto-injected client data (withdraw PT_old → merge → buy PT_new → deposit, flash-loan
-   * wrapped). The buy leg is venue-agnostic — supplied via `rollOpts.buyInstructions`.
+   * auto-injected client data (withdraw PT_old → `wrapper_merge` to base → swap-engine buy
+   * PT_new → deposit, flash-loan wrapped). The full deposit ends up as new PT.
    *
    * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap, addressLookupTables
    *
-   * @param params - Roll-PT parameters (user provides: connection, withdrawOpts, depositOpts, rollOpts, etc.)
+   * @param params - Roll-PT parameters (user provides: connection, withdrawOpts, depositOpts, swapOpts, rollOpts, etc.)
    */
   async makeRollPtTx(params) {
     const fullParams = {