@haven-fi/solauto-sdk 1.0.581 → 1.0.583

package/src/solautoPosition/marginfiSolautoPositionEx.ts

@@ -0,0 +1,111 @@
+import { PublicKey } from "@solana/web3.js";
+import { SolautoPositionEx } from "./solautoPositionEx";
+import {
+  Bank,
+  fetchMarginfiAccount,
+  MarginfiAccount,
+  safeFetchAllBank,
+} from "../marginfi-sdk";
+import { publicKey } from "@metaplex-foundation/umi";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  calcMarginfiMaxLtvAndLiqThreshold,
+  fetchTokenPrices,
+  getBankLiquidityAvailableBaseUnit,
+  getMarginfiAccountPositionState,
+  toBps,
+} from "../utils";
+import { DEFAULT_MARGINFI_GROUP, MARGINFI_ACCOUNTS } from "../constants";
+
+export class MarginfiSolautoPositionEx extends SolautoPositionEx {
+  private marginfiAccountData: MarginfiAccount | null = null;
+  private supplyBank: Bank | null = null;
+  private debtBank: Bank | null = null;
+
+  public async lendingPool(): Promise<PublicKey> {
+    if (this.lp) {
+      return this.lp;
+    }
+
+    if (
+      !this.marginfiAccountData &&
+      this.lpUserAccount &&
+      !this.lpUserAccount.equals(PublicKey.default)
+    ) {
+      this.marginfiAccountData = await fetchMarginfiAccount(
+        this.umi,
+        publicKey(this.lpUserAccount),
+        { commitment: "confirmed" }
+      );
+      this.lp = toWeb3JsPublicKey(this.marginfiAccountData.group);
+    }
+
+    if (!this.lp) {
+      this.lp = new PublicKey(DEFAULT_MARGINFI_GROUP);
+    }
+
+    return this.lp;
+  }
+
+  async maxLtvAndLiqThresholdBps(): Promise<[number, number]> {
+    if (!this.supplyBank || !this.debtBank) {
+      const group = (await this.lendingPool()).toString();
+      const supplyBank =
+        MARGINFI_ACCOUNTS[group][this.supplyMint().toString()].bank;
+      const debtBank =
+        MARGINFI_ACCOUNTS[group][this.debtMint().toString()].bank;
+
+      [this.supplyBank, this.debtBank] = await safeFetchAllBank(this.umi, [
+        publicKey(supplyBank),
+        publicKey(debtBank),
+      ]);
+    }
+
+    const [supplyPrice] = await fetchTokenPrices([this.supplyMint()]);
+    const [maxLtv, liqThreshold] = calcMarginfiMaxLtvAndLiqThreshold(
+      this.supplyBank,
+      this.debtBank,
+      supplyPrice
+    );
+
+    return [toBps(maxLtv), toBps(liqThreshold)];
+  }
+
+  supplyLiquidityAvailable(): bigint {
+    return getBankLiquidityAvailableBaseUnit(this.supplyBank, false);
+  }
+
+  supplyLiquidityDepositable(): bigint {
+    return getBankLiquidityAvailableBaseUnit(this.supplyBank, true);
+  }
+
+  debtLiquidityAvailable(): bigint {
+    return getBankLiquidityAvailableBaseUnit(this.debtBank, false);
+  }
+
+  async refreshPositionState(): Promise<void> {
+    if (!this.canRefreshPositionState()) {
+      return;
+    }
+
+    const useDesignatedMint = !this._data.position || !this._data.selfManaged;
+    const resp = await getMarginfiAccountPositionState(
+      this.umi,
+      { pk: this.lpUserAccount },
+      await this.lendingPool(),
+      useDesignatedMint
+        ? { mint: toWeb3JsPublicKey(this.state().supply.mint) }
+        : undefined,
+      useDesignatedMint
+        ? { mint: toWeb3JsPublicKey(this.state().debt.mint) }
+        : undefined,
+      this.contextUpdates
+    );
+
+    if (resp) {
+      this.supplyBank = resp.supplyBank;
+      this.debtBank = resp.debtBank;
+      this._data.state = resp.state;
+    }
+  }
+}

