Отправка транзакций через Apex

// npm install @solana/web3.js
// Print a signed, tipped transaction as base64: node apex-tx.mjs
import {
  ComputeBudgetProgram, Connection, Keypair, PublicKey, SystemProgram,
  TransactionInstruction, TransactionMessage, VersionedTransaction,
} from "@solana/web3.js";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";

export const APEX_RPC = process.env.APEX_RPC ?? "http://fra.apex.orbitflare.com";
export const API_KEY = process.env.APEX_API_KEY ?? "";
const SOLANA_RPC = process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com";
const TIP_LAMPORTS = Number(process.env.TIP_LAMPORTS ?? 1_000_000);
const MEMO_PROGRAM = new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");

export const payer = Keypair.fromSecretKey(
  Uint8Array.from(JSON.parse(readFileSync(process.env.KEYPAIR_PATH ?? "payer.json", "utf8"))),
);
export const connection = new Connection(SOLANA_RPC, "confirmed");

export async function apexRpc(method, params) {
  const res = await fetch(APEX_RPC, {
    method: "POST",
    headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
  });
  const body = await res.json();
  if (body.error) throw new Error(`${method} failed ${body.error.code}: ${body.error.message}`);
  return body.result;
}

let tipAccounts;
let counter = 0;

// Returns a signed VersionedTransaction. Pass { tip: false } for a bundle member without a tip.
export async function buildTx({ tip = true, label = "apex" } = {}) {
  tipAccounts ??= await apexRpc("getTipAccounts", []);
  const tipAccount = new PublicKey(tipAccounts[Math.floor(Math.random() * tipAccounts.length)]);
  const { blockhash } = await connection.getLatestBlockhash("confirmed");
  const instructions = [
    ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 10_000 }),
    new TransactionInstruction({
      programId: MEMO_PROGRAM,
      keys: [{ pubkey: payer.publicKey, isSigner: true, isWritable: true }],
      data: Buffer.from(`${label} ${Date.now()} ${counter++}`),
    }),
  ];
  if (tip) {
    instructions.push(
      SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: tipAccount, lamports: TIP_LAMPORTS }),
    );
  }
  const message = new TransactionMessage({
    payerKey: payer.publicKey,
    recentBlockhash: blockhash,
    instructions,
  }).compileToV0Message();
  const tx = new VersionedTransaction(message);
  tx.sign([payer]);
  return tx;
}

// Poll getSignatureStatuses on the Solana RPC. Returns the slot, or null on timeout.
export async function confirm(signature, timeoutMs = 30_000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const { value } = await connection.getSignatureStatuses([signature]);
    const status = value[0];
    if (status?.err) throw new Error(`failed on chain: ${JSON.stringify(status.err)}`);
    if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
      return status.slot;
    }
    await new Promise((resolve) => setTimeout(resolve, 500));
  }
  return null;
}

if (process.argv[1] === fileURLToPath(import.meta.url)) {
  const tx = await buildTx();
  console.log(Buffer.from(tx.serialize()).toString("base64"));
}

# pip install solders requests
# Print a signed, tipped transaction as base64: python apex_tx.py
import base64
import itertools
import json
import os
import random
import time

import requests
from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
from solders.hash import Hash
from solders.instruction import AccountMeta, Instruction
from solders.keypair import Keypair
from solders.message import Message
from solders.pubkey import Pubkey
from solders.system_program import TransferParams, transfer
from solders.transaction import Transaction

APEX_RPC = os.environ.get("APEX_RPC", "http://fra.apex.orbitflare.com")
API_KEY = os.environ.get("APEX_API_KEY", "")
SOLANA_RPC = os.environ.get("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com")
TIP_LAMPORTS = int(os.environ.get("TIP_LAMPORTS", "1000000"))
MEMO_PROGRAM = Pubkey.from_string("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr")

# One session keeps the HTTP connection to the Apex endpoint open between sends.
session = requests.Session()
session.headers.update({"x-api-key": API_KEY})

with open(os.environ.get("KEYPAIR_PATH", "payer.json")) as f:
    payer = Keypair.from_bytes(bytes(json.load(f)))

_tip_accounts = None
_counter = itertools.count()


def apex_rpc(method, params):
    r = session.post(APEX_RPC, json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params}, timeout=5)
    body = r.json()
    if "error" in body:
        raise RuntimeError(f"{method} failed {body['error']['code']}: {body['error']['message']}")
    return body["result"]


def solana_rpc(method, params):
    r = requests.post(SOLANA_RPC, json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params}, timeout=10)
    return r.json()["result"]


