@haven-fi/solauto-sdk 1.0.626 → 1.0.627

package/src/constants/pythConstants.ts

@@ -1,5 +1,13 @@
 import { NATIVE_MINT } from "@solana/spl-token";
 import * as tokens from "./tokenConstants";
+import { PublicKey } from "@solana/web3.js";
+
+export const PYTH_PUSH_PROGRAM = new PublicKey(
+  "pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT"
+);
+
+export const PYTH_SPONSORED_SHARD_ID = 0;
+export const MARGINFI_SPONSORED_SHARD_ID = 3301;
 
 // https://pyth.network/developers/price-feed-ids#solana-stable
 export const PYTH_PRICE_FEED_IDS = {

package/src/services/flashLoans/marginfiFlProvider.ts

@@ -29,6 +29,7 @@ import {
   fromBaseUnit,
   getBankLiquidityAvailableBaseUnit,
   getEmptyMarginfiAccountsByAuthority,
+  getMarginfiPriceOracle,
   getTokenAccount,
   rpcAccountCreated,
   safeGetPrice,
@@ -72,15 +73,15 @@ export class MarginfiFlProvider extends FlProviderBase {
     const bankAccounts = getMarginfiAccounts(this.programEnv).bankAccounts;
 
     const availableBanks: string[] = [];
-    const checkIfUsable = (group: string, mint: PublicKey) => {
-      if (Object.keys(bankAccounts[group]).includes(mint.toString())) {
-        availableBanks.push(bankAccounts[group][mint.toString()].bank);
+    const checkIfUsable = (group: string, mint: string) => {
+      if (Object.keys(bankAccounts[group]).includes(mint)) {
+        availableBanks.push(bankAccounts[group][mint].bank);
       }
     };
 
     for (const group of Object.keys(bankAccounts)) {
-      checkIfUsable(group, this.supplyMint);
-      checkIfUsable(group, this.debtMint);
+      checkIfUsable(group, this.supplyMint.toString());
+      checkIfUsable(group, this.debtMint.toString());
     }
 
     const banks = await safeFetchAllBank(
@@ -301,11 +302,10 @@ export class MarginfiFlProvider extends FlProviderBase {
             flBankHadPrevBalance = 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
+            await getMarginfiPriceOracle(this.umi, {
+              pk: toWeb3JsPublicKey(x.bankPk),
+            })
           );
 
           remainingAccounts.push(

package/src/services/solauto/solautoClient.ts

@@ -205,12 +205,8 @@ export abstract class SolautoClient extends ReferralStateManager {
     return [
       this.authority,
       ...(this.authorityLutAddress ? [this.authorityLutAddress] : []),
-      ...(toWeb3JsPublicKey(this.signer.publicKey).equals(this.authority)
-        ? [this.signerSupplyTa]
-        : []),
-      ...(toWeb3JsPublicKey(this.signer.publicKey).equals(this.authority)
-        ? [this.signerDebtTa]
-        : []),
+      this.signerSupplyTa,
+      this.signerDebtTa,
       this.pos.publicKey,
       this.positionSupplyTa,
       this.positionDebtTa,
@@ -239,6 +235,10 @@ export abstract class SolautoClient extends ReferralStateManager {
       }
     | undefined
   > {
+    if (!toWeb3JsPublicKey(this.signer.publicKey).equals(this.authority)) {
+      return undefined;
+    }
+
     const existingLutAccounts = await this.fetchExistingAuthorityLutAccounts();
     if (
       this.lutAccountsToAdd().every((element) =>

package/src/services/solauto/solautoMarginfiClient.ts

@@ -32,6 +32,7 @@ import {
   hasFirstRebalance,
 } from "../../utils";
 import {
+  Bank,
   lendingAccountBorrow,
   lendingAccountDeposit,
   lendingAccountRepay,
@@ -113,19 +114,12 @@ export class SolautoMarginfiClient extends SolautoClient {
         this.pos.debtMint().toString()
       ]!;
 
-    // TODO: Don't dynamically pull oracle from bank until Marginfi sorts out their price oracle issues.
-    // const [supplyBank, debtBank] = await safeFetchAllBank(this.umi, [
-    //   publicKey(this.marginfiSupplyAccounts.bank),
-    //   publicKey(this.marginfiDebtAccounts.bank),
-    // ]);
-    // this.supplyPriceOracle = toWeb3JsPublicKey(supplyBank.config.oracleKeys[0]);
-    // this.debtPriceOracle = toWeb3JsPublicKey(debtBank.config.oracleKeys[0]);
-    this.supplyPriceOracle = new PublicKey(
-      this.marginfiSupplyAccounts.priceOracle
-    );
-    this.debtPriceOracle = new PublicKey(this.marginfiDebtAccounts.priceOracle);
+    [this.supplyPriceOracle, this.debtPriceOracle] =
+      await this.pos.priceOracles();
 
     this.log("Marginfi account:", this.marginfiAccountPk.toString());
+    this.log("Supply price oracle:", this.supplyPriceOracle.toString());
+    this.log("Debt price oracle:", this.debtPriceOracle.toString());
   }
 
   defaultLookupTables(): string[] {

package/src/services/transactions/transactionUtils.ts

@@ -39,7 +39,6 @@ import {
   getTokenAccount,
   getTokenAccountData,
   isMarginfiClient,
-  isMarginfiProgram,
 } from "../../utils";
 import {
   createMarginfiProgram,
@@ -56,6 +55,7 @@ import {
   JUPITER_PROGRAM_ID,
 } from "../../jupiter-sdk";
 import { TransactionItemInputs, BundleSimulationError } from "../../types";
+import { isMarginfiProgram } from "../../constants";
 
 interface wSolTokenUsage {
   wSolTokenAccount: PublicKey;

package/src/solautoPosition/marginfiSolautoPositionEx.ts

@@ -13,11 +13,15 @@ import {
   fromBaseUnit,
   getBankLiquidityAvailableBaseUnit,
   getMarginfiAccountPositionState,
+  getMarginfiPriceOracle,
 } from "../utils";
 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;
@@ -47,7 +51,7 @@ export class MarginfiSolautoPositionEx extends SolautoPositionEx {
     return this.lp;
   }
 
-  async maxLtvAndLiqThresholdBps(): Promise<[number, number]> {
+  async getBanks(): Promise<Bank[]> {
     if (!this.supplyBank || !this.debtBank) {
       const group = (await this.lendingPool()).toString();
       const bankAccounts = getMarginfiAccounts(this.lpEnv).bankAccounts;
@@ -60,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
     );
 

package/src/solautoPosition/solautoPositionEx.ts

@@ -67,6 +67,7 @@ interface PositionExArgs {
 }
 
 export abstract class SolautoPositionEx {
+  public lendingPlatform!: LendingPlatform;
   public umi!: Umi;
   public publicKey!: PublicKey;
   protected _data!: SolautoPositionExData;
@@ -226,6 +227,7 @@ export abstract class SolautoPositionEx {
   }
 
   abstract maxLtvAndLiqThresholdBps(): Promise<[number, number]>;
+  abstract priceOracles(): Promise<PublicKey[]>;
   abstract supplyLiquidityAvailable(): number;
 
   sufficientLiquidityToBoost() {

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

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