@haven-fi/solauto-sdk 1.0.626 → 1.0.628

package/src/utils/marginfiUtils.ts

@@ -9,20 +9,22 @@ import { PositionState, PositionTokenState } from "../generated";
 import {
   ALL_SUPPORTED_TOKENS,
   getMarginfiAccounts,
-  MARGINFI_PROD_PROGRAM,
-  MARGINFI_STAGING_PROGRAM,
-  MarginfiAccountsMap,
+  MARGINFI_SPONSORED_SHARD_ID,
+  MarginfiBankAccountsMap,
+  PYTH_SPONSORED_SHARD_ID,
   TOKEN_INFO,
   USD_DECIMALS,
 } from "../constants";
 import {
   Bank,
   deserializeMarginfiAccount,
+  fetchBank,
   getMarginfiAccountSize,
   getMarginfiErrorFromCode,
   getMarginfiErrorFromName,
   MarginfiAccount,
   OracleSetup,
+  safeFetchAllBank,
   safeFetchBank,
   safeFetchMarginfiAccount,
 } from "../marginfi-sdk";
@@ -38,22 +40,15 @@ import {
   toBps,
 } from "./numberUtils";
 import { getTokenAccountData } from "./accountUtils";
-
-export function getMarginfiProgram(env: ProgramEnv) {
-  return env === "Prod" ? MARGINFI_PROD_PROGRAM : MARGINFI_STAGING_PROGRAM;
-}
-
-export function isMarginfiProgram(programId: PublicKey) {
-  return (
-    programId.equals(MARGINFI_PROD_PROGRAM) ||
-    programId.equals(MARGINFI_STAGING_PROGRAM)
-  );
-}
+import {
+  getMostUpToDatePythOracle,
+  getPythPushOracleAddress,
+} from "./pythUtils";
 
 export function createDynamicMarginfiProgram(env?: ProgramEnv): Program {
   return {
     name: "marginfi",
-    publicKey: publicKey(getMarginfiProgram(env ?? "Prod")),
+    publicKey: publicKey(getMarginfiAccounts(env ?? "Prod").program),
     getErrorFromCode(code: number, cause?: Error) {
       return getMarginfiErrorFromCode(code, this, cause);
     },
@@ -77,18 +72,81 @@ export function umiWithMarginfiProgram(umi: Umi, marginfiEnv?: ProgramEnv) {
   });
 }
 
+export async function getAllBankRelatedAccounts(
+  umi: Umi,
+  bankAccountsMap: MarginfiBankAccountsMap
+): Promise<PublicKey[]> {
+  const banks = Object.values(bankAccountsMap).flatMap((group) =>
+    Object.values(group).map((accounts) => accounts.bank)
+  );
+  const banksData = await safeFetchAllBank(
+    umi,
+    banks.map((x) => publicKey(x))
+  );
+
+  const oracles = banksData
+    .map((bank) => {
+      const oracleKey = toWeb3JsPublicKey(bank.config.oracleKeys[0]);
+      return bank.config.oracleSetup === OracleSetup.PythPushOracle
+        ? [
+            getPythPushOracleAddress(oracleKey, PYTH_SPONSORED_SHARD_ID),
+            getPythPushOracleAddress(oracleKey, MARGINFI_SPONSORED_SHARD_ID),
+          ]
+        : [oracleKey];
+
+    })
+    .flat()
+    .map((x) => x.toString());
+
+  const otherAccounts = Object.entries(bankAccountsMap).flatMap(
+    ([groupName, tokenMap]) =>
+      Object.values(tokenMap).flatMap((accounts) => [
+        groupName,
+        accounts.liquidityVault,
+        accounts.vaultAuthority,
+      ])
+  );
+
+  return Array.from(new Set([...banks, ...oracles, ...otherAccounts]))
+    .filter((x) => x !== PublicKey.default.toString())
+    .map((x) => new PublicKey(x));
+}
+
 export async function fetchBankAddresses(umi: Umi, bankPk: PublicKey) {
-  const bank = await safeFetchBank(umi, fromWeb3JsPublicKey(bankPk));
+  const bank = await fetchBank(umi, fromWeb3JsPublicKey(bankPk));
   const liquidityVault = toWeb3JsPublicKey(bank!.liquidityVault);
   const vaultAuthority = (await getTokenAccountData(umi, liquidityVault))
     ?.owner;
+  const priceOracle = await getMarginfiPriceOracle(umi, { data: bank });
+
   return {
     bank: bankPk,
     liquidityVault,
     vaultAuthority,
+    priceOracle,
   };
 }
 
