> ## 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.

# Como Ver Quem Financiou uma Carteira Solana

> Descubra a fonte original de financiamento de qualquer carteira Solana rastreando sua primeira transferência de SOL recebida. Identifique financiamento de exchanges, atribuições e relações de carteiras.

<Note>
  A Wallet API está em Beta. Os endpoints e formatos de resposta podem mudar.
</Note>

## Visão Geral

O endpoint Fonte de Financiamento da Carteira identifica quem originalmente financiou uma carteira Solana analisando sua primeira transferência de SOL recebida. É valioso para atribuição, conformidade, compreensão de relações de carteiras e identificação de carteiras financiadas por exchanges.

O nome e a categoria do financiador vêm do mesmo sistema de identidade usado pelo endpoint [Identity](/docs/pt-BR/wallet-api/identity), portanto, quando o financiador é uma entidade conhecida, você obtém um rótulo legível por humanos e categoria diretamente na resposta.

Este endpoint requer um plano pago. Solicitações feitas com uma chave de API do plano gratuito retornam `403 Forbidden`. Consulte [Requisitos do plano](/docs/pt-BR/wallet-api/overview#plan-requirements) para a tabela completa de cobertura.

## Quando utilizar

Use a Wallet Funding Source API para:

* **Atribuição de carteiras**: rastreie de onde novas carteiras estão sendo financiadas.
* **Detecção de exchanges**: identifique carteiras financiadas diretamente por exchanges centralizadas.
* **Conformidade e AML**: sinalize carteiras financiadas por entidades conhecidas para verificações de conformidade.
* **Detecção de bots**: identifique fazendas de bots financiadas pela mesma fonte.
* **Análise de airdrop**: rastreie quais carteiras receberam financiamento inicial de um projeto.
* **Detecção de Sybil**: encontre clusters de carteiras financiadas pelo mesmo endereço.

## Início rápido

### Consulta básica de financiamento

Descubra quem financiou uma carteira:

<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>

## Formato da resposta

Uma resposta bem-sucedida descreve a primeira transferência de SOL recebida pela carteira:

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

Se uma carteira nunca tiver recebido SOL, a API retorna um 404:

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

### Notas sobre os campos

* **`funder`**: o endereço que enviou a primeira transferência de SOL para esta carteira.
* **`funderName`**: nome legível por humanos se o financiador for uma entidade conhecida (por exemplo, exchange, protocolo); `null` caso contrário.
* **`funderType`**: categoria do financiador (por exemplo, `exchange`, `defi-protocol`); `null` se não estiver no banco de dados de identidade.
* **`mint`**: endereço de cunhagem do token (`So11111111111111111111111111111111111111111` para SOL).
* **`symbol`**: símbolo do token (sempre `SOL` para transações de financiamento).
* **`amount`**: quantidade inicial de SOL recebida (legível por humanos, por exemplo, `0.05` SOL).
* **`amountRaw`**: quantidade bruta em lamports como string (por exemplo, `"50000000"` para 0.05 SOL).
* **`decimals`**: número de casas decimais para o token (9 para SOL).
* **`date`**: string de data formatada em ISO 8601 (por exemplo, `"2024-01-01T00:00:00.000Z"`).
* **`signature`**: assinatura da transação de financiamento.
* **`timestamp`**: timestamp Unix (em segundos) quando a carteira foi financiada.
* **`slot`**: número do slot Solana quando a transação de financiamento foi confirmada.
* **`explorerUrl`**: link direto para visualizar a transação no Orb.

## Casos de uso

### Detectar carteiras financiadas por exchanges

Identifique carteiras financiadas diretamente por exchanges centralizadas:

```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");
```

### Encontrar clusters de carteiras (Detecção de Sybil)

Identifique grupos de carteiras financiadas pela mesma fonte:

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

### Rastrear destinatários de airdrop

Analise de onde vieram os destinatários de airdrop:

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

### Construir uma linha do tempo da carteira

Crie uma linha do tempo a partir da criação da carteira:

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

### Avaliação de risco de conformidade

Atribua pontuações de risco com base na fonte de financiamento:

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

### Rastreamento de atribuição

Acompanhe quais fontes estão criando mais novas carteiras:

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

## Tipos de financiadores

O campo `funderType` indica a categoria da carteira que financiou o endereço. Todos os valores das [Categorias de Identidade](/docs/pt-BR/wallet-api/identity#identity-categories) são suportados.

<Accordion title="Tipos de financiadores suportados">
  Tipos comuns de financiadores:

  | Tipo                  | Descrição                        | Exemplos                                            |
  | --------------------- | -------------------------------- | --------------------------------------------------- |
  | Exchange Centralizada | Carteiras quentes de CEX         | Binance, Coinbase, Kraken, OKX                      |
  | DeFi                  | Endereços de protocolo DeFi      | Jupiter, Raydium, Marinade                          |
  | Formador de Mercado   | Empresas de criação de mercado   | Jump Trading, Wintermute                            |
  | Empresa de Trading    | Empresas de trading proprietário | Comerciais institucionais                           |
  | Ponte Cross-chain     | Endereços de protocolo de ponte  | Wormhole, AllBridge, Portal                         |
  | Validador             | Endereços de validadores         | Validador Coinbase, Jito                            |
  | Líder de Opinião      | Indivíduos notáveis              | Influenciadores, fundadores                         |
  | Tesouraria            | Tesourarias de projetos          | Tesourarias de protocolos                           |
  | Pool de Stake         | Pools de staking líquido         | Marinade, Jito                                      |
  | null                  | Financiador desconhecido         | Carteira comum, não no banco de dados de identidade |

  A lista completa inclui: Airdrop, Autoridade, Ponte Cross-chain, Cassino & Jogos de Azar, DAO, DeFi, DePIN, Exchange Centralizada, Explorador/Hackers/Golpes, Taxas, Arrecadação de Fundos, Jogo, Distribuição do Bloco Gênesis, Governança, Hacker, Jito, Líder de Opinião, Formador de Mercado, Memecoin, Multisig, NFT, Oferta Não Circulante, Oráculo, Outro, Pagamentos, AMM Proprietário, Restaking, Enganador, Picareta, Spam, Pool de Stake, Sistema, Ferramentas, App/Bot de Trading, Empresa de Trading, Envio de Transações, Tesouraria, Validador, Cofre e X402.

  Veja a seção [Categorias de Identidade](/docs/pt-BR/wallet-api/identity#identity-categories) para a lista completa com descrições.
</Accordion>

## Melhores práticas

* **Lide com respostas 404.** Carteiras que nunca receberam SOL retornam um 404. Isso é esperado para carteiras recém-criadas, mas não financiadas.
* **Combine com a Identity API.** A resposta inclui `funderName` e `funderType`, mas você pode chamar o endpoint [Identity](/docs/pt-BR/wallet-api/identity) no endereço `funder` para mais detalhes.
* **Cache de dados de financiamento.** A fonte de financiamento de uma carteira nunca muda. Armazene esses dados permanentemente para evitar chamadas repetidas à API.
* **Verifique a idade para contexto.** O `timestamp` indica quando a carteira foi financiada pela primeira vez. Combine a idade com a fonte de financiamento para um melhor contexto.

## Erros comuns

| Código de Erro | Descrição                                     | Solução                                                                                                                                            |
| -------------- | --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400            | Formato de endereço de carteira inválido      | Verifique se o endereço é um endereço Solana válido em base58                                                                                      |
| 401            | Chave de API ausente ou inválida              | Verifique se sua chave de API está incluída na solicitação                                                                                         |
| 403            | O endpoint requer um plano pago               | Consultas de fonte de financiamento não estão disponíveis no plano gratuito. [Atualize seu plano](https://dashboard.helius.dev) para um nível pago |
| 404            | Nenhuma transação de financiamento encontrada | Esta carteira nunca recebeu SOL                                                                                                                    |
| 429            | Limite de taxa excedido                       | Reduza a frequência de solicitações ou atualize seu plano                                                                                          |

## Limitações

* Este endpoint rastreia apenas a **primeira transferência de SOL** para uma carteira.
* Se uma carteira foi criada via airdrop ou inicialização de programa sem uma transferência de SOL, não terá dados de financiamento.
* A fonte de financiamento representa o financiador **imediato**, não necessariamente a fonte final dos fundos.
* Dados históricos estão disponíveis apenas para carteiras criadas após o lançamento deste recurso.

## Próximos passos

<CardGroup cols={3}>
  <Card title="Identidade da Carteira" icon="address-card" href="/docs/pt-BR/wallet-api/identity">
    Resolva o endereço do financiador para um rótulo completo, categoria e tags.
  </Card>

  <Card title="Visão Geral da Wallet API" icon="wallet" href="/docs/pt-BR/wallet-api/overview">
    Todos os endpoints da Wallet API e convenções compartilhadas.
  </Card>

  <Card title="Referência da API" icon="code" href="/docs/pt-BR/api-reference/wallet-api/funded-by">
    Esquemas de solicitação e resposta para consulta de fonte de financiamento.
  </Card>
</CardGroup>