@haven-fi/solauto-sdk 1.0.0

package/src/utils/jitoUtils.ts

@@ -0,0 +1,192 @@
+import { assert } from "chai";
+import { SolautoClient } from "../clients/solautoClient";
+import { Keypair, PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { SimulatedBundleTransactionResult } from "jito-ts";
+import { toWeb3JsTransaction } from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  JITO_BLOCK_ENGINE,
+  JITO_CONNECTION,
+  UMI,
+} from "../constants/solautoConstants";
+import {
+  Signer,
+  transactionBuilder,
+  TransactionBuilder,
+  WrappedInstruction,
+} from "@metaplex-foundation/umi";
+import {
+  assembleFinalTransaction,
+  getComputeUnitPriceEstimate,
+  getSecretKey,
+  setComputeUnitLimitUmiIx,
+  setComputeUnitPriceUmiIx,
+  systemTransferUmiIx,
+} from "./solanaUtils";
+import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
+import {
+  SearcherClient,
+  searcherClient,
+} from "jito-ts/dist/sdk/block-engine/searcher";
+import { BundleResult } from "jito-ts/dist/gen/block-engine/bundle";
+
+export function getSearcherClient(): SearcherClient {
+  return searcherClient(
+    JITO_BLOCK_ENGINE,
+    Keypair.fromSecretKey(getSecretKey("jito-bundles"))
+  );
+}
+
+export async function getRandomTipAccount(): Promise<PublicKey> {
+  const tipAccounts = await getSearcherClient().getTipAccounts();
+  const randomInt = Math.floor(Math.random() * tipAccounts.length);
+  return new PublicKey(tipAccounts[randomInt]);
+}
+
+export async function waitUntilJitoNextLeader(
+  distanceFromJitoSlot: number = 5
+) {
+  let searcher = getSearcherClient();
+  let isLeaderSlot = false;
+
+  while (!isLeaderSlot) {
+    const nextLeader = await searcher.getNextScheduledLeader();
+    const numSlots = nextLeader.nextLeaderSlot - nextLeader.currentSlot;
+    isLeaderSlot = numSlots <= distanceFromJitoSlot && numSlots > 1;
+    console.log(`Next jito leader slot in ${numSlots} slots`);
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+async function getTipInstruction(
+  client: SolautoClient,
+  tipLamports: number
+): Promise<WrappedInstruction> {
+  return systemTransferUmiIx(
+    client.signer,
+    await getRandomTipAccount(),
+    BigInt(tipLamports)
+  );
+}
+
+async function simulateJitoBundle(
+  txs: VersionedTransaction[]
+): Promise<SimulatedBundleTransactionResult[]> {
+  const simulationResult = await JITO_CONNECTION.simulateBundle(txs, {
+    preExecutionAccountsConfigs: txs.map((x) => null),
+    postExecutionAccountsConfigs: txs.map((x) => null),
+    skipSigVerify: true,
+  });
+
+  simulationResult.value.transactionResults.forEach((tx) => {
+    if (tx.err) {
+      tx.logs?.forEach((x) => {
+        console.log(x);
+      });
+    }
+    assert.equal(tx.err, undefined);
+  });
+
+  return simulationResult.value.transactionResults;
+}
+
+async function umiToVersionedTransactions(
+  signer: Signer,
+  txs: TransactionBuilder[],
+  feeEstimates: number[],
+  computeUnitLimits?: number[]
+): Promise<VersionedTransaction[]> {
+  return await Promise.all(
+    txs.map(async (tx, i) => {
+      const versionedTx = toWeb3JsTransaction(
+        await (
+          await assembleFinalTransaction(
+            signer,
+            tx,
+            feeEstimates[i],
+            computeUnitLimits ? computeUnitLimits[i] : undefined
+          ).setLatestBlockhash(UMI)
+        ).buildAndSign(UMI)
+      );
+      return versionedTx;
+    })
+  );
+}
+
+async function sendJitoBundle(bundle: Bundle): Promise<BundleResult> {
+  await waitUntilJitoNextLeader();
+  let searcher = getSearcherClient();
+
+  console.log("Sending bundle...");
+  try {
+    const resp = await searcher.sendBundle(bundle);
+    console.log("Send bundle response:", resp);
+  } catch (e) {
+    console.error("Error sending bundle:", e);
+  }
+
+  return await new Promise((resolve, reject) => {
+    searcher.onBundleResult(
+      (res) => {
+        if (res.accepted || res.processed || res.finalized) {
+          resolve(res);
+        } else {
+          console.log(res);
+          return reject("Bundle not accepted");
+        }
+      },
+      (err) => {
+        console.log("Error: ", err);
+        return reject(err);
+      }
+    );
+  });
+}
+
+interface JitoTransactionsResult {
+  bundleResult: BundleResult;
+  txSigs: Uint8Array[];
+}
+
+export async function sendJitoBundledTransactions(
+  client: SolautoClient,
+  txs: TransactionBuilder[],
+  simulateOnly?: boolean
+): Promise<JitoTransactionsResult | undefined> {
+  client.log("Sending Jito bundle...");
+  client.log("Transactions: ", txs.length);
+  client.log(
+    "Transaction sizes: ",
+    txs.map((x) => x.getTransactionSize(UMI))
+  );
+
+  txs[0] = txs[0].prepend(await getTipInstruction(client, 1000000));
+  const feeEstimates = await Promise.all(txs.map(getComputeUnitPriceEstimate));
+
+  let builtTxs = await umiToVersionedTransactions(
+    client.signer,
+    txs,
+    feeEstimates,
+    // Array(txs.length).fill(1_400_000)
+  );
+  // // TODO: Skip over this for now, and instead don't specify a compute unit limit in the final bundle transactions
+  // const simulationResults = await simulateJitoBundle(builtTxs);
+
+  if (!simulateOnly) {
+    // let builtTxs = await umiToVersionedTransactions(
+    //   client.signer,
+    //   txs,
+    //   feeEstimates,
+    //   simulationResults.map((x) => x.unitsConsumed! * 1.15)
+    // );
+
+    const bundleResult = await sendJitoBundle(
+      new Bundle(builtTxs, 100)
+    );
+    return {
+      bundleResult,
+      txSigs: builtTxs.map((x) => x.signatures).flat(),
+    };
+  }
+
+  return undefined;
+}

package/src/utils/jupiterUtils.ts

@@ -0,0 +1,114 @@
+import {
+  Signer,
+  TransactionBuilder,
+  transactionBuilder,
+} from "@metaplex-foundation/umi";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { getWrappedInstruction } from "./solanaUtils";
+import { toBps } from "./numberUtils";
+import { assert } from "console";
+import {
+  createJupiterApiClient,
+  Instruction,
+  QuoteResponse,
+} from "@jup-ag/api";
+import { getTokenAccount } from "./accountUtils";
+
+const jupApi = createJupiterApiClient();
+
+export interface JupSwapDetails {
+  inputMint: PublicKey;
+  outputMint: PublicKey;
+  destinationWallet: PublicKey;
+  amount: bigint;
+  slippageBpsIncFactor?: number;
+  exactOut?: boolean;
+  exactIn?: boolean;
+}
+
+function createTransactionInstruction(
+  instruction: Instruction
+): TransactionInstruction {
+  return new TransactionInstruction({
+    programId: new PublicKey(instruction.programId),
+    keys: instruction.accounts.map((key) => ({
+      pubkey: new PublicKey(key.pubkey),
+      isSigner: key.isSigner,
+      isWritable: key.isWritable,
+    })),
+    data: Buffer.from(instruction.data, "base64"),
+  });
+}
+
+export interface JupSwapTransaction {
+  jupQuote: QuoteResponse;
+  lookupTableAddresses: string[];
+  setupInstructions: TransactionBuilder;
+  tokenLedgerIx: TransactionBuilder;
+  swapIx: TransactionBuilder;
+}
+
+export async function getJupSwapTransaction(
+  signer: Signer,
+  swapDetails: JupSwapDetails
+): Promise<JupSwapTransaction> {
+  console.log("Getting jup quote...");
+
+  const quoteResponse = await jupApi.quoteGet({
+    amount: Number(swapDetails.amount),
+    inputMint: swapDetails.inputMint.toString(),
+    outputMint: swapDetails.outputMint.toString(),
+    swapMode: swapDetails.exactOut
+      ? "ExactOut"
+      : swapDetails.exactIn
+        ? "ExactIn"
+        : undefined,
+  });
+
+  // Up price slippage bps by an extra swapDetails.slippageBpsIncFactor of the estimated price impact (minimum 0.1% price slippage no matter what)
+  const finalPriceSlippageBps = Math.max(
+    quoteResponse.slippageBps ?? 10,
+    Math.round(
+      toBps(parseFloat(quoteResponse.priceImpactPct)) *
+        (1 + (swapDetails.slippageBpsIncFactor ?? 0))
+    )
+  );
+  quoteResponse.slippageBps = finalPriceSlippageBps;
+  console.log(quoteResponse);
+
+  console.log("Getting jup instructions...");
+  const instructions = await jupApi.swapInstructionsPost({
+    swapRequest: {
+      userPublicKey: signer.publicKey.toString(),
+      quoteResponse,
+      wrapAndUnwrapSol: false,
+      useTokenLedger: !swapDetails.exactOut && !swapDetails.exactIn,
+      destinationTokenAccount: getTokenAccount(swapDetails.destinationWallet, swapDetails.outputMint).toString(),
+    },
+  });
+
+  assert(instructions.swapInstruction !== undefined);
+  return {
+    jupQuote: quoteResponse,
+    lookupTableAddresses: instructions.addressLookupTableAddresses,
+    setupInstructions: transactionBuilder().add(
+      instructions.setupInstructions.map((ix) =>
+        getWrappedInstruction(signer, createTransactionInstruction(ix))
+      )
+    ),
+    tokenLedgerIx: transactionBuilder().add(
+      instructions.tokenLedgerInstruction !== undefined
+        ? getWrappedInstruction(
+            signer,
+            createTransactionInstruction(instructions.tokenLedgerInstruction)
+          )
+        : transactionBuilder()
+    ),
+    swapIx: transactionBuilder().add(
+      getWrappedInstruction(
+        signer,
+        createTransactionInstruction(instructions.swapInstruction)
+      )
+    ),
+  };
+}

package/src/utils/local/shared.ts

@@ -0,0 +1,85 @@
+import {
+  Keypair,
+  AddressLookupTableProgram,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+  PublicKey,
+} from "@solana/web3.js";
+import { getSecretKey } from "../solanaUtils";
+import { CONNECTION } from "../../constants/solautoConstants";
+
+const keypair = Keypair.fromSecretKey(getSecretKey());
+
+async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) {
+  let latestBlockhash = await CONNECTION.getLatestBlockhash("finalized");
+
+  const messageV0 = new TransactionMessage({
+    payerKey: keypair.publicKey,
+    recentBlockhash: latestBlockhash.blockhash,
+    instructions: txInstructions,
+  }).compileToV0Message();
+  const transaction = new VersionedTransaction(messageV0);
+
+  transaction.sign([keypair]);
+
+  const txid = await CONNECTION.sendTransaction(transaction, {
+    maxRetries: 5,
+  });
+
+  const confirmation = await CONNECTION.confirmTransaction({
+    signature: txid,
+    blockhash: latestBlockhash.blockhash,
+    lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+  });
+  if (confirmation.value.err) {
+    throw new Error(confirmation.value.err.toString());
+  }
+  console.log(txid);
+}
+
+async function addAddressesIfNeeded(
+  lookupTableAddress: PublicKey,
+  existingAddresses: string[],
+  addressesToAdd: string[]
+) {
+  const addresses = addressesToAdd
+    .filter((x) => !existingAddresses.includes(x))
+    .map((x) => new PublicKey(x));
+
+  if (addresses.length > 0) {
+    await createAndSendV0Tx([
+      AddressLookupTableProgram.extendLookupTable({
+        payer: keypair.publicKey,
+        authority: keypair.publicKey,
+        lookupTable: lookupTableAddress,
+        addresses,
+      }),
+    ]);
+  }
+}
+
+export async function updateLookupTable(
+  accounts: string[],
+  lookupTableAddress?: PublicKey
+) {
+  let lookupTable = lookupTableAddress
+    ? await CONNECTION.getAddressLookupTable(lookupTableAddress)
+    : null;
+  if (lookupTable === null) {
+    const [createLutIx, addr] = AddressLookupTableProgram.createLookupTable({
+      authority: keypair.publicKey,
+      payer: keypair.publicKey,
+      recentSlot: await CONNECTION.getSlot({ commitment: "finalized" }),
+    });
+    lookupTableAddress = addr;
+    console.log("Lookup Table Address:", lookupTableAddress.toString());
+    createAndSendV0Tx([createLutIx]);
+  }
+
+  const existingAccounts =
+    lookupTable?.value?.state.addresses.map((x) => x.toString()) ?? [];
+  console.log("Existing accounts: ", existingAccounts.length);
+
+  await addAddressesIfNeeded(lookupTableAddress!, existingAccounts, accounts);
+}

package/src/utils/local/updateMarginfiLUT.ts

@@ -0,0 +1,33 @@
+import { PublicKey } from "@solana/web3.js";
+import { MARGINFI_ACCOUNTS_LOOKUP_TABLE } from "../../constants/marginfiAccounts";
+import {
+  MARGINFI_ACCOUNTS,
+  DEFAULT_MARGINFI_GROUP,
+} from "../../constants/marginfiAccounts";
+import { MARGINFI_PROGRAM_ID } from "../../marginfi-sdk";
+import { updateLookupTable } from "./shared";
+
+const LOOKUP_TABLE_ADDRESS = new PublicKey(MARGINFI_ACCOUNTS_LOOKUP_TABLE);
+
+async function addBanks() {
+  for (const key in MARGINFI_ACCOUNTS) {
+    const accounts = MARGINFI_ACCOUNTS[key];
+    await updateLookupTable(
+      [
+        accounts.mint,
+        accounts.bank,
+        accounts.liquidityVault,
+        accounts.vaultAuthority,
+        accounts.priceOracle,
+      ],
+      LOOKUP_TABLE_ADDRESS
+    );
+  }
+}
+
+updateLookupTable(
+  [DEFAULT_MARGINFI_GROUP, MARGINFI_PROGRAM_ID],
+  LOOKUP_TABLE_ADDRESS
+);
+
+addBanks();

package/src/utils/local/updateSolautoLUT.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+import { getTokenAccounts } from "../accountUtils";
+import { SOLAUTO_MANAGER } from "../../constants/generalAccounts";
+import { ALL_SUPPORTED_TOKENS } from "../../constants/tokenConstants";
+import { updateLookupTable } from "./shared";
+import { STANDARD_LUT_ACCOUNTS } from "../../constants/solautoConstants";
+
+const solautoManagerTokenAccounts = getTokenAccounts(SOLAUTO_MANAGER, ALL_SUPPORTED_TOKENS.map((x) => new PublicKey(x)));
+
+updateLookupTable(
+  [
+    ...STANDARD_LUT_ACCOUNTS,
+    ...solautoManagerTokenAccounts.map((x) => x.toString())
+  ]
+);