> ## 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. # Rust SDK > Robinhood Chain için Rust SDK: orbitflare-robinhood-sdk crate'i. Baştan sona [alloy](https://github.com/alloy-rs/alloy) tipleri kullanılır — `Address`, `U256`, `B256`, `Filter`, `TransactionRequest`, tiplenmiş bloklar, işlemler, makbuzlar ve günlükler — ve OrbitFlare'ın kendi taşıma katmanıyla gelir: yedek uç nokta, geri çekilmeli yeniden deneme ve kendi kendini onaran WebSocket abonelikleri. SDK, EVM uyumlu L2 [Robinhood Chain](/tr/robinhood-chain)'i hedefler ve varsayılan olarak OrbitFlare'ın üretim endpoint'lerine bağlanır. ## Kurulum ```bash theme={null} cargo add orbitflare-robinhood-sdk ``` Varsayılan olarak yalnızca RPC istemcisi etkindir. İhtiyacınız olanı etkinleştirin: ```bash theme={null} cargo add orbitflare-robinhood-sdk --features ws cargo add orbitflare-robinhood-sdk --features all ``` ## Alloy tipleri Tüm adresler, hash'ler ve miktarlar alloy tipleridir. Yaygın olanlar crate kökünde yeniden dışa aktarılır (`Address`, `U256`, `B256`, `Bytes`, `Filter`, `TransactionRequest`, `BlockNumberOrTag`, ...); crate'lerin tamamına ise `orbitflare_robinhood_sdk::primitives` (alloy-primitives) ve `orbitflare_robinhood_sdk::rpc_types` (alloy-rpc-types-eth) olarak erişilebilir. ```rust theme={null} use orbitflare_robinhood_sdk::primitives::{address, b256, utils::format_ether}; ``` ## RPC istemcisi Tüm seçeneklerin ayarlı olduğu bir istemci: ```rust theme={null} use orbitflare_robinhood_sdk::{BlockNumberOrTag, Result, RetryPolicy, RpcClientBuilder}; use std::time::Duration; let client = RpcClientBuilder::new() .url("https://robinhood.rpc.orbitflare.com") .fallback_urls(&["https://robinhood-backup.rpc.orbitflare.com"]) .api_key("ORBIT-XXXXXX-NNNNNN-NNNNNN") .block_tag(BlockNumberOrTag::Finalized) .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()?; ``` Her şeyin makul bir varsayılanı vardır — builder varsayılan olarak üretimdeki OrbitFlare uç noktasını kullanır, bu yüzden minimal kurulum: ```rust theme={null} let client = RpcClientBuilder::new().build()?; ``` ### Builder yöntemleri **`.url(url)`** — Birincil uç nokta. Çözümleme sırası: builder üzerindeki `.url()`, sonra `ORBITFLARE_ROBINHOOD_RPC_URL` ortam değişkeni, sonra varsayılan `https://robinhood.rpc.orbitflare.com` (`rpc::DEFAULT_RPC_URL`). **`.urls(&[...])`** — Birincil ve tüm yedekleri tek çağrıda ayarlar. İlk eleman birincil, kalanlar yedeklerdir. **`.fallback_url(url)` / `.fallback_urls(&[...])`** — Yedek uç noktalar ekler. Birincil başarısız olduğunda SDK yedekleri sırayla dener. Başarısız olan uç noktalar üstel bekleme süresiyle (10 sn, 20 sn, 40 sn, en çok 60 sn) karantinaya alınır ve süre dolduğunda otomatik olarak yeniden denenir; sağlıklı uç noktalar her zaman tercih edilir. **`.api_key(key)`** — OrbitFlare lisans anahtarınız. Ayarlanmazsa SDK ortamdan `ORBITFLARE_LICENSE_KEY` okur. Anahtar istek zamanında uç nokta URL'sine eklenir. **`.block_tag(tag)`** — Durum sorgularının (`get_balance`, `call`, `get_code`, ...) kullandığı varsayılan blok etiketi. `BlockNumberOrTag` tipine dönüşen her şeyi alır. Varsayılan: `Latest`. **`.retry(policy)`** — Geçici hatalarda (5xx, 429, bağlantı kopmaları, JSON-RPC hata kodu -32005) sonraki uç noktaya geçmeden önce üstel geri çekilmeli yeniden denemeyi denetler. `Retry-After` başlığı taşıyan 429 yanıtlarına uyulur. **`.timeout(duration)`** — Her tekil istek için HTTP zaman aşımı. ### Kullanılabilir RPC yöntemleri | Yöntem | Döndürdüğü | | ------------------------------------------------------------ | ------------------------------------------------------- | | `get_block_number()` | `u64` | | `get_chain_id()` | `u64` | | `get_balance(Address)` | `U256` wei | | `get_transaction_count(Address)` | `u64` nonce | | `get_gas_price()` | `u128` wei | | `max_priority_fee_per_gas()` | `u128` wei | | `get_block_by_number(impl Into, full_txs)` | `Option` | | `get_transaction_by_hash(B256)` | `Option` | | `get_transaction_receipt(B256)` | `Option` | | `get_logs(&Filter)` | `Vec` | | `get_code(Address)` | `Bytes` | | `call(&TransactionRequest)` | `Bytes` | | `estimate_gas(&TransactionRequest)` | `u64` | | `send_raw_transaction(&[u8])` | `B256` işlem hash'i | | `fee_history(blocks, newest, percentiles)` | `FeeHistory` | | `request(method, params)` | Ada göre herhangi bir RPC yöntemi (`serde_json::Value`) | | `request_raw(body)` | Ham JSON-RPC gövde dizgesi | ### Zincir durumunu okuma ```rust theme={null} use orbitflare_robinhood_sdk::primitives::{address, utils::format_ether}; let block = client.get_block_number().await?; let gas_price = client.get_gas_price().await?; let wallet = address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045"); let balance = client.get_balance(wallet).await?; let nonce = client.get_transaction_count(wallet).await?; println!("ETH: {}", format_ether(balance)); ``` ### Günlük filtreleri `get_logs`, alloy'un `Filter` tipini doğrudan alır: ```rust theme={null} use orbitflare_robinhood_sdk::primitives::{address, b256}; use orbitflare_robinhood_sdk::{BlockNumberOrTag, Filter}; let transfer_topic = b256!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"); let filter = Filter::new() .from_block(1_000_000u64) .to_block(BlockNumberOrTag::Latest) .address(address!("d0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC")) .event_signature(transfer_topic); let logs = client.get_logs(&filter).await?; ``` ### Kontrat çağrıları ve işlemler `call` ve `estimate_gas`, alloy'un `TransactionRequest` tipini alır. İşlem göndermek için işlemi alloy ile (`alloy-signer`, `alloy-network`) oluşturup imzalayın, ardından SDK üzerinden yayınlayın: ```rust theme={null} let hash = client.send_raw_transaction(&signed_tx_rlp).await?; let receipt = client.get_transaction_receipt(hash).await?; ``` ### Diğer yöntemler `request`, 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. Bu, Robinhood Chain'in bir Arbitrum Nitro ağı olarak sunduğu `arb_*` uzantı yöntemlerini de kapsar. `request_raw` ham JSON-RPC gövde dizgesi gönderir. ```rust theme={null} use serde_json::json; let syncing = client.request("eth_syncing", json!([])).await?; let version = client .request_raw(r#"{"jsonrpc":"2.0","id":1,"method":"web3_clientVersion","params":[]}"#) .await?; ``` ## WebSocket istemcisi `ws` özelliğini etkinleştirin. Robinhood Chain yaklaşık her 100 milisaniyede bir blok üretir; bu nedenle `newHeads`, Ethereum mainnet'e ve çoğu L2'ye göre çok daha hızlı tetiklenir. ```rust theme={null} use orbitflare_robinhood_sdk::{Result, RetryPolicy, WsClientBuilder}; use std::time::Duration; let client = WsClientBuilder::new() .url("wss://robinhood.rpc.orbitflare.com") .api_key("ORBIT-XXXXXX-NNNNNN-NNNNNN") .retry(RetryPolicy { initial_delay: Duration::from_millis(100), max_delay: Duration::from_secs(30), multiplier: 2.0, max_attempts: 0, }) .ping_interval_secs(10) .max_missed_pongs(3) .build() .await?; ``` Minimal: ```rust theme={null} let client = WsClientBuilder::new().build().await?; ``` `.build()` öğesinin asenkron olduğuna dikkat edin — döndürmeden önce WebSocket bağlantısını kurar. Builder; `.urls()`, `.fallback_url(s)()`, `.api_key()` ve `.retry()` yöntemlerini RPC builder ile paylaşır. WebSocket'e özgü seçenekler şunlardır: **`.url(url)`** — Birincil WebSocket uç noktası. Çözümleme sırası: `.url()`, sonra `ORBITFLARE_ROBINHOOD_WS_URL`, sonra varsayılan `wss://robinhood.rpc.orbitflare.com` (`ws::DEFAULT_WS_URL`). **`.ping_interval_secs(n)`** — SDK'nın ölü bağlantıları tespit etmek için WebSocket `Ping` çerçevelerini gönderme sıklığı. Varsayılan: 10. **`.max_missed_pongs(n)`** — Bağlantı ölü sayılıp yeniden bağlanılmadan önce yanıtsız kalan ping sayısı. Varsayılan: 3. ### Abonelikler Abonelikler tiplenmiştir — her biri ham JSON yerine karşılık gelen alloy tipini üretir: | Yöntem | Ürettiği | | -------------------------------------- | --------------------------- | | `new_heads_subscribe()` | Her yeni blok için `Header` | | `logs_subscribe(&Filter)` | Filtreyle eşleşen `Log` | | `new_pending_transactions_subscribe()` | `B256` işlem hash'i | ```rust theme={null} use orbitflare_robinhood_sdk::primitives::b256; use orbitflare_robinhood_sdk::Filter; let mut heads = client.new_heads_subscribe().await?; let transfer_topic = b256!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"); let mut transfers = client .logs_subscribe(&Filter::new().event_signature(transfer_topic)) .await?; ``` Tüm abonelikler bir `WsSubscription` döndürür. Sonraki tiplenmiş olay için `.next()` çağırın (`None`, aboneliğin kapatıldığı anlamına gelir); tiplenmemiş `serde_json::Value` yükü için `.next_raw()` kullanın. ```rust theme={null} while let Some(head) = heads.next().await { println!("block {} (gas used {})", head.number, head.gas_used); } ``` Tüm abonelikler tek WebSocket bağlantısında çalışır ve istediğiniz zaman yeni abonelik ekleyebilirsiniz. `sub.unsubscribe().await` bir aboneliği açıkça kaldırır; bunu çağırmadan aboneliği düşürmek de işe yarar — SDK yetimi tespit eder ve abonelikten çıkmayı otomatik gönderir. ### Yeniden bağlanma Bağlantı koparsa arka plan görevi üstel geri çekilme ile yeniden bağlanır ve tüm etkin abonelikleri otomatik olarak yeniden abone eder. `.next()` çağrılarınız çalışmaya devam eder — bağlantı geri gelince olaylar sürer. Ölü bağlantılar etkin ping/pong ile tespit edilir; bu, `.ping_interval_secs()` ve `.max_missed_pongs()` ile yapılandırılabilir. ## Ortam değişkenleri | Değişken | Kullanan | Amaç | | ------------------------------ | -------------- | --------------------------------------------------------- | | `ORBITFLARE_LICENSE_KEY` | RPC, WebSocket | Uç nokta URL'lerine eklenen API anahtarı | | `ORBITFLARE_ROBINHOOD_RPC_URL` | RPC | `.url()` çağrılmazsa varsayılan uç noktayı geçersiz kılar | | `ORBITFLARE_ROBINHOOD_WS_URL` | WebSocket | `.url()` çağrılmazsa varsayılan uç noktayı geçersiz kılar | ## Tam örnek Bir cüzdanı okuyan, ardından yeni blokları ve ERC-20 transferlerini gerçek zamanlı takip eden bir izleme betiği: ```rust theme={null} use orbitflare_robinhood_sdk::primitives::{address, b256, utils::format_ether}; use orbitflare_robinhood_sdk::{Filter, Result, RpcClientBuilder, WsClientBuilder}; #[tokio::main] async fn main() -> Result<()> { let rpc = RpcClientBuilder::new().build()?; let wallet = address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045"); let balance = rpc.get_balance(wallet).await?; let block = rpc.get_block_number().await?; println!("block {block}, wallet holds {} ETH", format_ether(balance)); let ws = WsClientBuilder::new().build().await?; let mut heads = ws.new_heads_subscribe().await?; let transfer_topic = b256!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"); let mut transfers = ws .logs_subscribe(&Filter::new().event_signature(transfer_topic)) .await?; println!("watching new heads and ERC-20 transfers..."); loop { tokio::select! { Some(head) = heads.next() => { println!("block {} (gas used {})", head.number, head.gas_used); } Some(log) = transfers.next() => { let tx = log.transaction_hash.unwrap_or_default(); println!("transfer on {} in {tx}", log.address()); } } } } ``` ## Kaynak SDK açık kaynaktır: [github.com/orbitflare/orbitflare-robinhood-sdk-rs](https://github.com/orbitflare/orbitflare-robinhood-sdk-rs)