@haven-fi/solauto-sdk 1.0.9 → 1.0.11

package/src/utils/marginfiUtils.ts

@@ -1,5 +1,5 @@
 import { PublicKey } from "@solana/web3.js";
-import { publicKey } from "@metaplex-foundation/umi";
+import { publicKey, Umi } from "@metaplex-foundation/umi";
 import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
 import {
   Bank,
@@ -8,6 +8,7 @@ import {
   MarginfiAccount,
   safeFetchAllMarginfiAccount,
   safeFetchBank,
+  safeFetchMarginfiAccount,
 } from "../marginfi-sdk";
 import { currentUnixSeconds, getTokenPrices } from "./generalUtils";
 import {
@@ -16,7 +17,7 @@ import {
   getLiqUtilzationRateBps,
   toBaseUnit,
 } from "./numberUtils";
-import { PRICES, UMI } from "../constants/solautoConstants";
+import { PRICES } from "../constants/solautoConstants";
 import { MARGINFI_ACCOUNTS } from "../constants/marginfiAccounts";
 import { MarginfiTokenAccounts } from "../types/accounts";
 import { PositionState, PositionTokenUsage } from "../generated";
@@ -84,9 +85,10 @@ export async function getMaxLtvAndLiqThreshold(
 }
 
 export async function getAllMarginfiAccountsByAuthority(
+  umi: Umi,
   authority: PublicKey
 ): Promise<MarginfiAccount[]> {
-  const marginfiAccounts = await UMI.rpc.getProgramAccounts(
+  const marginfiAccounts = await umi.rpc.getProgramAccounts(
     MARGINFI_PROGRAM_ID,
     {
       commitment: "finalized",
@@ -109,20 +111,23 @@ export async function getAllMarginfiAccountsByAuthority(
   );
 
   return safeFetchAllMarginfiAccount(
-    UMI,
+    umi,
     marginfiAccounts.map((x) => x.publicKey)
   );
 }
 
 async function getTokenUsage(
+  umi: Umi,
   bank: Bank,
   isAsset: boolean,
   shares: number,
   amountUsedAdjustment?: bigint
 ): Promise<PositionTokenUsage> {
   let [marketPrice] = await getTokenPrices([toWeb3JsPublicKey(bank.mint)]);
-  const [assetShareValue, liabilityShareValue] =
-    await getUpToDateShareValues(bank);
+  const [assetShareValue, liabilityShareValue] = await getUpToDateShareValues(
+    umi,
+    bank
+  );
   const shareValue = isAsset ? assetShareValue : liabilityShareValue;
   const amountUsed = shares * shareValue + Number(amountUsedAdjustment ?? 0);
 
@@ -162,15 +167,21 @@ async function getTokenUsage(
 }
 
 export async function getMarginfiAccountPositionState(
+  umi: Umi,
   supplyMint: PublicKey,
   debtMint: PublicKey,
-  marginfiAccount: MarginfiAccount | null,
+  marginfiAccountPk: PublicKey,
   livePositionUpdates?: LivePositionUpdates
 ): Promise<PositionState | undefined> {
+  let marginfiAccount = await safeFetchMarginfiAccount(
+    umi,
+    publicKey(marginfiAccountPk)
+  );
+
   let supplyBank: Bank | null =
     supplyMint && supplyMint !== PublicKey.default
       ? await safeFetchBank(
-          UMI,
+          umi,
           publicKey(
             findMarginfiBankAccounts({ mint: supplyMint.toString() }).bank
           )
@@ -179,7 +190,7 @@ export async function getMarginfiAccountPositionState(
   let debtBank: Bank | null =
     debtMint && debtMint !== PublicKey.default
       ? await safeFetchBank(
-          UMI,
+          umi,
           publicKey(
             findMarginfiBankAccounts({ mint: debtMint.toString() }).bank
           )
@@ -204,10 +215,11 @@ export async function getMarginfiAccountPositionState(
 
     for (const balance of supplyBalances) {
       if (supplyBank === null) {
-        supplyBank = await safeFetchBank(UMI, balance.bankPk);
+        supplyBank = await safeFetchBank(umi, balance.bankPk);
       }
 
       supplyUsage = await getTokenUsage(
+        umi,
         supplyBank!,
         true,
         bytesToI80F48(balance.assetShares.value),
@@ -217,10 +229,11 @@ export async function getMarginfiAccountPositionState(
     }
     for (const balance of debtBalances) {
       if (debtBank === null) {
-        debtBank = await safeFetchBank(UMI, balance.bankPk);
+        debtBank = await safeFetchBank(umi, balance.bankPk);
       }
 
       debtUsage = await getTokenUsage(
+        umi,
         debtBank!,
         false,
         bytesToI80F48(balance.liabilityShares.value),
@@ -232,6 +245,7 @@ export async function getMarginfiAccountPositionState(
 
   if (supplyBank !== null && !supplyUsage) {
     supplyUsage = await getTokenUsage(
+      umi,
       supplyBank,
       true,
       0,
@@ -241,6 +255,7 @@ export async function getMarginfiAccountPositionState(
 
   if (debtBank !== null && !debtUsage) {
     debtUsage = await getTokenUsage(
+      umi,
       debtBank,
       false,
       0,
@@ -353,9 +368,10 @@ function calcAccruedInterestPaymentPerPeriod(
 }
 
 export async function getUpToDateShareValues(
+  umi: Umi,
   bank: Bank
 ): Promise<[number, number]> {
-  const currentTime = await currentUnixSecondsSolana();
+  const currentTime = await currentUnixSecondsSolana(umi);
   let timeDelta = currentTime - Number(bank.lastUpdate);
 
   const totalAssets =

package/src/utils/solanaUtils.ts

@@ -3,6 +3,7 @@ import {
   AddressLookupTableInput,
   Signer,
   TransactionBuilder,
+  Umi,
   WrappedInstruction,
   publicKey,
   transactionBuilder,
@@ -15,6 +16,7 @@ import {
 import {
   AddressLookupTableAccount,
   ComputeBudgetProgram,
+  Connection,
   PublicKey,
   RpcResponseAndContext,
   SimulatedTransactionResponse,
@@ -28,21 +30,19 @@ import {
   createTransferInstruction,
 } from "@solana/spl-token";
 import { getTokenAccount } from "./accountUtils";
-import { SolautoClient } from "../clients/solautoClient";
-import { CONNECTION, UMI } from "../constants/solautoConstants";
 import { arraysAreEqual, retryWithExponentialBackoff } from "./generalUtils";
 import {
   getLendingAccountEndFlashloanInstructionDataSerializer,
   getLendingAccountStartFlashloanInstructionDataSerializer,
 } from "../marginfi-sdk";
 
-export async function currentUnixSecondsSolana(): Promise<number> {
+export async function currentUnixSecondsSolana(umi: Umi): Promise<number> {
   return await retryWithExponentialBackoff(async () => {
-    const blockTime = await CONNECTION.getBlockTime(await CONNECTION.getSlot());
+    const blockTime = await umi.rpc.getBlockTime(await umi.rpc.getSlot());
     if (blockTime === null) {
       throw new Error("Unable to retrieve block time");
     }
-    return blockTime;
+    return Number(blockTime);
   });
 }
 
@@ -137,9 +137,10 @@ export function splTokenTransferUmiIx(
 }
 
 export async function getAdressLookupInputs(
+  umi: Umi,
   lookupTableAddresses: string[]
 ): Promise<AddressLookupTableInput[]> {
-  const addressLookupTableAccountInfos = await UMI.rpc.getAccounts(
+  const addressLookupTableAccountInfos = await umi.rpc.getAccounts(
     lookupTableAddresses.map((key) => publicKey(key))
   );
 
@@ -225,13 +226,14 @@ export function assembleFinalTransaction(
 }
 
 async function simulateTransaction(
+  connection: Connection,
   transaction: VersionedTransaction
 ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>> {
-  const simulationResult = await CONNECTION.simulateTransaction(transaction, {
+  const simulationResult = await connection.simulateTransaction(transaction, {
     sigVerify: true,
   });
   if (simulationResult.value.err) {
-    simulationResult.value.logs?.forEach((x) => {
+    simulationResult.value.logs?.forEach((x: any) => {
       console.log(x);
     });
     throw simulationResult.value.err;
@@ -240,14 +242,15 @@ async function simulateTransaction(
 }
 
 export async function getComputeUnitPriceEstimate(
+  umi: Umi,
   tx: TransactionBuilder,
   attemptNum?: number
 ): Promise<number> {
   const web3Transaction = toWeb3JsTransaction(
-    (await tx.setLatestBlockhash(UMI, { commitment: "finalized" })).build(UMI)
+    (await tx.setLatestBlockhash(umi, { commitment: "finalized" })).build(umi)
   );
   const serializedTransaction = bs58.encode(web3Transaction.serialize());
-  const resp = await UMI.rpc.call("getPriorityFeeEstimate", [
+  const resp = await umi.rpc.call("getPriorityFeeEstimate", [
     {
       transaction: serializedTransaction,
       options: { priorityLevel: attemptNum && attemptNum > 0 ? "VeryHigh" : "High" },
@@ -259,30 +262,32 @@ export async function getComputeUnitPriceEstimate(
 }
 
 export async function sendSingleOptimizedTransaction(
-  client: SolautoClient,
+  umi: Umi,
+  connection: Connection,
   tx: TransactionBuilder,
   simulateOnly?: boolean,
   attemptNum?: number
 ): Promise<Uint8Array | undefined> {
-  client.log("Sending single optimized transaction...");
-  client.log("Instructions: ", tx.getInstructions().length);
-  client.log("Serialized transaction size: ", tx.getTransactionSize(UMI));
+  console.log("Sending single optimized transaction...");
+  console.log("Instructions: ", tx.getInstructions().length);
+  console.log("Serialized transaction size: ", tx.getTransactionSize(umi));
 
-  const feeEstimate = await getComputeUnitPriceEstimate(tx, attemptNum);
-  client.log("Compute unit price: ", feeEstimate);
+  const feeEstimate = await getComputeUnitPriceEstimate(umi, tx, attemptNum);
+  console.log("Compute unit price: ", feeEstimate);
 
   const simulationResult = await retryWithExponentialBackoff(
     async () =>
       await simulateTransaction(
+        connection,
         toWeb3JsTransaction(
           await (
             await assembleFinalTransaction(
-              client.signer,
+              umi.identity,
               tx,
               feeEstimate,
               1_400_000
-            ).setLatestBlockhash(UMI)
-          ).buildAndSign(UMI)
+            ).setLatestBlockhash(umi)
+          ).buildAndSign(umi)
         )
       )
   );
@@ -290,17 +295,17 @@ export async function sendSingleOptimizedTransaction(
   const computeUnitLimit = Math.round(
     simulationResult.value.unitsConsumed! * 1.15
   );
-  client.log("Compute unit limit: ", computeUnitLimit);
+  console.log("Compute unit limit: ", computeUnitLimit);
 
   if (!simulateOnly) {
     const result = await retryWithExponentialBackoff(
       async () =>
         await assembleFinalTransaction(
-          client.signer,
+          umi.identity,
           tx,
           feeEstimate,
           computeUnitLimit
-        ).sendAndConfirm(UMI, {
+        ).sendAndConfirm(umi, {
           send: {
             skipPreflight: true,
             commitment: "finalized",
@@ -308,7 +313,7 @@ export async function sendSingleOptimizedTransaction(
           confirm: { commitment: "finalized" },
         })
     );
-    client.log(`https://solscan.io/tx/${bs58.encode(result.signature)}`);
+    console.log(`https://solscan.io/tx/${bs58.encode(result.signature)}`);
     if (result.result.value.err !== null) {
       throw new Error(result.result.value.err.toString());
     }

package/src/utils/solauto/generalUtils.ts

@@ -1,4 +1,4 @@
-import { isOption, isSome, PublicKey } from "@metaplex-foundation/umi";
+import { isOption, isSome, PublicKey, Umi } from "@metaplex-foundation/umi";
 import {
   AutomationSettings,
   DCASettings,
@@ -13,14 +13,19 @@ import {
   getSolautoPositionAccountDataSerializer,
   getSolautoPositionSize,
 } from "../../generated";
-import { currentUnixSeconds } from "../generalUtils";
-import { fromBps, toBps } from "../numberUtils";
+import { currentUnixSeconds, getTokenPrices } from "../generalUtils";
 import {
-  MAX_REPAY_GAP_BPS,
-  UMI,
-} from "../../constants/solautoConstants";
+  fromBaseUnit,
+  fromBps,
+  getLiqUtilzationRateBps,
+  toBaseUnit,
+  toBps,
+} from "../numberUtils";
+import { MAX_REPAY_GAP_BPS } from "../../constants/solautoConstants";
 import { getReferralState } from "../accountUtils";
 import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import { USD_DECIMALS } from "../../constants";
+import { getMarginfiAccountPositionState } from "../marginfiUtils";
 
 function newPeriodsPassed(
   automation: AutomationSettings,
@@ -90,7 +95,10 @@ export function getAdjustedSettingsFromAutomation(
   };
 }
 
-export function getSolautoFeesBps(isReferred: boolean, feeType: FeeType): {
+export function getSolautoFeesBps(
+  isReferred: boolean,
+  feeType: FeeType
+): {
   solauto: number;
   referrer: number;
   total: number;
@@ -116,11 +124,17 @@ export function getMaxLiqUtilizationRate(
 }
 
 export function maxRepayFrom(maxLtvBps: number, liqThresholdBps: number) {
-  return Math.min(9000, getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps - 1000));
+  return Math.min(
+    9000,
+    getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps - 1000)
+  );
 }
 
 export function maxRepayTo(maxLtvBps: number, liqThresholdBps: number) {
-  return Math.min(maxRepayFrom(maxLtvBps, liqThresholdBps) - MAX_REPAY_GAP_BPS, getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps));
+  return Math.min(
+    maxRepayFrom(maxLtvBps, liqThresholdBps) - MAX_REPAY_GAP_BPS,
+    getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps)
+  );
 }
 
 export function eligibileForRebalance(
@@ -167,11 +181,15 @@ export function eligibleForRefresh(
   if (positionSettings.automation.targetPeriods > 0) {
     return eligibleForNextAutomationPeriod(positionSettings.automation);
   } else {
-    return currentUnixSeconds() - Number(positionState.lastUpdated) > 60 * 60 * 24 * 7;
+    return (
+      currentUnixSeconds() - Number(positionState.lastUpdated) >
+      60 * 60 * 24 * 7
+    );
   }
 }
 
 export async function getSolautoManagedPositions(
+  umi: Umi,
   authority?: PublicKey
 ): Promise<
   {
@@ -187,7 +205,7 @@ export async function getSolautoManagedPositions(
   // authority: Pubkey
   // lending_platform: u8
 
-  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+  const accounts = await umi.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
     commitment: "finalized",
     dataSlice: {
       offset: 0,
@@ -231,8 +249,8 @@ export async function getSolautoManagedPositions(
   });
 }
 
-export async function getAllReferralStates(): Promise<PublicKey[]> {
-  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+export async function getAllReferralStates(umi: Umi): Promise<PublicKey[]> {
+  const accounts = await umi.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
     commitment: "finalized",
     dataSlice: {
       offset: 0,
@@ -249,6 +267,7 @@ export async function getAllReferralStates(): Promise<PublicKey[]> {
 }
 
 export async function getReferralsByUser(
+  umi: Umi,
   user: PublicKey
 ): Promise<PublicKey[]> {
   // bump: [u8; 1],
@@ -257,7 +276,7 @@ export async function getReferralsByUser(
   // referred_by_state: Pubkey,
 
   const userReferralState = await getReferralState(toWeb3JsPublicKey(user));
-  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+  const accounts = await umi.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
     commitment: "finalized",
     dataSlice: {
       offset: 0,
@@ -279,6 +298,64 @@ export async function getReferralsByUser(
   return accounts.map((x) => x.publicKey);
 }
 
+async function positionStateWithLatestPrices(
+  umi: Umi,
+  state: PositionState,
+  protocolAccount: PublicKey,
+  lendingPlatform: LendingPlatform
+): Promise<PositionState | undefined> {
+  if (currentUnixSeconds() - Number(state.lastUpdated) > 60 * 60 * 24 * 7) {
+    if (lendingPlatform === LendingPlatform.Marginfi) {
+      return await getMarginfiAccountPositionState(
+        umi,
+        toWeb3JsPublicKey(state.supply.mint),
+        toWeb3JsPublicKey(state.debt.mint),
+        toWeb3JsPublicKey(protocolAccount)
+      );
+    } else {
+      throw new Error("Lending platorm not yet supported");
+    }
+  }
+
+  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),
+      },
+    },
+  };
+}
+
 type PositionAdjustment =
   | { type: "supply"; value: bigint }
   | { type: "debt"; value: bigint }

package/tests/transactions/solautoMarginfi.ts

@@ -26,7 +26,7 @@ describe("Solauto Marginfi tests", async () => {
   const positionId = 1;
 
   it("open - deposit - borrow - rebalance to 0 - withdraw - close", async () => {
-    const client = new SolautoMarginfiClient(true);
+    const client = new SolautoMarginfiClient(process.env.HELIUS_API_KEY!, true);
 
     const supply = NATIVE_MINT;
     const supplyDecimals = 9;