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

# JetStream İstemcisi

> İşlem ve hesap filtreleri ile gRPC akışları olarak sunulan OrbitFlare’ın çözümlenmiş shred’leri.

## Kurulum

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

## İstemciyi oluşturma

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

let client = JetstreamClientBuilder::new()
    .url("http://ny.jetstream.orbitflare.com")
    .fallback_url("http://fra.jetstream.orbitflare.com")
    .retry(RetryPolicy {
        initial_delay: Duration::from_millis(100),
        max_delay: Duration::from_secs(30),
        multiplier: 2.0,
        max_attempts: 0,
    })
    .timeout_secs(30)
    .keepalive_secs(60)
    .ping_interval_secs(10)
    .max_missed_pongs(3)
    .channel_capacity(4096)
    .build()?;
```

Minimal:

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

URL, ayarlanmazsa `ORBITFLARE_JETSTREAM_URL` ortam değişkenine düşer. Tüm builder yöntemleri [gRPC istemcisi](/tr/sdk/rust-grpc) ile aynıdır — aynı varsayılanlar, aynı davranış.

## YAML yapılandırması yazma

JetStream işlem ve hesap filtrelerini destekler. Slot, blok veya taahhüt yok — bunlar Yellowstone’a özgüdür.

```yaml theme={null}
# jetstream.yml
transactions:
  raydium:
    account_include:
      - "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
  pumpfun:
    account_include:
      - "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"

accounts:
  my_wallet:
    account:
      - "YOUR_WALLET_ADDRESS"
    owner:
      - "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
```

### YAML filtre referansı

**`transactions`** — adlı filtreler. `account_include`, bu adresleri içeren işlemlerle eşleşir. `account_exclude` eşleşmeleri çıkarır. `account_required` listelenen tüm adreslerin görünmesini gerektirir.

**`accounts`** — `account` ile belirli adresleri veya `owner` ile bir programa ait tüm hesapları izleyin.

`${ENV_VAR}` genişletmesini destekler.

## Olaylara abone olma ve okuma

### YAML’dan

```rust theme={null}
let mut stream = client.subscribe_yaml("jetstream.yml")?;
```

### Programatik olarak

```rust theme={null}
use std::collections::HashMap;
use orbitflare_sdk::proto::jetstream::*;

let mut filters = HashMap::new();
filters.insert("target".into(), SubscribeRequestFilterTransactions {
    account_include: vec![some_address.to_string()],
    account_exclude: vec![],
    account_required: vec![],
});

let request = SubscribeRequest {
    transactions: filters,
    accounts: HashMap::new(),
    ping: Some(SubscribeRequestPing { id: 1 }),
};

let mut stream = client.subscribe(request);
```

### Tiplenmiş builder ile

`SubscribeRequestBuilder` ve `TransactionFilter`, proto’yu elle yazmadan aynı isteği oluşturur. Her `TransactionFilter`; `account_include`, `account_exclude` ve `account_required` sunar ve string benzeri değerlerden oluşan herhangi bir yineleyiciyi (iterator) kabul eder.

```rust theme={null}
use orbitflare_sdk::jetstream::{SubscribeRequestBuilder, TransactionFilter};

let request = SubscribeRequestBuilder::new()
    .transactions(
        "pumpfun",
        TransactionFilter::new()
            .account_include(["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"])
            .account_required(["So11111111111111111111111111111111111111112"]),
    )
    .build();

let mut stream = client.subscribe(request);
```

### Akışı okuma

```rust theme={null}
use orbitflare_sdk::proto::jetstream::subscribe_update::UpdateOneof;

while let Some(update) = stream.next().await {
    let update = update?;
    match update.update_oneof {
        Some(UpdateOneof::Transaction(tx)) => {
            // tx.slot - the slot number
            // tx.transaction - transaction info with signature, account_keys,
            //   instructions, address_table_lookups
        }
        Some(UpdateOneof::Account(acct)) => {
            // acct.slot - the slot
            // acct.account - account info (pubkey, lamports, owner, data)
            // acct.is_startup - true during initial snapshot
        }
        _ => {}
    }
}
```

Kapatma, birden çok akış, yeniden bağlanma ve ping/pong, [gRPC istemcisi](/tr/sdk/rust-grpc) ile birebir aynı şekilde çalışır.

## Tam örnek

Raydium AMM takaslarını izleyen ve her işlemin imzası ile talimat sayısını yazdıran bir akış.

```rust theme={null}
use orbitflare_sdk::{JetstreamClientBuilder, Result};
use orbitflare_sdk::proto::jetstream::subscribe_update::UpdateOneof;

#[tokio::main]
async fn main() -> Result<()> {
    let client = JetstreamClientBuilder::new()
        .url("http://ny.jetstream.orbitflare.com")
        .build()?;

    let mut stream = client.subscribe_yaml("jetstream.yml")?;
    let mut count: u64 = 0;

    println!("streaming raydium txs...");

    while let Some(update) = stream.next().await {
        let update = update?;

        if let Some(UpdateOneof::Transaction(tx)) = update.update_oneof {
            count += 1;
            if let Some(info) = &tx.transaction {
                let sig = bs58::encode(&info.signature).into_string();
                let num_ix = info.instructions.len();
                let num_accounts = info.account_keys.len();

                println!(
                    "#{count} slot={} sig={}... ix={num_ix} accounts={num_accounts}",
                    tx.slot,
                    &sig[..16],
                );
            }
        }
    }

    Ok(())
}
```

Bu `jetstream.yml` ile:

```yaml theme={null}
transactions:
  raydium:
    account_include:
      - "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
