getSignaturesForAddress

​

Parameters

​

Response

​

Code Examples

​

Basic Request

curl https://rpc.orbitflare.com -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "ADDRESS"
  ]
}'

​

Request with Config

curl https://rpc.orbitflare.com -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "ADDRESS",
    {
      "limit": 100,
      "before": "SIGNATURE",
      "commitment": "confirmed"
    }
  ]
}'

​

Using web3.js

import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://rpc.orbitflare.com');

// Get signatures for address
const signatures = await connection.getSignaturesForAddress(
  new PublicKey('ADDRESS')
);
console.log('Signatures:', signatures);

// Get paginated signatures
async function getPaginatedSignatures(
  address: PublicKey,
  limit: number = 100,
  before?: string
) {
  const signatures = await connection.getSignaturesForAddress(address, {
    limit,
    before
  });
  
  return signatures.map(signature => ({
    signature: signature.signature,
    slot: signature.slot,
    success: !signature.err,
    timestamp: signature.blockTime,
    status: signature.confirmationStatus
  }));
}

​

Notes

1. Returns confirmed transaction signatures for an address
2. Results are returned in reverse chronological order
3. Pagination can be achieved using the before parameter
4. The response is immediate as it reads from the current state
5. Different commitment levels can be specified

​

Best Practices

1. Use appropriate limit based on your needs
2. Implement pagination for large result sets
3. Cache results when appropriate to reduce RPC load
4. Consider using websocket subscription for real-time updates
5. Handle network errors and retry when appropriate

​

Common Errors

​

Use Cases

1. Transaction History

   interface TransactionHistory {
     transactions: Array<{
       signature: string;
       slot: number;
       success: boolean;
       timestamp: number;
       status: string;
     }>;
     metadata: {
       total: number;
       startTime: number;
       endTime: number;
     };
   }
   
   async function getTransactionHistory(
     address: PublicKey,
     limit: number = 100
   ): Promise<TransactionHistory> {
     const signatures = await connection.getSignaturesForAddress(address, {
       limit
     });
     
     return {
       transactions: signatures.map(signature => ({
         signature: signature.signature,
         slot: signature.slot,
         success: !signature.err,
         timestamp: signature.blockTime || 0,
         status: signature.confirmationStatus || 'unknown'
       })),
       metadata: {
         total: signatures.length,
         startTime: signatures[0]?.blockTime || 0,
         endTime: signatures[signatures.length - 1]?.blockTime || 0
       }
     };
   }
   

2. Transaction Monitoring

   interface TransactionAlert {
     type: 'new' | 'failed' | 'status_change';
     signature: string;
     previousStatus: string | null;
     currentStatus: string;
     metadata: {
       timestamp: number;
       slot: number;
     };
   }
   
   class TransactionMonitor {
     private previousSignatures: Map<string, any> = new Map();
     
     async monitorTransactions(
       address: PublicKey,
       interval: number = 5000
     ): Promise<TransactionAlert[]> {
       const signatures = await connection.getSignaturesForAddress(address, {
         limit: 10
       });
       const alerts: TransactionAlert[] = [];
       
       signatures.forEach(signature => {
         const previous = this.previousSignatures.get(signature.signature);
         
         if (!previous) {
           alerts.push({
             type: 'new',
             signature: signature.signature,
             previousStatus: null,
             currentStatus: signature.confirmationStatus || 'unknown',
             metadata: {
               timestamp: Date.now(),
               slot: signature.slot
             }
           });
         } else if (previous.confirmationStatus !== signature.confirmationStatus) {
           alerts.push({
             type: 'status_change',
             signature: signature.signature,
             previousStatus: previous.confirmationStatus,
             currentStatus: signature.confirmationStatus || 'unknown',
             metadata: {
               timestamp: Date.now(),
               slot: signature.slot
             }
           });
         }
         
         this.previousSignatures.set(signature.signature, signature);
       });
       
       return alerts;
     }
   }
   

3. Transaction Analysis

   interface TransactionAnalysis {
     total: number;
     successful: number;
     failed: number;
     statusDistribution: Record<string, number>;
     timeDistribution: {
       hourly: Record<number, number>;
       daily: Record<number, number>;
     };
     metadata: {
       startTime: number;
       endTime: number;
       duration: number;
     };
   }
   
   async function analyzeTransactions(
     address: PublicKey,
     limit: number = 1000
   ): Promise<TransactionAnalysis> {
     const signatures = await connection.getSignaturesForAddress(address, {
       limit
     });
     
     const statusDistribution: Record<string, number> = {};
     const hourlyDistribution: Record<number, number> = {};
     const dailyDistribution: Record<number, number> = {};
     
     let successful = 0;
     let failed = 0;
     
     signatures.forEach(signature => {
       const status = signature.confirmationStatus || 'unknown';
       statusDistribution[status] = (statusDistribution[status] || 0) + 1;
       
       if (signature.err) {
         failed++;
       } else {
         successful++;
       }
       
       if (signature.blockTime) {
         const date = new Date(signature.blockTime * 1000);
         const hour = date.getHours();
         const day = date.getDay();
         
         hourlyDistribution[hour] = (hourlyDistribution[hour] || 0) + 1;
         dailyDistribution[day] = (dailyDistribution[day] || 0) + 1;
       }
     });
     
     return {
       total: signatures.length,
       successful,
       failed,
       statusDistribution,
       timeDistribution: {
         hourly: hourlyDistribution,
         daily: dailyDistribution
       },
       metadata: {
         startTime: signatures[0]?.blockTime || 0,
         endTime: signatures[signatures.length - 1]?.blockTime || 0,
         duration: signatures.length > 1
           ? (signatures[0]?.blockTime || 0) - (signatures[signatures.length - 1]?.blockTime || 0)
           : 0
       }
     };
   }