@haven-fi/solauto-sdk 1.0.0

package/src/utils/marginfiUtils.ts

@@ -0,0 +1,383 @@
+import { PublicKey } from "@solana/web3.js";
+import { publicKey } from "@metaplex-foundation/umi";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  Bank,
+  getMarginfiAccountSize,
+  MARGINFI_PROGRAM_ID,
+  MarginfiAccount,
+  safeFetchAllMarginfiAccount,
+  safeFetchBank,
+} from "../marginfi-sdk";
+import { currentUnixSeconds, getTokenPrices } from "./generalUtils";
+import {
+  bytesToI80F48,
+  fromBaseUnit,
+  getLiqUtilzationRateBps,
+  toBaseUnit,
+} from "./numberUtils";
+import { PRICES, UMI } from "../constants/solautoConstants";
+import { MARGINFI_ACCOUNTS } from "../constants/marginfiAccounts";
+import { MarginfiTokenAccounts } from "../types/accounts";
+import { PositionState, PositionTokenUsage } from "../generated";
+import { USD_DECIMALS } from "../constants/generalAccounts";
+import { LivePositionUpdates } from "./solauto/generalUtils";
+import { currentUnixSecondsSolana } from "./solanaUtils";
+
+export function findMarginfiBankAccounts({
+  mint,
+  bank,
+}: {
+  mint?: string;
+  bank?: string;
+}): MarginfiTokenAccounts {
+  for (const key in MARGINFI_ACCOUNTS) {
+    const account = MARGINFI_ACCOUNTS[key];
+    if (mint && account.mint.toString().toLowerCase() === mint.toLowerCase()) {
+      return account;
+    }
+    if (bank && account.bank.toString().toLowerCase() === bank.toLowerCase()) {
+      return account;
+    }
+  }
+  throw new Error(`Marginfi accounts not found by the mint: ${mint}`);
+}
+
+export async function getMaxLtvAndLiqThreshold(
+  supplyBank: Bank,
+  debtBank: Bank,
+  supplyPrice?: number
+): Promise<[number, number]> {
+  if (!PRICES[supplyBank.mint.toString()].price) {
+    const [price] = await getTokenPrices([toWeb3JsPublicKey(supplyBank.mint)]);
+    supplyPrice = price;
+  }
+
+  let maxLtv =
+    bytesToI80F48(supplyBank.config.assetWeightInit.value) /
+    bytesToI80F48(debtBank.config.liabilityWeightInit.value);
+  const liqThreshold =
+    bytesToI80F48(supplyBank.config.assetWeightMaint.value) /
+    bytesToI80F48(debtBank.config.liabilityWeightMaint.value);
+
+  const totalDepositedUsdValue =
+    fromBaseUnit(
+      BigInt(
+        Math.round(
+          bytesToI80F48(supplyBank!.totalAssetShares.value) *
+            bytesToI80F48(supplyBank!.assetShareValue.value)
+        )
+      ),
+      supplyBank!.mintDecimals
+    ) * supplyPrice!;
+  if (
+    supplyBank!.config.totalAssetValueInitLimit !== BigInt(0) &&
+    totalDepositedUsdValue > supplyBank!.config.totalAssetValueInitLimit
+  ) {
+    const discount =
+      Number(supplyBank!.config.totalAssetValueInitLimit) /
+      totalDepositedUsdValue;
+    maxLtv = Math.round(maxLtv * Number(discount));
+  }
+
+  return [maxLtv, liqThreshold];
+}
+
+export async function getAllMarginfiAccountsByAuthority(
+  authority: PublicKey
+): Promise<MarginfiAccount[]> {
+  const marginfiAccounts = await UMI.rpc.getProgramAccounts(
+    MARGINFI_PROGRAM_ID,
+    {
+      commitment: "finalized",
+      dataSlice: {
+        offset: 0,
+        length: 0,
+      },
+      filters: [
+        {
+          dataSize: getMarginfiAccountSize(),
+        },
+        {
+          memcmp: {
+            bytes: new Uint8Array(authority.toBuffer()),
+            offset: 40, // Anchor account discriminator + group pubkey
+          },
+        },
+      ],
+    }
+  );
+
+  return safeFetchAllMarginfiAccount(
+    UMI,
+    marginfiAccounts.map((x) => x.publicKey)
+  );
+}
+
+async function getTokenUsage(
+  bank: Bank,
+  isAsset: boolean,
+  shares: number,
+  amountUsedAdjustment?: bigint
+): Promise<PositionTokenUsage> {
+  let [marketPrice] = await getTokenPrices([toWeb3JsPublicKey(bank.mint)]);
+  const [assetShareValue, liabilityShareValue] =
+    await getUpToDateShareValues(bank);
+  const shareValue = isAsset ? assetShareValue : liabilityShareValue;
+  const amountUsed = shares * shareValue + Number(amountUsedAdjustment ?? 0);
+
+  const totalDeposited =
+    bytesToI80F48(bank.totalAssetShares.value) * assetShareValue;
+  const amountCanBeUsd = isAsset
+    ? Number(bank.config.depositLimit) - totalDeposited
+    : totalDeposited -
+      bytesToI80F48(bank.totalLiabilityShares.value) * liabilityShareValue;
+
+  return {
+    mint: bank.mint,
+    decimals: bank.mintDecimals,
+    amountUsed: {
+      baseUnit: BigInt(Math.round(amountUsed)),
+      baseAmountUsdValue: toBaseUnit(
+        fromBaseUnit(BigInt(Math.round(amountUsed)), bank.mintDecimals) *
+          marketPrice,
+        USD_DECIMALS
+      ),
+    },
+    amountCanBeUsed: {
+      baseUnit: BigInt(Math.round(amountCanBeUsd)),
+      baseAmountUsdValue: toBaseUnit(
+        fromBaseUnit(BigInt(Math.round(amountCanBeUsd)), bank.mintDecimals) *
+          marketPrice,
+        USD_DECIMALS
+      ),
+    },
+    baseAmountMarketPriceUsd: toBaseUnit(marketPrice, USD_DECIMALS),
+    flashLoanFeeBps: 0,
+    borrowFeeBps: 0,
+    padding1: [],
+    padding2: [],
+    padding: new Uint8Array([]),
+  };
+}
+
+export async function getMarginfiAccountPositionState(
+  supplyMint: PublicKey,
+  debtMint: PublicKey,
+  marginfiAccount: MarginfiAccount | null,
+  livePositionUpdates?: LivePositionUpdates
+): Promise<PositionState | undefined> {
+  let supplyBank: Bank | null =
+    supplyMint && supplyMint !== PublicKey.default
+      ? await safeFetchBank(
+          UMI,
+          publicKey(
+            findMarginfiBankAccounts({ mint: supplyMint.toString() }).bank
+          )
+        )
+      : null;
+  let debtBank: Bank | null =
+    debtMint && debtMint !== PublicKey.default
+      ? await safeFetchBank(
+          UMI,
+          publicKey(
+            findMarginfiBankAccounts({ mint: debtMint.toString() }).bank
+          )
+        )
+      : null;
+
+  let supplyUsage: PositionTokenUsage | undefined = undefined;
+  let debtUsage: PositionTokenUsage | undefined = undefined;
+
+  if (
+    marginfiAccount !== null &&
+    marginfiAccount.lendingAccount.balances.filter((x) => x.active).length > 0
+  ) {
+    const supplyBalances = marginfiAccount.lendingAccount.balances.filter(
+      (balance) =>
+        balance.active && bytesToI80F48(balance.assetShares.value) > 0
+    );
+    const debtBalances = marginfiAccount.lendingAccount.balances.filter(
+      (balance) =>
+        balance.active && bytesToI80F48(balance.liabilityShares.value) > 0
+    );
+
+    for (const balance of supplyBalances) {
+      if (supplyBank === null) {
+        supplyBank = await safeFetchBank(UMI, balance.bankPk);
+      }
+
+      supplyUsage = await getTokenUsage(
+        supplyBank!,
+        true,
+        bytesToI80F48(balance.assetShares.value),
+        livePositionUpdates?.supplyAdjustment
+      );
+      break;
+    }
+    for (const balance of debtBalances) {
+      if (debtBank === null) {
+        debtBank = await safeFetchBank(UMI, balance.bankPk);
+      }
+
+      debtUsage = await getTokenUsage(
+        debtBank!,
+        false,
+        bytesToI80F48(balance.liabilityShares.value),
+        livePositionUpdates?.debtAdjustment
+      );
+      break;
+    }
+  }
+
+  if (supplyBank !== null && !supplyUsage) {
+    supplyUsage = await getTokenUsage(
+      supplyBank,
+      true,
+      0,
+      livePositionUpdates?.supplyAdjustment
+    );
+  }
+
+  if (debtBank !== null && !debtUsage) {
+    debtUsage = await getTokenUsage(
+      debtBank,
+      false,
+      0,
+      livePositionUpdates?.debtAdjustment
+    );
+  }
+
+  if (supplyBank === null || debtBank === null) {
+    return undefined;
+  }
+
+  const supplyPrice = PRICES[supplyMint.toString()].price;
+  let [maxLtv, liqThreshold] = await getMaxLtvAndLiqThreshold(
+    supplyBank,
+    debtBank,
+    supplyPrice
+  );
+  const supplyUsd = fromBaseUnit(
+    supplyUsage!.amountUsed.baseAmountUsdValue,
+    USD_DECIMALS
+  );
+  const debtUsd = fromBaseUnit(
+    debtUsage?.amountUsed?.baseAmountUsdValue ?? BigInt(0),
+    USD_DECIMALS
+  );
+
+  return {
+    liqUtilizationRateBps: getLiqUtilzationRateBps(
+      supplyUsd,
+      debtUsd,
+      Math.round(liqThreshold * 10000)
+    ),
+    netWorth: {
+      baseAmountUsdValue: toBaseUnit(supplyUsd - debtUsd, USD_DECIMALS),
+      baseUnit: toBaseUnit(
+        (supplyUsd - debtUsd) / supplyPrice,
+        supplyUsage!.decimals
+      ),
+    },
+    supply: supplyUsage!,
+    debt: debtUsage!,
+    maxLtvBps: Math.round(maxLtv * 10000),
+    liqThresholdBps: Math.round(liqThreshold * 10000),
+    lastUpdated: BigInt(currentUnixSeconds()),
+    padding1: [],
+    padding2: [],
+    padding: [],
+  };
+}
+
+function marginfiInterestRateCurve(
+  bank: Bank,
+  utilizationRatio: number
+): number {
+  const optimalUr = bytesToI80F48(
+    bank.config.interestRateConfig.optimalUtilizationRate.value
+  );
+  const plateauIr = bytesToI80F48(
+    bank.config.interestRateConfig.plateauInterestRate.value
+  );
+  const maxIr = bytesToI80F48(
+    bank.config.interestRateConfig.maxInterestRate.value
+  );
+
+  if (utilizationRatio <= optimalUr) {
+    return (utilizationRatio / optimalUr) * plateauIr;
+  } else {
+    return (
+      ((utilizationRatio - optimalUr) / (1 - optimalUr)) * (maxIr - plateauIr) +
+      plateauIr
+    );
+  }
+}
+
+function calcInterestRate(
+  bank: Bank,
+  utilizationRatio: number
+): [number, number] {
+  const baseRate = marginfiInterestRateCurve(bank, utilizationRatio);
+
+  const lendingRate = baseRate * utilizationRatio;
+
+  const protocolIrFee = bytesToI80F48(
+    bank.config.interestRateConfig.protocolIrFee.value
+  );
+  const insuranceIrFee = bytesToI80F48(
+    bank.config.interestRateConfig.insuranceIrFee.value
+  );
+  const protocolFixedFeeApr = bytesToI80F48(
+    bank.config.interestRateConfig.protocolFixedFeeApr.value
+  );
+  const insuranceFixedFeeApr = bytesToI80F48(
+    bank.config.interestRateConfig.insuranceFeeFixedApr.value
+  );
+  const rateFee = protocolIrFee + insuranceIrFee;
+  const totalFixedFeeApr = protocolFixedFeeApr + insuranceFixedFeeApr;
+  const borrowingRate = baseRate * (1 + rateFee) * totalFixedFeeApr;
+
+  return [lendingRate, borrowingRate];
+}
+
+function calcAccruedInterestPaymentPerPeriod(
+  apr: number,
+  timeDelta: number,
+  shareValue: number
+) {
+  const irPerPeriod = (apr * timeDelta) / 31_536_000; // Seconds per year
+  const newValue = shareValue * (1 + irPerPeriod);
+  return newValue;
+}
+
+export async function getUpToDateShareValues(
+  bank: Bank
+): Promise<[number, number]> {
+  const currentTime = await currentUnixSecondsSolana();
+  let timeDelta = currentTime - Number(bank.lastUpdate);
+
+  const totalAssets =
+    bytesToI80F48(bank.totalAssetShares.value) *
+    bytesToI80F48(bank.assetShareValue.value);
+  const totalLiabilities =
+    bytesToI80F48(bank.totalLiabilityShares.value) *
+    bytesToI80F48(bank.liabilityShareValue.value);
+
+  const utilizationRatio = totalLiabilities / totalAssets;
+  const [lendingApr, borrowingApr] = calcInterestRate(bank, utilizationRatio);
+
+  return [
+    calcAccruedInterestPaymentPerPeriod(
+      lendingApr,
+      timeDelta,
+      bytesToI80F48(bank.assetShareValue.value)
+    ),
+    calcAccruedInterestPaymentPerPeriod(
+      borrowingApr,
+      timeDelta,
+      bytesToI80F48(bank.liabilityShareValue.value)
+    ),
+  ];
+}