```

## JetStream v2

JetStream v2 (`orbitflare_sdk::jetstream::v2`), v1 ile **aynı uç noktalar ve kimlik doğrulama** üzerinde çalışır ve tamamen eklemelidir: v1 değişmeden çalışmaya devam eder. v2’nin eklediği özellikler:

* **Çalışma zamanında yönetilen filtreler** — canlı bir akışta yeniden bağlanmadan filtre ekleyin ve kaldırın.
* **Mesaj başına sıra numaraları** — her yanıt monotonik bir `sequence` taşır, böylece düşen mesajları tespit edebilirsiniz.
* **İsteğe bağlı zenginleştirme** — işlem başına ücret ödeyeni, program kimliklerini, hesaplama birimi fiyatını, hesaplama limitini, çözümlenmiş adres tablosu adreslerini ve daha fazlasını isteyin.
* **Slot yaşam döngüsü olayları** — slot alive/complete/dead olaylarının ayrı bir sunucu akışı.

v2 istemcisi `jetstream::v2` altında bulunur. Builder, v1 ile aynıdır (aynı yöntemler, varsayılanlar, `ORBITFLARE_JETSTREAM_URL` ortam değişkeni ve yük devretme):

```rust theme={null}
use orbitflare_sdk::jetstream::v2::{JetstreamClientBuilder, TransactionFilter};

let client = JetstreamClientBuilder::new()
    .url("http://ny.jetstream.orbitflare.com")
    .fallback_url("http://fra.jetstream.orbitflare.com")
    .build()?;
```

### Tiplenmiş filtreler oluşturma

Her filtre, istemci tarafından seçilen bir kimliğe (`.with_id()` ile) sahip bir `TransactionFilter`’dır. Bu kimlik, eşleşen her işlemde ve filtre doğrulama onayında geri yansıtılır, böylece eşleşmeleri ilişkilendirebilir ve filtreyi daha sonra kaldırabilirsiniz.

```rust theme={null}
let filter = TransactionFilter::new()
    .account_include(["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"])
    .include_enrichment(true)
    .with_id("pumpfun");
```

Bir filtre `account_include`, `account_exclude` veya `account_required` alanlarından en az birini ayarlamalıdır; boş (her şeyle eşleşen) filtreler reddedilir. `include_enrichment` isteğe bağlıdır (varsayılan kapalı) ve tüm aboneliğe uygulanır: herhangi bir etkin filtre bunu etkinleştirirse, aldığınız her işlem zenginleştirilir.

### İşlemlere abone olma

```rust theme={null}
use orbitflare_sdk::proto::jetstream::v2::subscribe_transactions_response::Payload;

let mut stream = client.subscribe_transactions(vec![filter]);

while let Some(resp) = stream.next().await {
    let resp = resp?;
    match resp.payload {
        Some(Payload::Transaction(ft)) => {
            // resp.sequence - monotonic per-stream sequence number
            // ft.filter_ids - which of your filters this tx matched
            if let Some(tx) = &ft.transaction {
                // tx.slot, tx.signature, tx.account_keys, tx.instructions
                // enrichment (only when include_enrichment is set): tx.fee_payer,
                //   tx.program_ids, tx.compute_unit_price, tx.compute_limit,
                //   tx.loaded_writable_addresses, tx.loaded_readonly_addresses
                println!("seq={} slot={} cu_price={}", resp.sequence, tx.slot, tx.compute_unit_price);
            }
        }
        Some(Payload::FilterValidation(r)) => {
            // one per filter after each add/remove
            println!("filter {} accepted={} {}", r.filter_id, r.accepted, r.rejection_reason);
        }
        Some(Payload::Heartbeat(hb)) => {
            // hb.server_ts_ms - server wall-clock, ms since epoch
            let _ = hb;
        }
        Some(Payload::Pong(p)) => {
            // p.ping_id
            let _ = p;
        }
        None => {}
    }
}
```

### Canlı bir akışta filtreleri yönetme

Akıştan bir handle alın ve yeniden bağlanmadan filtre ekleyin veya kaldırın. Kaldırmalar, `.with_id()` ile atadığınız filtre kimliğine başvurur.

```rust theme={null}
let handle = stream.handle();

handle.add_filters(vec![
    TransactionFilter::new()
        .account_include(["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"])
        .with_id("raydium"),
])?;

handle.remove_filters(vec!["pumpfun".to_string()])?;
```

### Slot yaşam döngüsü olayları

`subscribe_slots()` ayrı bir sunucu akışıdır ve filtre almaz.

```rust theme={null}
let mut slots = client.subscribe_slots();

while let Some(event) = slots.next().await {
    let event = event?;
    // event.slot, event.status() (a SlotStatus enum: alive / complete / dead),
    // event.parent_slot, event.current_leader, event.sequence
    println!("slot={} status={:?}", event.slot, event.status());
}
```

### Sağlık probları

`get_version()` ve `ping()`, akışlarla aynı yük devretmeye sahip tekil (unary) çağrılardır.

```rust theme={null}
println!("version={}", client.get_version().await?);
println!("ping={}", client.ping(7).await?);
```

Tam protobuf spesifikasyonu, mesaj şekilleri, zenginleştirme alanları ve slot durumları için [JetStream v2 Protokol Referansı](/tr/data-streaming/jetstream-v2-reference) bölümüne bakın.