@haven-fi/solauto-sdk 1.0.581 → 1.0.583

package/src/services/rebalance/rebalanceValues.ts

@@ -0,0 +1,232 @@
+import {
+  RebalanceDirection,
+  TokenBalanceChange,
+  TokenBalanceChangeType,
+} from "../../generated";
+import { SolautoPositionEx } from "../../solautoPosition";
+import {
+  fromBps,
+  getLiqUtilzationRateBps,
+  maxRepayToBps,
+  toBps,
+} from "../../utils";
+import { SolautoFeesBps } from "./solautoFees";
+
+export interface PositionValues {
+  supplyUsd: number;
+  debtUsd: number;
+}
+
+export interface DebtAdjustment {
+  debtAdjustmentUsd: number;
+  endResult: PositionValues;
+  intermediaryLiqUtilizationRateBps: number;
+}
+
+export interface RebalanceFeesBps {
+  solauto: number;
+  lpBorrow: number;
+  flashLoan: number;
+}
+
+interface ApplyDebtAdjustmentResult {
+  newPos: PositionValues;
+  intermediaryLiqUtilizationRateBps: number;
+}
+
+export function applyDebtAdjustmentUsd(
+  debtAdjustmentUsd: number,
+  pos: PositionValues,
+  fees: RebalanceFeesBps,
+  liqThreshold: number
+): ApplyDebtAdjustmentResult {
+  const newPos = { ...pos };
+  const isBoost = debtAdjustmentUsd > 0;
+
+  const daMinusSolautoFees =
+    debtAdjustmentUsd - debtAdjustmentUsd * fromBps(fees.solauto);
+  const daWithFlashLoan = debtAdjustmentUsd * (1.0 + fromBps(fees.flashLoan));
+
+  let intermediaryLiqUtilizationRateBps = 0;
+  if (isBoost) {
+    newPos.debtUsd +=
+      daWithFlashLoan * fromBps(fees.lpBorrow) + daWithFlashLoan;
+    intermediaryLiqUtilizationRateBps = getLiqUtilzationRateBps(
+      newPos.supplyUsd,
+      newPos.debtUsd,
+      toBps(liqThreshold)
+    );
+    newPos.supplyUsd += daMinusSolautoFees;
+  } else {
+    newPos.supplyUsd += daWithFlashLoan;
+    intermediaryLiqUtilizationRateBps = getLiqUtilzationRateBps(
+      newPos.supplyUsd,
+      newPos.debtUsd,
+      toBps(liqThreshold)
+    );
+    newPos.debtUsd += daMinusSolautoFees;
+  }
+
+  return { newPos, intermediaryLiqUtilizationRateBps };
+}
+
+export function getDebtAdjustment(
+  liqThreshold: number,
+  pos: PositionValues,
+  fees: RebalanceFeesBps,
+  targetLiqUtilizationRateBps: number
+): DebtAdjustment {
+  const isBoost =
+    getLiqUtilzationRateBps(pos.supplyUsd, pos.debtUsd, toBps(liqThreshold)) <
+    targetLiqUtilizationRateBps;
+
+  const targetUtilizationRate = fromBps(targetLiqUtilizationRateBps);
+  const actualizedFee = 1.0 - fromBps(fees.solauto);
+  const flFee = fromBps(fees.flashLoan);
+  const lpBorrowFee = fromBps(fees.lpBorrow);
+
+  const debtAdjustmentUsd = isBoost
+    ? (targetUtilizationRate * liqThreshold * pos.supplyUsd - pos.debtUsd) /
+      (1.0 +
+        lpBorrowFee +
+        flFee -
+        targetUtilizationRate * actualizedFee * liqThreshold)
+    : (targetUtilizationRate * liqThreshold * pos.supplyUsd - pos.debtUsd) /
+      (actualizedFee - targetUtilizationRate * liqThreshold * (1.0 + flFee));
+
+  const newPos = applyDebtAdjustmentUsd(
+    debtAdjustmentUsd,
+    pos,
+    fees,
+    liqThreshold
+  );
+
+  return {
+    debtAdjustmentUsd,
+    endResult: newPos.newPos,
+    intermediaryLiqUtilizationRateBps: newPos.intermediaryLiqUtilizationRateBps,
+  };
+}
+
+function getTokenBalanceChange(): TokenBalanceChange | undefined {
+  // TODO: DCA, limit orders, take profit, stop loss, etc.
+  return undefined;
+}
+
+function getTargetLiqUtilizationRateBps(
+  solautoPosition: SolautoPositionEx,
+  targetLiqUtilizationRateBps: number | undefined,
+  tokenBalanceChange: TokenBalanceChange | undefined
+): number {
+  if (targetLiqUtilizationRateBps !== undefined) {
+    return targetLiqUtilizationRateBps;
+  }
+
+  const currentRate = solautoPosition.state().liqUtilizationRateBps;
+
+  if (currentRate <= solautoPosition.boostFromBps()) {
+    return solautoPosition.settings()!.boostToBps;
+  } else if (currentRate >= solautoPosition.repayFromBps()) {
+    return solautoPosition.settings()!.repayToBps;
+  }
+  // TODO: DCA, limit orders, take profit, stop loss, etc.
+  //   else if (tokenBalanceChange !== null) {
+  //     return currentRate;
+  //   }
+
+  throw new Error("Invalid rebalance condition");
+}
+
+function getAdjustedPositionValues(
+  solautoPosition: SolautoPositionEx,
+  tokenBalanceChange: TokenBalanceChange | undefined
+): PositionValues {
+  let supplyUsd = solautoPosition.supplyUsd();
+  const debtUsd = solautoPosition.debtUsd();
+
+  if (tokenBalanceChange) {
+    const tb = tokenBalanceChange;
+    switch (tb.changeType) {
+      case TokenBalanceChangeType.PreSwapDeposit:
+      case TokenBalanceChangeType.PostSwapDeposit:
+        supplyUsd += Number(tb.amountUsd);
+        break;
+      case TokenBalanceChangeType.PostRebalanceWithdrawDebtToken:
+      case TokenBalanceChangeType.PostRebalanceWithdrawSupplyToken:
+        supplyUsd -= Number(tb.amountUsd);
+        break;
+      default:
+        break;
+    }
+  }
+
+  return {
+    supplyUsd,
+    debtUsd,
+  };
+}
+
+function getRebalanceDirection(
+  solautoPosition: SolautoPositionEx,
+  targetLtvBps: number
+): RebalanceDirection {
+  return solautoPosition.state().liqUtilizationRateBps < targetLtvBps
+    ? RebalanceDirection.Boost
+    : RebalanceDirection.Repay;
+}
+
+export interface RebalanceValues extends DebtAdjustment {
+  rebalanceDirection: RebalanceDirection;
+  tokenBalanceChange?: TokenBalanceChange;
+  repayingCloseToMaxLtv: boolean;
+}
+
+export function getRebalanceValues(
+  solautoPosition: SolautoPositionEx,
+  solautoFeeBps: SolautoFeesBps,
+  flFeeBps: number,
+  targetLiqUtilizationRateBps?: number
+): RebalanceValues {
+  const tokenBalanceChange = getTokenBalanceChange();
+
+  const targetRate = getTargetLiqUtilizationRateBps(
+    solautoPosition,
+    targetLiqUtilizationRateBps,
+    tokenBalanceChange
+  );
+
+  const rebalanceDirection = getRebalanceDirection(solautoPosition, targetRate);
+
+  const position = getAdjustedPositionValues(
+    solautoPosition,
+    tokenBalanceChange
+  );
+
+  const fees: RebalanceFeesBps = {
+    solauto: solautoFeeBps.getSolautoFeesBps(rebalanceDirection).total,
+    lpBorrow: solautoPosition.state().debt.borrowFeeBps,
+    flashLoan: flFeeBps,
+  };
+
+  const debtAdjustment = getDebtAdjustment(
+    fromBps(solautoPosition.state().liqThresholdBps),
+    position,
+    fees,
+    targetRate
+  );
+
+  const repayingCloseToMaxLtv =
+    rebalanceDirection === RebalanceDirection.Repay &&
+    targetRate >=
+      maxRepayToBps(
+        solautoPosition.state().maxLtvBps,
+        solautoPosition.state().liqThresholdBps
+      );
+
+  return {
+    ...debtAdjustment,
+    rebalanceDirection,
+    tokenBalanceChange,
+    repayingCloseToMaxLtv,
+  };
+}

