@haven-fi/solauto-sdk 1.0.685 → 1.0.687

package/src/services/transactions/{transactionsManager.ts → manager/transactionsManager.ts}

@@ -1,41 +1,21 @@
 import bs58 from "bs58";
-import {
-  PublicKey,
-  TransactionExpiredBlockheightExceededError,
-} from "@solana/web3.js";
-import {
-  AddressLookupTableInput,
-  transactionBuilder,
-  TransactionBuilder,
-  Umi,
-} from "@metaplex-foundation/umi";
+import { TransactionExpiredBlockheightExceededError } from "@solana/web3.js";
+import { TransactionBuilder } from "@metaplex-foundation/umi";
 import {
   PriorityFeeSetting,
   priorityFeeSettingValues,
-  TransactionItemInputs,
   TransactionRunType,
-} from "../../types";
-import {
-  SOLAUTO_PROD_PROGRAM,
-  SOLAUTO_TEST_PROGRAM,
-  SWITCHBOARD_PRICE_FEED_IDS,
-} from "../../constants";
+} from "../../../types";
 import {
   consoleLog,
   ErrorsToThrow,
   retryWithExponentialBackoff,
-  addTxOptimizations,
-  getAddressLookupInputs,
   sendSingleOptimizedTransaction,
-  buildSwbSubmitResponseTx,
-  getSwitchboardFeedData,
   sendJitoBundledTransactions,
-} from "../../utils";
-import { SolautoClient, ReferralStateManager, TxHandler } from "../solauto";
-import { getErrorInfo, getTransactionChores } from "./transactionUtils";
-
-const CHORES_TX_NAME = "account chores";
-const MAX_SUPPORTED_ACCOUNT_LOCKS = 64;
+} from "../../../utils";
+import { TxHandler } from "../../solauto";
+import { getErrorInfo } from "../transactionUtils";
+import { LookupTables, TransactionItem, TransactionSet } from "../types";
 
 export class TransactionTooLargeError extends Error {
   constructor(message: string) {
@@ -45,183 +25,6 @@ export class TransactionTooLargeError extends Error {
   }
 }
 
-class LookupTables {
-  cache: AddressLookupTableInput[] = [];
-
-  constructor(
-    public defaultLuts: string[],
-    private umi: Umi
-  ) {}
-
-  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 getAddressLookupInputs(
-        this.umi,
-        missingAddresses
-      );
-      this.cache.push(...additionalInputs);
-    }
-
-    return this.cache;
-  }
-
-  reset() {
-    this.cache = this.cache.filter((x) =>
-      this.defaultLuts.includes(x.publicKey.toString())
-    );
-  }
-}
-
-export class TransactionItem {
-  lookupTableAddresses!: string[];
-  tx?: TransactionBuilder;
-  initialized: boolean = false;
-  orderPrio: number = 0;
-
-  constructor(
-    public fetchTx: (
-      attemptNum: number,
-      prevError?: Error
-    ) => Promise<TransactionItemInputs | undefined>,
-    public name?: string
-  ) {}
-
-  async initialize() {
-    await this.refetch(0);
-    this.initialized = true;
-  }
-
-  async refetch(attemptNum: number, prevError?: Error) {
-    const resp = await this.fetchTx(attemptNum, prevError);
-    this.tx = resp?.tx;
-    this.lookupTableAddresses = resp?.lookupTableAddresses ?? [];
-    this.orderPrio = resp?.orderPrio ?? 0;
-  }
-
-  uniqueAccounts(): string[] {
-    return Array.from(
-      new Set(
-        this.tx!.getInstructions()
-          .map((x) => [
-            x.programId.toString(),
-            ...x.keys.map((y) => y.pubkey.toString()),
-          ])
-          .flat()
-      )
-    );
-  }
-}
-
-class TransactionSet {
-  constructor(
-    private txHandler: TxHandler,
-    public lookupTables: LookupTables,
-    public items: TransactionItem[] = []
-  ) {}
-
-  async lutInputs(): Promise<AddressLookupTableInput[]> {
-    const lutInputs = await this.lookupTables.getLutInputs(this.lutAddresses());
-
-    return lutInputs.filter(
-      (lut, index, self) =>
-        index ===
-        self.findIndex(
-          (item) => item.publicKey.toString() === lut.publicKey.toString()
-        )
-    );
-  }
-
-  async fitsWith(item: TransactionItem): Promise<boolean> {
-    if (!item.tx) {
-      return true;
-    }
-
-    const accountLocks = Array.from(
-      new Set([
-        ...this.items.map((x) => x.uniqueAccounts()),
-        ...item.uniqueAccounts(),
-      ])
-    ).length;
-    if (accountLocks > MAX_SUPPORTED_ACCOUNT_LOCKS) {
-      return false;
-    }
-
-    const singleTx = await this.getSingleTransaction();
-    const tx = addTxOptimizations(this.txHandler.umi, singleTx, 1, 1)
-      .add(item.tx)
-      .setAddressLookupTables(
-        await this.lookupTables.getLutInputs([
-          ...this.lutAddresses(),
-          ...item.lookupTableAddresses,
-        ])
-      );
-
-    return tx.fitsInOneTransaction(this.txHandler.umi);
-  }
-
-  add(...items: TransactionItem[]) {
-    this.items.push(
-      ...items.filter((x) => x.tx && x.tx.getInstructions().length > 0)
-    );
-  }
-
-  prepend(...items: TransactionItem[]) {
-    this.items.unshift(
-      ...items.filter((x) => x.tx && x.tx.getInstructions().length > 0)
-    );
-  }
-
-  async reset() {
-    await this.txHandler.resetLiveTxUpdates();
-  }
-
-  async refetchAll(attemptNum: number, prevError?: Error) {
-    for (const item of this.items) {
-      await item.refetch(attemptNum, prevError);
-    }
-  }
-
-  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.lutInputs());
-  }
-
-  lutAddresses(): string[] {
-    return Array.from(
-      new Set(this.items.map((x) => x.lookupTableAddresses).flat())
-    );
-  }
-
-  name(): string {
-    let names = this.items
-      .filter((x) => x.tx && Boolean(x.name))
-      .map((x) => x.name!.toLowerCase());
-    if (names.length > 1) {
-      names = names.filter((x) => x !== CHORES_TX_NAME);
-    }
-    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",
@@ -245,33 +48,48 @@ interface RetryConfig {
   retryDelay?: number;
 }
 
-export class TransactionsManager {
-  private statuses: TransactionManagerStatuses = [];
-  private lookupTables: LookupTables;
-  private signableRetries: number;
-  private totalRetries: number;
-  private retryDelay: number;
+export interface TransactionManagerArgs<T extends TxHandler> {
+  txHandler: T;
+  statusCallback?: (statuses: TransactionManagerStatuses) => void;
+  txRunType?: TransactionRunType;
+  priorityFeeSetting?: PriorityFeeSetting;
+  atomically?: boolean;
+  errorsToThrow?: ErrorsToThrow;
+  retryConfig?: RetryConfig;
+}
+
+export class TransactionsManager<T extends TxHandler> {
+  protected txHandler: T;
+  protected statusCallback?: (statuses: TransactionManagerStatuses) => void;
+  protected txRunType?: TransactionRunType;
+  protected priorityFeeSetting: PriorityFeeSetting;
+  protected atomically: boolean;
+  protected errorsToThrow?: ErrorsToThrow;
+  protected statuses: TransactionManagerStatuses = [];
+  protected lookupTables: LookupTables;
+  protected signableRetries: number;
+  protected totalRetries: number;
+  protected retryDelay: number;
 
   updateOracleTxName = "update oracle";
 
-  constructor(
-    private txHandler: SolautoClient | ReferralStateManager,
-    private statusCallback?: (statuses: TransactionManagerStatuses) => void,
-    private txType?: TransactionRunType,
-    private priorityFeeSetting: PriorityFeeSetting = PriorityFeeSetting.Min,
-    private atomically: boolean = true,
-    private errorsToThrow?: ErrorsToThrow,
-    retryConfig?: RetryConfig
-  ) {
+  constructor(args: TransactionManagerArgs<T>) {
+    this.txHandler = args.txHandler;
+    this.statusCallback = args.statusCallback;
+    this.txRunType = args.txRunType;
+    this.priorityFeeSetting = args.priorityFeeSetting ?? PriorityFeeSetting.Min;
+    this.atomically = args.atomically ?? true;
+    this.errorsToThrow = args.errorsToThrow;
+
     this.lookupTables = new LookupTables(
       this.txHandler.defaultLookupTables(),
       this.txHandler.umi
     );
     this.signableRetries =
-      retryConfig?.signableRetries ?? retryConfig?.totalRetries ?? 4;
+      args.retryConfig?.signableRetries ?? args.retryConfig?.totalRetries ?? 4;
     this.totalRetries =
-      retryConfig?.totalRetries ?? retryConfig?.signableRetries ?? 4;
-    this.retryDelay = retryConfig?.retryDelay ?? 150;
+      args.retryConfig?.totalRetries ?? args.retryConfig?.signableRetries ?? 4;
+    this.retryDelay = args.retryConfig?.retryDelay ?? 150;
   }
 
   private async assembleTransactionSets(
@@ -381,7 +199,7 @@ export class TransactionsManager {
     }
   }
 
-  private getUpdatedPriorityFeeSetting(
+  protected getUpdatedPriorityFeeSetting(
     prevError: Error | undefined,
     attemptNum: number
   ) {
@@ -417,132 +235,6 @@ export class TransactionsManager {
     });
   }
 
-  private async updateLut(tx: TransactionBuilder, newLut: boolean) {
-    const lutInputs = await this.lookupTables.getLutInputs();
-    const updateLutTxName = `${newLut ? "create" : "update"} lookup table`;
-    await retryWithExponentialBackoff(
-      async (attemptNum, prevError) =>
-        await this.sendTransaction(
-          tx.setAddressLookupTables(lutInputs),
-          updateLutTxName,
-          attemptNum,
-          this.getUpdatedPriorityFeeSetting(prevError, attemptNum),
-          "skip-simulation"
-        ),
-      this.signableRetries,
-      150,
-      this.errorsToThrow
-    );
-    await this.txHandler.refetchReferralState();
-  }
-
-  public async clientSend(
-    transactions: TransactionItem[]
-  ): Promise<TransactionManagerStatuses> {
-    const items = [...transactions];
-    const client = this.txHandler as SolautoClient;
-
-    const updateLut = await client.updateLookupTable();
-
-    if (updateLut && (updateLut?.new || updateLut.accountsToAdd.length > 4)) {
-      await this.updateLut(updateLut.tx, updateLut.new);
-    }
-    this.lookupTables.defaultLuts = client.defaultLookupTables();
-
-    for (const item of items) {
-      await item.initialize();
-    }
-
-    const allAccounts = items.flatMap((item) => {
-      return (
-        item.tx
-          ?.getInstructions()
-          .filter((ix) => {
-            return (
-              ix.programId.toString() === SOLAUTO_PROD_PROGRAM.toString() ||
-              ix.programId.toString() === SOLAUTO_TEST_PROGRAM.toString()
-            );
-          })
-          .flatMap((ix) => {
-            return ix.keys.map((key) => key.pubkey.toString());
-          }) ?? []
-      );
-    });
-
-    const swbOracle = allAccounts.find((x) =>
-      Object.values(SWITCHBOARD_PRICE_FEED_IDS)
-        .map((x) => x.feedId)
-        .includes(x ?? "")
-    );
-    if (swbOracle) {
-      const mint = new PublicKey(
-        Object.keys(SWITCHBOARD_PRICE_FEED_IDS).find(
-          (x) => SWITCHBOARD_PRICE_FEED_IDS[x].feedId === swbOracle
-        )!
-      );
-      const stale = (await getSwitchboardFeedData(client.connection, [mint]))[0]
-        .stale;
-
-      if (stale) {
-        this.txHandler.log("Requires oracle update...");
-        const swbTx = new TransactionItem(
-          async () =>
-            buildSwbSubmitResponseTx(client.connection, client.signer, mint),
-          this.updateOracleTxName
-        );
-        await swbTx.initialize();
-        items.unshift(swbTx);
-      }
-    }
-
-    let [choresBefore, choresAfter] = await getTransactionChores(
-      client,
-      transactionBuilder().add(
-        items
-          .filter((x) => x.tx && x.tx.getInstructions().length > 0)
-          .map((x) => x.tx!)
-      )
-    );
-    if (updateLut && !updateLut?.new) {
-      choresBefore = choresBefore.prepend(updateLut.tx);
-    }
-    if (choresBefore.getInstructions().length > 0) {
-      const chore = new TransactionItem(
-        async () => ({ tx: choresBefore }),
-        CHORES_TX_NAME
-      );
-      await chore.initialize();
-      items.unshift(chore);
-      this.txHandler.log(
-        "Chores before: ",
-        choresBefore.getInstructions().length
-      );
-    }
-    if (choresAfter.getInstructions().length > 0) {
-      const chore = new TransactionItem(
-        async () => ({ tx: choresAfter }),
-        CHORES_TX_NAME
-      );
-      await chore.initialize();
-      items.push(chore);
-      this.txHandler.log(
-        "Chores after: ",
-        choresAfter.getInstructions().length
-      );
-    }
-
-    const result = await this.send(items).catch((e) => {
-      client.resetLiveTxUpdates(false);
-      throw e;
-    });
-
-    if (this.txType !== "only-simulate") {
-      await client.resetLiveTxUpdates();
-    }
-
-    return result;
-  }
-
   public async send(
     items: TransactionItem[]
   ): Promise<TransactionManagerStatuses> {
@@ -641,7 +333,7 @@ export class TransactionsManager {
             this.txHandler.signer,
             this.txHandler.otherSigners,
             transactions,
-            this.txType,
+            this.txRunType,
             this.getUpdatedPriorityFeeSetting(prevError, attemptNum),
             () =>
               this.updateStatusForSets(
@@ -658,7 +350,7 @@ export class TransactionsManager {
 
         if (
           error ||
-          (this.txType !== "only-simulate" &&
+          (this.txRunType !== "only-simulate" &&
             (!Boolean(txSigs) || txSigs?.length === 0))
         ) {
           this.updateStatusForSets(
@@ -825,12 +517,12 @@ export class TransactionsManager {
     return newItemSets;
   }
 
-  private async sendTransaction(
+  protected async sendTransaction(
     tx: TransactionBuilder,
     txName: string,
     attemptNum: number,
     priorityFeeSetting?: PriorityFeeSetting,
-    txType?: TransactionRunType
+    txRunType?: TransactionRunType
   ) {
     this.updateStatus(txName, TransactionStatus.Processing, attemptNum);
     try {
@@ -838,7 +530,7 @@ export class TransactionsManager {
         this.txHandler.umi,
         this.txHandler.connection,
         tx,
-        txType ?? this.txType,
+        txRunType ?? this.txRunType,
         priorityFeeSetting,
         () =>
           this.updateStatus(

package/src/services/transactions/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./lookupTables";
+export * from "./transactionItem";
+export * from "./transactionSet";

package/src/services/transactions/types/lookupTables.ts

@@ -0,0 +1,37 @@
+import { AddressLookupTableInput, Umi } from "@metaplex-foundation/umi";
+import { getAddressLookupInputs } from "../../../utils";
+
+export class LookupTables {
+  cache: AddressLookupTableInput[] = [];
+
+  constructor(
+    public defaultLuts: string[],
+    private umi: Umi
+  ) {}
+
+  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 getAddressLookupInputs(
+        this.umi,
+        missingAddresses
+      );
+      this.cache.push(...additionalInputs);
+    }
+
+    return this.cache;
+  }
+
+  reset() {
+    this.cache = this.cache.filter((x) =>
+      this.defaultLuts.includes(x.publicKey.toString())
+    );
+  }
+}

package/src/services/transactions/types/transactionItem.ts

@@ -0,0 +1,43 @@
+import { TransactionBuilder } from "@metaplex-foundation/umi";
+import { TransactionItemInputs } from "../../../types";
+
+export class TransactionItem {
+  lookupTableAddresses!: string[];
+  tx?: TransactionBuilder;
+  initialized: boolean = false;
+  orderPrio: number = 0;
+
+  constructor(
+    public fetchTx: (
+      attemptNum: number,
+      prevError?: Error
+    ) => Promise<TransactionItemInputs | undefined>,
+    public name?: string,
+    public oracleInteractor?: boolean
+  ) {}
+
+  async initialize() {
+    await this.refetch(0);
+    this.initialized = true;
+  }
+
+  async refetch(attemptNum: number, prevError?: Error) {
+    const resp = await this.fetchTx(attemptNum, prevError);
+    this.tx = resp?.tx;
+    this.lookupTableAddresses = resp?.lookupTableAddresses ?? [];
+    this.orderPrio = resp?.orderPrio ?? 0;
+  }
+
+  uniqueAccounts(): string[] {
+    return Array.from(
+      new Set(
+        this.tx!.getInstructions()
+          .map((x) => [
+            x.programId.toString(),
+            ...x.keys.map((y) => y.pubkey.toString()),
+          ])
+          .flat()
+      )
+    );
+  }
+}

package/src/services/transactions/types/transactionSet.ts

@@ -0,0 +1,114 @@
+import {
+  AddressLookupTableInput,
+  transactionBuilder,
+  TransactionBuilder,
+} from "@metaplex-foundation/umi";
+import { TxHandler } from "../../solauto";
+import { LookupTables } from "./lookupTables";
+import { TransactionItem } from "./transactionItem";
+import { addTxOptimizations } from "../../../utils";
+import { CHORES_TX_NAME } from "../../../constants";
+
+const MAX_SUPPORTED_ACCOUNT_LOCKS = 64;
+
+export class TransactionSet {
+  constructor(
+    private txHandler: TxHandler,
+    public lookupTables: LookupTables,
+    public items: TransactionItem[] = []
+  ) {}
+
+  async lutInputs(): Promise<AddressLookupTableInput[]> {
+    const lutInputs = await this.lookupTables.getLutInputs(this.lutAddresses());
+
+    return lutInputs.filter(
+      (lut, index, self) =>
+        index ===
+        self.findIndex(
+          (item) => item.publicKey.toString() === lut.publicKey.toString()
+        )
+    );
+  }
+
+  async fitsWith(item: TransactionItem): Promise<boolean> {
+    if (!item.tx) {
+      return true;
+    }
+
+    const accountLocks = Array.from(
+      new Set([
+        ...this.items.map((x) => x.uniqueAccounts()),
+        ...item.uniqueAccounts(),
+      ])
+    ).length;
+    if (accountLocks > MAX_SUPPORTED_ACCOUNT_LOCKS) {
+      return false;
+    }
+
+    const singleTx = await this.getSingleTransaction();
+    const tx = addTxOptimizations(this.txHandler.umi, singleTx, 1, 1)
+      .add(item.tx)
+      .setAddressLookupTables(
+        await this.lookupTables.getLutInputs([
+          ...this.lutAddresses(),
+          ...item.lookupTableAddresses,
+        ])
+      );
+
+    return tx.fitsInOneTransaction(this.txHandler.umi);
+  }
+
+  add(...items: TransactionItem[]) {
+    this.items.push(
+      ...items.filter((x) => x.tx && x.tx.getInstructions().length > 0)
+    );
+  }
+
+  prepend(...items: TransactionItem[]) {
+    this.items.unshift(
+      ...items.filter((x) => x.tx && x.tx.getInstructions().length > 0)
+    );
+  }
+
+  async reset() {
+    await this.txHandler.resetLiveTxUpdates();
+  }
+
+  async refetchAll(attemptNum: number, prevError?: Error) {
+    for (const item of this.items) {
+      await item.refetch(attemptNum, prevError);
+    }
+  }
+
+  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.lutInputs());
+  }
+
+  lutAddresses(): string[] {
+    return Array.from(
+      new Set(this.items.map((x) => x.lookupTableAddresses).flat())
+    );
+  }
+
+  name(): string {
+    let names = this.items
+      .filter((x) => x.tx && Boolean(x.name))
+      .map((x) => x.name!.toLowerCase());
+    if (names.length > 1) {
+      names = names.filter((x) => x !== CHORES_TX_NAME);
+    }
+    if (names.length >= 3) {
+      return [names.slice(0, -1).join(", "), names[names.length - 1]].join(
+        ", and "
+      );
+    } else {
+      return names.join(" & ");
+    }
+  }
+}

package/src/solautoPosition/positionUtils.ts

@@ -198,7 +198,7 @@ export function createFakePositionState(
     },
     maxLtvBps,
     liqThresholdBps,
-    lastRefreshed: BigInt(currentUnixSeconds() - 100),
+    lastRefreshed: BigInt(currentUnixSeconds()),
     padding1: [],
     padding2: [],
     padding: [],