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

# 如何查看谁资助了一个Solana钱包

> 通过追踪Solana钱包的首次SOL转账，发现其原始资金来源。识别交易所资金、归属和钱包关系。

<Note>
  Wallet API处于测试阶段。端点和响应格式可能会发生变化。
</Note>

## 概述

Wallet Funding Source端点通过分析Solana钱包的首次SOL转账来识别原始资金来源。对于归属、合规、理解钱包关系以及识别由交易所资助的钱包非常有价值。

资助者的名称和类别来自与[Identity](/zh/wallet-api/identity)端点相同的身份系统，因此当资助者是已知实体时，您可以直接在响应中获得人类可读的标签和类别。

此端点需要付费计划。使用免费计划 API 密钥进行的请求将返回 `403 Forbidden`。请查看[计划要求](/zh/wallet-api/overview#plan-requirements)以获取完整的覆盖表。

## 何时使用

使用 Wallet Funding Source API：

* **钱包归因**：跟踪新钱包的资金来源。
* **交易所检测**：识别直接从中心化交易所获得资金的钱包。
* **合规和反洗钱**：为合规检查标记由已知实体资助的钱包。
* **机器人检测**：识别同一来源资助的僵尸农场。
* **空投分析**：跟踪哪些钱包从项目获得了初始资金。
* **Sybil 检测**：查找由同一地址资助的钱包集群。

## 快速入门

### 基本资金查询

找出谁资助了钱包：

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

## 响应格式

成功的响应描述了钱包的第一次 SOL 转账：

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

如果钱包从未接收 SOL，API 将返回 404：

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

### 字段说明

* **`funder`**：发送第一次 SOL 转账到此钱包的地址。
* **`funderName`**：如果资助者是已知实体（例如交易所、协议），则为可读名；否则为 `null`。
* **`funderType`**：资助者类别（例如，`exchange`，`defi-protocol`）；如果不在身份数据库中，则为 `null`。
* **`mint`**：代币铸造地址（SOL 为 `So11111111111111111111111111111111111111111`）。
* **`symbol`**：代币符号（资金交易总是为 `SOL`）。
* **`amount`**：初始 SOL 接收量（可读，例如，`0.05` SOL）。
* **`amountRaw`**：以字符串形式表示的 lamports 原始金额（例如，0.05 SOL 为 `"50000000"`）。
* **`decimals`**：代币的小数位数（SOL 为 9）。
* **`date`**：ISO 8601 格式化日期字符串（例如，`"2024-01-01T00:00:00.000Z"`）。
* **`signature`**：资金转账的交易签名。
* **`timestamp`**：资助钱包时的 Unix 时间戳（以秒计）。
* **`slot`**：资金交易确认时的 Solana 插槽号。
* **`explorerUrl`**：在 Orb 上查看交易的直接链接。

## 用例

### 检测交易所资助的钱包

识别直接从中心化交易所资助的钱包：

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

### 查找钱包集群（Sybil检测）

识别由同一来源资助的钱包群组：

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

### 跟踪空投接收者

分析空投接收者的来源：

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

### 构建钱包时间轴

从钱包创建开始创建时间轴：

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

### 合规风险评分

根据资金来源分配风险评分：

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

### 归因跟踪

追踪哪个来源创造了最多的新钱包：

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

## 资助者类型

`funderType`字段表示资助该地址的钱包类别。支持的所有值来自 [身份类别](/zh/wallet-api/identity#identity-categories)。

<Accordion title="支持的资助者类型">
  常见资助者类型：

  | 类型     | 描述        | 示例                             |
  | ------ | --------- | ------------------------------ |
  | 中心化交易所 | CEX 热钱包   | Binance, Coinbase, Kraken, OKX |
  | DeFi   | DeFi 协议地址 | Jupiter, Raydium, Marinade     |
  | 做市商    | 市场做市公司    | Jump Trading, Wintermute       |
  | 交易公司   | 专业交易公司    | 机构交易者                          |
  | 跨链桥    | 桥协议地址     | Wormhole, AllBridge, Portal    |
  | 验证者    | 验证者地址     | Coinbase Validator, Jito       |
  | 关键意见领袖 | 知名个人      | 影响者, 创始人                       |
  | 财库     | 项目财库      | 协议财库                           |
  | 质押池    | 流动质押池     | Marinade, Jito                 |
  | null   | 未知资助者     | 普通钱包, 不在身份数据库中                 |

  完整列表包括：空投，授权，跨链桥，赌场赌博，DAO，DeFi，DePIN，中心化交易所，攻击者/黑客/骗局，费用，募资，游戏，创世区块分配，治理，黑客，Jito，关键意见领袖，做市商，Memecoin，多签，NFT，非流通供应，预言机，其他，支付，专有AMM，重质押，诈骗者，垃圾信息，质押池，系统，工具，交易应用/机器人，交易公司，交易发送，财库，验证者，金库，以及X402。

  有关完整列表及描述，请参阅[身份类别](/zh/wallet-api/identity#identity-categories)部分。
</Accordion>

## 最佳实践

* **处理404响应。** 从未接收过SOL的钱包返回404。这对于新创建但未资助的钱包是预期的。
* **结合身份API。** 响应包括`funderName`和`funderType`，但您可以在`funder`地址调用[身份](/zh/wallet-api/identity)端点以获取更多详细信息。
* **缓存资金数据。** 钱包的资金来源不会变化。永久缓存此数据以避免重复的API调用。
* **检查年龄以获取上下文。** `timestamp`告诉您钱包首次获得资金的时间。结合年龄和资金来源以获得更好的上下文。

## 常见错误

| 错误代码 | 描述          | 解决方案                                                      |
| ---- | ----------- | --------------------------------------------------------- |
| 400  | 钱包地址格式无效    | 验证地址是否为有效的base58 Solana地址                                 |
| 401  | 缺失或无效的API密钥 | 确保您的API密钥包含在请求中                                           |
| 403  | 端点需要付费计划    | 免费计划中不提供资金来源查找。[升级您的计划](https://dashboard.helius.dev)到付费层 |
| 404  | 找不到资金交易     | 此钱包从未接收过SOL                                               |
| 429  | 超出速率限制      | 减少请求频率或升级您的计划                                             |

## 限制

* 此端点仅跟踪**首次SOL转账**到钱包。
* 如果钱包通过空投或程序初始化创建而没有SOL转账，则不会有资金数据。
* 资金来源表示**直接** 资助者，不一定是资金的最终来源。
* 仅为此功能部署后创建的钱包提供历史数据。

## 下一步

<CardGroup cols={3}>
  <Card title="钱包身份" icon="address-card" href="/zh/wallet-api/identity">
    将资助者地址解析为完整的标签、类别和标签。
  </Card>

  <Card title="钱包 API 概述" icon="wallet" href="/zh/wallet-api/overview">
    所有钱包 API 端点和共享约定。
  </Card>

  <Card title="API 参考" icon="code" href="/zh/api-reference/wallet-api/funded-by">
    资金来源查询的请求和响应模式。
  </Card>
</CardGroup>