> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Comment utiliser getSignaturesForAddress
> Découvrez les cas d'utilisation de getSignaturesForAddress, des exemples de code, des paramètres de requête, la structure des réponses et des conseils.
La méthode RPC [`getSignaturesForAddress`](https://www.helius.dev/docs/api-reference/rpc/http/getsignaturesforaddress) vous permet de récupérer une liste de signatures de transactions confirmées impliquant une adresse de compte spécifique. Cela est utile pour récupérer l'historique des transactions d'un compte. Les signatures sont renvoyées dans l'ordre chronologique inverse (les plus récentes en premier).
Pour le filtrage avancé, le tri et l'historique des comptes de jetons, utilisez [`getTransactionsForAddress`](/docs/fr/rpc/gettransactionsforaddress) à la place. Notez que `getSignaturesForAddress` n'inclut pas les transactions impliquant des comptes de jetons associés.
## Cas d'utilisation communs
* **Historique des transactions du compte :** Affichage des transactions passées pour le portefeuille d'un utilisateur. Pour une analyse plus avancée de l'historique des transactions, envisagez d'utiliser l'[API Transactions améliorées](https://www.helius.dev/docs/enhanced-transactions) de Helius.
* **Audit d'activité :** Révision de toutes les transactions associées à un contrat intelligent ou à un compte particulier.
* **Recherche de transaction spécifique :** Trouver une transaction spécifique en parcourant l'historique d'un compte si seule l'adresse impliquée est connue.
* **Indexation des données :** Création d'un index localisé des transactions pour une interrogation et une analyse plus rapides.
## Paramètres de la requête
1. **`address`** (`string`): (Requis) La clé publique encodée en base-58 du compte pour lequel récupérer les signatures de transactions.
2. **`options`** (`object`, optionnel) : Un objet de configuration optionnel avec les champs suivants :
* **`limit`** (`number`, optionnel) : Le nombre maximum de signatures à retourner. La valeur par défaut est 1000, et le maximum autorisé est 1000.
* **`before`** (`string`, optionnel) : Une signature de transaction encodée en base-58. Si fourni, la requête commencera à rechercher des transactions avant cette signature.
* **`until`** (`string`, optionnel) : Une signature de transaction encodée en base-58. Si spécifié, la requête recherchera des transactions jusqu'à atteindre cette signature (exclusif).
* **`commitment`** (`string`, optionnel) : Spécifie le [niveau d'engagement](https://www.helius.dev/blog/solana-commitment-levels) à utiliser pour la requête. Les valeurs prises en charge sont `finalized` ou `confirmed`. L'engagement `processed` n'est pas pris en charge. Si omis, l'engagement par défaut du nœud RPC est utilisé (généralement `finalized`).
* **`minContextSlot`** (`number`, optionnel) : Le minimum de slots auquel la requête peut être évaluée. Ce n'est pas un filtre sur les transactions historiques mais définit le minimum de slots pour le contexte du nœud.
**Regroupement non pris en charge**
Cette méthode d'archivage ne prend pas en charge le regroupement. Effectuez uniquement des requêtes individuelles.
## Structure de la réponse
Le champ `result` de la réponse JSON-RPC est un tableau d'objets d'informations sur les signatures. Chaque objet a la structure suivante :
* **`signature`** (`string`): La signature de transaction encodée en base-58.
* **`slot`** (`u64`): Le slot dans lequel la transaction a été traitée.
* **`err`** (`object` | `null`): Un objet d'erreur si la transaction a échoué, ou `null` si elle a réussi.
* **`memo`** (`string` | `null`): Le mémo associé à la transaction, le cas échéant.
* **`blockTime`** (`i64` | `null`): Le temps de production estimé du bloc contenant la transaction, en tant que timestamp Unix (secondes depuis l'ère). `null` si non disponible.
* **`confirmationStatus`** (`string` | `null`): Le statut de confirmation de la transaction (e.g., `processed`, `confirmed`, `finalized`). `null` si non disponible (e.g., pour les réponses Helius plus anciennes).
## Exemples
### 1. Obtenez les signatures les plus récentes pour une adresse
Cet exemple récupère les signatures de transactions les plus récentes (jusqu'à 1000) pour une adresse donnée.
```bash cURL theme={"system"}
# Replace with your Helius API key
# Replace SYSTEM_PROGRAM_ID with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"11111111111111111111111111111111"
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function getLatestSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query
const address = new PublicKey('11111111111111111111111111111111');
try {
const signatures = await connection.getSignaturesForAddress(address);
if (signatures && signatures.length > 0) {
console.log(`Found ${signatures.length} signatures:`);
signatures.forEach((sigInfo, index) => {
console.log(`--- Signature ${index + 1} ---`);
console.log(` Signature: ${sigInfo.signature}`);
console.log(` Slot: ${sigInfo.slot}`);
console.log(` Block Time: ${sigInfo.blockTime ? new Date(sigInfo.blockTime * 1000).toLocaleString() : 'N/A'}`);
console.log(` Error: ${JSON.stringify(sigInfo.err)}`);
console.log(` Memo: ${sigInfo.memo || 'N/A'}`);
console.log(` Confirmation Status: ${sigInfo.confirmationStatus || 'N/A'}`);
});
} else {
console.log('No signatures found for this address.');
}
} catch (error) {
console.error('Error fetching signatures:', error);
}
}
getLatestSignatures();
```
### 2. Obtenez des signatures avec une limite
Cet exemple récupère un nombre spécifié de signatures de transactions récentes pour une adresse.
```bash cURL theme={"system"}
# Replace with your Helius API key
# Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{
"limit": 5
}
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function getLimitedSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query
const address = new PublicKey('Vote111111111111111111111111111111111111111');
const limit = 5;
try {
const signatures = await connection.getSignaturesForAddress(address, { limit });
console.log(`Fetched up to ${limit} signatures:`);
signatures.forEach((sigInfo, index) => {
console.log(`${index + 1}. Signature: ${sigInfo.signature}, Slot: ${sigInfo.slot}`);
});
} catch (error) {
console.error(`Error fetching limited signatures for ${address.toBase58()}:`, error);
}
}
getLimitedSignatures();
```
### 3. Pagination dans l'historique des transactions
Cet exemple montre comment récupérer l'historique des transactions par lots en utilisant le paramètre `before`.
```bash cURL theme={"system"}
# Initial request (get the latest 2)
# Replace with your Helius API key
# Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{ "limit": 2 }
]
}'
# Suppose the last signature from the above response was LAST_SIGNATURE_FROM_PREVIOUS_BATCH
# Fetch the next 2 transactions before that one
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{
"limit": 2,
"before": "LAST_SIGNATURE_FROM_PREVIOUS_BATCH"
}
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function paginateSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query - e.g. a known active address
const address = new PublicKey('Vote111111111111111111111111111111111111111');
const batchSize = 2;
let lastSignature = null;
let allSignatures = [];
const maxPages = 3; // Limit how many pages we fetch for this example
try {
for (let i = 0; i < maxPages; i++) {
console.log(`Fetching page ${i + 1}...`);
const options = { limit: batchSize };
if (lastSignature) {
options.before = lastSignature;
}
const signatures = await connection.getSignaturesForAddress(address, options);
if (signatures.length === 0) {
console.log('No more signatures found.');
break;
}
signatures.forEach(sigInfo => {
allSignatures.push(sigInfo.signature);
console.log(` Found: ${sigInfo.signature} in slot ${sigInfo.slot}`);
});
lastSignature = signatures[signatures.length - 1]?.signature;
if (signatures.length < batchSize || !lastSignature) {
console.log('Fetched all available signatures or reached end of page.');
break;
}
// Optional: Add a small delay if making many sequential requests
// await new Promise(resolve => setTimeout(resolve, 200));
}
console.log(`
Total signatures fetched (${allSignatures.length}):`);
allSignatures.forEach((sig, idx) => console.log(`${idx + 1}. ${sig}`));
} catch (error) {
console.error('Error paginating signatures:', error);
}
}
paginateSignatures();
```
## Conseils pour les développeurs
* **Pagination :** Pour obtenir un historique de transactions complet pour un compte actif, vous devrez probablement effectuer plusieurs requêtes, en utilisant le paramètre `before` avec la dernière signature reçue dans le lot précédent et un `limit`.
* **Limites de taux :** Faites attention aux limites de taux des nœuds RPC lors de la récupération d'historiques de transactions étendus.
* **Ordre :** Les signatures sont toujours renvoyées des plus récentes aux plus anciennes.
* **Paramètre `limit` :** Le paramètre `limit` peut être compris entre 1 et 1000. Si non spécifié, il est par défaut à 1000.
* **Paramètre `until` :** Ce paramètre peut être utilisé pour arrêter de récupérer des signatures si une signature plus ancienne connue est atteinte, ce qui peut être utile si vous ne souhaitez que des transactions jusqu'à un certain point.
* **`minContextSlot` :** Ce paramètre ne filtre pas les transactions historiques. Il spécifie le minimum de slots que le nœud RPC doit utiliser pour son contexte lors de l’évaluation de la requête. Si l'état du nœud est plus ancien que ce slot, il peut renvoyer une erreur.
* **Détails de la transaction :** Cette méthode ne renvoie que les signatures et les informations de base. Pour obtenir les détails complets des transactions, vous utiliseriez la méthode `getTransaction` avec chaque signature.
* **Limitation des comptes de jetons :** Cette méthode ne renvoie que les transactions qui référencent directement l'adresse fournie. Elle n'inclut pas les transactions impliquant des comptes de jetons détenus par l'adresse. Pour un historique complet des jetons, y compris les comptes de jetons associés, utilisez [`getTransactionsForAddress`](/docs/fr/rpc/gettransactionsforaddress) avec le filtre `tokenAccounts`.
En utilisant `getSignaturesForAddress` avec ses options de pagination, vous pouvez efficacement récupérer et gérer les historiques de transactions pour toute adresse Solana.
## Méthodes associées
Filtrage avancé, tri et historique des comptes de jetons
Obtenez les détails complets de la transaction à partir d'une signature