@haven-fi/solauto-sdk 1.0.0

package/src/utils/solauto/rebalanceUtils.ts

@@ -0,0 +1,359 @@
+import { PublicKey } from "@solana/web3.js";
+import { SolautoClient } from "../../clients/solautoClient";
+import { PositionTokenUsage } from "../../generated";
+import {
+  eligibleForNextAutomationPeriod,
+  getAdjustedSettingsFromAutomation,
+  getMaxLiqUtilizationRate,
+  getSolautoFeesBps,
+  getUpdatedValueFromAutomation,
+} from "./generalUtils";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import { QuoteResponse } from "@jup-ag/api";
+import { JupSwapDetails } from "../jupiterUtils";
+import { currentUnixSeconds } from "../generalUtils";
+import {
+  fromBaseUnit,
+  fromBps,
+  getDebtAdjustmentUsd,
+  getLiqUtilzationRateBps,
+  toBaseUnit,
+} from "../numberUtils";
+import { USD_DECIMALS } from "../../constants/generalAccounts";
+import {
+  DEFAULT_LIMIT_GAP_BPS,
+  MIN_POSITION_STATE_FRESHNESS_SECS,
+  PRICES,
+} from "../../constants/solautoConstants";
+
+function getAdditionalAmountToDcaIn(client: SolautoClient): number {
+  const dca = client.solautoPositionActiveDca()!;
+  if (dca.debtToAddBaseUnit === BigInt(0)) {
+    return 0;
+  }
+
+  const debtBalance =
+    Number(client.solautoPositionData?.position.dca.debtToAddBaseUnit ?? 0) +
+    Number(client.livePositionUpdates.debtTaBalanceAdjustment ?? 0);
+  const updatedDebtBalance = getUpdatedValueFromAutomation(
+    debtBalance,
+    0,
+    dca.automation,
+    currentUnixSeconds()
+  );
+
+  return debtBalance - updatedDebtBalance;
+}
+
+function getStandardTargetLiqUtilizationRateBps(client: SolautoClient): number {
+  if (!client.selfManaged) {
+    const adjustedSettings = getAdjustedSettingsFromAutomation(
+      client.solautoPositionSettings()!,
+      currentUnixSeconds()
+    );
+
+    const repayFrom = adjustedSettings.repayToBps - adjustedSettings.repayGap;
+    const boostFrom = adjustedSettings.boostToBps + adjustedSettings.boostGap;
+
+    if (client.solautoPositionState!.liqUtilizationRateBps < boostFrom) {
+      return adjustedSettings.boostToBps;
+    } else if (
+      client.solautoPositionState!.liqUtilizationRateBps > repayFrom ||
+      repayFrom - client.solautoPositionState!.liqUtilizationRateBps <
+        repayFrom * 0.015
+    ) {
+      return adjustedSettings.repayToBps;
+    } else {
+      throw new Error("Invalid rebalance condition");
+    }
+  } else {
+    throw new Error(
+      "This is a self-managed position, a targetLiqUtilizationRateBps must be provided initiate a rebalance"
+    );
+  }
+}
+
+function targetLiqUtilizationRateBpsFromDCA(client: SolautoClient) {
+  const adjustedSettings = getAdjustedSettingsFromAutomation(
+    client.solautoPositionSettings()!,
+    currentUnixSeconds()
+  );
+
+  let targetRateBps = 0;
+  if (client.solautoPositionActiveDca()!.debtToAddBaseUnit > BigInt(0)) {
+    targetRateBps = Math.max(
+      client.solautoPositionState!.liqUtilizationRateBps,
+      adjustedSettings.boostToBps
+    );
+  } else {
+    targetRateBps = adjustedSettings.boostToBps;
+  }
+  return targetRateBps;
+}
+
+function isDcaRebalance(client: SolautoClient): boolean {
+  if (client.solautoPositionActiveDca() === undefined || client.selfManaged) {
+    return false;
+  }
+
+  const adjustedSettings = getAdjustedSettingsFromAutomation(
+    client.solautoPositionSettings()!,
+    currentUnixSeconds()
+  );
+
+  if (
+    client.solautoPositionState!.liqUtilizationRateBps >
+    adjustedSettings.repayToBps + adjustedSettings.repayGap
+  ) {
+    return false;
+  }
+
+  if (client.solautoPositionActiveDca()!.automation.targetPeriods === 0) {
+    return false;
+  }
+
+  if (
+    !eligibleForNextAutomationPeriod(
+      client.solautoPositionActiveDca()!.automation
+    )
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function getTargetRateAndDcaAmount(
+  client: SolautoClient,
+  targetLiqUtilizationRateBps?: number
+): { targetRateBps: number; amountToDcaIn?: number } {
+  if (targetLiqUtilizationRateBps !== undefined) {
+    return {
+      targetRateBps: targetLiqUtilizationRateBps,
+    };
+  }
+
+  if (isDcaRebalance(client)) {
+    const amountToDcaIn = getAdditionalAmountToDcaIn(client);
+    const targetLiqUtilizationRateBps =
+      targetLiqUtilizationRateBpsFromDCA(client);
+
+    return {
+      targetRateBps: targetLiqUtilizationRateBps,
+      amountToDcaIn,
+    };
+  } else {
+    return {
+      targetRateBps:
+        getStandardTargetLiqUtilizationRateBps(client),
+    };
+  }
+}
+
+export interface RebalanceValues {
+  increasingLeverage: boolean;
+  debtAdjustmentUsd: number;
+  amountUsdToDcaIn: number;
+}
+
+export function getRebalanceValues(
+  client: SolautoClient,
+  targetLiqUtilizationRateBps?: number,
+  limitGapBps?: number
+): RebalanceValues {
+  if (
+    client.solautoPositionState === undefined ||
+    client.solautoPositionState.lastUpdated <
+      BigInt(
+        Math.round(currentUnixSeconds() - MIN_POSITION_STATE_FRESHNESS_SECS)
+      )
+  ) {
+    throw new Error("Requires a fresh position state to get rebalance details");
+  }
+
+  const { targetRateBps, amountToDcaIn } = getTargetRateAndDcaAmount(
+    client,
+    targetLiqUtilizationRateBps
+  );
+
+  const amountUsdToDcaIn =
+    fromBaseUnit(
+      BigInt(Math.round(amountToDcaIn ?? 0)),
+      client.solautoPositionState!.debt.decimals
+    ) * PRICES[client.debtLiquidityMint.toString()].price;
+
+  const increasingLeverage =
+    amountUsdToDcaIn > 0 ||
+    client.solautoPositionState!.liqUtilizationRateBps < targetRateBps;
+  let adjustmentFeeBps = 0;
+  if (increasingLeverage) {
+    adjustmentFeeBps = getSolautoFeesBps(
+      client.referredByState !== undefined,
+      client.solautoPositionData!.feeType
+    ).total;
+  }
+
+  const supplyUsd =
+    fromBaseUnit(
+      client.solautoPositionState!.supply.amountUsed.baseAmountUsdValue,
+      USD_DECIMALS
+    ) + amountUsdToDcaIn;
+  const debtUsd = fromBaseUnit(
+    client.solautoPositionState!.debt.amountUsed.baseAmountUsdValue,
+    USD_DECIMALS
+  );
+  let debtAdjustmentUsd = getDebtAdjustmentUsd(
+    client.solautoPositionState!.liqThresholdBps,
+    supplyUsd,
+    debtUsd,
+    targetRateBps,
+    adjustmentFeeBps
+  );
+
+  const input = increasingLeverage
+    ? client.solautoPositionState!.debt
+    : client.solautoPositionState!.supply;
+  const inputMarketPrice = increasingLeverage
+    ? PRICES[client.debtLiquidityMint.toString()].price
+    : PRICES[client.supplyLiquidityMint.toString()].price;
+
+  const limitGap = limitGapBps
+    ? fromBps(limitGapBps)
+    : fromBps(DEFAULT_LIMIT_GAP_BPS);
+
+  if (
+    debtAdjustmentUsd > 0 &&
+    toBaseUnit(debtAdjustmentUsd / inputMarketPrice, input.decimals) >
+      input.amountCanBeUsed.baseUnit
+  ) {
+    const maxUsageUsd =
+      fromBaseUnit(input.amountCanBeUsed.baseUnit, input.decimals) *
+      inputMarketPrice *
+      limitGap;
+    debtAdjustmentUsd = maxUsageUsd - maxUsageUsd * limitGap;
+  }
+
+  return {
+    increasingLeverage,
+    debtAdjustmentUsd,
+    amountUsdToDcaIn,
+  };
+}
+
+export interface FlashLoanDetails {
+  baseUnitAmount: bigint;
+  mint: PublicKey;
+}
+
+export function getFlashLoanDetails(
+  client: SolautoClient,
+  values: RebalanceValues,
+  jupQuote: QuoteResponse
+): FlashLoanDetails | undefined {
+  let supplyUsd = fromBaseUnit(
+    client.solautoPositionState!.supply.amountUsed.baseAmountUsdValue,
+    USD_DECIMALS
+  );
+  let debtUsd = fromBaseUnit(
+    client.solautoPositionState!.debt.amountUsed.baseAmountUsdValue,
+    USD_DECIMALS
+  );
+
+  const debtAdjustmentWithSlippage =
+    Math.abs(values.debtAdjustmentUsd) +
+    Math.abs(values.debtAdjustmentUsd) * fromBps(jupQuote.slippageBps);
+  supplyUsd =
+    values.debtAdjustmentUsd < 0
+      ? supplyUsd - debtAdjustmentWithSlippage
+      : supplyUsd;
+  debtUsd =
+    values.debtAdjustmentUsd > 0
+      ? debtUsd + debtAdjustmentWithSlippage
+      : debtUsd;
+  const tempLiqUtilizationRateBps = getLiqUtilzationRateBps(
+    supplyUsd,
+    debtUsd,
+    client.solautoPositionState!.liqThresholdBps
+  );
+  const requiresFlashLoan =
+    supplyUsd === 0 ||
+    tempLiqUtilizationRateBps >
+      getMaxLiqUtilizationRate(
+        client.solautoPositionState!.maxLtvBps,
+        client.solautoPositionState!.liqThresholdBps
+      );
+
+  let flashLoanToken: PositionTokenUsage | undefined = undefined;
+  let flashLoanTokenPrice = 0;
+  if (values.increasingLeverage) {
+    flashLoanToken = client.solautoPositionState!.debt;
+    flashLoanTokenPrice = PRICES[client.debtLiquidityMint.toString()].price;
+  } else {
+    flashLoanToken = client.solautoPositionState!.supply;
+    flashLoanTokenPrice = PRICES[client.supplyLiquidityMint.toString()].price;
+  }
+
+  const exactAmountBaseUnit =
+    jupQuote && jupQuote.swapMode === "ExactOut"
+      ? BigInt(parseInt(jupQuote.inAmount))
+      : undefined;
+
+  return requiresFlashLoan
+    ? {
+        baseUnitAmount: exactAmountBaseUnit
+          ? exactAmountBaseUnit +
+            BigInt(
+              Math.round(
+                Number(exactAmountBaseUnit) * fromBps(jupQuote.slippageBps)
+              )
+            )
+          : toBaseUnit(
+              debtAdjustmentWithSlippage / flashLoanTokenPrice,
+              flashLoanToken.decimals
+            ),
+        mint: toWeb3JsPublicKey(flashLoanToken.mint),
+      }
+    : undefined;
+}
+
+export function getJupSwapRebalanceDetails(
+  client: SolautoClient,
+  values: RebalanceValues,
+  targetLiqUtilizationRateBps?: number,
+  attemptNum?: number
+): JupSwapDetails {
+  const input = values.increasingLeverage
+    ? client.solautoPositionState!.debt
+    : client.solautoPositionState!.supply;
+  const output = values.increasingLeverage
+    ? client.solautoPositionState!.supply
+    : client.solautoPositionState!.debt;
+
+  const usdToSwap =
+    Math.abs(values.debtAdjustmentUsd) + values.amountUsdToDcaIn;
+
+  const inputPrice = values.increasingLeverage
+    ? PRICES[client.debtLiquidityMint.toString()].price
+    : PRICES[client.supplyLiquidityMint.toString()].price;
+  const inputAmount = toBaseUnit(usdToSwap / inputPrice!, input.decimals);
+
+  const rebalancingToZero = targetLiqUtilizationRateBps === 0;
+  return {
+    inputMint: toWeb3JsPublicKey(input.mint),
+    outputMint: toWeb3JsPublicKey(output.mint),
+    destinationWallet: client.solautoPosition,
+    // slippageBpsIncFactor: (values.increasingLeverage ? 0.1 : 0.2) + ((attemptNum ?? 0) * 0.1),
+    slippageBpsIncFactor: (attemptNum ?? 0) * 0.15,
+    amount: rebalancingToZero
+      ? client.solautoPositionState!.debt.amountUsed.baseUnit +
+        BigInt(
+          Math.round(
+            Number(client.solautoPositionState!.debt.amountUsed.baseUnit) *
+              // Add this small percentage to account for the APR on the debt between now and the transaction
+              0.0001
+          )
+        )
+      : inputAmount,
+    exactOut: rebalancingToZero,
+  };
+}

package/tests/shared.ts

@@ -0,0 +1,15 @@
+import { Signer, createSignerFromKeypair } from "@metaplex-foundation/umi";
+import { Connection, clusterApiUrl } from "@solana/web3.js";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { getSecretKey } from "../src/utils/solanaUtils";
+
+export function setupTest(keypairFilename?: string): Signer {
+  const umi = createUmi(
+    new Connection(clusterApiUrl("mainnet-beta"), "confirmed")
+  );
+  const secretKey = getSecretKey(keypairFilename);
+  const signerKeypair = umi.eddsa.createKeypairFromSecretKey(secretKey);
+  const signer = createSignerFromKeypair(umi, signerKeypair);
+
+  return signer;
+}

package/tests/transactions/solautoMarginfi.ts

@@ -0,0 +1,144 @@
+import { describe, it } from 'mocha';
+import { none, some } from "@metaplex-foundation/umi";
+import { setupTest } from "../shared";
+import {
+  SolautoMarginfiClient,
+  newMarginfiSolautoManagedPositionArgs,
+} from "../../src/clients/solautoMarginfiClient";
+import {
+  solautoAction,
+  SolautoSettingsParametersInpArgs,
+} from "../../src/generated";
+import { buildSolautoRebalanceTransaction } from "../../src/transactions/transactionUtils";
+import { toBaseUnit } from "../../src/utils/numberUtils";
+import { NATIVE_MINT } from "@solana/spl-token";
+import { getTokenPrices } from "../../src/utils/generalUtils";
+import {
+  TransactionItem,
+  TransactionsManager,
+} from "../../src/transactions/transactionsManager";
+
+describe("Solauto Marginfi tests", async () => {
+  const signer = setupTest();
+
+  const payForTransactions = false;
+  const useJitoBundle = false;
+  const positionId = 1;
+
+  it("open - deposit - borrow - rebalance to 0 - withdraw - close", async () => {
+    const client = new SolautoMarginfiClient(true);
+
+    const supply = NATIVE_MINT;
+    const supplyDecimals = 9;
+    const debtDecimals = 6;
+
+    await client.initialize(
+      // newMarginfiSolautoManagedPositionArgs(
+      //   positionId,
+      //   signer,
+      //   supply,
+      //   debt
+      // )
+      {
+        signer,
+        positionId,
+      }
+    );
+
+    const transactionItems: TransactionItem[] = [];
+    const settingParams: SolautoSettingsParametersInpArgs = {
+      boostToBps: 4000,
+      boostGap: 500,
+      repayToBps: 7456,
+      repayGap: 500,
+      automation: none(),
+      targetBoostToBps: none(),
+    };
+
+    if (client.solautoPositionData === null) {
+      transactionItems.push(
+        new TransactionItem(async () => {
+          return {
+            tx: client.openPosition(settingParams),
+          };
+        }, "open position")
+      );
+
+      const initialSupplyUsd = 50;
+      transactionItems.push(
+        new TransactionItem(async () => {
+          const [supplyPrice] = await getTokenPrices([supply]);
+          return {
+            tx: client.protocolInteraction(
+              solautoAction("Deposit", [
+                toBaseUnit(initialSupplyUsd / supplyPrice, supplyDecimals),
+              ])
+            ),
+          };
+        }, "deposit")
+      );
+    }
+
+    // transactionItems.push(
+    //   new TransactionItem(
+    //     async () => ({
+    //       tx: client.updatePositionIx({
+    //         positionId: client.positionId,
+    //         settingParams: some({
+    //           ...settingParams,
+    //           boostGap: 50,
+    //           boostToBps: maxLiqRate,
+    //           repayGap: 200,
+    //           repayToBps: maxLiqRate
+    //         }),
+    //         dca: null,
+    //       }),
+    //     }),
+    //     "update position"
+    //   )
+    // );
+
+    transactionItems.push(
+      new TransactionItem(
+        async (attemptNum) =>
+          await buildSolautoRebalanceTransaction(client, undefined, attemptNum),
+        "rebalance"
+      )
+    );
+
+    // transactionItems.push(
+    //   new TransactionItem(
+    //     async (attemptNum) => await buildSolautoRebalanceTransaction(client, 0),
+    //     "repay all debt"
+    //   )
+    // );
+
+    // transactionItems.push(
+    //   new TransactionItem(
+    //     async () => ({
+    //       tx: client.protocolInteraction(
+    //         solautoAction("Withdraw", [{ __kind: "All" }])
+    //       ),
+    //     }),
+    //     "withdraw"
+    //   )
+    // );
+
+    // transactionItems.push(
+    //   new TransactionItem(
+    //     async () => ({
+    //       tx: client.closePositionIx(),
+    //     }),
+    //     "close position"
+    //   )
+    // );
+
+    await new TransactionsManager(
+      client,
+      transactionItems,
+      undefined,
+      !payForTransactions,
+      useJitoBundle
+    ).send();
+  });
+});

package/tests/unit/lookupTables.ts

@@ -0,0 +1,40 @@
+import { describe, it } from 'mocha';
+import { PublicKey } from "@solana/web3.js";
+import {
+  MARGINFI_ACCOUNTS,
+  MARGINFI_ACCOUNTS_LOOKUP_TABLE,
+} from "../../src/constants/marginfiAccounts";
+import { CONNECTION } from "../../src/constants/solautoConstants";
+
+describe("Assert lookup tables up-to-date", async () => {
+  it("marginfi accounts LUT should have everything", async () => {
+    const lookupTable = await CONNECTION.getAddressLookupTable(
+      new PublicKey(MARGINFI_ACCOUNTS_LOOKUP_TABLE)
+    );
+    if (lookupTable === null) {
+      throw new Error("Lookup table not found");
+    }
+
+    const existingAccounts =
+      lookupTable.value?.state.addresses.map((x) => x.toString()) ?? [];
+
+    for (const key in MARGINFI_ACCOUNTS) {
+      const tokenAccounts = MARGINFI_ACCOUNTS[key];
+      const addresses = [
+        tokenAccounts.mint,
+        tokenAccounts.bank,
+        tokenAccounts.liquidityVault,
+        tokenAccounts.vaultAuthority,
+        tokenAccounts.priceOracle,
+      ];
+
+      if (addresses.find((x) => !existingAccounts.includes(x))) {
+        throw new Error("Marginfi accounts lookup table missing an account");
+      }
+    }
+  });
+
+  it("solauto accounts LUT should have everything", async () => {
+    // TODO
+  });
+});