Helius

https://www.helius.dev/docs
Admin
Helius is a high-performance Solana development platform providing RPC infrastructure, real-time...
Tokens:792,052
Snippets:5,776
Trust Score:9.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and Start Zolana CLI

Source: https://www.helius.dev/docs/privacy/endpoints

Installs the Zolana CLI from the specified GitHub tag and starts the local development environment.

```bash
cargo install --git https://github.com/helius-labs/zolana --tag v0.1.0-alpha zolana-cli
zolana dev start
```

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

### Install Laserstream Go SDK

Source: https://www.helius.dev/docs/laserstream/clients

Use the go get command to install the Laserstream SDK package.

```bash
go get github.com/helius-labs/laserstream-sdk/go
```

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

### Setup project and install dependencies

Source: https://www.helius.dev/docs/laserstream/guides/stream-pump-amm-data

Initialize a new Node.js project, install the required Helius LaserStream SDK and bs58 library, and configure the environment variable for the API key.

```bash
mkdir pump-monitor && cd pump-monitor
npm init -y
npm install helius-laserstream bs58
npm install --save-dev typescript ts-node @types/node
npx tsc --init
export HELIUS_API_KEY=your-key-here
```

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

### Run the install script

Source: https://www.helius.dev/docs/agents/skills/build

Execute the installation script to install the skill and reference files. Options include --project for local installation or --path for a custom directory.

```bash
./install.sh
```

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

### Setup Rust project and dependencies

Source: https://www.helius.dev/docs/laserstream/guides/measuring-latency

Commands to install Rust, initialize a new project, and configure the Cargo.toml file with required dependencies for gRPC streaming and latency analysis.

```bash
# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Setup project
cargo new latency-testing
cd latency-testing

# Add dependencies to Cargo.toml
[dependencies]
# Async runtime
tokio = { version = "1", features = ["full"] }
# Futures utilities for StreamExt, SinkExt
futures = "0.3"
# Environment variable loading
dotenvy = "0.15"
# Logging
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
# Yellowstone gRPC client and protocol
yellowstone-grpc-client = "8.0.0"
yellowstone-grpc-proto = "8.0.0"
# For timestamp analysis
prost-types = "0.12"
```

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

### Quick Start with LaserStream SDK

Source: https://www.helius.dev/docs/laserstream/clients

Example of initializing a subscription with LaserStream, including configuration and transaction filtering. The SDK automatically manages reconnection and data replay.

```typescript
import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

async function streamTransactions() {
  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  };

  const request: SubscribeRequest = {
    transactions: {
      "jupiter-filter": { // user-defined label for this filter
        accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'], // Jupiter Program
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {},
    slots: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: []
  };

  // The SDK handles reconnection and replay automatically
  await subscribe(config, request, 
    async (data) => {
      console.log('New transaction:', data);
    }, 
    async (error) => {
      console.error('Error:', error);
    }
  );
}

streamTransactions().catch(console.error);
```

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

### Install OKX CLI

Source: https://www.helius.dev/docs/agents/skills/okx

Downloads and installs the onchainos CLI tool.

```bash
curl -fsSL https://raw.githubusercontent.com/okx/onchainos-skills/main/install.sh | bash
```

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

### Install Dependencies

Source: https://www.helius.dev/docs/rpc/websocket/stream-pump-amm-data

Install the required 'ws' library for WebSocket communication.

```bash
npm install ws
```

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

### Install helius-wallet-kit

Source: https://www.helius.dev/docs/waas/quickstart

Install the required package using pnpm.

```bash
pnpm add helius-wallet-kit
```

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

### Run Full Example

Source: https://www.helius.dev/docs/privacy/guides/read-balance

Clone the example repository and run the deposit, transfer, and withdraw demonstration.

```bash
git clone https://github.com/helius-labs/zolana-examples.git
cd zolana-examples/rust-client
cargo run -p rust-client-example --example deposit_transfer_withdraw
```

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

### Run Full Example

Source: https://www.helius.dev/docs/privacy/guides/read-balance

Clone the examples repository and execute the deposit, transfer, and withdraw workflow.

```bash
git clone https://github.com/helius-labs/zolana-examples.git
cd zolana-examples/typescript-client
pnpm install
pnpm example examples/deposit_transfer_withdraw.ts
```

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

### getSignaturesForAddress Request Example

