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

package/dist/index.cjs

@@ -44720,6 +44720,52 @@ function deserializeTitanWireInstruction(ix) {
     data: Buffer.from(ix.d)
   });
 }
+var EXPONENT_CORE_PROGRAM_ID = new web3_js.PublicKey(
+  "XP1BRLn8eCYSygrd8er5P4GKdzqKbC3DLoSsS5UYVZy"
+);
+new web3_js.PublicKey(
+  "XPC1MM4dYACDfykNuXYZ5una2DsMDWL24CrYubCvarC"
+);
+new web3_js.PublicKey(
+  "ExponentnaRg3CQbW6dqQNZKXp7gtZ9DGMp1cwC4HAS7"
+);
+var EXPONENT_EVENT_AUTHORITY_SEED = "__event_authority";
+function deriveExponentEventAuthority() {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(EXPONENT_EVENT_AUTHORITY_SEED)],
+    EXPONENT_CORE_PROGRAM_ID
+  )[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 }
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: EXPONENT_CORE_PROGRAM_ID,
+    data
+  });
+}
 
 // src/vendor/klend/utils/klend/interest-rate.utils.ts
 function getKaminoTotalSupply(reserve) {
@@ -50349,6 +50395,249 @@ async function buildSwapDebtFlashloanTx({
     repayIxs
   };
 }
+async function makeRollPtTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    withdrawOpts,
+    depositOpts,
+    mergeAccounts,
+    underlying,
+    assetShareValueMultiplierByBank,
+    addressLookupTableAccounts,
+    crossbarUrl
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
+      { mint: underlying.mint, tokenProgram: underlying.tokenProgram ?? TOKEN_PROGRAM_ID },
+      { mint: mergeAccounts.mintYt, tokenProgram: TOKEN_PROGRAM_ID },
+      { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
+    ]
+  });
+  const { flashloanTx, setupInstructions, swapQuote, withdrawIxs, depositIxs } = await buildRollPtFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const engineSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.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(underlying.mint) || mintKey?.equals(mergeAccounts.mintYt) || mintKey?.equals(depositOpts.depositBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...engineSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  const additionalTxs = [];
+  if (setupIxs.length > 0) {
+    const txs = splitInstructionsToFitTransactions([], setupIxs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.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: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildRollPtFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  withdrawOpts,
+  depositOpts,
+  mergeAccounts,
+  underlying,
+  redeemedAmountNative,
+  swapOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  overrideInferAccounts,
+  blockhash,
+  swapEngineRunner
+}) {
+  const { withdrawBank, tokenProgram: withdrawTokenProgram, totalPositionAmount } = withdrawOpts;
+  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
+  const authority = marginfiAccount.authority;
+  if (withdrawOpts.withdrawAmount !== void 0 && withdrawOpts.withdrawAmount <= 0) {
+    throw new Error("withdrawAmount must be greater than 0");
+  }
+  const actualWithdrawAmount = Math.min(
+    withdrawOpts.withdrawAmount ?? totalPositionAmount,
+    totalPositionAmount
+  );
+  const isFullWithdraw = isWholePosition(
+    { amount: totalPositionAmount, isLending: true },
+    actualWithdrawAmount,
+    withdrawBank.mintDecimals
+  );
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const withdrawIxs = await makeWithdrawIx3({
+    program,
+    bank: withdrawBank,
+    bankMap,
+    tokenProgram: withdrawTokenProgram,
+    amount: actualWithdrawAmount,
+    marginfiAccount,
+    authority,
+    withdrawAll: isFullWithdraw,
+    isSync: false,
+    opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
+  });
+  const mergeIx = makeExponentMergeIx(
+    mergeAccounts,
+    BigInt(uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toString())
+  );
+  const depositIxs = await makeDepositIx3({
+    program,
+    bank: depositBank,
+    tokenProgram: depositTokenProgram,
+    amount: 0,
+    accountAddress: marginfiAccount.address,
+    authority,
+    group: marginfiAccount.group,
+    opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+  });
+  const destinationTokenAccount = getAssociatedTokenAddressSync(
+    depositBank.mint,
+    authority,
+    true,
+    depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+  );
+  const swapConstraints = await computeFlashloanSwapConstraints({
+    program,
+    marginfiAccount,
+    bankMap,
+    bankMetadataMap,
+    addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+    primaryIx: { type: "withdraw", bank: withdrawBank, tokenProgram: withdrawTokenProgram },
+    secondaryIx: { type: "deposit", bank: depositBank, tokenProgram: depositTokenProgram },
+    overrideInferAccounts
+  });
+  const runEngine = swapEngineRunner ?? runSwapEngine;
+  const engineResult = await runEngine({
+    inputMint: underlying.mint.toBase58(),
+    outputMint: depositBank.mint.toBase58(),
+    amountNative: Number(redeemedAmountNative),
+    inputDecimals: underlying.decimals,
+    outputDecimals: depositBank.mintDecimals,
+    ...swapEngineQuoteFieldsFromOpts(swapOpts),
+    taker: authority,
+    destinationTokenAccount,
+    connection,
+    footprint: {
+      instructions: [
+        ...cuRequestIxs,
+        ...withdrawIxs.instructions,
+        mergeIx,
+        ...depositIxs.instructions
+      ],
+      luts: addressLookupTableAccounts ?? [],
+      payer: authority,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.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, engineResult.outputAmountNative);
+  const swapInstructions = engineResult.swapInstructions;
+  const setupInstructions = engineResult.setupInstructions;
+  const swapLookupTables = engineResult.swapLuts;
+  const swapQuote = engineResult.quoteResponse;
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    mergeIx,
+    ...swapInstructions,
+    ...depositIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: authority,
+      luts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
+  }
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: false
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    depositIxs
+  };
+}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -56689,6 +56978,7 @@ exports.makeRefreshKaminoBanksIxs = makeRefreshKaminoBanksIxs;
 exports.makeRepayIx = makeRepayIx3;
 exports.makeRepayTx = makeRepayTx;
 exports.makeRepayWithCollatTx = makeRepayWithCollatTx;
+exports.makeRollPtTx = makeRollPtTx;
 exports.makeSetupIx = makeSetupIx;
 exports.makeSmartCrankSwbFeedIx = makeSmartCrankSwbFeedIx;
 exports.makeSwapCollateralTx = makeSwapCollateralTx;