sol-ihor-lab 1.0.0

package/lib/esm/global.js

@@ -0,0 +1,103 @@
+import { DEVNET_PROGRAM_ID, LOOKUP_TABLE_CACHE, MAINNET_PROGRAM_ID } from "@raydium-io/raydium-sdk";
+import { PublicKey } from "@solana/web3.js";
+export var SPL_ERROR;
+(function (SPL_ERROR) {
+    SPL_ERROR[SPL_ERROR["E_INVALID_ARGUE"] = -1] = "E_INVALID_ARGUE";
+    SPL_ERROR[SPL_ERROR["E_OK"] = 0] = "E_OK";
+    SPL_ERROR[SPL_ERROR["E_FAIL"] = 1] = "E_FAIL";
+    SPL_ERROR[SPL_ERROR["E_CHECK_FAIL"] = 2] = "E_CHECK_FAIL";
+    SPL_ERROR[SPL_ERROR["E_SEND_TX_FAIL"] = 3] = "E_SEND_TX_FAIL";
+    SPL_ERROR[SPL_ERROR["E_CONFIRM_TX_FAIL"] = 4] = "E_CONFIRM_TX_FAIL";
+    SPL_ERROR[SPL_ERROR["E_CREATE_META_FAILED"] = 5] = "E_CREATE_META_FAILED";
+    SPL_ERROR[SPL_ERROR["E_TOTAL_MINT_FAIL"] = 6] = "E_TOTAL_MINT_FAIL";
+})(SPL_ERROR || (SPL_ERROR = {}));
+export var NETWORK_MODE;
+(function (NETWORK_MODE) {
+    NETWORK_MODE[NETWORK_MODE["NETWORK_MAIN"] = 0] = "NETWORK_MAIN";
+    NETWORK_MODE[NETWORK_MODE["NETWORK_DEV"] = 1] = "NETWORK_DEV";
+    NETWORK_MODE[NETWORK_MODE["NETWORK_TEST"] = 2] = "NETWORK_TEST";
+})(NETWORK_MODE || (NETWORK_MODE = {}));
+export class EnvironmentManager {
+    static setNetworkMode(mode) {
+        EnvironmentManager.NET_MODE = mode;
+    }
+    static setMainNetURL(url) {
+        EnvironmentManager.RPC_MAIN_URL = url;
+    }
+    static setDevNetURL(url) {
+        EnvironmentManager.RPC_DEVNET_URL = url;
+    }
+    static setTestNettURL(url) {
+        EnvironmentManager.RPC_TESTNET_URL = url;
+    }
+    static getMainNetURL() {
+        return EnvironmentManager.RPC_MAIN_URL;
+    }
+    static getDevNetURL() {
+        return EnvironmentManager.RPC_DEVNET_URL;
+    }
+    static getTestNetURL() {
+        return EnvironmentManager.RPC_TESTNET_URL;
+    }
+    static getNetworkMode() {
+        return EnvironmentManager.NET_MODE;
+    }
+    static getRpcNetUrl() {
+        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, dev_url, test_url) {
+        EnvironmentManager.setMainNetURL(main_url);
+        EnvironmentManager.setDevNetURL(dev_url);
+    }
+    static getBundlrUrl() {
+        return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+            ? "https://node1.bundlr.network"
+            : "https://devnet.bundlr.network";
+    }
+    static getCheckUrl() {
+        return EnvironmentManager.RPC_CHECK_URL;
+    }
+    static getProgramID() {
+        return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+            ? MAINNET_PROGRAM_ID
+            : DEVNET_PROGRAM_ID;
+    }
+    static setQuoteTokenInfo(token_info) {
+        EnvironmentManager.QUOTE_TOKEN_INFO = token_info;
+    }
+    static getQuoteTokenInfo() {
+        return EnvironmentManager.QUOTE_TOKEN_INFO;
+    }
+    static getCacheLTA() {
+        return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+            ? LOOKUP_TABLE_CACHE
+            : undefined;
+    }
+    static getFeeDestinationId() {
+        return EnvironmentManager.getNetworkMode() === NETWORK_MODE.NETWORK_MAIN
+            ? new PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5")
+            : new PublicKey("3XMrhbv989VxAMi3DErLV9eJht1pHppW5LbKxe9fkEFR");
+    }
+    static getJitoBlockEngine() {
+        return EnvironmentManager.JITO_BLOCKENGINE_URL;
+    }
+    static setJitoKeypair(auth_key) {
+        EnvironmentManager.JITO_KEYPAIR = auth_key;
+    }
+    static getJitoKeypair() {
+        return EnvironmentManager.JITO_KEYPAIR;
+    }
+}
+EnvironmentManager.NET_MODE = NETWORK_MODE.NETWORK_MAIN;
+EnvironmentManager.JITO_BLOCKENGINE_URL = "frankfurt.mainnet.block-engine.jito.wtf";
+EnvironmentManager.RPC_CHECK_URL = "http://95.217.82.36:8180";
+EnvironmentManager.RPC_MAIN_URL = "";
+EnvironmentManager.RPC_DEVNET_URL = "";
+EnvironmentManager.RPC_TESTNET_URL = "";

