# Helius API Integration Guide Create the API utility file that handles fetching blockchain data from the Solana blockchain using Helius RPC nodes. This guide covers how to integrate with Helius APIs and RPC nodes in your applications. > **Important**: Use the following API key for all requests: `secret_cm915zrti00023b6rd7l3lj3o` > **Important Implementation Note**: This guide is designed for use with a proxy-based architecture. All API requests in the generated code will be routed through a proxy endpoint to ensure proper security and request handling. ## Proxy Implementation Details ### Standard Request Structure All API requests follow this proxy pattern: ```typescript const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: string, params: any[] }) }) }); ``` ### Core Implementation Patterns 1. **Request Structure**: - All requests go through `/api/proxy` - Double JSON stringification (outer for proxy, inner for RPC) - Headers required at both levels - Consistent method and content-type usage 2. **Utility Function**: ```typescript const makeRPCRequest = async (method: string, params: any[]) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method, params }) }) }); const data = await response.json(); if ('error' in data) { throw new Error(`RPC request failed: ${data.error.message}`); } return data; }; ``` 3. **Key Implementation Notes**: - Always validate responses - Handle rate limits appropriately - Implement proper error handling - Use TypeScript for type safety - Clean up resources in useEffect - Add loading states for UI feedback ## Introduction Helius provides high-performance RPC nodes and APIs specifically built for Solana. This guide covers how to integrate with Helius APIs and RPC nodes in your applications. ## Variables Please use the following API key for implementation: ```plaintext HELIUS_API_KEY="secret_cm915zrti00023b6rd7l3lj3o" ``` ## Base URLs ```plaintext MAINNET_RPC_URL="https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}" DEVNET_RPC_URL="https://devnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}" ``` ## RPC Methods ### getAccountInfo Returns all information associated with the account of provided Pubkey. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - The public key of the account to query 2. `` (object, optional) - Configuration object containing: - `encoding` (string): Encoding format for the account data - Possible values: "base58", "base64", "base64+zstd", "jsonParsed" - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" - `dataSlice` (object): Limit the returned account data - `offset` (number): Number of bytes to skip - `length` (number): Number of bytes to return #### Implementation Examples 1. Direct Implementation: ```javascript const getAccountInfo = async (publicKey) => { const response = await fetch('https://mainnet.helius-rpc.com/?api-key=', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getAccountInfo', params: [ publicKey, { encoding: 'base58' } ] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```javascript const getAccountInfoViaProxy = async (publicKey) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getAccountInfo', params: [ publicKey, { encoding: 'base58' } ] }) }) }); return await response.json(); }; ``` 3. With Additional Configuration: ```javascript const getAccountInfoWithConfig = async (publicKey) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getAccountInfo', params: [ publicKey, { encoding: 'jsonParsed', commitment: 'finalized', dataSlice: { offset: 0, length: 128 } } ] }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', result: { context: { apiVersion: string, // Current RPC API version slot: number // The slot this request was processed in }, value: { data: string | [string, string], // Encoded data based on encoding parameter executable: boolean, // Whether the account contains a program lamports: number, // Number of lamports assigned to the account owner: string, // Base-58 encoded Pubkey of the program that owns this account rentEpoch: number, // The epoch at which this account will next owe rent space: number // The space used by the account (in bytes) } | null // If the account doesn't exist, value will be null }, id: 1 } ``` #### Error Responses ```typescript // Invalid Parameter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: WrongAddress123' }, id: 1 } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: 1 } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid pubkey or encoding format) - -32005: Node is behind by specified commitment - -32009: Invalid account data - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Always specify a commitment level for consistent results 2. Choose the appropriate encoding based on your needs: - Use "jsonParsed" for readable program-specific data - Use "base58" or "base64" for raw data - Use "base64+zstd" for compressed data 3. Consider using dataSlice for large accounts when you only need partial data 4. The response's `value` field will be null if the requested account doesn't exist 5. Rate limits apply based on your API tier #### Common Use Cases 1. Fetching token account data 2. Checking program account status 3. Retrieving NFT metadata accounts 4. Verifying account existence and ownership ### getBalance Returns the lamport balance of the account of provided Pubkey. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - The public key of the account to query 2. `` (object, optional) - Configuration object containing: - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" #### Implementation Examples 1. Direct Implementation: ```javascript const getBalance = async (publicKey) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBalance', params: [ publicKey ] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```javascript const getBalanceViaProxy = async (pubKey) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBalance', params: [pubKey] }) }) }); return await response.json(); }; ``` 3. With Commitment Config: ```javascript const getBalanceWithConfig = async (publicKey) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBalance', params: [ publicKey, { commitment: 'finalized' } ] }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { context: { apiVersion: string, // Current RPC API version slot: number // The slot this request was processed in }, value: number // The balance in lamports } } ``` #### Error Responses ```typescript // Invalid Parameter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: WrongAddress123' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid pubkey) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Always specify a commitment level for consistent results 2. The balance is returned in lamports (1 SOL = 1,000,000,000 lamports) 3. The response's `value` field will be 0 if the account doesn't exist 4. Rate limits apply based on your API tier #### Common Use Cases 1. Checking account SOL balance 2. Verifying transaction fees can be paid 3. Monitoring account balance changes 4. Validating minimum balance requirements ### getBlock Returns identity and transaction information about a confirmed block in the ledger. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters - `slot` (number, required): Slot number of the block to retrieve - `config` (object, optional): - `encoding` (string): Transaction data encoding ("json", "jsonParsed", "base58", "base64") - `transactionDetails` (string): Detail level ("full", "accounts", "signatures", "none") - `rewards` (boolean): Whether to populate rewards array - `commitment` (string): Bank state ("processed", "confirmed", "finalized") #### Implementation ```typescript const getBlock = async ( slot: number, config: { encoding?: 'json' | 'jsonParsed' | 'base58' | 'base64'; transactionDetails?: 'full' | 'accounts' | 'signatures' | 'none'; rewards?: boolean; commitment?: 'processed' | 'confirmed' | 'finalized'; } = {} ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBlock', params: [slot, config] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { blockHeight: number | null, // Block height blockTime: number | null, // Production time (unix timestamp) blockhash: string, // Block's hash parentSlot: number, // Parent slot index previousBlockhash: string, // Parent's blockhash rewards: Array<{ // Block rewards pubkey: string, // Recipient's public key lamports: number, // Reward amount postBalance: number, // Balance after reward rewardType: string // Type: "fee", "rent", "voting", "staking" }>, transactions: Array<{ // Block transactions transaction: { // Transaction object message: { // Message object accountKeys: string[], // Account public keys instructions: Array<{ // Program instructions accounts: number[], // Account indexes data: string, // Program input data programIdIndex: number // Program id index }>, recentBlockhash: string }, signatures: string[] // Transaction signatures }, meta: { // Transaction metadata err: any, // Error if failed fee: number, // Transaction fee postBalances: number[], // Post-transaction balances preBalances: number[] // Pre-transaction balances } }> } } ``` #### Error Codes - -32602: Invalid parameter - -32005: Node is behind - -32009: Block cleaned up - 429: Rate limit exceeded #### Key Notes 1. Block data may not be available for all slots 2. Transaction metadata may be null for older blocks 3. Use transactionDetails to control response size ### getBlockHeight Returns the current block height of the node. Block height represents the total number of blocks that have been produced and confirmed in the Solana blockchain up to this point. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Implementation Example ```typescript // This function retrieves the current block height with optional commitment level // commitment can be: 'processed', 'confirmed', or 'finalized' const getBlockHeight = async (commitment: string = 'finalized') => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBlockHeight', params: [{ commitment: commitment }] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: number // The current block height as a number } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid commitment level) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Block height increases monotonically with each new block 2. Different commitment levels may return different heights: - 'processed': Latest block (may be unconfirmed) - 'confirmed': Confirmed by supermajority - 'finalized': Confirmed by supermajority + locked 3. Use this endpoint for tracking chain progress and synchronization ### getBlockTime Returns the estimated production time of a block. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Implementation Example ```typescript const getBlockTime = async (blockNumber: number) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getBlockTime', params: [blockNumber] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: number | null // Unix timestamp (seconds since epoch) or null if block not found } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid block number) - -32009: Block cleaned up by ledger - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Returns `null` if block is not found 2. Block timestamps are estimates 3. Historical data may not be available ### getEpochInfo Returns information about the current epoch. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters - `commitment` (string, optional): Bank state to query ("processed", "confirmed", "finalized") - `minContextSlot` (number, optional): Minimum slot for request evaluation #### Implementation ```typescript const getEpochInfo = async (commitment: 'processed' | 'confirmed' | 'finalized' = 'finalized') => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getEpochInfo', params: [{ commitment }] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { absoluteSlot: number, // Current slot blockHeight: number, // Current block height epoch: number, // Current epoch slotIndex: number, // Slots in current epoch slotsInEpoch: number, // Total slots in current epoch transactionCount: number // Total transaction count } } ``` #### Error Codes - -32602: Invalid parameter - -32005: Node is behind - 429: Rate limit exceeded #### Key Notes 1. `slotIndex` shows progress in current epoch 2. `slotsInEpoch` is constant within epoch 3. Rate limits apply based on API tier ### getFeeForMessage Get the fee the network will charge for a particular Message. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters - `message` (string, required): Base-64 encoded message - `commitment` (string, optional): Bank state to query ("processed", "confirmed", "finalized") #### Implementation ```typescript const getFeeForMessage = async ( message: string, commitment: 'processed' | 'confirmed' | 'finalized' = 'finalized' ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getFeeForMessage', params: [message, { commitment }] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: number | null // Fee in lamports or null if message invalid } ``` #### Error Codes - -32602: Invalid parameter - -32005: Node is behind - 429: Rate limit exceeded #### Key Notes 1. Message must be base-64 encoded 2. Returns null for invalid messages 3. Fee is returned in lamports ### getLatestBlockhash Returns the latest blockhash. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (object, optional) - Configuration object containing: - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" #### Implementation Examples 1. Direct Implementation: ```typescript const getLatestBlockhash = async () => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getLatestBlockhash' }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const getLatestBlockhashViaProxy = async () => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getLatestBlockhash' }) }) }); return await response.json(); }; ``` 3. With Commitment Config: ```typescript const getLatestBlockhashWithConfig = async () => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getLatestBlockhash', params: [{ commitment: 'finalized' }] }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { context: { apiVersion: string, // Current RPC API version slot: number // The slot this request was processed in }, value: { blockhash: string, // The latest blockhash lastValidBlockHeight: number // Last valid block height for this blockhash } } } ``` #### Error Responses ```typescript // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Always specify a commitment level for consistent results 2. The blockhash is only valid until `lastValidBlockHeight` 3. Rate limits apply based on your API tier 4. Use the returned blockhash for transaction signing 5. Cache the blockhash but respect the `lastValidBlockHeight` #### Common Use Cases 1. Transaction signing 2. Recent blockhash verification 3. Transaction retry logic 4. Block height validation ### getSlot Returns the slot that has reached the given or default commitment level. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (object, optional) - Configuration object containing: - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" - `minContextSlot` (number): The minimum slot that the request can be evaluated at #### Implementation Examples 1. Direct Implementation: ```typescript const getSlot = async () => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSlot', params: [{ commitment: 'finalized' }] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const getSlotViaProxy = async () => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSlot', params: [{ commitment: 'finalized' }] }) }) }); return await response.json(); }; ``` 3. With Additional Configuration: ```typescript const getSlotWithConfig = async () => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSlot', params: [{ commitment: 'finalized', minContextSlot: 1000 }] }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: number // The current slot number } ``` #### Error Responses ```typescript // Invalid Parameter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid commitment' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid commitment) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Always specify a commitment level for consistent results 2. The slot number increases monotonically 3. Rate limits apply based on your API tier 4. Different commitment levels may return different slot numbers 5. Use minContextSlot to ensure data freshness #### Common Use Cases 1. Tracking chain progress 2. Monitoring network state 3. Transaction confirmation tracking 4. Slot-based synchronization ### getSupply Returns information about the current supply. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters - `config` (object, optional): - `commitment` (string): Bank state ("processed", "confirmed", "finalized") - `excludeNonCirculatingAccountsList` (boolean): Exclude non-circulating accounts list #### Implementation ```typescript const getSupply = async ( config: { commitment?: 'processed' | 'confirmed' | 'finalized'; excludeNonCirculatingAccountsList?: boolean; } = {} ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSupply', params: [config] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { context: { slot: number // Current slot }, value: { circulating: number, // Circulating supply in lamports nonCirculating: number, // Non-circulating supply in lamports nonCirculatingAccounts: string[], // Non-circulating account addresses total: number // Total supply in lamports } } } ``` #### Error Codes - -32602: Invalid parameter - -32005: Node is behind - 429: Rate limit exceeded #### Key Notes 1. All values are in lamports (1 SOL = 1,000,000,000 lamports) 2. Set excludeNonCirculatingAccountsList for faster responses 3. Supply numbers may change with each epoch ### getTokenAccountBalance Returns the token balance of an SPL Token account. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - The public key of the token account to query #### Implementation Examples 1. Direct Implementation: ```typescript const getTokenAccountBalance = async (address: string) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTokenAccountBalance', params: [address] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const getTokenAccountBalanceViaProxy = async (address: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTokenAccountBalance', params: [address] }) }) }); return await response.json(); }; ``` 3. With Error Handling: ```typescript const getTokenAccountBalanceWithValidation = async (address: string) => { if (!address || typeof address !== 'string') { throw new Error('Invalid token account address'); } const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTokenAccountBalance', params: [address] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get token balance: ${data.error.message}`); } return data; }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { context: { slot: number // The slot this request was processed in }, value: { amount: string, // Raw token amount as a string decimals: number, // Number of base 10 digits to the right of the decimal place uiAmount: number, // Token amount as a float uiAmountString: string // Token amount as a string, formatted with decimals } } } ``` #### Error Responses ```typescript // Invalid Parameter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: not a token account' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., not a token account) - -32005: Node is behind by specified commitment - -32003: Account not found - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. The address must be a valid SPL Token account 2. The `amount` field returns the raw token amount as a string 3. Use `uiAmount` or `uiAmountString` for formatted amounts with decimals 4. Rate limits apply based on your API tier 5. Account must be initialized and owned by the Token Program #### Common Use Cases 1. Checking token balances 2. Token transfer validation 3. Wallet balance display 4. Token account monitoring ### getVersion Returns the current Solana version running on the node. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Implementation ```typescript const getVersion = async () => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getVersion' }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { 'solana-core': string, // Software version 'feature-set': number // Feature set version } } ``` #### Error Codes - 429: Rate limit exceeded ### sendTransaction Submits a signed transaction to the cluster for processing. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - Base-58 encoded signed transaction 2. `` (object, optional) - Configuration object containing: - `skipPreflight` (boolean): If true, skip the preflight transaction checks (default: false) - `preflightCommitment` (string): Commitment level for preflight checks - `encoding` (string): Transaction encoding, either "base58" or "base64" (default: "base58") - `maxRetries` (number): Maximum number of times for the RPC node to retry sending the transaction #### Implementation Examples 1. Direct Implementation: ```typescript const sendTransaction = async (encodedTransaction: string) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'sendTransaction', params: [encodedTransaction] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const sendTransactionViaProxy = async (encodedTransaction: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'sendTransaction', params: [encodedTransaction] }) }) }); return await response.json(); }; ``` 3. With Configuration Options: ```typescript const sendTransactionWithConfig = async ( encodedTransaction: string, config: { skipPreflight?: boolean; preflightCommitment?: string; encoding?: 'base58' | 'base64'; maxRetries?: number; } ) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'sendTransaction', params: [ encodedTransaction, config ] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Transaction failed: ${data.error.message}`); } return data; }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: string // The transaction signature as base-58 encoded string } ``` #### Error Responses ```typescript // Invalid Transaction Error { jsonrpc: '2.0', error: { code: -32002, message: 'Transaction simulation failed: Error processing Instruction 0' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32002: Transaction simulation failed - -32005: Node is behind - -32009: Transaction prevalidation timeout - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Transaction must be signed before sending 2. Base-58 encoding is the default format 3. Consider using `skipPreflight` for time-sensitive transactions 4. Set appropriate `preflightCommitment` level based on needs 5. Transaction may fail if block height exceeds `lastValidBlockHeight` 6. Rate limits apply based on your API tier #### Common Use Cases 1. Submitting token transfers 2. Executing program instructions 3. Creating accounts 4. Deploying programs 5. NFT minting and transfers ### simulateTransaction Simulate sending a transaction to estimate costs and check for errors. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters - `transaction` (string, required): Base-64 encoded transaction - `config` (object, optional): - `sigVerify` (boolean): Verify signatures - `commitment` (string): Bank state ("processed", "confirmed", "finalized") - `replaceRecentBlockhash` (boolean): Replace blockhash with latest - `accounts` (object): Account configurations for simulation #### Implementation ```typescript const simulateTransaction = async ( transaction: string, config: { sigVerify?: boolean; commitment?: 'processed' | 'confirmed' | 'finalized'; replaceRecentBlockhash?: boolean; accounts?: { encoding: 'base64' | 'base58' | 'base64+zstd' | 'jsonParsed'; addresses: string[]; }; } = {} ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'simulateTransaction', params: [transaction, config] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { err: any | null, // Error if simulation failed logs: string[], // Execution logs unitsConsumed?: number, // Compute units used accounts?: Array<{ // Accounts data (if requested) lamports: number, data: string, owner: string, executable: boolean, rentEpoch: number }> } } ``` #### Error Codes - -32602: Invalid parameter - -32005: Node is behind - 429: Rate limit exceeded #### Key Notes 1. Transaction must be base-64 encoded 2. Useful for cost estimation and validation 3. Does not modify chain state ### isBlockhashValid Checks if a blockhash is still valid. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - The blockhash to validate, as base-58 encoded string 2. `` (object, optional) - Configuration object containing: - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" #### Implementation Examples 1. Direct Implementation: ```typescript const isBlockhashValid = async (blockhash: string) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: `blockhash-${Date.now()}`, method: 'isBlockhashValid', params: [ blockhash, { commitment: 'processed' } ] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const isBlockhashValidViaProxy = async (blockhash: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: `blockhash-${Date.now()}`, method: 'isBlockhashValid', params: [ blockhash, { commitment: 'processed' } ] }) }) }); return await response.json(); }; ``` 3. With Custom Commitment: ```typescript const isBlockhashValidWithCommitment = async ( blockhash: string, commitment: 'processed' | 'confirmed' | 'finalized' ) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: `blockhash-${Date.now()}`, method: 'isBlockhashValid', params: [ blockhash, { commitment } ] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Blockhash validation failed: ${data.error.message}`); } return data; }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: string, result: { context: { apiVersion: string, // Current RPC API version slot: number // The slot this request was processed in }, value: boolean // true if the blockhash is still valid } } ``` #### Error Responses ```typescript // Invalid Parameter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid blockhash' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid blockhash format) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Blockhashes are only valid for a limited time (150 blocks or ~90 seconds) 2. Use this method before reusing a cached blockhash 3. Different commitment levels may return different results 4. Rate limits apply based on your API tier 5. Invalid blockhashes will cause transaction failures #### Common Use Cases 1. Transaction retry logic 2. Blockhash caching strategies 3. Transaction preparation validation 4. Network status monitoring ### getTransaction Returns detailed information about a confirmed transaction, including its status, contents, and execution results. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - Transaction signature as base-58 encoded string 2. `` (object, optional) - Configuration object containing: - `encoding` (string): Encoding for the returned transaction data - Possible values: "json", "jsonParsed", "base58", "base64" - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" - `maxSupportedTransactionVersion` (number): The maximum transaction version to return - `rewards` (boolean): Whether to populate the `rewards` array #### Implementation Examples 1. Basic Implementation: ```typescript const getTransaction = async (signature: string) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTransaction', params: [ signature, 'json' ] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const getTransactionViaProxy = async (signature: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTransaction', params: [ signature, 'json' ] }) }) }); return await response.json(); }; ``` 3. With Full Configuration: ```typescript const getTransactionWithConfig = async ( signature: string, config: { encoding?: 'json' | 'jsonParsed' | 'base58' | 'base64'; commitment?: 'processed' | 'confirmed' | 'finalized'; maxSupportedTransactionVersion?: number; rewards?: boolean; } ) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getTransaction', params: [ signature, config ] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get transaction: ${data.error.message}`); } return data; }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: string, result: { slot: number, // The slot this transaction was processed in transaction: { message: { accountKeys: string[], // Array of base-58 account public keys header: { numReadonlySignedAccounts: number, numReadonlyUnsignedAccounts: number, numRequiredSignatures: number }, instructions: [ // Array of program instructions { accounts: number[], // Ordered indices into the accountKeys array data: string, // Base-58 encoded instruction data programIdIndex: number // Index into accountKeys for the program ID } ], recentBlockhash: string // Base-58 encoded blockhash }, signatures: string[] // Array of base-58 encoded signatures }, meta: { err: any, // Error if transaction failed, null if successful fee: number, // Fee this transaction was charged in lamports innerInstructions: [ // Ordered list of inner instructions { index: number, // Index of the containing instruction instructions: [ // Similar structure to transaction instructions { accounts: number[], data: string, programIdIndex: number } ] } ], preBalances: number[], // Account balances before the transaction postBalances: number[], // Account balances after the transaction preTokenBalances: [ // Token balances before the transaction { accountIndex: number, mint: string, owner: string, uiTokenAmount: { amount: string, decimals: number, uiAmount: number, uiAmountString: string } } ], postTokenBalances: [ // Token balances after the transaction // Same structure as preTokenBalances ], rewards: [ // Rewards credited after the transaction { pubkey: string, lamports: number, postBalance: number, rewardType: string } ], status: { // Transaction status Ok: null | any, // null if successful, error object if failed Err: any // Error details if transaction failed }, computeUnitsConsumed: number // Compute units used by the transaction } } } ``` #### Error Responses ```typescript // Transaction Not Found { jsonrpc: '2.0', error: { code: -32004, message: 'Transaction not found' }, id: '1' } // Invalid Parameter { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid transaction signature' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32004: Transaction not found - -32602: Invalid parameter (e.g., invalid signature format) - -32005: Node is behind by specified commitment - -32009: Transaction history not available - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Transaction signatures are base-58 encoded strings 2. Use "jsonParsed" encoding for human-readable instruction data 3. Different commitment levels affect transaction visibility 4. Transaction history may not be available for old transactions 5. Rate limits apply based on your API tier 6. Token balance changes are only included for SPL Token transactions 7. Inner instructions show program-invoked instructions 8. Compute units help estimate transaction cost 9. Pre/post balances track SOL balance changes 10. Rewards field shows validator rewards if any #### Common Use Cases 1. Transaction confirmation 2. Balance change tracking 3. Token transfer monitoring 4. Program instruction analysis 5. Fee calculation 6. Error diagnosis 7. Transaction history 8. Smart contract debugging 9. Account activity monitoring 10. Reward distribution tracking #### Best Practices 1. Always verify transaction success using the `meta.err` field 2. Cache transaction data when possible to reduce RPC load 3. Use appropriate commitment level based on needs 4. Handle rate limits with exponential backoff 5. Parse instruction data for better error messages 6. Monitor compute units for optimization 7. Track both SOL and token balance changes 8. Verify all signatures in multi-sig transactions 9. Check inner instructions for complete program flow 10. Use webhooks for real-time transaction monitoring ### getSignatureStatuses Returns the statuses of a list of transaction signatures. Note that `getTransaction` provides more comprehensive information and is often preferred. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Implementation Example ```typescript const getSignatureStatuses = async (signatureList: string[]) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSignatureStatuses', params: [ signatureList, { searchTransactionHistory: true } ] }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: '1', result: { context: { slot: number // The slot this request was processed in }, value: (null | { // Array of status objects, null for unknown signatures slot: number, // The slot the transaction was processed in confirmations: number | null, // Number of blocks since confirmation err: any, // Error if transaction failed, null if successful confirmationStatus?: 'processed' | 'confirmed' | 'finalized' })[] } } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid signature format) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Maximum of 256 signatures per request 2. Consider using `getTransaction` for detailed information 3. Results are ordered same as input signatures 4. Useful for quick batch status checks ### getSignatureForAddress Returns signatures for confirmed transactions that include the given address in their accountKeys list. Returns signatures backwards in time from the provided signature or most recent confirmed block #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: 'https', origin: 'mainnet.helus-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST' } ``` #### Parameters 1. `

