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

# Helius Sender: 超低遅延Solanaトランザクション送信

> マルチパスルーティングによる超低遅延のSolanaトランザクション送信。クレジットが消費されず、グローバルエンドポイントで高頻度取引に最適化されています。

## 概要

<Note>
  **価格更新:** Sender Maxは**0.001 SOL**の最低ティップを使用するようになりました。
  これはブロックの上部に優先ティップバッファに入ります— 最初に着地するために多めにティップを行います。コスト最適化された
  [SWQOS-only](/ja/sending-transactions/sender-swqos-only)ティアは0.000005 SOLのままです。
</Note>

Helius Senderは、遅延に敏感なトレーディングのために構築された、超低遅延トランザクション送信用の専門サービスです。Heslius、Jito、Harmonic、Rakuraiなどのすべての経路でトランザクションを同時に送信し、ブロックへの最速のルートを提供します。

Senderは**APIクレジットを消費しません** －SOLのティップでトランザクションごとに支払います。すべてのプランで利用可能で、無料プランにも含まれています。

<CardGroup cols={2}>
  <Card title="クレジットなし" icon="coins">
    APIクレジットを消費せずにすべてのプランで利用可能。SOLのティップで送信ごとに支払います。
  </Card>

  <Card title="マルチパスルーティング" icon="arrows-split-up-and-left">
    すべての経路（Helius、Jito、Harmonic、Rakuraiなど）で送信し、最速のブロックへの組み込みを提供
  </Card>

  <Card title="グローバルエンドポイント" icon="globe">
    HTTPSエンドポイントがフロントエンドの最寄りの場所に自動ルーティングし、バックエンド用の地域HTTP
  </Card>

  <Card title="50 TPS (デフォルト)" icon="gauge-high" href="https://www.helius.dev/contact">
    もっと必要ですか？ 高い制限とカスタムティップのアレンジをリクエストしてください
  </Card>
</CardGroup>

## ティアを選ぶ

Senderは2つのティアを提供します。どちらも低遅延でクレジットフリーです— 違いはトランザクションが経る経路の数と必要最小限のティップです。

| ティア                                                      | ルーティング     | 最低ティップ       | ティップバッファ | 最適                  |
| -------------------------------------------------------- | ---------- | ------------ | -------- | ------------------- |
| [Sender Max](/ja/sending-transactions/sender-max)        | すべての高速経路   | 0.001 SOL    | あり       | 競争の激しいトランザクションとバンドル |
| [SWQOS-only](/ja/sending-transactions/sender-swqos-only) | 単一のSWQOS経路 | 0.000005 SOL | なし       | コスト最適化された単一の高速経路    |

<Note>
  0.000005 SOLから0.001 SOLの間のティップは受け付けますが、
  優先ティップバッファには入りません — 少ない経路で最善の努力で送信されます。
  バッファの優先順位を得てすべてのルーティング経路を取るには、少なくとも0.001 SOLのティップを行います。
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (最速の着地)" icon="trophy" href="/ja/sending-transactions/sender-max">
    すべての経路で送信され、最も競争の激しい送信のために優先ティップバッファに入ります。トランザクションとバンドルの両方を処理します。
  </Card>

  <Card title="SWQOS-only (コスト最適化)" icon="dollar-sign" href="/ja/sending-transactions/sender-swqos-only">
    最低ティップ、単一の高速経路。任意のエンドポイントURLに`?swqos_only=true`を追加します。
  </Card>
</CardGroup>

## クイックスタートガイド

最初の超低遅延Solanaトランザクションを送信する準備はできましたか？このガイドで数分で開始できます。良い点は、**特別なアクセスや有料プランが必要ないこと**— Senderはすべてのユーザーが利用可能で、APIクレジットを消費しません。

以下の例では、[Sender Max](/ja/sending-transactions/sender-max)ティア（0.001 SOLティップ）を使用します。最低ティップオプションについては、[SWQOS-only](/ja/sending-transactions/sender-swqos-only)を参照してください。

