@haven-fi/solauto-sdk 1.0.625 → 1.0.627

package/src/solautoPosition/marginfiSolautoPositionEx.ts

@@ -13,11 +13,15 @@ import {
   fromBaseUnit,
   getBankLiquidityAvailableBaseUnit,
   getMarginfiAccountPositionState,
+  getMarginfiPriceOracle,
 } from "../utils";
-import { DEFAULT_MARGINFI_GROUP, MARGINFI_ACCOUNTS } from "../constants";
+import { getMarginfiAccounts } from "../constants";
 import { SolautoPositionEx } from "./solautoPositionEx";
+import { LendingPlatform } from "../generated";
 
 export class MarginfiSolautoPositionEx extends SolautoPositionEx {
+  lendingPlatform = LendingPlatform.Marginfi;
+
   private marginfiAccountData: MarginfiAccount | null = null;
   private supplyBank: Bank | null = null;
   private debtBank: Bank | null = null;
@@ -41,19 +45,18 @@ export class MarginfiSolautoPositionEx extends SolautoPositionEx {
     }
 
     if (!this.lp) {
-      this.lp = new PublicKey(DEFAULT_MARGINFI_GROUP);
+      this.lp = getMarginfiAccounts(this.lpEnv).defaultGroup;
     }
 
     return this.lp;
   }
 
