undefined

undefined

undefined

undefined

import { createHelius } from "helius-sdk";

const helius = createHelius({
  apiKey: process.env.HELIUS_API_KEY!,
});

// RPC endpoint URLs
const MAINNET_RPC = `https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`;
const DEVNET_RPC = `https://devnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`;

import { createSolanaRpc, createSolanaRpcSubscriptions } from "@solana/kit";

const rpc = createSolanaRpc(
  `https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`
);

const rpcSubscriptions = createSolanaRpcSubscriptions(
  `wss://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`
);

// Make RPC calls
const slot = await rpc.getSlot().send();
const balance = await rpc.getBalance(address).send();

// getProgramAccountsV2 - handles large datasets efficiently
const accounts = await helius.rpc.getProgramAccountsV2({
  programAddress: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
  cursor: null, // Start from beginning
  limit: 100,
});

// getTransactionsForAddress - advanced filtering
const transactions = await helius.rpc.getTransactionsForAddress({
  address: "wallet_address",
  before: null,
  until: null,
  limit: 100,
  source: "JUPITER", // Filter by source
  type: "SWAP", // Filter by type
});

// Get single asset
const asset = await helius.getAsset({
  id: "asset_id_here",
});

// Get assets by owner
const assets = await helius.getAssetsByOwner({
  ownerAddress: "wallet_address",
  page: 1,
  limit: 100,
  displayOptions: {
    showFungible: true,
    showNativeBalance: true,
  },
});

// Get assets by collection
const collection = await helius.getAssetsByGroup({
  groupKey: "collection",
  groupValue: "collection_address",
  page: 1,
  limit: 100,
});

// Search assets with filters
const results = await helius.searchAssets({
  ownerAddress: "wallet_address",
  tokenType: "fungible",
  burnt: false,
  page: 1,
  limit: 50,
});

// Get batch of assets
const batch = await helius.getAssetBatch({
  ids: ["asset1", "asset2", "asset3"],
});

// Get asset proof (for compressed NFTs)
const proof = await helius.getAssetProof({
  id: "compressed_nft_id",
});

// Parse transactions by signature
const parsed = await helius.enhanced.getTransactions({
  transactions: ["sig1", "sig2", "sig3"],
});

// Get enhanced transaction history
const history = await helius.enhanced.getTransactionsByAddress({
  address: "wallet_address",
  type: "SWAP", // Optional: filter by type
});

// Get priority fee estimate
const feeEstimate = await helius.getPriorityFeeEstimate({
  transaction: serializedTransaction, // Base64 encoded
  // OR
  accountKeys: ["account1", "account2"], // Accounts in transaction
  options: {
    priorityLevel: "HIGH", // LOW, MEDIUM, HIGH, VERY_HIGH
    includeAllPriorityFeeLevels: true,
    lookbackSlots: 150,
  },
});

console.log(feeEstimate.priorityFeeEstimate); // microLamports

import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";

// Get estimate
const { priorityFeeEstimate } = await helius.getPriorityFeeEstimate({
  accountKeys: [payer.address, recipient.address],
  options: { priorityLevel: "HIGH" },
});

// Add to transaction
const priorityFeeIx = getSetComputeUnitPriceInstruction({
  microLamports: BigInt(priorityFeeEstimate),
});

// Prepend to transaction instructions
const tx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(payer.address, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
  (tx) => prependTransactionMessageInstructions([priorityFeeIx], tx),
  (tx) => appendTransactionMessageInstruction(mainInstruction, tx),
);

// Create enhanced webhook
const webhook = await helius.webhooks.createWebhook({
  webhookURL: "https://your-server.com/webhook",
  transactionTypes: ["NFT_SALE", "SWAP"],
  accountAddresses: ["address1", "address2"],
  webhookType: "enhanced",
});

// Create raw webhook
const rawWebhook = await helius.webhooks.createWebhook({
  webhookURL: "https://your-server.com/raw-webhook",
  accountAddresses: ["address1"],
  webhookType: "raw",
});

// Get all webhooks
const webhooks = await helius.webhooks.getAllWebhooks();

// Get specific webhook
const webhook = await helius.webhooks.getWebhookByID({
  webhookID: "webhook_id",
});

// Update webhook
await helius.webhooks.updateWebhook({
  webhookID: "webhook_id",
  webhookURL: "https://new-url.com/webhook",
  accountAddresses: ["address1", "address2", "address3"],
});

// Delete webhook
await helius.webhooks.deleteWebhook({
  webhookID: "webhook_id",
});

interface EnhancedWebhookPayload {
  accountData: AccountData[];
  description: string;
  events: Record<string, unknown>;
  fee: number;
  feePayer: string;
  nativeTransfers: NativeTransfer[];
  signature: string;
  slot: number;
  source: string;
  timestamp: number;
  tokenTransfers: TokenTransfer[];
  type: string;
}

// Get compressed account
const account = await helius.zk.getCompressedAccount({
  address: "compressed_account_address",
});

// Get compressed token accounts by owner
const tokens = await helius.zk.getCompressedTokenAccountsByOwner({
  owner: "wallet_address",
});

