@haven-fi/solauto-sdk 1.0.581 → 1.0.583

package/src/services/rebalance/rebalanceSwapManager.ts

@@ -0,0 +1,218 @@
+import { QuoteResponse } from "@jup-ag/api";
+import { FlashLoanRequirements } from "../../types";
+import { SolautoClient } from "../solauto";
+import { JupSwapManager, SwapParams, SwapInput } from "../swap";
+import { RebalanceValues } from "./rebalanceValues";
+import { RebalanceDirection, TokenType } from "../../generated";
+import {
+  consoleLog,
+  fromBaseUnit,
+  getLiqUtilzationRateBps,
+  maxRepayToBps,
+  safeGetPrice,
+  toBaseUnit,
+  tokenInfo,
+} from "../../utils";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+
+export class RebalanceSwapManager {
+  public swapParams!: SwapParams;
+  public swapQuote?: QuoteResponse;
+  public flBorrowAmount?: bigint;
+
+  private jupSwapManager!: JupSwapManager;
+
+  constructor(
+    private client: SolautoClient,
+    private values: RebalanceValues,
+    private flRequirements?: FlashLoanRequirements,
+    private targetLiqUtilizationRateBps?: number
+  ) {
+    this.jupSwapManager = new JupSwapManager(client.signer);
+  }
+
+  private isBoost() {
+    return this.values.rebalanceDirection === RebalanceDirection.Boost;
+  }
+
+  private usdToSwap() {
+    return Math.abs(this.values.debtAdjustmentUsd);
+  }
+
+  private postRebalanceLiqUtilizationRateBps(swapOutputAmount?: bigint) {
+    let supplyUsd = this.client.solautoPosition.supplyUsd();
+    // TODO: add token balance change
+    let debtUsd = this.client.solautoPosition.debtUsd();
+
+    const outputToken = toWeb3JsPublicKey(
+      this.isBoost()
+        ? this.client.solautoPosition.state().supply.mint
+        : this.client.solautoPosition.state().debt.mint
+    );
+    const swapOutputUsd = swapOutputAmount
+      ? fromBaseUnit(swapOutputAmount, tokenInfo(outputToken).decimals) *
+        (safeGetPrice(outputToken) ?? 0)
+      : this.usdToSwap();
+
+    supplyUsd = this.isBoost()
+      ? supplyUsd + swapOutputUsd
+      : supplyUsd - this.usdToSwap();
+    debtUsd = this.isBoost()
+      ? debtUsd + this.usdToSwap()
+      : debtUsd - swapOutputUsd;
+
+    return getLiqUtilzationRateBps(
+      supplyUsd,
+      debtUsd,
+      this.client.solautoPosition.state().liqThresholdBps ?? 0
+    );
+  }
+
+  private async findSufficientQuote(
+    swapInput: SwapInput,
+    criteria: {
+      minOutputAmount?: bigint;
+      minLiqUtilizationRateBps?: number;
+      maxLiqUtilizationRateBps?: number;
+    }
+  ): Promise<QuoteResponse> {
+    let swapQuote: QuoteResponse;
+    let insufficient: boolean = false;
+
+    for (let i = 0; i < 10; i++) {
+      consoleLog("Finding sufficient quote...");
+      swapQuote = await this.jupSwapManager.getQuote(swapInput);
+
+      const outputAmount = parseInt(swapQuote.outAmount);
+      const postRebalanceRate = this.postRebalanceLiqUtilizationRateBps(
+        BigInt(outputAmount)
+      );
+      insufficient = criteria.minOutputAmount
+        ? outputAmount < Number(criteria.minOutputAmount)
+        : criteria.minLiqUtilizationRateBps
+          ? postRebalanceRate < criteria.minLiqUtilizationRateBps
+          : postRebalanceRate > criteria.maxLiqUtilizationRateBps!;
+
+      if (insufficient) {
+        consoleLog("Insufficient swap quote:", swapQuote);
+        swapInput.amount = this.bigIntWithIncrement(swapInput.amount, 0.01);
+      } else {
+        break;
+      }
+    }
+
+    return swapQuote!;
+  }
+
+  private swapDetails() {
+    const input = this.isBoost()
+      ? this.client.solautoPosition.state().debt
+      : this.client.solautoPosition.state().supply;
+    const output = this.isBoost()
+      ? this.client.solautoPosition.state().supply
+      : this.client.solautoPosition.state().debt;
+
+    let inputAmount = toBaseUnit(
+      this.usdToSwap() / safeGetPrice(input.mint)!,
+      input.decimals
+    );
+
+    return {
+      input,
+      output,
+      inputAmount,
+    };
+  }
+
+  private bigIntWithIncrement(num: bigint, inc: number) {
+    return num + BigInt(Math.round(Number(num) * inc));
+  }
+
+  async setSwapParams(attemptNum: number) {
+    const rebalanceToZero = this.targetLiqUtilizationRateBps === 0;
+    let { input, output, inputAmount } = this.swapDetails();
+
+    let outputAmount = rebalanceToZero
+      ? output.amountUsed.baseUnit +
+        BigInt(
+          Math.round(
+            Number(output.amountUsed.baseUnit) *
+              // Add this small percentage to account for the APR on the debt between now and the transaction
+              0.0001
+          )
+        )
+      : toBaseUnit(
+          this.usdToSwap() / safeGetPrice(output.mint)!,
+          output.decimals
+        );
+
+    const flashLoanRepayFromDebt =
+      !this.isBoost() &&
+      this.flRequirements &&
+      this.flRequirements.liquiditySource === TokenType.Debt;
+
+    const exactOut = flashLoanRepayFromDebt && !rebalanceToZero;
+    const exactIn = !exactOut;
+
+    if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+      inputAmount = this.bigIntWithIncrement(inputAmount, 0.005);
+    }
+
+    const swapAmount = exactOut
+      ? this.flRequirements
+        ? this.bigIntWithIncrement(
+            outputAmount,
+            this.flRequirements.flFeeBps ?? 0
+          )
+        : outputAmount
+      : inputAmount;
+    const swapInput: SwapInput = {
+      inputMint: toWeb3JsPublicKey(input.mint),
+      outputMint: toWeb3JsPublicKey(output.mint),
+      exactIn,
+      exactOut,
+      amount: swapAmount,
+    };
+    consoleLog("Swap input:", swapInput);
+
+    if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+      this.swapQuote = await this.findSufficientQuote(swapInput, {
+        minOutputAmount: rebalanceToZero ? outputAmount : undefined,
+        maxLiqUtilizationRateBps: this.values.repayingCloseToMaxLtv
+          ? maxRepayToBps(
+              this.client.solautoPosition.state().maxLtvBps ?? 0,
+              this.client.solautoPosition.state().liqThresholdBps ?? 0
+            ) - 15
+          : undefined,
+      });
+    }
+
+    if (this.flRequirements) {
+      this.flBorrowAmount = exactOut
+        ? outputAmount
+        : this.swapQuote
+          ? BigInt(parseInt(this.swapQuote.inAmount))
+          : inputAmount;
+    }
+
+    this.swapParams = {
+      ...swapInput,
+      destinationWallet: flashLoanRepayFromDebt
+        ? toWeb3JsPublicKey(this.client.signer.publicKey)
+        : this.client.solautoPosition.publicKey,
+      slippageIncFactor: 0.2 + attemptNum * 0.25,
+    };
+  }
+
+  async getSwapTxData() {
+    const { jupQuote, lookupTableAddresses, setupInstructions, swapIx } =
+      await this.jupSwapManager.getJupSwapTxData(this.swapParams);
+
+    return {
+      swapQuote: jupQuote,
+      lookupTableAddresses,
+      setupInstructions,
+      swapIx,
+    };
+  }
+}