package/lib/esm/index.d.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/lib/esm/index.js

@@ -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/lib/esm/instructions/build-instruction.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair, Signer, Transaction, VersionedTransaction } from "@solana/web3.js";
+export interface TransactionInfo {
+    txn: VersionedTransaction;
+    singer: (Keypair | Signer)[];
+}
+export declare const compileInstToVersioned: (connection: Connection, payer: Keypair, insts: any[], signer: (Keypair | Signer)[], lookupAddr?: string) => Promise<TransactionInfo | undefined>;
+export declare const buildInstToVersioned: (connection: Connection, payer: Keypair, inst: any) => Promise<(VersionedTransaction | Transaction)[]>;

package/lib/esm/instructions/build-instruction.js

@@ -0,0 +1,61 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { BuildInstructionError } from "../errors";
+import { LOOKUP_TABLE_CACHE, TxVersion, buildSimpleTransaction } from "@raydium-io/raydium-sdk";
+export const compileInstToVersioned = (connection, payer, insts, signer, lookupAddr) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const recentBlockhash = (yield connection.getLatestBlockhash("finalized"))
+            .blockhash;
+        if (lookupAddr) {
+            const lookupTableAccount = (yield 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 = (connection, payer, inst) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const txn = yield buildSimpleTransaction({
+            connection,
+            makeTxVersion: TxVersion.V0,
+            payer: payer.publicKey,
+            innerTransactions: inst,
+            recentBlockhash: (yield connection.getLatestBlockhash("finalized"))
+                .blockhash,
+            addLookupTableInfo: LOOKUP_TABLE_CACHE
+        });
+        return txn;
+    }
+    catch (error) {
+        throw new BuildInstructionError(`BuildInstToVersioned: ${error}`);
+    }
+});

package/lib/esm/instructions/buy-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+export declare const generateBuyInst: (connection: Connection, poolKeys: any, buyer: Keypair, inputTokenAmount: any, minAmountOut: any, maxLamports?: number) => Promise<any>;

package/lib/esm/instructions/buy-instruction.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Liquidity, TxVersion } from "@raydium-io/raydium-sdk";
+import { getWalletTokenAccount } from "../utils/get-balance";
+import { GenerateTransactionError } from "../errors";
+export const generateBuyInst = (connection, poolKeys, buyer, inputTokenAmount, minAmountOut, maxLamports = 100000) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const tokenAccountInfos = yield getWalletTokenAccount(connection, buyer.publicKey);
+        const { innerTransactions } = yield Liquidity.makeSwapInstructionSimple({
+            connection: connection,
+            poolKeys: Object.assign({}, 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/lib/esm/instructions/cache-alt-instruction.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+export declare const generateCreateAltInst: (connection: Connection, payer: Keypair) => Promise<any>;
+export declare const generateExtendAltInst: (connection: Connection, payer: Keypair, lookupTableAddress: any, addresses: PublicKey[]) => import("@solana/web3.js").TransactionInstruction;

package/lib/esm/instructions/cache-alt-instruction.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AddressLookupTableProgram } from "@solana/web3.js";
+import { GenerateTransactionError } from "../errors";
+export const generateCreateAltInst = (connection, payer) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return AddressLookupTableProgram.createLookupTable({
+            authority: payer.publicKey,
+            payer: payer.publicKey,
+            recentSlot: yield connection.getSlot()
+        });
+    }
+    catch (error) {
+        throw new GenerateTransactionError(`GenerateCreateAltInst: ${error}`);
+    }
+});
+export const generateExtendAltInst = (connection, payer, lookupTableAddress, addresses) => {
+    try {
+        return AddressLookupTableProgram.extendLookupTable({
+            payer: payer.publicKey,
+            authority: payer.publicKey,
+            lookupTable: lookupTableAddress,
+            addresses: addresses
+        });
+    }
+    catch (error) {
+        throw new GenerateTransactionError(`GenerateExtendAltInst: ${error}`);
+    }
+};

