> ## 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 > Yeniden deneme, yedek uç nokta ve yaygın Solana yöntemleri için tiplenmiş yardımcılar içeren JSON-RPC istemcisi. ## Kurulum ```bash theme={null} go get github.com/orbitflare/orbitflare-sdk-go ``` ```go theme={null} import "github.com/orbitflare/orbitflare-sdk-go/rpc" ``` ## İstemciyi oluşturma Tüm seçenekleri ayarlanmış bir istemci: ```go theme={null} import ( "time" "github.com/orbitflare/orbitflare-sdk-go/orbitflare" "github.com/orbitflare/orbitflare-sdk-go/rpc" ) client, err := rpc.NewBuilder(). URL("http://ny.rpc.orbitflare.com"). FallbackURL("http://fra.rpc.orbitflare.com"). FallbackURL("http://ams.rpc.orbitflare.com"). APIKey("ORBIT-XXXXXX-NNNNNN-NNNNNN"). Commitment("confirmed"). Retry(orbitflare.RetryPolicy{ InitialDelay: 100 * time.Millisecond, MaxDelay: 30 * time.Second, Multiplier: 2.0, MaxAttempts: 5, }). Timeout(30 * time.Second). Build() ``` Bunların çoğunun makul varsayılanları vardır. Minimal kurulum: ```go theme={null} client, err := rpc.NewBuilder(). URL("http://ny.rpc.orbitflare.com"). Build() ``` Her yöntem bir `context.Context` alır; bu nedenle çağrıyı sınırlamak için son tarihli bir context geçirin: ```go theme={null} ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() ``` ### Builder yöntemleri **`.URL(url)`** - İstekleri göndereceğiniz birincil uç nokta. Ayarlanmazsa SDK, `ORBITFLARE_RPC_URL` ortam değişkenine bakar. ```go theme={null} .URL("http://ny.rpc.orbitflare.com") ``` **`.URLs(urls...)`** - Birincil ve tüm yedekleri tek çağrıda ayarlar. İlk eleman birincil, geri kalanlar yedektir. ```go theme={null} .URLs("http://ny.rpc.orbitflare.com", "http://fra.rpc.orbitflare.com", "http://ams.rpc.orbitflare.com") ``` **`.FallbackURL(url)`** - Tek bir yedek uç nokta ekler. Birden çok eklemek için birden çok kez çağırın. Birincil başarısız olduğunda SDK yedekleri sırayla dener. ```go theme={null} .FallbackURL("http://fra.rpc.orbitflare.com"). FallbackURL("http://ams.rpc.orbitflare.com") ``` **`.FallbackURLs(urls...)`** - `FallbackURL` ile aynı, ancak birden fazlasını birden alır. ```go theme={null} .FallbackURLs("http://fra.rpc.orbitflare.com", "http://ams.rpc.orbitflare.com") ``` **`.APIKey(key)`** - OrbitFlare lisans anahtarınız. Ayarlanmazsa SDK ortamdan `ORBITFLARE_LICENSE_KEY` değerini okur. Anahtar istek anında URL'ye eklenir, uç noktada asla saklanmaz ve loglara ya da hatalara asla yazdırılmaz. ```go theme={null} .APIKey("ORBIT-XXXXXX-NNNNNN-NNNNNN") ``` **`.Commitment(level)`** - Tüm tiplenmiş yardımcılarda kullanılan varsayılan commitment düzeyi. Seçenekler: `"processed"`, `"confirmed"`, `"finalized"`. Varsayılan `"confirmed"`. ```go theme={null} .Commitment("finalized") ``` **`.Retry(policy)`** - SDK'nın başarısız istekleri nasıl yeniden deneyeceğini denetler. `InitialDelay` ilk yeniden denemeden önceki beklemedir. `Multiplier` her denemede gecikmeyi ölçekler. `MaxDelay` backoff'u sınırlar. `MaxAttempts` toplam yeniden deneme sayısını sınırlar (0 sonsuz demektir). Varsayılan: 100 ms başlangıç, 30 s maksimum, 2x çarpan, sonsuz deneme. ```go theme={null} .Retry(orbitflare.RetryPolicy{ InitialDelay: 200 * time.Millisecond, MaxDelay: 15 * time.Second, Multiplier: 2.0, MaxAttempts: 5, }) ``` **`.Timeout(duration)`** - Her bir istek için HTTP zaman aşımı. Varsayılan 30 saniye. ```go theme={null} .Timeout(10 * time.Second) ``` **`.Logger(logger)`** - İstek yeniden denemeleri ve yedek uç nokta geçişleri için bir `*slog.Logger`. Ayarlanmazsa loglama `ORBITFLARE_LOG` ortam değişkeniyle denetlenir (`trace|debug|info|warn|error|silent`, varsayılan `silent`). ```go theme={null} .Logger(slog.New(slog.NewTextHandler(os.Stderr, nil))) ``` ## Kullanılabilir RPC yöntemleri Tiplenmiş yardımcılar Go değerleri döndürür; diğer her şey, kendi tiplerinize çözebileceğiniz `json.RawMessage` döndürür. ### `GetSlot(ctx)` Geçerli slot numarasını döndürür. ```go theme={null} slot, err := client.GetSlot(ctx) // uint64 ``` ### `GetBalance(ctx, address)` Bir hesabın bakiyesini lamports cinsinden döndürür. ```go theme={null} lamports, err := client.GetBalance(ctx, "So11111111111111111111111111111111111111112") // uint64 sol := float64(lamports) / 1_000_000_000 ``` ### `GetAccountInfo(ctx, address)` Tam hesap verisini `json.RawMessage` olarak döndürür; hesap yoksa nil döner. Veri base64 kodludur. ```go theme={null} raw, err := client.GetAccountInfo(ctx, "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") if raw != nil { var info struct { Owner string `json:"owner"` Lamports uint64 `json:"lamports"` } json.Unmarshal(raw, &info) } ``` ### `GetMultipleAccounts(ctx, addresses)` Birden çok hesabı tek çağrıda getirir. 100'lük gruplara otomatik böler (Solana'nın istek başına limiti), böylece istediğiniz sayıda adres geçebilirsiniz. ```go theme={null} accounts, err := client.GetMultipleAccounts(ctx, []string{"addr1", "addr2", "addr3"}) // []json.RawMessage ``` ### `GetLatestBlockhash(ctx)` En güncel blockhash'i ve geçerli olduğu son blok yüksekliğini döndürür. ```go theme={null} blockhash, lastValid, err := client.GetLatestBlockhash(ctx) // (string, uint64) ``` ### `GetTransaction(ctx, signature)` Onaylanmış bir işlemi imzasıyla getirir. Meta verilerle birlikte tam işlemi `json.RawMessage` olarak döndürür. ```go theme={null} raw, err := client.GetTransaction(ctx, "5K8F2j...") ``` ### `GetSignaturesForAddress(ctx, address, limit)` Bir adres için son işlem imzalarını, en yeniden başlayarak döndürür. ```go theme={null} sigs, err := client.GetSignaturesForAddress(ctx, "So111...", 10) // []json.RawMessage ``` ### `GetProgramAccounts(ctx, programID)` Bir programa ait tüm hesapları döndürür. Çok fazla veri dönebilir. ```go theme={null} accounts, err := client.GetProgramAccounts(ctx, "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") ``` ### `GetRecentPrioritizationFees(ctx, addresses)` Bir dizi hesap için son öncelik ücretlerini döndürür. Compute unit fiyatını tahmin etmek için kullanışlıdır. ```go theme={null} fees, err := client.GetRecentPrioritizationFees(ctx, []string{"6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}) ``` ### `SendTransaction(ctx, txBase64)` İmzalı bir işlemi ağa gönderir. base64 kodlu, serileştirilmiş bir işlem alır. İşlem imzasını döndürür. ```go theme={null} signature, err := client.SendTransaction(ctx, txBase64) // string ``` ### `SimulateTransaction(ctx, txBase64)` Bir işlemi göndermeden simüle eder. Logları, tüketilen compute unit'leri ve varsa hataları `json.RawMessage` olarak döndürür. ```go theme={null} raw, err := client.SimulateTransaction(ctx, txBase64) ``` ### `GetTokenAccountsByOwner(ctx, owner, mint, programID)` Bir cüzdanın token hesaplarını döndürür. Belirli bir mint veya bir token program ID'si geçin. İkisi de boş dizeyse SPL Token programı varsayılır. ```go theme={null} tokens, err := client.GetTokenAccountsByOwner(ctx, "wallet_address", "", "") ``` ### `GetTransactionsForAddress(ctx, address, options)` `getSignaturesForAddress` ve `getTransaction`'ı tek çağrıda birleştiren OrbitFlare'e özgü yöntem. `Data` dilimini ve sonraki sayfayı getirmek için isteğe bağlı bir `PaginationToken` içeren bir `GetTransactionsResult` döndürür. Dört ayrıntı düzeyini (`signatures`, `none`, `accounts`, `full`), iki yönlü sıralamayı, zaman/slot filtrelemesini, durum filtrelemesini ve token hesabı dahil etmeyi destekler. `options` varsayılanlar için nil olabilir. ```go theme={null} details, order, status := "full", "asc", "succeeded" var limit uint32 = 100 gte, lte := int64(1704067200), int64(1706745600) result, err := client.GetTransactionsForAddress(ctx, "address", &rpc.GetTransactionsOptions{ TransactionDetails: &details, Limit: &limit, SortOrder: &order, Filters: &rpc.GetTransactionsFilters{ Status: &status, BlockTime: &rpc.RangeFilter[int64]{Gte: >e, Lte: <e}, }, }) for _, tx := range result.Data { _ = tx // json.RawMessage } if result.PaginationToken != nil { // sonraki çağrıda PaginationToken ayarlayarak sonraki sayfayı getirin } ``` ### `Request(ctx, method, params)` Herhangi bir RPC yöntemini adıyla çağırın. SDK, JSON-RPC zarfını oluşturur, yeniden deneme ve yedek uç nokta geçişini yönetir ve `result` alanını `json.RawMessage` olarak döndürür. ```go theme={null} epoch, err := client.Request(ctx, "getEpochInfo", []any{}) inflation, err := client.Request(ctx, "getInflationRate", []any{}) ``` ### `RequestRaw(ctx, body)` Ham bir JSON-RPC gövde dizesi gönderin. Diğer her şeyle aynı yeniden deneme ve yedek uç nokta geçişi geçerlidir. ```go theme={null} result, err := client.RequestRaw(ctx, `{"jsonrpc":"2.0","id":1,"method":"getHealth","params":[]}`) ``` ## Tam örnek Ağın durumunu kontrol eden, bir cüzdanın SOL bakiyesini getiren ve son işlemleri arayan bir program. ```go theme={null} package main import ( "context" "encoding/json" "fmt" "log" "time" "github.com/orbitflare/orbitflare-sdk-go/rpc" ) func main() { client, err := rpc.NewBuilder(). URL("http://ny.rpc.orbitflare.com"). FallbackURL("http://fra.rpc.orbitflare.com"). Commitment("confirmed"). Build() if err != nil { log.Fatal(err) } ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() wallet := "CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX" slot, _ := client.GetSlot(ctx) blockhash, _, _ := client.GetLatestBlockhash(ctx) fmt.Printf("network slot: %d\nblockhash: %s\n", slot, blockhash) balance, _ := client.GetBalance(ctx, wallet) fmt.Printf("\n%s\n SOL: %.4f\n", wallet, float64(balance)/1_000_000_000) sigs, _ := client.GetSignaturesForAddress(ctx, wallet, 5) fmt.Println("\nrecent transactions:") for _, raw := range sigs { var sig struct { Signature string `json:"signature"` Slot uint64 `json:"slot"` Err any `json:"err"` } json.Unmarshal(raw, &sig) status := "ok" if sig.Err != nil { status = "failed" } fmt.Printf(" %d %s %s\n", sig.Slot, status, sig.Signature[:20]) } } ```