@haven-fi/solauto-sdk 1.0.582 → 1.0.583

package/src/services/swap/jupSwapManager.ts

@@ -0,0 +1,189 @@
+import {
+  Signer,
+  TransactionBuilder,
+  transactionBuilder,
+} from "@metaplex-foundation/umi";
+import {
+  createJupiterApiClient,
+  QuoteResponse,
+  SwapInstructionsResponse,
+} from "@jup-ag/api";
+import { getWrappedInstruction } from "../../utils/solanaUtils";
+import { fromBps, toBps } from "../../utils/numberUtils";
+import { getTokenAccount } from "../../utils/accountUtils";
+import { PublicKey } from "@solana/web3.js";
+import {
+  consoleLog,
+  jupIxToSolanaIx,
+  retryWithExponentialBackoff,
+} from "../../utils";
+import { TransactionItemInputs } from "../../types";
+
+export interface SwapInput {
+  inputMint: PublicKey;
+  outputMint: PublicKey;
+  amount: bigint;
+  exactIn?: boolean;
+  exactOut?: boolean;
+}
+
+export interface SwapParams extends SwapInput {
+  destinationWallet: PublicKey;
+  slippageIncFactor?: number;
+  wrapAndUnwrapSol?: boolean;
+}
+
+export interface JupSwapTransactionData {
+  jupQuote: QuoteResponse;
+  setupInstructions: TransactionBuilder;
+  swapIx: TransactionBuilder;
+  cleanupIx: TransactionBuilder;
+  lookupTableAddresses: string[];
+}
+
+export class JupSwapManager {
+  jupApi = createJupiterApiClient();
+
+  public jupQuote: QuoteResponse | undefined = undefined;
+
+  constructor(private signer: Signer) {}
+
+  public async getQuote(data: SwapInput): Promise<QuoteResponse> {
+    return await retryWithExponentialBackoff(
+      async (attemptNum: number) =>
+        await this.jupApi.quoteGet({
+          amount: Number(data.amount),
+          inputMint: data.inputMint.toString(),
+          outputMint: data.outputMint.toString(),
+          swapMode: data.exactOut
+            ? "ExactOut"
+            : data.exactIn
+              ? "ExactIn"
+              : undefined,
+          slippageBps: 10,
+          maxAccounts: !data.exactOut ? 15 + attemptNum * 5 : undefined,
+        }),
+      3,
+      200
+    );
+  }
+
+  private async getJupInstructions(
+    data: SwapParams
+  ): Promise<SwapInstructionsResponse> {
+    if (!this.jupQuote) {
+      throw new Error(
+        "Fetch a quote first before getting Jupiter instructions"
+      );
+    }
+
+    const instructions = await retryWithExponentialBackoff(
+      async () => {
+        const res = await this.jupApi.swapInstructionsPost({
+          swapRequest: {
+            userPublicKey: this.signer.publicKey.toString(),
+            quoteResponse: this.jupQuote!,
+            wrapAndUnwrapSol: data.wrapAndUnwrapSol ?? false,
+            useTokenLedger: !data.exactOut && !data.exactIn,
+            destinationTokenAccount: getTokenAccount(
+              data.destinationWallet,
+              data.outputMint
+            ).toString(),
+          },
+        });
+        if (!res) {
+          throw new Error("No instructions retrieved");
+        }
+        return res;
+      },
+      4,
+      200
+    );
+    if (!instructions.swapInstruction) {
+      throw new Error("No swap instruction was returned by Jupiter");
+    }
+    return instructions;
+  }
+
+  priceImpactBps() {
+    return Math.round(toBps(parseFloat(this.jupQuote!.priceImpactPct))) + 1;
+  }
+
+  private adaptSlippageToPriceImpact(slippageIncFactor: number) {
+    const finalPriceSlippageBps = Math.round(
+      Math.max(20, this.jupQuote!.slippageBps, this.priceImpactBps()) *
+        (1 + slippageIncFactor)
+    );
+    this.jupQuote!.slippageBps = finalPriceSlippageBps;
+  }
+
+  private addInAmountSlippagePadding() {
+    consoleLog("Raw inAmount:", this.jupQuote!.inAmount);
+    const inc = Math.max(
+      fromBps(this.priceImpactBps()) * 1.1,
+      fromBps(this.jupQuote!.slippageBps) * 0.1
+    );
+    consoleLog("Inc:", inc);
+    this.jupQuote!.inAmount = Math.round(
+      parseInt(this.jupQuote!.inAmount) +
+        parseInt(this.jupQuote!.inAmount) * inc
+    ).toString();
+    consoleLog("Increased inAmount:", this.jupQuote!.inAmount);
+  }
+
+  async getJupSwapTxData(data: SwapParams): Promise<JupSwapTransactionData> {
+    if (!this.jupQuote) {
+      this.jupQuote = await this.getQuote(data);
+    }
+
+    if (data.slippageIncFactor) {
+      this.adaptSlippageToPriceImpact(data.slippageIncFactor);
+    }
+    consoleLog("Quote:", this.jupQuote);
+
+    const instructions = await this.getJupInstructions(data);
+
+    if (data.exactOut) {
+      this.addInAmountSlippagePadding();
+    }
+
+    return {
+      jupQuote: this.jupQuote,
+      lookupTableAddresses: instructions.addressLookupTableAddresses,
+      setupInstructions: transactionBuilder(
+        (instructions.setupInstructions ?? []).map((ix) =>
+          getWrappedInstruction(this.signer, jupIxToSolanaIx(ix))
+        )
+      ),
+      swapIx: transactionBuilder([
+        getWrappedInstruction(
+          this.signer,
+          jupIxToSolanaIx(instructions.swapInstruction)
+        ),
+      ]),
+      cleanupIx: transactionBuilder(
+        instructions.cleanupInstruction
+          ? [
+              getWrappedInstruction(
+                this.signer,
+                jupIxToSolanaIx(instructions.cleanupInstruction)
+              ),
+            ]
+          : []
+      ),
+    };
+  }
+
+  async getSwapTx(data: SwapParams): Promise<TransactionItemInputs> {
+    const swapData = await this.getJupSwapTxData(data);
+
+    return {
+      tx: transactionBuilder().add([
+        swapData.setupInstructions,
+        swapData.swapIx,
+        swapData.cleanupIx,
+      ]),
+      lookupTableAddresses: swapData.lookupTableAddresses,
+    };
+  }
+}

