@haven-fi/solauto-sdk 1.0.0

package/src/transactions/transactionsManager.ts

@@ -0,0 +1,344 @@
+import bs58 from "bs58";
+import {
+  AddressLookupTableInput,
+  transactionBuilder,
+  TransactionBuilder,
+} from "@metaplex-foundation/umi";
+import { SolautoClient } from "../clients/solautoClient";
+import {
+  getAdressLookupInputs,
+  sendSingleOptimizedTransaction,
+} from "../utils/solanaUtils";
+import { UMI } from "../constants/solautoConstants";
+import { retryWithExponentialBackoff } from "../utils/generalUtils";
+import { getTransactionChores } from "./transactionUtils";
+import { sendJitoBundledTransactions } from "../utils/jitoUtils";
+
+class LookupTables {
+  defaultLuts: string[] = [];
+  cache: AddressLookupTableInput[] = [];
+
+  constructor(private client: SolautoClient) {
+    this.defaultLuts = [
+      client.authorityLutAddress!.toString(),
+      ...client.defaultLookupTables(),
+    ];
+  }
+
+  async getLutInputs(
+    additionalAddresses: string[]
+  ): Promise<AddressLookupTableInput[]> {
+    const addresses = [...this.defaultLuts, ...additionalAddresses];
+    const currentCacheAddresses = this.cache.map((x) => x.publicKey.toString());
+
+    const missingAddresses = addresses.filter(
+      (x) => !currentCacheAddresses.includes(x)
+    );
+    if (missingAddresses) {
+      const additionalInputs = await getAdressLookupInputs(missingAddresses);
+      this.cache.push(...additionalInputs);
+    }
+
+    return this.cache.filter((x) => addresses.includes(x.publicKey.toString()));
+  }
+}
+
+export class TransactionItem {
+  lookupTableAddresses!: string[];
+  tx?: TransactionBuilder;
+
+  constructor(
+    public fetchTx: (
+      attemptNum: number
+    ) => Promise<
+      { tx: TransactionBuilder; lookupTableAddresses?: string[] } | undefined
+    >,
+    public name?: string
+  ) {}
+
+  async initialize() {
+    await this.refetch(0);
+  }
+
+  async refetch(attemptNum: number) {
+    const resp = await this.fetchTx(attemptNum);
+    this.tx = resp?.tx;
+    this.lookupTableAddresses = resp?.lookupTableAddresses ?? [];
+  }
+}
+
+class TransactionSet {
+  constructor(
+    private client: SolautoClient,
+    private lookupTables: LookupTables,
+    public items: TransactionItem[] = []
+  ) {}
+
+  async fitsWith(item: TransactionItem): Promise<boolean> {
+    if (!item.tx) {
+      return true;
+    }
+
+    return (await this.getSingleTransaction())
+      .add(item.tx)
+      .setAddressLookupTables(
+        await this.lookupTables.getLutInputs([
+          ...this.lutAddresses(),
+          ...item.lookupTableAddresses,
+        ])
+      )
+      .fitsInOneTransaction(UMI);
+  }
+
+  add(...items: TransactionItem[]) {
+    this.items.push(
+      ...items.filter((x) => x.tx && x.tx.getInstructions().length > 0)
+    );
+  }
+
+  async refetchAll(attemptNum: number) {
+    await this.client.resetLivePositionUpdates();
+    for (const item of this.items) {
+      await item.refetch(attemptNum);
+    }
+  }
+
+  async getSingleTransaction(): Promise<TransactionBuilder> {
+    const transactions = this.items
+      .filter((x) => x.tx && x.tx.getInstructions().length > 0)
+      .map((x) => x.tx!);
+
+    return transactionBuilder()
+      .add(transactions)
+      .setAddressLookupTables(
+        await this.lookupTables.getLutInputs(this.lutAddresses())
+      );
+  }
+
+  lutAddresses(): string[] {
+    return Array.from(
+      new Set(this.items.map((x) => x.lookupTableAddresses).flat())
+    );
+  }
+
+  name(): string {
+    const names = this.items
+      .filter((x) => x.tx && x.name !== undefined)
+      .map((x) => x.name!.toLowerCase());
+    if (names.length >= 3) {
+      return [names.slice(0, -1).join(", "), names[names.length - 1]].join(
+        ", and "
+      );
+    } else {
+      return names.join(" & ");
+    }
+  }
+}
+
+export enum TransactionStatus {
+  Skipped = "Skipped",
+  Processing = "Processing",
+  Queued = "Queued",
+  Successful = "Successful",
+}
+
+export type TransactionManagerStatuses = {
+  name: string;
+  status: TransactionStatus;
+  txSig?: string;
+}[];
+
+export class TransactionsManager {
+  private statuses: TransactionManagerStatuses = [];
+  private lookupTables: LookupTables;
+
+  constructor(
+    private client: SolautoClient,
+    private items: TransactionItem[],
+    private statusCallback?: (statuses: TransactionManagerStatuses) => void,
+    private simulateOnly?: boolean,
+    private mustBeAtomic?: boolean
+  ) {
+    this.lookupTables = new LookupTables(client);
+  }
+
+  private async assembleTransactionSets(
+    items: TransactionItem[]
+  ): Promise<TransactionSet[]> {
+    let transactionSets: TransactionSet[] = [];
+    this.client.log(`Reassembling ${items.length} items`);
+
+    for (let i = 0; i < items.length; ) {
+      let item = items[i];
+      i++;
+
+      if (!item.tx) {
+        continue;
+      }
+
+      const transaction = item.tx.setAddressLookupTables(
+        await this.lookupTables.getLutInputs(item.lookupTableAddresses)
+      );
+      if (!transaction.fitsInOneTransaction(UMI)) {
+        throw new Error(
+          `Transaction exceeds max transaction size (${transaction.getTransactionSize(UMI)})`
+        );
+      } else {
+        let newSet = new TransactionSet(this.client, this.lookupTables, [item]);
+        for (let j = i; j < items.length; j++) {
+          if (await newSet.fitsWith(items[j])) {
+            newSet.add(items[j]);
+            i++;
+          } else {
+            break;
+          }
+        }
+        transactionSets.push(newSet);
+      }
+    }
+
+    return transactionSets;
+  }
+
+  updateStatus(name: string, status: TransactionStatus, txSig?: string) {
+    if (!this.statuses.filter((x) => x.name === name)) {
+      this.statuses.push({ name, status, txSig });
+    } else {
+      const idx = this.statuses.findIndex((x) => x.name === name);
+      if (idx !== -1) {
+        this.statuses[idx].status = status;
+        this.statuses[idx].txSig = txSig;
+      } else {
+        this.statuses.push({ name, status, txSig });
+      }
+    }
+    this.client.log(`${name} is ${status.toString().toLowerCase()}`);
+    this.statusCallback?.(this.statuses);
+  }
+
+  async send() {
+    const updateLookupTable = await this.client.updateLookupTable();
+    if (updateLookupTable && updateLookupTable?.needsToBeIsolated) {
+      this.updateStatus("update lookup table", TransactionStatus.Processing);
+      await retryWithExponentialBackoff(
+        async (attemptNum) =>
+          await sendSingleOptimizedTransaction(
+            this.client,
+            updateLookupTable.updateLutTx,
+            this.simulateOnly,
+            attemptNum
+          ),
+        2
+      );
+      this.updateStatus("update lookup table", TransactionStatus.Successful);
+    }
+
+    for (const item of this.items) {
+      await item.initialize();
+    }
+
+    const [choresBefore, choresAfter] = await getTransactionChores(
+      this.client,
+      transactionBuilder().add(
+        this.items
+          .filter((x) => x.tx && x.tx.getInstructions().length > 0)
+          .map((x) => x.tx!)
+      )
+    );
+    if (updateLookupTable && !updateLookupTable.needsToBeIsolated) {
+      choresBefore.prepend(updateLookupTable.updateLutTx);
+    }
+    if (choresBefore.getInstructions().length > 0) {
+      this.items.unshift(new TransactionItem(async () => ({ tx: choresBefore })));
+      this.client.log("Chores before: ", choresBefore.getInstructions().length);
+    }
+    if (choresAfter.getInstructions().length > 0) {
+      this.items.push(new TransactionItem(async () => ({ tx: choresAfter })));
+      this.client.log("Chores after: ", choresAfter.getInstructions().length);
+    }
+
+    const itemSets = await this.assembleTransactionSets(this.items);
+    const statusesStartIdx = this.statuses.length;
+    for (const itemSet of itemSets) {
+      this.updateStatus(itemSet.name(), TransactionStatus.Queued);
+    }
+
+    if (this.mustBeAtomic && itemSets.length > 1) {
+      itemSets.forEach((set) => {
+        this.updateStatus(set.name(), TransactionStatus.Processing);
+      });
+      await sendJitoBundledTransactions(
+        this.client,
+        await Promise.all(itemSets.map((x) => x.getSingleTransaction())),
+        this.simulateOnly
+      );
+      // TODO: check if successful or not
+      // itemSets.forEach((set) => {
+      //   this.updateStatus(set.name(), TransactionStatus.Successful);
+      // });
+    } else if (!this.simulateOnly || itemSets.length === 1) {
+      for (let i = 0; i < itemSets.length; i++) {
+        const getFreshItemSet = async (
+          itemSet: TransactionSet,
+          attemptNum: number
+        ) => {
+          await itemSet.refetchAll(attemptNum);
+          const newItemSets = await this.assembleTransactionSets([
+            ...itemSet.items,
+            ...itemSets
+              .slice(i + 1)
+              .map((x) => x.items)
+              .flat(),
+          ]);
+          if (newItemSets.length > 1) {
+            this.statuses.splice(
+              statusesStartIdx + i,
+              itemSets.length - i,
+              ...newItemSets.map((x) => ({
+                name: x.name(),
+                status: TransactionStatus.Queued,
+              }))
+            );
+            this.client.log(this.statuses);
+            itemSets.splice(
+              i + 1,
+              itemSets.length - i - 1,
+              ...newItemSets.slice(1)
+            );
+          }
+          return newItemSets[0];
+        };
+
+        let itemSet = itemSets[i];
+        await retryWithExponentialBackoff(async (attemptNum) => {
+          itemSet =
+            i > 0 || attemptNum > 0
+              ? await getFreshItemSet(itemSet, attemptNum)
+              : itemSet;
+          const tx = await itemSet.getSingleTransaction();
+
+          if (tx.getInstructions().length === 0) {
+            this.updateStatus(itemSet.name(), TransactionStatus.Skipped);
+          } else {
+            this.updateStatus(itemSet.name(), TransactionStatus.Processing);
+            const txSig = await sendSingleOptimizedTransaction(
+              this.client,
+              tx,
+              this.simulateOnly,
+              attemptNum
+            );
+            this.updateStatus(
+              itemSet.name(),
+              TransactionStatus.Successful,
+              txSig ? bs58.encode(txSig) : undefined
+            );
+          }
+        }, 3);
+      }
+    }
+
+    if (!this.simulateOnly) {
+      await this.client.resetLivePositionUpdates();
+    }
+  }
+}

