> ## 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.
# getTransactionsForAddress 概述和教程
> 了解如何使用此 Helius 独有的 RPC 方法，通过高级过滤、双向排序和高效分页查询 Solana 交易历史。
## 概述
[`getTransactionsForAddress`](/zh/api-reference/rpc/http/gettransactionsforaddress) 是一个 Helius 独有的 RPC 方法，返回地址的交易历史，具有高级过滤、灵活排序和高效分页功能。它不是标准 Solana RPC 的一部分。
与 `getSignaturesForAddress` 不同，它仅返回签名并跳过关联的代币账户，`getTransactionsForAddress` 可以在一次调用中返回完整的交易数据，包括钱包的关联代币账户 (ATA) 活动。这使得它成为回填、索引和分析的最快路径。
此方法每次调用最多返回1000个完整交易。
按时间顺序排序（最旧的在前）或反序（最新的在前）。
按时间范围、槽位、签名、状态和代币转移进行过滤。
在一次调用中获取完整的交易详情，无需后续 getTransaction。
包括地址的关联代币账户的交易。
## 使用场景
在需要以下情况时使用 `getTransactionsForAddress`：
* 完整的钱包代币历史，包括关联的代币账户
* 用于索引器或数据管道的快速单次调用回填
* 基于时间或槽位的交易分析和报告
* 状态过滤仅保留成功或失败的交易
* 按时间顺序的历史重演（最旧的排序）
* 代币发布分析：首次铸造交易和早期持有者
* 钱包资金历史和对方发现
* 特定时间段的合规性和审计报告
对于解析的、仅转账历史（付款、余额调整），请改用 [`getTransfersByAddress`](/zh/rpc/gettransfersbyaddress)。
### 网络支持
| 网络 | 支持 | 保留期 |
| --- | -- | --- |
| 主网 | 是 | 无限 |
| 开发网 | 是 | 2 周 |
| 测试网 | 否 | N/A |
## 快速开始
从[Helius仪表板](https://dashboard.helius.dev/api-keys)获取你的API密钥。
获取在两个日期之间的钱包的所有成功交易，按时间顺序排序：
```javascript theme={"system"}
// Get successful transactions between Jan 1-31, 2025 in chronological order
const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'getTransactionsForAddress',
params: [
'YOUR_ADDRESS_HERE',
{
transactionDetails: 'full',
sortOrder: 'asc',
limit: 1000,
filters: {
blockTime: {
gte: 1735689600, // Jan 1, 2025
lt: 1738368000 // Before Feb 1, 2025
},
status: 'succeeded', // Only successful transactions
tokenAccounts: 'balanceChanged' // Include associated token accounts
}
}
]
})
});
const data = await response.json();
console.log('Successful transactions in January:', data.result.data);
```
这个例子展示了关键功能：
* **transactionDetails**: 设置为`'full'`以在一次调用中获取完整交易数据
* **sortOrder**: 使用`'asc'`按时间顺序（最早的优先）或`'desc'`按最新顺序
* **filters.blockTime**: 使用`gte`（大于或等于）和`lte`（小于或等于）设置时间范围
* **filters.status**: 仅过滤为`'succeeded'`或`'failed'`的交易
* **filters.tokenAccounts**: 包括相关token账户的转账、铸造和销毁
## 请求参数
要查询交易历史记录的账户的Base-58编码公钥
返回的交易详细级别：
* `signatures`: 基本签名信息（更快）
* `full`: 完整交易数据（消除对getTransaction调用的需要，支持最大限制为1000）
结果的排序顺序：
* `desc`: 最新优先（默认）
* `asc`: 最早优先（按时间顺序，非常适合历史分析）
返回的最大交易数：
* 当`transactionDetails: "signatures"`时最多到1000
* 当`transactionDetails: "full"`时最多到1000
上一次响应的分页token（格式：`"slot:position"`）
承诺级别：`finalized`或`confirmed`。不支持`processed`承诺。
用于缩小结果的高级过滤选项。
使用比较运算符过滤slot编号：`gte`, `gt`, `lte`, `lt`
示例：`{ "slot": { "gte": 1000, "lte": 2000 } }`
使用比较运算符按Unix时间戳过滤：`gte`, `gt`, `lte`, `lt`, `eq`
示例：`{ "blockTime": { "gte": 1640995200, "lte": 1641081600 } }`
使用比较运算符按交易签名过滤：`gte`, `gt`, `lte`, `lt`
示例：`{ "signature": { "lt": "SIGNATURE_STRING" } }`
按交易成功/失败状态过滤：
* `succeeded`：仅成功交易
* `failed`：仅失败交易
* `any`：成功和失败（默认）
示例：`{ "status": "succeeded" }`
对相关代币账户的交易进行过滤：
* `none`: 仅返回引用提供地址的交易（默认）
* `balanceChanged`: 返回引用提供地址或修改由提供地址持有的代币账户余额的交易（推荐）
* `all`: 返回引用提供地址或任何由提供地址持有的代币账户的交易
示例: `{ "tokenAccounts": "balanceChanged" }`
过滤符合对应方、方向、铸造或原始金额范围的代币转账参与地址的交易。所有字段都是可选的，并以AND语义组合。
示例: `{ "tokenTransfer": { "direction": "in", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" } }`
对方地址。匹配另一方为此地址的转账。
根据相对于查询地址的转账方向进行过滤：
* `in`: 查询地址接收的转账
* `out`: 查询地址发送的转账
* `any`: 入站和出站的转账
用于过滤的代币铸造。
使用区块链上的原始金额进行比较，而不是UI或调整后的小数金额。支持 `gt`, `gte`, `lt`, 和 `lte`。
用于交易数据的编码格式（仅在 `transactionDetails: "full"` 时适用）。与 `getTransaction` API 相同。选项：`json`, `jsonParsed`, `base64`, `base58`
设置要返回的最大交易版本。如果省略，则仅返回传统交易。设置为 `0` 可包含所有版本的交易。
请求可以评估的最小槽位
### 计量
成功的响应将根据返回内容进行计量：
| 响应类型 | 学分 |
| ------- | --------------------------- |
| 完整交易 | 每100个返回交易10个学分，向上取整；最低10个学分 |
| 仅签名 | 无论数量如何，都是固定的10个学分 |
| API响应失败 | 免费 |
## 响应
响应结构取决于`transactionDetails`。签名模式返回轻量级签名记录；完整模式返回完整的交易和元数据对象。
```json theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"data": [
{
"signature": "5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv",
"slot": 1054,
"transactionIndex": 42,
"err": null,
"memo": null,
"blockTime": 1641038400,
"confirmationStatus": "finalized"
}
],
"paginationToken": "1055:5"
}
}
```
```json theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"data": [
{
"slot": 1054,
"transactionIndex": 42,
"blockTime": 1641038400,
"transaction": {
"signatures": ["5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv"],
"message": {
"accountKeys": ["...", "..."],
"instructions": [...],
// Complete transaction structure
}
},
"meta": {
"fee": 5000,
"preBalances": [1000000, 2000000],
"postBalances": [999995000, 2000000],
// Complete metadata
}
}
],
"paginationToken": "1055:5"
}
}
```
### 响应字段
| 字段 | 类型 | 描述 |
| -------------------- | -------------- | ----------------------------- |
| `signature` | string | 交易签名（base-58编码）。仅在签名模式下。 |
| `slot` | number | 包含此交易的块的槽位。 |
| `transactionIndex` | number | 交易在其区块中的基于零的索引。用于交易排序和区块重建。 |
| `blockTime` | number \| null | 估计的生产时间，以Unix时间戳表示（自纪元以来的秒数）。 |
| `err` | object \| null | 如果交易失败则出错，成功时为null。仅在签名模式下。 |
| `memo` | string \| null | 与交易关联的备注。仅在签名模式下。 |
| `confirmationStatus` | string | 交易的集群确认状态。仅在签名模式下。 |
| `transaction` | object | 完整的交易数据。仅在完整模式下。 |
| `meta` | object | 交易状态元数据。仅在完整模式下。 |
| `paginationToken` | string \| null | 用于获取下一页的令牌，若无更多结果则为null。 |
`transactionIndex`字段仅适用于`getTransactionsForAddress`。其他类似端点如`getSignaturesForAddress`，`getTransaction`和`getTransactions`不包含此字段。
## 过滤器
可以对`slot`，`blockTime`和`signature`使用比较运算符，加上特殊的`status`，`tokenAccounts`和`tokenTransfer`过滤器。组合多个过滤器会将结果缩小到它们的交集。
### 比较运算符
这些运算符像数据库查询一样工作，使您能够精确控制数据范围。
| 运算符 | 全名 | 描述 | 示例 |
| ----- | ----- | -------------------------- | ------------------------------- |
| `gte` | 大于或等于 | 包括大于等于指定值的值 | `slot: { gte: 100 }` |
| `gt` | 大于 | 包括大于指定值的值 | `blockTime: { gt: 1641081600 }` |
| `lte` | 小于或等于 | 包括小于等于指定值的值 | `slot: { lte: 2000 }` |
| `lt` | 小于 | 包括小于指定值的值 | `blockTime: { lt: 1641168000 }` |
| `eq` | 等于 | 包括与指定值完全相等的值（仅`blockTime`） | `blockTime: { eq: 1641081600 }` |
### 枚举过滤器
| 过滤器 | 描述 | 值 |
| --------------- | ----------- | ----------------------------- |
| `status` | 按成功/失败过滤交易 | `succeeded`，`failed`或`any` |
| `tokenAccounts` | 按相关代币账户过滤交易 | `none`，`balanceChanged`或`all` |
组合过滤器示例：
```javascript theme={"system"}
// Time range with successful transactions only
"filters": {
"blockTime": {
"gte": 1640995200,
"lte": 1641081600
},
"status": "succeeded"
}
// Slot range
"filters": {
"slot": {
"gte": 1000,
"lte": 2000
}
}
// Only failed transactions
"filters": {
"status": "failed"
}
```
### 关联代币账户
在Solana上，钱包不会直接持有代币。相反，钱包拥有代币账户，这些代币账户持有代币。当有人给您发送USDC时，它会进入您的USDC代币账户，而不是您的主要钱包地址。
此方法很独特，因为它可以查询**完整的代币历史**，包括钱包的关联代币账户（ATAs）。本机RPC方法如`getSignaturesForAddress`不包括ATAs。
`tokenAccounts` 过滤器控制此行为：
* **`none`**（默认）：仅返回直接引用钱包地址的交易。当您只关心直接的钱包交互时使用。
* **`balanceChanged`**（推荐）：返回引用钱包地址或修改由钱包拥有的代币账户余额的交易。这样可以过滤掉垃圾邮件和不相关的操作，如费用收集或委托，呈现出意义明确的钱包活动视图。
* **`all`**：返回引用钱包地址或任何由钱包拥有的代币账户的所有交易。
`tokenAccounts` 过滤器不支持2022年12月之前的交易。它依赖于在 Solana 的槽位111,491,819上引入的代币传输元数据。要覆盖更早的活动，请参阅[历史代币账户解决方法](#limitations-and-edge-cases)。
### 代币传输过滤器
`tokenTransfer` 过滤器将结果缩小到查询地址参与的符合特定条件的代币转移交易：特定的交易对手、代币铸造、方向或金额范围。
使用此工具回答以下问题：
* 这个钱包什么时候从特定的交易对手接收到 USDC？
* 显示每个超过1000个代币的转出交易。
* 这个钱包何时与此特定的铸造代币接触过？
过滤器是请求配置的 `filters` 对象中的可选字段：
```json theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionsForAddress",
"params": [
"",
{
"filters": {
"tokenTransfer": {}
}
}
]
}
```
`tokenTransfer` 中的所有字段都是可选的。组合多个字段被视为 AND。
| 字段 | 类型 | 默认 | 描述 |
| ----------- | ---------------------------- | ------- | ------------------------------- |
| `with` | 字符串（pubkey） | - | 交易对手地址。匹配另一方是此地址的转移。 |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"` | 查询地址是否收到、发送或任一。 |
| `mint` | 字符串（pubkey） | - | 用于过滤的代币铸造。 |
| `amount` | 对象 | - | 数量比较。使用原始链上数量，而不是 UI 或小数调整后的数量。 |
金额范围运算符：
| 运算符 | 含义 |
| ----- | ----- |
| `gt` | 严格大于 |
| `gte` | 大于或等于 |
| `lt` | 严格小于 |
| `lte` | 小于或等于 |
您可以组合金额运算符，例如 `{ "gte": 1000000, "lte": 5000000 }` 表示一个封闭范围。`tokenTransfer` 与其他顶级过滤器（`slot`、`blockTime`、`status` 和 `tokenAccounts`）一起组成；最终结果是交集。
## 示例
### 基于时间的分析
生成月度交易报告：
```javascript theme={"system"}
// Get all successful transactions for January 2025
const startTime = Math.floor(new Date('2025-01-01').getTime() / 1000);
const endTime = Math.floor(new Date('2025-02-01').getTime() / 1000);
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionsForAddress",
"params": [
"WALLET_OR_PROGRAM_ADDRESS",
{
"transactionDetails": "signatures",
"filters": {
"blockTime": {
"gte": startTime,
"lt": endTime
},
"status": "succeeded"
},
"limit": 1000
}
]
}
```
分析过程：
```javascript theme={"system"}
// Calculate daily transaction volume
const dailyStats = {};
response.result.data.forEach(tx => {
const date = new Date(tx.blockTime * 1000).toISOString().split('T')[0];
dailyStats[date] = (dailyStats[date] || 0) + 1;
});
console.log('Daily Transaction Counts:', dailyStats);
```
### 代币铸造创建
查找特定代币的铸造创建交易：
```javascript theme={"system"}
{
"jsonrpc": "2.0",
"id": "find-first-mints",
"method": "getTransactionsForAddress",
"params": [
MINT_ADDRESS, // Token mint address
{
"encoding": "jsonParsed",
"maxSupportedTransactionVersion": 0,
"sortOrder": "asc", // Chronological order from the beginning
"limit": 10,
"transactionDetails": "full"
}
]
}
```
对于流动性池创建，查询池地址：
```javascript theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionsForAddress",
"params": [
"POOL_ADDRESS_HERE", // Raydium/Meteora pool address
{
"transactionDetails": "full",
"sortOrder": "asc", // First transaction is usually pool creation
"limit": 1
}
]
}
```
找到代币铸造或流动性池创建的确切时刻，包括创建者地址和初始参数。
### 资金交易
查找谁为特定地址提供资金：
```javascript theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionsForAddress",
"params": [
"TARGET_WALLET_ADDRESS",
{
"transactionDetails": "full",
"sortOrder": "asc", // Oldest first
"limit": 10
}
]
}
```
然后分析交易数据以找到 SOL 转账：
```javascript theme={"system"}
response.result.data.forEach(tx => {
// Look for SOL transfers in preBalances/postBalances
const balanceChanges = tx.meta.preBalances.map((pre, index) =>
tx.meta.postBalances[index] - pre
);
// Positive balance change = incoming SOL
balanceChanges.forEach((change, index) => {
if (change > 0) {
console.log(`Received ${change} lamports from ${tx.transaction.message.accountKeys[index]}`);
}
});
});
```
最初的几笔交易通常揭示资金来源，并可帮助识别相关地址或资金模式。
### 代币转账
通过 `tokenTransfer` 过滤以隔离特定的代币移动。
USDC 流入某个地址：
```json theme={"system"}
{
"filters": {
"tokenTransfer": {
"direction": "in",
"mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
}
}
}
```
针对特定交易对手的大额转出：
```json theme={"system"}
{
"filters": {
"tokenTransfer": {
"with": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
"direction": "out",
"amount": { "gte": 1000000000 }
}
}
}
```
结合插槽范围和状态：
```json theme={"system"}
{
"filters": {
"status": "succeeded",
"slot": { "gte": 100000000, "lte": 200000000 },
"tokenTransfer": {
"direction": "in",
"mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
"amount": { "gte": 5000000 }
}
}
}
```
## 分页
当您的交易超过限制时，使用响应中的`paginationToken`获取下一页。该令牌是一个简单的字符串，格式为`"slot:position"`，指示API从何处继续。
使用每个响应中的分页令牌获取下一页：
```javascript theme={"system"}
// First request
let paginationToken = null;
let allTransactions = [];
const getNextPage = async (paginationToken = null) => {
const params = [
'ADDRESS',
{
transactionDetails: 'signatures',
limit: 100,
...(paginationToken && { paginationToken })
}
];
const response = await fetch(rpcUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'getTransactionsForAddress',
params
})
});
const data = await response.json();
return data.result;
};
// Paginate through all results
do {
const result = await getNextPage(paginationToken);
allTransactions.push(...result.data);
paginationToken = result.paginationToken;
console.log(`Fetched ${result.data.length} transactions, total: ${allTransactions.length}`);
} while (paginationToken);
```
### 多个地址
您不能在单个请求中查询多个地址。每个地址查询都算作单独的API请求，并相应计量。要获取多个地址的交易，在相同时间或插槽窗口内查询每个地址，然后合并和排序：
```javascript theme={"system"}
const addresses = ['Address1...', 'Address2...', 'Address3...'];
// Query all addresses in parallel with slot filter
const results = await Promise.all(
addresses.map(address =>
fetch(rpcUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'getTransactionsForAddress',
params: [address, {
sortOrder: 'desc',
filters: { slot: { gt: 250000000 } }
}]
})
}).then(r => r.json())
)
);
// Merge and sort by slot
const allTransactions = results
.flatMap(r => r.result.data)
.sort((a, b) => b.slot - a.slot);
```
对于更大的历史扫描，逐步通过时间或插槽窗口（例如一次1000个插槽）进行迭代，并重复此模式。
## 最佳实践
**性能。** 当不需要完整交易数据时，使用`transactionDetails: "signatures"`。使用合理的页面大小以获得更好的响应时间，并通过时间范围或特定插槽进行筛选，以实现更有针对性的查询。
**过滤。** 从宽泛的过滤器开始，然后逐步缩小范围。使用基于时间的过滤器进行分析和报告工作流，并组合多个过滤器以进行精确查询，针对特定交易类型或时间段。
**分页。** 在您需要稍后恢复大型查询时存储分页令牌。监控分页深度以进行性能规划，并在需要按时间顺序重放历史事件时使用升序。
**错误处理。** 使用指数退避优雅地处理速率限制。在发出请求之前验证地址，并在适当情况下缓存结果以减少API使用。
## 限制和边界情况
一小部分地址会路由到旧的归档，限于槽扫描备用，或者返回为空。在槽111,491,819之前进行Token账户发现也需要解决方法。展开下面的部分以获取完整的详细信息。
\*\*路由到旧归档。\*\*这些地址的请求被路由到我们的旧归档系统。
| 地址 | 名称 |
| --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `Stake11111111111111111111111111111111111111` | [Stake Program](https://orbmarkets.io/address/Stake11111111111111111111111111111111111111/history) |
| `StakeConfig11111111111111111111111111111111` | [Stake Config](https://orbmarkets.io/address/StakeConfig11111111111111111111111111111111/history) |
| `Sysvar1111111111111111111111111111111111111` | [Sysvar Owner](https://orbmarkets.io/address/Sysvar1111111111111111111111111111111111111/history) |
| `AddressLookupTab1e1111111111111111111111111` | [Address Lookup Table](https://orbmarkets.io/address/AddressLookupTab1e1111111111111111111111111/history) |
| `BPFLoaderUpgradeab1e11111111111111111111111` | [BPF Loader Upgradeable](https://orbmarkets.io/address/BPFLoaderUpgradeab1e11111111111111111111111/history) |
\*\*槽扫描备用。\*\*这些地址的请求被转发到我们的新归档系统，并通过逐槽扫描方式进行查询（最多100个槽）。但是，这些数据未被索引。
| 地址 | 名称 |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| `11111111111111111111111111111111` | [System Program](https://orbmarkets.io/address/11111111111111111111111111111111/history) |
| `ComputeBudget111111111111111111111111111111` | [Compute Budget](https://orbmarkets.io/address/ComputeBudget111111111111111111111111111111/history) |
| `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr` | [Memo Program](https://orbmarkets.io/address/MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr/history) |
| `Vote111111111111111111111111111111111111111` | [Vote Program](https://orbmarkets.io/address/Vote111111111111111111111111111111111111111/history) |
\*\*返回为空(`is_reserved_address`)。\*\*请求被转发到我们的新归档系统，但数据未被索引，查询结果为空。
| 地址 | 名称 |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `BPFLoader1111111111111111111111111111111111` | [BPF Loader (deprecated)](https://orbmarkets.io/address/BPFLoader1111111111111111111111111111111111/history) |
| `BPFLoader2111111111111111111111111111111111` | [BPF Loader](https://orbmarkets.io/address/BPFLoader2111111111111111111111111111111111/history) |
| `Config1111111111111111111111111111111111111` | [Config Program](https://orbmarkets.io/address/Config1111111111111111111111111111111111111/history) |
| `Ed25519SigVerify111111111111111111111111111` | [Ed25519 Program](https://orbmarkets.io/address/Ed25519SigVerify111111111111111111111111111/history) |
| `Feature111111111111111111111111111111111111` | [Feature Program](https://orbmarkets.io/address/Feature111111111111111111111111111111111111/history) |
| `KeccakSecp256k11111111111111111111111111111` | [Secp256k1 Program](https://orbmarkets.io/address/KeccakSecp256k11111111111111111111111111111/history) |
| `LoaderV411111111111111111111111111111111111` | [Loader V4](https://orbmarkets.io/address/LoaderV411111111111111111111111111111111111/history) |
| `NativeLoader1111111111111111111111111111111` | [Native Loader](https://orbmarkets.io/address/NativeLoader1111111111111111111111111111111/history) |
| `SysvarC1ock11111111111111111111111111111111` | [Clock Sysvar](https://orbmarkets.io/address/SysvarC1ock11111111111111111111111111111111/history) |
| `SysvarEpochSchedu1e111111111111111111111111` | [Epoch Schedule Sysvar](https://orbmarkets.io/address/SysvarEpochSchedu1e111111111111111111111111/history) |
| `SysvarFees111111111111111111111111111111111` | [Fees Sysvar](https://orbmarkets.io/address/SysvarFees111111111111111111111111111111111/history) |
| `Sysvar1nstructions1111111111111111111111111` | [Instructions Sysvar](https://orbmarkets.io/address/Sysvar1nstructions1111111111111111111111111/history) |
| `SysvarRecentB1ockHashes11111111111111111111` | [Recent Blockhashes Sysvar](https://orbmarkets.io/address/SysvarRecentB1ockHashes11111111111111111111/history) |
| `SysvarRent111111111111111111111111111111111` | [Rent Sysvar](https://orbmarkets.io/address/SysvarRent111111111111111111111111111111111/history) |
| `SysvarRewards111111111111111111111111111111` | [Rewards Sysvar](https://orbmarkets.io/address/SysvarRewards111111111111111111111111111111/history) |
| `SysvarS1otHashes111111111111111111111111111` | [Slot Hashes Sysvar](https://orbmarkets.io/address/SysvarS1otHashes111111111111111111111111111/history) |
| `SysvarS1otHistory11111111111111111111111111` | [Slot History Sysvar](https://orbmarkets.io/address/SysvarS1otHistory11111111111111111111111111/history) |
| `SysvarStakeHistory1111111111111111111111111` | [Stake History Sysvar](https://orbmarkets.io/address/SysvarStakeHistory1111111111111111111111111/history) |
| `SysvarEpochRewards11111111111111111111111111` | [Epoch Rewards Sysvar](https://orbmarkets.io/address/SysvarEpochRewards11111111111111111111111111/history) |
| `SysvarLastRestartS1ot1111111111111111111111` | [Last Restart Slot Sysvar](https://orbmarkets.io/address/SysvarLastRestartS1ot1111111111111111111111/history) |
对于在槽位111,491,819之前有令牌账户活动的地址，由于令牌余额元数据中的`owner`字段尚不存在，`tokenAccounts`过滤器无法确定归属。为了获得完整的结果，您可以手动通过解析早期交易指令发现这些令牌账户，然后为每个账户并行查询`getTransactionsForAddress`。
```javascript theme={"system"}
const HELIUS_RPC = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
const OWNER_CUTOFF_SLOT = 111_491_819;
async function rpcCall(method, params) {
const res = await fetch(HELIUS_RPC, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ jsonrpc: "2.0", id: "1", method, params }),
});
const json = await res.json();
if (json.error) throw new Error(json.error.message);
return json.result;
}
// Step 1: Discover token accounts owned by the address before the cutoff slot
// by parsing initializeAccount instructions and transfer authorities.
async function discoverHistoricalTokenAccounts(address) {
const tokenAccounts = new Set();
let paginationToken = null;
do {
const result = await rpcCall("getTransactionsForAddress", [
address,
{
transactionDetails: "full",
encoding: "jsonParsed",
maxSupportedTransactionVersion: 0,
sortOrder: "asc",
limit: 100,
filters: { slot: { lt: OWNER_CUTOFF_SLOT } },
...(paginationToken && { paginationToken }),
},
]);
if (!result?.data?.length) break;
for (const entry of result.data) {
const tx = entry.transaction;
const meta = entry.meta;
if (!tx || !meta) continue;
const allInstructions = [
...(tx.message?.instructions ?? []),
...(meta.innerInstructions ?? []).flatMap((inner) => inner.instructions ?? []),
];
for (const ix of allInstructions) {
// AToken program "create" instruction
if (ix.program === "spl-associated-token-account") {
if (ix.parsed?.type === "create" && ix.parsed.info?.wallet === address && ix.parsed.info?.account) {
tokenAccounts.add(ix.parsed.info.account);
}
continue;
}
if (ix.program !== "spl-token" && ix.program !== "spl-token-2022") continue;
const type = ix.parsed?.type;
const info = ix.parsed?.info;
// Token account initialization
if (type === "initializeAccount" || type === "initializeAccount2" || type === "initializeAccount3") {
if (info?.owner === address && info?.account) tokenAccounts.add(info.account);
}
// Transfers where our address is the authority (source account is ours)
if (type === "transfer" || type === "transferChecked") {
if (info?.authority === address && info?.source) tokenAccounts.add(info.source);
}
}
}
paginationToken = result.paginationToken;
} while (paginationToken);
return Array.from(tokenAccounts);
}
// Step 2: Fetch all signatures for an address with pagination
async function fetchAllSignatures(address, filters) {
const allSignatures = [];
let paginationToken = null;
do {
const result = await rpcCall("getTransactionsForAddress", [
address,
{
transactionDetails: "signatures",
sortOrder: "asc",
limit: 1000,
...(filters && { filters }),
...(paginationToken && { paginationToken }),
},
]);
if (!result?.data?.length) break;
allSignatures.push(...result.data);
paginationToken = result.paginationToken;
} while (paginationToken);
return allSignatures;
}
// Step 3: Get complete history by combining tokenAccounts:"all" with
// individual queries for historical token accounts
async function getCompleteHistory(address) {
const historicalAccounts = await discoverHistoricalTokenAccounts(address);
if (historicalAccounts.length === 0) {
return fetchAllSignatures(address, { tokenAccounts: "all" });
}
// Query main address with tokenAccounts:"all" + each historical account in parallel
const results = await Promise.all([
fetchAllSignatures(address, { tokenAccounts: "all" }),
...historicalAccounts.map((addr) => fetchAllSignatures(addr)),
]);
// Merge and deduplicate by signature
const seen = new Set();
const merged = [];
for (const batch of results) {
for (const tx of batch) {
if (!seen.has(tx.signature)) {
seen.add(tx.signature);
merged.push(tx);
}
}
}
return merged.sort((a, b) => a.slot - b.slot);
}
```
## 这与getSignaturesForAddress有何不同？
如果您熟悉标准的`getSignaturesForAddress`方法，`getTransactionsForAddress`将多步骤工作流缩减为单个调用，并增加了过滤、排序和令牌账户支持。
### 一次调用获取完整交易
使用`getSignaturesForAddress`，您需要两个步骤：
```javascript theme={"system"}
// Step 1: Get signatures
const signatures = await connection.getSignaturesForAddress(address, { limit: 1000 });
// Step 2: Get transaction details (1,000 additional calls!)
const transactions = await Promise.all(
signatures.map(sig => connection.getTransaction(sig.signature))
);
```
使用`getTransactionsForAddress`，只需一次调用：
```javascript theme={"system"}
const response = await fetch(heliusRpcUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'getTransactionsForAddress',
params: [
address,
{
transactionDetails: 'full',
limit: 1000
}
]
})
});
```
### 一次调用获取令牌历史
使用`getSignaturesForAddress`，您需要先调用`getTokenAccountsByOwner`，然后查询每个令牌账户：
```javascript theme={"system"}
// OLD WAY (with getSignaturesForAddress)
// Step 1: Get all token accounts owned by this wallet
const tokenAccounts = await connection.getTokenAccountsByOwner(
new PublicKey(walletAddress),
{ programId: TOKEN_PROGRAM_ID }
);
// Step 2: Fetch signatures for the wallet itself
const walletSignatures = await connection.getSignaturesForAddress(
new PublicKey(walletAddress),
{ limit: 1000 }
);
// Step 3: Fetch signatures for EVERY token account (this is the painful part)
const tokenAccountSignatures = await Promise.all(
tokenAccounts.value.map(async (account) => {
return connection.getSignaturesForAddress(
account.pubkey,
{ limit: 1000 }
);
})
);
// Step 4: Merge all results together
const allSignatures = [
...walletSignatures,
...tokenAccountSignatures.flat()
];
// Step 5: Deduplicate (many transactions touch multiple accounts)
const seen = new Set();
const uniqueSignatures = allSignatures.filter((sig) => {
if (seen.has(sig.signature)) {
return false;
}
seen.add(sig.signature);
return true;
});
// Step 6: Sort chronologically
const sortedSignatures = uniqueSignatures.sort(
(a, b) => a.slot - b.slot
);
return sortedSignatures;
```
使用`getTransactionsForAddress`，您只需设置`filters.tokenAccounts`：
```javascript theme={"system"}
// NEW WAY (with getTransactionsForAddress)
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: "helius-example",
method: "getTransactionsForAddress",
params: [
walletAddress,
{
filters: {
tokenAccounts: "all"
},
sortOrder: "asc",
limit: 100
}
]
})
});
const { result } = await response.json();
return result;
```
### 其他功能
使用`sortOrder: 'asc'`从最早到最新排序交易。
使用`blockTime`过滤器按时间范围过滤。
使用`status`过滤器仅获取成功或失败的交易。
使用`paginationToken`代替复杂的`before`/`until`签名。
## 下一步
使用getTransactionsForAddress备份和同步Solana索引。
解析后，仅限转账的历史记录，用于支付和对账。
getTransactionsForAddress的完整请求和响应模式。
比较所有Solana历史数据方法。