@haven-fi/solauto-sdk 1.0.582 → 1.0.584

package/src/services/flashLoans/flProviderBase.ts

@@ -0,0 +1,88 @@
+import {
+  Signer,
+  transactionBuilder,
+  TransactionBuilder,
+  Umi,
+} from "@metaplex-foundation/umi";
+import { PublicKey } from "@solana/web3.js";
+import {
+  fromBaseUnit,
+  getTokenAccount,
+  safeGetPrice,
+  splTokenTransferUmiIx,
+  tokenInfo,
+} from "../../utils";
+import { TokenType } from "../../generated";
+import { FlashLoanDetails } from "../../types";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+
+export abstract class FlProviderBase {
+  protected flSigners: Signer[] = [];
+
+  constructor(
+    protected umi: Umi,
+    protected signer: Signer,
+    protected supplyMint: PublicKey,
+    protected debtMint: PublicKey
+  ) {}
+
+  abstract initialize(): Promise<void>;
+
+  lutAccountsToAdd(): PublicKey[] {
+    return [];
+  }
+
+  otherSigners(): Signer[] {
+    return this.flSigners;
+  }
+
+  mint(source: TokenType) {
+    return source === TokenType.Supply ? this.supplyMint : this.debtMint;
+  }
+
+  abstract liquidityAvailable(source: TokenType): bigint;
+  liquidityAvailableUsd(source: TokenType): number {
+    return (
+      fromBaseUnit(
+        this.liquidityAvailable(source),
+        tokenInfo(this.mint(source)).decimals
+      ) * (safeGetPrice(this.mint(source)) ?? 0)
+    );
+  }
+
+  abstract flFeeBps(source: TokenType, signerFlashLoan?: boolean): number;
+  abstract flashBorrow(
+    flashLoan: FlashLoanDetails,
+    destTokenAccount: PublicKey
+  ): TransactionBuilder;
+  abstract flashRepay(flashLoan: FlashLoanDetails): TransactionBuilder;
+
+  protected signerFlashBorrow(
+    flashLoan: FlashLoanDetails,
+    destTokenAccount: PublicKey
+  ): TransactionBuilder {
+    if (
+      !destTokenAccount.equals(
+        getTokenAccount(
+          toWeb3JsPublicKey(this.signer.publicKey),
+          flashLoan.mint
+        )
+      )
+    ) {
+      return transactionBuilder().add(
+        splTokenTransferUmiIx(
+          this.signer,
+          getTokenAccount(
+            toWeb3JsPublicKey(this.signer.publicKey),
+            flashLoan.mint
+          ),
+          destTokenAccount,
+          toWeb3JsPublicKey(this.signer.publicKey),
+          flashLoan.baseUnitAmount
+        )
+      );
+    } else {
+      return transactionBuilder();
+    }
+  }
+}

package/src/services/flashLoans/index.ts

@@ -0,0 +1,3 @@
+export * from "./flProviderAggregator";
+export * from "./flProviderBase";
+export * from "./marginfiFlProvider";

package/src/services/flashLoans/marginfiFlProvider.ts

