@haven-fi/solauto-sdk 1.0.835 → 1.0.837

package/tests/unit/marginfiOracles.ts

@@ -0,0 +1,333 @@
+import { assert } from "chai";
+import {
+  publicKey,
+  RpcAccount,
+  Umi,
+  createNoopSigner,
+} from "@metaplex-foundation/umi";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { PublicKey } from "@solana/web3.js";
+import {
+  composeRemainingAccounts,
+  getMarginfiBankHealthAccounts,
+  getMarginfiBankPrice,
+  getPythLstPriceData,
+  safeGetMarginfiBankPrice,
+  addSwbOraclePullTxs,
+  getMarginfiSwitchboardFeeds,
+  LendingPlatform,
+  PriceType,
+  PRICES,
+  SWITCHBOARD_PRICE_FEED_IDS,
+  SolautoMarginfiClient,
+  getMarginfiAccounts,
+  getAccountMeta,
+  RebalanceStep,
+  RebalanceDirection,
+  SolautoRebalanceType,
+} from "../../src";
+import {
+  deserializeBank,
+  OracleSetup,
+  PriceBias,
+} from "../../src/externalSdks/marginfi";
+import fixtures from "../fixtures/marginfiOracles.json";
+
+function account(value: {
+  publicKey: string;
+  owner: string;
+  data: string;
+}): RpcAccount {
+  return {
+    ...value,
+    publicKey: publicKey(value.publicKey),
+    owner: publicKey(value.owner),
+    data: Buffer.from(value.data, "base64"),
+    exists: true,
+  } as RpcAccount;
+}
+
+const bank = (ticker: string) =>
+  deserializeBank(account(fixtures.banks.find((b) => b.ticker === ticker)!));
+const oracle = (address: string) =>
+  account(fixtures.oracles.find((o) => o.publicKey === address)!);
+const clock = () => account(fixtures.oracles[4]);
+const noRpc = {} as Umi;
+
+describe("Marginfi oracle migration", () => {
+  it("decodes the migrated mainnet banks without changing discriminator values", () => {
+    for (const ticker of ["LST", "hSOL", "JupSOL"]) {
+      assert.equal(bank(ticker).config.oracleSetup, OracleSetup.PythLST);
+    }
+    for (const ticker of ["SOL", "JitoSOL", "JTO"]) {
+      assert.equal(bank(ticker).config.oracleSetup, OracleSetup.PythPushOracle);
+    }
+    assert.equal(OracleSetup.PythLST, 22);
+    assert.equal(bank("USDC").config.oracleSetup, OracleSetup.Fixed);
+  });
+
+  it("does not crank the six banks that migrated away from Switchboard", async () => {
+    const banks = fixtures.banks
+      .filter((b) => b.env === "Prod")
+      .map((b) => bank(b.ticker));
+    assert.deepEqual(getMarginfiSwitchboardFeeds(banks), {});
+    for (const b of banks)
+      assert.isUndefined(SWITCHBOARD_PRICE_FEED_IDS[b.mint]);
+    let calls = 0;
+    const client: any = {
+      lendingPlatform: LendingPlatform.Marginfi,
+      pos: {
+        supplyMint: new PublicKey(banks[0].mint),
+        debtMint: new PublicKey(banks[3].mint),
+        lpSupplyAccount: new PublicKey(banks[0].publicKey),
+        lpDebtAccount: new PublicKey(banks[3].publicKey),
+      },
+      umi: {
+        rpc: {
+          getAccounts: async (keys: string[]) => {
+            calls++;
+            return keys.map((key) =>
+              account(fixtures.banks.find((b) => b.publicKey === key)!)
+            );
+          },
+        },
+      },
+      connection: {
+        getSlot: () => {
+          throw new Error("Should not read a Switchboard feed");
+        },
+      },
+    };
+    const txs: any[] = [{ oracleInteractor: true }];
+    await addSwbOraclePullTxs(client, txs);
+    assert.equal(calls, 1);
+    assert.lengthOf(txs, 1);
+  });
+
+  it("uses the bank's configured Switchboard address even for an unmapped mint", () => {
+    const b = bank("SOL");
+    b.config.oracleSetup = OracleSetup.SwitchboardPull;
+    b.config.oracleKeys[0] = publicKey(
+      "4Hmd6PdjVA9auCoScE12iaBogfwS4ZXQ6VZoBeqanwWW"
+    );
+    assert.deepEqual(getMarginfiSwitchboardFeeds([b]), {
+      [b.mint]: b.config.oracleKeys[0],
+    });
+  });
+
+  it("keeps stake pools with their banks when sorting mixed health-account groups", async () => {
+    const lst = bank("LST");
+    const sol = bank("SOL");
+    const lstGroup = await getMarginfiBankHealthAccounts(noRpc, lst);
+    const solGroup = await getMarginfiBankHealthAccounts(
+      noRpc,
+      sol,
+      new PublicKey(sol.config.oracleKeys[0])
+    );
+    assert.deepEqual(
+      lstGroup.map((a) => a.pubkey),
+      [lst.publicKey, ...lst.config.oracleKeys.slice(0, 2)]
+    );
+    assert.deepEqual(
+      composeRemainingAccounts([...solGroup, ...lstGroup]).map((a) => a.pubkey),
+      [...lstGroup, ...solGroup].map((a) => a.pubkey)
+    );
+    // Repeated base oracles must appear in each bank group, including two LSTs.
+    const hsol = await getMarginfiBankHealthAccounts(noRpc, bank("hSOL"));
+    const mixed = composeRemainingAccounts([...lstGroup, ...hsol, ...solGroup]);
+    assert.lengthOf(mixed, 8);
+    assert.equal(
+      mixed.filter((a) => a.pubkey === lst.config.oracleKeys[0]).length,
+      3
+    );
+  });
+
+  it("prices SPL and both Sanctum stake-pool variants from the Pyth base feed", () => {
+    const expected = {
+      LST: 152.58419233,
+      hSOL: 117.37554225,
+      JupSOL: 119.63081594,
+    };
+    for (const [ticker, price] of Object.entries(expected)) {
+      const b = bank(ticker);
+      const prices = getPythLstPriceData(
+        b,
+        oracle(b.config.oracleKeys[0]),
+        oracle(b.config.oracleKeys[1]),
+        clock()
+      );
+      assert.closeTo(prices.realtimePrice, price, 1e-8);
+      assert.isAbove(prices.emaPrice, prices.realtimePrice);
+    }
+  });
+
+  it("includes the stake pool in Solauto refresh, interaction, rebalance and direct borrow instructions", async () => {
+    const supply = bank("LST");
+    const debt = bank("SOL");
+    const key = new PublicKey(supply.publicKey);
+    const pool = getAccountMeta(new PublicKey(supply.config.oracleKeys[1]));
+    const client: any = Object.assign(
+      Object.create(SolautoMarginfiClient.prototype),
+      {
+        umi: createUmi("https://example.invalid"),
+        signer: createNoopSigner(publicKey(key)),
+        mfiAccounts: getMarginfiAccounts("Prod"),
+        marginfiGroup: new PublicKey(supply.group),
+        marginfiAccount: key,
+        marginfiAccountPk: key,
+        marginfiSupplyAccounts:
+          getMarginfiAccounts("Prod").bankAccounts[supply.group][supply.mint],
+        marginfiDebtAccounts:
+          getMarginfiAccounts("Prod").bankAccounts[debt.group][debt.mint],
+        supplyPriceOracle: new PublicKey(supply.config.oracleKeys[0]),
+        debtPriceOracle: new PublicKey(debt.config.oracleKeys[0]),
+        auxiliaryOracleAccounts: [pool],
+        pos: {
+          publicKey: key,
+          selfManaged: false,
+          supplyMint: new PublicKey(supply.mint),
+          debtMint: new PublicKey(debt.mint),
+        },
+        positionSupplyTa: key,
+        positionDebtTa: key,
+        signerSupplyTa: key,
+        signerDebtTa: key,
+        solautoFeesSupplyTa: key,
+        solautoFeesDebtTa: key,
+        referralState: key,
+        authority: key,
+        healthCheckRemainingAccounts: await getMarginfiBankHealthAccounts(
+          noRpc,
+          supply
+        ),
+        debtBankHealthAccounts: await getMarginfiBankHealthAccounts(
+          noRpc,
+          debt,
+          new PublicKey(debt.config.oracleKeys[0])
+        ),
+      }
+    );
+    const instructions = [
+      client.refreshIx(),
+      client.marginfiSolautoProtocolInteractionIx({
+        __kind: "Borrow",
+        fields: [1n],
+      }),
+      client.rebalanceIx(RebalanceStep.PreSwap, {
+        rebalanceType: SolautoRebalanceType.Regular,
+        priceType: PriceType.Realtime,
+        values: { rebalanceDirection: RebalanceDirection.Boost },
+        swapQuote: {
+          inputMint: supply.mint,
+          inAmount: "1",
+          swapMode: "ExactIn",
+        },
+      }),
+    ];
+    for (const tx of instructions) {
+      const keys = tx.getInstructions()[0].keys;
+      assert.equal(keys[keys.length - 1].pubkey, pool.pubkey);
+      assert.isFalse(keys[keys.length - 1].isWritable);
+    }
+    client.pos.selfManaged = true;
+    const borrow = client
+      .marginfiProtocolInteractionIx({ __kind: "Borrow", fields: [1n] })
+      .getInstructions()[0];
+    assert.deepEqual(
+      borrow.keys.slice(-5).map((a: any) => a.pubkey),
+      [
+        supply.publicKey,
+        supply.config.oracleKeys[0],
+        pool.pubkey,
+        debt.publicKey,
+        debt.config.oracleKeys[0],
+      ]
+    );
+  });
+
+  it("preserves exchange-rate-adjusted EMA and confidence independently of generic prices", async () => {
+    const b = bank("LST");
+    const umi = {
+      rpc: { getAccounts: async (keys: string[]) => keys.map(oracle) },
+    } as unknown as Umi;
+    assert.closeTo(
+      await getMarginfiBankPrice(umi, b, PriceType.Ema, PriceBias.Low),
+      152.8792992004,
+      1e-8
+    );
+    PRICES[b.mint] = {
+      realtimePrice: 1,
+      emaPrice: 1,
+      confInterval: 0,
+      emaConfInterval: 0,
+      time: 0,
+    };
+    assert.closeTo(
+      safeGetMarginfiBankPrice(b, PriceType.Realtime, PriceBias.High)!,
+      152.6201380112,
+      1e-8
+    );
+    delete PRICES[b.mint];
+  });
+
+  it("reads the staging fixed price from the bank without fetching an oracle", async () => {
+    assert.closeTo(await getMarginfiBankPrice(noRpc, bank("USDC")), 1, 1e-8);
+  });
+
+  it("rejects incorrect, malformed, stale, or unverified pricing accounts", () => {
+    const b = bank("LST");
+    const mutations: Array<
+      (o: RpcAccount, p: RpcAccount, c: RpcAccount) => void
+    > = [
+      (_, p) => {
+        p.owner = publicKey(PublicKey.default);
+      },
+      (_, p) => {
+        p.publicKey = publicKey(PublicKey.default);
+      },
+      (_, p) => {
+        p.data = p.data.slice(0, 281);
+      },
+      (_, p) => {
+        p.data[0] = 0;
+      },
+      (_, p) => {
+        p.data[162] ^= 1;
+      },
+      (_, p) => {
+        (p.data as Buffer).writeBigUInt64LE(0n, 266);
+      },
+      (_, p) => {
+        (p.data as Buffer).writeBigUInt64LE(1n, 266);
+      },
+      (_, p) => {
+        (p.data as Buffer).writeBigUInt64LE(0n, 274);
+      },
+      (o) => {
+        o.owner = publicKey(PublicKey.default);
+      },
+      (o) => {
+        o.publicKey = publicKey(PublicKey.default);
+      },
+      (o) => {
+        o.data[0] ^= 1;
+      },
+      (o) => {
+        o.data[40] = 0;
+      },
+      (o) => {
+        (o.data as Buffer).writeBigInt64LE(0n, 93);
+      },
+      (_, __, c) => {
+        c.publicKey = publicKey(PublicKey.default);
+      },
+    ];
+    for (const mutate of mutations) {
+      const o = oracle(b.config.oracleKeys[0]);
+      const p = oracle(b.config.oracleKeys[1]);
+      const c = clock();
+      mutate(o, p, c);
+      assert.throws(() => getPythLstPriceData(b, o, p, c));
+    }
+  });
+});

