Apex 小费

curl -s http://fra.apex.orbitflare.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getTipAccounts","params":[]}'

const res = await fetch("http://fra.apex.orbitflare.com", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getTipAccounts", params: [] }),
});
const { result: tipAccounts } = await res.json();
const tipAccount = tipAccounts[Math.floor(Math.random() * tipAccounts.length)];
console.log(tipAccount);

import random
import requests

res = requests.post(
    "http://fra.apex.orbitflare.com",
    json={"jsonrpc": "2.0", "id": 1, "method": "getTipAccounts", "params": []},
    timeout=5,
)
tip_accounts = res.json()["result"]
tip_account = random.choice(tip_accounts)
print(tip_account)

use apex_sender_client::rpc::RpcClient;
use apex_sender_client::{tip, Region};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("APEX_API_KEY")?;
    let tip_accounts = RpcClient::new(Region::Frankfurt, &api_key)
        .get_tip_accounts()
        .await?;
    let tip_account = tip::pick_tip_account(&tip_accounts).ok_or("no tip accounts")?;
    println!("{tip_account}");
    Ok(())
}

import { PublicKey, SystemProgram } from "@solana/web3.js";

const tipInstruction = SystemProgram.transfer({
  fromPubkey: payer.publicKey,
  toPubkey: new PublicKey(tipAccount),
  lamports: 1_000_000, // 0.001 SOL, the standard tier floor
});

from solders.pubkey import Pubkey
from solders.system_program import TransferParams, transfer

tip_instruction = transfer(TransferParams(
    from_pubkey=payer.pubkey(),
    to_pubkey=Pubkey.from_string(tip_account),
    lamports=1_000_000,  # 0.001 SOL, the standard tier floor
))

use apex_sender_client::{tip_instruction, MIN_TIP_LAMPORTS};

let tip_ix = tip_instruction(&payer.pubkey(), &tip_account, MIN_TIP_LAMPORTS);

import { ComputeBudgetProgram } from "@solana/web3.js";

const computeBudget = [
  ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
  ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 10_000 }),
];

from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price

compute_budget = [
    set_compute_unit_limit(100_000),
    set_compute_unit_price(10_000),  # micro-lamports per compute unit
]

use solana_compute_budget_interface::ComputeBudgetInstruction;

let compute_budget = [
    ComputeBudgetInstruction::set_compute_unit_limit(100_000),
    ComputeBudgetInstruction::set_compute_unit_price(10_000), // micro-lamports per compute unit
];