package/src/solautoPosition/solautoPositionEx.ts

@@ -0,0 +1,281 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+  DCASettings,
+  fetchSolautoPosition,
+  LendingPlatform,
+  PositionState,
+  SolautoPosition,
+  SolautoSettingsParameters,
+} from "../generated";
+import { Umi } from "@metaplex-foundation/umi";
+import {
+  calcDebtUsd,
+  calcNetWorth,
+  calcNetWorthUsd,
+  calcSupplyUsd,
+  calcTotalDebt,
+  calcTotalSupply,
+  consoleLog,
+  ContextUpdates,
+  currentUnixSeconds,
+  debtLiquidityUsdAvailable,
+  maxBoostToBps,
+  maxRepayToBps,
+  positionStateWithLatestPrices,
+  safeGetPrice,
+  solautoStrategyName,
+  supplyLiquidityUsdDepositable,
+} from "../utils";
+import { RebalanceAction } from "../types";
+import { getDebtAdjustment } from "../services/rebalance";
+import { MIN_POSITION_STATE_FRESHNESS_SECS } from "../constants";
+import {
+  fromWeb3JsPublicKey,
+  toWeb3JsPublicKey,
+} from "@metaplex-foundation/umi-web3js-adapters";
+
+export interface PositionCustomArgs {
+  lendingPlatform: LendingPlatform;
+  supplyMint?: PublicKey;
+  debtMint?: PublicKey;
+  lendingPool?: PublicKey;
+  lpUserAccount?: PublicKey;
+}
+
+interface SolautoPositionExData extends Partial<SolautoPosition> {
+  state: PositionState;
+}
+
+interface PositionExArgs {
+  umi: Umi;
+  publicKey: PublicKey;
+  data: SolautoPositionExData;
+  customArgs?: PositionCustomArgs;
+  contextUpdates?: ContextUpdates;
+}
+
+export abstract class SolautoPositionEx {
+  public umi!: Umi;
+  public publicKey!: PublicKey;
+  protected _data!: SolautoPositionExData;
+  protected lp?: PublicKey = undefined;
+  public lpUserAccount?: PublicKey = undefined;
+  protected contextUpdates?: ContextUpdates;
+
+  private readonly firstState!: PositionState;
+
+  constructor(args: PositionExArgs) {
+    this.umi = args.umi;
+    this.publicKey = args.publicKey;
+    this.contextUpdates = args.contextUpdates;
+
+    this.lp = args.customArgs?.lendingPool;
+    this.lpUserAccount =
+      args.customArgs?.lpUserAccount ??
+      (args.data.position
+        ? toWeb3JsPublicKey(args.data.position!.protocolUserAccount)
+        : undefined);
+
+    this._data = args.data;
+    this.firstState = { ...args.data.state };
+  }
+
+  abstract lendingPool(): Promise<PublicKey>;
+
+  exists() {
+    return this._data.position !== undefined;
+  }
+
+  strategyName() {
+    return solautoStrategyName(
+      toWeb3JsPublicKey(this.state().supply.mint),
+      toWeb3JsPublicKey(this.state().debt.mint)
+    );
+  }
+
+  data(): SolautoPositionExData {
+    return this._data;
+  }
+
+  state(): PositionState {
+    return this.data().state;
+  }
+
+  settings(): SolautoSettingsParameters | undefined {
+    return this.contextUpdates?.settings ?? this.data().position?.settings;
+  }
+
+  dca(): DCASettings | undefined {
+    return this.contextUpdates?.dca ?? this.data().position?.dca;
+  }
+
+  supplyMint(): PublicKey {
+    return toWeb3JsPublicKey(this.state().supply.mint);
+  }
+
+  debtMint(): PublicKey {
+    return toWeb3JsPublicKey(this.state().debt.mint);
+  }
+
+  boostToBps() {
+    return Math.min(
+      this.settings()?.boostToBps ?? 0,
+      maxBoostToBps(this.state().maxLtvBps, this.state().liqThresholdBps)
+    );
+  }
+
+  boostFromBps() {
+    return this.boostToBps() - (this.settings()?.boostGap ?? 0);
+  }
+
+  repayToBps() {
+    return Math.min(
+      this.settings()?.repayToBps ?? 0,
+      maxRepayToBps(this.state().maxLtvBps, this.state().liqThresholdBps)
+    );
+  }
+
+  repayFromBps() {
+    return (
+      (this.settings()?.repayToBps ?? 0) + (this.settings()?.repayGap ?? 0)
+    );
+  }
+
+  netWorth() {
+    return calcNetWorth(this.state());
+  }
+
+  netWorthUsd() {
+    return calcNetWorthUsd(this.state());
+  }
+
+  totalSupply() {
+    return calcTotalSupply(this.state());
+  }
+
+  supplyUsd() {
+    return calcSupplyUsd(this.state());
+  }
+
+  totalDebt() {
+    return calcTotalDebt(this.state());
+  }
+
+  debtUsd() {
+    return calcDebtUsd(this.state());
+  }
+
+  supplyLiquidityUsdDepositable() {
+    return supplyLiquidityUsdDepositable(this.state());
+  }
+
+  debtLiquidityUsdAvailable() {
+    return debtLiquidityUsdAvailable(this.state());
+  }
+
+  abstract maxLtvAndLiqThresholdBps(): Promise<[number, number]>;
+  abstract supplyLiquidityDepositable(): bigint;
+  abstract supplyLiquidityAvailable(): bigint;
+  abstract debtLiquidityAvailable(): bigint;
+
+  sufficientLiquidityToBoost() {
+    const limitsUpToDate =
+      this.debtLiquidityUsdAvailable() !== 0 ||
+      this.supplyLiquidityUsdDepositable() !== 0;
+
+    if (limitsUpToDate) {
+      const { debtAdjustmentUsd } = getDebtAdjustment(
+        this.state().liqThresholdBps,
+        { supplyUsd: this.supplyUsd(), debtUsd: this.debtUsd() },
+        { solauto: 50, lpBorrow: 50, flashLoan: 50 }, // TODO: add better fix here instead of magic numbers
+        this.boostToBps()
+      );
+
+      const sufficientLiquidity =
+        this.debtLiquidityUsdAvailable() * 0.95 > debtAdjustmentUsd &&
+        this.supplyLiquidityUsdDepositable() * 0.95 > debtAdjustmentUsd;
+
+      if (!sufficientLiquidity) {
+        consoleLog("Insufficient liquidity to further boost");
+      }
+      return sufficientLiquidity;
+    }
+
+    return true;
+  }
+
+  eligibleForRebalance(bpsDistanceThreshold = 0): RebalanceAction | undefined {
+    if (!this.settings() || !calcSupplyUsd(this.state())) {
+      return undefined;
+    }
+
+    if (
+      this.state().liqUtilizationRateBps - this.boostFromBps() <=
+      bpsDistanceThreshold
+    ) {
+      const sufficientLiquidity = this.sufficientLiquidityToBoost();
+      return sufficientLiquidity ? "boost" : undefined;
+    } else if (
+      this.repayFromBps() - this.state().liqUtilizationRateBps <=
+      bpsDistanceThreshold
+    ) {
+      return "repay";
+    }
+
+    return undefined;
+  }
+
+  eligibleForRefresh(): boolean {
+    if (this._data.selfManaged) return false;
+
+    return (
+      currentUnixSeconds() - Number(this.state().lastRefreshed) >
+      60 * 60 * 24 * 7
+    );
+  }
+
+  protected canRefreshPositionState() {
+    if (
+      Number(this.state().lastRefreshed) >
+        currentUnixSeconds() - MIN_POSITION_STATE_FRESHNESS_SECS &&
+      !this.contextUpdates?.positionUpdates()
+    ) {
+      return false;
+    }
+    return true;
+  }
+
+  abstract refreshPositionState(): Promise<void>;
+
+  async utilizationRateBpsDrift() {
+    const supplyPrice = safeGetPrice(this.state().supply.mint) ?? 0;
+    const debtPrice = safeGetPrice(this.state().debt.mint) ?? 0;
+    const oldState = await positionStateWithLatestPrices(
+      this.firstState,
+      supplyPrice,
+      debtPrice
+    );
+    const newState = await positionStateWithLatestPrices(
+      this.state(),
+      supplyPrice,
+      debtPrice
+    );
+
+    return newState.liqUtilizationRateBps - oldState.liqUtilizationRateBps;
+  }
+
+  async updateWithLatestPrices(supplyPrice?: number, debtPrice?: number) {
+    this._data.state = await positionStateWithLatestPrices(
+      this.state(),
+      supplyPrice,
+      debtPrice
+    );
+  }
+
+  async refetchPositionData() {
+    this._data = await fetchSolautoPosition(
+      this.umi,
+      fromWeb3JsPublicKey(this.publicKey)
+    );
+  }
+}