package/src/services/rebalance/rebalanceTxBuilder.ts

@@ -0,0 +1,330 @@
+import { SolautoClient } from "../solauto";
+import {
+  FlashLoanRequirements,
+  RebalanceDetails,
+  TransactionItemInputs,
+} from "../../types";
+import {
+  consoleLog,
+  fromBaseUnit,
+  getMaxLiqUtilizationRateBps,
+  getTokenAccount,
+  hasFirstRebalance,
+  hasLastRebalance,
+  safeGetPrice,
+  tokenInfo,
+} from "../../utils";
+import { getRebalanceValues, RebalanceValues } from "./rebalanceValues";
+import { SolautoFeesBps } from "./solautoFees";
+import {
+  PositionTokenState,
+  RebalanceDirection,
+  RebalanceStep,
+  SolautoRebalanceType,
+  SwapType,
+  TokenBalanceChangeType,
+  TokenType,
+} from "../../generated";
+import { PublicKey } from "@solana/web3.js";
+import { RebalanceSwapManager } from "./rebalanceSwapManager";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import { transactionBuilder } from "@metaplex-foundation/umi";
+
+export class RebalanceTxBuilder {
+  private values!: RebalanceValues;
+  private rebalanceType!: SolautoRebalanceType;
+  private swapManager!: RebalanceSwapManager;
+  private flRequirements?: FlashLoanRequirements;
+
+  constructor(
+    private client: SolautoClient,
+    private targetLiqUtilizationRateBps?: number
+  ) {}
+
+  private async shouldProceedWithRebalance() {
+    return (
+      this.client.solautoPosition.supplyUsd() > 0 &&
+      (this.targetLiqUtilizationRateBps !== undefined ||
+        this.client.solautoPosition.eligibleForRebalance())
+    );
+  }
+
+  private getRebalanceValues(flFee?: number) {
+    return getRebalanceValues(
+      this.client.solautoPosition,
+      new SolautoFeesBps(
+        this.client.isReferred(),
+        this.targetLiqUtilizationRateBps,
+        this.client.solautoPosition.netWorthUsd()
+      ),
+      flFee ?? 0,
+      this.targetLiqUtilizationRateBps
+    );
+  }
+
+  private getFlLiquiditySource(
+    supplyLiquidityAvailable: bigint,
+    debtLiquidityAvailable: bigint
+  ): TokenType | undefined {
+    const debtAdjustmentUsd = Math.abs(this.values.debtAdjustmentUsd);
+
+    const insufficientLiquidity = (
+      amountNeededUsd: number,
+      liquidityAvailable: bigint,
+      tokenMint: PublicKey
+    ) => {
+      return (
+        amountNeededUsd >
+        fromBaseUnit(liquidityAvailable, tokenInfo(tokenMint).decimals) *
+          (safeGetPrice(tokenMint) ?? 0) *
+          0.95
+      );
+    };
+
+    const insufficientSupplyLiquidity = insufficientLiquidity(
+      debtAdjustmentUsd,
+      supplyLiquidityAvailable,
+      this.client.solautoPosition.supplyMint()
+    );
+    const insufficientDebtLiquidity = insufficientLiquidity(
+      debtAdjustmentUsd,
+      debtLiquidityAvailable,
+      this.client.solautoPosition.debtMint()
+    );
+
+    let useDebtLiquidity =
+      this.values.rebalanceDirection === RebalanceDirection.Boost ||
+      insufficientSupplyLiquidity;
+
+    if (useDebtLiquidity) {
+      return !insufficientDebtLiquidity ? TokenType.Debt : undefined;
+    } else {
+      return !insufficientSupplyLiquidity ? TokenType.Supply : undefined;
+    }
+  }
+
+  private async flashLoanRequirements(
+    attemptNum: number
+  ): Promise<FlashLoanRequirements | undefined> {
+    const maxLtvRateBps = getMaxLiqUtilizationRateBps(
+      this.client.solautoPosition.state().maxLtvBps,
+      this.client.solautoPosition.state().liqThresholdBps,
+      0.02
+    );
+
+    if (this.values.intermediaryLiqUtilizationRateBps < maxLtvRateBps) {
+      return undefined;
+    }
+
+    const stdFlLiquiditySource = this.getFlLiquiditySource(
+      this.client.flProvider.liquidityAvailable(TokenType.Supply),
+      this.client.flProvider.liquidityAvailable(TokenType.Debt)
+    );
+
+    if ((attemptNum ?? 0) >= 3 || stdFlLiquiditySource === undefined) {
+      const { supplyBalance, debtBalance } = await this.client.signerBalances();
+      const signerFlLiquiditySource = this.getFlLiquiditySource(
+        supplyBalance,
+        debtBalance
+      );
+
+      if (signerFlLiquiditySource) {
+        return {
+          liquiditySource: signerFlLiquiditySource,
+          signerFlashLoan: true,
+        };
+      } else {
+        throw new Error(`Insufficient liquidity to perform the transaction`);
+      }
+    } else {
+      return {
+        liquiditySource: stdFlLiquiditySource,
+        flFeeBps: this.client.flProvider.flFeeBps(stdFlLiquiditySource),
+      };
+    }
+  }
+
+  private getFlashLoanDetails() {
+    if (!this.flRequirements) {
+      throw new Error("Flash loan requirements data needed");
+    }
+
+    const boosting =
+      this.values.rebalanceDirection === RebalanceDirection.Boost;
+    const useDebtLiquidity =
+      this.flRequirements.liquiditySource === TokenType.Debt;
+
+    let flashLoanToken: PositionTokenState | undefined = undefined;
+    if (boosting || useDebtLiquidity) {
+      flashLoanToken = this.client.solautoPosition.state().debt;
+    } else {
+      flashLoanToken = this.client.solautoPosition.state().supply;
+    }
+
+    return {
+      ...this.flRequirements,
+      baseUnitAmount: this.swapManager.flBorrowAmount!,
+      mint: toWeb3JsPublicKey(flashLoanToken.mint),
+    };
+  }
+
+  private setRebalanceType() {
+    if (this.flRequirements) {
+      const tokenBalanceChangeType = this.values.tokenBalanceChange?.changeType;
+      const firstRebalanceTokenChanges =
+        tokenBalanceChangeType === TokenBalanceChangeType.PreSwapDeposit;
+      const lastRebalanceTokenChanges = [
+        TokenBalanceChangeType.PostSwapDeposit,
+        TokenBalanceChangeType.PostRebalanceWithdrawDebtToken,
+        TokenBalanceChangeType.PostRebalanceWithdrawSupplyToken,
+      ].includes(tokenBalanceChangeType ?? TokenBalanceChangeType.None);
+
+      const swapType = this.swapManager.swapParams.exactIn
+        ? SwapType.ExactIn
+        : SwapType.ExactOut;
+
+      if (
+        (firstRebalanceTokenChanges && swapType === SwapType.ExactIn) ||
+        (lastRebalanceTokenChanges && swapType === SwapType.ExactOut)
+      ) {
+        this.rebalanceType = SolautoRebalanceType.DoubleRebalanceWithFL;
+      } else {
+        this.rebalanceType =
+          swapType === SwapType.ExactOut
+            ? SolautoRebalanceType.FLRebalanceThenSwap
+            : SolautoRebalanceType.FLSwapThenRebalance;
+      }
+    } else {
+      this.rebalanceType = SolautoRebalanceType.Regular;
+    }
+    consoleLog("Rebalance type:", this.rebalanceType);
+  }
+
+  private async setRebalanceDetails(attemptNum: number) {
+    this.values = this.getRebalanceValues();
+    this.flRequirements = await this.flashLoanRequirements(attemptNum);
+
+    if (this.flRequirements?.flFeeBps) {
+      this.values = this.getRebalanceValues(this.flRequirements.flFeeBps);
+    }
+
+    consoleLog("Rebalance values:", this.values);
+    this.swapManager = new RebalanceSwapManager(
+      this.client,
+      this.values,
+      this.flRequirements,
+      this.targetLiqUtilizationRateBps
+    );
+    await this.swapManager.setSwapParams(attemptNum);
+
+    this.setRebalanceType();
+  }
+
+  private async refreshBeforeRebalance() {
+    if (
+      this.client.selfManaged ||
+      this.client.contextUpdates.supplyAdjustment > BigInt(0) ||
+      this.client.contextUpdates.debtAdjustment > BigInt(0)
+    ) {
+      return false;
+    }
+    // Rebalance ix will already refresh internally if position is self managed
+
+    if (!this.client.solautoPosition.data().position) {
+      return true;
+    }
+
+    const utilizationRateDiff = Math.abs(
+      await this.client.solautoPosition.utilizationRateBpsDrift()
+    );
+    consoleLog("Liq utilization rate diff:", utilizationRateDiff);
+
+    if (utilizationRateDiff >= 10) {
+      consoleLog("Refreshing before rebalance");
+      return true;
+    }
+
+    consoleLog("Not refreshing before rebalance");
+    return false;
+  }
+
+  private async assembleTransaction(): Promise<TransactionItemInputs> {
+    const { swapQuote, lookupTableAddresses, setupInstructions, swapIx } =
+      await this.swapManager.getSwapTxData();
+
+    const flashLoanDetails = this.flRequirements
+      ? this.getFlashLoanDetails()
+      : undefined;
+
+    let tx = transactionBuilder();
+
+    if (await this.refreshBeforeRebalance()) {
+      tx = tx.add(this.client.refreshIx());
+    }
+
+    const rebalanceDetails: RebalanceDetails = {
+      values: this.values,
+      rebalanceType: this.rebalanceType,
+      flashLoan: flashLoanDetails,
+      swapQuote,
+      targetLiqUtilizationRateBps: this.targetLiqUtilizationRateBps,
+    };
+
+    const firstRebalance = this.client.rebalanceIx(
+      RebalanceStep.PreSwap,
+      rebalanceDetails
+    );
+    const lastRebalance = this.client.rebalanceIx(
+      RebalanceStep.PostSwap,
+      rebalanceDetails
+    );
+
+    if (!flashLoanDetails) {
+      tx = tx.add([setupInstructions, firstRebalance, swapIx, lastRebalance]);
+    } else {
+      consoleLog("Flash loan details:", flashLoanDetails);
+
+      const exactOut = swapQuote.swapMode === "ExactOut";
+      const addFirstRebalance = hasFirstRebalance(this.rebalanceType);
+      const addLastRebalance = hasLastRebalance(this.rebalanceType);
+
+      const flashBorrowDest = exactOut
+        ? getTokenAccount(
+            this.client.solautoPosition.publicKey,
+            new PublicKey(swapQuote.outputMint)
+          )
+        : getTokenAccount(
+            toWeb3JsPublicKey(this.client.signer.publicKey),
+            new PublicKey(swapQuote.inputMint)
+          );
+
+      tx = tx.add([
+        setupInstructions,
+        this.client.flProvider.flashBorrow(flashLoanDetails, flashBorrowDest),
+        ...(addFirstRebalance ? [firstRebalance] : []),
+        swapIx,
+        ...(addLastRebalance ? [lastRebalance] : []),
+        this.client.flProvider.flashRepay(flashLoanDetails),
+      ]);
+    }
+
+    return {
+      tx,
+      lookupTableAddresses,
+    };
+  }
+
+  public async buildRebalanceTx(
+    attemptNum: number
+  ): Promise<TransactionItemInputs | undefined> {
+    await this.client.solautoPosition.refreshPositionState();
+
+    if (!this.shouldProceedWithRebalance()) {
+      this.client.log("Not eligible for a rebalance");
+      return undefined;
+    }
+
+    await this.setRebalanceDetails(attemptNum);
+    return await this.assembleTransaction();
+  }
+}