+export async function getMarginfiPriceOracle(
+  umi: Umi,
+  bank: { pk?: PublicKey; data?: Bank }
+) {
+  if (!bank.data) {
+    bank.data = await fetchBank(umi, fromWeb3JsPublicKey(bank.pk!));
+  }
+
+  const oracleKey = toWeb3JsPublicKey(bank.data.config.oracleKeys[0]);
+  const priceOracle =
+    bank.data.config.oracleSetup === OracleSetup.PythPushOracle
+      ? await getMostUpToDatePythOracle(umi, [
+          getPythPushOracleAddress(oracleKey, PYTH_SPONSORED_SHARD_ID),
+          getPythPushOracleAddress(oracleKey, MARGINFI_SPONSORED_SHARD_ID),
+        ])
+      : oracleKey;
+
+  return priceOracle;
+}
+
 interface AllMarginfiAssetAccounts extends MarginfiAssetAccounts {
   mint: PublicKey;
 }
@@ -96,7 +154,7 @@ interface AllMarginfiAssetAccounts extends MarginfiAssetAccounts {
 export function findMarginfiAccounts(
   bank: PublicKey
 ): AllMarginfiAssetAccounts {
-  const search = (bankAccounts: MarginfiAccountsMap) => {
+  const search = (bankAccounts: MarginfiBankAccountsMap) => {
     for (const group in bankAccounts) {
       for (const key in bankAccounts[group]) {
         const account = bankAccounts[group][key];

package/src/utils/pythUtils.ts

@@ -0,0 +1,84 @@
+import { PublicKey } from "@solana/web3.js";
+import { PYTH_PUSH_PROGRAM } from "../constants";
+import { u16ToArrayBufferLE, zip } from "./generalUtils";
+import * as borsh from "borsh";
+import { Umi } from "@metaplex-foundation/umi";
+import { fromWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+
+type PriceUpdateV2 = {
+  writeAuthority: Buffer;
+  verificationLevel: number;
+  priceMessage: {
+    feedId: Buffer;
+    price: bigint;
+    conf: bigint;
+    exponent: number;
+    publishTime: bigint;
+    prevPublishTime: bigint;
+    emaPrice: bigint;
+    emaConf: bigint;
+  };
+};
+
+const priceUpdateV2Schema = {
+  struct: {
+    writeAuthority: {
+      array: { type: "u8", len: 32 },
+    },
+    verificationLevel: "u8",
+    priceMessage: {
+      struct: {
+        feedId: { array: { type: "u8", len: 32 } },
+        price: "i64",
+        conf: "u64",
+        exponent: "i32",
+        publishTime: "i64",
+        prevPublishTime: "i64",
+        emaPrice: "i64",
+        emaConf: "u64",
+      },
+    },
+    postedSlot: "u64",
+  },
+};
+
+export function parsePriceInfo(data: Uint8Array): PriceUpdateV2 {
+  let decoded: PriceUpdateV2 = borsh.deserialize(
+    priceUpdateV2Schema,
+    data
+  ) as any;
+  return decoded;
+}
+
+export async function getMostUpToDatePythOracle(
+  umi: Umi,
+  oracleKeys: PublicKey[]
+) {
+  const oracles = zip(
+    oracleKeys,
+    (
+      await umi.rpc.getAccounts(
+        oracleKeys.map((x) => fromWeb3JsPublicKey(x)),
+        { commitment: "confirmed" }
+      )
+    ).map((x) => (x.exists ? parsePriceInfo(x!.data.slice(8)) : undefined))
+  ).sort(
+    (a, b) =>
+      Number(b[1]?.priceMessage.publishTime ?? 0) -
+      Number(a[1]?.priceMessage.publishTime ?? 0)
+  );
+
+  return oracles[0][0];
+}
+
+export function getPythPushOracleAddress(
+  feedId: PublicKey,
+  shardId: number,
+  programId: PublicKey = PYTH_PUSH_PROGRAM
+): PublicKey {
+  const shardBytes = u16ToArrayBufferLE(shardId);
+  return PublicKey.findProgramAddressSync(
+    [shardBytes, feedId.toBuffer()],
+    programId
+  )[0];
+}

package/src/utils/solautoUtils.ts

@@ -453,7 +453,7 @@ export function getClient(
 export function isMarginfiClient(
   client: SolautoClient
 ): client is SolautoMarginfiClient {
-  return client.lendingPlatform == LendingPlatform.Marginfi;
+  return client.lendingPlatform === LendingPlatform.Marginfi;
 }
 // TODO: PF
 

package/tests/transactions/shared.ts

@@ -18,6 +18,12 @@ import {
   TransactionItem,
   TransactionsManager,
   USDC,
+  deposit,
+  openSolautoPosition,
+  borrow,
+  rebalance,
+  withdraw,
+  closeSolautoPosition,
 } from "../../src";
 
 export async function e2eTransactionTest(
@@ -51,77 +57,27 @@ export async function e2eTransactionTest(
     repayGap: 50,
   };
 
-  const transactionItems: TransactionItem[] = [];
-
-  transactionItems.push(
-    new TransactionItem(async () => {
-      return {
-        tx: client.openPositionIx(settings),
-      };
-    }, "open position")
-  );
-
+  const supplyUsd = 100;
+  const debtUsd = withFlashLoan ? 60 : 10;
   const [supplyPrice, debtPrice] = await fetchTokenPrices([
     supplyMint,
     debtMint,
   ]);
 
-  const supplyUsd = 100;
-  transactionItems.push(
-    new TransactionItem(async () => {
-      return {
-        tx: client.protocolInteractionIx(
-          solautoAction("Deposit", [
-            toBaseUnit(
-              supplyUsd / supplyPrice,
-              client.pos.supplyMintInfo().decimals
-            ),
-          ])
-        ),
-      };
-    }, "deposit")
-  );
-
-  const debtUsd = withFlashLoan ? 60 : 10;
-  transactionItems.push(
-    new TransactionItem(async () => {
-      return {
-        tx: client.protocolInteractionIx(
-          solautoAction("Borrow", [
-            toBaseUnit(debtUsd / debtPrice, client.pos.debtMintInfo().decimals),
-          ])
-        ),
-      };
-    }, "borrow")
-  );
-
-  transactionItems.push(
-    new TransactionItem(
-      async (attemptNum) =>
-        await new RebalanceTxBuilder(client, 0).buildRebalanceTx(attemptNum),
-      "rebalance"
-    )
-  );
-
-  transactionItems.push(
-    new TransactionItem(
-      async () => ({
-        tx: client.protocolInteractionIx(
-          solautoAction("Withdraw", [{ __kind: "All" }])
-        ),
-      }),
-      "withdraw"
-    )
-  );
-
-  transactionItems.push(
-    new TransactionItem(
-      async () => ({
-        tx: client.closePositionIx(),
-      }),
-      "close position"
-    )
-  );
+  const transactionItems = [
+    openSolautoPosition(client, settings),
+    deposit(
+      client,
+      toBaseUnit(supplyUsd / supplyPrice, client.pos.supplyMintInfo().decimals)
+    ),
+    borrow(
+      client,
+      toBaseUnit(debtUsd / debtPrice, client.pos.debtMintInfo().decimals)
+    ),
+    rebalance(client, 0),
+    withdraw(client, "All"),
+    closeSolautoPosition(client),
+  ];
 
   const txManager = new TransactionsManager(client, undefined, "only-simulate");
   const statuses = await txManager.clientSend(transactionItems);

package/tests/unit/accounts.ts

@@ -6,21 +6,17 @@ import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
 import {
   ALL_SUPPORTED_TOKENS,
   TOKEN_INFO,
-  MARGINFI_ACCOUNTS,
   SOLAUTO_FEES_WALLET,
   SOLAUTO_MANAGER,
   LOCAL_IRONFORGE_API_URL,
-} from "../../src/constants";
-import {
+  getMarginfiAccounts,
   getSolanaRpcConnection,
   getEmptyMarginfiAccountsByAuthority,
   getTokenAccount,
-} from "../../src/utils";
+} from "../../src";
 
 async function hasTokenAccounts(wallet: PublicKey) {
-  let [_, umi] = getSolanaRpcConnection(
-    LOCAL_IRONFORGE_API_URL
-  );
+  let [_, umi] = getSolanaRpcConnection(LOCAL_IRONFORGE_API_URL);
 
   const tokenAccounts = await umi.rpc.getAccounts(
     ALL_SUPPORTED_TOKENS.map((x) =>
@@ -45,17 +41,15 @@ describe("Assert Solauto fee token accounts are created", async () => {
   });
 
   it("ISM accounts for every supported Marginfi group", async () => {
-    let [_, umi] = getSolanaRpcConnection(
-      LOCAL_IRONFORGE_API_URL
-    );
+    let [_, umi] = getSolanaRpcConnection(LOCAL_IRONFORGE_API_URL);
 
     const ismAccounts = await getEmptyMarginfiAccountsByAuthority(
       umi,
       SOLAUTO_MANAGER
     );
-    const supportedMarginfiGroups = Object.keys(MARGINFI_ACCOUNTS).map(
-      (x) => new PublicKey(x)
-    );
+    const supportedMarginfiGroups = Object.keys(
+      getMarginfiAccounts("Prod").bankAccounts
+    ).map((x) => new PublicKey(x));
     const missingIsmAccounts = supportedMarginfiGroups.filter(
       (group) =>
         !ismAccounts.find((x) => group.equals(toWeb3JsPublicKey(x.group)))

package/tests/unit/lookupTables.ts

@@ -1,64 +1,43 @@
 import { describe, it } from "mocha";
-import { PublicKey } from "@solana/web3.js";
 import {
+  getMarginfiAccounts,
   LOCAL_IRONFORGE_API_URL,
-  MARGINFI_ACCOUNTS,
-  MARGINFI_ACCOUNTS_LOOKUP_TABLE,
   SOLAUTO_MANAGER,
-} from "../../src/constants";
-import {
+  getAllBankRelatedAccounts,
   getEmptyMarginfiAccountsByAuthority,
   getSolanaRpcConnection,
-} from "../../src/utils";
+  ProgramEnv,
+} from "../../src";
 
-const [conn, umi] = getSolanaRpcConnection(
-  LOCAL_IRONFORGE_API_URL
-);
+const [conn, umi] = getSolanaRpcConnection(LOCAL_IRONFORGE_API_URL);
 
-describe("Assert lookup tables up-to-date", async () => {
-  it("marginfi accounts LUT should have everything", async () => {
-    const lookupTable = await conn.getAddressLookupTable(
-      new PublicKey(MARGINFI_ACCOUNTS_LOOKUP_TABLE)
-    );
-    if (lookupTable === null) {
-      throw new Error("Lookup table not found");
-    }
+async function checkLookupTableAccounts(programEnv: ProgramEnv) {
+  const data = getMarginfiAccounts(programEnv);
+  const lookupTable = await conn.getAddressLookupTable(data.lookupTable);
+  if (lookupTable === null) {
+    throw new Error("Lookup table not found");
+  }
 
-    const ismAccounts = await getEmptyMarginfiAccountsByAuthority(
-      umi,
-      SOLAUTO_MANAGER
-    );
+  const ismAccounts = (
+    await getEmptyMarginfiAccountsByAuthority(umi, SOLAUTO_MANAGER)
+  ).map((x) => x.publicKey.toString());
 
-    const existingAccounts =
-      lookupTable.value?.state.addresses.map((x) => x.toString()) ?? [];
+  const bankAccounts = (
+    await getAllBankRelatedAccounts(umi, data.bankAccounts)
+  ).map((x) => x.toString());
 
-    for (const group in MARGINFI_ACCOUNTS) {
-      for (const key in MARGINFI_ACCOUNTS[group]) {
-        if (key === PublicKey.default.toString()) {
-          continue;
-        }
+  const accountsRequired = [...ismAccounts, ...bankAccounts];
 
-        const groupIsmAccounts = ismAccounts
-          .filter((x) => x.group.toString() === group)
-          .map((x) => x.publicKey.toString());
-        if (groupIsmAccounts.length === 0) {
-          throw new Error(`Missing ISM account for group: ${group}`);
-        }
+  const existingAccounts =
+    lookupTable.value?.state.addresses.map((x) => x.toString()) ?? [];
 
-        const accounts = MARGINFI_ACCOUNTS[group][key];
-        const addresses = [
-          group,
-          accounts.bank,
-          accounts.liquidityVault,
-          accounts.vaultAuthority,
-          accounts.priceOracle,
-          ...groupIsmAccounts,
-        ];
+  if (accountsRequired.find((x) => !existingAccounts.includes(x.toString()))) {
+    throw new Error("Marginfi accounts lookup table missing an account");
+  }
+}
 
-        if (addresses.find((x) => !existingAccounts.includes(x.toString()))) {
-          throw new Error("Marginfi accounts lookup table missing an account");
-        }
-      }
-    }
+describe("Assert lookup tables up-to-date", async () => {
+  it("marginfi accounts LUT should have everything", async () => {
+    await checkLookupTableAccounts("Prod");
   });
 });