> ## 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 voir qui a financé un portefeuille Solana

> Découvrez la source de financement initiale de tout portefeuille Solana en retraçant son premier transfert SOL entrant. Identifiez le financement d'échange, l'attribution et les relations de portefeuille.

<Note>
  L'API Wallet est en version bêta. Les points de terminaison et les formats de réponse peuvent changer.
</Note>

## Aperçu

Le point de terminaison Wallet Funding Source identifie qui a initialement financé un portefeuille Solana en analysant son premier transfert SOL entrant. Il est précieux pour l'attribution, la conformité, la compréhension des relations de portefeuille et l'identification des portefeuilles financés par échange.

Le nom et la catégorie du financeur proviennent du même système d'identité utilisé par le point de terminaison [Identity](/docs/fr/wallet-api/identity), donc lorsque le financeur est une entité connue, vous obtenez une étiquette lisible par l'homme et une catégorie directement dans la réponse.

Ce point de terminaison nécessite un plan payant. Les demandes faites avec une clé API du plan gratuit renvoient `403 Forbidden`. Voir [Exigences du plan](/docs/fr/wallet-api/overview#exigences-du-plan) pour le tableau de couverture complet.

## Quand l'utiliser

Utilisez l'API Wallet Funding Source pour :

* **Attribution de portefeuille** : suivez d'où proviennent les financements des nouveaux portefeuilles.
* **Détection d'échange** : identifiez les portefeuilles financés directement par des échanges centralisés.
* **Conformité et AML** : signalez les portefeuilles financés par des entités connues pour des vérifications de conformité.
* **Détection de bots** : identifiez les fermes de bots financées par la même source.
* **Analyse de largage** : suivez quels portefeuilles ont reçu un financement initial d'un projet.
* **Détection Sybil** : trouvez des groupes de portefeuilles financés par la même adresse.

## Démarrage rapide

### Recherche de financement de base

Découvrez qui a financé un portefeuille :

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={"system"}
    const getWalletFundingSource = async (address) => {
      const url = `https://api.helius.xyz/v1/wallet/${address}/funded-by?api-key=YOUR_API_KEY`;

      const response = await fetch(url);

      if (response.status === 404) {
        console.log('No funding transaction found for this wallet');
        return null;
      }

      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }

      const funding = await response.json();

      console.log(`Funding Source: ${funding.funderName || funding.funder}`);
      console.log(`Funder Type: ${funding.funderType || 'Unknown'}`);
      console.log(`Initial Amount: ${funding.amount} SOL`);
      console.log(`Date: ${new Date(funding.timestamp * 1000).toLocaleString()}`);
      console.log(`Transaction: ${funding.explorerUrl}`);

      return funding;
    };

    getWalletFundingSource("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    import requests
    from datetime import datetime

    def get_wallet_funding_source(address: str):
        url = f"https://api.helius.xyz/v1/wallet/{address}/funded-by"
        headers = {"X-Api-Key": "YOUR_API_KEY"}

        response = requests.get(url, headers=headers)

        if response.status_code == 404:
            print('No funding transaction found for this wallet')
            return None

        response.raise_for_status()
        funding = response.json()

        print(f"Funding Source: {funding.get('funderName') or funding['funder']}")
        print(f"Funder Type: {funding.get('funderType', 'Unknown')}")
        print(f"Initial Amount: {funding['amount']} SOL")
        print(f"Date: {datetime.fromtimestamp(funding['timestamp']).strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"Transaction: {funding['explorerUrl']}")

        return funding

    get_wallet_funding_source("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY")
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://api.helius.xyz/v1/wallet/86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY/funded-by?api-key=YOUR_API_KEY"
    ```
  </Tab>
</Tabs>

## Format de réponse

Une réponse réussie décrit le premier transfert SOL entrant du portefeuille :

```json theme={"system"}
{
  "funder": "26MAyPNpK4At8LgRECMMbgiKQuJyg3oACtw1Q9FRyuba",
  "funderName": null,
  "funderType": null,
  "mint": "So11111111111111111111111111111111111111111",
  "symbol": "SOL",
  "amount": 0.09811972,
  "amountRaw": "98119720",
  "decimals": 9,
  "date": "2022-01-19T20:46:34.000Z",
  "signature": "5WX9C5kCQNULGGrSHJBR1WDFyetVyekbUpe1KQ45p3zEBe6jVgSsJuMqLWijjTDcnaAK2518ZriktRMCNycnsNAG",
  "timestamp": 1642625194,
  "slot": 116984883,
  "explorerUrl": "https://orbmarkets.io/tx/5WX9C5kCQNULGGrSHJBR1WDFyetVyekbUpe1KQ45p3zEBe6jVgSsJuMqLWijjTDcnaAK2518ZriktRMCNycnsNAG?tab=summary"
}
```

Si un portefeuille n'a jamais reçu de SOL, l'API renvoie un 404 :

```json theme={"system"}
{
  "error": "No funding transaction found",
  "code": 404
}
```

### Notes sur les champs

* **`funder`** : l'adresse qui a envoyé le premier transfert SOL à ce portefeuille.
* **`funderName`** : nom lisible par l'homme si le financeur est une entité connue (par exemple, échange, protocole) ; `null` sinon.
* **`funderType`** : catégorie du financeur (par exemple, `exchange`, `defi-protocol`) ; `null` si non dans la base de données d'identité.
* **`mint`** : adresse de la frappe du jeton (`So11111111111111111111111111111111111111111` pour SOL).
* **`symbol`** : symbole du jeton (toujours `SOL` pour les transactions de financement).
* **`amount`** : montant initial de SOL reçu (lisible par l'homme, par exemple, `0.05` SOL).
* **`amountRaw`** : montant brut en lamports en tant que chaîne (par exemple, `"50000000"` pour 0,05 SOL).
* **`decimals`** : nombre de décimales pour le jeton (9 pour SOL).
* **`date`** : chaîne de date formatée ISO 8601 (par exemple, `"2024-01-01T00:00:00.000Z"`).
* **`signature`** : signature de la transaction du transfert de financement.
* **`timestamp`** : horodatage Unix (en secondes) lorsque le portefeuille a été financé.
* **`slot`** : numéro de slot Solana lorsque la transaction de financement a été confirmée.
* **`explorerUrl`** : lien direct pour voir la transaction sur Orb.

## Cas d'utilisation

### Détecter les portefeuilles financés par échange

Identifiez les portefeuilles financés directement par des échanges centralisés :

```javascript theme={"system"}
const isExchangeFunded = async (address) => {
  try {
    const funding = await getWalletFundingSource(address);

    if (!funding) {
      console.log('Wallet has no funding transaction');
      return false;
    }

    if (funding.funderType === 'exchange') {
      console.log(`Wallet was funded by ${funding.funderName}`);
      console.log(`This is likely a retail user withdrawing from an exchange`);
      return true;
    }

    console.log(`Wallet was not funded by an exchange`);
    return false;

  } catch (error) {
    console.error('Error checking funding source:', error);
    return false;
  }
};

isExchangeFunded("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");
```

### Trouver des clusters de portefeuilles (détection Sybil)

Identifiez les groupes de portefeuilles financés par la même source :

```javascript theme={"system"}
const findWalletClusters = async (walletAddresses) => {
  const fundingData = await Promise.all(
    walletAddresses.map(async address => {
      try {
        const funding = await getWalletFundingSource(address);
        return { address, funder: funding?.funder };
      } catch {
        return { address, funder: null };
      }
    })
  );

  // Group by funder
  const clusters = {};

  fundingData.forEach(({ address, funder }) => {
    if (funder) {
      if (!clusters[funder]) {
        clusters[funder] = [];
      }
      clusters[funder].push(address);
    }
  });

  // Report clusters
  Object.entries(clusters).forEach(([funder, wallets]) => {
    if (wallets.length > 1) {
      console.log(`\nFound cluster: ${wallets.length} wallets funded by ${funder.slice(0, 8)}...`);
      wallets.forEach(wallet => console.log(`  - ${wallet}`));
    }
  });

  return clusters;
};

// Example: Check list of wallets for clusters
const suspiciousWallets = [
  "Wallet1...",
  "Wallet2...",
  "Wallet3..."
];

findWalletClusters(suspiciousWallets);
```

### Suivre les destinataires de largage

Analysez d'où viennent les destinataires de largage :

```javascript theme={"system"}
const analyzeAirdropRecipients = async (airdropWallets) => {
  const fundingSources = await Promise.all(
    airdropWallets.map(async address => {
      try {
        return await getWalletFundingSource(address);
      } catch {
        return null;
      }
    })
  );

  const stats = {
    total: airdropWallets.length,
    exchangeFunded: 0,
    unknown: 0,
    byExchange: {}
  };

  fundingSources.forEach(funding => {
    if (!funding) {
      stats.unknown++;
      return;
    }

    if (funding.funderType === 'exchange') {
      stats.exchangeFunded++;
      const exchange = funding.funderName || 'Unknown Exchange';
      stats.byExchange[exchange] = (stats.byExchange[exchange] || 0) + 1;
    }
  });

  console.log('Airdrop Recipient Analysis:');
  console.log(`Total Recipients: ${stats.total}`);
  console.log(`Exchange-Funded: ${stats.exchangeFunded} (${(stats.exchangeFunded / stats.total * 100).toFixed(1)}%)`);
  console.log(`Unknown Source: ${stats.unknown}`);
  console.log('\nBy Exchange:');
  Object.entries(stats.byExchange).forEach(([exchange, count]) => {
    console.log(`  ${exchange}: ${count}`);
  });

  return stats;
};
```

### Construire une chronologie de portefeuille

Créez une chronologie à partir de la création du portefeuille :

```javascript theme={"system"}
const buildWalletTimeline = async (address) => {
  const funding = await getWalletFundingSource(address);

  if (!funding) {
    console.log('No funding data available');
    return null;
  }

  const creationDate = new Date(funding.timestamp * 1000);
  const ageInDays = Math.floor((Date.now() - creationDate.getTime()) / (1000 * 60 * 60 * 24));

  console.log('Wallet Timeline:');
  console.log(`Created: ${creationDate.toLocaleString()} (${ageInDays} days ago)`);
  console.log(`Initial Funding: ${funding.amount} SOL`);
  console.log(`Funded By: ${funding.funderName || funding.funder.slice(0, 8) + '...'}`);

  if (funding.funderType === 'exchange') {
    console.log(`This wallet was likely created by withdrawing from ${funding.funderName}`);
  }

  return {
    creationDate,
    ageInDays,
    initialFunding: funding.amount,
    fundedBy: funding.funderName || funding.funder
  };
};
```

### Évaluation du risque de conformité

Attribuez des scores de risque en fonction de la source de financement :

```javascript theme={"system"}
const assessWalletRisk = async (address) => {
  const funding = await getWalletFundingSource(address);

  if (!funding) {
    return { riskLevel: 'UNKNOWN', score: 50, reasons: ['No funding data available'] };
  }

  let score = 0;
  let reasons = [];

  // Low risk: Funded by known exchange
  if (funding.funderType === 'exchange') {
    score = 20;
    reasons.push(`Funded by known exchange (${funding.funderName})`);
  }
  // Medium risk: Unknown funder
  else if (!funding.funderName) {
    score = 50;
    reasons.push('Funded by unknown wallet');
  }
  // High risk: Funded by flagged address
  else if (funding.funderType === 'flagged') {
    score = 90;
    reasons.push('Funded by flagged address');
  }

  // Age factor: New wallets are higher risk
  const ageInDays = (Date.now() / 1000 - funding.timestamp) / (60 * 60 * 24);
  if (ageInDays < 7) {
    score += 20;
    reasons.push('Wallet is less than 7 days old');
  }

  // Amount factor: Very small initial funding is suspicious
  if (funding.amount < 0.01) {
    score += 10;
    reasons.push('Very small initial funding amount');
  }

  const riskLevel = score < 30 ? 'LOW' : score < 60 ? 'MEDIUM' : 'HIGH';

  console.log(`Risk Assessment for ${address}:`);
  console.log(`Risk Level: ${riskLevel} (Score: ${score}/100)`);
  reasons.forEach(reason => console.log(`  - ${reason}`));

  return { riskLevel, score, reasons };
};
```

### Suivi de l'attribution

Suivez quelles sources créent le plus de nouveaux portefeuilles :

```javascript theme={"system"}
const trackNewWalletSources = async (recentWallets) => {
  const fundingSources = await Promise.all(
    recentWallets.map(async address => {
      try {
        const funding = await getWalletFundingSource(address);
        return {
          address,
          funder: funding?.funder,
          funderName: funding?.funderName,
          funderType: funding?.funderType
        };
      } catch {
        return { address, funder: null };
      }
    })
  );

  // Count by source
  const sourceStats = {};

  fundingSources.forEach(({ funderName, funderType }) => {
    const sourceName = funderName || funderType || 'Unknown';
    sourceStats[sourceName] = (sourceStats[sourceName] || 0) + 1;
  });

  // Sort by count
  const sorted = Object.entries(sourceStats)
    .sort(([, a], [, b]) => b - a)
    .slice(0, 10);

  console.log('Top Wallet Funding Sources:');
  sorted.forEach(([source, count]) => {
    console.log(`${source}: ${count} wallets`);
  });

  return sourceStats;
};
```

## Types de financeurs

Le champ `funderType` indique la catégorie du portefeuille qui a financé l'adresse. Toutes les valeurs des [Catégories d'identité](/docs/fr/wallet-api/identity#catégories-didentité) sont prises en charge.

<Accordion title="Types de financeurs pris en charge">
  Types de financeurs courants :

  | Type                 | Description                      | Exemples                                                      |
  | -------------------- | -------------------------------- | ------------------------------------------------------------- |
  | Échange centralisé   | Portefeuilles chauds CEX         | Binance, Coinbase, Kraken, OKX                                |
  | DeFi                 | Adresses de protocole DeFi       | Jupiter, Raydium, Marinade                                    |
  | Market Maker         | Sociétés de teneur de marché     | Jump Trading, Wintermute                                      |
  | Société de trading   | Sociétés de trading propriétaire | Commerçants institutionnels                                   |
  | Pont inter-chaînes   | Adresses de protocole de pont    | Wormhole, AllBridge, Portal                                   |
  | Validateur           | Adresses de validateur           | Validateur Coinbase, Jito                                     |
  | Leader d'opinion clé | Personnes notables               | Influenceurs, fondateurs                                      |
  | Trésorerie           | Trésoreries de projet            | Trésoreries de protocole                                      |
  | Pool de staking      | Pools de staking liquide         | Marinade, Jito                                                |
  | null                 | Financeur inconnu                | Portefeuille régulier, non dans la base de données d'identité |

  La liste complète comprend : Largage, Autorité, Pont inter-chaînes, Casino & Jeux, DAO, DeFi, DePIN, Échange centralisé, Exploiteur/Pirates/Arnaques, Frais, Levée de fonds, Jeu, Distribution du bloc de genèse, Gouvernance, Pirate, Jito, Leader d'opinion clé, Teneur de marché, Memecoin, Multisig, NFT, Offre non circulante, Oracle, Autre, Paiements, AMM propriétaire, Re-staking, Rugger, Arnaqueur, Spam, Pool de staking, Système, Outils, Application/Bot de trading, Société de trading, Envoi de transactions, Trésorerie, Validateur, Coffre-fort et X402.

  Voir la section [Catégories d'identité](/docs/fr/wallet-api/identity#catégories-didentité) pour la liste complète avec descriptions.
</Accordion>

## Meilleures pratiques

* **Gérez les réponses 404.** Les portefeuilles qui n'ont jamais reçu de SOL renvoient un 404. C'est attendu pour les portefeuilles nouvellement créés mais non financés.
* **Combinez avec l'API d'identité.** La réponse inclut `funderName` et `funderType`, mais vous pouvez appeler le point de terminaison [Identity](/docs/fr/wallet-api/identity) sur l'adresse `funder` pour plus de détails.
* **Mettez en cache les données de financement.** La source de financement d'un portefeuille ne change jamais. Mettez ces données en cache de manière permanente pour éviter les appels d'API répétés.
* **Vérifiez l'âge pour le contexte.** `timestamp` vous indique quand le portefeuille a été financé pour la première fois. Combinez l'âge avec la source de financement pour un meilleur contexte.

## Erreurs courantes

| Code d'erreur | Description                                      | Solution                                                                                                                                                              |
| ------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400           | Format d'adresse de portefeuille invalide        | Vérifiez que l'adresse est une adresse Solana valide en base58                                                                                                        |
| 401           | Clé API manquante ou invalide                    | Vérifiez que votre clé API est incluse dans la demande                                                                                                                |
| 403           | Le point de terminaison nécessite un plan payant | Les recherches de source de financement ne sont pas disponibles sur le plan gratuit. [Mettez à niveau votre plan](https://dashboard.helius.dev) vers un niveau payant |
| 404           | Aucune transaction de financement trouvée        | Ce portefeuille n'a jamais reçu de SOL                                                                                                                                |
| 429           | Limite de taux dépassée                          | Réduisez la fréquence des demandes ou mettez à niveau votre plan                                                                                                      |

## Limitations

* Ce point de terminaison suit uniquement le **premier transfert SOL** vers un portefeuille.
* Si un portefeuille a été créé par largage ou initialisation de programme sans transfert SOL, il n'aura pas de données de financement.
* La source de financement représente le financeur **immédiat**, pas nécessairement la source ultime des fonds.
* Les données historiques ne sont disponibles que pour les portefeuilles créés après le déploiement de cette fonctionnalité.

## Prochaines étapes

<CardGroup cols={3}>
  <Card title="Identité du portefeuille" icon="address-card" href="/docs/fr/wallet-api/identity">
    Résolvez l'adresse du financeur en une étiquette complète, une catégorie et des balises.
  </Card>

  <Card title="Présentation de l'API Wallet" icon="wallet" href="/docs/fr/wallet-api/overview">
    Tous les points de terminaison de l'API Wallet et conventions partagées.
  </Card>

  <Card title="Référence de l'API" icon="code" href="/docs/fr/api-reference/wallet-api/funded-by">
    Schémas de requête et de réponse pour la recherche de source de financement.
  </Card>
</CardGroup>