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

# RPC İstemcisi

> Yaygın Solana yöntemleri için yeniden deneme, yedek uç nokta ve tiplenmiş yardımcılar içeren JSON-RPC istemcisi.

## Kurulum

```bash theme={null}
cargo add orbitflare-sdk
```

`rpc` özelliği varsayılan olarak etkindir.

## İstemciyi oluşturma

Tüm seçeneklerin ayarlı olduğu bir istemci:

```rust theme={null}
use orbitflare_sdk::{RpcClientBuilder, RetryPolicy, Result};
use std::time::Duration;

let client = RpcClientBuilder::new()
    .url("http://ny.rpc.orbitflare.com")
    .fallback_url("http://fra.rpc.orbitflare.com")
    .fallback_url("http://ams.rpc.orbitflare.com")
    .api_key("ORBIT-XXXXXX-NNNNNN-NNNNNN")
    .commitment("confirmed")
    .retry(RetryPolicy {
        initial_delay: Duration::from_millis(100),
        max_delay: Duration::from_secs(30),
        multiplier: 2.0,
        max_attempts: 5,
    })
    .timeout(Duration::from_secs(30))
    .build()?;
```

Çoğunun makul varsayılanları vardır. Minimal kurulum:

```rust theme={null}
let client = RpcClientBuilder::new()
    .url("http://ny.rpc.orbitflare.com")
    .build()?;
```

### Builder yöntemleri

**`.url(url)`** — İsteklerin gönderileceği birincil uç nokta. Ayarlanmazsa SDK `ORBITFLARE_RPC_URL` ortam değişkenine bakar.

```rust theme={null}
.url("http://ny.rpc.orbitflare.com")
```

**`.urls(&[...])`** — Birincil ve tüm yedekleri tek çağrıda ayarlar. İlk eleman birincil, kalanlar yedeklerdir.

```rust theme={null}
.urls(&["http://ny.rpc.orbitflare.com", "http://fra.rpc.orbitflare.com", "http://ams.rpc.orbitflare.com"])
```

**`.fallback_url(url)`** — Tek bir yedek uç nokta ekler. Birden fazla eklemek için birden çok kez çağırın. Birincil başarısız olduğunda SDK yedekleri sırayla dener.

```rust theme={null}
.fallback_url("http://fra.rpc.orbitflare.com")
.fallback_url("http://ams.rpc.orbitflare.com")
```

**`.fallback_urls(&[...])`** — `fallback_url` ile aynı; dilim alır.

```rust theme={null}
.fallback_urls(&["http://fra.rpc.orbitflare.com", "http://ams.rpc.orbitflare.com"])
```

**`.api_key(key)`** — OrbitFlare lisans anahtarınız. Ayarlanmazsa SDK ortamdan `ORBITFLARE_LICENSE_KEY` okur. Anahtar istek zamanında URL’ye eklenir, uç nokta içinde saklanmaz.

```rust theme={null}
.api_key("ORBIT-XXXXXX-NNNNNN-NNNNNN")
```

**`.commitment(level)`** — Tüm tiplenmiş yardımcılar için kullanılan varsayılan taahhüt düzeyi. Seçenekler: `"processed"`, `"confirmed"`, `"finalized"`. Varsayılan: `"confirmed"`.

```rust theme={null}
.commitment("finalized")
```

**`.retry(policy)`** — Başarısız isteklerin nasıl yeniden deneneceğini denetler. `initial_delay` ilk yeniden denemeden önceki beklemedir. `multiplier` her denemede gecikmeyi ölçekler. `max_delay` geri çekilmeyi sınırlar. `max_attempts` uç nokta başına toplam yeniden denemeyi sınırlar (0 sonsuz anlamına gelir). Varsayılanlar: 100 ms başlangıç, 30 sn üst sınır, 2x çarpan, sınırsız deneme.

```rust theme={null}
use orbitflare_sdk::RetryPolicy;
use std::time::Duration;

.retry(RetryPolicy {
    initial_delay: Duration::from_millis(200),
    max_delay: Duration::from_secs(15),
    multiplier: 2.0,
    max_attempts: 5,
})
```

**`.timeout(duration)`** — Her tekil istek için HTTP zaman aşımı. Varsayılan: 30 saniye.

```rust theme={null}
.timeout(Duration::from_secs(10))
```

## Kullanılabilir RPC yöntemleri

