@haven-fi/solauto-sdk 1.0.581 → 1.0.583

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from './clients';
-export * from './constants';
-export * from './generated';
-export * from './transactions';
-export * from './types';
-export * from './utils';
-// export * from './marginfi-sdk';
-// export * from './jupiter-sdk';
+export * from "./constants";
+export * from "./generated/accounts";
+export * from "./generated/types";
+export * from "./marginfi-sdk/accounts";
+export * from "./services";
+export * from "./solautoPosition";
+export * from "./types";
+export * from "./utils";

package/src/marginfi-sdk/types/interestRateConfig.ts

@@ -11,6 +11,7 @@ import {
   array,
   struct,
   u128,
+  u32,
 } from '@metaplex-foundation/umi/serializers';
 import {
   WrappedI80F48,
@@ -26,7 +27,8 @@ export type InterestRateConfig = {
   insuranceIrFee: WrappedI80F48;
   protocolFixedFeeApr: WrappedI80F48;
   protocolIrFee: WrappedI80F48;
-  padding: Array<bigint>;
+  protocolOriginationFee: WrappedI80F48;
+  padding: Array<number>;
 };
 
 export type InterestRateConfigArgs = {
@@ -37,6 +39,7 @@ export type InterestRateConfigArgs = {
   insuranceIrFee: WrappedI80F48Args;
   protocolFixedFeeApr: WrappedI80F48Args;
   protocolIrFee: WrappedI80F48Args;
+  protocolOriginationFee: WrappedI80F48Args;
   padding: Array<number | bigint>;
 };
 
@@ -53,7 +56,8 @@ export function getInterestRateConfigSerializer(): Serializer<
       ['insuranceIrFee', getWrappedI80F48Serializer()],
       ['protocolFixedFeeApr', getWrappedI80F48Serializer()],
       ['protocolIrFee', getWrappedI80F48Serializer()],
-      ['padding', array(u128(), { size: 8 })],
+      ['protocolOriginationFee', getWrappedI80F48Serializer()],
+      ['padding', array(u32(), { size: 28 })],
     ],
     { description: 'InterestRateConfig' }
   ) as Serializer<InterestRateConfigArgs, InterestRateConfig>;

package/src/services/flashLoans/flProviderAggregator.ts

@@ -0,0 +1,74 @@
+import { FlProviderBase } from "./flProviderBase";
+import { PublicKey } from "@solana/web3.js";
+import { FlashLoanDetails, FlashLoanRequirements } from "../../types";
+import { Signer, TransactionBuilder, Umi } from "@metaplex-foundation/umi";
+import { TokenType } from "../../generated";
+import { MarginfiFlProvider } from "./marginfiFlProvider";
+
+export class FlProviderAggregator extends FlProviderBase {
+  private marginfiFlProvider!: MarginfiFlProvider;
+
+  constructor(
+    umi: Umi,
+    signer: Signer,
+    supplyMint: PublicKey,
+    debtMint: PublicKey
+  ) {
+    super(umi, signer, supplyMint, debtMint);
+    this.marginfiFlProvider = new MarginfiFlProvider(
+      umi,
+      signer,
+      supplyMint,
+      debtMint
+    );
+  }
+
+  async initialize() {
+    // TODO: PF
+    // Once we have more than one, set the right fl provider for each liquidity source
+    await this.marginfiFlProvider.initialize();
+  }
+
+  async flAccountPrereqIxs(): Promise<TransactionBuilder> {
+    return await this.marginfiFlProvider.initializeIMfiAccounts();
+  }
+
+  otherSigners(): Signer[] {
+    // TODO: PF
+    return [...this.flSigners, ...this.marginfiFlProvider.otherSigners()];
+  }
+
+  lutAccountsToAdd(): PublicKey[] {
+    return [
+      ...super.lutAccountsToAdd(),
+      ...this.marginfiFlProvider.lutAccountsToAdd(),
+    ];
+  }
+
+  private flProvider(source: TokenType): FlProviderBase {
+    // TODO: PF
+    return this.marginfiFlProvider;
+  }
+
+  liquidityAvailable(source: TokenType): bigint {
+    return this.flProvider(source).liquidityAvailable(source);
+  }
+
+  flFeeBps(source: TokenType, signerFlashLoan?: boolean): number {
+    return this.flProvider(source).flFeeBps(source);
+  }
+
+  flashBorrow(
+    flashLoan: FlashLoanDetails,
+    destTokenAccount: PublicKey
+  ): TransactionBuilder {
+    return this.flProvider(flashLoan.liquiditySource).flashBorrow(
+      flashLoan,
+      destTokenAccount
+    );
+  }
+
+  flashRepay(flashLoan: FlashLoanDetails): TransactionBuilder {
+    return this.flProvider(flashLoan.liquiditySource).flashRepay(flashLoan);
+  }
+}

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";