> ## 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 Go İstemcisi

> orbitflare-apex-go, OrbitFlare Apex için Go istemcisidir: 0-RTT ile yeniden bağlanan kalıcı bir QUIC bağlantısı, ayrıca JSON-RPC, toplu gönderimler ve paketler için HTTP yardımcıları.

`orbitflare-apex-go`, Apex için Go istemcisidir. Apex uç noktası başına tek bir kalıcı QUIC bağlantısı tutar, API anahtarınızdan türetilen bir istemci sertifikasıyla kimlik doğrular, akış başına bir serileştirilmiş işlem gönderir ve bağlantı koptuğunda 0-RTT ile yeniden bağlanır. [Rust istemcisi](/tr/apex/rust-client) ile aynı özelliklere sahiptir ve istemci sertifikası Rust istemcisininkiyle bayt düzeyinde aynıdır.

## Kurulum

Modül `github.com/orbitflare/orbitflare-apex-go` adını taşır; kaynak kodu [GitHub](https://github.com/orbitflare/orbitflare-apex-go)'dadır:

```bash theme={null}
go get github.com/orbitflare/orbitflare-apex-go@latest
go get github.com/gagliardetto/solana-go@v1.24.0
```

Modülün iki paketi vardır:

| Paket | İçe aktarma | İçerik |
| - | - | - |
| `apex` | `github.com/orbitflare/orbitflare-apex-go` | QUIC istemcisi, bölgeler, bahşişler ve aktarım biçimi |
| `rpc` | `github.com/orbitflare/orbitflare-apex-go/rpc` | HTTP üzerinden Apex uç noktası, ayrıca herhangi bir Solana RPC için blockhash ve onay yardımcıları |

İşlemler, legacy, v0 ve [v1](/tr/apex/transaction-v1) mesajlarını kapsayan [`solana-go`](https://github.com/gagliardetto/solana-go) ile oluşturulur. QUIC yolu `rpc` paketine bağımlı değildir.

Modül, Go 1.26 veya daha yenisini gerektirir.

## Hızlı Başlangıç

Eksiksiz bir program. Hesaplama bütçesi ve bahşiş içeren bir memo işlemi oluşturur, onu QUIC üzerinden gönderir ve onayı bekler. [Hızlı başlangıç](/tr/apex/quickstart) ile aynı ortam değişkenlerini okur: `APEX_API_KEY`, `KEYPAIR_PATH` ve `SOLANA_RPC_URL`.

```go main.go theme={null}
package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/gagliardetto/solana-go"
	computebudget "github.com/gagliardetto/solana-go/programs/compute-budget"

	apex "github.com/orbitflare/orbitflare-apex-go"
	"github.com/orbitflare/orbitflare-apex-go/rpc"
)

func getenv(name, fallback string) string {
	if v := os.Getenv(name); v != "" {
		return v
	}
	return fallback
}

func main() {
	ctx := context.Background()
	apiKey := os.Getenv("APEX_API_KEY")
	payer, err := solana.PrivateKeyFromSolanaKeygenFile(getenv("KEYPAIR_PATH", "payer.json"))
	if err != nil {
		log.Fatal(err)
	}
	region := apex.Frankfurt

	client, err := apex.Connect(ctx, region, apiKey)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	tipAccounts, err := rpc.New(region, apiKey).GetTipAccounts(ctx)
	if err != nil {
		log.Fatal(err)
	}
	tipAccount, _ := apex.PickTipAccount(tipAccounts)

	solanaRPC := rpc.NewSolanaRPC(getenv("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com"))
	blockhash, err := solanaRPC.LatestBlockhash(ctx)
	if err != nil {
		log.Fatal(err)
	}

	memo := solana.NewInstruction(
		solana.MustPublicKeyFromBase58("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
		solana.AccountMetaSlice{solana.Meta(payer.PublicKey()).WRITE().SIGNER()},
		[]byte(fmt.Sprintf("apex go %d", time.Now().UnixNano())),
	)
	tx, err := solana.NewTransaction([]solana.Instruction{
		computebudget.NewSetComputeUnitLimitInstruction(100_000).Build(),
		computebudget.NewSetComputeUnitPriceInstruction(10_000).Build(),
		memo,
		apex.TipInstruction(payer.PublicKey(), tipAccount, apex.MinTipLamports),
	}, blockhash, solana.TransactionPayer(payer.PublicKey()))
	if err != nil {
		log.Fatal(err)
	}
	if _, err := tx.Sign(func(solana.PublicKey) *solana.PrivateKey { return &payer }); err != nil {
		log.Fatal(err)
	}

	sentAt := time.Now()
	signature, err := client.SendTransaction(ctx, tx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("sent in %d us\n", time.Since(sentAt).Microseconds())

	slot, landed, err := solanaRPC.Confirm(ctx, signature.String(), 30*time.Second)
	switch {
	case err != nil:
		log.Fatal(err)
	case landed:
		fmt.Printf("landed in slot %d after %d ms: %s\n", slot, time.Since(sentAt).Milliseconds(), signature)
	default:
		fmt.Printf("not confirmed within 30 s: %s\n", signature)
	}
}
```

```bash theme={null}
go mod init apexdemo
go get github.com/orbitflare/orbitflare-apex-go@latest github.com/gagliardetto/solana-go@v1.24.0
APEX_API_KEY=... KEYPAIR_PATH=payer.json go run .
```

`SendTransaction`, işlem akışa yazılır yazılmaz, mikrosaniyeler içinde ve herhangi bir onay almadan döner. Aşağıdaki kod parçaları bu programın içine yerleşir: programın `ctx`, `client`, `apiKey`, `payer`, `tipAccount`, `blockhash`, `solanaRPC` ve `tx` değişkenlerini yeniden kullanırlar. Bir kod parçasının kullandığı `errors`, `encoding/base64` veya `sync` gibi standart kütüphane içe aktarmalarını ekleyin.

## Yanıtla Gönderme

Çift yönlü akış, dönmeden önce Apex'in yanıtını okur: işlem kabul edildiğinde imzayı, aksi halde [kabul kodu](/tr/apex/errors-and-rate-limits#quic-kabul-kodları) ve mesajla birlikte bir `*apex.RejectedError` döndürür. Bir ek gidiş dönüşe mal olur, dolayısıyla onu entegrasyon sırasında veya nedeni satır içinde görmeniz gerektiğinde kullanın.

```go theme={null}
signature, err := client.SendTransactionWithResponse(ctx, tx)
var rejected *apex.RejectedError
switch {
case errors.As(err, &rejected):
	fmt.Printf("rejected: %s: %s\n", rejected.Code, rejected.Message)
case err != nil:
	log.Fatal(err)
default:
	fmt.Println("accepted:", signature)
}
```

`SendWithResponse(ctx, wire)` aynısını elinizde zaten bulunan baytlarla yapar ve ham `apex.Admission` değerini (`Accepted`, `Signature`, `Code`, `Message`) döndürür.

## v1 İşlemleri

v1 işlemleri 4096 bayta kadar çıkabilir. Hesaplama bütçesi ComputeBudget talimatları yerine mesajın `solana.TransactionConfig` alanında yer alır ve ayarlanmamış her sınır 0 olur; dolayısıyla hesaplama birimi sınırını, yüklenen hesap verisi boyutu sınırını ve öncelik için ücreti ayarlayın. [Transaction v1](/tr/apex/transaction-v1) sayfasına bakın.

```go theme={null}
config := solana.TransactionConfig{}.
	WithComputeUnitLimit(100_000).
	WithLoadedAccountsDataSizeLimit(1024 * 1024).
	WithPriorityFee(4_000)

tx, err := solana.NewTransaction([]solana.Instruction{
	yourInstruction,
	apex.TipInstruction(payer.PublicKey(), tipAccount, apex.MinTipLamports),
}, blockhash,
	solana.TransactionPayer(payer.PublicKey()),
	solana.TransactionV1Config(config),
)
if err != nil {
	log.Fatal(err)
}
if _, err := tx.Sign(func(solana.PublicKey) *solana.PrivateKey { return &payer }); err != nil {
	log.Fatal(err)
}
signature, err := client.SendTransaction(ctx, tx)
if err != nil {
	log.Fatal(err)
}
fmt.Println("sent v1:", signature)
```

## Ham Baytlar

İşleminiz zaten serileştirilmişse (başka bir imzalayıcıdan, başka bir süreçten veya bir dosyadan), baytları olduğu gibi gönderin. Hiçbir şey onları yeniden kodlamaz.

```go theme={null}
wire, err := base64.StdEncoding.DecodeString(signedBase64)
if err != nil {
	log.Fatal(err)
}
if err := client.SendTransactionBytes(ctx, wire); err != nil {
	log.Fatal(err)
}
```

`apex.EncodePacket(wire, mevProtect, maxRetries)`, istemcinin akışa yazdığı veri paketinin tam halini döndürür: 8 baytlık bir uzunluk, işlem ve 3 baytlık bir kuyruk. Diğer diller için referans budur.

## HTTP

`rpc` paketi, Apex uç noktasındaki her HTTP rotasını kapsar. Anahtarı `x-api-key` başlığı olarak gönderir.

```go theme={null}
apexRPC := rpc.New(apex.Frankfurt, apiKey)

if err := apexRPC.Ping(ctx); err != nil {
	log.Fatal(err)
}

wire, err := apex.SerializeTransaction(tx)
if err != nil {
	log.Fatal(err)
}

signature, err := apexRPC.SendTransaction(ctx, wire, false, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println("JSON-RPC:", signature)

signature, err = apexRPC.SendTransactionBinary(ctx, wire, false, apex.RetryBudget(20))
if err != nil {
	var rpcErr *rpc.Error
	if errors.As(err, &rpcErr) {
		fmt.Println("rejected:", rpcErr.Message)
	}
	log.Fatal(err)
}
fmt.Println("send-bin:", signature)
```

`SendTransaction`, mevcut koda doğrudan eklenebilen JSON-RPC `sendTransaction` çağrısıdır. `SendTransactionBinary` ham baytları en ucuz HTTP yolu olan `/send-bin` rotasına gönderir. Son iki argüman `mevProtect` ve `maxRetries` değerleridir; `nil`, uç noktanın varsayılan yeniden deneme bütçesini kullanır.

### Toplu Gönderimler

`SendBatch` tek bir istekte en fazla 16 işlem gönderir. Her biri ayrı ayrı kabul edilir ve sonuç hangilerinin kabul edildiğini söyler.

```go theme={null}
wires := make([][]byte, 0, len(txs))
for _, tx := range txs {
	wire, err := apex.SerializeTransaction(tx)
	if err != nil {
		log.Fatal(err)
	}
	wires = append(wires, wire)
}

result, err := apexRPC.SendBatch(ctx, wires, false, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%d accepted, %d rejected\n", result.Accepted, result.Rejected)
for i, item := range result.Results {
	if item.Accepted {
		fmt.Println(i, "accepted:", item.Signature)
	} else {
		fmt.Println(i, "rejected:", item.Error, item.Message)
	}
}
```

### Paketler

`SendBundle`, sırayla ve ya hep ya hiç biçiminde bloğa giren, tam olarak biri bahşişli bir ila dört işlem gönderir. Paket bloğa girene veya başarısız olana kadar `BundleStatuses` çağrısını yoklayın. [Paketler](/tr/apex/bundles) sayfasına bakın.

```go theme={null}
firstWire, _ := apex.SerializeTransaction(first)
secondWire, _ := apex.SerializeTransaction(second)

accepted, err := apexRPC.SendBundle(ctx, [][]byte{firstWire, secondWire})
if err != nil {
	log.Fatal(err)
}
fmt.Println("bundle", accepted.BundleID)

for range 60 {
	statuses, err := apexRPC.BundleStatuses(ctx, []string{accepted.BundleID})
	if err != nil {
		log.Fatal(err)
	}
	if len(statuses) > 0 {
		switch statuses[0].State {
		case rpc.BundleLanded:
			fmt.Println("landed in slot", *statuses[0].LandedSlot)
			return
		case rpc.BundleFailed, rpc.BundleInvalid:
			fmt.Println("did not land:", statuses[0].State)
			return
		}
	}
	time.Sleep(500 * time.Millisecond)
}
```

## Eşzamanlı Gönderimler

Bir `*apex.Client` eşzamanlı kullanım için güvenlidir ve her gönderim tek bağlantı üzerinde kendi akışını alır. İstemciyi bir kez oluşturun ve istediğiniz kadar goroutine'den gönderin.

```go theme={null}
var wg sync.WaitGroup
for _, tx := range txs {
	wg.Add(1)
	go func() {
		defer wg.Done()
		signature, err := client.SendTransaction(ctx, tx)
		if err != nil {
			log.Println("send failed:", err)
			return
		}
		log.Println("sent", signature)
	}()
}
wg.Wait()
```

## Bölgeler

Her Apex uç noktası bir `apex.Region` sabitidir. `apex.ParseRegion` bir kod veya şehir adı kabul eder, `apex.AllRegions` ise bunları listeler.

| Sabit | Kod |
| - | - |
| `apex.Frankfurt` | `fra` |
| `apex.Amsterdam` | `ams` |
| `apex.Dublin` | `dub` |
| `apex.London` | `lon` |
| `apex.NewYork` | `nyc` |
| `apex.SaltLakeCity` | `slc` |
| `apex.Singapore` | `sgp` |
| `apex.Tokyo` | `tyo` |
| `apex.Siauliai` | `sqq` |
| `apex.Global` | `global` |

```go theme={null}
region, ok := apex.ParseRegion("tokyo")
if !ok {
	log.Fatal("unknown region")
}
fmt.Println(region.Code(), region.QUICEndpoint(), region.RPCURL())
```

`QUICEndpoint()` `<code>.apex.orbitflare.com:7001` döndürür ve `RPCURL()` `http://<code>.apex.orbitflare.com` döndürür. [Uç noktalar ve bölgeler](/tr/apex/endpoints) sayfasına bakın.

## Taşıma Yöntemleri

| | QUIC tek yönlü | QUIC çift yönlü | İkili HTTP | JSON-RPC |
| - | - | - | - | - |
| **Çağrı** | `SendTransaction`, `SendTransactionBytes` | `SendTransactionWithResponse`, `SendWithResponse` | `rpc.Client.SendTransactionBinary`, `SendBatch` | `rpc.Client.SendTransaction` |
| **Döndürdüğü değer** | İmza. Geriye hiçbir şey okunmaz | Kabul edildi veya bir ret kodu ve mesajı | İmza veya etiketli bir hata | İmza veya bir JSON-RPC hatası |
| **Gönderim başına maliyet** | Sıcak bir bağlantıda bir akış | Bir akış ve bir gidiş dönüş | Ham baytlarla bir HTTP isteği | JSON içinde base64 ile bir HTTP isteği |
| **En uygun kullanım** | Kalıcı bağlantı kullanan botlar | Entegrasyon, hata ayıklama, nedeni satır içinde görmek isteyen araçlar | Toplu gönderimler | `sendTransaction` koduna doğrudan ekleme |

Taşıma yöntemi önceliği veya yönlendirmeyi değiştirmez. Bunu bahşiş belirler.

## API

| Öğe | Açıklama |
| - | - |
| `apex.Connect(ctx, region, apiKey)` | Geçici bir yerel port ve varsayılan seçeneklerle bağlanır |
| `apex.ConnectWithOptions(ctx, opts, apiKey)` | [`apex.Options`](#seçenekler) ile bağlanır |
| `SendTransaction(ctx, tx)` | Serileştirir (legacy, v0 veya v1) ve tek yönlü bir akışta gönderir. İlk imzayı döndürür |
| `SendTransactionBytes(ctx, wire)` | Aynısı, elinizde zaten bulunan baytlarla. Hiçbir şey onları yeniden kodlamaz |
| `SendTransactionWithResponse(ctx, tx)` | Çift yönlü akış. Ret durumunda bir `*apex.RejectedError` |
| `SendWithResponse(ctx, wire)` | Aynısı, baytlarla. Ham `apex.Admission` değerini döndürür |
| `Health()`, `ReconnectsTotal()`, `ZeroRTTResumptionsTotal()`, `RemoteAddr()` | Metrikleriniz için bağlantı durumu |
| `Reconnect(ctx)`, `Close()` | Yaşam döngüsü |
| `apex.TipInstruction(payer, tipAccount, lamports)` | Bahşiş transferini oluşturur |
| `apex.PickTipAccount(accounts)` | Bahşiş hesaplarından birini rastgele seçer |
| `apex.MinTipLamports` | Standart katman tabanı: 1.000.000 lamport |
| `rpc.Client` | HTTP üzerinden Apex uç noktası: `GetTipAccounts`, `SendTransaction` (JSON-RPC), `SendTransactionBinary`, `SendBatch`, `SendBundle`, `BundleStatuses`, `Ping` |
| `rpc.SolanaRPC` | Herhangi bir Solana RPC: `LatestBlockhash`, `Confirm(ctx, signature, timeout)` |
| `rpc.FetchVaults(ctx, solanaRPCURL)` | Bahşiş programının vault hesaplarını zincirden okur (`rpc.TipProgramID`). Bu, bahşiş listesi değildir: uç noktanın reddettiği yayınlanmamış vault'ları da içerir. Bahşiş verilecek hesaplar için `GetTipAccounts` kullanın; bunu ise yalnızca belirli bir hesabın gerçek bir vault olup olmadığını kontrol etmek için kullanın |
| `apex.ClientPubkey(apiKey)` | API anahtarınızın türettiği, gösterge panelinizde gösterilen sertifika anahtarı |
| `apex.SerializeTransaction(tx)` | Legacy, v0 ve v1 için kanonik aktarım baytları |
| `apex.EncodePacket`, `apex.FrameParts`, `apex.DecodeAdmission` | Diğer diller için referans olarak QUIC aktarım biçimi |
| `apex.RetryBudget(n)` | Seçenekler ve HTTP çağrıları için bir `MaxRetries` değeri |

Ağa dokunan her çağrı bir `context.Context` alır, böylece bir gönderimi iptal edebilir veya ona bir son tarih verebilirsiniz. İşiniz bittiğinde `Close` çağırın; arka plandaki yeniden bağlanmayı durdurur ve soketi kapatır.

## Seçenekler

Her alanın sıfır değeri size varsayılanları verir, dolayısıyla yalnızca ihtiyacınız olanı ayarlayın:

| Alan | Varsayılan | Açıklama |
| - | - | - |
| `Endpoint` | Frankfurt'un QUIC adresi | QUIC adresinin `host:port` değeri |
| `MEVProtect` | `false` | Shield engelleme listesindeki liderleri atlar. [MEV koruması](/tr/apex/mev-protection) sayfasına bakın |
| `MaxRetries` | `nil` | `apex.RetryBudget(n)` olarak işlem başına yeniden deneme bütçesi. `nil`, uç noktanın varsayılanını kullanır |
| `BindAddr` | Geçici port | Güvenlik duvarı izin listeleri için yerel UDP bağlama adresi |
| `ConnectTimeout` | 3 sn | El sıkışma zaman aşımı |
| `SendTimeout` | 2 sn | Tek bir gönderim için zaman aşımı |
| `KeepAlive` | 1 sn | QUIC PING aralığı. Uç noktanın boşta kalma zaman aşımı 30 sn'dir |
| `DisableAutoReconnect` | `false` | `false` olduğunda, bağlantı gittiği için başarısız olan bir gönderim yeniden bağlanır ve bir kez daha gönderir |
| `DisableProactiveReconnect` | `false` | `false` olduğunda, bir arka plan goroutine'i kopma fark edilir edilmez yeniden el sıkışır, böylece bir sonraki gönderim bunun bedelini ödemez |

```go theme={null}
client, err := apex.ConnectWithOptions(ctx, apex.Options{
	Endpoint:       apex.NewYork.QUICEndpoint(),
	BindAddr:       "0.0.0.0:47001",
	MEVProtect:     true,
	MaxRetries:     apex.RetryBudget(30),
	ConnectTimeout: 3 * time.Second,
	SendTimeout:    time.Second,
	KeepAlive:      time.Second,
}, apiKey)
if err != nil {
	log.Fatal(err)
}
defer client.Close()
```

## Canlı Tutma ve Yeniden Bağlanmalar

Bağlantı, Apex uç noktasındaki 30 saniyelik boşta kalma zaman aşımına karşı her saniye gönderilen bir QUIC PING ile açık kalır. Sıcak bir bağlantıda bir gönderim, bir akış açma ve bir yazmadan ibarettir.

Bağlantı koparsa:

* Bir arka plan goroutine'i bunu fark eder ve hemen yeniden el sıkışır, böylece bir sonraki gönderim genellikle canlı bir bağlantı bulur. Bağlantıyı uç noktanın kendisi kapattıysa (bilinmeyen bir anahtar, çok fazla bağlantı), goroutine sert biçimde yeniden denemek yerine her denemeden sonra bekleme süresini 30 saniyeye kadar ikiye katlar.
* Yeniden bağlanma, önbelleğe alınmış bir oturum bileti kullanır ve bekleyen işlemi el sıkışmanın ilk uçuşunda gönderir (**0-RTT**). Uç nokta erken veriyi reddederse istemci onu el sıkışmadan sonra yeniden gönderir.
* Bağlantı gittiği için başarısız olan bir gönderim yeniden bağlanır ve bir kez yeniden dener. Bunu kendiniz ele almak için `DisableAutoReconnect` ayarlayın.
* Her yeniden bağlanmada ana bilgisayar adı yeniden çözümlenir; böylece `apex.Global` kullanan bir istemci, kendi uç noktası düştüğünde yeniden başlatılmadan yük dengeleyiciyi izleyerek bir sonraki en yakın uç noktaya geçer. Çözümleme gönderim sırasında değil, arka plandaki yeniden bağlanmada yapılır; başarısız olursa veya iki saniyeden uzun sürerse istemci elindeki adresi korur. IP adresi olarak verilen bir uç nokta hiçbir zaman çözümlenmez.

Bağlantı durumunu metriklerinize aktarın:

```go theme={null}
go func() {
	for range time.Tick(10 * time.Second) {
		log.Printf("apex health=%s reconnects=%d zero_rtt=%d remote=%s",
			client.Health(), client.ReconnectsTotal(), client.ZeroRTTResumptionsTotal(), client.RemoteAddr())
	}
}()
```

## Hatalar

Hatalar bir sentinel değeri sarar; böylece `errors.Is` hangi aşamanın başarısız olduğunu söyler, `errors.As` ise türlü hataları verir.

| Hata | Anlamı |
| - | - |
| `*apex.RejectedError` | Uç nokta, işlemi çift yönlü bir akışta reddetti. `Code` ve `Message`, [kabul kodu](/tr/apex/errors-and-rate-limits#quic-kabul-kodları) ve nedenidir |
| `*apex.TooLargeError` | 4096 baytın üzerinde. Herhangi bir şey gönderilmeden önce yerel olarak yakalanır |
| `apex.ErrTimeout` | Bağlanma veya gönderim zaman aşımı doldu |
| `apex.ErrResolve`, `ErrBind`, `ErrTLS`, `ErrConnect`, `ErrConnection`, `ErrWrite`, `ErrRead` | Taşıma hataları |
| `apex.ErrSerialize`, `ErrBadAdmission`, `ErrNoSignature` | Kodlama sorunları |
| `apex.ErrClosed` | Bir akış sonlandırılamadı |
| `apex.ErrClientStopped` | `Close` sonrasında yapılan bir gönderim |

```go theme={null}
_, err := client.SendTransaction(ctx, tx)
var tooLarge *apex.TooLargeError
switch {
case err == nil:
case errors.As(err, &tooLarge):
	fmt.Println("transaction is", tooLarge.Size, "bytes")
case errors.Is(err, apex.ErrTimeout):
	fmt.Println("timed out, the transaction may still have been sent")
case errors.Is(err, apex.ErrConnect), errors.Is(err, apex.ErrConnection):
	fmt.Println("connection problem:", err)
default:
	fmt.Println(err)
}
```

`rpc` paketi, bir JSON-RPC veya düz HTTP reddi için kod ve mesaj içeren `*rpc.Error`, okuyamadığı bir yanıt için ise `rpc.ErrBadResponse` döndürür. Düz HTTP reddinin kodu 0'dır ve mesajı `label: message` biçimindedir; etiketler [Hatalar ve hız sınırları](/tr/apex/errors-and-rate-limits) sayfasında listelenmiştir.

## Anahtarınızı Kontrol Edin

API anahtarınızın türettiği sertifika anahtarını yazdırın. Gösterge panelinizde anahtarın yanında gösterilen istemci açık anahtarıyla eşleşmelidir; eşleşmiyorsa anahtar yanlış kopyalanmıştır.

```go theme={null}
fmt.Println(apex.ClientPubkey(apiKey))
```

## Depodaki Örnekler

Tüm örnekler `APEX_API_KEY`, `KEYPAIR_PATH` (varsayılan `payer.json`), `SOLANA_RPC_URL` ve isteğe bağlı olarak `APEX_REGION`, `APEX_QUIC`, `APEX_RPC`, `TIP_LAMPORTS`, `APEX_TX_VERSION` (`legacy` veya `v1`), `APEX_MEMO_BYTES` ve `APEX_CU_LIMIT` değişkenlerini okur. Her biri bahşişli bir memo gönderir ve bloğa girdiği slotu bildirir.

| Örnek | Gösterdiği şey |
| - | - |
| `quic_send` | Tek yönlü akış: en hızlı yol, ardından bir Solana RPC'den onay |
| `quic_send_with_response` | Çift yönlü akış: kabul edildi veya reddedildi yanıtı ve bir reddin nasıl okunacağı |
| `rpc_send` | Aynı bahşiş kuralıyla HTTP üzerinden JSON-RPC `sendTransaction` |
| `http_binary` | `/ping`, ham baytlarla `/send-bin` ve üç işlemlik bir `/send-batch` |
| `raw_bytes` | Ağ üzerinde önceden serileştirilmiş baytlar ve veri paketinin tam yerleşimi |
| `throughput` | Tek bir sıcak bağlantı, N eşzamanlı gönderim, gönderim başına p50 ve p99, bloğa giren işlem sayısı |
| `bundle` | İki işlemden oluşan, biri bahşişli atomik bir paket ve bloğa girene kadar durumu |
| `transfer` | `TO` adresine `LAMPORTS` tutarında, legacy veya v1, kabul yanıtıyla birlikte bahşişli bir SOL transferi |
| `client_pubkey` | Gösterge panelinizle karşılaştırmak için bir API anahtarının türettiği sertifika anahtarı |

```bash theme={null}
git clone https://github.com/orbitflare/orbitflare-apex-go.git
cd orbitflare-apex-go
APEX_API_KEY=... KEYPAIR_PATH=payer.json SOLANA_RPC_URL=https://... \
  go run ./examples/quic_send
```

## İstemcinin Yapmadıkları

* İşlem oluşturmak veya imzalamak ya da öncelik ücretinizi seçmek.
* Simülasyon yapmak veya preflight kontrolleri çalıştırmak. Sizinle lider arasındaki hiçbir şey bunu yapmaz.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.