> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Apex'te Transaction v1

> OrbitFlare Apex, 4096 bayta kadar Solana transaction v1 (SIMD-0385) işlemlerini sendTransaction, HTTP gönderim rotaları ve QUIC üzerinde kabul eder. Nasıl serileştirileceğini öğrenin.

## Biçime Göre Boyut Sınırları

Transaction v1, SIMD-0385 ile tanıtılan mesaj biçimidir. Gönderenler açısından ana değişiklik boyuttur: bir v1 işlemi **4096 bayta** kadar olabilirken legacy ve v0 işlemler 1232'de kalır.

| Biçim  | En büyük boyut | Kabul edildiği yer                                             |
| ------ | -------------- | -------------------------------------------------------------- |
| Legacy | 1232 bayt      | Her rota                                                       |
| v0     | 1232 bayt      | Her rota                                                       |
| **v1** | **4096 bayt**  | `sendTransaction`, `/send`, `/send-bin`, `/send-batch` ve QUIC |

Apex biçimi işlem baytlarından algılar. Ayarlanacak bir bayrak veya ayrı bir rota yoktur.

<Note>
  [Paket](/tr/apex/bundles) üyeleri, biçimleri ne olursa olsun her biri 1232 baytla sınırlıdır.
</Note>

1232 baytı aşan bir legacy veya v0 işlem ya da 4096 baytı aşan herhangi bir işlem, çok büyük olduğu gerekçesiyle reddedilir. [Hatalar ve hız sınırları](/tr/apex/errors-and-rate-limits) sayfasına bakın.

## v1'i Kanonik Kodlayıcıyla Serileştirin

Bir v1 işlemi, biçimin kanonik kodlayıcısıyla serileştirilmelidir. Rust'ta bu `wincode`'dur. Eski bincode ve serde yolu legacy ve v0 için doğru baytları üretir, ancak **v1 için yanlış baytları** üretir ve işlem hatalı biçimlendirilmiş olarak reddedilir.

Rust istemcisi doğru kodlayıcıyı `apex_sender_client::serialize_transaction` olarak sunar. Legacy ve v0 için bincode ile bayt düzeyinde aynıdır, v1 için ise doğrudur. `ApexSenderClient::send_transaction` onu dahili olarak kullanır, dolayısıyla onu yalnızca baytlara ihtiyacınız olduğunda, örneğin HTTP rotaları için, kendiniz çağırırsınız.

Diğer dillerde, SIMD-0385 serileştirmesini uygulayan bir Solana kütüphanesi sürümü kullanın. Göndermeden önce serileştirilmiş mesajınızın ilk baytının v1 sürüm öneki olduğunu kontrol edin.

## Bahşiş Kuralı Aynıdır

Bir v1 işlemi aynı [bahşişe](/tr/apex/tips) ihtiyaç duyar: yayınlanmış bir bahşiş hesabına, bir imzalayan tarafından karşılanan, katmanınızın tabanında veya üzerinde tek bir üst düzey SystemProgram transferi.

Bir fark hesaplama bütçesidir. Bir v1 mesajında hesaplama bütçesi ComputeBudget program talimatlarında değil, mesajın kendi `TransactionConfig` yapısında yer alır. `TransactionConfig` içinde belirlenmeyen her limit 0'dır ve yüklenen hesap verisi boyutu da buna dahildir. 2026-09-19 tarihli mainnet testimizde, ComputeBudget talimatlarına güvenen bir v1 işlemi bloğa girdi ve zincir üzerinde `MaxLoadedAccountsDataSizeExceeded` hatasıyla başarısız oldu.

Bu yüzden üçünü de belirleyin: hesaplama birimi limiti, yüklenen hesap verisi boyutu limiti ve öncelik için ücret. Öncelik ücreti, hesaplama birimi başına bir fiyat değil, lamport cinsinden bir toplamdır. Bu yapılandırmayla 276, 741 ve 1641 baytlık v1 işlemleri Apex üzerinden QUIC ile mainnet'te bloğa girdi. 1641 baytlık olan, 1232 baytlık legacy sınırının üzerindedir.