package/src/{transactions → services/transactions}/transactionUtils.ts

@@ -15,10 +15,9 @@ import {
 } from "@solana/spl-token";
 import {
   InvalidRebalanceConditionError,
-  LendingPlatform,
-  RebalanceDirection,
   SolautoAction,
   SolautoRebalanceType,
+  SwapType,
   TokenType,
   convertReferralFees,
   createSolautoProgram,
@@ -27,36 +26,20 @@ import {
   getSolautoErrorFromCode,
   isSolautoAction,
   solautoAction,
-} from "../generated";
-import { SolautoClient } from "../clients/solautoClient";
+} from "../../generated";
+import { SolautoClient } from "../solauto/solautoClient";
 import {
   closeTokenAccountUmiIx,
   createAssociatedTokenAccountUmiIx,
   systemTransferUmiIx,
-} from "../utils/solanaUtils";
-import { getJupSwapTransaction } from "../utils/jupiterUtils";
-import {
-  getFlashLoanDetails,
-  getFlashLoanRequirements,
-  getJupSwapRebalanceDetails,
-  getRebalanceValues,
-} from "../utils/solauto/rebalanceUtils";
+} from "../../utils/solanaUtils";
 import {
   consoleLog,
-  currentUnixSeconds,
   getSolanaAccountCreated,
   rpcAccountCreated,
-} from "../utils/generalUtils";
-import { SolautoMarginfiClient } from "../clients/solautoMarginfiClient";
-import {
-  getMaxLiqUtilizationRateBps,
-  uint8ArrayToBigInt,
-} from "../utils/numberUtils";
-import {
-  eligibleForRebalance,
-  positionStateWithLatestPrices,
-} from "../utils/solauto/generalUtils";
-import { getTokenAccount, getTokenAccountData } from "../utils/accountUtils";
+} from "../../utils/generalUtils";
+import { uint8ArrayToBigInt } from "../../utils/numberUtils";
+import { getTokenAccount, getTokenAccountData } from "../../utils/accountUtils";
 import {
   createMarginfiProgram,
   getLendingAccountBorrowInstructionDataSerializer,
@@ -65,17 +48,16 @@ import {
   getLendingAccountWithdrawInstructionDataSerializer,
   getMarginfiErrorFromCode,
   MARGINFI_PROGRAM_ID,
-} from "../marginfi-sdk";
-import { ReferralStateManager } from "../clients";
+} from "../../marginfi-sdk";
+import { JupSwapManager, ReferralStateManager } from "..";
 import {
   createJupiterProgram,
   getJupiterErrorFromCode,
   JUPITER_PROGRAM_ID,
-} from "../jupiter-sdk";
-import { PRICES } from "../constants";
-import { TransactionItemInputs } from "../types";
-import { safeGetPrice } from "../utils";
-import { BundleSimulationError } from "../types/transactions";
+} from "../../jupiter-sdk";
+import { TransactionItemInputs } from "../../types";
+import { isMarginfiClient } from "../../utils";
+import { BundleSimulationError } from "../../types/transactions";
 
 interface wSolTokenUsage {
   wSolTokenAccount: PublicKey;
@@ -91,8 +73,8 @@ function getWSolUsage(
   },
   cancellingDcaIn?: TokenType
 ): wSolTokenUsage | undefined {
-  const supplyIsWsol = client.supplyMint.equals(NATIVE_MINT);
-  const debtIsWsol = client.debtMint.equals(NATIVE_MINT);
+  const supplyIsWsol = client.solautoPosition.supplyMint().equals(NATIVE_MINT);
+  const debtIsWsol = client.solautoPosition.debtMint().equals(NATIVE_MINT);
   if (!supplyIsWsol && !debtIsWsol) {
     return undefined;
   }
@@ -156,22 +138,19 @@ async function transactionChoresBefore(
   }
 
   if (client.selfManaged) {
-    if (client.solautoPositionData === null) {
-      chores = chores.add(client.openPosition());
-    } else if (
-      client.lendingPlatform === LendingPlatform.Marginfi &&
-      !(await getSolanaAccountCreated(
-        client.umi,
-        (client as SolautoMarginfiClient).marginfiAccountPk
-      ))
+    if (
+      isMarginfiClient(client) &&
+      !(await getSolanaAccountCreated(client.umi, client.marginfiAccountPk))
     ) {
       chores = chores.add(
-        (client as SolautoMarginfiClient).marginfiAccountInitialize(
-          (client as SolautoMarginfiClient).marginfiAccount as Signer
-        )
+        client.marginfiAccountInitialize(client.marginfiAccount as Signer)
       );
     }
     // TODO: PF
+
+    if (!client.solautoPosition.exists()) {
+      chores = chores.add(client.openPositionIx());
+    }
   }
 
   const wSolUsage = getWSolUsage(
@@ -250,8 +229,8 @@ async function transactionChoresBefore(
           client.signer,
           toWeb3JsPublicKey(client.signer.publicKey),
           isSolautoAction("Withdraw", solautoAction)
-            ? client.supplyMint
-            : client.debtMint
+            ? client.solautoPosition.supplyMint()
+            : client.solautoPosition.debtMint()
         )
       );
       accountsGettingCreated.push(tokenAccount.toString());
@@ -280,11 +259,6 @@ export async function rebalanceChoresBefore(
     client.referredBySupplyTa() && usesAccount(client.referredBySupplyTa()!);
   const checkReferralDebtTa =
     client.referredByDebtTa() && usesAccount(client.referredByDebtTa()!);
-  const checkIntermediaryMfiAccount =
-    client.lendingPlatform === LendingPlatform.Marginfi &&
-    usesAccount(
-      (client as SolautoMarginfiClient).intermediaryMarginfiAccountPk
-    );
   const checkSignerSupplyTa = usesAccount(client.signerSupplyTa);
   const checkSignerDebtTa = usesAccount(client.signerDebtTa);
 
@@ -293,24 +267,14 @@ export async function rebalanceChoresBefore(
       checkReferralSupplyTa ? client.referredBySupplyTa() : PublicKey.default,
     ],
     ...[checkReferralDebtTa ? client.referredByDebtTa() : PublicKey.default],
-    ...[
-      checkIntermediaryMfiAccount
-        ? (client as SolautoMarginfiClient).intermediaryMarginfiAccountPk
-        : PublicKey.default,
-    ],
     ...[checkSignerSupplyTa ? client.signerSupplyTa : PublicKey.default],
     ...[checkSignerDebtTa ? client.signerDebtTa : PublicKey.default],
   ];
 
-  const [
-    referredBySupplyTa,
-    referredByDebtTa,
-    intermediaryMarginfiAccount,
-    signerSupplyTa,
-    signerDebtTa,
-  ] = await client.umi.rpc.getAccounts(
-    accountsNeeded.map((x) => publicKey(x ?? PublicKey.default))
-  );
+  const [referredBySupplyTa, referredByDebtTa, signerSupplyTa, signerDebtTa] =
+    await client.umi.rpc.getAccounts(
+      accountsNeeded.map((x) => publicKey(x ?? PublicKey.default))
+    );
 
   let chores = transactionBuilder();
 
@@ -320,7 +284,7 @@ export async function rebalanceChoresBefore(
       createAssociatedTokenAccountUmiIx(
         client.signer,
         client.referredByState!,
-        client.supplyMint
+        client.solautoPosition.supplyMint()
       )
     );
   }
@@ -331,19 +295,7 @@ export async function rebalanceChoresBefore(
       createAssociatedTokenAccountUmiIx(
         client.signer,
         client.referredByState!,
-        client.debtMint
-      )
-    );
-  }
-
-  if (
-    checkIntermediaryMfiAccount &&
-    !rpcAccountCreated(intermediaryMarginfiAccount)
-  ) {
-    client.log("Creating intermediary marginfi account");
-    chores = chores.add(
-      (client as SolautoMarginfiClient).marginfiAccountInitialize(
-        (client as SolautoMarginfiClient).intermediaryMarginfiAccountSigner!
+        client.solautoPosition.debtMint()
       )
     );
   }