### `get_slot()`

Geçerli slot numarasını döndürür.

```rust theme={null}
let slot: u64 = client.get_slot().await?;
```

### `get_balance(address)`

Bir hesap için lamport cinsinden bakiyeyi döndürür.

```rust theme={null}
let lamports: u64 = client.get_balance("So11111111111111111111111111111111111111112").await?;
let sol = lamports as f64 / 1_000_000_000.0;
```

### `get_account_info(address)`

Hesap yoksa tam hesap verisini veya `None` döndürür. Veri base64 kodlanmıştır.

```rust theme={null}
let account: Option<serde_json::Value> = client.get_account_info("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v").await?;
if let Some(info) = account {
    println!("owner: {}", info["owner"]);
    println!("lamports: {}", info["lamports"]);
    println!("data length: {}", info["data"][0].as_str().unwrap_or("").len());
}
```

### `get_multiple_accounts(addresses)`

Birden çok hesabı tek çağrıda getirir. Otomatik olarak 100’lük gruplara böler (Solana’nın istek başına limiti), bu yüzden istediğiniz kadar adres geçebilirsiniz.

```rust theme={null}
let accounts: Vec<Option<serde_json::Value>> = client
    .get_multiple_accounts(&["addr1", "addr2", "addr3"])
    .await?;

for (i, acct) in accounts.iter().enumerate() {
    match acct {
        Some(info) => println!("account {i}: {} lamports", info["lamports"]),
        None => println!("account {i}: not found"),
    }
}
```

### `get_latest_blockhash()`

En son blockhash’i ve geçerliliğinin sona erdiği son blok yüksekliğini döndürür.

```rust theme={null}
let (blockhash, last_valid_block_height): (String, u64) = client.get_latest_blockhash().await?;
```

### `get_transaction(signature)`

İmzasına göre onaylanmış bir işlemi getirir. Üst veriyle birlikte tam işlemi döndürür.

```rust theme={null}
let tx: serde_json::Value = client.get_transaction("5K8F2j...").await?;
println!("slot: {}", tx["slot"]);
println!("fee: {}", tx["meta"]["fee"]);
```

### `get_signatures_for_address(address, limit)`

Bir adres için en yeniden eskiye yakın işlem imzalarını döndürür.

```rust theme={null}
let sigs: Vec<serde_json::Value> = client
    .get_signatures_for_address("So111...", 10)
    .await?;

for sig in &sigs {
    println!("{} at slot {}", sig["signature"], sig["slot"]);
}
```

### `get_program_accounts(program_id)`

Bir programa ait tüm hesapları döndürür. Çok fazla veri dönebilir.

```rust theme={null}
let accounts: Vec<serde_json::Value> = client
    .get_program_accounts("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
    .await?;
```

### `get_recent_prioritization_fees(addresses)`

Hesap kümesi için son öncelik ücretlerini döndürür. İşlem birimi fiyatlandırmasını tahmin etmek için kullanışlıdır.

```rust theme={null}
let fees: Vec<serde_json::Value> = client
    .get_recent_prioritization_fees(&["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"])
    .await?;

for fee in &fees {
    println!("slot {}: {} micro-lamports", fee["slot"], fee["prioritizationFee"]);
}
```

### `send_transaction(tx_base64)`

İmzalı işlemi ağa gönderir. Base64 kodlanmış seri işlemi alır. İşlem imzasını döndürür.

```rust theme={null}
let signature: String = client.send_transaction(tx_base64).await?;
println!("sent: {signature}");
```

### `simulate_transaction(tx_base64)`

İşlemi göndermeden simüle eder. Günlükleri, tüketilen işlem birimlerini ve varsa hataları döndürür.

```rust theme={null}
let result: serde_json::Value = client.simulate_transaction(tx_base64).await?;
if let Some(err) = result["err"].as_str() {
    println!("simulation failed: {err}");
} else {
    println!("compute units: {}", result["unitsConsumed"]);
}
```

### `get_token_accounts_by_owner(owner, mint, program_id)`

Cüzdan için token hesaplarını döndürür. Belirli bir mint veya bir token programı kimliği verin. İkisi de `None` ise varsayılan SPL Token programı kullanılır.