## Rust Örneği

Bu program, legacy bir işleme sığmayacak olan 3.000 baytlık memo tarzı bir yüke sahip bir v1 işlemi oluşturur ve onu QUIC üzerinden gönderir. [Hızlı başlangıç bağımlılıklarına](/tr/apex/quickstart#rust-bağımlılıkları) ek olarak `solana-message = "=4.4.1"` gerektirir.

```rust theme={null}
use std::str::FromStr;
use std::time::Duration;

use apex_sender_client::rpc::{RpcClient, SolanaRpc};
use apex_sender_client::{
    serialize_transaction, tip, tip_instruction, ApexSenderClient, Region, MIN_TIP_LAMPORTS,
};
use solana_instruction::{AccountMeta, Instruction};
use solana_keypair::read_keypair_file;
use solana_message::v1::{self, TransactionConfig};
use solana_message::VersionedMessage;
use solana_pubkey::Pubkey;
use solana_signer::Signer;
use solana_transaction::versioned::VersionedTransaction;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("APEX_API_KEY")?;
    let solana = SolanaRpc::new(
        std::env::var("SOLANA_RPC_URL").unwrap_or_else(|_| "https://api.mainnet-beta.solana.com".into()),
    );
    let payer = read_keypair_file(std::env::var("KEYPAIR_PATH").unwrap_or_else(|_| "payer.json".into()))?;
    let region = Region::Frankfurt;

    let client = ApexSenderClient::connect(region, &api_key).await?;
    let tip_accounts = RpcClient::new(region, &api_key).get_tip_accounts().await?;
    let tip_account = tip::pick_tip_account(&tip_accounts).ok_or("no tip accounts")?;

    // A payload far larger than a legacy transaction could carry.
    let memo = Instruction::new_with_bytes(
        Pubkey::from_str("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr")?,
        "v".repeat(3_000).as_bytes(),
        vec![AccountMeta::new(payer.pubkey(), true)],
    );
    let instructions = [
        memo,
        tip_instruction(&payer.pubkey(), &tip_account, MIN_TIP_LAMPORTS),
    ];

    // v1 sets the compute budget in the message config. Every limit left unset is 0.
    let config = TransactionConfig::empty()
        .with_compute_unit_limit(400_000)
        .with_loaded_accounts_data_size_limit(1024 * 1024)
        .with_priority_fee(4_000); // total lamports, not a price per compute unit
    let message = v1::Message::try_compile_with_config(
        &payer.pubkey(),
        &instructions,
        solana.latest_blockhash().await?,
        config,
    )?;
    let tx = VersionedTransaction::try_new(VersionedMessage::V1(message), &[&payer])?;

    let wire = serialize_transaction(&tx)?;
    println!("v1 transaction: {} bytes, prefix {:#04x}", wire.len(), wire[0]);
    assert_eq!(wire[0], v1::V1_PREFIX);

    let signature = client.send_transaction(&tx).await?;
    println!("sent: {signature}");
    println!("slot: {:?}", solana.confirm(&signature.to_string(), Duration::from_secs(30)).await?);
    Ok(())
}
```

4096 bayttan fazlasını göndermek, ağa herhangi bir şey ulaşmadan önce yerel olarak `Error::TooLarge` ile başarısız olur.

## v1'i HTTP Üzerinden Gönderme

Doğru serileştirilmiş v1 baytlarını elinizde tuttuğunuzda HTTP rotaları onları tam olarak herhangi bir işlemi aldıkları gibi alır: `sendTransaction` ve `/send` için base64, `/send-bin` ve `/send-batch` için ham baytlar.

```rust theme={null}
// `tx` is the v1 transaction from the example above.
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}");
```