@@ -358,7 +310,7 @@ export async function rebalanceChoresBefore(
       createAssociatedTokenAccountUmiIx(
         client.signer,
         toWeb3JsPublicKey(client.signer.publicKey),
-        client.supplyMint
+        client.solautoPosition.supplyMint()
       )
     );
     accountsGettingCreated.push(signerSupplyTa.publicKey.toString());
@@ -374,7 +326,7 @@ export async function rebalanceChoresBefore(
       createAssociatedTokenAccountUmiIx(
         client.signer,
         toWeb3JsPublicKey(client.signer.publicKey),
-        client.debtMint
+        client.solautoPosition.debtMint()
       )
     );
     accountsGettingCreated.push(signerDebtTa.publicKey.toString());
@@ -421,9 +373,11 @@ function getRebalanceInstructions(
       try {
         const serializer = getMarginfiRebalanceInstructionDataSerializer();
         const discriminator = serializer.serialize({
-          targetInAmountBaseUnit: 0,
-          rebalanceType: SolautoRebalanceType.None,
+          swapInAmountBaseUnit: 0,
+          rebalanceType: SolautoRebalanceType.Regular,
+          swapType: SwapType.ExactIn,
           targetLiqUtilizationRateBps: 0,
+          flashLoanFeeBps: null,
         })[0];
         const [data, _] = serializer.deserialize(x.data);
         if (data.discriminator === discriminator) {
@@ -599,201 +553,6 @@ export async function getTransactionChores(
   return [choresBefore, choresAfter];
 }
 
-export async function requiresRefreshBeforeRebalance(client: SolautoClient) {
-  const neverRefreshedBefore =
-    client.solautoPositionData &&
-    client.solautoPositionData.state.supply.amountCanBeUsed.baseUnit ===
-      BigInt(0) &&
-    client.solautoPositionData.state.debt.amountCanBeUsed.baseUnit ===
-      BigInt(0);
-  const aboveMaxLtv =
-    client.solautoPositionState!.liqUtilizationRateBps >
-    getMaxLiqUtilizationRateBps(
-      client.solautoPositionState!.maxLtvBps,
-      client.solautoPositionState!.liqThresholdBps,
-      0.01
-    );
-
-  if (aboveMaxLtv || neverRefreshedBefore) {
-    return true;
-  } else if (client.solautoPositionData && !client.selfManaged) {
-    if (
-      client.contextUpdates.supplyAdjustment > BigInt(0) ||
-      client.contextUpdates.debtAdjustment > BigInt(0)
-    ) {
-      return false;
-    }
-
-    const oldStateWithLatestPrices = await positionStateWithLatestPrices(
-      client.solautoPositionData.state,
-      PRICES[client.supplyMint.toString()].price,
-      PRICES[client.debtMint.toString()].price
-    );
-    const utilizationRateDiff = Math.abs(
-      (client.solautoPositionState?.liqUtilizationRateBps ?? 0) -
-        oldStateWithLatestPrices.liqUtilizationRateBps
-    );
-
-    client.log("Liq utilization rate diff:", utilizationRateDiff);
-    if (
-      client.contextUpdates.supplyAdjustment === BigInt(0) &&
-      client.contextUpdates.debtAdjustment === BigInt(0) &&
-      utilizationRateDiff >= 10
-    ) {
-      client.log(
-        "Choosing to refresh before rebalance. Utilization rate diff:",
-        utilizationRateDiff
-      );
-      return true;
-    }
-  }
-
-  // Rebalance ix will already refresh internally if position is self managed, has automation to update, or position state last updated >= 1 day ago
-
-  client.log("Not refreshing before rebalance");
-  return false;
-}
-
-export async function buildSolautoRebalanceTransaction(
-  client: SolautoClient,
-  targetLiqUtilizationRateBps?: number,
-  attemptNum?: number
-): Promise<TransactionItemInputs | undefined> {
-  client.solautoPositionState = await client.getFreshPositionState();
-  const supplyPrice = safeGetPrice(client.supplyMint) ?? 0;
-  const debtPrice = safeGetPrice(client.debtMint) ?? 0;
-
-  if (
-    (client.solautoPositionState?.supply.amountUsed.baseUnit === BigInt(0) &&
-      client.contextUpdates.supplyAdjustment === BigInt(0)) ||
-    (targetLiqUtilizationRateBps === undefined &&
-      !eligibleForRebalance(
-        client.solautoPositionState!,
-        client.solautoPositionSettings(),
-        client.solautoPositionActiveDca(),
-        currentUnixSeconds(),
-        supplyPrice,
-        debtPrice
-      ))
-  ) {
-    client.log("Not eligible for a rebalance");
-    return undefined;
-  }
-
-  const values = getRebalanceValues(
-    client.solautoPositionState!,
-    client.solautoPositionSettings(),
-    client.solautoPositionActiveDca(),
-    currentUnixSeconds(),
-    supplyPrice,
-    debtPrice,
-    targetLiqUtilizationRateBps
-  );
-  client.log("Rebalance values: ", values);
-
-  const flRequirements = await getFlashLoanRequirements(
-    client,
-    values,
-    attemptNum
-  );
-  const swapDetails = await getJupSwapRebalanceDetails(
-    client,
-    values,
-    flRequirements,
-    targetLiqUtilizationRateBps,
-    attemptNum
-  );
-  const { jupQuote, lookupTableAddresses, setupInstructions, swapIx } =
-    await getJupSwapTransaction(client.signer, swapDetails, attemptNum);
-
-  const flashLoan = flRequirements
-    ? getFlashLoanDetails(client, flRequirements, values, jupQuote)
-    : undefined;
-
-  let tx = transactionBuilder();
-
-  if (await requiresRefreshBeforeRebalance(client)) {
-    tx = tx.add(client.refresh());
-  }
-
-  if (flashLoan) {
-    client.log("Flash loan details: ", flashLoan);
-    const addFirstRebalance = values.amountUsdToDcaIn > 0;
-
-    const rebalanceThenSwap =
-      values.rebalanceDirection === RebalanceDirection.Repay &&
-      flashLoan.useDebtLiquidity;
-
-    const rebalanceType = addFirstRebalance
-      ? SolautoRebalanceType.DoubleRebalanceWithFL
-      : rebalanceThenSwap
-        ? SolautoRebalanceType.FLRebalanceThenSwap
-        : SolautoRebalanceType.FLSwapThenRebalance;
-
-    client.log("Rebalance type:", rebalanceType);
-    const firstRebalance = client.rebalance(
-      "A",
-      jupQuote,
-      rebalanceType,
-      values,
-      flashLoan,
-      targetLiqUtilizationRateBps
-    );
-    const lastRebalance = client.rebalance(
-      "B",
-      jupQuote,
-      rebalanceType,
-      values,
-      flashLoan,
-      targetLiqUtilizationRateBps
-    );
-
-    const flashBorrowDest = getTokenAccount(
-      rebalanceThenSwap
-        ? client.solautoPosition
-        : toWeb3JsPublicKey(client.signer.publicKey),
-      rebalanceThenSwap ? swapDetails.outputMint : swapDetails.inputMint
-    );
-
-    tx = tx.add([
-      setupInstructions,
-      client.flashBorrow(rebalanceType, flashLoan, flashBorrowDest),
-      ...(addFirstRebalance ? [firstRebalance] : []),
-      ...(rebalanceThenSwap
-        ? [lastRebalance, swapIx]
-        : [swapIx, lastRebalance]),
-      client.flashRepay(flashLoan),
-    ]);
-  } else {
-    const rebalanceType = SolautoRebalanceType.Regular;
-    tx = tx.add([
-      setupInstructions,
-      client.rebalance(
-        "A",
-        jupQuote,
-        rebalanceType,
-        values,
-        undefined,
-        targetLiqUtilizationRateBps
-      ),
-      swapIx,
-      client.rebalance(
-        "B",
-        jupQuote,
-        rebalanceType,
-        values,
-        undefined,
-        targetLiqUtilizationRateBps
-      ),
-    ]);
-  }
-
-  return {
-    tx,
-    lookupTableAddresses,
-  };
-}
-
 export async function convertReferralFeesToDestination(
   referralManager: ReferralStateManager,
   tokenAccount: PublicKey,
@@ -807,8 +566,9 @@ export async function convertReferralFeesToDestination(
     return undefined;
   }
 
-  const { lookupTableAddresses, setupInstructions, swapIx } =
-    await getJupSwapTransaction(referralManager.umi.identity, {
+  const jupSwapManager = new JupSwapManager(referralManager.umi.identity);
+  const { lookupTableAddresses, setupInstructions, swapIx, cleanupIx } =
+    await jupSwapManager.getJupSwapTxData({
       amount: tokenAccountData.amount,
       destinationWallet: referralManager.referralState,
       inputMint: tokenAccountData.mint,

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

@@ -5,33 +5,33 @@ import {
   TransactionBuilder,
   Umi,
 } from "@metaplex-foundation/umi";
-import { SolautoClient } from "../clients/solautoClient";
+import { SolautoClient } from "../solauto/solautoClient";
 import {
   addTxOptimizations,
   getAddressLookupInputs,
   sendSingleOptimizedTransaction,
-} from "../utils/solanaUtils";
+} from "../../utils/solanaUtils";
 import {
   consoleLog,
   ErrorsToThrow,
   retryWithExponentialBackoff,
-} from "../utils/generalUtils";
+} from "../../utils/generalUtils";
 import { getErrorInfo, getTransactionChores } from "./transactionUtils";
 import {
   PriorityFeeSetting,
   priorityFeeSettingValues,
   TransactionItemInputs,
   TransactionRunType,
-} from "../types";
-import { ReferralStateManager, TxHandler } from "../clients";
+} from "../../types";
+import { ReferralStateManager, TxHandler } from "..";
 import {
   PublicKey,
   TransactionExpiredBlockheightExceededError,
 } from "@solana/web3.js";
-import { SWITCHBOARD_PRICE_FEED_IDS } from "../constants/switchboardConstants";
-import { buildSwbSubmitResponseTx, getSwitchboardFeedData } from "../utils";
-import { sendJitoBundledTransactions } from "../utils/jitoUtils";
-import { SOLAUTO_PROD_PROGRAM, SOLAUTO_TEST_PROGRAM } from "../constants";
+import { SWITCHBOARD_PRICE_FEED_IDS } from "../../constants/switchboardConstants";
+import { buildSwbSubmitResponseTx, getSwitchboardFeedData } from "../../utils";
+import { sendJitoBundledTransactions } from "../../utils/jitoUtils";
+import { SOLAUTO_PROD_PROGRAM, SOLAUTO_TEST_PROGRAM } from "../../constants";
 
 const CHORES_TX_NAME = "account chores";
 const MAX_SUPPORTED_ACCOUNT_LOCKS = 64;
@@ -416,11 +416,15 @@ export class TransactionsManager {
   }
 
   private async updateLut(tx: TransactionBuilder, newLut: boolean) {
+    const lutInputs = await getAddressLookupInputs(
+      this.txHandler.umi,
+      this.txHandler.defaultLookupTables()
+    );
     const updateLutTxName = `${newLut ? "create" : "update"} lookup table`;
     await retryWithExponentialBackoff(
       async (attemptNum, prevError) =>
         await this.sendTransaction(
-          tx,
+          tx.setAddressLookupTables(lutInputs),
           updateLutTxName,
           attemptNum,
           this.getUpdatedPriorityFeeSetting(prevError, attemptNum),
@@ -430,6 +434,7 @@ export class TransactionsManager {
       150,
       this.errorsToThrow
     );
+    await this.txHandler.refetchReferralState();
   }
 
   public async clientSend(

package/src/solautoPosition/index.ts

@@ -0,0 +1,3 @@
+export * from "./solautoPositionEx";
+export * from "./marginfiSolautoPositionEx";
+export * from "./utils";