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

# Sender Max：最快的 Solana 交易着陆

> 通过 Helius Sender 的最快着陆层发送 Solana 交易和包。每次提交都可访问所有路径（Helius、Jito、Harmonic、Rakurai 等），最低消费 0.001 SOL 小费。

## 概述

<Note>
  **价格更新：** Sender Max 现在使用 **0.001 SOL** 的最低小费。这
  会将您置于优先小费缓冲区中以便于块顶级着陆 — 多给小费可优先着陆。
</Note>

Sender Max 是最高性能的 [Helius Sender](/zh/sending-transactions/sender) 层，专为需要领先于竞争对手提交而构建。它将您的提交通过所有可用的高速路径路由，并将其放入优先小费缓冲区，优先考虑最高的小费。

Sender Max 处理**单个交易和包**。两者均使用所有路径（Helius、Jito、Harmonic、Rakurai 等）— 唯一的区别是有效载荷：提交一个交易使用 `sendTransaction`，或提交最多四个使用 `sendBundle`。

此层要求最低小费为 **0.001 SOL**。要在单路径上进行成本优化发送，请使用 [SWQOS-only](/zh/sending-transactions/sender-swqos-only) 层。

<CardGroup cols={2}>
  <Card title="最快着陆" icon="trophy">
    通过所有高速路径路由，以最高概率着陆
  </Card>

  <Card title="优先小费缓冲区" icon="arrow-up-wide-short">
    您的提交进入一个优先小费缓冲区，优先处理高小费提交 — 多给小费优先着陆
  </Card>

  <Card title="无积分" icon="coins">
    所有计划中可用，无需消耗 API 积分
  </Card>

  <Card title="0.001 SOL 最低小费" icon="dollar-sign">
    进入优先小费缓冲区并使用所有路由路径所需的最低小费
  </Card>
</CardGroup>

## 工作原理

当您至少给予 **0.001 SOL** 小费时，无论是单个交易还是包，您的提交将通过所有可用的高速路径路由并进入优先小费缓冲区。缓冲区优先处理最高小费，因此超出最低限额的小费提高您的优先着陆机会。

<Note>
  不到 0.001 SOL 的小费不会进入优先小费缓冲区——它们通过更少的路径以尽力方式发送。为了在较低小费下实现可预测的低延迟发送，请使用 [SWQOS-only](/zh/sending-transactions/sender-swqos-only) 层（0.000005 SOL）。
</Note>

## 何时使用 Max

<CardGroup cols={2}>
  <Card title="适合使用" icon="circle-check">
    高度竞争的账户、竞争激烈的代币发布、清算，以及任何先到达值得更高小费的交易。
  </Card>

  <Card title="考虑改用 SWQOS-only" icon="dollar-sign" href="/zh/sending-transactions/sender-swqos-only">
    对成本敏感或高流量的情况，在单路径可靠到达时使用。
  </Card>
</CardGroup>

## 要求

每个 Sender Max 提交必须包含：

