sol-ihor-lab 1.0.0

package/src/instructions/createpool-instruction.ts

@@ -0,0 +1,72 @@
+import { Connection, Keypair, PublicKey, TokenAmount } from "@solana/web3.js";
+import {
+  LOOKUP_TABLE_CACHE,
+  Liquidity,
+  MAINNET_PROGRAM_ID,
+  ProgramId,
+  Token,
+  TxVersion
+} from "@raydium-io/raydium-sdk";
+import { getWalletTokenAccount, xWeiAmount } from "../utils/get-balance";
+import { BN } from "bn.js";
+import { getComputeBudgetConfig } from "../utils/budget";
+import { GenerateTransactionError } from "../errors";
+
+export const generateCreatePoolInst = async (
+  connection: Connection,
+  owner: Keypair,
+  marketId: PublicKey,
+  baseMint: PublicKey,
+  quoteMint: PublicKey,
+  baseDecimals: number,
+  quoteDecimals: number,
+  baseAmount: number,
+  quoteAmount: number,
+  programId: ProgramId = MAINNET_PROGRAM_ID,
+  delayTime: number = 0,
+  feeDestinationId: PublicKey = new PublicKey(
+    "7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5"
+  )
+): Promise<any> => {
+  try {
+    const tokenAccountInfos = await getWalletTokenAccount(
+      connection,
+      owner.publicKey
+    );
+
+    const { innerTransactions } =
+      await Liquidity.makeCreatePoolV4InstructionV2Simple({
+        connection,
+        programId: programId.AmmV4,
+        marketInfo: {
+          programId: programId.OPENBOOK_MARKET,
+          marketId: marketId
+        },
+        associatedOnly: false,
+        ownerInfo: {
+          feePayer: owner.publicKey,
+          wallet: owner.publicKey,
+          tokenAccounts: tokenAccountInfos,
+          useSOLBalance: true
+        },
+        baseMintInfo: {
+          mint: baseMint,
+          decimals: baseDecimals
+        },
+        quoteMintInfo: {
+          mint: quoteMint,
+          decimals: quoteDecimals
+        },
+        startTime: new BN(Math.floor(Date.now() / 1000) + delayTime),
+        baseAmount: xWeiAmount(baseAmount, baseDecimals),
+        quoteAmount: xWeiAmount(quoteAmount, quoteDecimals),
+        checkCreateATAOwner: true,
+        makeTxVersion: TxVersion.V0,
+        feeDestinationId: feeDestinationId
+      });
+
+    return innerTransactions;
+  } catch (error) {
+    throw new GenerateTransactionError(`GenerateCreatePoolInst: ${error}`);
+  }
+};

package/src/instructions/sol-transfer-instruction.ts

@@ -0,0 +1,13 @@
+import { LAMPORTS_PER_SOL, PublicKey, SystemProgram } from "@solana/web3.js";
+
+export const generateSolTransferInst = (
+  from: PublicKey,
+  to: PublicKey,
+  amount: number
+) => {
+  return SystemProgram.transfer({
+    fromPubkey: from,
+    toPubkey: to,
+    lamports: Math.floor(amount * LAMPORTS_PER_SOL)
+  });
+};

package/src/instructions/transfer-instruction.ts

@@ -0,0 +1,22 @@
+import { createTransferCheckedInstruction } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+
+export const generateTransferInst = (
+  sender: PublicKey,
+  fromAccount: PublicKey,
+  toAccount: PublicKey,
+  ca: PublicKey,
+  amount: number,
+  decimal: number
+) => {
+  const txn = createTransferCheckedInstruction(
+    fromAccount,
+    ca,
+    toAccount,
+    sender,
+    amount,
+    decimal
+  );
+
+  return txn;
+};

package/src/pool/pool-manager.ts

