helius - Claude MCP Skill

# Helius Solana Infrastructure Expert

Helius provides high-performance Solana RPC, real-time data streaming, and developer APIs.

## When to Use

- Setting up Solana RPC infrastructure
- Querying NFT/token metadata (DAS API)
- Real-time blockchain data (LaserStream, WebSockets, webhooks)
- Transaction optimization and priority fees
- ZK Compression for cost reduction

## Quick Start

1. Get API key: https://dashboard.helius.dev
2. Use RPC URL: `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`

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

## Core Services

### RPC Endpoints

```javascript
// Mainnet
const RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${API_KEY}`;

// Devnet
const DEVNET_URL = `https://devnet.helius-rpc.com/?api-key=${API_KEY}`;
```

### Digital Asset Standard (DAS) API

Query NFT and token metadata - handles both regular and compressed NFTs.

**Get Single Asset:**
```javascript
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getAsset',
    params: { id: 'ASSET_MINT_ADDRESS' }
  })
});
```

**Get Assets by Owner:**
```javascript
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getAssetsByOwner',
    params: {
      ownerAddress: 'WALLET_ADDRESS',
      page: 1,
      limit: 100
    }
  })
});
```

**DAS Methods:**
| Method | Description |
|--------|-------------|
| `getAsset` | Single asset metadata |
| `getAssetBatch` | Batch asset retrieval |
| `getAssetsByOwner` | All assets for wallet |
| `getAssetsByCreator` | Assets by creator |
| `getAssetsByGroup` | Assets in collection |

### Enhanced Transactions API

Pre-parsed transaction data in human-readable format.

```javascript
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      'WALLET_ADDRESS',
      {
        transactionDetails: 'full',
        sortOrder: 'desc',
        limit: 10
      }
    ]
  })
});
```

### Priority Fee API

Get optimal priority fees for fast transaction landing.

```javascript
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: ['PROGRAM_ID', 'ACCOUNT_1', 'ACCOUNT_2']
    }]
  })
});

const { priorityFeeEstimate } = await response.json();
// Returns: { low, medium, high, veryHigh } in microlamports
```

### LaserStream (Real-Time gRPC)

Ultra-low latency blockchain streaming. Drop-in replacement for Yellowstone gRPC.

```typescript
import { LaserStream } from '@helius-labs/laserstream';

const stream = new LaserStream({
  apiKey: 'YOUR_API_KEY',
  region: 'fra'  // fra, ams, tyo, sg, ewr, pitt, slc, lax, lon
});

// Subscribe to account changes
stream.subscribeAccount('ACCOUNT_ADDRESS', (update) => {
  console.log('Account updated:', update);
});

// Subscribe to program transactions
stream.subscribeProgram('PROGRAM_ID', (tx) => {
  console.log('Program transaction:', tx);
});
```

**Regions:** FRA, AMS, TYO, SG, EWR, PITT, SLC, LAX, LON

### Webhooks

Event-driven notifications for blockchain activity.

```javascript
// Create webhook via API
const webhook = await fetch('https://api.helius.xyz/v0/webhooks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${API_KEY}`
  },
  body: JSON.stringify({
    webhookURL: 'https://your-server.com/webhook',
    transactionTypes: ['NFT_SALE', 'TOKEN_TRANSFER'],
    accountAddresses: ['ADDRESS_TO_WATCH']
  })
});
```

**Webhook Types:**
- Account changes
- Transaction confirmations
- Program events
- NFT activity

### ZK Compression

Reduce on-chain storage costs by up to 98%.

```javascript
// Get compressed account
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getCompressedAccount',
    params: { address: 'COMPRESSED_ACCOUNT' }
  })
});

// Get compressed token balances
const balances = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getCompressedTokenBalancesByOwner',
    params: { owner: 'WALLET_ADDRESS' }
  })
});
```

## Pricing & Rate Limits

| Plan | Price | Credits | Rate Limit | DAS Limit |
|------|-------|---------|------------|-----------|
| Free | $0/mo | 1M | 10 RPS | 2 RPS |
| Developer | $49/mo | 10M | 50 RPS | 10 RPS |
| Business | $499/mo | 100M | 200 RPS | 50 RPS |
| Professional | $999/mo | 200M | 500 RPS | 100 RPS |

**Feature Availability:**
| Feature | Free | Developer | Business | Professional |
|---------|------|-----------|----------|--------------|
| Shared RPC | Yes | Yes | Yes | Yes |
| LaserStream (Devnet) | - | Yes | Yes | Yes |
| LaserStream (Mainnet) | - | - | - | Yes |
| Enhanced WebSockets | - | - | Yes | Yes |

## Error Handling

```javascript
try {
  const response = await fetch(RPC_URL, { method: 'POST', ... });

  // Check rate limits
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');

  if (response.status === 429) {
    // Rate limited - wait and retry
    await new Promise(r => setTimeout(r, 1000));
    return retry();
  }

  const data = await response.json();
  if (data.error) {
    console.error(`RPC Error ${data.error.code}: ${data.error.message}`);
  }

  return data.result;
} catch (err) {
  // Network error - retry with backoff
}
```

## Best Practices

**DO:**
- Use `confirmed` commitment for faster responses
- Use DAS API for NFT queries (not raw `getAccountInfo`)
- Simulate transactions before sending
- Use `getPriorityFeeEstimate` for dynamic fees
- Check rate limit headers

**DON'T:**
- Poll for real-time data (use WebSockets/LaserStream)
- Hardcode priority fees
- Ignore rate limits
- Skip transaction simulation

## Common Patterns

### Wallet Portfolio

```javascript
async function getWalletPortfolio(wallet) {
  // Get all assets (NFTs + tokens)
  const assets = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getAssetsByOwner',
      params: { ownerAddress: wallet, page: 1, limit: 1000 }
    })
  }).then(r => r.json());

  // Get SOL balance
  const balance = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getBalance',
      params: [wallet]
    })
  }).then(r => r.json());

  return {
    solBalance: balance.result.value / 1e9,
    assets: assets.result.items
  };
}
```

### Transaction with Priority Fee

```javascript
async function sendWithPriorityFee(transaction, accounts) {
  // Get priority fee estimate
  const feeEstimate = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getPriorityFeeEstimate',
      params: [{ accountKeys: accounts }]
    })
  }).then(r => r.json());

  // Add compute budget instruction with priority fee
  const priorityFee = feeEstimate.result.priorityFeeEstimate.high;

  // Simulate first
  const simulation = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'simulateTransaction',
      params: [transaction, { commitment: 'confirmed' }]
    })
  }).then(r => r.json());

  if (simulation.result.err) {
    throw new Error(`Simulation failed: ${JSON.stringify(simulation.result.err)}`);
  }

  // Send transaction
  return fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendTransaction',
      params: [transaction, { skipPreflight: true }]
    })
  }).then(r => r.json());
}
```

## Resources

- **Helius Docs:** https://www.helius.dev/docs
- **Dashboard:** https://dashboard.helius.dev
- **Discord:** https://discord.gg/helius

### Pull Local Docs

```bash
pipx install docpull
docpull https://www.helius.dev/docs -o .claude/skills/helius/docs
```