package/src/services/rebalance/solautoFees.ts

@@ -0,0 +1,61 @@
+import { REFERRER_PERCENTAGE } from "../../constants";
+import { RebalanceDirection } from "../../generated";
+
+export class SolautoFeesBps {
+  constructor(
+    private isReferred: boolean,
+    private targetLiqUtilizationRateBps: number | undefined,
+    private positionNetWorthUsd: number
+  ) {}
+
+  public getSolautoFeesBps(rebalanceDirection: RebalanceDirection) {
+    const minSize = 10_000; // Minimum position size
+    const maxSize = 250_000; // Maximum position size
+    const maxFeeBps = 50; // Fee in basis points for minSize (0.5%)
+    const minFeeBps = 25; // Fee in basis points for maxSize (0.25%)
+    const k = 1.5;
+
+    if (
+      this.targetLiqUtilizationRateBps !== undefined &&
+      this.targetLiqUtilizationRateBps === 0
+    ) {
+      return {
+        solauto: 0,
+        referrer: 0,
+        total: 0,
+      };
+    }
+
+    let feeBps: number = 0;
+
+    if (
+      this.targetLiqUtilizationRateBps !== undefined ||
+      rebalanceDirection === RebalanceDirection.Repay
+    ) {
+      feeBps = 25;
+    } else if (this.positionNetWorthUsd <= minSize) {
+      feeBps = maxFeeBps;
+    } else if (this.positionNetWorthUsd >= maxSize) {
+      feeBps = minFeeBps;
+    } else {
+      const t =
+        (Math.log(this.positionNetWorthUsd) - Math.log(minSize)) /
+        (Math.log(maxSize) - Math.log(minSize));
+      feeBps = Math.round(
+        minFeeBps + (maxFeeBps - minFeeBps) * (1 - Math.pow(t, k))
+      );
+    }
+
+    let referrer = 0;
+    if (this.isReferred) {
+      feeBps *= 1.0 - REFERRER_PERCENTAGE;
+      referrer = Math.floor(feeBps * REFERRER_PERCENTAGE);
+    }
+
+    return {
+      solauto: feeBps - referrer,
+      referrer,
+      total: feeBps,
+    };
+  }
+}

