> ## 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`](/ja/api-reference/rpc/http/gettransactionsforaddress) はHelius専用のRPCメソッドで、アドレスのトランザクション履歴を高度なフィルタリング、柔軟なソート、効率的なページネーションを使用して返します。これが標準のSolana RPCの一部ではありません。

`getSignaturesForAddress` とは異なり、署名のみを返し、関連トークンアカウントをスキップしますが、`getTransactionsForAddress` はウォレットの関連トークンアカウント（ATA）のアクティビティを含む完全なトランザクションデータを1回の呼び出しで返すことができます。それにより、バックフィル、インデックス作成、および分析のための完全なアドレス履歴への最速の経路となります。

このメソッドは、1回の呼び出しで最大1,000の完全なトランザクションを返します。

<CardGroup cols={2}>
  <Card title="柔軟なソート" icon="arrows-up-down">
    時系列（古い順）または逆（新しい順）でソートします。
  </Card>

  <Card title="高度なフィルタリング" icon="filter">
    時間範囲、スロット、署名、ステータス、トークン転送でフィルタリングします。
  </Card>

  <Card title="完全なトランザクションデータ" icon="database">
    完全なトランザクションの詳細を一回の呼び出しで取得します。追跡getTransactionは不要です。
  </Card>

  <Card title="トークンアカウント" icon="layer-group">
    アドレスの関連トークンアカウントに対するトランザクションを含めます。
  </Card>
</CardGroup>

## いつ使用するか

`getTransactionsForAddress` を使用するとき:

* 関連トークンアカウントを含む完全なウォレットトークン履歴が必要な場合
* インデクサーやデータパイプラインのために単一呼び出しの高速バックフィルが必要な場合
* 時間ベースまたはスロットベースのトランザクション分析と報告が必要な場合
* 成功したトランザクションまたは失敗したトランザクションのみを保持するためのステータスフィルタリングが必要な場合
* 時系列履歴再生（古い順序）の場合
* トークン発行分析：最初のミントトランザクションと初期ホルダー
* ウォレット資金提供履歴およびカウンターパーティの発見
* 特定の期間のコンプライアンスおよび監査報告が必要な場合

解析された転送のみの履歴（支払い、残高調整）の場合は、代わりに[`getTransfersByAddress`](/ja/rpc/gettransfersbyaddress) を使用します。

### ネットワークサポート

| ネットワーク  | サポート | 保持期間 |
| ------- | ---- | ---- |
| Mainnet | はい   | 無制限  |
| Devnet  | はい   | 2週間  |
| Testnet | いいえ  | 該当なし |

## クイックスタート