package/src/solautoPosition/utils.ts

@@ -0,0 +1,188 @@
+import { Umi } from "@metaplex-foundation/umi";
+import {
+  LendingPlatform,
+  PositionState,
+  safeFetchAllSolautoPosition,
+  safeFetchSolautoPosition,
+  SolautoSettingsParameters,
+  SolautoSettingsParametersInpArgs,
+} from "../generated";
+import { PublicKey } from "@solana/web3.js";
+import { PositionCustomArgs, SolautoPositionEx } from "./solautoPositionEx";
+import {
+  fromWeb3JsPublicKey,
+  toWeb3JsPublicKey,
+} from "@metaplex-foundation/umi-web3js-adapters";
+import { MarginfiSolautoPositionEx } from "./marginfiSolautoPositionEx";
+import {
+  ContextUpdates,
+  currentUnixSeconds,
+  getBatches,
+  getLiqUtilzationRateBps,
+  retryWithExponentialBackoff,
+  toBaseUnit,
+  toRoundedUsdValue,
+} from "../utils";
+import { TOKEN_INFO } from "../constants";
+
+export function createSolautoSettings(
+  settings: SolautoSettingsParametersInpArgs
+): SolautoSettingsParameters {
+  return {
+    boostGap: settings.boostGap,
+    boostToBps: settings.boostToBps,
+    repayGap: settings.repayGap,
+    repayToBps: settings.repayToBps,
+    padding: [],
+  };
+}
+
+export async function getPositionExBulk(
+  umi: Umi,
+  publicKeys: PublicKey[]
+): Promise<SolautoPositionEx[]> {
+  const batches = getBatches(publicKeys, 30);
+
+  const data = (
+    await Promise.all(
+      batches.map(async (pubkeys) => {
+        return retryWithExponentialBackoff(
+          async () =>
+            await safeFetchAllSolautoPosition(
+              umi,
+              pubkeys.map((x) => fromWeb3JsPublicKey(x))
+            )
+        );
+      })
+    )
+  ).flat();
+
+  return data.map((x) => {
+    switch (x.position.lendingPlatform) {
+      case LendingPlatform.Marginfi:
+        return new MarginfiSolautoPositionEx({
+          umi,
+          publicKey: toWeb3JsPublicKey(x.publicKey),
+          data: x,
+        });
+      // TODO: PF
+    }
+  });
+}
+
+export async function getOrCreatePositionEx(
+  umi: Umi,
+  publicKey: PublicKey,
+  customArgs?: PositionCustomArgs,
+  contextUpdates?: ContextUpdates
+): Promise<SolautoPositionEx> {
+  const data = await safeFetchSolautoPosition(
+    umi,
+    fromWeb3JsPublicKey(publicKey)
+  );
+
+  const placeholderState = createFakePositionState(
+    {
+      mint: customArgs?.supplyMint ?? PublicKey.default,
+    },
+    { mint: customArgs?.debtMint ?? PublicKey.default },
+    0,
+    0
+  );
+
+  const lendingPlatform = data
+    ? data.position.lendingPlatform
+    : customArgs!.lendingPlatform;
+
+  switch (lendingPlatform) {
+    case LendingPlatform.Marginfi:
+      return new MarginfiSolautoPositionEx({
+        umi,
+        publicKey,
+        data: data ?? {
+          state: placeholderState!,
+        },
+        customArgs,
+        contextUpdates,
+      });
+    // TODO: PF
+  }
+}
+
+interface AssetProps {
+  mint: PublicKey;
+  price?: number;
+  amountUsed?: number;
+  amountCanBeUsed?: number;
+}
+
+export function createFakePositionState(
+  supply: AssetProps,
+  debt: AssetProps,
+  maxLtvBps: number,
+  liqThresholdBps: number
+): PositionState {
+  const supplyDecimals = TOKEN_INFO[supply.mint.toString()].decimals;
+  const debtDecimals = TOKEN_INFO[debt.mint.toString()].decimals;
+
+  const supplyUsd = (supply.amountUsed ?? 0) * (supply.price ?? 0);
+  const debtUsd = (debt.amountUsed ?? 0) * (debt.price ?? 0);
+
+  return {
+    liqUtilizationRateBps: getLiqUtilzationRateBps(
+      supplyUsd,
+      debtUsd,
+      liqThresholdBps
+    ),
+    supply: {
+      amountUsed: {
+        baseUnit: toBaseUnit(supply.amountUsed ?? 0, supplyDecimals),
+        baseAmountUsdValue: toRoundedUsdValue(supplyUsd),
+      },
+      amountCanBeUsed: {
+        baseUnit: toBaseUnit(supply.amountCanBeUsed ?? 0, supplyDecimals),
+        baseAmountUsdValue: toRoundedUsdValue(
+          (supply.amountCanBeUsed ?? 0) * (supply.price ?? 0)
+        ),
+      },
+      baseAmountMarketPriceUsd: toRoundedUsdValue(supply.price ?? 0),
+      borrowFeeBps: 0,
+      decimals: supplyDecimals,
+      mint: fromWeb3JsPublicKey(supply.mint),
+      padding1: [],
+      padding2: [],
+      padding: new Uint8Array([]),
+    },
+    debt: {
+      amountUsed: {
+        baseUnit: toBaseUnit(debt.amountUsed ?? 0, debtDecimals),
+        baseAmountUsdValue: toRoundedUsdValue(debtUsd),
+      },
+      amountCanBeUsed: {
+        baseUnit: toBaseUnit(debt.amountCanBeUsed ?? 0, debtDecimals),
+        baseAmountUsdValue: toRoundedUsdValue(
+          (debt.amountCanBeUsed ?? 0) * (debt.price ?? 0)
+        ),
+      },
+      baseAmountMarketPriceUsd: toRoundedUsdValue(debt.price ?? 0),
+      borrowFeeBps: 0,
+      decimals: debtDecimals,
+      mint: fromWeb3JsPublicKey(debt.mint),
+      padding1: [],
+      padding2: [],
+      padding: new Uint8Array([]),
+    },
+    netWorth: {
+      baseUnit: supply.price
+        ? toBaseUnit((supplyUsd - debtUsd) / supply.price, supplyDecimals)
+        : BigInt(0),
+      baseAmountUsdValue: toRoundedUsdValue(supplyUsd - debtUsd),
+    },
+    maxLtvBps,
+    liqThresholdBps,
+    lastRefreshed: BigInt(currentUnixSeconds()),
+    padding1: [],
+    padding2: [],
+    padding: [],
+  };
+}