```rust theme={null}
let tokens: Vec<serde_json::Value> = client
    .get_token_accounts_by_owner("wallet_address", None, None)
    .await?;

for token in &tokens {
    let info = &token["account"]["data"]["parsed"]["info"];
    println!("mint: {} balance: {}",
        info["mint"],
        info["tokenAmount"]["uiAmountString"],
    );
}
```

### `get_transactions_for_address(address, options)`

`getSignaturesForAddress` ve `getTransaction` çağrılarını tek istekte birleştiren OrbitFlare’a özgü yöntem. `data` dizisi ve isteğe bağlı bir sonraki sayfa için `pagination_token` içeren `GetTransactionsResult` döndürür.

Dört ayrıntı düzeyini (`signatures`, `none`, `accounts`, `full`), çift yönlü sıralamayı, zaman/slot filtrelerini, durum filtrelerini ve token hesabı dahilini destekler.

```rust theme={null}
use orbitflare_sdk::{GetTransactionsOptions, GetTransactionsFilters, RangeFilter};

let result = client.get_transactions_for_address(
    "address",
    GetTransactionsOptions::new()
        .transaction_details("full")
        .limit(100)
        .sort_order("asc")
        .filters(
            GetTransactionsFilters::new()
                .token_accounts("all")
                .status("succeeded")
                .block_time(RangeFilter {
                    gte: Some(1704067200),
                    lte: Some(1706745600),
                    ..Default::default()
                })
        ),
).await?;

for tx in &result.data {
    println!("slot {}", tx["slot"]);
}

if let Some(token) = result.pagination_token {
    // fetch next page using .pagination_token(&token)
}
```

### `request(method, params)`

Herhangi bir RPC yöntemini ada göre çağırır. SDK JSON-RPC zarfını oluşturur, yeniden deneme ve yedek uç noktayı yönetir ve `result` alanını döndürür.

```rust theme={null}
use serde_json::json;

let epoch = client.request("getEpochInfo", json!([])).await?;
let inflation = client.request("getInflationRate", json!([])).await?;
let supply = client.request("getSupply", json!([])).await?;
```

### `request_raw(body)`

Ham JSON-RPC gövde dizgesi gönderir. Diğer her şeyle aynı yeniden deneme ve yedek uç nokta davranışı.

```rust theme={null}
let result = client
    .request_raw(r#"{"jsonrpc":"2.0","id":1,"method":"getHealth","params":[]}"#)
    .await?;
```

## Tam örnek

Ağ durumunu kontrol eden, bir cüzdanın SOL bakiyesini ve token varlıklarını çeken ve son işlemlere bakan bir betik.

```rust theme={null}
use orbitflare_sdk::{RpcClientBuilder, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClientBuilder::new()
        .url("http://ny.rpc.orbitflare.com")
        .fallback_url("http://fra.rpc.orbitflare.com")
        .commitment("confirmed")
        .build()?;

    let wallet = "CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX";

    let slot = client.get_slot().await?;
    let (blockhash, _) = client.get_latest_blockhash().await?;
    println!("network slot: {slot}");
    println!("blockhash: {blockhash}");

    let balance = client.get_balance(wallet).await?;
    println!("\n{wallet}");
    println!("  SOL: {:.4}", balance as f64 / 1_000_000_000.0);

    let tokens = client.get_token_accounts_by_owner(wallet, None, None).await?;
    for token in &tokens {
        let info = &token["account"]["data"]["parsed"]["info"];
        let mint = info["mint"].as_str().unwrap_or("unknown");
        let amount = info["tokenAmount"]["uiAmountString"].as_str().unwrap_or("0");
        if amount != "0" {
            println!("  {mint}: {amount}");
        }
    }

    let sigs = client.get_signatures_for_address(wallet, 5).await?;
    println!("\nrecent transactions:");
    for sig in &sigs {
        let signature = sig["signature"].as_str().unwrap_or("?");
        let slot = sig["slot"].as_u64().unwrap_or(0);
        let err = if sig["err"].is_null() { "ok" } else { "failed" };
        println!("  {slot} {err} {}", &signature[..20]);
    }

    let fees = client
        .get_recent_prioritization_fees(&[wallet])
        .await?;
    let avg: f64 = fees.iter()
        .filter_map(|f| f["prioritizationFee"].as_f64())
        .sum::<f64>() / fees.len().max(1) as f64;
    println!("\navg priority fee: {avg:.0} micro-lamports");

    Ok(())
}
```