> ## 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](/docs/zh/sending-transactions/sender-swqos-only)层保持在0.000005
  SOL。
</Note>

Helius Sender是一项专为超低延迟交易提交而设计的服务，适用于对延迟敏感的交易。它同时通过所有路径（Helius, 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提供两个层级。两者都是低延迟且无信用的——区别在于您的交易经过多少路径和所需的小费下限。

| 等级                                                       | 路由         | 最小小费         | 小费缓冲 | 最适用于             |
| -------------------------------------------------------- | ---------- | ------------ | ---- | ---------------- |
| [Sender Max](/docs/zh/sending-transactions/sender-max)        | 所有高速路径     | 0.001 SOL    | 是    | 需要最快着陆的高度竞争交易和包  |
| [SWQOS-only](/docs/zh/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="/docs/zh/sending-transactions/sender-max">
    在每条路径上路由并进入优先小费缓冲区以响应最具竞争力的提交。处理交易和包。
  </Card>

  <Card title="仅 SWQOS（成本优化）" icon="dollar-sign" href="/docs/zh/sending-transactions/sender-swqos-only">
    最低小费，单条快速路径。将 `?swqos_only=true` 添加到任何端点 URL。
  </Card>
</CardGroup>

## 快速入门指南

准备好提交您的第一个超低延迟 Solana 交易了吗？本指南几分钟内即可让您上手。最棒的是：**您不需要任何付费计划或特别访问权限** —— Sender 对所有用户开放并且不消耗 API 点数。

下面的示例使用 [Sender Max](/docs/zh/sending-transactions/sender-max) 等级（0.001 SOL 小费）。对于最低小费选项，请参见 [仅 SWQOS](/docs/zh/sending-transactions/sender-swqos-only)。

<Steps titleSize="h3">
  <Step title="创建您的免费 Helius 帐户">
    从 [Helius Dashboard](https://dashboard.helius.dev/dashboard) 创建您的免费帐户开始。 Sender 在所有计划中可用，包括免费等级，并且不消耗任何 API 点数。
  </Step>

  <Step title="获取您的 API 密钥">
    转到 [API Keys](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 仅选项
    * 优先费用：向验证者表示您愿意支付优先处理费用
    * 跳过预检（可选）：通过牺牲验证换取速度—Sender 还支持预检检查
  </Step>
</Steps>

## 要求

<Warning>
  **强制要求**：每个 Sender 交易必须包含小费
  （[Sender Max](/docs/zh/sending-transactions/sender-max) 最低 0.001 SOL，或
  [SWQOS-only](/docs/zh/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](/docs/zh/priority-fee-api) 获取实时优先费用建议。

## 端点

根据您的用例，发送者端点有多种配置：

<Tabs>
  <Tab title="前端/浏览器应用程序">
    **推荐用于前端应用以避免 CORS 问题：**

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

    <Note>
      此 HTTPS 端点解决了使用区域 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>

## 请求格式

发送方在相同端点上接受两种方法。每次提交必须包含提示和优先费用；跳过预检是可选的（它可以降低延迟）。

### 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` 示例。

### sendBundle

提交多达 4 个完全签名的交易，用于原子性的全有或全无执行。至少一个交易必须携带提示。

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

请参阅[发送者最大捆绑包](/docs/zh/sending-transactions/sender-max#批处理)以获取完整示例和如何跟踪着陆。

### MEV 保护（可选）

要规避与夹层攻击统计相关的验证者，请在终端 URL 中添加 `mev-protect=true` 查询参数。它可以在 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 保护](/docs/zh/sending-transactions/mev-protect) 了解其工作原理和权衡。

<Card title="API 参考" icon="code" href="/docs/zh/api-reference/sender/sendtransaction">
  查看完整的 Sender API 参考，包括请求/响应模式和参数。
</Card>

## 速率限制和扩展

* **默认速率限制**：每秒 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) 并通过联系我们的销售团队探索自定义小费安排。
</Tip>

## 支持

通过 [Helius 控制台](https://dashboard.helius.dev) 获取支持，或加入 [Discord](https://discord.com/invite/6GXdee3gBj) 寻求帮助。

## 另见：碎片传递

[Raw Shreds (UDP)](/docs/zh/shred-delivery/raw-shreds) 是我们通过 UDP 提供的 Solana 原始数据的专门交付方式，旨在为您提供超低延迟的 Solana 原始交易数据访问。

通过直接从网络传送未经处理的分片，Shred Delivery 为希望消除网络同步延迟的 propAMMs、狙击手、复制交易者、清算机器人、套利者和 RPC 节点运营商提供了竞争优势。

<Tip>
  开始接收原始分片。[订阅 Helius Shred
  Delivery](https://dashboard.helius.dev/shred-delivery-seats) 在你的仪表板上。
</Tip>