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

# Cara Mengetahui Siapa yang Mendanai Dompet Solana

> Temukan sumber pendanaan awal dompet Solana mana pun dengan melacak transfer SOL masuk pertamanya. Identifikasi pendanaan dari bursa, atribusi, dan hubungan antardompet.

<Note>
  Wallet API masih dalam versi Beta. Endpoint dan format respons dapat berubah.
</Note>

## Ringkasan

Endpoint Wallet Funding Source mengidentifikasi siapa yang pertama kali mendanai dompet Solana dengan menganalisis transfer SOL masuk pertamanya. Endpoint ini berguna untuk atribusi, kepatuhan, memahami hubungan antardompet, dan mengidentifikasi dompet yang didanai oleh bursa.

Nama dan kategori penyandang dana berasal dari sistem identitas yang sama dengan yang digunakan oleh endpoint [Identity](/docs/id/wallet-api/identity). Jadi, jika penyandang dana merupakan entitas yang dikenal, Anda akan mendapatkan label dan kategori yang mudah dibaca langsung dalam respons.

Endpoint ini memerlukan paket berbayar. Permintaan yang dibuat dengan API key paket Free akan mengembalikan `403 Forbidden`. Lihat [Persyaratan paket](/docs/id/wallet-api/overview#persyaratan-paket) untuk tabel cakupan lengkap.

## Kapan menggunakannya

Gunakan Wallet Funding Source API untuk:

* **Atribusi dompet**: melacak sumber pendanaan dompet baru.
* **Deteksi bursa**: mengidentifikasi dompet yang didanai langsung dari bursa tersentralisasi.
* **Kepatuhan dan AML**: menandai dompet yang didanai oleh entitas yang dikenal untuk pemeriksaan kepatuhan.
* **Deteksi bot**: mengidentifikasi kumpulan bot yang didanai dari sumber yang sama.
* **Analisis airdrop**: melacak dompet yang menerima pendanaan awal dari suatu proyek.
* **Deteksi Sybil**: menemukan klaster dompet yang didanai oleh alamat yang sama.

## Panduan memulai cepat

### Pencarian pendanaan dasar

Cari tahu siapa yang mendanai dompet:

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

Respons yang berhasil menjelaskan transfer SOL masuk pertama ke dompet:

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

Jika dompet belum pernah menerima SOL, API akan mengembalikan 404:

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

### Catatan bidang

* **`funder`**: alamat yang mengirim transfer SOL pertama ke dompet ini.
* **`funderName`**: nama yang mudah dibaca jika penyandang dana merupakan entitas yang dikenal (misalnya, bursa atau protokol); jika tidak, nilainya adalah `null`.
* **`funderType`**: kategori penyandang dana (misalnya, `exchange`, `defi-protocol`); nilainya adalah `null` jika tidak ada dalam basis data identitas.
* **`mint`**: alamat mint token (`So11111111111111111111111111111111111111111` untuk SOL).
* **`symbol`**: simbol token (selalu `SOL` untuk transaksi pendanaan).
* **`amount`**: jumlah awal SOL yang diterima (mudah dibaca, misalnya `0.05` SOL).
* **`amountRaw`**: jumlah mentah dalam lamport sebagai string (misalnya, `"50000000"` untuk 0,05 SOL).
* **`decimals`**: jumlah angka di belakang koma untuk token (9 untuk SOL).
* **`date`**: string tanggal berformat ISO 8601 (misalnya, `"2024-01-01T00:00:00.000Z"`).
* **`signature`**: tanda tangan transaksi dari transfer pendanaan.
* **`timestamp`**: stempel waktu Unix (dalam detik) saat dompet didanai.
* **`slot`**: nomor slot Solana saat transaksi pendanaan dikonfirmasi.
* **`explorerUrl`**: tautan langsung untuk melihat transaksi di Orb.

## Kasus penggunaan

### Mendeteksi dompet yang didanai oleh bursa

Identifikasi dompet yang didanai langsung dari bursa tersentralisasi:

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

### Menemukan klaster dompet (deteksi Sybil)

Identifikasi kelompok dompet yang didanai oleh sumber yang sama:

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

### Melacak penerima airdrop

Analisis asal penerima 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;
};
```

### Membuat linimasa dompet

Buat linimasa yang dimulai sejak dompet dibuat:

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

### Penilaian risiko kepatuhan

Tetapkan skor risiko berdasarkan sumber pendanaan:

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

### Pelacakan atribusi

Lacak sumber yang membuat dompet baru paling banyak:

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

## Jenis penyandang dana

Bidang `funderType` menunjukkan kategori dompet yang mendanai alamat tersebut. Semua nilai dari [Kategori Identitas](/docs/id/wallet-api/identity#kategori-identitas) didukung.

<Accordion title="Supported funder types">
  Jenis penyandang dana yang umum:

  | Jenis                | Deskripsi                         | Contoh                                             |
  | -------------------- | --------------------------------- | -------------------------------------------------- |
  | Centralized Exchange | Dompet panas CEX                  | Binance, Coinbase, Kraken, OKX                     |
  | DeFi                 | Alamat protokol DeFi              | Jupiter, Raydium, Marinade                         |
  | Market Maker         | Perusahaan pembuat pasar          | Jump Trading, Wintermute                           |
  | Trading Firm         | Perusahaan perdagangan proprieter | Pedagang institusional                             |
  | Cross-chain Bridge   | Alamat protokol bridge            | Wormhole, AllBridge, Portal                        |
  | Validator            | Alamat validator                  | Coinbase Validator, Jito                           |
  | Key Opinion Leader   | Individu terkemuka                | Pemengaruh, pendiri                                |
  | Treasury             | Perbendaharaan proyek             | Perbendaharaan protokol                            |
  | Stake Pool           | Pool staking likuid               | Marinade, Jito                                     |
  | null                 | Penyandang dana tidak dikenal     | Dompet biasa, tidak ada dalam basis data identitas |

  Daftar lengkap mencakup: Airdrop, Authority, Cross-chain Bridge, Casino & Gambling, DAO, DeFi, DePIN, Centralized Exchange, Exploiter/Hackers/Scams, Fees, Fundraise, Game, Genesis Block Distribution, Governance, Hacker, Jito, Key Opinion Leader, Market Maker, Memecoin, Multisig, NFT, Non-Circulating Supply, Oracle, Other, Payments, Proprietary AMM, Restaking, Rugger, Scammer, Spam, Stake Pool, System, Tools, Trading App/Bot, Trading Firm, Transaction Sending, Treasury, Validator, Vault, dan X402.

  Lihat bagian [Kategori Identitas](/docs/id/wallet-api/identity#kategori-identitas) untuk daftar lengkap beserta deskripsinya.
</Accordion>

## Praktik terbaik

* **Tangani respons 404.** Dompet yang belum pernah menerima SOL akan mengembalikan 404. Hal ini wajar untuk dompet yang baru dibuat tetapi belum didanai.
* **Gabungkan dengan Identity API.** Respons mencakup `funderName` dan `funderType`, tetapi Anda dapat memanggil endpoint [Identity](/docs/id/wallet-api/identity) pada alamat `funder` untuk mendapatkan informasi lebih terperinci.
* **Simpan data pendanaan dalam cache.** Sumber pendanaan dompet tidak pernah berubah. Simpan data ini secara permanen dalam cache untuk menghindari pemanggilan API berulang.
* **Periksa usia untuk mendapatkan konteks.** `timestamp` menunjukkan waktu dompet pertama kali didanai. Gabungkan usia dengan sumber pendanaan untuk mendapatkan konteks yang lebih baik.

## Kesalahan umum

| Kode Kesalahan | Deskripsi                           | Solusi                                                                                                                               |
| -------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| 400            | Format alamat dompet tidak valid    | Pastikan alamat tersebut merupakan alamat Solana base58 yang valid                                                                   |
| 401            | API key tidak ada atau tidak valid  | Pastikan API key Anda disertakan dalam permintaan                                                                                    |
| 403            | Endpoint memerlukan paket berbayar  | Pencarian sumber pendanaan tidak tersedia pada paket Free. [Tingkatkan paket Anda](https://dashboard.helius.dev) ke tingkat berbayar |
| 404            | Transaksi pendanaan tidak ditemukan | Dompet ini belum pernah menerima SOL                                                                                                 |
| 429            | Batas laju terlampaui               | Kurangi frekuensi permintaan atau tingkatkan paket Anda                                                                              |

## Batasan

* Endpoint ini hanya melacak **transfer SOL pertama** ke suatu dompet.
* Jika dompet dibuat melalui airdrop atau inisialisasi program tanpa transfer SOL, dompet tersebut tidak akan memiliki data pendanaan.
* Sumber pendanaan menunjukkan penyandang dana **langsung**, bukan selalu sumber dana utama.
* Data historis hanya tersedia untuk dompet yang dibuat setelah fitur ini diterapkan.

## Langkah berikutnya

<CardGroup cols={3}>
  <Card title="Wallet Identity" icon="address-card" href="/docs/id/wallet-api/identity">
    Uraikan alamat penyandang dana menjadi label, kategori, dan tag lengkap.
  </Card>

  <Card title="Wallet API Overview" icon="wallet" href="/docs/id/wallet-api/overview">
    Semua endpoint Wallet API dan konvensi bersama.
  </Card>

  <Card title="API Reference" icon="code" href="/docs/id/api-reference/wallet-api/funded-by">
    Skema permintaan dan respons untuk pencarian sumber pendanaan.
  </Card>
</CardGroup>