def build_tx(tip=True, label="apex"):
    """Returns a signed Transaction. Pass tip=False for a bundle member without a tip."""
    global _tip_accounts
    if _tip_accounts is None:
        _tip_accounts = apex_rpc("getTipAccounts", [])
    tip_account = Pubkey.from_string(random.choice(_tip_accounts))
    blockhash = Hash.from_string(
        solana_rpc("getLatestBlockhash", [{"commitment": "confirmed"}])["value"]["blockhash"])
    instructions = [
        set_compute_unit_limit(100_000),
        set_compute_unit_price(10_000),
        Instruction(MEMO_PROGRAM, f"{label} {time.time_ns()} {next(_counter)}".encode(),
                    [AccountMeta(payer.pubkey(), is_signer=True, is_writable=True)]),
    ]
    if tip:
        instructions.append(
            transfer(TransferParams(from_pubkey=payer.pubkey(), to_pubkey=tip_account, lamports=TIP_LAMPORTS)))
    return Transaction([payer], Message.new_with_blockhash(instructions, payer.pubkey(), blockhash), blockhash)


def confirm(signature, timeout_s=30.0):
    """Poll getSignatureStatuses on the Solana RPC. Returns the slot, or None on timeout."""
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        status = solana_rpc("getSignatureStatuses", [[signature]])["value"][0]
        if status and status.get("err"):
            raise RuntimeError(f"failed on chain: {status['err']}")
        if status and status.get("confirmationStatus") in ("confirmed", "finalized"):
            return status["slot"]
        time.sleep(0.5)
    return None


if __name__ == "__main__":
    print(base64.b64encode(bytes(build_tx())).decode())

curl -s "$APEX_RPC" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $APEX_API_KEY" \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"sendTransaction\",\"params\":[\"$TX_BASE64\",{\"encoding\":\"base64\",\"maxRetries\":30},false]}"

import { apexRpc, buildTx, confirm } from "./apex-tx.mjs";

const tx = await buildTx({ label: "apex json-rpc" });
const signature = await apexRpc("sendTransaction", [
  Buffer.from(tx.serialize()).toString("base64"),
  { encoding: "base64", maxRetries: 30 },
  false, // mevProtect
]);
console.log("accepted:", signature);
console.log("landed in slot", await confirm(signature));

import base64

from apex_tx import apex_rpc, build_tx, confirm

tx = build_tx(label="apex json-rpc")
signature = apex_rpc("sendTransaction", [
    base64.b64encode(bytes(tx)).decode(),
    {"encoding": "base64", "maxRetries": 30},
    False,  # mevProtect
])
print("accepted:", signature)
print("landed in slot", confirm(signature))

// `tx` is a signed, tipped VersionedTransaction, built as in the Quickstart.
use apex_sender_client::rpc::RpcClient;
use apex_sender_client::{serialize_transaction, Region};

let rpc = RpcClient::new(Region::Frankfurt, &api_key);
let wire = serialize_transaction(&tx)?;
// mev_protect = false, max_retries = Some(30)
let signature = rpc.send_transaction(&wire, false, Some(30)).await?;
println!("accepted: {signature}");