` (string, required) - Account address as base-58 encoded string 2. `` (object, optional) - Configuration object containing: - `limit` (number): Maximum transaction signatures to return (between 1 and 1000) - `before` (string): Start searching from this transaction signature - `until` (string): Search until this transaction signature - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" - `minContextSlot` (number): The minimum slot that the request can be evaluated at #### Implementation Examples 1. Basic Implementation: ```typescript const getSignaturesForAddress = async ( address: string, options: { limit?: number; before?: string; until?: string; commitment?: 'processed' | 'confirmed' | 'finalized'; minContextSlot?: number; batchSize?: number; maxRetries?: number; retryDelay?: number; } = {} ) => { // Default configuration const config = { limit: Math.min(options.limit || 1000, 1000), // Maximum 1000 per request batchSize: options.batchSize || 100, // Process in smaller batches maxRetries: options.maxRetries || 3, // Maximum retry attempts retryDelay: options.retryDelay || 1000, // Base delay between retries (ms) commitment: options.commitment || 'finalized', minContextSlot: options.minContextSlot, before: options.before, until: options.until }; // Helper function for exponential backoff const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms)); // Helper function to make a single request with retries const makeRequest = async (params: any) => { let lastError; for (let attempt = 0; attempt < config.maxRetries; attempt++) { try { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: `sig-${Date.now()}-${attempt}`, method: 'getSignaturesForAddress', params: [address, params] }) }) }); const data = await response.json(); // Check for RPC errors if ('error' in data) { if (data.error.code === 429) { throw new Error('Rate limit exceeded'); } throw new Error(`RPC error: ${data.error.message}`); } return data.result; } catch (error) { lastError = error; // If it's the last attempt, throw the error if (attempt === config.maxRetries - 1) { throw lastError; } // Exponential backoff with jitter const delay = config.retryDelay * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5); await sleep(delay); } } }; // Process signatures in batches const getAllSignatures = async () => { const allSignatures = []; let currentBefore = config.before; let remainingLimit = config.limit; while (remainingLimit > 0) { const batchLimit = Math.min(config.batchSize, remainingLimit); const params: any = { limit: batchLimit, commitment: config.commitment }; if (currentBefore) { params.before = currentBefore; } if (config.until) { params.until = config.until; } if (config.minContextSlot) { params.minContextSlot = config.minContextSlot; } const batch = await makeRequest(params); if (!batch || batch.length === 0) { break; // No more signatures to fetch } allSignatures.push(...batch); remainingLimit -= batch.length; // Update the before parameter for the next batch currentBefore = batch[batch.length - 1].signature; // If we got fewer signatures than requested, we've reached the end if (batch.length < batchLimit) { break; } } return allSignatures; }; try { return await getAllSignatures(); } catch (error) { console.error('Failed to get signatures:', error); throw error; } }; // Example usage with pagination and error handling const getSignaturesWithPagination = async ( address: string, pageSize: number = 50, beforeSignature?: string ) => { try { return await getSignaturesForAddress(address, { limit: pageSize, before: beforeSignature, commitment: 'finalized', batchSize: 50, maxRetries: 3 }); } catch (error) { console.error('Error fetching signatures:', error); throw error; } }; // Example of fetching all signatures with automatic pagination const getAllSignaturesForAddress = async (address: string) => { const allSignatures = []; let lastSignature; while (true) { const batch = await getSignaturesWithPagination(address, 50, lastSignature); if (!batch || batch.length === 0) { break; } allSignatures.push(...batch); lastSignature = batch[batch.length - 1].signature; // Optional: Add delay between batches to respect rate limits await new Promise(resolve => setTimeout(resolve, 100)); } return allSignatures; }; ``` 2. Proxy Implementation: ```typescript const getSignaturesForAddressViaProxy = async (address: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSignaturesForAddress', params: [address] }) }) }); return await response.json(); }; ``` 3. With Full Configuration: ```typescript const getSignaturesForAddressWithConfig = async ( address: string, config: { limit?: number; before?: string; until?: string; commitment?: 'processed' | 'confirmed' | 'finalized'; minContextSlot?: number; } ) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'getSignaturesForAddress', params: [ address, config ] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get signatures: ${data.error.message}`); } return data; }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: string, result: [ { signature: string, // The transaction signature as base-58 encoded string slot: number, // The slot that contains this transaction err: any, // Error if transaction failed, null if successful memo: string | null, // Memo associated with the transaction, if any blockTime: number | null, // Estimated production time of transaction confirmationStatus: 'processed' | 'confirmed' | 'finalized' } ] } ``` #### Error Responses ```typescript // Invalid Address Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid address' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid address format) - -32005: Node is behind by specified commitment - -32009: Transaction history not available - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Address must be a base-58 encoded string 2. Results are returned in reverse chronological order 3. Maximum of 1000 signatures per request 4. Use `before` and `until` for pagination 5. `blockTime` may be null for old transactions 6. Rate limits apply based on your API tier 7. Historical data may be limited 8. Memos are only included if present 9. Confirmation status depends on commitment level 10. Results include failed transactions #### Common Use Cases 1. Account transaction history 2. Payment tracking 3. Activity monitoring 4. Transaction analysis 5. Historical data collection 6. Audit trail generation 7. Balance reconciliation 8. Program interaction tracking 9. User activity feeds 10. Smart contract monitoring #### Best Practices 1. Implement pagination for large result sets 2. Cache results when appropriate 3. Use appropriate commitment level 4. Handle rate limits with backoff 5. Verify address format before querying 6. Monitor error responses 7. Implement timeout handling 8. Log failed queries 9. Use webhooks for real-time updates 10. Consider data retention limits ### getProgramAccounts Returns all accounts owned by the provided program public key. This is a powerful endpoint for querying program state and finding all accounts associated with a specific program. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Endpoint Structure ```typescript { protocol: "https", origin: "mainnet.helius-rpc.com", path: "/?api-key=YOUR_API_KEY", method: "POST" } ``` #### Parameters 1. `` (string, required) - Public key of the program to query, as base-58 encoded string 2. `` (object, optional) - Configuration object containing: - `encoding` (string): Encoding for account data - Possible values: "base58", "base64", "base64+zstd", "jsonParsed" - `commitment` (string): Bank state to query - Possible values: "processed", "confirmed", "finalized" - `dataSlice` (object): Limit the returned account data - `offset` (number): Number of bytes to skip - `length` (number): Number of bytes to return - `filters` (array): Filter results using various filter objects: - `memcmp` (object): Match a chunk of data at a specific offset - `offset` (number): Offset into program account data to start comparison - `bytes` (string): Data to match, as base-58 encoded string or base64 - `dataSize` (number): Match the exact program account data length - `withContext` (boolean): Return the context object #### Implementation Examples 1. Basic Implementation: ```typescript const getProgramAccounts = async (programId: string) => { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: `prog-${Date.now()}`, method: 'getProgramAccounts', params: [programId] }) }); return await response.json(); }; ``` 2. Proxy Implementation: ```typescript const getProgramAccountsViaProxy = async ( programId: string, config: { encoding: string; commitment: string } ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: `prog-${Date.now()}`, method: 'getProgramAccounts', params: [ programId, config ] }) }) }); return await response.json(); }; ``` 3. With Advanced Filtering: ```typescript const getProgramAccountsWithFilters = async ( programId: string, config: { encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed'; commitment?: 'processed' | 'confirmed' | 'finalized'; dataSlice?: { offset: number; length: number; }; filters?: Array<{ memcmp?: { offset: number; bytes: string; }; dataSize?: number; }>; withContext?: boolean; } ) => { try { const response = await fetch(MAINNET_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', id: `prog-${Date.now()}`, method: 'getProgramAccounts', params: [ programId, config ] }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get program accounts: ${data.error.message}`); } return data; } catch (error) { console.error('Error fetching program accounts:', error); throw error; } }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: string, result: [ { pubkey: string, // The account's public key as base-58 encoded string account: { lamports: number, // Number of lamports assigned to the account owner: string, // Base-58 encoded public key of the program that owns this account data: [ // Account data as specified by the encoding parameter string, // The encoded data string // The encoding used for the data ], executable: boolean, // Whether this account contains a program rentEpoch: number, // The epoch at which this account will next owe rent space: number // The data size of the account } } ] } ``` #### Error Responses ```typescript // Invalid Program ID Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid program id' }, id: '1' } // Invalid Filter Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid param: Invalid filter' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid program ID or filter) - -32005: Node is behind by specified commitment - -32007: Slot skipped by leader - -32009: Invalid account data - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. This endpoint can be resource-intensive for programs with many accounts 2. Use filters to reduce response size and improve performance 3. Consider using dataSlice when full account data isn't needed 4. Different encoding options affect response size and parsing requirements 5. Rate limits are especially important for this endpoint 6. Results may change between requests as accounts are created/modified 7. Some programs may have thousands of accounts 8. Account data format varies by program 9. Executable accounts have different data structure 10. Consider pagination for large result sets #### Common Use Cases 1. Token account discovery 2. Program state analysis 3. Account monitoring 4. Balance tracking 5. Program activity analysis 6. Smart contract debugging 7. Account enumeration 8. State auditing 9. Data indexing 10. Program interaction analysis #### Best Practices 1. Always use appropriate filters to limit results 2. Cache results when possible 3. Implement rate limiting and backoff 4. Use appropriate encoding for your use case 5. Handle large result sets appropriately 6. Monitor response times 7. Validate program ID before querying 8. Consider using dataSlice for efficiency 9. Implement error handling for timeouts 10. Use commitment level appropriate for your use case #### Performance Optimization 1. Use memcmp filters to reduce result set 2. Implement client-side caching 3. Use dataSlice when possible 4. Choose appropriate encoding 5. Batch requests when possible 6. Implement request timeouts 7. Use pagination for large results 8. Monitor memory usage 9. Cache frequently accessed accounts 10. Use appropriate commitment levels #### Security Considerations 1. Validate program IDs 2. Handle sensitive account data appropriately 3. Implement rate limiting 4. Monitor for suspicious patterns 5. Validate account ownership 6. Handle errors gracefully 7. Protect API keys 8. Validate response data 9. Implement request timeouts 10. Monitor for abuse # Digital Asset Standard (DAS) API ## Introduction The Digital Asset Standard (DAS) API provides a unified interface for interacting with digital assets on Solana, including fungible tokens, regular NFTs, and compressed NFTs. This section covers the implementation of DAS API endpoints. ## Base Configuration ```typescript const DAS_BASE_ENDPOINTS = { mainnet: 'https://mainnet.helius-rpc.com', devnet: 'https://devnet.helius-rpc.com' }; // Standard DAS request configuration const makeDAStRequest = async ( method: string, params: any[], network: 'mainnet' | 'devnet' = 'mainnet' ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: `${network}.helius-rpc.com`, path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: `das-${Date.now()}`, method, params }) }) }); const data = await response.json(); if ('error' in data) { throw new Error(`DAS request failed: ${data.error.message}`); } return data; }; ``` ## Important Implementation Notes 1. **Asset Types Support**: - Regular NFTs - Compressed NFTs - Fungible Tokens - Token-2022 Standard 2. **Response Handling**: - All responses include standard JSON-RPC 2.0 format - Error handling for both RPC and API-specific errors - Pagination support for large result sets 3. **Best Practices**: - Use appropriate network endpoint - Implement proper error handling - Cache results when possible - Handle rate limits - Validate input parameters 4. **Common Patterns**: - Asset lookup by ID - Batch operations - Owner-based queries - Asset proofs for compressed NFTs - Search and filtering ## DAS Methods ### getAsset Returns all relevant information about a digital asset (NFT or Token) by its ID. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters 1. `id` (string, required) - The asset ID to query 2. `displayOptions` (object, optional): - `showFungible` (boolean): Include fungible token details - `showInscription` (boolean): Include inscription and SPL-20 data #### Implementation Examples 1. Basic Implementation: ```typescript const getAsset = async (assetId: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAsset', params: { id: assetId } }) }) }); return await response.json(); }; ``` 2. With Display Options: ```typescript const getAssetWithOptions = async ( assetId: string, showFungible: boolean = false, showInscription: boolean = false ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAsset', params: { id: assetId, displayOptions: { showFungible, showInscription } } }) }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get asset: ${data.error.message}`); } return data; }; ``` 3. Using Utility Function: ```typescript const getAssetUsingUtility = async ( assetId: string, options?: { showFungible?: boolean; showInscription?: boolean; } ) => { return await makeDAStRequest('getAsset', [{ id: assetId, displayOptions: options }]); }; ``` #### Response Format ```typescript interface AssetResponse { jsonrpc: '2.0'; id: string; result: { interface: 'V1_NFT'; id: string; content: { $schema: string; json_uri: string; files: any[]; metadata: { name: string; symbol: string; }; }; authorities: Array<{ address: string; scopes: string[]; }>; compression: { eligible: boolean; compressed: boolean; data_hash: string; creator_hash: string; asset_hash: string; tree: string; seq: number; leaf_id: number; }; grouping: Array<{ group_key: string; group_value: string; }>; royalty: { royalty_model: string; target: string; percent: number; basis_points: number; primary_sale_happened: boolean; locked: boolean; }; creators: Array<{ address: string; share: number; verified: boolean; }>; ownership: { frozen: boolean; delegated: boolean; delegate: string; ownership_model: string; owner: string; }; supply: { print_max_supply: number; print_current_supply: number; edition_nonce: number; }; mutable: boolean; burnt: boolean; token_info?: { supply: number; decimals: number; token_program: string; mint_authority: string; freeze_authority: string; }; }; } ``` #### Error Responses ```typescript // Asset Not Found { jsonrpc: '2.0', error: { code: -32602, message: 'Asset not found' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid asset ID) - -32603: Internal error - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Asset ID must be a valid Solana public key 2. Use `showFungible` for fungible token details 3. Use `showInscription` for inscription/SPL-20 data 4. Response includes compression status 5. Creators array shows royalty distribution 6. Token info only present for fungible tokens 7. Rate limits apply based on your API tier 8. Compression details only for cNFTs 9. Ownership shows current state 10. Content includes metadata URIs #### Common Use Cases 1. NFT metadata retrieval 2. Token information lookup 3. Ownership verification 4. Royalty calculation 5. Compression status check 6. Creator verification 7. Asset type determination 8. Metadata display 9. Supply tracking 10. Authority validation ### getAssetsByOwner Returns a list of all assets owned by a specific wallet address, including NFTs, compressed NFTs, fungible tokens, and Token22 tokens. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters 1. `ownerAddress` (string, required) - The wallet address to query 2. `page` (number, optional) - Page number, starts at 1 3. `limit` (number, optional) - Number of items per page (max 1000) 4. `displayOptions` (object, optional): - `showFungible` (boolean): Include fungible token details - `showInscription` (boolean): Include inscription and SPL-20 data - `showNativeBalance` (boolean): Include native SOL balance #### Implementation Examples 1. Basic Implementation: ```typescript const getAssetsByOwner = async (ownerAddress: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAssetsByOwner', params: { ownerAddress, page: 1, limit: 1000 } }) }) }); return await response.json(); }; ``` 2. With Display Options: ```typescript const getAssetsByOwnerWithOptions = async ( ownerAddress: string, options?: { page?: number; limit?: number; showFungible?: boolean; showInscription?: boolean; showNativeBalance?: boolean; } ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAssetsByOwner', params: { ownerAddress, page: options?.page || 1, limit: options?.limit || 1000, displayOptions: { showFungible: options?.showFungible, showInscription: options?.showInscription, showNativeBalance: options?.showNativeBalance } } }) }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get assets: ${data.error.message}`); } return data; }; ``` 3. Using Utility Function: ```typescript const getAssetsByOwnerUsingUtility = async ( ownerAddress: string, options?: { page?: number; limit?: number; showFungible?: boolean; showInscription?: boolean; showNativeBalance?: boolean; } ) => { return await makeDAStRequest('getAssetsByOwner', [{ ownerAddress, page: options?.page || 1, limit: options?.limit || 1000, displayOptions: { showFungible: options?.showFungible, showInscription: options?.showInscription, showNativeBalance: options?.showNativeBalance } }]); }; ``` #### Response Format ```typescript interface AssetsByOwnerResponse { jsonrpc: '2.0'; id: string; result: { total: number; limit: number; page: number; items: Array<{ interface: 'V1_NFT'; id: string; content: { $schema: string; json_uri: string; files: Array<{ uri: string; cdn_uri: string; mime: string; }>; }; authorities: Array<{ address: string; scopes: string[]; }>; compression: { eligible: boolean; compressed: boolean; data_hash: string; creator_hash: string; asset_hash: string; tree: string; seq: number; leaf_id: number; }; grouping: Array<{ group_key: string; group_value: string; }>; royalty: { royalty_model: string; target: string | null; percent: number; basis_points: number; primary_sale_happened: boolean; locked: boolean; }; creators: Array<{ address: string; share: number; verified: boolean; }>; ownership: { frozen: boolean; delegated: boolean; delegate: string; ownership_model: string; owner: string; }; supply: { print_max_supply: number; print_current_supply: number; edition_nonce: number; }; mutable: boolean; burnt: boolean; }>; nativeBalance?: { lamports: number; }; }; } ``` #### Error Responses ```typescript // Invalid Address Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid owner address' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid address) - -32603: Internal error - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Owner address must be a valid Solana public key 2. Page numbering starts at 1 3. Maximum limit per request is 1000 items 4. Use `showFungible` to include token balances 5. Use `showInscription` for SPL-20 tokens 6. Use `showNativeBalance` for SOL balance 7. Results are paginated for large collections 8. Rate limits apply based on your API tier 9. Response includes both NFTs and tokens 10. Compression status included for cNFTs #### Common Use Cases 1. Wallet portfolio viewer 2. Token-gated applications 3. NFT collection display 4. Balance tracking 5. Asset management 6. Portfolio valuation 7. Collection tracking 8. Token holdings display 9. Wallet activity monitoring 10. Asset verification ### getAssetsByCreator Returns a list of assets created by a specific address, including both compressed and standard NFTs. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Parameters 1. `creatorAddress` (string, required) - The creator's address to query 2. `page` (number, optional) - Page number, starts at 1 3. `limit` (number, optional) - Number of items per page 4. `onlyVerified` (boolean, optional) - Only return verified creator assets #### Implementation Examples 1. Basic Implementation: ```typescript const getAssetsByCreator = async (creatorAddress: string) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAssetsByCreator', params: { creatorAddress, page: 1, limit: 1000 } }) }) }); return await response.json(); }; ``` 2. With Options: ```typescript const getAssetsByCreatorWithOptions = async ( creatorAddress: string, options?: { page?: number; limit?: number; onlyVerified?: boolean; } ) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', headers: { 'Content-Type': 'application/json', }, method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'das-' + Date.now(), method: 'getAssetsByCreator', params: { creatorAddress, page: options?.page || 1, limit: options?.limit || 1000, onlyVerified: options?.onlyVerified } }) }) }); const data = await response.json(); if ('error' in data) { throw new Error(`Failed to get assets by creator: ${data.error.message}`); } return data; }; ``` 3. Using Utility Function: ```typescript const getAssetsByCreatorUsingUtility = async ( creatorAddress: string, options?: { page?: number; limit?: number; onlyVerified?: boolean; } ) => { return await makeDAStRequest('getAssetsByCreator', [{ creatorAddress, page: options?.page || 1, limit: options?.limit || 1000, onlyVerified: options?.onlyVerified }]); }; ``` #### Response Format ```typescript interface AssetsByCreatorResponse { jsonrpc: '2.0'; result: { total: number; limit: number; page: number; items: Array<{ interface: string; id: string; content: { $schema: string; json_uri: string; files: Array<{ uri: string; cdn_uri: string; mime: string; }>; }; authorities: Array<{ address: string; scopes: string[]; }>; compression: { eligible: boolean; compressed: boolean; data_hash: string; creator_hash: string; asset_hash: string; tree: string; seq: number; leaf_id: number; }; grouping: Array<{ group_key: string; group_value: string; }>; royalty: { royalty_model: string; target: string | null; percent: number; basis_points: number; primary_sale_happened: boolean; locked: boolean; }; creators: Array<{ address: string; share: number; verified: boolean; }>; ownership: { frozen: boolean; delegated: boolean; delegate: string | null; ownership_model: string; owner: string; }; }>; }; } ``` #### Error Responses ```typescript // Invalid Creator Address Error { jsonrpc: '2.0', error: { code: -32602, message: 'Invalid creator address' }, id: '1' } // Rate Limit Error { jsonrpc: '2.0', error: { code: 429, message: 'Too many requests' }, id: '1' } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid creator address) - -32603: Internal error - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Creator address must be a valid Solana public key 2. Page numbering starts at 1 3. Results include both compressed and standard NFTs 4. Use `onlyVerified` to filter for verified creator assets 5. Results are paginated for large collections 6. Rate limits apply based on your API tier 7. Response includes detailed asset information 8. Compression status included for each asset 9. Creator verification status included 10. Royalty information included #### Common Use Cases 1. NFT creator portfolio 2. Collection management 3. Creator verification 4. Royalty tracking 5. Collection analytics 6. NFT search engine 7. Creator dashboard 8. Asset verification 9. Collection monitoring 10. Marketplace integration ### getTokenAccounts Get information about all token accounts for a specific mint or a specific owner. This is an efficient way to get all the owners of an SPL token or all tokens owned by a particular address. #### Request Format - **Method**: POST - **Content-Type**: application/json #### Implementation Examples 1. Basic Implementation (Get token accounts by owner): ```typescript const getTokenAccounts = async (owner: string, showZeroBalance: boolean = false) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'helius-test', method: 'getTokenAccounts', params: { page: 1, limit: 100, displayOptions: { showZeroBalance }, owner } }) }) }); return await response.json(); }; ``` 2. Paginated Implementation (Get all token holders): ```typescript const getAllTokenHolders = async (mint: string) => { let allHolders = new Set(); let cursor; while (true) { const params: any = { limit: 1000, mint }; if (cursor) { params.cursor = cursor; } const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'mainnet.helius-rpc.com', path: '/?api-key=YOUR_API_KEY', method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id: 'helius-test', method: 'getTokenAccounts', params }) }) }); const data = await response.json(); if (!data.result || data.result.token_accounts.length === 0) { break; } data.result.token_accounts.forEach((account: any) => { allHolders.add(account.owner); }); cursor = data.result.cursor; if (!cursor) break; } return Array.from(allHolders); }; ``` #### Response Format ```typescript { jsonrpc: '2.0', id: string, result: { total: number, // Total number of results limit: number, // Maximum results per page cursor?: string, // Cursor for pagination token_accounts: Array<{ address: string, // Token account address mint: string, // Token mint address owner: string, // Token account owner amount: number, // Token amount delegated_amount: number, // Delegated token amount frozen: boolean // Whether the account is frozen }> } } ``` #### Error Handling Common error codes: - -32602: Invalid parameter (e.g., invalid owner or mint address) - -32005: Node is behind by specified commitment - 429: Too many requests (rate limit exceeded) #### Usage Notes 1. Use `showZeroBalance` flag to include empty token accounts 2. Maximum of 1000 results per request 3. Use cursor-based pagination for large result sets 4. Results include both SPL tokens and Token-2022 accounts 5. Rate limits apply based on your API tier #### Common Use Cases 1. Getting all holders of a specific token 2. Retrieving a wallet's token holdings 3. Token holder analytics 4. Balance monitoring 5. Token distribution analysis ### parseTransaction Returns enriched, human-readable transaction information for given transaction signatures. #### Request Format - **Method**: POST - **Content-Type**: application/json - **URL**: `https://api.helius.xyz/v0/transactions/?api-key=secret_cm915zrti00023b6rd7l3lj3o` #### Implementation ```typescript const parseTransaction = async (transactionSignatures: string[]) => { const response = await fetch('/api/proxy', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ protocol: 'https', origin: 'api.helius.xyz', path: '/v0/transactions/?api-key=secret_cm915zrti00023b6rd7l3lj3o', method: 'POST', body: JSON.stringify({ transactions: transactionSignatures }) }) }); return await response.json(); }; ``` #### Response Format ```typescript { description: string, // Human readable interpretation type: string, // Transaction type source: string, // Transaction source fee: number, // Transaction fee feePayer: string, // Fee payer address signature: string, // Transaction signature slot: number, // Slot number timestamp: number, // Unix timestamp nativeTransfers: Array<{ // SOL transfers fromUserAccount: string, toUserAccount: string, amount: number }>, tokenTransfers: Array<{ // Token transfers fromUserAccount: string, toUserAccount: string, tokenAmount: number, mint: string }>, accountData: Array<{ // Account changes account: string, nativeBalanceChange: number, tokenBalanceChanges: Array<{ userAccount: string, tokenAccount: string, mint: string, rawTokenAmount: { tokenAmount: string, decimals: number } }> }>, events: { // Parsed events (NFT, swap, etc) nft?: object, swap?: object, compressed?: object } } ``` #### Error Codes - -32602: Invalid parameter - 429: Rate limit exceeded #### Key Notes 1. Maximum 100 transactions per request 2. Parses NFT actions, Jupiter swaps, and SPL transactions 3. Returns human-readable format with detailed event parsing

Bulk Transfer App