@haven-fi/solauto-sdk 1.0.0

package/src/transactions/transactionUtils.ts

@@ -0,0 +1,518 @@
+import {
+  Signer,
+  TransactionBuilder,
+  publicKey,
+  transactionBuilder,
+} from "@metaplex-foundation/umi";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import { PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY } from "@solana/web3.js";
+import {
+  ACCOUNT_SIZE as TOKEN_ACCOUNT_SIZE,
+  NATIVE_MINT,
+  Account as SplTokenAccount,
+} from "@solana/spl-token";
+import {
+  LendingPlatform,
+  ReferralState,
+  SOLAUTO_PROGRAM_ID,
+  SolautoAction,
+  SolautoRebalanceType,
+  convertReferralFees,
+  getMarginfiProtocolInteractionInstructionDataSerializer,
+  isSolautoAction,
+  solautoAction,
+} from "../generated";
+import { SolautoClient } from "../clients/solautoClient";
+import {
+  closeTokenAccountUmiIx,
+  createAssociatedTokenAccountUmiIx,
+  systemTransferUmiIx,
+} from "../utils/solanaUtils";
+import { getJupSwapTransaction } from "../utils/jupiterUtils";
+import {
+  getFlashLoanDetails,
+  getJupSwapRebalanceDetails,
+  getRebalanceValues,
+} from "../utils/solauto/rebalanceUtils";
+import {
+  getSolanaAccountCreated,
+  rpcAccountCreated,
+} from "../utils/generalUtils";
+import { SolautoMarginfiClient } from "../clients/solautoMarginfiClient";
+import { UMI } from "../constants/solautoConstants";
+import { uint8ArrayToBigInt } from "../utils/numberUtils";
+import {
+  eligibileForRebalance,
+  getMaxLiqUtilizationRate,
+} from "../utils/solauto/generalUtils";
+import { getTokenAccount } from "../utils/accountUtils";
+
+interface wSolTokenUsage {
+  wSolTokenAccount: PublicKey;
+  solautoAction: SolautoAction;
+}
+
+function getWSolUsage(
+  client: SolautoClient,
+  solautoActions?: SolautoAction[],
+  initiatingDcaIn?: bigint,
+  cancellingDcaIn?: boolean
+): wSolTokenUsage | undefined {
+  const supplyIsWsol = client.supplyLiquidityMint.equals(NATIVE_MINT);
+  const debtIsWsol = client.debtLiquidityMint.equals(NATIVE_MINT);
+  if (!supplyIsWsol && !debtIsWsol) {
+    return undefined;
+  }
+
+  const usingSupplyTaAction = solautoActions?.find(
+    (args) =>
+      isSolautoAction("Deposit", args) || isSolautoAction("Withdraw", args)
+  );
+  const usingDebtTaAction = solautoActions?.find(
+    (args) =>
+      isSolautoAction("Borrow", args) ||
+      isSolautoAction("Repay", args) ||
+      initiatingDcaIn ||
+      cancellingDcaIn
+  );
+  if (supplyIsWsol && usingSupplyTaAction) {
+    return {
+      wSolTokenAccount: client.signerSupplyLiquidityTa,
+      solautoAction: usingSupplyTaAction,
+    };
+  } else if (debtIsWsol && usingDebtTaAction) {
+    return {
+      wSolTokenAccount: client.signerDebtLiquidityTa,
+      solautoAction: usingDebtTaAction,
+    };
+  } else {
+    return undefined;
+  }
+}
+
+async function transactionChoresBefore(
+  client: SolautoClient,
+  solautoActions?: SolautoAction[],
+  initiatingDcaIn?: bigint
+): Promise<TransactionBuilder> {
+  const accountsGettingCreated: string[] = [];
+  let chores = transactionBuilder();
+
+  if (
+    client.authorityReferralStateData === null ||
+    (client.referredByState !== undefined &&
+      client.authorityReferralStateData.referredByState ===
+        publicKey(PublicKey.default)) ||
+    (client.authorityLutAddress !== undefined &&
+      client.authorityReferralStateData.lookupTable ==
+        publicKey(PublicKey.default))
+  ) {
+    chores = chores.add(client.updateReferralStatesIx());
+  }
+
+  if (client.selfManaged && client.solautoPositionData === undefined) {
+    chores = chores.add(client.openPosition());
+  }
+
+  const wSolUsage = getWSolUsage(
+    client,
+    solautoActions,
+    initiatingDcaIn,
+    undefined
+  );
+  if (wSolUsage !== undefined) {
+    if (!getSolanaAccountCreated(wSolUsage.wSolTokenAccount)) {
+      client.log(`Closing signer wSol TA`);
+      chores = chores.add(
+        closeTokenAccountUmiIx(
+          client.signer,
+          wSolUsage.wSolTokenAccount,
+          toWeb3JsPublicKey(client.signer.publicKey)
+        )
+      );
+    }
+
+    let amountToTransfer = BigInt(0);
+    if (isSolautoAction("Deposit", wSolUsage.solautoAction)) {
+      amountToTransfer += BigInt(wSolUsage.solautoAction.fields[0]);
+    } else if (
+      isSolautoAction("Repay", wSolUsage.solautoAction) &&
+      wSolUsage.solautoAction.fields[0].__kind === "Some"
+    ) {
+      amountToTransfer += BigInt(wSolUsage.solautoAction.fields[0].fields[0]);
+    } else if (
+      initiatingDcaIn &&
+      client.debtLiquidityMint.toString() === NATIVE_MINT.toString()
+    ) {
+      amountToTransfer += initiatingDcaIn;
+    }
+
+    if (amountToTransfer > 0) {
+      const amount =
+        amountToTransfer +
+        (await UMI.rpc.getRent(TOKEN_ACCOUNT_SIZE)).basisPoints;
+      client.log(`Transferring ${amount} lamports to signer wSol TA`);
+      chores = chores.add(
+        systemTransferUmiIx(client.signer, wSolUsage.wSolTokenAccount, amount)
+      );
+    }
+
+    client.log("Creating signer wSol TA");
+    chores = chores.add(
+      createAssociatedTokenAccountUmiIx(
+        client.signer,
+        toWeb3JsPublicKey(client.signer.publicKey),
+        NATIVE_MINT
+      )
+    );
+    accountsGettingCreated.push(wSolUsage.wSolTokenAccount.toString());
+  }
+
+  for (const solautoAction of solautoActions ?? []) {
+    if (
+      !isSolautoAction("Withdraw", solautoAction) &&
+      !isSolautoAction("Borrow", solautoAction)
+    ) {
+      continue;
+    }
+
+    const tokenAccount = isSolautoAction("Withdraw", solautoAction)
+      ? client.signerSupplyLiquidityTa
+      : client.signerDebtLiquidityTa;
+    if (accountsGettingCreated.includes(tokenAccount.toString())) {
+      continue;
+    }
+
+    if (!getSolanaAccountCreated(tokenAccount)) {
+      chores = chores.add(
+        createAssociatedTokenAccountUmiIx(
+          client.signer,
+          toWeb3JsPublicKey(client.signer.publicKey),
+          isSolautoAction("Withdraw", solautoAction)
+            ? client.supplyLiquidityMint
+            : client.debtLiquidityMint
+        )
+      );
+      accountsGettingCreated.push(tokenAccount.toString());
+    }
+  }
+
+  return chores;
+}
+
+export async function rebalanceChoresBefore(
+  client: SolautoClient,
+  tx: TransactionBuilder
+): Promise<TransactionBuilder> {
+  const usesAccount = (key: PublicKey) =>
+    tx
+      .getInstructions()
+      .some((t) => t.keys.some((k) => toWeb3JsPublicKey(k.pubkey).equals(key)));
+
+  const checkReferralSupplyTa =
+    client.referredBySupplyTa && usesAccount(client.referredBySupplyTa);
+  const checkSolautoFeesTa = usesAccount(client.solautoFeesSupplyTa);
+  const checkIntermediaryMfiAccount =
+    client.lendingPlatform === LendingPlatform.Marginfi &&
+    usesAccount(
+      (client as SolautoMarginfiClient).intermediaryMarginfiAccountPk
+    );
+
+  const accountsNeeded = [
+    ...[checkReferralSupplyTa ? client.referredBySupplyTa : PublicKey.default],
+    ...[checkSolautoFeesTa ? client.solautoFeesSupplyTa : PublicKey.default],
+    ...[
+      checkIntermediaryMfiAccount
+        ? (client as SolautoMarginfiClient).intermediaryMarginfiAccountPk
+        : PublicKey.default,
+    ],
+  ];
+
+  const [referredBySupplyTa, solautoFeesSupplyTa, intermediaryMarginfiAccount] =
+    await UMI.rpc.getAccounts(
+      accountsNeeded.map((x) => publicKey(x ?? PublicKey.default))
+    );
+
+  let chores = transactionBuilder();
+
+  if (checkReferralSupplyTa && !rpcAccountCreated(referredBySupplyTa)) {
+    client.log(
+      "Creating referred-by TA for ",
+      client.supplyLiquidityMint.toString()
+    );
+    chores = chores.add(
+      createAssociatedTokenAccountUmiIx(
+        client.signer,
+        client.referredByState!,
+        client.supplyLiquidityMint
+      )
+    );
+  }
+
+  if (checkSolautoFeesTa && !rpcAccountCreated(solautoFeesSupplyTa)) {
+    client.log(
+      "Creating Solauto fees TA for ",
+      client.supplyLiquidityMint.toString()
+    );
+    chores = chores.add(
+      createAssociatedTokenAccountUmiIx(
+        client.signer,
+        client.solautoFeesWallet,
+        client.supplyLiquidityMint
+      )
+    );
+  }
+
+  if (
+    checkIntermediaryMfiAccount &&
+    !rpcAccountCreated(intermediaryMarginfiAccount)
+  ) {
+    chores = chores.add(
+      (client as SolautoMarginfiClient).createIntermediaryMarginfiAccount()
+    );
+  }
+
+  return chores;
+}
+
+function transactionChoresAfter(
+  client: SolautoClient,
+  solautoActions?: SolautoAction[],
+  cancellingDcaIn?: boolean
+): TransactionBuilder {
+  let chores = transactionBuilder();
+
+  const wSolUsage = getWSolUsage(
+    client,
+    solautoActions,
+    undefined,
+    cancellingDcaIn
+  );
+  if (wSolUsage) {
+    chores = chores.add(
+      closeTokenAccountUmiIx(
+        client.signer,
+        wSolUsage.wSolTokenAccount,
+        toWeb3JsPublicKey(client.signer.publicKey)
+      )
+    );
+  }
+
+  return chores;
+}
+
+function getSolautoActions(tx: TransactionBuilder): SolautoAction[] {
+  let solautoActions: SolautoAction[] = [];
+
+  tx.getInstructions().forEach((x) => {
+    if (x.programId !== SOLAUTO_PROGRAM_ID) {
+      return;
+    }
+
+    try {
+      const serializer =
+        getMarginfiProtocolInteractionInstructionDataSerializer();
+      const discriminator = uint8ArrayToBigInt(
+        serializer
+          .serialize({
+            solautoAction: solautoAction("Deposit", [BigInt(0)]),
+          })
+          .slice(0, 8)
+      );
+      const [data, _] = serializer.deserialize(x.data);
+      if (BigInt(data.discriminator) === discriminator) {
+        solautoActions?.push(data.solautoAction);
+      }
+    } catch {}
+
+    // TODO support other platforms
+  });
+
+  return solautoActions;
+}
+
+export async function getTransactionChores(
+  client: SolautoClient,
+  tx: TransactionBuilder
+): Promise<[TransactionBuilder, TransactionBuilder]> {
+  let choresBefore = transactionBuilder();
+  let choresAfter = transactionBuilder();
+
+  const solautoActions = getSolautoActions(tx);
+
+  choresBefore = choresBefore.add([
+    await transactionChoresBefore(
+      client,
+      solautoActions,
+      client.livePositionUpdates.debtTaBalanceAdjustment > 0
+        ? client.livePositionUpdates.debtTaBalanceAdjustment
+        : undefined
+    ),
+    await rebalanceChoresBefore(client, tx),
+  ]);
+
+  choresAfter = choresAfter.add(
+    transactionChoresAfter(
+      client,
+      solautoActions,
+      client.livePositionUpdates.debtTaBalanceAdjustment < 0
+    )
+  );
+
+  return [choresBefore, choresAfter];
+}
+
+export async function buildSolautoRebalanceTransaction(
+  client: SolautoClient,
+  targetLiqUtilizationRateBps?: number,
+  attemptNum?: number
+): Promise<
+  | {
+      tx: TransactionBuilder;
+      lookupTableAddresses: string[];
+    }
+  | undefined
+> {
+  client.solautoPositionState = await client.getFreshPositionState();
+  if (
+    targetLiqUtilizationRateBps === undefined &&
+    !eligibileForRebalance(
+      client.solautoPositionState!,
+      client.livePositionUpdates.settings ??
+        client.solautoPositionData?.position.settingParams!,
+      client.livePositionUpdates.activeDca ??
+        client.solautoPositionData?.position.dca!
+    )
+  ) {
+    client.log("Not eligible for a rebalance");
+    return undefined;
+  }
+
+  const values = getRebalanceValues(client, targetLiqUtilizationRateBps);
+  client.log("Rebalance values: ", values);
+
+  const swapDetails = getJupSwapRebalanceDetails(
+    client,
+    values,
+    targetLiqUtilizationRateBps,
+    attemptNum
+  );
+  const {
+    jupQuote,
+    lookupTableAddresses,
+    setupInstructions,
+    tokenLedgerIx,
+    swapIx,
+  } = await getJupSwapTransaction(client.signer, swapDetails);
+  const flashLoan = getFlashLoanDetails(client, values, jupQuote);
+
+  let tx = transactionBuilder();
+
+  if (flashLoan) {
+    client.log("Flash loan details: ", flashLoan);
+    const addFirstRebalance = values.amountUsdToDcaIn > 0;
+    const rebalanceType = addFirstRebalance
+      ? SolautoRebalanceType.DoubleRebalanceWithFL
+      : SolautoRebalanceType.SingleRebalanceWithFL;
+
+    tx = tx.add([
+      setupInstructions,
+      tokenLedgerIx,
+      client.flashBorrow(
+        flashLoan,
+        getTokenAccount(
+          toWeb3JsPublicKey(client.signer.publicKey),
+          swapDetails.inputMint
+        )
+      ),
+      ...(addFirstRebalance
+        ? [
+            client.rebalance(
+              "A",
+              swapDetails,
+              rebalanceType,
+              targetLiqUtilizationRateBps
+            ),
+          ]
+        : []),
+      swapIx,
+      client.rebalance(
+        "B",
+        swapDetails,
+        rebalanceType,
+        targetLiqUtilizationRateBps
+      ),
+      client.flashRepay(flashLoan),
+    ]);
+  } else {
+    const rebalanceType = SolautoRebalanceType.Regular;
+    tx = tx.add([
+      setupInstructions,
+      tokenLedgerIx,
+      client.rebalance(
+        "A",
+        swapDetails,
+        rebalanceType,
+        targetLiqUtilizationRateBps
+      ),
+      swapIx,
+      client.rebalance(
+        "B",
+        swapDetails,
+        rebalanceType,
+        targetLiqUtilizationRateBps
+      ),
+    ]);
+  }
+
+  if (
+    client.solautoPositionState!.liqUtilizationRateBps >
+    getMaxLiqUtilizationRate(
+      client.solautoPositionState!.maxLtvBps,
+      client.solautoPositionState!.liqThresholdBps
+    )
+  ) {
+    tx = tx.prepend(client.refresh());
+  }
+
+  return {
+    tx,
+    lookupTableAddresses,
+  };
+}
+
+export async function convertReferralFeesToDestination(
+  referralState: ReferralState,
+  tokenAccount: SplTokenAccount,
+  signer: Signer
+): Promise<[TransactionBuilder, string[]]> {
+  const { lookupTableAddresses, setupInstructions, swapIx } =
+    await getJupSwapTransaction(signer, {
+      amount: tokenAccount.amount,
+      destinationWallet: toWeb3JsPublicKey(referralState.publicKey),
+      inputMint: tokenAccount.mint,
+      outputMint: toWeb3JsPublicKey(referralState.destFeesMint),
+      exactIn: true,
+      slippageBpsIncFactor: 0.15,
+    });
+
+  let tx = transactionBuilder()
+    .add(setupInstructions)
+    .add(
+      convertReferralFees(UMI, {
+        signer,
+        intermediaryTa: publicKey(
+          getTokenAccount(
+            toWeb3JsPublicKey(signer.publicKey),
+            toWeb3JsPublicKey(referralState.destFeesMint)
+          )
+        ),
+        ixsSysvar: publicKey(SYSVAR_INSTRUCTIONS_PUBKEY),
+        referralState: referralState.publicKey,
+        referralFeesTa: publicKey(tokenAccount.address),
+      })
+    )
+    .add(swapIx);
+
+  return [tx, lookupTableAddresses];
+}