curl -s "$APEX_RPC/send" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $APEX_API_KEY" \
  -d "{\"transaction\":\"$TX_BASE64\",\"mevProtect\":false,\"maxRetries\":30}"

import { APEX_RPC, API_KEY, buildTx, confirm } from "./apex-tx.mjs";

const tx = await buildTx({ label: "apex send" });
const res = await fetch(`${APEX_RPC}/send`, {
  method: "POST",
  headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
  body: JSON.stringify({ transaction: Buffer.from(tx.serialize()).toString("base64"), mevProtect: false }),
});
const body = await res.json();
if (!body.signature) throw new Error(`rejected ${res.status} ${body.error}: ${body.message}`);
console.log("accepted:", body.signature);
console.log("landed in slot", await confirm(body.signature));

import base64

from apex_tx import APEX_RPC, build_tx, confirm, session

tx = build_tx(label="apex send")
r = session.post(f"{APEX_RPC}/send",
                 json={"transaction": base64.b64encode(bytes(tx)).decode(), "mevProtect": False}, timeout=5)
body = r.json()
if "signature" not in body:
    raise RuntimeError(f"rejected {r.status_code} {body['error']}: {body['message']}")
print("accepted:", body["signature"])
print("landed in slot", confirm(body["signature"]))

echo "$TX_BASE64" | base64 --decode | curl -s "$APEX_RPC/send-bin?mev_protect=0" \
  -H "Content-Type: application/octet-stream" \
  -H "x-api-key: $APEX_API_KEY" \
  --data-binary @-

import { APEX_RPC, API_KEY, buildTx, confirm } from "./apex-tx.mjs";

const tx = await buildTx({ label: "apex send-bin" });
const res = await fetch(`${APEX_RPC}/send-bin`, {
  method: "POST",
  headers: { "Content-Type": "application/octet-stream", "x-api-key": API_KEY },
  body: tx.serialize(),
});
const body = await res.json();
if (!body.signature) throw new Error(`rejected ${res.status} ${body.error}: ${body.message}`);
console.log("accepted:", body.signature);
console.log("landed in slot", await confirm(body.signature));

from apex_tx import APEX_RPC, build_tx, confirm, session

tx = build_tx(label="apex send-bin")
r = session.post(f"{APEX_RPC}/send-bin", headers={"Content-Type": "application/octet-stream"},
                 data=bytes(tx), timeout=5)
body = r.json()
if "signature" not in body:
    raise RuntimeError(f"rejected {r.status_code} {body['error']}: {body['message']}")
print("accepted:", body["signature"])
print("landed in slot", confirm(body["signature"]))

// `tx` is a signed, tipped VersionedTransaction, built as in the Quickstart.
use apex_sender_client::rpc::RpcClient;
use apex_sender_client::{serialize_transaction, Region};

let rpc = RpcClient::new(Region::Frankfurt, &api_key);
let wire = serialize_transaction(&tx)?;
let signature = rpc.send_transaction_binary(&wire, false, None).await?;
println!("accepted: {signature}");

: > batch.bin
for i in 1 2 3; do
  node apex-tx.mjs | base64 --decode > tx.bin
  printf '%04x' $(($(wc -c < tx.bin))) | xxd -r -p >> batch.bin   # u16 big-endian length
  cat tx.bin >> batch.bin
done

curl -s "$APEX_RPC/send-batch" \
  -H "Content-Type: application/octet-stream" \
  -H "x-api-key: $APEX_API_KEY" \
  --data-binary @batch.bin

import { APEX_RPC, API_KEY, buildTx, confirm } from "./apex-tx.mjs";

const txs = [];
for (let i = 0; i < 3; i++) txs.push(await buildTx({ label: `apex batch ${i}` }));

// Each frame: u16 big-endian length, then the transaction bytes.
const frames = txs.map((tx) => {
  const wire = Buffer.from(tx.serialize());
  const length = Buffer.alloc(2);
  length.writeUInt16BE(wire.length);
  return Buffer.concat([length, wire]);
});

const res = await fetch(`${APEX_RPC}/send-batch`, {
  method: "POST",
  headers: { "Content-Type": "application/octet-stream", "x-api-key": API_KEY },
  body: Buffer.concat(frames),
});
const body = await res.json();
if (!body.results) throw new Error(`rejected ${res.status} ${body.error}: ${body.message}`);
console.log(`accepted ${body.accepted} of ${body.attempted}`);
for (const result of body.results) {
  if (result.signature) console.log(result.signature, "landed in slot", await confirm(result.signature));
  else console.log("rejected:", result.error, result.message);
}

import struct

from apex_tx import APEX_RPC, build_tx, confirm, session

txs = [bytes(build_tx(label=f"apex batch {i}")) for i in range(3)]
# Each frame: u16 big-endian length, then the transaction bytes.
payload = b"".join(struct.pack(">H", len(wire)) + wire for wire in txs)

r = session.post(f"{APEX_RPC}/send-batch", headers={"Content-Type": "application/octet-stream"},
                 data=payload, timeout=5)
body = r.json()
if "results" not in body:
    raise RuntimeError(f"rejected {r.status_code} {body['error']}: {body['message']}")
print(f"accepted {body['accepted']} of {body['attempted']}")
for result in body["results"]:
    if "signature" in result:
        print(result["signature"], "landed in slot", confirm(result["signature"]))
    else:
        print("rejected:", result["error"], result["message"])

// `txs` is a Vec of signed, tipped VersionedTransaction values.
use apex_sender_client::rpc::{BatchItem, RpcClient};
use apex_sender_client::{serialize_transaction, Region};

let rpc = RpcClient::new(Region::Frankfurt, &api_key);
let wires: Vec<Vec<u8>> = txs.iter().map(serialize_transaction).collect::<Result<_, _>>()?;
let refs: Vec<&[u8]> = wires.iter().map(Vec::as_slice).collect();

let batch = rpc.send_batch(&refs, false, None).await?;
println!("accepted {} of {}", batch.accepted, batch.attempted);
for item in &batch.results {
    match item {
        BatchItem::Accepted(signature) => println!("accepted: {signature}"),
        BatchItem::Rejected { error, message } => println!("rejected: {error}: {message}"),
    }
}