Roboqo Studio
  • Roboqo Studio
  • OVERVIEW
    • Quickstart
    • Fees and Tokens
  • Basics
    • Roboqo Scripts
    • Transactions
    • UI Elements
    • Helper Functions
  • Global Objects
    • Solana Object
    • Positions Object
    • Jito Object
    • Raydium Object
    • Jupiter Object
    • Pumpfun Object
    • Rugcheck Object
    • Warp Object
    • Memes Object
    • Script / CLI
    • Storage Object
  • Instances
    • Solana Transaction
    • Solana Bundle
    • Jito Bundle
    • Solana Position
    • Solana Aggregate Position
Powered by GitBook
On this page
  • Raydium Object Documentation
  • Methods
  • Types
  1. Global Objects

Raydium Object

Raydium global object and helpers.

Raydium Object Documentation

The Raydium class provides methods to interact with the Raydium decentralized exchange on the Solana blockchain. It allows watching for pool creation and swap events, retrieving liquidity pool information, and executing swaps. This class extends the Subscribable class, enabling subscription to Raydium-related events.

Methods

watchCreatePools

Description Watches for the creation of new liquidity pools and invokes a callback when an event occurs.

Signature

public async watchCreatePools(
  callback: (event: RaydiumCreatePool) => void
): Promise<SubscriptionResult>

Parameters

  • callback ((event: RaydiumCreatePool) => void): The callback function to handle pool creation events.

Returns

  • Promise<SubscriptionResult>: The result of the subscription operation.


watchSwaps

Description Watches for swap events and invokes a callback when a swap occurs on Raydium.

Signature

public async watchSwaps(
  callback: (event: RaydiumSwap) => void
): Promise<SubscriptionResult>

Parameters

  • callback ((event: RaydiumSwap) => void): The callback function to handle swap events.

Returns

  • Promise<SubscriptionResult>: The result of the subscription operation.


getLiquidityPools

Description Fetches liquidity pools that match the specified baseMint and optionally a quoteMint.

Signature

public async getLiquidityPools(
  baseMint: PublicKeyOrString,
  quoteMint?: PublicKeyOrString
): Promise<LiquidityPool[]>

Parameters

  • baseMint (PublicKeyOrString): The base mint of the liquidity pool.

  • quoteMint (PublicKeyOrString): Optional. The quote mint of the liquidity pool.

Returns

  • Promise<LiquidityPool[]>: An array of matching liquidity pool objects.

Example Return Value

[
  {
    "id": "pool-id",
    "baseMint": "base-mint-address",
    "quoteMint": "quote-mint-address",
    "lpMint": "lp-mint-address",
    "baseDecimals": 6,
    "quoteDecimals": 6,
    "lpDecimals": 6,
    "version": 4,
    "programId": "program-id",
    "authority": "authority-address",
    "openOrders": "open-orders-address",
    "targetOrders": "target-orders-address",
    "baseVault": "base-vault-address",
    "quoteVault": "quote-vault-address",
    "withdrawQueue": "withdraw-queue-address",
    "lpVault": "lp-vault-address",
    "marketVersion": 3,
    "marketProgramId": "market-program-id",
    "marketId": "market-id",
    "marketAuthority": "market-authority-address",
    "marketBaseVault": "market-base-vault-address",
    "marketQuoteVault": "market-quote-vault-address",
    "marketBids": "market-bids-address",
    "marketAsks": "market-asks-address",
    "marketEventQueue": "market-event-queue-address",
    "lookupTableAccount": "lookup-table-account"
  }
]

swap

Description Performs a token swap on the Raydium decentralized exchange.

Signature

public async swap({
  inputMint,
  outputMint,
  amount,
  autoSlippage,
  computeBudgetMicroLamports,
  computeBudgetUnits,
  priorityFee,
  priorityFeeEstimate,
  slippageBps,
}: RaydiumSwapRequest): Promise<VersionedTransaction>

Parameters

  • inputMint (PublicKeyOrString): The input token's mint address.

  • outputMint (PublicKeyOrString): The output token's mint address.

  • amount (string | number): The amount of the input token to swap.

  • autoSlippage (boolean): Optional. Whether to automatically adjust slippage.

  • computeBudgetMicroLamports (string | number): Optional. Compute budget in micro-lamports.

  • computeBudgetUnits (string | number): Optional. Compute budget in units.

  • priorityFee (string | number): Optional. The priority fee in lamports.

  • priorityFeeEstimate (string): Optional. An estimate of the priority fee.

  • slippageBps (string | number): Optional. The slippage in basis points.

Returns

  • Promise<VersionedTransaction>: A VersionedTransaction object representing the swap transaction.

Example Usage

const swapTx = await raydium.swap({
  inputMint: "So11111111111111111111111111111111111111112", // Example SOL mint address
  outputMint: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Example USDC mint address
  amount: 1000000, // Amount in lamports (1 SOL)
});

Types

LiquidityPool

Represents a Raydium liquidity pool.

type LiquidityPool = {
  id: string;
  baseMint: string;
  quoteMint: string;
  lpMint: string;
  baseDecimals: number;
  quoteDecimals: number;
  lpDecimals: number;
  version: number;
  programId: string;
  authority: string;
  openOrders: string;
  targetOrders: string;
  baseVault: string;
  quoteVault: string;
  withdrawQueue: string;
  lpVault: string;
  marketVersion: number;
  marketProgramId: string;
  marketId: string;
  marketAuthority: string;
  marketBaseVault: string;
  marketQuoteVault: string;
  marketBids: string;
  marketAsks: string;
  marketEventQueue: string;
  lookupTableAccount: string;
};

RaydiumSwapRequest

Request type for performing a Raydium swap.

type RaydiumSwapRequest = {
  inputMint: PublicKeyOrString;
  outputMint: PublicKeyOrString;
  amount: string | number;
  slippageBps?: string | number;
  autoSlippage?: boolean;
  computeBudgetMicroLamports?: string | number;
  computeBudgetUnits?: string | number;
  priorityFee?: string | number;
  priorityFeeEstimate?: string;
};

RaydiumSwap

Represents a Raydium swap event.

type RaydiumSwap = {
  service: "raydium";
  event: "swap";
  transaction: VersionedTransactionResponse;
  instruction: {
    name: string;
    args: {
      amountIn: number;
      minimumAmountOut: number;
    };
  };
  pool: LiquidityPool;
  swap: {
    inToken: {
      mint: string;
      amount: number;
      uiAmount: string;
      decimals: number;
    };
    outToken: {
      mint: string;
      amount: string;
      uiAmount: string;
      decimals: number;
    };
  };
};

RaydiumCreatePoolDetails

Represents details of a Raydium pool creation event.

type RaydiumCreatePoolDetails = {
  amm: string;
  amm_authority: string;
  amm_open_orders: string;
  lp_mint_address: string;
  coin_mint_address: string;
  pc_mint_address: string;
  pool_coin_token_account: string;
  pool_pc_token_account: string;
  pool_withdraw_queue: string;
  pool_target_orders_account: string;
  user_lp_token_account: string;
  pool_temp_lp_token_account: string;
  serum_market: string;
  user_wallet: string;
  user_token_coin: string;
  user_token_pc: string;
  initialBalance: number;
  startTime: Date;
};

RaydiumCreatePool

Represents a Raydium pool creation event.

type RaydiumCreatePool = {
  service: "raydium";
  event: "create-pool";
  pool: RaydiumCreatePoolDetails;
  transaction: ParsedTransaction;
};
PreviousJito ObjectNextJupiter Object

Last updated 5 months ago