Source: https://www.helius.dev/docs/api-reference/rpc/http/getsignaturesforaddress

Example of a JSON-RPC request to get signatures for a specific address with a limit parameter.

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "Vote111111111111111111111111111111111111111",
    {
      "limit": 1
    }
  ]
}
```

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

### Get Estimated Time of a Specific Block (JavaScript)

Source: https://www.helius.dev/docs/rpc/guides/getblocktime

Example using JavaScript with the @solana/web3.js library to get the estimated block production time.

```APIDOC
## GET /getBlockTime (JavaScript Example)

### Description
This JavaScript example uses the `@solana/web3.js` library to connect to the Helius RPC and retrieve the estimated production time for a given block slot.

### Method
POST (via @solana/web3.js Connection)

### Endpoint
https://mainnet.helius-rpc.com/?api-key=<api-key>

### Parameters
#### Function Parameters
- **slotToQuery** (number) - Required - The slot number of the block for which to retrieve the estimated production time.

### Request Example
```javascript
const { Connection } = require('@solana/web3.js');

async function getSpecificBlockTime(slotToQuery) {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  try {
    const blockTime = await connection.getBlockTime(slotToQuery);
    if (blockTime !== null) {
      console.log(`Estimated time for slot ${slotToQuery}: ${new Date(blockTime * 1000).toISOString()} (Unix: ${blockTime})`);
    } else {
      console.log(`Timestamp not available for slot ${slotToQuery}.`);
    }
  } catch (error) {
    console.error('Error fetching block time:', error);
  }
}

// Example usage: Replace with a recent, valid slot number from Mainnet Beta
const slotToQuery = 300000000; // Replace with an actual slot number
getSpecificBlockTime(slotToQuery);
```

### Response
#### Success Response
- **blockTime** (number | null) - The estimated production time as a Unix timestamp (seconds since the Unix epoch), or `null` if not available.
```

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

### Set up the development environment

Source: https://www.helius.dev/docs/sending-transactions/jupiter-swap-api-via-sender

Initialize the TypeScript project and install necessary dependencies.

```bash
npx tsc --init
npm install @solana/web3.js bs58
npm install --save-dev @types/node
```

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

### Complete implementation with multiple priority levels

Source: https://www.helius.dev/docs/priority-fee/estimating-fees-using-account-keys

A full example demonstrating how to initialize a connection, define account keys, fetch estimates for various priority levels, and retrieve all levels simultaneously using a helper function.

```javascript
const { 
    Connection, 
    PublicKey, 
    Transaction, 
    ComputeBudgetProgram 
  } = require("@solana/web3.js");

  // Initialize connection
  const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");

  async function analyzeAccountPriorityFees() {
    // Define accounts involved in your transaction
    const accountKeys = [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
      "YOUR_WALLET_ADDRESS",                          // Your wallet
      "TOKEN_ACCOUNT_ADDRESS",                        // Token account
      "RECIPIENT_ADDRESS"                             // Recipient
    ];
    
    try {
      // Get estimates for different priority levels
      const [lowFee, mediumFee, highFee, veryHighFee] = await Promise.all([
        getPriorityFeeEstimate(connection, accountKeys, "Low"),
        getPriorityFeeEstimate(connection, accountKeys, "Medium"), 
        getPriorityFeeEstimate(connection, accountKeys, "High"),
        getPriorityFeeEstimate(connection, accountKeys, "VeryHigh")
      ]);
      
      console.log("Priority Fee Estimates:");
      console.log(`Low:      ${lowFee} micro-lamports`);
      console.log(`Medium:   ${mediumFee} micro-lamports`);
      console.log(`High:     ${highFee} micro-lamports`);
      console.log(`VeryHigh: ${veryHighFee} micro-lamports`);
      
      // Get all levels at once for comparison
      const allLevels = await getAllPriorityLevels(connection, accountKeys);
      console.log("\nAll priority levels:", allLevels);
      
      return {
        low: lowFee,
        medium: mediumFee,
        high: highFee,
        veryHigh: veryHighFee,
        allLevels
      };
    } catch (error) {
      console.error("Error getting priority fees:", error);
      throw error;
    }
  }

  // Helper function to get all priority levels
  async function getAllPriorityLevels(connection, accountKeys) {
    const response = await fetch(connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          accountKeys: accountKeys,
          options: { 
            includeAllPriorityFeeLevels: true
          }
        }]
      })
    });
    
    const result = await response.json();
    
    if (result.error) {
      throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
    }
    
    return result.result.priorityFeeLevels;
  }

  // Run the analysis
  analyzeAccountPriorityFees();
