sol-ihor-lab 1.0.0

package/src/create_token.ts

@@ -0,0 +1,267 @@
+import { Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR, TX_RET } from "./global";
+import {
+  createMint,
+  getMint,
+  getOrCreateAssociatedTokenAccount,
+  mintTo
+} from "@solana/spl-token";
+import {
+  Metaplex,
+  bundlrStorage,
+  keypairIdentity,
+  toMetaplexFile
+} from "@metaplex-foundation/js";
+import { readFileSync } from "fs";
+import { checkFileExists, xWeiAmount } from "./utility";
+import {
+  PROGRAM_ID,
+  createCreateMetadataAccountV3Instruction
+} from "@metaplex-foundation/mpl-token-metadata";
+
+import * as transaction from "./transaction-helper/transaction";
+
+const totalSupplyMint = async (
+  connection: Connection,
+  token_owner: Keypair,
+  token_addr: string,
+  total_supply: number
+) => {
+  const token_mint = new PublicKey(token_addr);
+  const mint_info = await getMint(connection, token_mint);
+  try {
+    const owner_token_account = await getOrCreateAssociatedTokenAccount(
+      connection,
+      token_owner,
+      token_mint,
+      token_owner.publicKey
+    );
+
+    if (owner_token_account.address.toBase58().length <= 0) {
+      console.log(
+        "Error: [Total Supply Mint] failed to create associated token account"
+      );
+      return SPL_ERROR.E_TOTAL_MINT_FAIL;
+    }
+
+    const token_amount = xWeiAmount(total_supply, mint_info.decimals);
+
+    const mint_result = await mintTo(
+      connection,
+      token_owner,
+      token_mint,
+      owner_token_account.address,
+      token_owner,
+      BigInt(token_amount.toString())
+    );
+
+    if (mint_result.length <= 0) {
+      console.log("Error: [Total Supply Mint] failed to mint to owner wallet");
+      return SPL_ERROR.E_TOTAL_MINT_FAIL;
+    }
+  } catch (error) {
+    console.log("Error: [Total Supply Mint] failed to mint to owner wallet");
+    return SPL_ERROR.E_TOTAL_MINT_FAIL;
+  }
+
+  return SPL_ERROR.E_OK;
+};
+
+const createTokenMetaData = async (
+  connection: Connection,
+  token_owner: Keypair,
+  token_addr: string,
+  name: string,
+  symbol: string,
+  token_logo: string,
+  rpc_url: string,
+  description?: string
+): Promise<SPL_ERROR> => {
+  try {
+    const metaplex = Metaplex.make(connection)
+      .use(keypairIdentity(token_owner))
+      .use(
+        bundlrStorage({
+          address: EnvironmentManager.getBundlrUrl(),
+          providerUrl: rpc_url,
+          timeout: 60000
+        })
+      );
+    const buffer = readFileSync(token_logo);
+    const file = toMetaplexFile(buffer, "token-logo.png");
+    const logo_url = await metaplex.storage().upload(file);
+
+    if (logo_url.length <= 0) {
+      console.log(
+        "Error: [Create Token Meta Data] failed to load metapelx data!!!"
+      );
+      return SPL_ERROR.E_FAIL;
+    }
+
+    const metaplex_data = {
+      name: name,
+      symbol: symbol,
+      image: logo_url,
+      description
+    };
+
+    const { uri } = await metaplex.nfts().uploadMetadata(metaplex_data);
+
+    if (uri.length <= 0) {
+      console.log(
+        "Error: [Create Token Meta Data] failed to upload metaplex data!!!"
+      );
+      return SPL_ERROR.E_FAIL;
+    }
+
+    const token_mint = new PublicKey(token_addr);
+    const [metadata_PDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), PROGRAM_ID.toBuffer(), token_mint.toBuffer()],
+      PROGRAM_ID
+    );
+
+    const token_meta_data = {
+      name: name,
+      symbol: symbol,
+      uri: uri,
+      sellerFeeBasisPoints: 0,
+      creators: null,
+      collection: null,
+      uses: null
+    };
+
+    const txn = new Transaction().add(
+      createCreateMetadataAccountV3Instruction(
+        {
+          metadata: metadata_PDA,
+          mint: token_mint,
+          mintAuthority: token_owner.publicKey,
+          payer: token_owner.publicKey,
+          updateAuthority: token_owner.publicKey
+        },
+        {
+          createMetadataAccountArgsV3: {
+            data: token_meta_data,
+            isMutable: true,
+            collectionDetails: null
+          }
+        }
+      )
+    );
+
+    if (
+      (await transaction.sendAndConfirmTransactionWithCheck(
+        connection,
+        token_owner,
+        txn
+      )) !== SPL_ERROR.E_OK
+    ) {
+      return SPL_ERROR.E_FAIL;
+    }
+  } catch (error) {
+    console.log(
+      "Error: [Create Token Meta Data] failed to create meta data -",
+      error
+    );
+    return SPL_ERROR.E_FAIL;
+  }
+
+  return SPL_ERROR.E_OK;
+};
+
+export const createToken = async (
+  connection: Connection,
+  token_owner: Keypair,
+  name: string,
+  symbol: string,
+  decimal: number,
+  total_supply: number,
+  token_logo: string,
+  description?: string
+): Promise<TX_RET> => {
+  if (
+    name.length <= 0 ||
+    symbol.length <= 0 ||
+    token_logo.length <= 0 ||
+    token_owner.publicKey.toBase58().length <= 0 ||
+    EnvironmentManager.getRpcNetUrl().length <= 0 ||
+    decimal <= 0 ||
+    total_supply <= 0
+  ) {
+    console.log("Error: [Create Token] invalid argument to create token!!!");
+    return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+  }
+
+  if ((await checkFileExists(token_logo)) === false) {
+    console.log(
+      "Error: [Create Token] invalid argument to create token - token logo path invalid!!!"
+    );
+    return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+  }
+
+  console.log("<-----------------[Create Token]---------------------");
+  console.log(
+    "Name: ",
+    name,
+    "Symbol: ",
+    symbol,
+    "Decimal: ",
+    decimal,
+    "Total Supply: ",
+    total_supply,
+    "Token Logo: ",
+    token_logo,
+    "Token Description: ",
+    description
+  );
+  console.log("<-----------------[Create Token]---------------------");
+
+  const token_mint = await createMint(
+    connection,
+    token_owner,
+    token_owner.publicKey,
+    token_owner.publicKey,
+    decimal
+  );
+
+  if (token_mint.toBase58().length <= 0) {
+    console.log("Error: [Create Token] failed to create mint!!!");
+    return { result: SPL_ERROR.E_FAIL, value: undefined };
+  }
+
+  console.log(
+    "<-----------------[Create Token Meta Data]---------------------"
+  );
+
+  const meta_result = await createTokenMetaData(
+    connection,
+    token_owner,
+    token_mint.toBase58(),
+    name,
+    symbol,
+    token_logo,
+    EnvironmentManager.getRpcNetUrl(),
+    description
+  );
+
+  if (meta_result !== SPL_ERROR.E_OK) {
+    console.log("Error: [Create Token] failed to create meta data!!!");
+    return { result: SPL_ERROR.E_CREATE_META_FAILED, value: undefined };
+  }
+
+  console.log("<-----------------[Token mint]---------------------");
+
+  if (
+    (await totalSupplyMint(
+      connection,
+      token_owner,
+      token_mint.toBase58(),
+      total_supply
+    )) !== SPL_ERROR.E_OK
+  ) {
+    console.log("Error: [Create Token] failed to mint total supply!!!");
+    return { result: SPL_ERROR.E_TOTAL_MINT_FAIL, value: undefined };
+  }
+  console.log("Success: [Create Token] Mint Address: ", token_mint.toBase58());
+  return { result: SPL_ERROR.E_OK, value: token_mint.toBase58() };
+};

