> ## 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="поля конфигурации">
    <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>
      Уровень подтверждения (processed, confirmed, finalized)
    </ResponseField>
  </Expandable>
</ResponseField>

## Ответ

<ResponseField name="result" type="array">
  Массив объектов информации о подписях

  <ResponseField name="signature" type="string">
    Подпись транзакции (в кодировке base-58)
  </ResponseField>

  <ResponseField name="slot" type="number">
    Слот, в котором была обработана транзакция
  </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. Можно указать разные уровни подтверждения

## Рекомендации

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