```

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

### Get Blocks from a Start Slot to Latest via cURL

Source: https://www.helius.dev/docs/rpc/guides/getblocks

Fetches confirmed block slots starting from 260,000,000 up to the latest confirmed block.

```bash
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlocks",
    "params": [
      260000000 
    ]
  }'
```

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

### Get Asset Success Response Example

Source: https://www.helius.dev/docs/api-reference/das/getasset

A JSON response example demonstrating a successful retrieval of asset details, including metadata, ownership, and token information.

```json
{
  "jsonrpc": "2.0",
  "id": "test",
  "result": {
    "last_indexed_slot": 365749093,
    "interface": "ProgrammableNFT",
    "id": "F9Lw3ki3hJ7PF9HQXsBzoY8GyE6sPoEZZdXJBsTTD2rk",
    "content": {
      "$schema": "https://schema.metaplex.com/nft1.0.json",
      "json_uri": "https://madlads.s3.us-west-2.amazonaws.com/json/8420.json",
      "files": [
        {
          "uri": "https://madlads.s3.us-west-2.amazonaws.com/images/8420.png",
          "cdn_uri": "https://cdn.helius-rpc.com/cdn-cgi/image//https://madlads.s3.us-west-2.amazonaws.com/images/8420.png",
          "mime": "image/png"
        },
        {
          "uri": "https://arweave.net/qJ5B6fx5hEt4P7XbicbJQRyTcbyLaV-OQNA1KjzdqOQ/0.png",
          "cdn_uri": "https://cdn.helius-rpc.com/cdn-cgi/image//https://arweave.net/qJ5B6fx5hEt4P7XbicbJQRyTcbyLaV-OQNA1KjzdqOQ/0.png",
          "mime": "image/png"
        }
      ],
      "metadata": {
        "attributes": [
          { "value": "Male", "trait_type": "Gender" },
          { "value": "King", "trait_type": "Type" },
          { "value": "Royal", "trait_type": "Expression" },
          { "value": "Mad Crown", "trait_type": "Hat" },
          { "value": "Madness", "trait_type": "Eyes" },
          { "value": "Mad Armor", "trait_type": "Clothing" },
          { "value": "Royal Rug", "trait_type": "Background" }
        ],
        "description": "Fock it.",
        "name": "Mad Lads #8420",
        "symbol": "MAD",
        "token_standard": "ProgrammableNonFungible"
      },
      "links": {
        "image": "https://madlads.s3.us-west-2.amazonaws.com/images/8420.png",
        "external_url": "https://madlads.com"
      }
    },
    "authorities": [
      { "address": "2RtGg6fsFiiF1EQzHqbd66AhW7R5bWeQGpTbv2UMkCdW", "scopes": ["full"] }
    ],
    "compression": {
      "eligible": false,
      "compressed": false,
      "data_hash": "",
      "creator_hash": "",
      "asset_hash": "",
      "tree": "",
      "seq": 0,
      "leaf_id": 0
    },
    "grouping": [
      { "group_key": "collection", "group_value": "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w" }
    ],
    "royalty": {
      "royalty_model": "creators",
      "target": null,
      "percent": 0.042,
      "basis_points": 420,
      "primary_sale_happened": true,
      "locked": false
    },
    "creators": [
      { "address": "5XvhfmRjwXkGp3jHGmaKpqeerNYjkuZZBYLVQYdeVcRv", "share": 0, "verified": true },
      { "address": "2RtGg6fsFiiF1EQzHqbd66AhW7R5bWeQGpTbv2UMkCdW", "share": 100, "verified": true }
    ],
    "ownership": {
      "frozen": true,
      "delegated": false,
      "delegate": null,
      "ownership_model": "single",
      "owner": "4zdNGgAtFsW1cQgHqkiWyRsxaAgxrSRRynnuunxzjxue"
    },
    "supply": {
      "print_max_supply": 0,
      "print_current_supply": 0,
      "edition_nonce": 254
    },
    "mutable": true,
    "burnt": false,
    "token_info": {
      "supply": 1,
      "decimals": 0,
      "token_program": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      "mint_authority": "TdMA45ZnakQCBt5XUvm7ib2htKuTWdcgGKu1eUGrDyJ",
      "freeze_authority": "TdMA45ZnakQCBt5XUvm7ib2htKuTWdcgGKu1eUGrDyJ"
    }
  }
}
```

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

### Initialize Project

Source: https://www.helius.dev/docs/laserstream/grpc

Create a new directory and initialize a Node.js project.

```bash
mkdir laserstream-grpc-demo
cd laserstream-grpc-demo
npm init -y
```

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

### Get Transaction Count with JavaScript

Source: https://www.helius.dev/docs/rpc/guides/gettransactioncount

Use the @solana/web3.js library to fetch the transaction count. This example shows how to get the count with the default commitment and with a specified 'confirmed' commitment.

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

async function getCurrentTransactionCount() {
  // Replace with your RPC endpoint
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

  try {
    const transactionCount = await connection.getTransactionCount();
    console.log(`Current ledger transaction count: ${transactionCount}`);

    // Example with commitment
    const confirmedTransactionCount = await connection.getTransactionCount('confirmed');
    console.log(`Current ledger transaction count (confirmed): ${confirmedTransactionCount}`);

  } catch (error) {
    console.error('Error fetching transaction count:', error);
  }
}

getCurrentTransactionCount();
```

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

