Getting Started with Dedicated Nodes

Dedicated Nodes with Increased Bandwidth and Reduced Latency

Dashboard Overview

Once you have placed an order for a Dedicated Node you will get access to the overview page which will be your Dedicated Node Hub. This will have all your pending orders and active Nodes. It can be reached by going to the Dedicated Nodes tab on the main dashboard or by clicking here. You will get an email once your node is ready and the status will change to Succeeded.

Dedicated Nodes Dashboard

Order ID and Host ID

Order ID and Host ID are identifiers that can be used when contacting the support team with questions regarding your order (Order ID) or your node (Host ID). Think of them as names for your Node.

URL

The URL is your standard Solana RPC URL which can be used to call RPC methods or used as a websocket by changing https to wss.

gRPC URL & gRPC Token

Your gRPC URL and gRPC Token are used when working with the Geyser Plugin that you chose. There will be code examples further that will explain how to use the gRPC and stream Solana events with minimal latency. All our dedicated nodes are Shredstream enhanced.

Region

This is where your node is located.

Solana version

This is the current version that is running on your node.

Geyser type

This is the Geyser plugin you chose.

Status

Status represents the current state of your node:

• Pending — signifies a pending order for your node

• Underway — your node is being set up

• Succeeded — your node is fully set up

• Failed — your node is down

Archival

Archival is an add-on that gives access to historical Solana data. If you want to enable or disable it, you can contact our support team.

Node Deactivated

This indicates if your node is currently suspended. If a payment is missed, your node will be deactivated automatically. You have a 3-day grace period to reactivate it by completing the payment.

Action Buttons

There are also 4 action buttons on the right that give you full control over your node's lifecycle and performance monitoring.

⬆️ Update Version

• Lets you update or downgrade your node's version

• Use this when you want to update to a newer version

• Important to keep your node up-to-date with latest features and performance updates

📊 Metrics

• Shows your node's performance

• Track things like your response times, requests per second, success and failure rates

• Monitor health and usage with request success rates and error rates

🗑️ Delete Node

• Permanently and immediately removes your node and cancels the subscription

• This cannot be undone and you will have to order a new Node

🔄 Restart Node

• Restarts your node

Working With Your Node

RPC and Websocket

Each dedicated eode comes with an RPC URL that you can use like in the example below.

Here we are using Solana web3.js to call getSlot using our dedicated node:

// Using @solana/web3.js
const { Connection } = require('@solana/web3.js');

const connection = new Connection('https://liveried-grazings-gxzjabdgqa-dedicated.helius-rpc.com?api-key=465964ff-f718-47d2-a51c-66ddcce332d7');

// Get the current slot
const getSlot = async () => {
    const slot = await connection.getSlot();
    console.log('Current slot:', slot);
};

getSlot();

This is how you would set up a native websocket connection to stream new slots:

const Websocket = require('ws');
const ws = new Websocket('wss://liveried-grazings-gxzjabdgqa-dedicated.helius-rpc.com?api-key=465964ff-f718-47d2-a51c-66ddcce332d7	');

ws.onopen = () => {
    ws.send(JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'slotSubscribe'
    }));
};

ws.onmessage = (event) => {
    console.log(JSON.parse(event.data));
};

Set up your Geyser Plugin

To begin using the Geyser plugin you need to clone the Yellowstone repo:

git clone https://github.com/helius-labs/yellowstone-grpc.git

Using the CLI

cd yellowstone-grpc/examples/rust/
cargo run --bin client -- -e "https://liveried-grazings-gxzjabdgqa-dedicated-lb.helius-rpc.com:2053" --x-token 42f03938-1daa-4162-a457-bb551ecaf590 subscribe --slots

Once complete, you should see the terminal output new slots. Don't forget to replace the URL and Token with your own.

Terminal output of new slots.

TypeScript Example

This example streams all Raydium transactions live in JSON format:

import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";
import * as bs58 from 'bs58';

const processBuffers = (obj: any): any =>
  !obj ? obj :
  Buffer.isBuffer(obj) || obj instanceof Uint8Array ? bs58.encode(obj) :
  Array.isArray(obj) ? obj.map(processBuffers) :
  typeof obj === 'object' ? Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, processBuffers(v)])) :
  obj;

const main = async () => {
  const client = new Client("grpc_url", 
    "x_token", 
    { "grpc.max_receive_message_length": 64 * 1024 * 1024 });

  const stream = await client.subscribe();
  const write = (req: SubscribeRequest) => new Promise<void>((resolve, reject) => 
    stream.write(req, (err) => err ? reject(err) : resolve()));

  stream.on("data", (data) => {
    try { console.log(JSON.stringify(processBuffers(data), null, 2)); }
    catch (e) { console.error('Error:', e); }
  });

  await write({
    slots: {},
    accounts: {},
    accountsDataSlice: [],
    transactions: {
      allRaydiumTxs: {
        accountInclude: ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"],
        accountExclude: [],
        accountRequired: [],
      }
    },
    blocks: {},
    blocksMeta: {},
    entry: {},
    commitment: CommitmentLevel.PROCESSED,
  });

  setInterval(() => write({
    ping: { id: 1 },
    accounts: {},
    accountsDataSlice: [],
    transactions: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    slots: {},
  }).catch(console.error), 30000);

  await new Promise<void>((resolve, reject) => {
    stream.on("error", (e) => { console.error("Stream error:", e); reject(e); stream.end(); });
    stream.on("end", resolve);
    stream.on("close", resolve);
  });
};

main().catch(console.error);

Example output of a partial Raydium transaction

Best Practices

Managing Node Load

While nodes don't have strict usage limits, they are bound by hardware constraints. A balanced workload helps maintain optimal performance and node liveliness.

• Avoid mixing heavy account-based calls (e.g. getProgramAccounts, getTokenAccountsByOwner, etc.) with gRPC usage on the same node.

  • It's best to move heavy account-based calls to a shared plan since we have a custom indexer that makes those calls much faster.

• Monitor your node's metrics to understand its performance based on response times, successful request %, and error counts.

• Consider distributing intensive workloads across multiple nodes in a dedicated fleet

If your team needs a cluster of multiple dedicated nodes, contact our sales team. We will take in your requirements and configure a dedicated fleet for your team.

System Recovery

Our nodes include an automatic recovery mechanism:

• If a node falls too far behind in processing slots, it will automatically initiate a restart

• During this recovery period, all requests are seamlessly routed to our shared backup pool

• Once your node catches up and becomes healthy, traffic will resume to it

Questions and Support

• Contact us through your Telegram group (available for dedicated node customers)

• You can also get support from the chat system on our website or in our Discord server