* **小费**：至少 **0.001 SOL** 的 SOL 转账到指定的 [小费账户](/zh/sending-transactions/sender#requirements)。在一个捆绑中，至少有一个交易必须包含小费。
* **优先费用**：一条至少包含 **5,000 lamports** 的优先费用的计算单元价格指令。参见 [优先费用](#priority-fees)。

跳过飞行前检查（`skipPreflight: true`）是可选的但建议这样做——飞行前检查会增加延迟。

<Warning>
  缺少小费或优先费用的交易将被拒绝。有关捆绑的具体规则，请参见 [Bundles](#bundles)。
</Warning>

## 优先费用

每个交易必须包含至少 **5,000 lamports** 的优先费用，我们建议至少 **10,000 lamports** 以提高到达的可靠性。小费使您的交易进入优先小费缓冲区，而优先费用则提高其在验证器调度中的优先级——两者结合最大化您的到达机会。

通过计算单元价格指令设置优先费用。您的总优先费用是计算单元价格（微 lamports）乘以您的计算单元限制：

```typescript theme={"system"}
import { ComputeBudgetProgram } from "@solana/web3.js";

ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 });
```

使用 [Helius Priority Fee API](/zh/priority-fee-api) 根据当前网络状况获取实时费用建议。

## 端点

前端使用全球HTTPS端点，后端使用最接近服务器的区域HTTP端点。

**前端 / 浏览器（全球HTTPS）：**

```
https://sender.helius-rpc.com/fast
```

**后端 / 服务器（区域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
```

有关连接预热和详细信息，请参阅[发送端点参考](/zh/sending-transactions/sender#endpoints)。

<Tip>
  想要避免与三明治攻击相关的验证器吗？将
  [`mev-protect=true`](/zh/sending-transactions/mev-protect) 添加到端点URL —
  它适用于 `sendTransaction` 和 `sendBundle`:
  `https://sender.helius-rpc.com/fast?mev-protect=true`。
</Tip>

## 代码示例

<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 PRIV_B58 = 'Your Private Key';
    const RECIPIENT = 'Recipient Address';
    const HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendWithSenderMax(
      keypair: Keypair,
      recipientAddress: string
    ): Promise<string> {
      const connection = new Connection(
        `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
      );

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

      // Build transaction: priority fee + recipient transfer + 0.001 SOL tip
      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: 0.001 * 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, // Minimum tip to enter the priority tip buffer
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );

      transaction.sign([keypair]);

      // Frontend: use the global HTTPS endpoint to avoid CORS issues
      const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast';
      // Backend: use the regional HTTP endpoint closest to your servers
      // const SENDER_ENDPOINT = 'http://slc-sender.helius-rpc.com/fast';

      const response = await fetch(SENDER_ENDPOINT, {
        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
    sendWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendTransaction",
        "params": [
          "BASE64_ENCODED_TRANSACTION",
          {
            "encoding": "base64",
            "skipPreflight": true,
            "maxRetries": 0
          }
        ]
      }'
    ```
  </Tab>
</Tabs>

<Tip>
  对于竞争性交易，0.001 SOL 的最低值可能不会有竞争力。建议根据您希望交易达成的价值来定价您的小费 — 成功达成的价值越高，您应给予的小费越高。最低值是底线，而不是目标。
</Tip>

## 批处理

批处理只是 Sender Max 接受的另一种负载。提交最多 4 个完全签名的交易，它们按顺序原子性执行（全有或全无），作为单笔交易进入 **相同优先级小费缓冲区** — 缓冲区优先考虑最高小费的批处理以实现最快速达成。

<Warning>
  **只提供 0.001 SOL 的 Sender 小费。** Sender Max 为您的批处理路由所有高速路径，并代表您添加任何路径小费 — 您不需添加单独的 Jito 小费、使用 Jito 小费账户或设置 `jito-region`
  标头。这些仅适用于 [基本
  批处理](/zh/sending-transactions/send-bundle)。
</Warning>

### 要求

* **最多 4 个交易**，完全签名。它们按顺序原子性执行 — 如果任何一个失败，整个批处理被拒绝。
* **小费**：至少一个交易必须至少转账 **0.001 SOL** 到指定的 [Sender 小费账户](/zh/sending-transactions/sender#requirements)。这与单笔交易使用的 Sender 小费相同 — Helius 为您添加任何路径小费（包括 Jito），您不用单独添加 Jito 小费。
* **优先费用**：每个交易必须包含至少 **5,000 lamports** 的 [优先费用](#priority-fees)。

### 提交

使用 `method: "sendBundle"` 发送到发送端点。前端使用全局 HTTPS 端点，后端使用任何[区域端点](#endpoints)——支持所有发送区域。

<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 PRIV_B58 = 'Your Private Key';
    const HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendBundleWithSenderMax(keypair: Keypair): Promise<string[]> {
      const connection = new Connection(
        `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
      );

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

      const tipAccount = new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]);

      // Transaction 1: your instructions + priority fee + the 0.001 SOL Sender tip
      const tx1 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
            SystemProgram.transfer({
              fromPubkey: keypair.publicKey,
              toPubkey: tipAccount,
              lamports: 0.001 * LAMPORTS_PER_SOL, // Sender tip — only one tx in the bundle needs it
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx1.sign([keypair]);

      // Transaction 2: more instructions — executes after tx1, atomically
      const tx2 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx2.sign([keypair]);

      // Serialize each fully-signed transaction (up to 4) to base64
      const bundle = [tx1, tx2].map((tx) => Buffer.from(tx.serialize()).toString('base64'));

      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: 'sendBundle',
          params: [bundle, { encoding: 'base64' }]
        })
      });

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

      // Track landing by each transaction's signature (see below)
      const signatures = [tx1, tx2].map((tx) => bs58.encode(tx.signatures[0]));
      console.log('Bundle submitted:', signatures);
      return signatures;
    }

    // Usage
    sendBundleWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)));
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendBundle",
        "params": [
          [
            "BASE64_SIGNED_TX_1",
            "BASE64_SIGNED_TX_2"
          ],
          { "encoding": "base64" }
        ]
      }'
    ```
  </Tab>
</Tabs>

### 跟踪着陆

跟踪捆绑包的方式与跟踪单笔交易相同——通过监控每笔交易的签名来实现。由于捆绑包是原子的，确认任何一笔交易意味着整个捆绑包已着陆。你**不**使用 `getBundleStatuses` 或捆绑包 ID。

使用适合你的堆栈的方法：

* 轮询 [`getSignatureStatuses`](/zh/api-reference/rpc/http/getsignaturestatuses) 直到签名确认。
* 订阅 [LaserStream](/zh/laserstream) 或 [LaserStream WebSocket](/zh/rpc/websocket) 并观测着陆签名。
* 使用 [Shred Delivery](/zh/shred-delivery/raw-shreds) 或其他任何公开着陆签名的 Helius 流产品。

## 最佳实践

* **端点选择**：前端应用使用 `https://sender.helius-rpc.com/fast` 以避免 CORS 问题。后端应用使用离你的服务器最近的区域 HTTP 端点。
* **动态小费**：对于竞争激烈的交易，提高小费超过 0.001 SOL 以提高在小费缓冲区中的优先级。
* **连接预热**：空闲时间超过 5 秒期间，使用 [`/ping` 端点](/zh/sending-transactions/sender#connection-warming)。
* **优先费用**：使用 [Helius Priority Fee API](/zh/priority-fee-api) 获取实时推荐。
* **重试**：设置 `maxRetries: 0` 并实现你自己的重试逻辑。

## 相关

<CardGroup cols={2}>
  <Card title="发送概览" icon="rocket" href="/zh/sending-transactions/sender">
    共享概念：端点、连接预热、速率限制和自定义 TPS。
  </Card>

  <Card title="仅限 SWQOS 的等级" icon="dollar-sign" href="/zh/sending-transactions/sender-swqos-only">
    单路径上成本优化的低延迟发送（最低小费 0.000005 SOL）。
  </Card>

  <Card title="MEV 保护" icon="shield-halved" href="/zh/sending-transactions/mev-protect">
    绕过统计上与三明治攻击相关的验证器。
  </Card>
</CardGroup>