<Steps titleSize="h3">
  <Step title="無料のHeliusアカウントを作成">
    [Heliusダッシュボード](https://dashboard.helius.dev/dashboard)で無料のアカウントを作成することから始めます。Senderはすべてのプランで利用可能で、無料ティアにも含まれ、APIクレジットを消費しません。
  </Step>

  <Step title="APIキーを取得">
    [APIキー](https://dashboard.helius.dev/api-keys)セクションに移動してキーをコピーします。これを使用してブロックハッシュとトランザクション確認を取得します。Senderはトランザクション送信を処理します。
  </Step>

  <Step title="最初のトランザクションを送信">
    Senderを使用して簡単なSOL転送を送信します。この例には、必要なティップと優先料金が含まれており、遅延を減らすためにプレフライトをスキップしています（任意）。

    <Tabs>
      <Tab title="@solana/web3.js">
        ```typescript [expandable] theme={"system"}
        import { 
          Connection, 
          TransactionMessage,
          VersionedTransaction,
          SystemProgram, 
          PublicKey,
          Keypair,
          LAMPORTS_PER_SOL,
          ComputeBudgetProgram
        } from '@solana/web3.js';
        import bs58 from 'bs58';

        const TIP_ACCOUNTS = [
          "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
          "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
          "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta"
          // ... more tip accounts available
        ];

        async function sendWithSender(
          keypair: Keypair,
          recipientAddress: string
        ): Promise<string> {
          const connection = new Connection(
            'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'
          );

          const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');

          // Build transaction with tip transfer and transfer to recipient
          const transaction = new VersionedTransaction(
            new TransactionMessage({
              instructions: [
                ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
                ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
                SystemProgram.transfer({
                  fromPubkey: keypair.publicKey,
                  toPubkey: new PublicKey(recipientAddress),
                  lamports: 1 * LAMPORTS_PER_SOL,
                }),
                SystemProgram.transfer({
                  fromPubkey: keypair.publicKey,
                  toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
                  lamports: 0.001 * LAMPORTS_PER_SOL,
                })
              ],
              payerKey: keypair.publicKey,
              recentBlockhash: blockhash,
            }).compileToV0Message()
          );

          transaction.sign([keypair]);
          console.log('Sending transaction via Sender endpoint...');

          const response = await fetch('https://sender.helius-rpc.com/fast', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
              jsonrpc: '2.0',
              id: Date.now().toString(),
              method: 'sendTransaction',
              params: [
                Buffer.from(transaction.serialize()).toString('base64'),
                {
                  encoding: 'base64',
                  skipPreflight: true, // Optional: skip for lower latency
                  maxRetries: 0
                }
              ]
            })
          });

          const json = await response.json();
          if (json.error) {
            throw new Error(json.error.message);
          }

          console.log('Transaction sent:', json.result);
          return json.result;
        }

        // Usage
        const keypair = Keypair.fromSecretKey(bs58.decode('YOUR_PRIVATE_KEY'));
        sendWithSender(keypair, 'RECIPIENT_ADDRESS');
        ```
      </Tab>

      <Tab title="@solana/kit">
        ```typescript [expandable] theme={"system"}
        import { pipe } from "@solana/kit";
        import {
          createSolanaRpc,
          createTransactionMessage,
          setTransactionMessageFeePayerSigner,
          setTransactionMessageLifetimeUsingBlockhash,
          appendTransactionMessageInstruction,
          signTransactionMessageWithSigners,
          lamports,
          getBase64EncodedWireTransaction,
          createKeyPairSignerFromBytes,
          address,
        } from "@solana/kit";
        import { getTransferSolInstruction } from "@solana-program/system";
        import {
          getSetComputeUnitLimitInstruction,
          getSetComputeUnitPriceInstruction,
        } from "@solana-program/compute-budget";
        import bs58 from 'bs58';

        const TIP_ACCOUNTS = [
          "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
          "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
          "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta"
          // ... more tip accounts available
        ];

        async function sendWithSender(
          privateKeyB58: string,
          recipientAddress: string
        ): Promise<string> {
          // Load signer from base58 private key
          const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));

          // Init RPC and fetch blockhash
          const rpc = createSolanaRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');
          const { value: blockhash } = await rpc.getLatestBlockhash().send();

          // Build + sign transaction
          const tx = pipe(
            createTransactionMessage({ version: 0 }),
            (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
            (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
            (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
            (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
            (m) =>
              appendTransactionMessageInstruction(
                getTransferSolInstruction({
                  source: ownerSigner,
                  destination: address(recipientAddress),
                  amount: lamports(1_000_000_000n), // 1 SOL
                }),
                m
              ),
            (m) =>
              appendTransactionMessageInstruction(
                getTransferSolInstruction({
                  source: ownerSigner,
                  destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
                  amount: lamports(1_000_000n), // 0.001 SOL
                }),
                m
              )
          );

          const signedTx = await signTransactionMessageWithSigners(tx);
          const base64Tx = getBase64EncodedWireTransaction(signedTx);

          console.log('Sending transaction via Sender endpoint...');

          // Send via Sender
          const res = await fetch("https://sender.helius-rpc.com/fast", {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
              jsonrpc: "2.0",
              id: Date.now().toString(),
              method: "sendTransaction",
              params: [
                base64Tx,
                { encoding: "base64", skipPreflight: true, maxRetries: 0 },
              ],
            }),
          });

          const { result: sig, error } = await res.json();
          if (error) throw new Error(error.message);

          console.log("Transaction sent: ", sig);
          return sig;
        }

        // Usage
        sendWithSender('YOUR_PRIVATE_KEY', 'RECIPIENT_ADDRESS');
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="成功！何が起こったかを理解する">
    Senderを介してトランザクションの送信に成功しました！成功の要因は以下の通りです：

    * クレジット未消費：Senderはすべてのユーザーでクレジットフリーです
    * マルチパスルーティング：トランザクションはすべての経路（Helius、Jito、Harmonic、Rakuraiなど）で同時に送信されました
    * 必要なティップ：0.001 SOLのティップで優先ティップバッファに入り、すべてのルーティング経路を利用します。低ティップのSWQOS-onlyオプションについては、[ティア](#choose-your-tier)を参照してください
    * 優先料金：優先処理のためにバリデータに支払う意欲を示します
    * プレフライトスキップ（任意）：速度のために検証をトレード — Senderはプレフライトチェックもサポート
  </Step>
</Steps>

## 要件

<Warning>
  **必須要件**: すべてのSenderトランザクションにはティップが必要です
  （[Sender Max](/ja/sending-transactions/sender-max)での最低0.001 SOL、または
  [SWQOS-only](/ja/sending-transactions/sender-swqos-only)での0.000005 SOL）と優先料金です。
</Warning>

<Note>
  `skipPreflight`はオプションです — Senderはプレフライトチェックをサポートしています。
  低遅延のために`skipPreflight: true`を設定します。
</Note>

### ティップと優先料金

Senderを通じて送信されたすべてのトランザクションには、**両方のティップと優先料金**が含まれている必要があります：

* **ティップ**: 指定されたティップアカウントへのSOL転送。Sender Maxには最低0.001 SOL、SWQOS-onlyには0.000005 SOL。
* **優先料金**: バリデータキュー内でのトランザクションの優先度を高めるための`ComputeBudgetProgram.setComputeUnitPrice`によるコンピュートユニット料金

<Accordion title="指定されたティップアカウント（mainnet-beta）">
  ```text theme={"system"}
  4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
  D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
  9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
  5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
  2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
  2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
  wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
  3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
  4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
  4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or
  ```
</Accordion>

#### なぜ両方が必要なのか

* **ティップ**: Senderのすべてのルーティング経路（Helius、Jito、Harmonic、Rakuraiなど）と優先ティップバッファへのアクセスを提供します
* **優先料金**: Solanaのネイティブな優先システムを通じて優先処理を支払う意欲をバリデータに示します
* **両者の組み合わせ**: ティップはトランザクションが利用できる経路を最大化し、優先料金はバリデータに対する優先度を高めます — 共に組み込まれる確率を最大化します

リアルタイムの優先料金の推奨を得るために[Helius Priority Fee API](/ja/priority-fee-api)を使用します。

## エンドポイント

Senderエンドポイントはユースケースに応じた複数の構成で利用可能です：

<Tabs>
  <Tab title="フロントエンド/ブラウザアプリケーション">
    **CORS問題を回避するためにフロントエンドアプリケーションに推奨：**

    ```
    https://sender.helius-rpc.com/fast   # Global HTTPS endpoint
    ```

    <Note>
      ブラウザベースのアプリケーションで地域HTTPエンドポイントを使用する際に発生するCORSのプレフライト失敗を解決します。
      このエンドポイントは最適なパフォーマンスのために最寄りの場所に自動的にルーティングされます。
      フロントエンド/ブラウザ用にこのエンドポイントを使用してください。
    </Note>
  </Tab>

  <Tab title="バックエンド/サーバーアプリケーション">
    **サーバー間レイテンシーを最適化するための地域HTTPエンドポイント：**

    ```
    http://slc-sender.helius-rpc.com/fast   # Salt Lake City
    http://ewr-sender.helius-rpc.com/fast   # Newark
    http://lon-sender.helius-rpc.com/fast   # London
    http://fra-sender.helius-rpc.com/fast   # Frankfurt
    http://ams-sender.helius-rpc.com/fast   # Amsterdam
    http://sg-sender.helius-rpc.com/fast    # Singapore
    http://tyo-sender.helius-rpc.com/fast   # Tokyo
    ```

    <Note>
      バックエンド/サーバーアプリケーションの場合、インフラストラクチャに最も近い地域HTTPエンドポイントを選択して最適なパフォーマンスを得ます。
    </Note>
  </Tab>

  <Tab title="コネクションウォーミング">
    **HTTPS（フロントエンド）：**

    ```
    https://sender.helius-rpc.com/ping   # Global HTTPS ping (auto-routes to nearest location)
    ```

    **HTTP（バックエンド）：**

    ```
    http://slc-sender.helius-rpc.com/ping   # Salt Lake City
    http://ewr-sender.helius-rpc.com/ping   # Newark
    http://lon-sender.helius-rpc.com/ping   # London
    http://fra-sender.helius-rpc.com/ping   # Frankfurt
    http://ams-sender.helius-rpc.com/ping   # Amsterdam
    http://sg-sender.helius-rpc.com/ping    # Singapore
    http://tyo-sender.helius-rpc.com/ping   # Tokyo
    ```
  </Tab>
</Tabs>

## コネクションウォーミング

トランザクション送信の間隔が長いアプリケーションの場合、pingエンドポイントを使用してウォーム接続を維持し、コールドスタート遅延を低減します。

pingエンドポイントは簡単なGETリクエストを受け入れ、接続を維持するための基本的な応答を返します：

```bash theme={"system"}
# Frontend applications - use HTTPS (auto-routes to nearest location)
curl https://sender.helius-rpc.com/ping

# Backend applications - use regional HTTP
curl http://slc-sender.helius-rpc.com/ping
```

```typescript theme={"system"}
// Keep connection warm during idle periods
async function warmConnection(endpoint: string) {
  try {
    const response = await fetch(`${endpoint}/ping`);
    console.log("Connection warmed:", response.ok);
  } catch (error) {
    console.warn("Failed to warm connection:", error);
  }
}

// Frontend applications - use HTTPS endpoint
setInterval(() => {
  warmConnection("https://sender.helius-rpc.com");
}, 5000);

// Backend/server applications - use regional HTTP endpoint
setInterval(() => {
  warmConnection("http://slc-sender.helius-rpc.com");
}, 5000);
```

<Note>
  トランザクション間の間隔が5秒以上ある場合、コネクションウォーミングを使用して最適な送信レイテンシーを維持します。
</Note>

## リクエスト形式

Senderは同じエンドポイントで2つのメソッドを受け付けます。すべての送信にはティップと優先料金が含まれている必要があります；プレフライトをスキップすると遅延が低減されます（任意）。

### sendTransaction

単一のトランザクションを送信します。指定されたティップアカウントへの最低ティップを含むSOL転送とコンピュートユニット価格指示が必要です — どちらもない場合は拒否されます。

```typescript theme={"system"}
{
  "id": "unique-request-id",
  "jsonrpc": "2.0",
  "method": "sendTransaction",
  "params": [
    "BASE64_ENCODED_TRANSACTION", // Must include both tip and priority fee instructions
    {
      "encoding": "base64",
      "skipPreflight": true,       // Optional: skip for lower latency
      "maxRetries": 0
    }
  ]
}
```

完全な実行可能な`sendTransaction`例については、[クイックスタート](#quickstart-guide)を参照してください。

### sendBundle

最大4つの完全に署名されたトランザクションを原子的かつオールオアナッシングで実行するために送信します。少なくとも1つのトランザクションにはティップが必要です。

```typescript theme={"system"}
{
  "id": "unique-request-id",
  "jsonrpc": "2.0",
  "method": "sendBundle",
  "params": [
    ["BASE64_SIGNED_TX_1", "BASE64_SIGNED_TX_2"], // Up to 4; at least one carries the tip
    { "encoding": "base64" }
  ]
}
```

完全な例と着地の追跡方法については、[Sender Max バンドル](/ja/sending-transactions/sender-max#bundles)を参照してください。

### MEV Protect（オプション）

サンドイッチ攻撃に統計的にリンクされたバリデータを回避するために、`mev-protect=true`クエリパラメータをエンドポイントURLに追加します。これはSenderの両方のティアで機能し、`sendTransaction`と`sendBundle`の両方で、リクエストボディに変更を加えずに機能します。

```
https://sender.helius-rpc.com/fast?mev-protect=true                    # Sender Max
https://sender.helius-rpc.com/fast?swqos_only=true&mev-protect=true     # SWQOS-only
```

その仕組みとトレードオフについては、[MEV Protect](/ja/sending-transactions/mev-protect)を参照してください。

<Card title="APIリファレンス" icon="code" href="/ja/api-reference/sender/sendtransaction">
  リクエスト/レスポンススキーマとパラメータを含むSender APIリファレンスを表示します。
</Card>

## レート制限とスケーリング

* **デフォルトレート制限**: 1秒あたり50トランザクション
* **クレジット未使用**: SenderトランザクションはプランのAPIクレジットを消費しません
* **高い制限**: プロフェッショナルプランのユーザーは、高スループットの取引アプリケーションをサポートするための大幅なレート制限の増加をリクエストできます

### APIキー認証を使用したカスタムTPS

<Note>
  このセクションは、TPS制限の増加が承認され、HeliusチームからAPIキーを受け取った場合にのみ関連があります。標準ユーザーはこのセクションをスキップできます。
</Note>

TPS制限の増加が承認された場合、Sender用の専用APIキーを受け取ります。これを使用するには、APIキーをクエリパラメータとしてエンドポイントURLに追加します：

<Tabs>
  <Tab title="フロントエンド/ブラウザアプリケーション">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="バックエンド/サーバーアプリケーション">
    ```
    http://slc-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ewr-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://lon-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://fra-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ams-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://sg-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://tyo-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>
</Tabs>

<Tip>
  50 TPS以上またはカスタムプランが必要ですか？ [高い制限をリクエスト](https://www.helius.dev/contact)して、Senderのカスタムティップアレンジメントを探るには、営業チームに連絡してください。
</Tip>

## サポート

サポートは[Heliusダッシュボード](https://dashboard.helius.dev)を通じて、または[Discord](https://discord.com/invite/6GXdee3gBj)に参加して提供されます。

## 参照: シュレッドデリバリー

[Raw Shreds (UDP)](/ja/shred-delivery/raw-shreds)は、Solanaの生のトランザクションデータへの超低遅延アクセスを提供するために構築された、生のSolanaシュレッドの専門的な配信です。

ネットワークから直接未処理のシュレッドを提供することで、Shred DeliveryはpropAMMs、スナイパー、コピー取引者、清算ボット、裁定取引、およびネットワーク同期の遅延を取り除きたいRPCノードオペレーターに競争優位性を提供します。

<Tip>
  生のシュレッドの受信を開始します。[Helius Shred Delivery](https://dashboard.helius.dev/shred-delivery-seats)にダッシュボードで購読します。
</Tip>
