Option to skip preflight check about orca-sdks HOT 2 OPEN

import { Transaction, TransactionSignature, TransactionError } from '@solana/web3.js';
import { Connection } from '@solana/web3.js';

export class TransactionProcessor {
  private connection: Connection;

  constructor(connection: Connection) {
    this.connection = connection;
  }

  async processTransaction(transaction: Transaction, skipPreflightCheck = false): Promise<TransactionSignature> {
    if (!skipPreflightCheck) {
      const { err } = await this.connection.getRecentBlockhash();
      if (err) {
        throw new Error(`Unable to get recent blockhash: ${err}`);
      }

      transaction.recentBlockhash = (await this.connection.getRecentBlockhash()).blockhash;
      const { feeCalculator } = await this.connection.getFeeCalculatorForBlockhash(transaction.recentBlockhash);
      transaction.feePayer = feeCalculator.target;
      transaction.recentBlockhash = (await this.connection.getRecentBlockhash()).blockhash;

      const { blockhash } = await this.connection.getRecentBlockhash();
      const signers = transaction.getSignatures().map(({ publicKey }) => publicKey);
      const { value: { err: preflightErr } } = await this.connection.getSignatureStatuses(
        transaction.signature,
        { searchTransactionHistory: true }
      );
      if (preflightErr) {
        throw new TransactionError('Transaction preflight checks failed', transaction, preflightErr);
      }
    }

    const signature = await this.connection.sendRawTransaction(transaction.serialize());
    return signature;
  }
}

const tx1 = new Transaction().add(...);
const tx2 = new Transaction().add(...);

const processor = new TransactionProcessor(connection);
const signature1 = await processor.processTransaction(tx1, true); // skip preflight check
const signature2 = await processor.processTransaction(tx2, true); // skip preflight check

import { Transaction, TransactionSignature } from "@solana/web3.js";
import { Provider } from "./provider";

export class TransactionProcessor {
  private provider: Provider;

  constructor(provider: Provider) {
    this.provider = provider;
  }

  async send(transaction: Transaction, skipPreflight: boolean = false): Promise<TransactionSignature> {
    if (!skipPreflight) {
      await this.provider.connection.getMinimumBalanceForRentExemption(transaction.recentBlockhash);
      await this.provider.connection.getTransactionCount("recent");
    }

    const signature = await this.provider.wallet.signTransaction(transaction);
    return await this.provider.connection.sendRawTransaction(signature.serialize());
  }
}