@@ -0,0 +1,392 @@
+import {
+  AccountMeta,
+  createSignerFromKeypair,
+  publicKey,
+  Signer,
+  transactionBuilder,
+  TransactionBuilder,
+} from "@metaplex-foundation/umi";
+import { MARGINFI_ACCOUNTS } from "../../constants";
+import {
+  Bank,
+  lendingAccountBorrow,
+  lendingAccountCloseBalance,
+  lendingAccountEndFlashloan,
+  lendingAccountRepay,
+  lendingAccountStartFlashloan,
+  MarginfiAccount,
+  marginfiAccountInitialize,
+  safeFetchAllBank,
+} from "../../marginfi-sdk";
+import { FlProviderBase } from "./flProviderBase";
+import { PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY } from "@solana/web3.js";
+import {
+  bytesToI80F48,
+  consoleLog,
+  fetchTokenPrices,
+  findMarginfiAccounts,
+  fromBaseUnit,
+  getBankLiquidityAvailableBaseUnit,
+  getEmptyMarginfiAccountsByAuthority,
+  getTokenAccount,
+  rpcAccountCreated,
+  safeGetPrice,
+  tokenInfo,
+} from "../../utils";
+import { TokenType } from "../../generated";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import { FlashLoanDetails } from "../../types";
+
+interface IMFIAccount {
+  signer?: Signer;
+  accountPk: PublicKey;
+  accountData?: MarginfiAccount;
+}
+
+export class MarginfiFlProvider extends FlProviderBase {
+  private existingMarginfiAccounts!: MarginfiAccount[];
+  private supplyBankLiquiditySource!: Bank;
+  private debtBankLiquiditySource!: Bank;
+  private supplyImfiAccount!: IMFIAccount;
+  private debtImfiAccount!: IMFIAccount;
+
+  async initialize() {
+    await this.setAvailableBanks();
+    this.existingMarginfiAccounts = await getEmptyMarginfiAccountsByAuthority(
+      this.umi,
+      toWeb3JsPublicKey(this.signer.publicKey)
+    );
+    if (
+      this.liquidityBank(TokenType.Supply).group.toString() !==
+      this.liquidityBank(TokenType.Debt).group.toString()
+    ) {
+      this.setIntermediaryAccount([TokenType.Supply]);
+      this.setIntermediaryAccount([TokenType.Debt]);
+    } else {
+      this.setIntermediaryAccount([TokenType.Supply, TokenType.Debt]);
+    }
+  }
+
+  private async setAvailableBanks() {
+    const availableBanks: string[] = [];
+    const checkIfUsable = (group: string, mint: PublicKey) => {
+      if (Object.keys(MARGINFI_ACCOUNTS[group]).includes(mint.toString())) {
+        availableBanks.push(MARGINFI_ACCOUNTS[group][mint.toString()].bank);
+      }
+    };
+
+    for (const group of Object.keys(MARGINFI_ACCOUNTS)) {
+      checkIfUsable(group, this.supplyMint);
+      checkIfUsable(group, this.debtMint);
+    }
+
+    const banks = await safeFetchAllBank(
+      this.umi,
+      availableBanks.map((x) => publicKey(x))
+    );
+
+    if (!safeGetPrice(this.supplyMint) || !safeGetPrice(this.debtMint)) {
+      await fetchTokenPrices([this.supplyMint, this.debtMint]);
+    }
+
+    const mapBanksAndBalances = (mint: PublicKey) =>
+      banks
+        .filter((x) => toWeb3JsPublicKey(x.mint).equals(mint))
+        .map((x) => {
+          return [
+            fromBaseUnit(
+              getBankLiquidityAvailableBaseUnit(x, false),
+              tokenInfo(mint).decimals
+            ) * safeGetPrice(mint)!,
+            x,
+          ] as const;
+        })
+        .sort((a, b) => b[0] - a[0]);
+
+    const supplyBanks = mapBanksAndBalances(this.supplyMint);
+    const debtBanks = mapBanksAndBalances(this.debtMint);
+
+    this.supplyBankLiquiditySource = supplyBanks[0][1];
+    this.debtBankLiquiditySource = debtBanks[0][1];
+  }
+
+  private setIntermediaryAccount(sources: TokenType[]) {
+    const compatibleMarginfiAccounts = this.existingMarginfiAccounts.filter(
+      (x) => x.group.toString() == this.liquidityBank(sources[0]).group
+    );
+
+    const signer =
+      compatibleMarginfiAccounts.length > 0
+        ? undefined
+        : createSignerFromKeypair(this.umi, this.umi.eddsa.generateKeypair());
+    const accountPk =
+      compatibleMarginfiAccounts.length > 0
+        ? toWeb3JsPublicKey(compatibleMarginfiAccounts[0].publicKey)
+        : toWeb3JsPublicKey(signer!.publicKey);
+    const accountData =
+      compatibleMarginfiAccounts.length > 0
+        ? compatibleMarginfiAccounts[0]
+        : undefined;
+
+    if (signer) {
+      this.flSigners.push(signer);
+    }
+
+    consoleLog("Intermediary MF account:", accountPk.toString());
+    for (const s of sources) {
+      const data: IMFIAccount = {
+        signer,
+        accountPk,
+        accountData,
+      };
+      if (s === TokenType.Supply) {
+        this.supplyImfiAccount = data;
+      } else {
+        this.debtImfiAccount = data;
+      }
+    }
+  }
+
+  async initializeIMfiAccounts(): Promise<TransactionBuilder> {
+    const supplyImfiAccount = this.iMfiAccount(TokenType.Supply);
+    const debtImfiAccount = this.iMfiAccount(TokenType.Debt);
+
+    const [supplyImfiRpcAccount, debtImfiRpcAccount] =
+      await this.umi.rpc.getAccounts([
+        publicKey(supplyImfiAccount.accountPk),
+        publicKey(debtImfiAccount.accountPk),
+      ]);
+
+    let tx = transactionBuilder();
+
+    if (!rpcAccountCreated(supplyImfiRpcAccount)) {
+      tx = tx.add(
+        marginfiAccountInitialize(this.umi, {
+          marginfiAccount: supplyImfiAccount.signer!,
+          marginfiGroup: this.supplyBankLiquiditySource.group,
+          authority: this.signer,
+          feePayer: this.signer,
+        })
+      );
+    }
+
+    if (
+      supplyImfiAccount.accountPk.toString() !==
+        debtImfiAccount.accountPk.toString() &&
+      !rpcAccountCreated(debtImfiRpcAccount)
+    ) {
+      tx = tx.add(
+        marginfiAccountInitialize(this.umi, {
+          marginfiAccount: debtImfiAccount.signer!,
+          marginfiGroup: this.debtBankLiquiditySource.group,
+          authority: this.signer,
+          feePayer: this.signer,
+        })
+      );
+    }
+
+    return tx;
+  }
+
+  lutAccountsToAdd(): PublicKey[] {
+    return [
+      ...super.lutAccountsToAdd(),
+      ...Array.from(
+        new Set([
+          this.iMfiAccount(TokenType.Supply).accountPk.toString(),
+          this.iMfiAccount(TokenType.Debt).accountPk.toString(),
+        ])
+      ).map((x) => new PublicKey(x)),
+    ];
+  }
+
+  private liquidityBank(source: TokenType): Bank {
+    return source === TokenType.Supply
+      ? this.supplyBankLiquiditySource
+      : this.debtBankLiquiditySource;
+  }
+
+  private iMfiAccount(source: TokenType): IMFIAccount {
+    return source === TokenType.Supply
+      ? this.supplyImfiAccount
+      : this.debtImfiAccount;
+  }
+
+  liquidityAvailable(source: TokenType): bigint {
+    return getBankLiquidityAvailableBaseUnit(this.liquidityBank(source), false);
+  }
+
+  flFeeBps(source: TokenType, signerFlashLoan?: boolean): number {
+    if (signerFlashLoan) {
+      return 0;
+    }
+
+    return bytesToI80F48(
+      this.liquidityBank(source).config.interestRateConfig
+        .protocolOriginationFee.value
+    );
+  }
+
+  flashBorrow(
+    flashLoan: FlashLoanDetails,
+    destTokenAccount: PublicKey
+  ): TransactionBuilder {
+    if (flashLoan.signerFlashLoan) {
+      return this.signerFlashBorrow(flashLoan, destTokenAccount);
+    }
+
+    const bank = this.liquidityBank(flashLoan.liquiditySource);
+    const associatedBankAccs = findMarginfiAccounts(
+      toWeb3JsPublicKey(bank.publicKey)
+    );
+    const iMfiAccount = this.iMfiAccount(flashLoan.liquiditySource)!;
+
+    return transactionBuilder()
+      .add(
+        lendingAccountStartFlashloan(this.umi, {
+          endIndex: 0, // We set this after building the transaction
+          ixsSysvar: publicKey(SYSVAR_INSTRUCTIONS_PUBKEY),
+          marginfiAccount: publicKey(iMfiAccount.accountPk),
+          signer: this.signer,
+        })
+      )
+      .add(
+        lendingAccountBorrow(this.umi, {
+          amount: flashLoan.baseUnitAmount,
+          bank: publicKey(bank),
+          bankLiquidityVault: publicKey(associatedBankAccs.liquidityVault),
+          bankLiquidityVaultAuthority: publicKey(
+            associatedBankAccs.vaultAuthority
+          ),
+          destinationTokenAccount: publicKey(destTokenAccount),
+          marginfiAccount: publicKey(iMfiAccount.accountPk),
+          marginfiGroup: this.liquidityBank(flashLoan.liquiditySource).group,
+          signer: this.signer,
+        })
+      );
+  }
+
+  flashRepay(flashLoan: FlashLoanDetails): TransactionBuilder {
+    if (flashLoan.signerFlashLoan) {
+      return transactionBuilder();
+    }
+
+    const bank = this.liquidityBank(flashLoan.liquiditySource);
+    const associatedBankAccs = findMarginfiAccounts(
+      toWeb3JsPublicKey(bank.publicKey)
+    );
+    const marginfiGroup = toWeb3JsPublicKey(
+      this.liquidityBank(flashLoan.liquiditySource).group
+    );
+    const iMfiAccount = this.iMfiAccount(flashLoan.liquiditySource)!;
+
+    const remainingAccounts: AccountMeta[] = [];
+    let includedFlashLoanToken = false;
+
+    if (iMfiAccount?.accountData) {
+      iMfiAccount.accountData.lendingAccount.balances.forEach(async (x) => {
+        if (x.active) {
+          if (x.bankPk.toString() === bank.publicKey.toString()) {
+            includedFlashLoanToken = true;
+          }
+
+          // TODO: Don't dynamically pull from bank until Marginfi sorts out their price oracle issues.
+          // const bankData = await safeFetchBank(this.umi, publicKey(accounts.data.bank));
+          // const priceOracle = bankData!.config.oracleKeys[0];
+          const priceOracle = publicKey(
+            findMarginfiAccounts(toWeb3JsPublicKey(x.bankPk)).priceOracle
+          );
+
+          remainingAccounts.push(
+            ...[
+              {
+                pubkey: x.bankPk,
+                isSigner: false,
+                isWritable: false,
+              },
+              {
+                pubkey: priceOracle,
+                isSigner: false,
+                isWritable: false,
+              },
+            ]
+          );
+        }
+      });
+    }
+    if (!iMfiAccount.accountData || !includedFlashLoanToken) {
+      remainingAccounts.push(
+        ...[
+          {
+            pubkey: bank.publicKey,
+            isSigner: false,
+            isWritable: false,
+          },
+          {
+            pubkey: publicKey(associatedBankAccs.priceOracle),
+            isSigner: false,
+            isWritable: false,
+          },
+        ]
+      );
+    }
+
+    const banksRequiringBalanceClose = Array.from(
+      new Set([
+        bank.publicKey.toString(),
+        ...(iMfiAccount.accountData?.lendingAccount.balances ?? [])
+          .filter((x) => x.active && bytesToI80F48(x.liabilityShares.value) > 0)
+          .map((x) => x.bankPk.toString()),
+      ])
+    );
+
+    return transactionBuilder()
+      .add(
+        lendingAccountRepay(this.umi, {
+          amount: flashLoan.baseUnitAmount,
+          repayAll: null,
+          bank: bank.publicKey,
+          bankLiquidityVault: publicKey(associatedBankAccs.liquidityVault),
+          marginfiAccount: publicKey(iMfiAccount.accountPk),
+          marginfiGroup: publicKey(marginfiGroup),
+          signer: this.signer,
+          signerTokenAccount: publicKey(
+            getTokenAccount(
+              toWeb3JsPublicKey(this.signer.publicKey),
+              flashLoan.mint
+            )
+          ),
+        })
+      )
+      .add(
+        banksRequiringBalanceClose.map((x) =>
+          this.closeBalance(
+            iMfiAccount.accountPk,
+            new PublicKey(x),
+            marginfiGroup
+          )
+        )
+      )
+      .add(
+        lendingAccountEndFlashloan(this.umi, {
+          marginfiAccount: publicKey(iMfiAccount.accountPk),
+          signer: this.signer,
+        }).addRemainingAccounts(remainingAccounts)
+      );
+  }
+
+  closeBalance(
+    marginfiAccount: PublicKey,
+    bank: PublicKey,
+    marginfiGroup: PublicKey
+  ) {
+    return transactionBuilder().add(
+      lendingAccountCloseBalance(this.umi, {
+        signer: this.signer,
+        marginfiAccount: publicKey(marginfiAccount),
+        bank: publicKey(bank),
+        marginfiGroup: publicKey(marginfiGroup),
+      })
+    );
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,5 @@
+export * from "./flashLoans";
+export * from "./rebalance";
+export * from "./solauto";
+export * from "./swap";
+export * from "./transactions";

package/src/services/rebalance/index.ts

@@ -0,0 +1,2 @@
+export * from "./rebalanceTxBuilder";
+export * from "./rebalanceValues";

package/src/services/rebalance/rebalanceSwapManager.ts

@@ -0,0 +1,218 @@
+import { QuoteResponse } from "@jup-ag/api";
+import { FlashLoanRequirements } from "../../types";
+import { SolautoClient } from "../solauto";
+import { JupSwapManager, SwapParams, SwapInput } from "../swap";
+import { RebalanceValues } from "./rebalanceValues";
+import { RebalanceDirection, TokenType } from "../../generated";
+import {
+  consoleLog,
+  fromBaseUnit,
+  getLiqUtilzationRateBps,
+  maxRepayToBps,
+  safeGetPrice,
+  toBaseUnit,
+  tokenInfo,
+} from "../../utils";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+
+export class RebalanceSwapManager {
+  public swapParams!: SwapParams;
+  public swapQuote?: QuoteResponse;
+  public flBorrowAmount?: bigint;
+
+  private jupSwapManager!: JupSwapManager;
+
+  constructor(
+    private client: SolautoClient,
+    private values: RebalanceValues,
+    private flRequirements?: FlashLoanRequirements,
+    private targetLiqUtilizationRateBps?: number
+  ) {
+    this.jupSwapManager = new JupSwapManager(client.signer);
+  }
+
+  private isBoost() {
+    return this.values.rebalanceDirection === RebalanceDirection.Boost;
+  }
+
+  private usdToSwap() {
+    return Math.abs(this.values.debtAdjustmentUsd);
+  }
+
+  private postRebalanceLiqUtilizationRateBps(swapOutputAmount?: bigint) {
+    let supplyUsd = this.client.solautoPosition.supplyUsd();
+    // TODO: add token balance change
+    let debtUsd = this.client.solautoPosition.debtUsd();
+
+    const outputToken = toWeb3JsPublicKey(
+      this.isBoost()
+        ? this.client.solautoPosition.state().supply.mint
+        : this.client.solautoPosition.state().debt.mint
+    );
+    const swapOutputUsd = swapOutputAmount
+      ? fromBaseUnit(swapOutputAmount, tokenInfo(outputToken).decimals) *
+        (safeGetPrice(outputToken) ?? 0)
+      : this.usdToSwap();
+
+    supplyUsd = this.isBoost()
+      ? supplyUsd + swapOutputUsd
+      : supplyUsd - this.usdToSwap();
+    debtUsd = this.isBoost()
+      ? debtUsd + this.usdToSwap()
+      : debtUsd - swapOutputUsd;
+
+    return getLiqUtilzationRateBps(
+      supplyUsd,
+      debtUsd,
+      this.client.solautoPosition.state().liqThresholdBps ?? 0
+    );
+  }
+
+  private async findSufficientQuote(
+    swapInput: SwapInput,
+    criteria: {
+      minOutputAmount?: bigint;
+      minLiqUtilizationRateBps?: number;
+      maxLiqUtilizationRateBps?: number;
+    }
+  ): Promise<QuoteResponse> {
+    let swapQuote: QuoteResponse;
+    let insufficient: boolean = false;
+
+    for (let i = 0; i < 10; i++) {
+      consoleLog("Finding sufficient quote...");
+      swapQuote = await this.jupSwapManager.getQuote(swapInput);
+
+      const outputAmount = parseInt(swapQuote.outAmount);
+      const postRebalanceRate = this.postRebalanceLiqUtilizationRateBps(
+        BigInt(outputAmount)
+      );
+      insufficient = criteria.minOutputAmount
+        ? outputAmount < Number(criteria.minOutputAmount)
+        : criteria.minLiqUtilizationRateBps
+          ? postRebalanceRate < criteria.minLiqUtilizationRateBps
+          : postRebalanceRate > criteria.maxLiqUtilizationRateBps!;
+
+      if (insufficient) {
+        consoleLog("Insufficient swap quote:", swapQuote);
+        swapInput.amount = this.bigIntWithIncrement(swapInput.amount, 0.01);
+      } else {
+        break;
+      }
+    }
+
+    return swapQuote!;
+  }
+
+  private swapDetails() {
+    const input = this.isBoost()
+      ? this.client.solautoPosition.state().debt
+      : this.client.solautoPosition.state().supply;
+    const output = this.isBoost()
+      ? this.client.solautoPosition.state().supply
+      : this.client.solautoPosition.state().debt;
+
+    let inputAmount = toBaseUnit(
+      this.usdToSwap() / safeGetPrice(input.mint)!,
+      input.decimals
+    );
+
+    return {
+      input,
+      output,
+      inputAmount,
+    };
+  }
+
+  private bigIntWithIncrement(num: bigint, inc: number) {
+    return num + BigInt(Math.round(Number(num) * inc));
+  }
+
+  async setSwapParams(attemptNum: number) {
+    const rebalanceToZero = this.targetLiqUtilizationRateBps === 0;
+    let { input, output, inputAmount } = this.swapDetails();
+
+    let outputAmount = rebalanceToZero
+      ? output.amountUsed.baseUnit +
+        BigInt(
+          Math.round(
+            Number(output.amountUsed.baseUnit) *
+              // Add this small percentage to account for the APR on the debt between now and the transaction
+              0.0001
+          )
+        )
+      : toBaseUnit(
+          this.usdToSwap() / safeGetPrice(output.mint)!,
+          output.decimals
+        );
+
+    const flashLoanRepayFromDebt =
+      !this.isBoost() &&
+      this.flRequirements &&
+      this.flRequirements.liquiditySource === TokenType.Debt;
+
+    const exactOut = flashLoanRepayFromDebt && !rebalanceToZero;
+    const exactIn = !exactOut;
+
+    if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+      inputAmount = this.bigIntWithIncrement(inputAmount, 0.005);
+    }
+
+    const swapAmount = exactOut
+      ? this.flRequirements
+        ? this.bigIntWithIncrement(
+            outputAmount,
+            this.flRequirements.flFeeBps ?? 0
+          )
+        : outputAmount
+      : inputAmount;
+    const swapInput: SwapInput = {
+      inputMint: toWeb3JsPublicKey(input.mint),
+      outputMint: toWeb3JsPublicKey(output.mint),
+      exactIn,
+      exactOut,
+      amount: swapAmount,
+    };
+    consoleLog("Swap input:", swapInput);
+
+    if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+      this.swapQuote = await this.findSufficientQuote(swapInput, {
+        minOutputAmount: rebalanceToZero ? outputAmount : undefined,
+        maxLiqUtilizationRateBps: this.values.repayingCloseToMaxLtv
+          ? maxRepayToBps(
+              this.client.solautoPosition.state().maxLtvBps ?? 0,
+              this.client.solautoPosition.state().liqThresholdBps ?? 0
+            ) - 15
+          : undefined,
+      });
+    }
+
+    if (this.flRequirements) {
+      this.flBorrowAmount = exactOut
+        ? outputAmount
+        : this.swapQuote
+          ? BigInt(parseInt(this.swapQuote.inAmount))
+          : inputAmount;
+    }
+
+    this.swapParams = {
+      ...swapInput,
+      destinationWallet: flashLoanRepayFromDebt
+        ? toWeb3JsPublicKey(this.client.signer.publicKey)
+        : this.client.solautoPosition.publicKey,
+      slippageIncFactor: 0.2 + attemptNum * 0.25,
+    };
+  }
+
+  async getSwapTxData() {
+    const { jupQuote, lookupTableAddresses, setupInstructions, swapIx } =
+      await this.jupSwapManager.getJupSwapTxData(this.swapParams);
+
+    return {
+      swapQuote: jupQuote,
+      lookupTableAddresses,
+      setupInstructions,
+      swapIx,
+    };
+  }
+}