> For the complete documentation index, see [llms.txt](https://docs.blockrazor.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.blockrazor.io/tc/transaction-submission/transaction-sending/solana/send-bundle/js.md).

# Solana Send Bundle JS Example

瞭解 BlockRazor Solana Transaction Sending 模式下 Send Bundle 的 JS 請求示例

### 請求示例

{% tabs %}
{% tab title="HTTP" %}
{% code overflow="wrap" %}

```javascript
const axios = require('axios');
const web3 = require('@solana/web3.js');
const bs58 = require('bs58');
const { getHttpTipAccount } = require('./get_tip_accounts');

// ------------------ Configuration Constants ------------------
// Example endpoints only. Always use the current endpoints published on the BlockRazor website.
const httpEndpoint = "http://frankfurt.solana.blockrazor.xyz:443/sendBundle";
const healthEndpoint = "http://frankfurt.solana.blockrazor.xyz:443/health";
const tipAccountsEndpoint = "http://frankfurt.solana.blockrazor.xyz:443/getTipAccounts";
// Replace with your Solana RPC endpoint
const mainNetRPC = "";
// Replace with your authKey
const authKey = "";
// Replace with your private key (base58)
const privateKey = "";
// Replace with your target public key
const publicKey = "";
// Transaction amount
const amount = 200_000;
// Tip amount
const tipAmount = 100_000;
// Leave empty to preserve the original bundle behavior. Set to "sandwichMitigation" to opt in.
const mode = "";

// ------------------ Axios HTTP Client (Connection Reuse Enabled) ------------------
const httpClient = axios.create({
		timeout: 10000,
		headers: {
				'Content-Type': 'application/json',
				'apikey': authKey,
		},
		httpAgent: new (require('http').Agent)({ keepAlive: true }),
		httpsAgent: new (require('https').Agent)({ keepAlive: true }),
});

// ------------------ Periodic Health Ping to Keep Connection Alive ------------------
async function pingHealth() {
		try {
        const res = await httpClient.post(healthEndpoint, {});
				console.log(`Health result:`, res.data);
		} catch (err) {
				console.error('Health check failed:', err.message);
		}
}

// ------------------ Build and Send Bundle ------------------
async function sendBundle() {
		const senderPrivateKey = new Uint8Array(bs58.decode(privateKey));
		const senderKeypair = web3.Keypair.fromSecretKey(senderPrivateKey);
		const receiver = new web3.PublicKey(publicKey);
    const tipAccount = new web3.PublicKey(await getHttpTipAccount(tipAccountsEndpoint));

		const connection = new web3.Connection(mainNetRPC);
		const { blockhash } = await connection.getLatestBlockhash('finalized');

		const tx = new web3.Transaction()
				.add(web3.SystemProgram.transfer({
						fromPubkey: senderKeypair.publicKey,
						toPubkey: tipAccount,
						lamports: tipAmount,
				}))
				.add(web3.SystemProgram.transfer({
						fromPubkey: senderKeypair.publicKey,
						toPubkey: receiver,
						lamports: amount,
				}));

		tx.recentBlockhash = blockhash;
		tx.feePayer = senderKeypair.publicKey;
		tx.sign(senderKeypair);

		const serialized = tx.serialize();
		const base64Tx = serialized.toString('base64');

		const payload = {
				transactions: [base64Tx],
		};
		if (mode) {
				payload.mode = mode;
		}

		try {
				const res = await httpClient.post(httpEndpoint, payload);
				console.log('[send bundle] response:', res.data);
		} catch (err) {
				console.error('sendBundle failed:', err.response?.data || err.message);
		}
}

// ------------------ Main Entry ------------------
(async () => {
		// Initial health check (establish connection)
		await pingHealth();

		// Periodically send /health to keep connection alive
		setInterval(pingHealth, 30 * 1000);
		sendBundle().catch(console.error);
})();
```

{% endcode %}
{% endtab %}

{% tab title="gRPC" %}
{% code overflow="wrap" %}

```javascript
const web3 = require("@solana/web3.js");
const bs58 = require("bs58");
const { getGrpcTipAccount } = require('./get_tip_accounts');

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const PROTO_PATH = __dirname + '/server.proto';
const packageDefinition = protoLoader.loadSync(
		PROTO_PATH,
		{
				keepCase: true,
				longs: String,
				enums: String,
				defaults: true,
				oneofs: true
		}
);

const serverProto = grpc.loadPackageDefinition(packageDefinition).serverpb;

// This example endpoint may change. Always use the current endpoint published on the BlockRazor website.
const blzRelayEndpoint = "frankfurt.solana-grpc.blockrazor.xyz:80";
// replace your solana rpc endpoint
const mainNetRPC = "";
// replace your authKey
const authKey = "";
// relace your private key(base58)
const privateKey = "";

// tip amount
const tipAmount = 100_000;
// Leave empty to preserve the original bundle behavior. Set to "sandwichMitigation" to opt in.
const mode = "";

const client = new serverProto.Server(
		blzRelayEndpoint,
		grpc.credentials.createInsecure()
);

var meta = new grpc.Metadata();

// ------------------ Periodic Health Ping to Keep Connection Alive ------------------
async function pingHealth() {
		client.getHealth({}, meta, (err, response) => {
				if (err) {
						console.error('[get health] error:', err);
						return;
				}

				console.log('[get health] response:', response);
		});
}

(async () => {
		meta.add('apikey', authKey);

		// Initial health check (establish connection)
		await pingHealth();

		// Periodically send /health to keep connection alive
		setInterval(pingHealth, 30 * 1000);

		const senderPrivateKey = new Uint8Array(bs58.decode(privateKey));
		const senderKeypair = web3.Keypair.fromSecretKey(senderPrivateKey);

		const tipAccount = await getGrpcTipAccount(client);
		const recipientPublicKey = new web3.PublicKey(tipAccount);

		const transaction = new web3.Transaction().add(
				web3.SystemProgram.transfer({
						fromPubkey: senderKeypair.publicKey,
						toPubkey: recipientPublicKey,
						lamports: tipAmount,
				})
		);

		const connection = new web3.Connection(mainNetRPC);

		transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
		transaction.feePayer = senderKeypair.publicKey;
		transaction.sign(senderKeypair);

		const serializedTransaction = transaction.serialize();
		const base64Tx = serializedTransaction.toString('base64');

		const request = { transactions: [base64Tx] };
		if (mode) {
				request.mode = mode;
		}

		client.SendBundle(request, meta, (err, response) => {
				if (err) {
						console.error('[send bundle] error:', err);
						return;
				}

				console.log('[send bundle] response:', response);
		});
})();
```

{% endcode %}
{% endtab %}
{% endtabs %}

### 返回示例

正常

```json
{"signature":"$first_tx_signature","error":""}
```

異常

{% code overflow="wrap" %}

```json
{"signature":"","error":"error: Invalid authentication credentials. Please ensure your auth token is correct and try again"}
```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.blockrazor.io/tc/transaction-submission/transaction-sending/solana/send-bundle/js.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