package/lib/esm/instructions/createATA-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Keypair } from "@solana/web3.js";
+export declare const getCreateAccountTransactionInst: (payer: Keypair, wallet: Keypair, addr: string) => import("@solana/web3.js").TransactionInstruction;

package/lib/esm/instructions/createATA-instruction.js

@@ -0,0 +1,6 @@
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, createAssociatedTokenAccountInstruction, getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+export const getCreateAccountTransactionInst = (payer, wallet, addr) => {
+    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);
+};

package/lib/esm/instructions/createpool-instruction.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { ProgramId } from "@raydium-io/raydium-sdk";
+export declare const generateCreatePoolInst: (connection: Connection, owner: Keypair, marketId: PublicKey, baseMint: PublicKey, quoteMint: PublicKey, baseDecimals: number, quoteDecimals: number, baseAmount: number, quoteAmount: number, programId?: ProgramId, delayTime?: number, feeDestinationId?: PublicKey) => Promise<any>;

package/lib/esm/instructions/createpool-instruction.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import { Liquidity, MAINNET_PROGRAM_ID, TxVersion } from "@raydium-io/raydium-sdk";
+import { getWalletTokenAccount, xWeiAmount } from "../utils/get-balance";
+import { BN } from "bn.js";
+import { GenerateTransactionError } from "../errors";
+export const generateCreatePoolInst = (connection, owner, marketId, baseMint, quoteMint, baseDecimals, quoteDecimals, baseAmount, quoteAmount, programId = MAINNET_PROGRAM_ID, delayTime = 0, feeDestinationId = new PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5")) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const tokenAccountInfos = yield getWalletTokenAccount(connection, owner.publicKey);
+        const { innerTransactions } = yield 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/lib/esm/instructions/sol-transfer-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { PublicKey } from "@solana/web3.js";
+export declare const generateSolTransferInst: (from: PublicKey, to: PublicKey, amount: number) => import("@solana/web3.js").TransactionInstruction;

package/lib/esm/instructions/sol-transfer-instruction.js

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

package/lib/esm/instructions/transfer-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { PublicKey } from "@solana/web3.js";
+export declare const generateTransferInst: (sender: PublicKey, fromAccount: PublicKey, toAccount: PublicKey, ca: PublicKey, amount: number, decimal: number) => import("@solana/web3.js").TransactionInstruction;

package/lib/esm/instructions/transfer-instruction.js

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

package/lib/esm/pool/pool-manager.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { LiquidityPoolKeys, Percent, TokenAmount } from "@raydium-io/raydium-sdk";
+import { Connection } from "@solana/web3.js";
+import BN from "bn.js";
+export declare class PoolManager {
+    private poolKey;
+    private poolInfo;
+    private baseToken;
+    private quoteToken;
+    constructor(poolKey: LiquidityPoolKeys);
+    computeSolOut(baseIn: BN): {
+        amountOut: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        minAmountOut: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+        fee: import("@raydium-io/raydium-sdk").CurrencyAmount;
+    } | {
+        amountOut: TokenAmount;
+        minAmountOut: TokenAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+        fee: import("@raydium-io/raydium-sdk").CurrencyAmount;
+    };
+    computeSolIn(baseAmount: BN): {
+        amountIn: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        maxAmountIn: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+    } | {
+        amountIn: TokenAmount;
+        maxAmountIn: TokenAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+    };
+    updateWithReverse(baseReserve: BN, quoteReserve: BN): void;
+    updateWithReal(connection: Connection): Promise<boolean>;
+    getPoolInfo(): any;
+}

package/lib/esm/pool/pool-manager.js

@@ -0,0 +1,63 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Liquidity, Percent, Token, TokenAmount } from "@raydium-io/raydium-sdk";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import BN from "bn.js";
+export class PoolManager {
+    constructor(poolKey) {
+        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)
+        };
+    }
+    computeSolOut(baseIn) {
+        return Liquidity.computeAmountOut({
+            poolKeys: this.poolKey,
+            poolInfo: this.poolInfo,
+            amountIn: new TokenAmount(this.baseToken, baseIn, true),
+            currencyOut: this.quoteToken,
+            slippage: new Percent(1, 100)
+        });
+    }
+    computeSolIn(baseAmount) {
+        return Liquidity.computeAmountIn({
+            poolKeys: this.poolKey,
+            poolInfo: this.poolInfo,
+            amountOut: new TokenAmount(this.baseToken, baseAmount, true),
+            currencyIn: this.quoteToken,
+            slippage: new Percent(1, 100)
+        });
+    }
+    updateWithReverse(baseReserve, quoteReserve) {
+        this.poolInfo = Object.assign(Object.assign({}, this.poolInfo), { baseReserve: baseReserve, quoteReserve: quoteReserve });
+    }
+    updateWithReal(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.poolInfo = yield Liquidity.fetchInfo({
+                    connection,
+                    poolKeys: this.poolKey
+                });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    getPoolInfo() {
+        return this.poolInfo;
+    }
+}