### Get All Known Cluster Nodes

Source: https://www.helius.dev/docs/rpc/guides/getclusternodes

This example fetches the list of all nodes known to the queried RPC endpoint. Use this to get a snapshot of the cluster's network topology.

```bash
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getClusterNodes"
  }'
```

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

### Initialize Go Environment

Source: https://www.helius.dev/docs/grpc/quickstart

Commands to create a new Go project and fetch the necessary gRPC dependencies.

```bash
mkdir solana-grpc-stream
cd solana-grpc-stream
go mod init solana-grpc-stream
go get github.com/rpcpool/yellowstone-grpc/examples/golang@latest
go get google.golang.org/grpc@v1.67.1
```

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

### Get Blocks from a Start Slot to Latest via JavaScript

Source: https://www.helius.dev/docs/rpc/guides/getblocks

Fetches confirmed block slots starting from 260,000,000 up to the latest confirmed block by omitting the endSlot parameter.

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

async function getBlocksFromStart(startSlot) {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  try {
    // The endSlot parameter is omitted to fetch up to the latest confirmed block
    const blocks = await connection.getBlocks(startSlot);
    console.log(`Confirmed blocks from slot ${startSlot} to latest:`, blocks);
    if (blocks.length > 0) {
      console.log(`Latest block in range: ${blocks[blocks.length - 1]}`);
    }
  } catch (error) {
    console.error('Error fetching blocks:', error);
  }
}

// Example usage (ensure this doesn't exceed the 500,000 slot limit from latest block):
const recentStartSlot = 260000000; 
getBlocksFromStart(recentStartSlot);
```

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

### Clone and build the sample program

Source: https://www.helius.dev/docs/quickstart/deploy-program

Clone the official Solana program examples repository and compile the hello-solana program using cargo build-sbf.

```bash
git clone https://github.com/solana-developers/program-examples.git
cd program-examples
cargo build-sbf --manifest-path basics/hello-solana/native/program/Cargo.toml
```

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

### Get Slot Leaders via cURL

Source: https://www.helius.dev/docs/rpc/guides/getslotleaders

Fetches the leaders for 5 slots starting from slot 180,000,000 using a POST request.

```bash
# Replace <api-key> with your Helius API key
  # Replace STARTING_SLOT with a recent or future slot number
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getSlotLeaders",
      "params": [
        180000000, 
        5          
      ]
    }'
```

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

### Get Blocks with Limit and Commitment via cURL

Source: https://www.helius.dev/docs/rpc/guides/getblockswithlimit

Fetches up to 3 blocks starting from slot 290000000 with the 'confirmed' commitment level.

```bash
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlocksWithLimit",
    "params": [
      290000000,
      3,
      { "commitment": "confirmed" }
    ]
  }'
```

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

### Initialize TypeScript client

Source: https://www.helius.dev/docs/quickstart/deploy-program

Set up a new project directory and install the required Solana web3.js dependency.

```bash
mkdir invoke-client && cd invoke-client
npm init -y
npm install @solana/web3.js
```

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

### Connect to Localnet

Source: https://www.helius.dev/docs/privacy/guides/read-balance

Install the CLI and initialize the ZolanaClient for a local environment.

```bash
cargo install --git https://github.com/helius-labs/zolana --tag v0.1.0-alpha zolana-cli
zolana dev start
```

```rust
use solana_address::Address;
use zolana_client::{SolanaRpc, ZolanaClient};
use zolana_interface::DEFAULT_TREE_ADDRESS;