@@ -0,0 +1,85 @@
+import {
+  Liquidity,
+  LiquidityPoolInfo,
+  LiquidityPoolKeys,
+  Percent,
+  Token,
+  TokenAmount
+} from "@raydium-io/raydium-sdk";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { Connection, PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+
+export class PoolManager {
+  private poolKey: LiquidityPoolKeys;
+  private poolInfo: any;
+  private baseToken: Token;
+  private quoteToken: Token;
+
+  constructor(poolKey: LiquidityPoolKeys) {
+    this.poolKey = poolKey;
+
+    this.baseToken = new Token(
+      TOKEN_PROGRAM_ID,
+      poolKey.baseMint,
+      poolKey.baseDecimals
+    );
+    this.quoteToken = new Token(
+      TOKEN_PROGRAM_ID,
+      poolKey.quoteMint,
+      poolKey.quoteDecimals
+    );
+
+    this.poolInfo = {
+      baseDecimals: poolKey.baseDecimals,
+      quoteDecimals: poolKey.baseDecimals,
+      baseReserve: new BN(0),
+      quoteReserve: new BN(0)
+    };
+  }
+
+  public computeSolOut(baseIn: BN) {
+    return Liquidity.computeAmountOut({
+      poolKeys: this.poolKey,
+      poolInfo: this.poolInfo,
+      amountIn: new TokenAmount(this.baseToken, baseIn, true),
+      currencyOut: this.quoteToken,
+      slippage: new Percent(1, 100)
+    });
+  }
+
+  public computeSolIn(baseAmount: BN) {
+    return Liquidity.computeAmountIn({
+      poolKeys: this.poolKey,
+      poolInfo: this.poolInfo,
+      amountOut: new TokenAmount(this.baseToken, baseAmount, true),
+      currencyIn: this.quoteToken,
+      slippage: new Percent(1, 100)
+    });
+  }
+
+  public updateWithReverse(baseReserve: BN, quoteReserve: BN) {
+    this.poolInfo = {
+      ...this.poolInfo,
+      baseReserve: baseReserve,
+      quoteReserve: quoteReserve
+    };
+  }
+
+  public async updateWithReal(connection: Connection) {
+    try {
+      this.poolInfo = await Liquidity.fetchInfo({
+        connection,
+        poolKeys: this.poolKey
+      });
+
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  public getPoolInfo() {
+    return this.poolInfo;
+  }
+}

package/src/pool_manager.ts

@@ -0,0 +1,197 @@
+import {
+  CurrencyAmount,
+  Liquidity,
+  LiquidityPoolInfo,
+  Percent,
+  TOKEN_PROGRAM_ID,
+  Token,
+  TokenAmount
+} from "@raydium-io/raydium-sdk";
+import { EnvironmentManager, TOKEN_INFO } from "./global";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getMint } from "@solana/spl-token";
+import { BN } from "bn.js";
+import { Market } from "@project-serum/serum";
+import { xWeiAmount } from "./utility";
+
+interface PairToken {
+  base_token: Token;
+  quote_token: Token;
+}
+
+export class PoolManager {
+  private base_token_info: TOKEN_INFO;
+  private quote_token_info: TOKEN_INFO;
+  private base_amount: number;
+  private quote_amount: number;
+  private market_id: PublicKey;
+  private pool_info: LiquidityPoolInfo;
+  private pool_keys: any;
+
+  constructor(
+    base_token_info: TOKEN_INFO,
+    quote_token_info: TOKEN_INFO,
+    base_amount: number,
+    quote_amount: number,
+    market_id: PublicKey
+  ) {
+    this.base_token_info = base_token_info;
+    this.quote_token_info = quote_token_info;
+    this.base_amount = base_amount;
+    this.quote_amount = quote_amount;
+    this.market_id = market_id;
+
+    const { base_token, quote_token } = this.getPairToken();
+
+    this.pool_keys = Liquidity.getAssociatedPoolKeys({
+      version: 4,
+      marketVersion: 3,
+      baseMint: base_token.mint,
+      quoteMint: quote_token.mint,
+      baseDecimals: base_token.decimals,
+      quoteDecimals: quote_token.decimals,
+      marketId: this.market_id,
+      programId: EnvironmentManager.getProgramID().AmmV4,
+      marketProgramId: EnvironmentManager.getProgramID().OPENBOOK_MARKET
+    });
+
+    this.pool_info = {
+      status: new BN(0),
+      baseDecimals: this.base_token_info.decimal,
+      lpDecimals: this.quote_token_info.decimal,
+      quoteDecimals: this.quote_token_info.decimal,
+      baseReserve: xWeiAmount(this.base_amount, this.base_token_info.decimal),
+      quoteReserve: xWeiAmount(
+        this.quote_amount,
+        this.quote_token_info.decimal
+      ),
+      lpSupply: new BN(base_amount),
+      startTime: new BN(0)
+    };
+  }
+
+  initializePoolInfo(market_id: PublicKey) {
+    this.market_id = market_id;
+    const { base_token, quote_token } = this.getPairToken();
+    this.pool_keys = Liquidity.getAssociatedPoolKeys({
+      version: 4,
+      marketVersion: 3,
+      baseMint: base_token.mint,
+      quoteMint: quote_token.mint,
+      baseDecimals: base_token.decimals,
+      quoteDecimals: quote_token.decimals,
+      marketId: this.market_id,
+      programId: EnvironmentManager.getProgramID().AmmV4,
+      marketProgramId: EnvironmentManager.getProgramID().OPENBOOK_MARKET
+    });
+
+    this.pool_info = {
+      status: new BN(0),
+      baseDecimals: this.base_token_info.decimal,
+      lpDecimals: this.quote_token_info.decimal,
+      quoteDecimals: this.quote_token_info.decimal,
+      baseReserve: xWeiAmount(this.base_amount, this.base_token_info.decimal),
+      quoteReserve: xWeiAmount(
+        this.quote_amount,
+        this.quote_token_info.decimal
+      ),
+      lpSupply: new BN(this.base_amount),
+      startTime: new BN(0)
+    };
+
+    console.log(
+      "Simulated Pool baseReserve: ",
+      this.pool_info.baseReserve.toString()
+    );
+    console.log(
+      "Simulated Pool quoteReserve: ",
+      this.pool_info.quoteReserve.toString()
+    );
+  }
+
+  computeSolAmount(base_amount: number, in_out: boolean): CurrencyAmount {
+    const { base_token, quote_token } = this.getPairToken();
+    // console.log("Simulated PoolInfo: ", this.pool_info);
+    if (in_out) {
+      const { maxAmountIn } = Liquidity.computeAmountIn({
+        poolKeys: this.pool_keys,
+        poolInfo: this.pool_info,
+        amountOut: new TokenAmount(base_token, base_amount, false),
+        currencyIn: quote_token,
+        slippage: new Percent(1, 100)
+      });
+      return maxAmountIn;
+    } else {
+      const { minAmountOut } = Liquidity.computeAmountOut({
+        poolKeys: this.pool_keys,
+        poolInfo: this.pool_info,
+        amountIn: new TokenAmount(base_token, base_amount, false),
+        currencyOut: quote_token,
+        slippage: new Percent(1, 100)
+      });
+      return minAmountOut;
+    }
+  }
+  computeCurrentPrice(): number {
+    return this.quote_amount / this.base_amount;
+  }
+  buyToken(base_amount: number) {
+    const sol_input = this.computeSolAmount(base_amount, true);
+    const { base_token, quote_token } = this.getPairToken();
+    const { amountOut } = Liquidity.computeAmountOut({
+      poolKeys: this.pool_keys,
+      poolInfo: this.pool_info,
+      amountIn: sol_input,
+      currencyOut: base_token,
+      slippage: new Percent(1, 100)
+    });
+    this.quote_amount += sol_input.raw
+      .div(new BN(10 ** this.quote_token_info.decimal))
+      .toNumber();
+    this.base_amount -= base_amount;
+    this.pool_info = {
+      ...this.pool_info,
+      baseReserve: this.pool_info.baseReserve.sub(amountOut.raw),
+      quoteReserve: this.pool_info.quoteReserve.add(sol_input.raw)
+    };
+
+    console.log(
+      "Simulated Pool baseReserve: ",
+      this.pool_info.baseReserve.toString()
+    );
+    console.log(
+      "Simulated Pool quoteReserve: ",
+      this.pool_info.quoteReserve.toString()
+    );
+
+    // this.initializePoolInfo(this.market_id);
+  }
+  sellToken(base_amount: number) {
+    const sol_input = this.computeSolAmount(base_amount, false);
+    this.quote_amount -= sol_input.raw
+      .div(new BN(10 ** this.quote_token_info.decimal))
+      .toNumber();
+    this.base_amount += base_amount;
+    this.initializePoolInfo(this.market_id);
+  }
+  getPairToken(): PairToken {
+    const base_mint = new PublicKey(this.base_token_info.address);
+    const base = new Token(
+      TOKEN_PROGRAM_ID,
+      base_mint,
+      this.base_token_info.decimal,
+      this.base_token_info.symbol,
+      this.base_token_info.name
+    );
+
+    const quote = new Token(
+      TOKEN_PROGRAM_ID,
+      new PublicKey(this.quote_token_info.address),
+      this.quote_token_info.decimal,
+      this.quote_token_info.symbol,
+      this.quote_token_info.name
+    );
+
+    return { base_token: base, quote_token: quote };
+  }
+}

package/src/sell_token.ts

@@ -0,0 +1,82 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR, TX_RET } from "./global";
+import { TOKEN_PROGRAM_ID, getMint } from "@solana/spl-token";
+import {
+  Liquidity,
+  LiquidityPoolKeys,
+  Token,
+  TokenAmount,
+  TxVersion,
+  buildSimpleTransaction
+} from "@raydium-io/raydium-sdk";
+import { getWalletAccounts } from "./utility";
+
+export const sellToken = async (
+  connection: Connection,
+  buyer: Keypair,
+  token_address: string,
+  base_amount: number,
+  quote_amount: number,
+  pool_key: LiquidityPoolKeys
+): Promise<TX_RET> => {
+  if (token_address.length <= 0 || base_amount <= 0) {
+    console.error("Error: [Buy Token] invalid argument iput!!!");
+    return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+  }
+
+  try {
+    const token_mint = new PublicKey(token_address);
+    const token_info = await getMint(connection, token_mint);
+    const base_token = new Token(
+      TOKEN_PROGRAM_ID,
+      token_address,
+      token_info.decimals
+    );
+    const quote_info = EnvironmentManager.getQuoteTokenInfo();
+    const quote_token = new Token(
+      TOKEN_PROGRAM_ID,
+      quote_info.address,
+      quote_info.decimal,
+      quote_info.symbol,
+      quote_info.name
+    );
+    const base_token_amount = new TokenAmount(base_token, base_amount, false);
+    const quote_token_amount = new TokenAmount(
+      quote_token,
+      quote_amount === 0 ? 1 : quote_amount,
+      quote_amount === 0 ? true : false
+    );
+
+    const wallet_token_accounts = await getWalletAccounts(
+      connection,
+      buyer.publicKey
+    );
+
+    const { innerTransactions } = await Liquidity.makeSwapInstructionSimple({
+      connection: connection,
+      poolKeys: pool_key,
+      userKeys: {
+        tokenAccounts: wallet_token_accounts,
+        owner: buyer.publicKey
+      },
+      amountIn: base_token_amount,
+      amountOut: quote_token_amount,
+      fixedSide: "in",
+      makeTxVersion: TxVersion.V0
+    });
+
+    const transactions = await buildSimpleTransaction({
+      connection: connection,
+      makeTxVersion: TxVersion.V0,
+      payer: buyer.publicKey,
+      innerTransactions: innerTransactions,
+      addLookupTableInfo: EnvironmentManager.getCacheLTA(),
+      recentBlockhash: (await connection.getLatestBlockhash()).blockhash
+    });
+
+    return { result: SPL_ERROR.E_OK, value: transactions };
+  } catch (error) {
+    console.error("Error: [buy Tokens] error code: ", error);
+    return { result: SPL_ERROR.E_FAIL, value: undefined };
+  }
+};

package/src/transaction/bundle.ts

@@ -0,0 +1,116 @@
+import {
+  Connection,
+  Keypair,
+  LAMPORTS_PER_SOL,
+  PublicKey
+} from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+import { searcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
+import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
+import base58 from "bs58";
+import { TransactionExecuteError } from "../errors";
+import { sleep } from "../utils/util";
+import { signTransaction } from "./sign-tx";
+
+export async function createAndSendBundle(
+  connection: Connection,
+  bundleTranasction: TransactionInfo[],
+  payer: Keypair,
+  jitoBlockEngine: string,
+  jitoAuther: Keypair,
+  fee: number
+) {
+  const searcher = searcherClient(jitoBlockEngine, jitoAuther);
+
+  let txnConfirmResult: boolean = false;
+  let breakCheckTransactionStatus: boolean = false;
+
+  try {
+    const blockhash = (await connection.getLatestBlockhash("finalized"))
+      .blockhash;
+    const realForBundle: any[] = [];
+    for (let i = 0; i < bundleTranasction.length; i++) {
+      bundleTranasction[i].txn.message.recentBlockhash = (
+        await connection.getLatestBlockhash("finalized")
+      ).blockhash;
+      signTransaction(bundleTranasction[i]);
+      realForBundle.push(bundleTranasction[i].txn);
+    }
+
+    let bundleTx = new Bundle(realForBundle, 5);
+    if (payer) {
+      const tipAccount = new PublicKey((await searcher.getTipAccounts())[0]);
+      bundleTx.addTipTx(payer, fee * LAMPORTS_PER_SOL, tipAccount, blockhash);
+    }
+
+    searcher.onBundleResult(
+      async (bundleResult: any) => {
+        console.log(bundleResult);
+
+        if (bundleResult.rejected) {
+          try {
+            if (
+              bundleResult.rejected.simulationFailure.msg.includes(
+                "custom program error"
+              ) ||
+              bundleResult.rejected.simulationFailure.msg.includes(
+                "Error processing Instruction"
+              )
+            ) {
+              breakCheckTransactionStatus = true;
+            } else if (
+              bundleResult.rejected.simulationFailure.msg.includes(
+                "This transaction has already been processed"
+              ) ||
+              bundleResult.rejected.droppedBundle.msg.includes(
+                "Bundle partially processed"
+              )
+            ) {
+              txnConfirmResult = true;
+              breakCheckTransactionStatus = true;
+            }
+          } catch (error) {}
+        }
+      },
+      (error) => {
+        breakCheckTransactionStatus = false;
+      }
+    );
+
+    console.log("Send");
+    await searcher.sendBundle(bundleTx);
+    console.log("Finish send");
+    setTimeout(() => {
+      breakCheckTransactionStatus = true;
+    }, 20000);
+
+    const txnHash = base58.encode(
+      realForBundle[realForBundle.length - 1].signatures[0]
+    );
+
+    console.log(txnHash);
+    while (!breakCheckTransactionStatus) {
+      await sleep(1000);
+      try {
+        const result = await connection.getSignatureStatus(txnHash, {
+          searchTransactionHistory: true
+        });
+        if (result && result.value && result.value.confirmationStatus) {
+          txnConfirmResult = true;
+          breakCheckTransactionStatus = true;
+        }
+      } catch (error) {
+        txnConfirmResult = false;
+        breakCheckTransactionStatus = false;
+      }
+    }
+
+    if (txnConfirmResult) {
+      return true;
+    } else {
+      throw new TransactionExecuteError(`Bundle Error: failed`);
+    }
+  } catch (error) {
+    throw new TransactionExecuteError(`Bundle Error: ${error}`);
+  }
+}

package/src/transaction/execute-rpc.ts

@@ -0,0 +1,35 @@
+import {
+  Connection,
+  SendOptions,
+  TransactionConfirmationStrategy
+} from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+import { signTransaction } from "./sign-tx";
+import { TransactionExecuteError } from "../errors";
+
+export async function sendTx(
+  connection: Connection,
+  tx: TransactionInfo,
+  option?: SendOptions
+): Promise<string> {
+  try {
+    tx.txn.message.recentBlockhash = (
+      await connection.getLatestBlockhash("finalized")
+    ).blockhash;
+    signTransaction(tx);
+    return await connection.sendTransaction(tx.txn, option);
+  } catch (error) {
+    throw new TransactionExecuteError(`sendTx: ${error}`);
+  }
+}
+
+export async function confirmTx(connection: Connection, txId: string) {
+  try {
+    await connection.confirmTransaction({
+      signature: txId,
+      abortSignal: AbortSignal.timeout(60000)
+    } as TransactionConfirmationStrategy);
+  } catch (error) {
+    throw new TransactionExecuteError(`confirmTx: ${error}`);
+  }
+}

package/src/transaction/sign-tx.ts

@@ -0,0 +1,5 @@
+import { TransactionInfo } from "../instructions/build-instruction";
+
+export function signTransaction(tx: TransactionInfo) {
+  tx.txn.sign(tx.singer);
+}