package/src/services/solauto/index.ts

@@ -0,0 +1,4 @@
+export * from "./referralStateManager";
+export * from "./solautoClient";
+export * from "./solautoMarginfiClient";
+export * from "./txHandler";

package/src/{clients → services/solauto}/referralStateManager.ts

@@ -1,30 +1,18 @@
 import { PublicKey } from "@solana/web3.js";
 import { NATIVE_MINT } from "@solana/spl-token";
-import {
-  publicKey,
-  Signer,
-  signerIdentity,
-  TransactionBuilder,
-  Umi,
-} from "@metaplex-foundation/umi";
+import { publicKey, TransactionBuilder, Umi } from "@metaplex-foundation/umi";
 import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
-import {
-  WalletAdapter,
-  walletAdapterIdentity,
-} from "@metaplex-foundation/umi-signer-wallet-adapters";
 import {
   claimReferralFees,
   ReferralState,
   safeFetchReferralState,
   updateReferralStates,
-} from "../generated";
-import { getReferralState, getTokenAccount } from "../utils";
+} from "../../generated";
+import { getReferralState, getTokenAccount } from "../../utils";
 import { TxHandler } from "./txHandler";
-import { SOLAUTO_LUT } from "../constants";
+import { SOLAUTO_LUT } from "../../constants";
 
 export interface ReferralStateManagerArgs {
-  signer?: Signer;
-  wallet?: WalletAdapter;
   authority?: PublicKey;
   referralState?: PublicKey;
   referredByAuthority?: PublicKey;
@@ -41,16 +29,6 @@ export class ReferralStateManager extends TxHandler {
   public referredByState?: PublicKey;
 
   async initialize(args: ReferralStateManagerArgs) {
-    if (!args.signer && !args.wallet) {
-      throw new Error("Signer or wallet must be provided");
-    }
-    this.umi = this.umi.use(
-      args.signer
-        ? signerIdentity(args.signer, true)
-        : walletAdapterIdentity(args.wallet!, true)
-    );
-    this.signer = this.umi.identity;
-
     this.referralState =
       args.referralState ??
       getReferralState(
@@ -58,11 +36,7 @@ export class ReferralStateManager extends TxHandler {
         this.programId
       );
 
-    this.referralStateData = await safeFetchReferralState(
-      this.umi,
-      publicKey(this.referralState),
-      { commitment: "confirmed" }
-    );
+    await this.refetchReferralState();
     this.authority = this.referralStateData?.authority
       ? toWeb3JsPublicKey(this.referralStateData.authority)
       : (args.authority ?? toWeb3JsPublicKey(this.signer.publicKey));
@@ -83,6 +57,14 @@ export class ReferralStateManager extends TxHandler {
       : [SOLAUTO_LUT];
   }
 
+  async refetchReferralState() {
+    this.referralStateData = await safeFetchReferralState(
+      this.umi,
+      publicKey(this.referralState),
+      { commitment: "confirmed" }
+    );
+  }
+
   setReferredBy(referredBy?: PublicKey) {
     const hasReferredBy =
       this.referralStateData &&
@@ -105,6 +87,10 @@ export class ReferralStateManager extends TxHandler {
         : undefined;
   }
 
+  isReferred(): boolean {
+    return Boolean(this.referredByState);
+  }
+
   updateReferralStatesIx(
     destFeesMint?: PublicKey,
     lookupTable?: PublicKey