> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# getSignaturesForAddress

> 返回地址的已确认交易签名

## 参数

<ResponseField name="address" type="string" required>
  账户地址（base-58 编码）
</ResponseField>

<ResponseField name="config" type="object" optional>
  <Expandable title="config fields">
    <ResponseField name="limit" type="number" optional>
      要返回的最大签名数量（默认：1000）
    </ResponseField>

    <ResponseField name="before" type="string" optional>
      从此签名开始向后搜索
    </ResponseField>

    <ResponseField name="until" type="string" optional>
      搜索直到此签名
    </ResponseField>

    <ResponseField name="commitment" type="string" optional>
      Commitment 级别（processed、confirmed、finalized）
    </ResponseField>
  </Expandable>
</ResponseField>

## 响应

<ResponseField name="result" type="array">
  签名信息对象数组

  <ResponseField name="signature" type="string">
    交易签名（base-58 编码）
  </ResponseField>

  <ResponseField name="slot" type="number">
    处理交易的 slot
  </ResponseField>

  <ResponseField name="err" type="object" optional>
    如果交易失败则为错误信息，成功则为 null
  </ResponseField>

  <ResponseField name="memo" type="string" optional>
    与交易关联的备忘录
  </ResponseField>

  <ResponseField name="blockTime" type="number" optional>
    交易处理的 Unix 时间戳
  </ResponseField>

  <ResponseField name="confirmationStatus" type="string" optional>
    交易确认状态
  </ResponseField>
</ResponseField>

## 代码示例

### 基本请求

```bash theme={null}
curl https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "ADDRESS"
  ]
}'
```

### 带配置的请求

```bash theme={null}
curl https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "ADDRESS",
    {
      "limit": 100,
      "before": "SIGNATURE",
      "commitment": "confirmed"
    }
  ]
}'
```

### 使用 web3.js

```typescript theme={null}
import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// 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
  }));
}
```

## 注意事项

1. 返回地址的已确认交易签名
2. 结果按时间倒序返回
3. 可以使用 `before` 参数实现分页
4. 响应是即时的，因为它从当前状态读取
5. 可以指定不同的 commitment 级别

## 最佳实践

1. 根据需求使用适当的限制数量
2. 对大型结果集实现分页
3. 在适当时缓存结果以减少 RPC 负载
4. 考虑使用 WebSocket 订阅获取实时更新
5. 适当处理网络错误并重试

## 常见错误

| 错误码    | 消息                                | 解决方案                  |
| ------ | --------------------------------- | --------------------- |
| -32601 | Method not found                  | 验证是否连接到 Solana RPC 节点 |
| -32602 | Invalid params                    | 检查地址和配置参数             |
| -32007 | Signature information unavailable | 节点可能正在启动或同步中          |

## 用例

1. **交易历史**
   ```typescript theme={null}
   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. **交易监控**
   ```typescript theme={null}
   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. **交易分析**
   ```typescript theme={null}
   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
       }
     };
   }
   ```