let tree: Address = DEFAULT_TREE_ADDRESS.parse()?;
let client = ZolanaClient::from_urls(
    SolanaRpc::new("http://127.0.0.1:8899"),
    "http://127.0.0.1:8784",
    "http://127.0.0.1:3001",
    tree,
)?;
```

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

### Get Estimated Time of a Specific Block (cURL)

Source: https://www.helius.dev/docs/rpc/guides/getblocktime

Example using cURL to fetch the estimated production time for a specific block slot.

```APIDOC
## GET /getBlockTime (cURL Example)

### Description
This example demonstrates how to use cURL to request the estimated production time for a specific block slot from the Helius RPC endpoint.

### Method
POST

### Endpoint
https://mainnet.helius-rpc.com/?api-key=<api-key>

### Parameters
#### Request Body
- **jsonrpc** (string) - Required - Specifies the JSON-RPC protocol version.
- **id** (number) - Required - The ID of the request.
- **method** (string) - Required - The name of the method to call, which is "getBlockTime".
- **params** (array) - Required - An array containing the parameters for the method.
  - **slot** (u64) - Required - The slot number of the block for which to retrieve the estimated production time. Replace `SLOT_NUMBER_TO_QUERY` with an actual, recent, and confirmed slot on the network.

### Request Example
```bash
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlockTime",
    "params": [
      SLOT_NUMBER_TO_QUERY 
    ]
  }'
```
```

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

### GET /ping

Source: https://www.helius.dev/docs/sending-transactions/sender

The ping endpoint is used to maintain warm connections and reduce cold start latency for applications with long periods between transaction submissions.

```APIDOC
## GET /ping

### Description
Maintains a warm connection to the RPC server to prevent cold start latency.

### Method
GET

### Endpoint
https://sender.helius-rpc.com/ping or http://slc-sender.helius-rpc.com/ping
```

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

### Helius SDK Quick Start

Source: https://www.helius.dev/docs/agents/rust-sdk

Demonstrates initializing the Helius client, fetching wallet assets, retrieving transaction history, and sending a smart transaction.

```rust
use helius::error::Result;
use helius::types::*;
use helius::Helius;

#[tokio::main]
async fn main() -> Result<()> {
    let helius = Helius::new("YOUR_API_KEY", Cluster::MainnetBeta)?;

    // Get all NFTs owned by a wallet
    let assets = helius.rpc().get_assets_by_owner(GetAssetsByOwner {
        owner_address: "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY".to_string(),
        page: 1,
        limit: Some(50),
        ..Default::default()
    }).await?;

    // Get transaction history (with token account activity)
    let txs = helius.rpc().get_transactions_for_address(
        "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY".to_string(),
        GetTransactionsForAddressOptions {
            limit: Some(100),
            transaction_details: Some(TransactionDetails::Full),
            filters: Some(GetTransactionsFilters {
                token_accounts: Some(TokenAccountsFilter::BalanceChanged),
                ..Default::default()
            }),
            ..Default::default()
        },
    ).await?;

    // Send a transaction via Helius Sender (ultra-low latency)
    let sig = helius.send_smart_transaction_with_sender(
        SmartTransactionConfig {
            create_config: CreateSmartTransactionConfig {
                instructions: vec![transfer_instruction],
                signers: vec![wallet_signer],
                ..Default::default()
            },
            ..Default::default()
        },
        SenderSendOptions {
            region: "US_EAST".to_string(),
            ..Default::default()
        },
    ).await?;

    Ok(())
}
```

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

### Get a Limited Number of Blocks via cURL

Source: https://www.helius.dev/docs/rpc/guides/getblockswithlimit

Fetches up to 5 confirmed block slots starting from slot 280000000 using a POST request.

```bash
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlocksWithLimit",
    "params": [
      280000000, 
      5 
    ]
  }'