package/src/utils/numberUtils.ts

@@ -0,0 +1,77 @@
+
+export function getLiqUtilzationRateBps(supplyUsd: number, debtUsd: number, liqThresholdBps: number): number {
+  if (supplyUsd === 0) {
+    return 0;
+  }
+  
+  return toBps(debtUsd / (supplyUsd * fromBps(liqThresholdBps)));
+}
+
+export function toBaseUnit(value: number, decimals: number): bigint {
+    return BigInt(Math.round(value * Math.pow(10, decimals)));
+  }
+  
+export function fromBaseUnit(value: bigint, decimals: number): number {
+  return Number(value) / Math.pow(10, decimals);
+}
+
+export function fromBps(value: number): number {
+  return value / 10000;
+}
+
+export function toBps(value: number): number {
+  return Math.round(value * 10000);
+}
+
+export function bytesToI80F48(bytes: number[]): number {
+  if (bytes.length !== 16) {
+    throw new Error('Byte array must be exactly 16 bytes.');
+  }
+
+  const reversedBytes = bytes.slice().reverse();
+
+  let integerPart = BigInt(0);
+  let fractionalPart = BigInt(0);
+
+  for (let i = 0; i < 10; i++) {
+    integerPart = (integerPart << 8n) | BigInt(reversedBytes[i]);
+  }
+
+  for (let i = 10; i < 16; i++) {
+    fractionalPart = (fractionalPart << 8n) | BigInt(reversedBytes[i]);
+  }
+
+  const fullValue = integerPart * BigInt(2 ** 48) + fractionalPart;
+
+  return Number(fullValue) / (2 ** 48);
+}
+
+export function uint8ArrayToBigInt(uint8Array: Uint8Array): bigint {
+  if (uint8Array.length !== 8) {
+    throw new Error('Uint8Array must be exactly 8 bytes long to convert to u64.');
+  }
+
+  const buffer = uint8Array.buffer;
+
+  const dataView = new DataView(buffer);
+
+  const low = dataView.getUint32(0, true);
+  const high = dataView.getUint32(4, true);
+
+  return BigInt(high) << 32n | BigInt(low);
+}
+
+export function getDebtAdjustmentUsd(
+  liqThresholdBps: number,
+  supplyUsd: number,
+  debtUsd: number,
+  targetLiqUtilizationRateBps: number,
+  adjustmentFeeBps?: number
+) {
+  const adjustmentFee = adjustmentFeeBps && adjustmentFeeBps > 0 ? fromBps(adjustmentFeeBps) : 0;
+  const liqThreshold = fromBps(liqThresholdBps);
+  const targetLiqUtilizationRate = fromBps(targetLiqUtilizationRateBps);
+
+  const debtAdjustmentUsd = (targetLiqUtilizationRate * supplyUsd * liqThreshold - debtUsd) / (1 - targetLiqUtilizationRate * (1 - adjustmentFee) * liqThreshold);
+  return debtAdjustmentUsd;
+}