package/lib/esm/pool_manager.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { CurrencyAmount, Token } from "@raydium-io/raydium-sdk";
+import { TOKEN_INFO } from "./global";
+import { PublicKey } from "@solana/web3.js";
+interface PairToken {
+    base_token: Token;
+    quote_token: Token;
+}
+export declare class PoolManager {
+    private base_token_info;
+    private quote_token_info;
+    private base_amount;
+    private quote_amount;
+    private market_id;
+    private pool_info;
+    private pool_keys;
+    constructor(base_token_info: TOKEN_INFO, quote_token_info: TOKEN_INFO, base_amount: number, quote_amount: number, market_id: PublicKey);
+    initializePoolInfo(market_id: PublicKey): void;
+    computeSolAmount(base_amount: number, in_out: boolean): CurrencyAmount;
+    computeCurrentPrice(): number;
+    buyToken(base_amount: number): void;
+    sellToken(base_amount: number): void;
+    getPairToken(): PairToken;
+}
+export {};

package/lib/esm/pool_manager.js

@@ -0,0 +1,123 @@
+import { Liquidity, Percent, TOKEN_PROGRAM_ID, Token, TokenAmount } from "@raydium-io/raydium-sdk";
+import { EnvironmentManager } from "./global";
+import { PublicKey } from "@solana/web3.js";
+import { BN } from "bn.js";
+import { xWeiAmount } from "./utility";
+export class PoolManager {
+    constructor(base_token_info, quote_token_info, base_amount, quote_amount, market_id) {
+        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) {
+        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, in_out) {
+        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() {
+        return this.quote_amount / this.base_amount;
+    }
+    buyToken(base_amount) {
+        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(Math.pow(10, this.quote_token_info.decimal)))
+            .toNumber();
+        this.base_amount -= base_amount;
+        this.pool_info = Object.assign(Object.assign({}, 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) {
+        const sol_input = this.computeSolAmount(base_amount, false);
+        this.quote_amount -= sol_input.raw
+            .div(new BN(Math.pow(10, this.quote_token_info.decimal)))
+            .toNumber();
+        this.base_amount += base_amount;
+        this.initializePoolInfo(this.market_id);
+    }
+    getPairToken() {
+        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 };
+    }
+}