```

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

### Install OKX Skill and CLI

Source: https://www.helius.dev/docs/agents/skills/okx

Combines the installation of the OKX skill library and the onchainos CLI.

```bash
npx skills add okx/onchainos-skills
curl -fsSL https://raw.githubusercontent.com/okx/onchainos-skills/main/install.sh | bash
```

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

### Get a Limited Number of Blocks via @solana/web3.js

Source: https://www.helius.dev/docs/rpc/guides/getblockswithlimit

Fetches up to 5 confirmed block slots starting from slot 280000000 using the Solana web3.js library.

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

async function getBlocksWithLimitExample(startSlot, limit) {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  try {
    const blocks = await connection.getBlocksWithLimit(startSlot, limit);
    console.log(`Up to ${limit} confirmed blocks starting from slot ${startSlot}:`, blocks);
  } catch (error) {
    console.error('Error fetching blocks with limit:', error);
  }
}

// Example usage:
const startSlot = 280000000;
const limit = 5;
getBlocksWithLimitExample(startSlot, limit);
```

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

### Subscribe to Transactions in Go

Source: https://www.helius.dev/docs/laserstream/clients

This example demonstrates how to configure the Laserstream client, define a transaction filter, and initiate a subscription with data and error callbacks.

```go
package main

import (
    "log"
    "os"
    "os/signal"
    "syscall"

    laserstream "github.com/helius-labs/laserstream-sdk/go"
    pb "github.com/helius-labs/laserstream-sdk/go/proto"
)

func main() {
    clientConfig := laserstream.LaserstreamConfig{
        APIKey:   "YOUR_API_KEY",
        Endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com",
    }

    voteFilter := false
    failedFilter := false
    commitment := pb.CommitmentLevel_CONFIRMED

    subscriptionRequest := &pb.SubscribeRequest{
        Transactions: map[string]*pb.SubscribeRequestFilterTransactions{
            "jupiter-filter": {
                Vote:           &voteFilter,
                Failed:         &failedFilter,
                AccountInclude: []string{"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"},
            },
        },
        Commitment: &commitment,
    }

    client := laserstream.NewClient(clientConfig)

    dataCallback := func(data *pb.SubscribeUpdate) {
        log.Printf("New transaction: %+v\n", data)
    }
    errorCallback := func(err error) {
        log.Printf("Error: %v", err)
    }

    if err := client.Subscribe(subscriptionRequest, dataCallback, errorCallback); err != nil {
        log.Fatalf("Failed to subscribe: %v", err)
    }

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan
    client.Close()
}
```

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

### Get the Maximum Shred Insert Slot

Source: https://www.helius.dev/docs/rpc/guides/getmaxshredinsertslot

This example fetches the maximum slot for which shreds have been inserted by the connected node using either cURL or the Solana web3.js library.

```bash
# Replace <api-key> with your Helius API key
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMaxShredInsertSlot"
  }'
```

```javascript
// Replace <api-key> with your Helius API key
const { Connection } = require('@solana/web3.js');

async function fetchMaxShredInsertSlot() {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  try {
    const maxShredInsertSlot = await connection.getMaxShredInsertSlot();
    console.log(`Maximum Slot for Shred Insertion: ${maxShredInsertSlot}`);
  } catch (error) {
    console.error('Error fetching maximum shred insert slot:', error);
  }
}

fetchMaxShredInsertSlot();
```

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

### Main Application Entry Point

Source: https://www.helius.dev/docs/grpc/stream-pump-amm-data

Initializes the monitoring system, starts the gRPC stream, and sets up periodic reporting and graceful shutdown.

```typescript
// Main application entry point
async function main() {
  const pumpMonitor = new PumpMonitoringSystem(
    "your-grpc-endpoint",
    "YOUR_API_KEY"
  );

  console.log('🚀 Starting Pump.fun monitoring system...');
  console.log('📊 Monitoring: Token launches, trades, and market data');
  console.log('🔔 Alerts: Large trades, price movements, new launches\n');

  // Start the monitoring system
  await pumpMonitor.start();

  // Generate reports periodically
  setInterval(() => {
    pumpMonitor.generateDailyReport();
  }, 60 * 60 * 1000); // Every hour

  // Graceful shutdown
  process.on('SIGINT', () => {
    console.log('\n🛑 Shutting down Pump monitor...');
    pumpMonitor.disconnect();
    process.exit(0);
  });

  console.log('✅ Pump.fun monitoring system is running!');
  console.log('Press Ctrl+C to stop\n');
}

main().catch(console.error);
```
Tokens:
Raw