<Steps>
  <Step title="APIキーの取得">
    [Helius Dashboard](https://dashboard.helius.dev/api-keys) からAPIキーを取得します。
  </Step>

  <Step title="高度な機能を使ってクエリを行います">
    2つの日付の間で、ウォレットのすべての成功したトランザクションを取得し、時系列に並べます:

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

  <Step title="パラメータを理解します">
    この例では、主要な機能を示しています:

    * **transactionDetails**: 完全なトランザクションデータを1回の呼び出しで取得するために`'full'`に設定
    * **sortOrder**: 時系列順（古い順）のために`'asc'`、または新しい順のために`'desc'`を使用
    * **filters.blockTime**: `gte`（以上）および`lte`（以下）で時間範囲を設定
    * **filters.status**: `'succeeded'`または`'failed'`のトランザクションに限定
    * **filters.tokenAccounts**: 関連トークンアカウントの転送、ミント、およびバーンを含める
  </Step>
</Steps>

## リクエストパラメータ

<ParamField body="address" type="string" required>
  トランザクション履歴をクエリするアカウントのBase-58エンコードされた公開鍵
</ParamField>

<ParamField body="transactionDetails" type="string" default="signatures">
  返すトランザクション詳細のレベル:

  * `signatures`: 基本的な署名情報（高速）
  * `full`: 完全なトランザクションデータ（getTransaction呼び出しの必要をなくし、最大1,000件をサポート）
</ParamField>

<ParamField body="sortOrder" type="string" default="desc">
  結果のソート順:

  * `desc`: 新しい順（デフォルト）
  * `asc`: 古い順（時系列、履歴分析向け）
</ParamField>

<ParamField body="limit" type="number" default="1000">
  返すトランザクションの最大数:

  * `transactionDetails: "signatures"` で最大1000件
  * `transactionDetails: "full"` で最大1000件
</ParamField>

<ParamField body="paginationToken" type="string">
  前回の応答からのページネーショントークン（形式: `"slot:position"`）
</ParamField>

<ParamField body="commitment" type="string" default="finalized">
  コミットメントレベル: `finalized` または `confirmed`。`processed` コミットメントはサポートされていません。
</ParamField>

<ParamField body="filters" type="object">
  結果を絞り込むための高度なフィルタリングオプション。
</ParamField>

<ParamField body="filters.slot" type="object">
  比較演算子を使用してスロット番号でフィルタリング: `gte`, `gt`, `lte`, `lt`

  例: `{ "slot": { "gte": 1000, "lte": 2000 } }`
</ParamField>

<ParamField body="filters.blockTime" type="object">
  比較演算子を使用してUnixタイムスタンプでフィルタリング: `gte`, `gt`, `lte`, `lt`, `eq`

  例: `{ "blockTime": { "gte": 1640995200, "lte": 1641081600 } }`
</ParamField>

<ParamField body="filters.signature" type="object">
  比較演算子を使用してトランザクション署名でフィルタリング: `gte`, `gt`, `lte`, `lt`

  例: `{ "signature": { "lt": "SIGNATURE_STRING" } }`
</ParamField>

<ParamField body="filters.status" type="string">
  トランザクションの成功/失敗ステータスでフィルタリング:

  * `succeeded`: 成功したトランザクションのみ
  * `failed`: 失敗したトランザクションのみ
  * `any`: 成功および失敗の両方（デフォルト）

  例: `{ "status": "succeeded" }`
</ParamField>

<ParamField body="filters.tokenAccounts" type="string" default="none">
  関連トークンアカウントのトランザクションでフィルタリング:

  * `none`: 提供されたアドレスを参照するトランザクションのみを返す（デフォルト）
  * `balanceChanged`: 提供されたアドレスまたは提供されたアドレスが所有するトークンアカウントの残高を変更するトランザクションを返す（推奨）
  * `all`: 提供されたアドレスまたは提供されたアドレスが所有する任意のトークンアカウントを参照するトランザクションを返す

  例: `{ "tokenAccounts": "balanceChanged" }`
</ParamField>

<ParamField body="filters.tokenTransfer" type="object">
  クエリされたアドレスがカウンターパーティ、方向、ミント、または生の量範囲に一致するトークン転送に参加したトランザクションにフィルタリングします。すべてのフィールドはオプションであり、ANDセマンティクスで組み合わされます。

  例: `{ "tokenTransfer": { "direction": "in", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" } }`
</ParamField>

<ParamField body="filters.tokenTransfer.with" type="string">
  カウンターパーティのアドレス。このアドレスを他方の側とする転送に一致します。
</ParamField>

<ParamField body="filters.tokenTransfer.direction" type="string" default="any">
  クエリされたアドレスに対する転送方向でフィルタリング:

  * `in`: クエリされたアドレスが受け取った転送
  * `out`: クエリされたアドレスが送信した転送
  * `any`: 入出転送
</ParamField>

<ParamField body="filters.tokenTransfer.mint" type="string">
  フィルタリングするトークンミント。
</ParamField>

<ParamField body="filters.tokenTransfer.amount" type="object">
  UIや小数点調整された量ではなく、生のオンチェーン量を使用して量を比較します。 `gt`, `gte`, `lt`, `lte`をサポートします。
</ParamField>

<ParamField body="encoding" type="string">
  トランザクションデータのエンコーディング形式（`transactionDetails: "full"`時にのみ適用されます）。`getTransaction` APIと同じです。オプション: `json`, `jsonParsed`, `base64`, `base58`
</ParamField>

<ParamField body="maxSupportedTransactionVersion" type="number">
  返す最大トランザクションバージョンを設定します。省略した場合、レガシートランザクションのみが返されます。すべてのバージョン化されたトランザクションを含めるには、`0` に設定します。
</ParamField>

<ParamField body="minContextSlot" type="number">
  リクエストを評価できる最小スロット
</ParamField>

### メータリング

成功した応答は返されるものによってメーターされます:

| 応答の種類       | クレジット                                        |
| ----------- | -------------------------------------------- |
| 完全なトランザクション | 100件返されるトランザクションごとに10クレジット、切り上げ; 10クレジットの最低限 |
| 署名のみ        | カウントに関係なく一律10クレジット                           |
| 失敗したAPI応答   | 無料                                           |

## 応答

応答の形式は`transactionDetails` に依存します。署名モードは軽量な署名レコードを返し、完全モードは完全なトランザクションとメタデータオブジェクトを返します。

<Tabs>
  <Tab title="署名応答">
    ```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"
      }
    }
    ```
  </Tab>

  <Tab title="完全なトランザクション応答">
    ```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"
      }
    }
    ```
  </Tab>
</Tabs>

### 応答フィールド

| フィールド                | 型              | 説明                                        |                                                           |
| -------------------- | -------------- | ----------------------------------------- | --------------------------------------------------------- |
| `signature`          | string         | トランザクション署名（base-58エンコード）。署名モードでのみ。        |                                                           |
| `slot`               | number         | このトランザクションを含むブロックのスロット。                   |                                                           |
| `transactionIndex`   | number         | null                                      | トランザクションのブロック内でのゼロベースのインデックス。トランザクションの順序付けやブロック再構築に役立ちます。 |
| `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`, and `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）を含む**完全なトークン履歴**をクエリすることができます。`getSignaturesForAddress` のようなネイティブRPCメソッドはATAsを含みません。

この動作を制御するのが`tokenAccounts` フィルタです:

* **`none`**（デフォルト）: 直接ウォレットアドレスを参照するトランザクションのみを返します。直接のウォレットインタラクションのみを気にする場合に使用します。
* **`balanceChanged`**（推奨）: ウォレットアドレスまたはウォレットが所有するトークンアカウントの残高を変更するトランザクションを返します。スパムや関連のない操作（手数料の回収やデリゲーションなど）を除外し、有意義なウォレット活動をクリーンに表示します。
* **`all`**: ウォレットアドレスまたはウォレットが所有する任意のトークンアカウントを参照するすべてのトランザクションを返します。

`tokenAccounts` フィルタは2022年12月以前のトランザクションをサポートしていません。これは、Solanaにトークントランスファーメタデータが導入されたスロット111,491,819に依存しています。以前のアクティビティをカバーするには、[歴史的トークンアカウントの回避策](#limitations-and-edge-cases) を参照してください。

### トークン転送フィルタ

`tokenTransfer` フィルタは、クエリされたアドレスが特定の基準に一致するトークン転送に参加したトランザクションに結果を絞り込みます: 特定のカウンターパーティ、ミント、方向、または量範囲。

次のような質問に答えるために使用します:

* このウォレットは特定のカウンターパーティからいつUSDCを受け取りましたか？
* 1,000トークン以上のすべての送信転送を表示します。
* このウォレットがこの特定のミントに一度でも触れたのはいつですか？

フィルタはリクエスト設定の `filters` オブジェクト内のオプションフィールドです:

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress",
  "params": [
    "<address>",
    {
      "filters": {
        "tokenTransfer": {}
      }
    }
  ]
}
```

`tokenTransfer` 内のすべてのフィールドはオプションです。複数のフィールドを組み合わせるとANDとして扱われます。

| フィールド       | 型                            | デフォルト   | 説明                                     |
| ----------- | ---------------------------- | ------- | -------------------------------------- |
| `with`      | string (pubkey)              | -       | カウンターパーティのアドレス。このアドレスを他方の側とする転送に一致します。 |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"` | クエリされたアドレスが受け取った、送信した、またはどちらかの転送か。     |
| `mint`      | string (pubkey)              | -       | フィルタリングするトークンミント。                      |
| `amount`    | object                       | -       | 量の比較。UIや小数点調整された量ではなく、生のオンチェーン量を使用します。 |

量の範囲演算子:

| 演算子   | 意味    |
| ----- | ----- |
| `gt`  | より大きい |
| `gte` | 以上    |
| `lt`  | より小さい |
| `lte` | 以下    |

量演算子を組み合わせることができます。たとえば、`{ "gte": 1000000, "lte": 5000000 }` は閉じた範囲です。`tokenTransfer` は他のトップレベルフィルタ（`slot`, `blockTime`, `status`, and `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` を使用して次のページをフェッチします。トークンは単純な文字列で、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以前のトークンアカウントの発見にはワークアラウンドが必要です。完全な詳細については、以下のセクションを展開してください。

<Accordion title="サポートされていないおよび特別ルートのアドレス">
  **古いアーカイブにルーティング。** これらのアドレスに対するリクエストは、私たちの古いアーカイブシステムにルーティングされます。

  | アドレス                                          | 名前                                                                                                          |
  | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
  | `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)  |
</Accordion>

<Accordion title="回避策: 歴史的トークンアカウントの発見（スロット111,491,819以前）">
  スロット111,491,819より前にトークンアカウント活動のある住所について、`tokenAccounts` フィルタは所有権を特定できません。これは、トークンのバランスメタデータに`owner` フィールドが存在しなかったためです。完全な結果を得るには、初期のトランザクション命令を解析してこれらのトークンアカウントを手動で発見し、それぞれ並行して`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);
  }
  ```
</Accordion>

## getSignaturesForAddressとの違いは何ですか？

標準の`getSignaturesForAddress` メソッドに精通している場合、`getTransactionsForAddress` はマルチステップワークフローを単一の呼び出しに統合し、フィルタリング、ソート、トークンアカウントのサポートを追加します。

### 1回の呼び出しで完全なトランザクションを取得

`getSignaturesForAddress` を使用すると、2ステップ必要です:

```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` では、1回の呼び出しです:

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

### 1回の呼び出しでトークン履歴を取得

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

### 追加機能

<CardGroup cols={2}>
  <Card title="時系列ソート" icon="arrow-up">
    `sortOrder: 'asc'` で古い順から新しい順にトランザクションをソートします。
  </Card>

  <Card title="時間ベースのフィルタリング" icon="clock">
    `blockTime` フィルタを使用して時間範囲でフィルタリングします。
  </Card>

  <Card title="ステータスフィルタリング" icon="filter">
    `status` フィルタで成功したトランザクションまたは失敗したトランザクションのみを取得します。
  </Card>

  <Card title="よりシンプルなページネーション" icon="list">
    `paginationToken` を使用して、混乱する `before`/`until` 署名の代わりにします。
  </Card>
</CardGroup>

## 次のステップ

<CardGroup cols={2}>
  <Card title="インデクシングガイド" icon="layer-group" href="/ja/rpc/how-to-index-solana-data">
    getTransactionsForAddress を使用してSolanaインデックスのバックフィルと同期を行います。
  </Card>

  <Card title="getTransfersByAddress" icon="arrow-right-arrow-left" href="/ja/rpc/gettransfersbyaddress">
    支払いと調整用の解析され、転送のみの履歴。
  </Card>

  <Card title="APIリファレンス" icon="code" href="/ja/api-reference/rpc/http/gettransactionsforaddress">
    getTransactionsForAddress の完全なリクエストと応答のスキーマ。
  </Card>

  <Card title="歴史的データの概要" icon="clock-rotate-left" href="/ja/rpc/historical-data">
    すべてのSolana歴史的データメソッドを比較します。
  </Card>
</CardGroup>