package/src/types/accounts.ts

@@ -0,0 +1,7 @@
+export interface MarginfiTokenAccounts {
+  mint: string;
+  bank: string;
+  liquidityVault: string;
+  vaultAuthority: string;
+  priceOracle: string;
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './accounts';

package/src/utils/accountUtils.ts

@@ -0,0 +1,92 @@
+import { PublicKey, AccountMeta } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { SOLAUTO_PROGRAM_ID } from "../generated";
+
+export function bufferFromU8(num: number): Buffer {
+  const buffer = Buffer.alloc(1);
+  buffer.writeUInt8(num);
+  return buffer;
+}
+
+export function bufferFromU64(num: bigint): Buffer {
+  const buffer = Buffer.alloc(8);
+  buffer.writeBigUInt64LE(num);
+  return buffer;
+}
+
+export function getTokenAccount(wallet: PublicKey, tokenMint: PublicKey): PublicKey {
+  return getAssociatedTokenAddressSync(
+    tokenMint,
+    wallet,
+    true
+  );
+}
+
+export function getTokenAccounts(wallet: PublicKey, tokenMints: PublicKey[]): PublicKey[] {
+  return tokenMints.map(x => getTokenAccount(wallet, x));
+}
+
+export async function getSolautoPositionAccount(
+  signer: PublicKey,
+  positionId: number
+) {
+  const [positionAccount, _] = await PublicKey.findProgramAddress(
+    [bufferFromU8(positionId), signer.toBuffer()],
+    new PublicKey(SOLAUTO_PROGRAM_ID)
+  );
+
+  return positionAccount;
+}
+
+export async function getReferralState(authority: PublicKey) {
+  const str = "referral_state";
+  const strBuffer = Buffer.from(str, "utf-8");
+
+  const [ReferralState, _] = await PublicKey.findProgramAddress(
+    [strBuffer, authority.toBuffer()],
+    new PublicKey(SOLAUTO_PROGRAM_ID)
+  );
+
+  return ReferralState;
+}
+
+export async function getMarginfiAccountPDA(
+  solautoPositionAccount: PublicKey,
+  marginfiAccountSeedIdx: bigint
+) {
+  const seeds = [
+    solautoPositionAccount.toBuffer(),
+    bufferFromU64(marginfiAccountSeedIdx),
+  ];
+
+  const [marginfiAccount, _] = await PublicKey.findProgramAddress(
+    seeds,
+    new PublicKey(SOLAUTO_PROGRAM_ID)
+  );
+
+  return marginfiAccount;
+}
+
+export async function getSolendObligationAccount(
+  solautoPositionAccount: PublicKey | undefined,
+  signer: PublicKey,
+  lendingMarket: PublicKey,
+  solendProgram: PublicKey
+) {
+  const seeds = [
+    signer.toBuffer(),
+    lendingMarket.toBuffer(),
+    solendProgram.toBuffer(),
+  ];
+
+  if (solautoPositionAccount !== undefined) {
+    seeds.unshift(solautoPositionAccount.toBuffer());
+  }
+
+  const [obligationAccount, _] = await PublicKey.findProgramAddress(
+    seeds,
+    new PublicKey(SOLAUTO_PROGRAM_ID)
+  );
+
+  return obligationAccount;
+}

package/src/utils/deleteme.ts

@@ -0,0 +1,40 @@
+import { getDebtAdjustmentUsd, getLiqUtilzationRateBps } from "./numberUtils";
+
+// // TODO delete this file
+function check() {
+  let supply = 458948;
+  let debt = 212846;
+  let supply_weight = 0.899999976158142;
+  let debt_weight = 1.100000023841858;
+  let liq_threshold = (supply_weight / debt_weight) * 10000;
+
+  console.log(liq_threshold);
+  let liq_utilization_rate = getLiqUtilzationRateBps(
+    supply,
+    debt,
+    liq_threshold
+  );
+  console.log!(liq_utilization_rate);
+
+  let debt_adjustment_usd = getDebtAdjustmentUsd(
+    liq_threshold,
+    supply,
+    debt,
+    6000,
+    0
+  );
+
+  supply += debt_adjustment_usd;
+  debt += debt_adjustment_usd;
+
+  liq_utilization_rate = getLiqUtilzationRateBps(
+    supply,
+    debt,
+    liq_threshold
+  );
+
+  console.log(debt_adjustment_usd);
+  console.log!(liq_utilization_rate);
+}
+
+check();

package/src/utils/generalUtils.ts

@@ -0,0 +1,123 @@
+import { PublicKey } from "@solana/web3.js";
+import { MaybeRpcAccount, publicKey } from "@metaplex-foundation/umi";
+import { PYTH_PRICE_FEED_IDS } from "../constants/pythConstants";
+import { fromBaseUnit, toBaseUnit } from "./numberUtils";
+import { PRICES, UMI } from "../constants/solautoConstants";
+
+export function generateRandomU8(): number {
+  return Math.floor(Math.random() * 255 + 1);
+}
+
+export function generateRandomU64(): bigint {
+  const upperBound = 2n ** 64n;
+  let result = 0n;
+  for (let i = 0; i < 64; i += 8) {
+    result |= BigInt(Math.floor(Math.random() * 256)) << BigInt(i);
+  }
+  return result % upperBound;
+}
+
+export function currentUnixSeconds(): number {
+  return Math.round(new Date().getTime() / 1000);
+}
+
+export async function getSolanaAccountCreated(pk: PublicKey): Promise<boolean> {
+  const account = await UMI.rpc.getAccount(publicKey(pk));
+  return rpcAccountCreated(account);
+}
+
+export function rpcAccountCreated(account: MaybeRpcAccount): boolean {
+  return account.exists && account.data.length > 0;
+}
+
+export function arraysAreEqual(arrayA: number[], arrayB: number[]): boolean {
+  if (arrayA.length !== arrayB.length) {
+    return false;
+  }
+  for (let i = 0; i < arrayA.length; i++) {
+    if (arrayA[i] !== arrayB[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export async function getTokenPrices(mints: PublicKey[]): Promise<number[]> {
+  const currentTime = currentUnixSeconds();
+  if (!mints.some(mint => !(mint.toString() in PRICES) || currentTime - PRICES[mint.toString()].time > 3)) {
+    console.log("Accessing price cache");
+    return mints.map(mint => PRICES[mint.toString()].price);
+  }
+
+  console.log("Fetching prices...");
+  const priceFeedIds = mints.map(
+    (mint) => PYTH_PRICE_FEED_IDS[mint.toString()]
+  );
+
+  const getReq = async () =>
+    await fetch(
+      `https://hermes.pyth.network/v2/updates/price/latest?${priceFeedIds.map((x) => `ids%5B%5D=${x}`).join("&")}`
+    );
+  let resp = await getReq();
+  let status = resp.status;
+  while (status !== 200) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    resp = await getReq();
+    status = resp.status;
+  }
+
+  const json = await resp.json();
+  const prices = json.parsed.map((x: any) => {
+    if (x.price.expo > 0) {
+      return Number(toBaseUnit(Number(x.price.price), x.price.expo));
+    } else if (x.price.expo < 0) {
+      return fromBaseUnit(
+        BigInt(x.price.price),
+        Math.abs(x.price.expo)
+      );
+    } else {
+      return Number(x.price.price);
+    }
+  });
+
+  for (var i = 0; i < mints.length; i++) {
+    PRICES[mints[i].toString()] = {
+      price: prices[i],
+      time: currentUnixSeconds()
+    };
+  }
+
+
+  return prices;
+}
+
+export function retryWithExponentialBackoff<T>(
+  fn: (attemptNum: number) => Promise<T>,
+  retries: number = 5,
+  delay: number = 150,
+  errorsToRetry?: Set<Function>
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const attempt = (attemptNum: number) => {
+      fn(attemptNum)
+        .then(resolve)
+        .catch((error: Error) => {
+          attemptNum++;
+          if (
+            attemptNum < retries &&
+            (!errorsToRetry || errorsToRetry.has(error.constructor))
+          ) {
+            console.log(error);
+            setTimeout(() => {
+              console.log("Retrying...");
+              attempt(attemptNum);
+            }, delay);
+            delay *= 2;
+          } else {
+            reject(error);
+          }
+        });
+    };
+    attempt(0);
+  });
+}

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+export * from './solauto/index';
+export * from './accountUtils';
+export * from './generalUtils';
+export * from './jitoUtils';
+export * from './jupiterUtils';
+export * from './marginfiUtils';
+export * from './numberUtils';
+export * from './solanaUtils';