@haven-fi/solauto-sdk 1.0.0

package/src/clients/solautoClient.ts

@@ -0,0 +1,684 @@
+import "rpc-websockets/dist/lib/client";
+import { AddressLookupTableProgram, PublicKey } from "@solana/web3.js";
+import {
+  Signer,
+  TransactionBuilder,
+  Umi,
+  isOption,
+  publicKey,
+  PublicKey as UmiPublicKey,
+  isSome,
+  transactionBuilder,
+  signerIdentity,
+  some,
+} from "@metaplex-foundation/umi";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  DCASettings,
+  DCASettingsInpArgs,
+  LendingPlatform,
+  PositionState,
+  ReferralState,
+  SolautoActionArgs,
+  SolautoPosition,
+  SolautoRebalanceTypeArgs,
+  SolautoSettingsParameters,
+  SolautoSettingsParametersInpArgs,
+  UpdatePositionDataArgs,
+  cancelDCA,
+  claimReferralFees,
+  closePosition,
+  safeFetchReferralState,
+  safeFetchSolautoPosition,
+  updatePosition,
+  updateReferralStates,
+} from "../generated";
+import {
+  getReferralState,
+  getSolautoPositionAccount,
+  getTokenAccount,
+} from "../utils/accountUtils";
+import {
+  SOLAUTO_FEES_WALLET,
+  USD_DECIMALS,
+} from "../constants/generalAccounts";
+import { JupSwapDetails } from "../utils/jupiterUtils";
+import {
+  getWrappedInstruction,
+  splTokenTransferUmiIx,
+} from "../utils/solanaUtils";
+import { FlashLoanDetails } from "../utils/solauto/rebalanceUtils";
+import { NATIVE_MINT } from "@solana/spl-token";
+import {
+  CONNECTION,
+  MIN_POSITION_STATE_FRESHNESS_SECS,
+  UMI,
+} from "../constants/solautoConstants";
+import { currentUnixSeconds, getTokenPrices } from "../utils/generalUtils";
+import { LivePositionUpdates } from "../utils/solauto/generalUtils";
+import {
+  fromBaseUnit,
+  getLiqUtilzationRateBps,
+  toBaseUnit,
+} from "../utils/numberUtils";
+
+export interface SolautoClientArgs {
+  authority?: PublicKey;
+  positionId: number;
+  signer: Signer;
+
+  supplyLiquidityMint?: PublicKey;
+  debtLiquidityMint?: PublicKey;
+
+  referralFeesDestMint?: PublicKey;
+  referredByAuthority?: PublicKey;
+}
+
+export abstract class SolautoClient {
+  public localTest: boolean;
+
+  public umi!: Umi;
+  public lendingPlatform!: LendingPlatform;
+
+  public authority!: PublicKey;
+  public signer!: Signer;
+
+  public positionId!: number;
+  public selfManaged!: boolean;
+  public solautoPosition!: PublicKey;
+  public solautoPositionData!: SolautoPosition | null;
+  public solautoPositionState!: PositionState | undefined;
+
+  public supplyLiquidityMint!: PublicKey;
+  public positionSupplyLiquidityTa!: PublicKey;
+  public signerSupplyLiquidityTa!: PublicKey;
+
+  public debtLiquidityMint!: PublicKey;
+  public positionDebtLiquidityTa!: PublicKey;
+  public signerDebtLiquidityTa!: PublicKey;
+
+  public authorityReferralState!: PublicKey;
+  public authorityReferralStateData!: ReferralState | null;
+  public authorityReferralFeesDestMint!: PublicKey;
+  public authorityReferralDestTa!: PublicKey;
+
+  public referredByState?: PublicKey;
+  public referredByAuthority?: PublicKey;
+  public referredBySupplyTa?: PublicKey;
+
+  public solautoFeesWallet!: PublicKey;
+  public solautoFeesSupplyTa!: PublicKey;
+
+  public authorityLutAddress?: PublicKey;
+  public upToDateLutAccounts!: PublicKey[];
+
+  public livePositionUpdates: LivePositionUpdates = new LivePositionUpdates();
+
+  constructor(localTest?: boolean) {
+    this.localTest = Boolean(localTest);
+  }
+
+  async initialize(args: SolautoClientArgs, lendingPlatform: LendingPlatform) {
+    this.umi = UMI.use(signerIdentity(args.signer));
+
+    this.signer = args.signer;
+    this.authority = args.authority ?? toWeb3JsPublicKey(args.signer.publicKey);
+
+    this.positionId = args.positionId;
+    this.selfManaged = this.positionId === 0;
+    this.lendingPlatform = lendingPlatform;
+    this.solautoPosition = await getSolautoPositionAccount(
+      this.authority,
+      this.positionId
+    );
+    this.solautoPositionData = await safeFetchSolautoPosition(
+      this.umi,
+      publicKey(this.solautoPosition)
+    );
+    this.solautoPositionState = this.solautoPositionData?.state;
+
+    this.supplyLiquidityMint =
+      args.supplyLiquidityMint ??
+      toWeb3JsPublicKey(this.solautoPositionData!.position.supplyMint);
+    this.positionSupplyLiquidityTa = getTokenAccount(
+      this.solautoPosition,
+      this.supplyLiquidityMint
+    );
+    this.signerSupplyLiquidityTa = getTokenAccount(
+      toWeb3JsPublicKey(this.signer.publicKey),
+      this.supplyLiquidityMint
+    );
+
+    this.debtLiquidityMint =
+      args.debtLiquidityMint ??
+      toWeb3JsPublicKey(this.solautoPositionData!.position.debtMint);
+    this.positionDebtLiquidityTa = getTokenAccount(
+      this.solautoPosition,
+      this.debtLiquidityMint
+    );
+    this.signerDebtLiquidityTa = getTokenAccount(
+      toWeb3JsPublicKey(this.signer.publicKey),
+      this.debtLiquidityMint
+    );
+
+    this.authorityReferralState = await getReferralState(this.authority);
+    this.authorityReferralStateData = await safeFetchReferralState(
+      this.umi,
+      publicKey(this.authorityReferralState)
+    );
+    this.authorityReferralFeesDestMint = args.referralFeesDestMint
+      ? args.referralFeesDestMint
+      : this.authorityReferralStateData?.destFeesMint
+        ? toWeb3JsPublicKey(this.authorityReferralStateData?.destFeesMint)
+        : NATIVE_MINT;
+    this.authorityReferralDestTa = getTokenAccount(
+      this.authorityReferralState,
+      this.authorityReferralFeesDestMint
+    );
+
+    const referredByAuthority =
+      args.referredByAuthority &&
+      !args.referredByAuthority.equals(toWeb3JsPublicKey(this.signer.publicKey))
+        ? args.referredByAuthority
+        : undefined;
+    this.referredByState =
+      this.authorityReferralStateData &&
+      this.authorityReferralStateData.referredByState !==
+        publicKey(PublicKey.default)
+        ? toWeb3JsPublicKey(this.authorityReferralStateData.referredByState)
+        : referredByAuthority
+          ? await getReferralState(referredByAuthority!)
+          : undefined;
+    this.referredByAuthority = referredByAuthority;
+    if (this.referredByState !== undefined) {
+      this.referredBySupplyTa = getTokenAccount(
+        this.referredByState,
+        this.supplyLiquidityMint
+      );
+    }
+
+    this.solautoFeesWallet = SOLAUTO_FEES_WALLET;
+    this.solautoFeesSupplyTa = getTokenAccount(
+      this.solautoFeesWallet,
+      this.supplyLiquidityMint
+    );
+
+    this.authorityLutAddress = this.authorityReferralStateData?.lookupTable
+      ? toWeb3JsPublicKey(this.authorityReferralStateData?.lookupTable)
+      : undefined;
+    this.upToDateLutAccounts = toWeb3JsPublicKey(this.signer.publicKey).equals(
+      this.authority
+    )
+      ? await this.fetchExistingAuthorityLutAccounts()
+      : [];
+
+    this.log("Position state: ", this.solautoPositionState);
+    this.log(
+      "Position settings: ",
+      this.solautoPositionData?.position?.settingParams
+    );
+    this.log(
+      "Position DCA: ",
+      (this.solautoPositionData?.position?.dca?.automation?.targetPeriods ??
+        0) > 0
+        ? this.solautoPositionData?.position?.dca
+        : undefined
+    );
+  }
+
+  log(...args: any[]): void {
+    if (this.localTest) {
+      console.log(...args);
+    }
+  }
+
+  async resetLivePositionUpdates() {
+    if (!this.solautoPositionData) {
+      this.solautoPositionData = await safeFetchSolautoPosition(
+        this.umi,
+        publicKey(this.solautoPosition)
+      );
+    } else {
+      if (this.livePositionUpdates.activeDca) {
+        this.solautoPositionData.position.dca =
+          this.livePositionUpdates.activeDca;
+      }
+      if (this.livePositionUpdates.settings) {
+        this.solautoPositionData.position.settingParams =
+          this.livePositionUpdates.settings;
+      }
+      // All other live position updates can be derived by getting a fresh position state, so we don't need to do anything else form livePositionUpdates
+    }
+    this.livePositionUpdates.reset();
+  }
+
+  defaultLookupTables(): string[] {
+    // TODO: solauto lookup table here
+    return [];
+  }
+
+  lutAccountsToAdd(): PublicKey[] {
+    return [
+      this.authority,
+      ...(this.signer.publicKey.toString() === this.authority.toString()
+        ? [this.signerSupplyLiquidityTa]
+        : []),
+      ...(this.signer.publicKey.toString() === this.authority.toString()
+        ? [this.signerDebtLiquidityTa]
+        : []),
+      this.solautoPosition,
+      this.positionSupplyLiquidityTa,
+      this.positionDebtLiquidityTa,
+      this.authorityReferralState,
+      ...(this.referredBySupplyTa ? [this.referredBySupplyTa] : []),
+    ];
+  }
+
+  async fetchExistingAuthorityLutAccounts(): Promise<PublicKey[]> {
+    const lookupTable = this.authorityLutAddress
+      ? await CONNECTION.getAddressLookupTable(this.authorityLutAddress)
+      : null;
+    if (lookupTable === null) {
+      this.authorityLutAddress = undefined;
+    }
+    return lookupTable?.value?.state.addresses ?? [];
+  }
+
+  async updateLookupTable(): Promise<
+    { updateLutTx: TransactionBuilder; needsToBeIsolated: boolean } | undefined
+  > {
+    const existingLutAccounts = await this.fetchExistingAuthorityLutAccounts();
+    if (
+      this.lutAccountsToAdd().every((element) =>
+        existingLutAccounts
+          .map((x) => x.toString().toLowerCase())
+          .includes(element.toString().toLowerCase())
+      )
+    ) {
+      return undefined;
+    }
+
+    this.log("Updating authority lookup table...");
+    let tx = transactionBuilder();
+
+    if (this.authorityLutAddress === undefined) {
+      const [createLookupTableInst, lookupTableAddress] =
+        AddressLookupTableProgram.createLookupTable({
+          authority: this.authority,
+          payer: toWeb3JsPublicKey(this.signer.publicKey),
+          recentSlot: await CONNECTION.getSlot({ commitment: "finalized" }),
+        });
+      this.authorityLutAddress = lookupTableAddress;
+      tx = tx.add(getWrappedInstruction(this.signer, createLookupTableInst));
+    }
+
+    const accountsToAdd: PublicKey[] = this.lutAccountsToAdd().filter(
+      (x) =>
+        !existingLutAccounts
+          .map((x) => x.toString().toLowerCase())
+          .includes(x.toString().toLowerCase())
+    );
+    this.upToDateLutAccounts = [...existingLutAccounts, ...accountsToAdd];
+
+    if (accountsToAdd.length > 0) {
+      tx = tx.add(
+        getWrappedInstruction(
+          this.signer,
+          AddressLookupTableProgram.extendLookupTable({
+            payer: toWeb3JsPublicKey(this.signer.publicKey),
+            authority: this.authority,
+            lookupTable: this.authorityLutAddress,
+            addresses: accountsToAdd,
+          })
+        )
+      );
+    }
+
+    const addingReferredBy =
+      accountsToAdd.length === 1 &&
+      accountsToAdd[0].toString().toLowerCase() ===
+        this.referredBySupplyTa?.toString().toLowerCase();
+
+    return { updateLutTx: tx, needsToBeIsolated: !addingReferredBy };
+  }
+
+  solautoPositionSettings(): SolautoSettingsParameters | undefined {
+    return (
+      this.livePositionUpdates.settings ??
+      this.solautoPositionData?.position.settingParams
+    );
+  }
+
+  solautoPositionActiveDca(): DCASettings | undefined {
+    return (
+      this.livePositionUpdates.activeDca ??
+      this.solautoPositionData?.position.dca
+    );
+  }
+
+  updateReferralStatesIx(): TransactionBuilder {
+    return updateReferralStates(this.umi, {
+      signer: this.signer,
+      signerReferralState: publicKey(this.authorityReferralState),
+      referralFeesDestMint: publicKey(this.authorityReferralFeesDestMint),
+      referredByState: this.referredByState
+        ? publicKey(this.referredByState)
+        : undefined,
+      referredByAuthority: this.referredByAuthority
+        ? publicKey(this.referredByAuthority)
+        : undefined,
+      addressLookupTable: this.authorityLutAddress
+        ? some(publicKey(this.authorityLutAddress))
+        : null,
+    });
+  }
+
+  claimReferralFeesIx(): TransactionBuilder {
+    const feesDestinationTa =
+      this.authorityReferralFeesDestMint !== NATIVE_MINT
+        ? publicKey(
+            getTokenAccount(
+              toWeb3JsPublicKey(this.signer.publicKey),
+              this.authorityReferralFeesDestMint
+            )
+          )
+        : undefined;
+    return claimReferralFees(this.umi, {
+      signer: this.signer,
+      referralState: publicKey(this.authorityReferralState),
+      referralFeesDestTa: publicKey(this.authorityReferralDestTa),
+      referralFeesDestMint: publicKey(this.authorityReferralFeesDestMint),
+      feesDestinationTa,
+    });
+  }
+
+  openPosition(
+    settingParams?: SolautoSettingsParametersInpArgs,
+    dca?: DCASettingsInpArgs
+  ): TransactionBuilder {
+    const tx = transactionBuilder();
+    if (dca && dca.debtToAddBaseUnit > 0) {
+      this.livePositionUpdates.new({
+        type: "debtDcaIn",
+        value: BigInt(dca.debtToAddBaseUnit),
+      });
+    }
+    if (settingParams) {
+      this.livePositionUpdates.new({
+        type: "settings",
+        value: settingParams,
+      });
+    }
+    if (dca) {
+      this.livePositionUpdates.new({
+        type: "dca",
+        value: dca,
+      });
+    }
+    return tx;
+  }
+
+  updatePositionIx(args: UpdatePositionDataArgs): TransactionBuilder {
+    let debtMint: UmiPublicKey | undefined = undefined;
+    let positionDebtTa: UmiPublicKey | undefined = undefined;
+    let signerDebtTa: UmiPublicKey | undefined = undefined;
+    if (isOption(args.dca) && isSome(args.dca)) {
+      debtMint = publicKey(this.debtLiquidityMint);
+      positionDebtTa = publicKey(this.positionDebtLiquidityTa);
+      signerDebtTa = publicKey(this.signerDebtLiquidityTa);
+
+      let addingToPos = false;
+      if (
+        isOption(args.dca) &&
+        isSome(args.dca) &&
+        args.dca.value.debtToAddBaseUnit > 0
+      ) {
+        this.livePositionUpdates.new({
+          type: "debtDcaIn",
+          value: BigInt(args.dca.value.debtToAddBaseUnit),
+        });
+        addingToPos = true;
+      }
+
+      if (
+        this.solautoPositionData?.position.dca.debtToAddBaseUnit &&
+        !addingToPos
+      ) {
+        this.livePositionUpdates.new({
+          type: "debtDcaIn",
+          value:
+            this.solautoPositionData.position.dca.debtToAddBaseUnit *
+            BigInt(-1),
+        });
+      }
+    }
+
+    if (isOption(args.settingParams) && isSome(args.settingParams)) {
+      this.livePositionUpdates.new({
+        type: "settings",
+        value: args.settingParams.value,
+      });
+    }
+
+    if (isOption(args.dca) && isSome(args.dca)) {
+      this.livePositionUpdates.new({
+        type: "dca",
+        value: args.dca.value,
+      });
+    }
+
+    return updatePosition(this.umi, {
+      signer: this.signer,
+      solautoPosition: publicKey(this.solautoPosition),
+      debtMint,
+      positionDebtTa,
+      signerDebtTa,
+      updatePositionData: args,
+    });
+  }
+
+  closePositionIx(): TransactionBuilder {
+    return closePosition(this.umi, {
+      signer: this.signer,
+      solautoPosition: publicKey(this.solautoPosition),
+      signerSupplyLiquidityTa: publicKey(this.signerSupplyLiquidityTa),
+      positionSupplyLiquidityTa: publicKey(this.positionSupplyLiquidityTa),
+      positionDebtLiquidityTa: publicKey(this.positionDebtLiquidityTa),
+      signerDebtLiquidityTa: publicKey(this.signerDebtLiquidityTa),
+    });
+  }
+
+  cancelDCAIx(): TransactionBuilder {
+    let debtMint: UmiPublicKey | undefined = undefined;
+    let positionDebtTa: UmiPublicKey | undefined = undefined;
+    let signerDebtTa: UmiPublicKey | undefined = undefined;
+
+    if (this.solautoPositionData !== null && !this.selfManaged) {
+      const positionData = this.solautoPositionData!.position;
+      if (positionData.dca.debtToAddBaseUnit) {
+        debtMint = publicKey(this.debtLiquidityMint);
+        positionDebtTa = publicKey(this.positionDebtLiquidityTa);
+        signerDebtTa = publicKey(this.signerDebtLiquidityTa);
+
+        this.livePositionUpdates.new({
+          type: "debtDcaIn",
+          value: positionData.dca.debtToAddBaseUnit * BigInt(-1),
+        });
+      }
+    }
+
+    return cancelDCA(this.umi, {
+      signer: this.signer,
+      solautoPosition: publicKey(this.solautoPosition),
+      debtMint,
+      positionDebtTa,
+      signerDebtTa,
+    });
+  }
+
+  abstract refresh(): TransactionBuilder;
+
+  protocolInteraction(args: SolautoActionArgs): TransactionBuilder {
+    let tx = transactionBuilder();
+
+    if (!this.selfManaged) {
+      if (args.__kind === "Deposit") {
+        tx = tx.add(
+          splTokenTransferUmiIx(
+            this.signer,
+            this.signerSupplyLiquidityTa,
+            this.positionSupplyLiquidityTa,
+            toWeb3JsPublicKey(this.signer.publicKey),
+            BigInt(args.fields[0])
+          )
+        );
+      } else if (args.__kind === "Repay") {
+        if (args.fields[0].__kind === "Some") {
+          tx = tx.add(
+            splTokenTransferUmiIx(
+              this.signer,
+              this.signerDebtLiquidityTa,
+              this.positionDebtLiquidityTa,
+              toWeb3JsPublicKey(this.signer.publicKey),
+              BigInt(args.fields[0].fields[0])
+            )
+          );
+        } else {
+          tx = tx.add(
+            splTokenTransferUmiIx(
+              this.signer,
+              this.signerDebtLiquidityTa,
+              this.positionDebtLiquidityTa,
+              toWeb3JsPublicKey(this.signer.publicKey),
+              BigInt(
+                Math.round(
+                  Number(this.solautoPositionState!.debt.amountUsed.baseUnit) *
+                    1.01
+                )
+              )
+            )
+          );
+        }
+      }
+    }
+
+    if (args.__kind === "Deposit") {
+      this.livePositionUpdates.new({
+        type: "supply",
+        value: BigInt(args.fields[0]),
+      });
+    } else if (args.__kind === "Withdraw") {
+      if (args.fields[0].__kind === "Some") {
+        this.livePositionUpdates.new({
+          type: "supply",
+          value: BigInt(args.fields[0].fields[0]) * BigInt(-1),
+        });
+      } else {
+        this.livePositionUpdates.new({
+          type: "supply",
+          value:
+            (this.solautoPositionState?.supply.amountUsed.baseUnit ??
+              BigInt(0)) + this.livePositionUpdates.supplyAdjustment,
+        });
+      }
+    } else if (args.__kind === "Borrow") {
+      this.livePositionUpdates.new({
+        type: "debt",
+        value: BigInt(args.fields[0]),
+      });
+    } else {
+      if (args.fields[0].__kind === "Some") {
+        this.livePositionUpdates.new({
+          type: "debt",
+          value: BigInt(args.fields[0].fields[0]) * BigInt(-1),
+        });
+      } else {
+        this.livePositionUpdates.new({
+          type: "debt",
+          value:
+            (this.solautoPositionState?.debt.amountUsed.baseUnit ?? BigInt(0)) +
+            this.livePositionUpdates.debtAdjustment,
+        });
+      }
+    }
+
+    return tx;
+  }
+
+  abstract flashBorrow(
+    flashLoanDetails: FlashLoanDetails,
+    destinationTokenAccount: PublicKey
+  ): TransactionBuilder;
+
+  abstract flashRepay(flashLoanDetails: FlashLoanDetails): TransactionBuilder;
+
+  abstract rebalance(
+    rebalanceStep: "A" | "B",
+    swapDetails: JupSwapDetails,
+    rebalanceType: SolautoRebalanceTypeArgs,
+    targetLiqUtilizationRateBps?: number,
+    limitGapBps?: number
+  ): TransactionBuilder;
+
+  async positionStateWithLatestPrices(): Promise<PositionState | undefined> {
+    if (!this.solautoPositionData) {
+      return undefined;
+    }
+
+    const state = this.solautoPositionState ?? this.solautoPositionData.state;
+    if (currentUnixSeconds() - Number(state.lastUpdated) > 60 * 60 * 24 * 7) {
+      return this.getFreshPositionState();
+    }
+
+    const [supplyPrice, debtPrice] = await getTokenPrices([
+      toWeb3JsPublicKey(state.supply.mint),
+      toWeb3JsPublicKey(state.debt.mint),
+    ]);
+
+    const supplyUsd =
+      fromBaseUnit(state.supply.amountUsed.baseUnit, state.supply.decimals) *
+      supplyPrice;
+    const debtUsd =
+      fromBaseUnit(state.debt.amountUsed.baseUnit, state.debt.decimals) *
+      debtPrice;
+    return {
+      ...state,
+      liqUtilizationRateBps: getLiqUtilzationRateBps(
+        supplyUsd,
+        debtUsd,
+        state.liqThresholdBps
+      ),
+      netWorth: {
+        ...state.netWorth,
+        baseAmountUsdValue: toBaseUnit(supplyUsd - debtUsd, USD_DECIMALS),
+      },
+      supply: {
+        ...state.supply,
+        amountUsed: {
+          ...state.supply.amountUsed,
+          baseAmountUsdValue: toBaseUnit(supplyUsd, USD_DECIMALS),
+        },
+      },
+      debt: {
+        ...state.debt,
+        amountUsed: {
+          ...state.debt.amountUsed,
+          baseAmountUsdValue: toBaseUnit(debtUsd, USD_DECIMALS),
+        },
+      },
+    };
+  }
+
+  async getFreshPositionState(): Promise<PositionState | undefined> {
+    if (
+      Boolean(this.solautoPositionState) &&
+      Number(this.solautoPositionState!.lastUpdated) >
+        currentUnixSeconds() - MIN_POSITION_STATE_FRESHNESS_SECS &&
+      !this.livePositionUpdates.hasUpdates()
+    ) {
+      return this.solautoPositionState;
+    }
+
+    return undefined;
+  }
+}