@haven-fi/solauto-sdk 1.0.582 → 1.0.583

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();
+  }
+}

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