package/tests/unit/transactionsManager.ts

@@ -1,6 +1,6 @@
 import { expect } from "chai";
 import { describe, it } from "mocha";
-import { TransactionsManager } from "../../src";
+import { TransactionsManager, UPDATE_ORACLE_TX_NAME } from "../../src";
 
 function createManager(abortController?: AbortController) {
   return new TransactionsManager({
@@ -14,6 +14,49 @@ function createManager(abortController?: AbortController) {
 }
 
 describe("TransactionsManager bundle fallback", () => {
+  it("sends a standalone oracle update when later transactions are pending", async () => {
+    const manager = createManager();
+    const sent: string[] = [];
+    const oracleTx = { getInstructions: () => [{}] };
+    const oracleSet = {
+      items: [{ name: UPDATE_ORACLE_TX_NAME }],
+      name: () => UPDATE_ORACLE_TX_NAME,
+      getSingleTransaction: async () => oracleTx,
+    };
+    const rebalanceSet = {
+      items: [{ name: "rebalance" }],
+      name: () => "rebalance",
+    };
+
+    manager.debugAccounts = async () => {};
+    manager.sendTransaction = async (_tx: unknown, name: string) => {
+      sent.push(name);
+    };
+
+    await manager.processTransactionSet([oracleSet, rebalanceSet], 0);
+
+    expect(sent).to.deep.equal([UPDATE_ORACLE_TX_NAME]);
+  });
+
+  it("still skips an oracle update when it is the only remaining transaction", async () => {
+    const manager = createManager();
+    let sends = 0;
+    const oracleSet = {
+      items: [{ name: UPDATE_ORACLE_TX_NAME }],
+      name: () => UPDATE_ORACLE_TX_NAME,
+      getSingleTransaction: async () => ({ getInstructions: () => [{}] }),
+    };
+
+    manager.debugAccounts = async () => {};
+    manager.sendTransaction = async () => {
+      sends++;
+    };
+
+    await manager.processTransactionSet([oracleSet], 0);
+
+    expect(sends).to.equal(0);
+  });
+
   it("retries a failed multi-transaction bundle sequentially", async () => {
     const manager = createManager();
     const calls: string[] = [];