@kamino-finance/klend-sdk 7.4.0-beta.0 → 7.4.0-beta.1

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -174,7 +174,7 @@ export function estimateDebtRepaymentWithColl(props: {
   slippagePct: Decimal;
   flashLoanFeePct: Decimal;
   kaminoMarket: KaminoMarket;
-  debtTokenMint: Address;
+  debtReserveAddress: Address;
   obligation: KaminoObligation;
   currentSlot: Slot;
 }): Decimal {
@@ -184,15 +184,14 @@ export function estimateDebtRepaymentWithColl(props: {
     slippagePct,
     flashLoanFeePct,
     kaminoMarket,
-    debtTokenMint,
+    debtReserveAddress,
     obligation,
     currentSlot,
   } = props;
   const slippageMultiplier = new Decimal(1.0).add(slippagePct.div('100'));
   const flashLoanFeeMultiplier = new Decimal(1.0).add(flashLoanFeePct.div('100'));
 
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
-
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
   const debtAfterSwap = collAmount.div(slippageMultiplier).div(priceDebtToColl);
   const debtAfterFlashLoanRepay = debtAfterSwap.div(flashLoanFeeMultiplier);
 

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -47,8 +47,8 @@ export type RepayWithCollInitialInputs<QuoteResponse> = {
 
 interface RepayWithCollSwapInputsProps<QuoteResponse> {
   kaminoMarket: KaminoMarket;
-  debtTokenMint: Address;
-  collTokenMint: Address;
+  debtReserveAddress: Address;
+  collReserveAddress: Address;
   owner: TransactionSigner;
   obligation: KaminoObligation;
   referrer: Option<Address>;
@@ -67,9 +67,9 @@ export enum MaxWithdrawLtvCheck {
 }
 
 export async function getRepayWithCollSwapInputs<QuoteResponse>({
-  collTokenMint,
+  collReserveAddress,
   currentSlot,
-  debtTokenMint,
+  debtReserveAddress,
   kaminoMarket,
   owner,
   obligation,
@@ -85,8 +85,10 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   flashLoanInfo: FlashLoanInfo;
   initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
 }> {
-  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
+  const collReserve = kaminoMarket.getExistingReserveByAddress(collReserveAddress);
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
+  const collTokenMint = collReserve.getLiquidityMint();
+  const debtTokenMint = debtReserve.getLiquidityMint();
 
   const {
     repayAmountLamports,
@@ -188,9 +190,9 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   repayAmount,
   isClosingPosition,
   budgetAndPriorityFeeIxs,
-  collTokenMint,
+  collReserveAddress,
   currentSlot,
-  debtTokenMint,
+  debtReserveAddress,
   kaminoMarket,
   owner,
   obligation,
@@ -202,9 +204,9 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   logger = console.log,
 }: RepayWithCollIxsProps<QuoteResponse>): Promise<Array<RepayWithCollIxsResponse<QuoteResponse>>> {
   const { swapInputs, initialInputs } = await getRepayWithCollSwapInputs({
-    collTokenMint,
+    collReserveAddress,
     currentSlot,
-    debtTokenMint,
+    debtReserveAddress,
     kaminoMarket,
     owner,
     obligation,
@@ -219,8 +221,8 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
-  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
+  const collReserve = kaminoMarket.getExistingReserveByAddress(collReserveAddress);
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
 
   // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
   // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
@@ -328,40 +330,40 @@ async function buildRepayWithCollateralIxs<QuoteResponse>(
   // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
   let repayAndWithdrawAction;
   if (maxWithdrawLtvCheck === MaxWithdrawLtvCheck.MAX_LTV) {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      owner,
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns({
+      kaminoMarket: market,
+      repayAmount: isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      repayReserveAddress: debtReserve.address,
+      withdrawAmount: isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      withdrawReserveAddress: collReserve.address,
+      payer: owner,
       currentSlot,
       obligation,
       useV2Ixs,
-      undefined,
-      0,
-      false,
+      scopeRefreshConfig: undefined,
+      extraComputeBudget: 0,
+      includeAtaIxs: false,
       requestElevationGroup,
-      undefined,
-      referrer
-    );
+      initUserMetadata: undefined,
+      referrer,
+    });
   } else {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      owner,
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns({
+      kaminoMarket: market,
+      repayAmount: isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      repayReserveAddress: debtReserve.address,
+      withdrawAmount: isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      withdrawReserveAddress: collReserve.address,
+      payer: owner,
       currentSlot,
       obligation,
-      undefined,
-      0,
-      false,
+      scopeRefreshConfig: undefined,
+      extraComputeBudget: 0,
+      includeAtaIxs: false,
       requestElevationGroup,
-      undefined,
-      referrer
-    );
+      initUserMetadata: undefined,
+      referrer,
+    });
   }
 
   // 4. Swap collateral to debt to repay flash loan

package/src/lending_operations/swap_collateral_operations.ts

@@ -40,14 +40,14 @@ export interface SwapCollIxsInputs<QuoteResponse> {
   isClosingSourceColl: boolean;
 
   /**
-   * The mint of the source collateral token (i.e. the current one).
+   * The address of the source collateral reserve (i.e. the current one).
    */
-  sourceCollTokenMint: Address;
+  sourceCollReserveAddress: Address;
 
   /**
-   * The mint of the target collateral token (i.e. the new one).
+   * The address of the target collateral reserve (i.e. the new one).
    */
-  targetCollTokenMint: Address;
+  targetCollReserveAddress: Address;
 
   /**
    * An elevation group ID that the obligation should end up with after the collateral swap - it will be requested by
@@ -220,7 +220,7 @@ type SwapCollContext<QuoteResponse> = {
 function extractArgsAndContext<QuoteResponse>(
   inputs: SwapCollIxsInputs<QuoteResponse>
 ): [SwapCollArgs, SwapCollContext<QuoteResponse>] {
-  if (inputs.sourceCollTokenMint === inputs.targetCollTokenMint) {
+  if (inputs.sourceCollReserveAddress === inputs.targetCollReserveAddress) {
     throw new Error(`Cannot swap from/to the same collateral`);
   }
   if (inputs.sourceCollSwapAmount.lte(0)) {
@@ -235,8 +235,14 @@ function extractArgsAndContext<QuoteResponse>(
     {
       budgetAndPriorityFeeIxs:
         inputs.budgetAndPriorityFeeIxs || getComputeBudgetAndPriorityFeeIxs(DEFAULT_MAX_COMPUTE_UNITS),
-      sourceCollReserve: inputs.market.getExistingReserveByMint(inputs.sourceCollTokenMint, 'Current collateral'),
-      targetCollReserve: inputs.market.getExistingReserveByMint(inputs.targetCollTokenMint, 'Target collateral'),
+      sourceCollReserve: inputs.market.getExistingReserveByAddress(
+        inputs.sourceCollReserveAddress,
+        'Current collateral'
+      ),
+      targetCollReserve: inputs.market.getExistingReserveByAddress(
+        inputs.targetCollReserveAddress,
+        'Target collateral'
+      ),
       logger: console.log,
       market: inputs.market,
       obligation: inputs.obligation,
@@ -395,22 +401,22 @@ async function getDepositTargetCollIxs(
   context: SwapCollContext<any>
 ): Promise<DepositTargetCollIxs> {
   const removesElevationGroup = mustRemoveElevationGroupBeforeDeposit(context);
-  const depositCollAction = await KaminoAction.buildDepositTxns(
-    context.market,
-    targetCollAmount.mul(context.targetCollReserve.getMintFactor()).toString(), // in lamports
-    context.targetCollReserve.getLiquidityMint(),
-    context.owner,
-    context.obligation,
-    context.useV2Ixs,
-    undefined, // we create the scope refresh ix outside of KaminoAction
-    0, // no extra compute budget
-    false, // we do not need ATA ixs here (we construct and close them ourselves)
-    removesElevationGroup, // we may need to (temporarily) remove the elevation group; the same or a different one will be set on withdraw, if requested
-    { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
-    context.referrer,
-    context.currentSlot,
-    removesElevationGroup ? 0 : undefined // only applicable when removing the group
-  );
+  const depositCollAction = await KaminoAction.buildDepositTxns({
+    kaminoMarket: context.market,
+    amount: targetCollAmount.mul(context.targetCollReserve.getMintFactor()).toString(), // in lamports
+    reserveAddress: context.targetCollReserve.address,
+    owner: context.owner,
+    obligation: context.obligation,
+    useV2Ixs: context.useV2Ixs,
+    scopeRefreshConfig: undefined, // we create the scope refresh ix outside of KaminoAction
+    extraComputeBudget: 0, // no extra compute budget
+    includeAtaIxs: false, // we do not need ATA ixs here (we construct and close them ourselves)
+    requestElevationGroup: removesElevationGroup, // we may need to (temporarily) remove the elevation group; the same or a different one will be set on withdraw, if requested
+    initUserMetadata: { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
+    referrer: context.referrer,
+    currentSlot: context.currentSlot,
+    overrideElevationGroupRequest: removesElevationGroup ? 0 : undefined, // only applicable when removing the group
+  });
   return {
     ixs: KaminoAction.actionToIxs(depositCollAction),
     removesElevationGroup,
@@ -444,27 +450,27 @@ async function getWithdrawSourceCollIxs(
     ? U64_MAX
     : args.sourceCollSwapAmount.mul(context.sourceCollReserve.getMintFactor()).toString();
   const requestedElevationGroup = elevationGroupIdToRequestAfterWithdraw(args, depositRemovedElevationGroup, context);
-  const withdrawCollAction = await KaminoAction.buildWithdrawTxns(
-    context.market,
-    withdrawnSourceCollLamports,
-    context.sourceCollReserve.getLiquidityMint(),
-    context.owner,
-    context.obligation,
-    context.useV2Ixs,
-    undefined, // we create the scope refresh ix outside of KaminoAction
-    0, // no extra compute budget
-    false, // we do not need ATA ixs here (we construct and close them ourselves)
-    requestedElevationGroup !== undefined, // the `elevationGroupIdToRequestAfterWithdraw()` has already decided on this
-    { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
-    context.referrer,
-    context.currentSlot,
-    requestedElevationGroup,
-    context.obligation.deposits.has(context.targetCollReserve.address) // if our obligation already had the target coll...
+  const withdrawCollAction = await KaminoAction.buildWithdrawTxns({
+    kaminoMarket: context.market,
+    amount: withdrawnSourceCollLamports,
+    reserveAddress: context.sourceCollReserve.address,
+    owner: context.owner,
+    obligation: context.obligation,
+    useV2Ixs: context.useV2Ixs,
+    scopeRefreshConfig: undefined, // we create the scope refresh ix outside of KaminoAction
+    extraComputeBudget: 0, // no extra compute budget
+    includeAtaIxs: false, // we do not need ATA ixs here (we construct and close them ourselves)
+    requestElevationGroup: requestedElevationGroup !== undefined, // the `elevationGroupIdToRequestAfterWithdraw()` has already decided on this
+    initUserMetadata: { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
+    referrer: context.referrer,
+    currentSlot: context.currentSlot,
+    overrideElevationGroupRequest: requestedElevationGroup,
+    obligationCustomizations: context.obligation.deposits.has(context.targetCollReserve.address) // if our obligation already had the target coll...
       ? undefined // ... then we need no customizations here, but otherwise...
       : {
           addedDepositReserves: [context.targetCollReserve.address], // ... we need to inform our infra that the obligation now has one more reserve that needs refreshing.
-        }
-  );
+        },
+  });
   return KaminoAction.actionToIxs(withdrawCollAction);
 }