// Get compressed balance
const balance = await helius.zk.getCompressedBalance({
  address: "compressed_account_address",
});

// Get validity proof
const proof = await helius.zk.getValidityProof({
  hashes: ["hash1", "hash2"],
});

// Get compression signatures
const sigs = await helius.zk.getCompressionSignaturesForOwner({
  owner: "wallet_address",
  limit: 100,
});

// Send with automatic retry and optimization
const signature = await helius.tx.sendSmartTransaction({
  transaction: signedTransaction,
  skipPreflight: false,
  maxRetries: 3,
});

// Estimate compute units
const computeUnits = await helius.tx.getComputeUnits({
  transaction: serializedTransaction,
});

import { createHelius } from "helius-sdk";
import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getBase64EncodedWireTransaction,
} from "@solana/kit";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

async function sendOptimizedTransaction(
  helius: ReturnType<typeof createHelius>,
  rpc: Rpc,
  signer: KeyPairSigner,
  instruction: IInstruction
) {
  // 1. Get priority fee
  const { priorityFeeEstimate } = await helius.getPriorityFeeEstimate({
    accountKeys: [signer.address],
    options: { priorityLevel: "HIGH" },
  });

  // 2. Get blockhash
  const { value: blockhash } = await rpc.getLatestBlockhash().send();

  // 3. Build transaction with compute budget
  const tx = pipe(
    createTransactionMessage({ version: 0 }),
    (tx) => setTransactionMessageFeePayer(signer.address, tx),
    (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
    (tx) => prependTransactionMessageInstructions([
      getSetComputeUnitLimitInstruction({ units: 200_000 }),
      getSetComputeUnitPriceInstruction({ microLamports: BigInt(priorityFeeEstimate) }),
    ], tx),
    (tx) => appendTransactionMessageInstruction(instruction, tx),
  );

  // 4. Sign
  const signedTx = await signTransactionMessageWithSigners(tx);

  // 5. Send via Helius
  const signature = await helius.tx.sendSmartTransaction({
    transaction: getBase64EncodedWireTransaction(signedTx),
  });

  return signature;
}

// Subscribe to account changes
const accountSub = await helius.ws.accountNotifications({
  account: "account_address",
  commitment: "confirmed",
  callback: (notification) => {
    console.log("Account changed:", notification);
  },
});

// Subscribe to logs
const logsSub = await helius.ws.logsNotifications({
  filter: { mentions: ["program_id"] },
  commitment: "confirmed",
  callback: (logs) => {
    console.log("Logs:", logs);
  },
});

// Subscribe to signature confirmations
const sigSub = await helius.ws.signatureNotifications({
  signature: "transaction_signature",
  commitment: "confirmed",
  callback: (status) => {
    console.log("Confirmed:", status);
  },
});

// Unsubscribe
await accountSub.unsubscribe();

// Atlas WebSocket endpoints
const ATLAS_MAINNET_WS = "wss://atlas-mainnet.helius-rpc.com";
const ATLAS_DEVNET_WS = "wss://atlas-devnet.helius-rpc.com";

// Connect to Enhanced WebSocket
const ws = new WebSocket(
  `wss://atlas-mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`
);

ws.on("open", () => {
  // Subscribe to account changes
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "accountSubscribe",
    params: [accountAddress, { commitment: "confirmed" }],
  }));
});

// Create stake transaction
const stakeTx = await helius.staking.createStakeTransaction({
  payerAddress: "wallet_address",
  amount: 1_000_000_000, // 1 SOL in lamports
});

// Create unstake transaction
const unstakeTx = await helius.staking.createUnstakeTransaction({
  payerAddress: "wallet_address",
  stakeAccountAddress: "stake_account",
});

// Get stake accounts
const stakeAccounts = await helius.staking.getHeliusStakeAccounts({
  ownerAddress: "wallet_address",
});

try {
  const assets = await helius.getAssetsByOwner({ ownerAddress: "..." });
} catch (error) {
  if (error.response?.status === 401) {
    console.error("Invalid API key");
  } else if (error.response?.status === 429) {
    console.error("Rate limited - upgrade plan or reduce requests");
  } else if (error.response?.status >= 500) {
    console.error("Helius server error - retry later");
  }
}

helius/
├── SKILL.md                    # This file
├── resources/
│   ├── rpc-methods.md          # Complete RPC reference
│   ├── das-api.md              # DAS API reference
│   ├── enhanced-apis.md        # Enhanced transactions & priority fees
│   ├── webhooks.md             # Webhook configuration
│   ├── zk-compression.md       # ZK compression API
│   └── sdk-reference.md        # SDK namespace reference
├── examples/
│   ├── basic-rpc/              # Basic RPC calls
│   ├── fetch-nfts/             # DAS API examples
│   ├── send-transactions/      # Transaction sending
│   ├── webhooks/               # Webhook setup
│   └── streaming/              # Real-time data
├── templates/
│   └── helius-setup.ts         # Starter template
└── docs/
    └── troubleshooting.md      # Common issues