package/src/errors.ts

@@ -0,0 +1,25 @@
+export abstract class BaseError extends Error {
+  constructor(message?: string) {
+    super(message);
+  }
+}
+
+export class UploadMetadataError extends BaseError {
+  name = "UploadMetadataError";
+}
+
+export class GenerateTransactionError extends BaseError {
+  name = "GenerateTransactionError";
+}
+
+export class BuildInstructionError extends BaseError {
+  name = "BuildInstructionError";
+}
+
+export class SetTxPriorityError extends BaseError {
+  name = "SetTxPriorityError";
+}
+
+export class TransactionExecuteError extends BaseError {
+  name = "TransactionExecuteError";
+}

package/src/global.ts

@@ -0,0 +1,156 @@
+import {
+  CacheLTA,
+  DEVNET_PROGRAM_ID,
+  LOOKUP_TABLE_CACHE,
+  MAINNET_PROGRAM_ID,
+  ProgramId
+} from "@raydium-io/raydium-sdk";
+
+import {
+  Keypair,
+  PublicKey,
+  Transaction,
+  VersionedTransaction
+} from "@solana/web3.js";
+
+export enum SPL_ERROR {
+  E_INVALID_ARGUE = -1,
+  E_OK = 0,
+  E_FAIL = 1,
+  E_CHECK_FAIL = 2,
+  E_SEND_TX_FAIL,
+  E_CONFIRM_TX_FAIL,
+  E_CREATE_META_FAILED,
+  E_TOTAL_MINT_FAIL
+}
+
+export enum NETWORK_MODE {
+  NETWORK_MAIN = 0,
+  NETWORK_DEV = 1,
+  NETWORK_TEST = 2
+}
+
+export interface TX_RET {
+  result: SPL_ERROR;
+  value: string | (VersionedTransaction | Transaction)[] | undefined;
+}
+
+export interface TOKEN_INFO {
+  address: string;
+  name: string;
+  symbol: string;
+  decimal: number;
+}
+
+export interface BUNDLE_TRANSACTION {
+  txn: VersionedTransaction;
+  signer: Keypair;
+}
+
+export class EnvironmentManager {
+  private static NET_MODE: NETWORK_MODE = NETWORK_MODE.NETWORK_MAIN;
+  private static JITO_BLOCKENGINE_URL =
+    "frankfurt.mainnet.block-engine.jito.wtf";
+  private static RPC_CHECK_URL = "http://95.217.82.36:8180";
+  private static RPC_MAIN_URL = "";
+  private static RPC_DEVNET_URL = "";
+  private static RPC_TESTNET_URL = "";
+  private static JITO_KEYPAIR: Keypair;
+
+  private static QUOTE_TOKEN_INFO: TOKEN_INFO;
+
+  static setNetworkMode(mode: NETWORK_MODE) {
+    EnvironmentManager.NET_MODE = mode;
+  }
+
+  static setMainNetURL(url: string) {
+    EnvironmentManager.RPC_MAIN_URL = url;
+  }
+
+  static setDevNetURL(url: string) {
+    EnvironmentManager.RPC_DEVNET_URL = url;
+  }
+
+  static setTestNettURL(url: string) {
+    EnvironmentManager.RPC_TESTNET_URL = url;
+  }
+
+  static getMainNetURL(): string {
+    return EnvironmentManager.RPC_MAIN_URL;
+  }
+
+  static getDevNetURL(): string {
+    return EnvironmentManager.RPC_DEVNET_URL;
+  }
+
+  static getTestNetURL(): string {
+    return EnvironmentManager.RPC_TESTNET_URL;
+  }
+
+  static getNetworkMode(): NETWORK_MODE {
+    return EnvironmentManager.NET_MODE;
+  }
+
+  static getRpcNetUrl(): string {
+    switch (EnvironmentManager.NET_MODE) {
+      case NETWORK_MODE.NETWORK_MAIN:
+        return EnvironmentManager.getMainNetURL();
+      case NETWORK_MODE.NETWORK_DEV:
+        return EnvironmentManager.getDevNetURL();
+      case NETWORK_MODE.NETWORK_TEST:
+        return EnvironmentManager.getTestNetURL();
+    }
+  }
+
+  static setNetUrls(main_url: string, dev_url: string, test_url?: string) {
+    EnvironmentManager.setMainNetURL(main_url);
+    EnvironmentManager.setDevNetURL(dev_url);
+  }
+
+  static getBundlrUrl(): string {
+    return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+      ? "https://node1.bundlr.network"
+      : "https://devnet.bundlr.network";
+  }
+
+  static getCheckUrl(): string {
+    return EnvironmentManager.RPC_CHECK_URL;
+  }
+
+  static getProgramID(): ProgramId {
+    return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+      ? MAINNET_PROGRAM_ID
+      : DEVNET_PROGRAM_ID;
+  }
+
+  static setQuoteTokenInfo(token_info: TOKEN_INFO) {
+    EnvironmentManager.QUOTE_TOKEN_INFO = token_info;
+  }
+
+  static getQuoteTokenInfo(): TOKEN_INFO {
+    return EnvironmentManager.QUOTE_TOKEN_INFO;
+  }
+
+  static getCacheLTA(): CacheLTA | undefined {
+    return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+      ? LOOKUP_TABLE_CACHE
+      : undefined;
+  }
+
+  static getFeeDestinationId(): PublicKey {
+    return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+      ? new PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5")
+      : new PublicKey("3XMrhbv989VxAMi3DErLV9eJht1pHppW5LbKxe9fkEFR");
+  }
+
+  static getJitoBlockEngine(): string {
+    return EnvironmentManager.JITO_BLOCKENGINE_URL;
+  }
+
+  static setJitoKeypair(auth_key: Keypair) {
+    EnvironmentManager.JITO_KEYPAIR = auth_key;
+  }
+  static getJitoKeypair(): Keypair {
+    return EnvironmentManager.JITO_KEYPAIR;
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./instructions/build-instruction";
+export * from "./instructions/buy-instruction";
+export * from "./instructions/cache-alt-instruction";
+export * from "./instructions/createATA-instruction";
+export * from "./instructions/createpool-instruction";
+export * from "./instructions/sol-transfer-instruction";
+export * from "./instructions/transfer-instruction";
+export * from "./pool/pool-manager";
+export * from "./transaction/bundle";
+export * from "./transaction/execute-rpc";
+export * from "./transaction/sign-tx";
+export * from "./transaction/transaction-exectue";
+export * from "./utils/budget";
+export * from "./utils/error-helper";
+export * from "./utils/get-balance";
+export * from "./utils/util";
+export * from "./errors";

package/src/instructions/build-instruction.ts

@@ -0,0 +1,87 @@
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  Signer,
+  Transaction,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+import { BuildInstructionError } from "../errors";
+import {
+  LOOKUP_TABLE_CACHE,
+  TxVersion,
+  buildSimpleTransaction
+} from "@raydium-io/raydium-sdk";
+
+export interface TransactionInfo {
+  txn: VersionedTransaction;
+  singer: (Keypair | Signer)[];
+}
+
+export const compileInstToVersioned = async (
+  connection: Connection,
+  payer: Keypair,
+  insts: any[],
+  signer: (Keypair | Signer)[],
+  lookupAddr?: string
+): Promise<TransactionInfo | undefined> => {
+  try {
+    const recentBlockhash = (await connection.getLatestBlockhash("finalized"))
+      .blockhash;
+    if (lookupAddr) {
+      const lookupTableAccount: any = (
+        await connection.getAddressLookupTable(new PublicKey(lookupAddr))
+      ).value;
+
+      const txn = new VersionedTransaction(
+        new TransactionMessage({
+          payerKey: payer.publicKey,
+          instructions: insts,
+          recentBlockhash: recentBlockhash
+        }).compileToV0Message([lookupTableAccount])
+      );
+      return {
+        txn: txn,
+        singer: signer
+      };
+    } else {
+      const txn = new VersionedTransaction(
+        new TransactionMessage({
+          payerKey: payer.publicKey,
+          instructions: insts,
+          recentBlockhash: recentBlockhash
+        }).compileToV0Message()
+      );
+      return {
+        txn: txn,
+        singer: signer
+      };
+    }
+  } catch (error) {
+    throw new BuildInstructionError(`CompileInstToVersioned: ${error}`);
+  }
+};
+
+export const buildInstToVersioned = async (
+  connection: Connection,
+  payer: Keypair,
+  inst: any
+): Promise<(VersionedTransaction | Transaction)[]> => {
+  try {
+    const txn = await buildSimpleTransaction({
+      connection,
+      makeTxVersion: TxVersion.V0,
+      payer: payer.publicKey,
+      innerTransactions: inst,
+      recentBlockhash: (await connection.getLatestBlockhash("finalized"))
+        .blockhash,
+      addLookupTableInfo: LOOKUP_TABLE_CACHE
+    });
+
+    return txn;
+  } catch (error) {
+    throw new BuildInstructionError(`BuildInstToVersioned: ${error}`);
+  }
+};

package/src/instructions/buy-instruction.ts

@@ -0,0 +1,52 @@
+import {
+  Liquidity,
+  ONE,
+  TxVersion,
+  parseBigNumberish
+} from "@raydium-io/raydium-sdk";
+import { Connection, Keypair, TokenAmount } from "@solana/web3.js";
+import { getWalletTokenAccount } from "../utils/get-balance";
+import { getComputeBudgetConfigHigh } from "../utils/budget";
+import { GenerateTransactionError } from "../errors";
+
+export const generateBuyInst = async (
+  connection: Connection,
+  poolKeys: any,
+  buyer: Keypair,
+  inputTokenAmount: any,
+  minAmountOut: any,
+  maxLamports: number = 100000
+): Promise<any> => {
+  try {
+    const tokenAccountInfos = await getWalletTokenAccount(
+      connection,
+      buyer.publicKey
+    );
+
+    const { innerTransactions } = await Liquidity.makeSwapInstructionSimple({
+      connection: connection,
+      poolKeys: { ...poolKeys },
+      userKeys: {
+        tokenAccounts: tokenAccountInfos,
+        owner: buyer.publicKey
+      },
+      amountIn: inputTokenAmount,
+      amountOut: minAmountOut,
+      config: {
+        bypassAssociatedCheck: false
+      },
+      fixedSide: "in",
+      makeTxVersion: TxVersion.V0,
+
+      computeBudgetConfig: {
+        microLamports: maxLamports
+      }
+    });
+
+    const instructions = innerTransactions[0].instructions.filter(Boolean);
+
+    return instructions.slice(1);
+  } catch (error) {
+    throw new GenerateTransactionError(`GenereateBuyInst: ${error}`);
+  }
+};

package/src/instructions/cache-alt-instruction.ts

@@ -0,0 +1,40 @@
+import {
+  AddressLookupTableProgram,
+  Connection,
+  Keypair,
+  PublicKey
+} from "@solana/web3.js";
+import { GenerateTransactionError } from "../errors";
+
+export const generateCreateAltInst = async (
+  connection: Connection,
+  payer: Keypair
+): Promise<any> => {
+  try {
+    return AddressLookupTableProgram.createLookupTable({
+      authority: payer.publicKey,
+      payer: payer.publicKey,
+      recentSlot: await connection.getSlot()
+    });
+  } catch (error) {
+    throw new GenerateTransactionError(`GenerateCreateAltInst: ${error}`);
+  }
+};
+
+export const generateExtendAltInst = (
+  connection: Connection,
+  payer: Keypair,
+  lookupTableAddress: any,
+  addresses: PublicKey[]
+) => {
+  try {
+    return AddressLookupTableProgram.extendLookupTable({
+      payer: payer.publicKey,
+      authority: payer.publicKey,
+      lookupTable: lookupTableAddress,
+      addresses: addresses
+    });
+  } catch (error) {
+    throw new GenerateTransactionError(`GenerateExtendAltInst: ${error}`);
+  }
+};

package/src/instructions/createATA-instruction.ts

@@ -0,0 +1,29 @@
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountInstruction,
+  getAssociatedTokenAddressSync
+} from "@solana/spl-token";
+import { Keypair, PublicKey } from "@solana/web3.js";
+
+export const getCreateAccountTransactionInst = (
+  payer: Keypair,
+  wallet: Keypair,
+  addr: string
+) => {
+  const associatedToken = getAssociatedTokenAddressSync(
+    new PublicKey(addr),
+    wallet.publicKey,
+    true,
+    TOKEN_PROGRAM_ID,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+  return createAssociatedTokenAccountInstruction(
+    payer.publicKey,
+    associatedToken,
+    wallet.publicKey,
+    new PublicKey(addr),
+    TOKEN_PROGRAM_ID,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+};