-  async maxLtvAndLiqThresholdBps(): Promise<[number, number]> {
+  async getBanks(): Promise<Bank[]> {
     if (!this.supplyBank || !this.debtBank) {
       const group = (await this.lendingPool()).toString();
-      const supplyBank =
-        MARGINFI_ACCOUNTS[group][this.supplyMint().toString()].bank;
-      const debtBank =
-        MARGINFI_ACCOUNTS[group][this.debtMint().toString()].bank;
+      const bankAccounts = getMarginfiAccounts(this.lpEnv).bankAccounts;
+      const supplyBank = bankAccounts[group][this.supplyMint().toString()].bank;
+      const debtBank = bankAccounts[group][this.debtMint().toString()].bank;
 
       [this.supplyBank, this.debtBank] = await safeFetchAllBank(this.umi, [
         publicKey(supplyBank),
@@ -61,10 +64,25 @@ export class MarginfiSolautoPositionEx extends SolautoPositionEx {
       ]);
     }
 
+    return [this.supplyBank!, this.debtBank!];
+  }
+
+  async priceOracles(): Promise<PublicKey[]> {
+    const [supplyBank, debtBank] = await this.getBanks();
+
+    return await Promise.all([
+      getMarginfiPriceOracle(this.umi, { data: supplyBank }),
+      getMarginfiPriceOracle(this.umi, { data: debtBank }),
+    ]);
+  }
+
+  async maxLtvAndLiqThresholdBps(): Promise<[number, number]> {
+    const [supplyBank, debtBank] = await this.getBanks();
+
     const [supplyPrice] = await fetchTokenPrices([this.supplyMint()]);
     const [maxLtvBps, liqThresholdBps] = calcMarginfiMaxLtvAndLiqThresholdBps(
-      this.supplyBank,
-      this.debtBank,
+      supplyBank,
+      debtBank,
       supplyPrice
     );
 
@@ -94,6 +112,7 @@ export class MarginfiSolautoPositionEx extends SolautoPositionEx {
       useDesignatedMint
         ? { mint: toWeb3JsPublicKey(this.state().debt.mint) }
         : undefined,
+      this.lpEnv,
       this.contextUpdates
     );
 

package/src/solautoPosition/solautoPositionEx.ts

@@ -37,7 +37,7 @@ import {
   tokenInfo,
   toRoundedUsdValue,
 } from "../utils";
-import { RebalanceAction } from "../types";
+import { ProgramEnv, RebalanceAction } from "../types";
 import {
   getDebtAdjustment,
   getRebalanceValues,
@@ -51,6 +51,7 @@ export interface PositionCustomArgs {
   debtMint?: PublicKey;
   lendingPool?: PublicKey;
   lpUserAccount?: PublicKey;
+  lpEnv?: ProgramEnv;
 }
 
 interface SolautoPositionExData extends Partial<SolautoPosition> {
@@ -66,10 +67,12 @@ interface PositionExArgs {
 }
 
 export abstract class SolautoPositionEx {
+  public lendingPlatform!: LendingPlatform;
   public umi!: Umi;
   public publicKey!: PublicKey;
   protected _data!: SolautoPositionExData;
   protected lp?: PublicKey = undefined;
+  protected lpEnv!: ProgramEnv;
   public lpUserAccount?: PublicKey = undefined;
   protected contextUpdates?: ContextUpdates;
 
@@ -86,6 +89,7 @@ export abstract class SolautoPositionEx {
       (args.data.position
         ? toWeb3JsPublicKey(args.data.position!.protocolUserAccount)
         : undefined);
+    this.lpEnv = args.customArgs?.lpEnv ?? "Prod";
 
     this._data = args.data;
     this.firstState = { ...args.data.state };
@@ -183,7 +187,10 @@ export abstract class SolautoPositionEx {
   }
 
   supplyUsd() {
-    return calcSupplyUsd(this.state());
+    const supplyPrice = safeGetPrice(this.supplyMint());
+    return supplyPrice
+      ? calcTotalSupply(this.state()) * supplyPrice
+      : calcSupplyUsd(this.state());
   }
 
   totalDebt() {
@@ -191,7 +198,10 @@ export abstract class SolautoPositionEx {
   }
 
   debtUsd() {
-    return calcDebtUsd(this.state());
+    const debtPrice = safeGetPrice(this.debtMint());
+    return debtPrice
+      ? calcTotalDebt(this.state()) * debtPrice
+      : calcDebtUsd(this.state());
   }
 
   supplyLiquidityDepositable() {
@@ -203,7 +213,9 @@ export abstract class SolautoPositionEx {
   }
 
   supplyLiquidityUsdAvailable() {
-    return this.supplyLiquidityAvailable() * (safeGetPrice(this.supplyMint()) ?? 0);
+    return (
+      this.supplyLiquidityAvailable() * (safeGetPrice(this.supplyMint()) ?? 0)
+    );
   }
 
   debtLiquidityAvailable() {
@@ -215,6 +227,7 @@ export abstract class SolautoPositionEx {
   }
 
   abstract maxLtvAndLiqThresholdBps(): Promise<[number, number]>;
+  abstract priceOracles(): Promise<PublicKey[]>;
   abstract supplyLiquidityAvailable(): number;
 
   sufficientLiquidityToBoost() {
@@ -244,7 +257,7 @@ export abstract class SolautoPositionEx {
   }
 
   eligibleForRebalance(bpsDistanceThreshold = 0): RebalanceAction | undefined {
-    if (!this.settings() || !calcSupplyUsd(this.state())) {
+    if (!this.settings() || !this.supplyUsd()) {
       return undefined;
     }
 

package/src/solautoPosition/utils.ts

@@ -41,7 +41,7 @@ export async function getPositionExBulk(
   umi: Umi,
   publicKeys: PublicKey[]
 ): Promise<SolautoPositionEx[]> {
-  const batches = getBatches(publicKeys, 30);
+  const batches = getBatches(publicKeys, 50);
 
   const data = (
     await Promise.all(

package/src/types/accounts.ts

@@ -2,5 +2,4 @@ export interface MarginfiAssetAccounts {
   bank: string;
   liquidityVault: string;
   vaultAuthority: string;
-  priceOracle: string;
 }

package/src/utils/generalUtils.ts

@@ -184,3 +184,15 @@ export async function customRpcCall(umi: Umi, method: string, params?: any) {
     return data;
   }
 }
+
+export function u16ToArrayBufferLE(value: number): Uint8Array {
+  // Create a buffer of 2 bytes
+  const buffer = new ArrayBuffer(2);
+  const dataView = new DataView(buffer);
+
+  // Set the Uint16 value in little-endian order
+  dataView.setUint16(0, value, true);
+
+  // Return the buffer
+  return new Uint8Array(buffer);
+}

package/src/utils/index.ts

@@ -8,4 +8,5 @@ export * from "./solautoUtils";
 export * from "./solanaUtils";
 export * from "./stringUtils";
 export * from "./priceUtils";
+export * from "./pythUtils";
 export * from "./switchboardUtils";

package/src/utils/marginfiUtils.ts

@@ -1,25 +1,30 @@
 import { PublicKey } from "@solana/web3.js";
 import { Program, publicKey, Umi } from "@metaplex-foundation/umi";
-import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  fromWeb3JsPublicKey,
+  toWeb3JsPublicKey,
+} from "@metaplex-foundation/umi-web3js-adapters";
 import { ProgramEnv, MarginfiAssetAccounts } from "../types";
 import { PositionState, PositionTokenState } from "../generated";
 import {
-  DEFAULT_MARGINFI_GROUP,
-  MARGINFI_ACCOUNTS,
   ALL_SUPPORTED_TOKENS,
-  MARGINFI_PROD_PROGRAM,
-  MARGINFI_STAGING_PROGRAM,
+  getMarginfiAccounts,
+  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";
@@ -34,22 +39,16 @@ import {
   toBaseUnit,
   toBps,
 } from "./numberUtils";
-
-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 { getTokenAccountData } from "./accountUtils";
+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);
     },
@@ -73,6 +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 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;
 }
@@ -80,16 +154,29 @@ interface AllMarginfiAssetAccounts extends MarginfiAssetAccounts {
 export function findMarginfiAccounts(
   bank: PublicKey
 ): AllMarginfiAssetAccounts {
-  for (const group in MARGINFI_ACCOUNTS) {
-    for (const key in MARGINFI_ACCOUNTS[group]) {
-      const account = MARGINFI_ACCOUNTS[group][key];
-      if (
-        account.bank.toString().toLowerCase() === bank.toString().toLowerCase()
-      ) {
-        return { ...account, mint: new PublicKey(key) };
+  const search = (bankAccounts: MarginfiBankAccountsMap) => {
+    for (const group in bankAccounts) {
+      for (const key in bankAccounts[group]) {
+        const account = bankAccounts[group][key];
+        if (
+          account.bank.toString().toLowerCase() ===
+          bank.toString().toLowerCase()
+        ) {
+          return { ...account, mint: new PublicKey(key) };
+        }
       }
     }
+  };
+
+  let res = search(getMarginfiAccounts("Prod").bankAccounts);
+  if (res) {
+    return res;
+  }
+  res = search(getMarginfiAccounts("Staging").bankAccounts);
+  if (res) {
+    return res;
   }
+
   throw new Error(`Marginfi accounts not found by the bank: ${bank}`);
 }
 
@@ -145,11 +232,16 @@ export async function getMarginfiMaxLtvAndLiqThresholdBps(
     return [0, 0];
   }
 
+  const bankAccounts = getMarginfiAccounts(
+    undefined,
+    marginfiGroup
+  ).bankAccounts;
+
   if (!supply.bank || supply.bank === null) {
     supply.bank = await safeFetchBank(
       umi,
       publicKey(
-        MARGINFI_ACCOUNTS[marginfiGroup.toString()][supply.mint.toString()].bank
+        bankAccounts[marginfiGroup.toString()][supply.mint.toString()].bank
       ),
       { commitment: "confirmed" }
     );
@@ -162,7 +254,7 @@ export async function getMarginfiMaxLtvAndLiqThresholdBps(
     debt.bank = await safeFetchBank(
       umi,
       publicKey(
-        MARGINFI_ACCOUNTS[marginfiGroup.toString()][debt.mint.toString()].bank
+        bankAccounts[marginfiGroup.toString()][debt.mint.toString()].bank
       ),
       { commitment: "confirmed" }
     );
@@ -381,9 +473,9 @@ async function getBank(
       ? await safeFetchBank(
           umi,
           publicKey(
-            MARGINFI_ACCOUNTS[marginfiGroup?.toString() ?? ""][
-              data?.mint.toString()
-            ].bank
+            getMarginfiAccounts(undefined, marginfiGroup).bankAccounts[
+              marginfiGroup?.toString() ?? ""
+            ][data?.mint.toString()].bank
           ),
           { commitment: "confirmed" }
         )
@@ -396,6 +488,7 @@ export async function getMarginfiAccountPositionState(
   marginfiGroup?: PublicKey,
   supply?: BankSelection,
   debt?: BankSelection,
+  programEnv?: ProgramEnv,
   contextUpdates?: ContextUpdates
 ): Promise<
   | { supplyBank: Bank | null; debtBank: Bank | null; state: PositionState }
@@ -523,7 +616,7 @@ export async function getMarginfiAccountPositionState(
   const supplyPrice = safeGetPrice(supply.mint!)!;
   let [maxLtvBps, liqThresholdBps] = await getMarginfiMaxLtvAndLiqThresholdBps(
     umi,
-    marginfiGroup ?? new PublicKey(DEFAULT_MARGINFI_GROUP),
+    marginfiGroup ?? getMarginfiAccounts(programEnv).defaultGroup,
     {
       mint: toWeb3JsPublicKey(supplyBank.mint),
       bank: supplyBank,

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/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");
   });
 });