package/src/types/solauto.ts

@@ -1,6 +1,13 @@
 import { PublicKey } from "@solana/web3.js";
-import { LendingPlatform, PositionType } from "../generated";
+import {
+  LendingPlatform,
+  PositionType,
+  SolautoRebalanceType,
+  TokenType,
+} from "../generated";
 import { TransactionBuilder } from "@metaplex-foundation/umi";
+import { RebalanceValues } from "../services/rebalance";
+import { QuoteResponse } from "@jup-ag/api";
 
 export interface SolautoPositionDetails {
   publicKey?: PublicKey;
@@ -22,7 +29,9 @@ export enum PriorityFeeSetting {
   VeryHigh = "VeryHigh",
 }
 
-export const priorityFeeSettingValues = Object.values(PriorityFeeSetting) as PriorityFeeSetting[];
+export const priorityFeeSettingValues = Object.values(
+  PriorityFeeSetting
+) as PriorityFeeSetting[];
 
 export type RebalanceAction = "boost" | "repay" | "dca";
 
@@ -33,3 +42,22 @@ export interface TransactionItemInputs {
   lookupTableAddresses?: string[];
   orderPrio?: number;
 }
+
+export interface FlashLoanRequirements {
+  liquiditySource: TokenType;
+  signerFlashLoan?: boolean;
+  flFeeBps?: number;
+}
+
+export interface FlashLoanDetails extends FlashLoanRequirements {
+  baseUnitAmount: bigint;
+  mint: PublicKey;
+}
+
+export interface RebalanceDetails {
+  values: RebalanceValues;
+  rebalanceType: SolautoRebalanceType;
+  flashLoan?: FlashLoanDetails;
+  swapQuote: QuoteResponse;
+  targetLiqUtilizationRateBps?: number;
+}

package/src/utils/generalUtils.ts

@@ -4,7 +4,7 @@ import { TOKEN_INFO, TokenInfo } from "../constants";
 import axios from "axios";
 
 export function consoleLog(...args: any[]): void {
-  if ((globalThis as any).LOCAL_TEST) {
+  if ((globalThis as any).SHOW_LOGS) {
     console.log(...args);
   }
 }
@@ -36,6 +36,14 @@ export function tokenInfoByTicker(ticker: string) {
   return undefined;
 }
 
+export function getBatches<T>(items: T[], batchSize: number): T[][] {
+  const batches: T[][] = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+
 export function generateRandomU8(): number {
   return Math.floor(Math.random() * 255 + 1);
 }

package/src/utils/index.ts

@@ -1,10 +1,10 @@
-export * from "./solauto/index";
 export * from "./accountUtils";
 export * from "./generalUtils";
 export * from "./jupiterUtils";
 export * from "./marginfiUtils";
 export * from "./numberUtils";
+export * from "./solautoUtils";
 export * from "./solanaUtils";
 export * from "./stringUtils";
 export * from "./priceUtils";
-export * from "./switchboardUtils";
+export * from "./switchboardUtils";

package/src/utils/jitoUtils.ts

@@ -3,12 +3,10 @@ import {
   PublicKey,
   SimulatedTransactionResponse,
   TransactionExpiredBlockheightExceededError,
-  VersionedMessage,
   VersionedTransaction,
 } from "@solana/web3.js";
 import { toWeb3JsTransaction } from "@metaplex-foundation/umi-web3js-adapters";
 import {
-  JITO_BLOCK_ENGINE,
   JITO_TIP_ACCOUNTS,
 } from "../constants/solautoConstants";
 import {
@@ -17,7 +15,6 @@ import {
   Umi,
   WrappedInstruction,
   TransactionMessage,
-  AddressLookupTableInput,
 } from "@metaplex-foundation/umi";
 import {
   assembleFinalTransaction,
@@ -31,7 +28,6 @@ import {
   retryWithExponentialBackoff,
 } from "./generalUtils";
 import { PriorityFeeSetting, TransactionRunType } from "../types";
-import axios from "axios";
 import base58 from "bs58";
 import { BundleSimulationError } from "../types/transactions";
 import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";