SDK Kütüphaneleri

TronZap, API'mizle kolayca entegrasyon yapmanıza yardımcı olmak için birden fazla programlama dili için resmi SDK kütüphaneleri sağlar. Bu SDK'lar kimlik doğrulama, API çağrıları ve hata yönetimini halledererek uygulamanızı oluşturmaya odaklanmanızı sağlar.

Mevcut SDK'lar

Şu anda aşağıdaki diller için SDK'lar sunuyoruz:

PHP SDK

composer require tron-energy-market/tronzap-sdk-php

GitHub'da PHP SDK'sını görüntüle

Node.js SDK

Bu SDK, birden fazla JavaScript/TypeScript platformunda çalışacak şekilde tasarlanmıştır:

• Node.js: v16.0.0 veya üzeri
• Bun: v1.0.0 veya üzeri
• Deno: v1.0.0 veya üzeri

npm install tronzap-sdk
# veya
yarn add tronzap-sdk
# veya
pnpm add tronzap-sdk

GitHub'da Node.js SDK'sını görüntüle

Python SDK

pip install tronzap-sdk

GitHub'da Python SDK'sını görüntüle

Go SDK

Gereksinimler: Go 1.21 veya üzeri, üçüncü taraf bağımlılık yok.

go get github.com/tron-energy-market/tronzap-sdk-go

GitHub'da Go SDK'sını görüntüle

Java SDK

Gereksinimler: Java 17 veya üzeri.

Maven

<dependency>
    <groupId>com.tronzap</groupId>
    <artifactId>tronzap-java</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle

implementation("com.tronzap:tronzap-java:1.0.0")

GitHub'da Java SDK'sını görüntüle

.NET (C#) SDK

Gereksinimler: .NET 8 veya üzeri.

dotnet add package Tronzap.Sdk

GitHub'da .NET SDK'sını görüntüle

Ruby SDK

Gereksinimler: Ruby 3.3 veya üzeri.

# Gem'i Gemfile dosyanıza ekleyin
gem "tronzap-sdk"

# veya doğrudan yükleyin
gem install tronzap-sdk

GitHub'da Ruby SDK'sını görüntüle

Rust SDK

Gereksinimler: Rust 1.85 veya üzeri, bir Tokio çalışma zamanı.

[dependencies]
tronzap-sdk = "1.0"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

GitHub'da Rust SDK'sını görüntüle

Temel Kullanım

Tüm SDK'lar TronZap API'si ile etkileşim için benzer bir arayüz sağlar. İşte bazı temel örnekler:

PHP

<?php
use TronZap\Client;
use TronZap\Exception\TronZapException;

// İstemciyi başlat
$apiToken = 'your_api_token';
$apiSecret = 'your_api_secret';
$client = new Client($apiToken, $apiSecret);

try {
    // Mevcut hizmetleri al
    $services = $client->getServices();

    // Enerji işlemi oluştur
    $transaction = $client->createEnergyTransaction(
        'TRX_ADDRESS', // TRON cüzdan adresi
        65000,         // Enerji miktarı
        1,             // Süre (saat)
        'my-tx-id',    // Dış kimlik (isteğe bağlı)
        false          // Adresi etkinleştirmeyin (isteğe bağlı)
    );

    // İşlem durumunu kontrol et
    $status = $client->checkTransaction($transaction['result']['transaction_id']);

} catch (TronZapException $e) {
    echo "Hata: " . $e->getMessage() . " (Kod: " . $e->getCode() . ")\n";
}

Node.js

import { TronZapClient, TronZapError } from 'tronzap-sdk';

// İstemciyi başlat
const client = new TronZapClient({
  apiToken: 'your_api_token',
  apiSecret: 'your_api_secret'
});

async function main() {
  try {
    // Mevcut hizmetleri al
    const services = await client.getServices();
    console.log(services);

    // Enerji işlemi oluştur
    const transaction = await client.createEnergyTransaction(
      'TRON_WALLET_ADDRESS',
      65150,
      1,
      'my-tx-id',  // İsteğe bağlı dış kimlik
      true        // İsteğe bağlı: gerekirse adresi etkinleştir
    );
    console.log(transaction);

    // İşlem durumunu kontrol et
    const status = await client.checkTransaction(transaction.result.transaction_id);
    console.log(status);

  } catch (error) {
    if (error instanceof TronZapError) {
      console.error(`TronZap API Hatası: ${error.message} (Kod: ${error.code})`);
    } else {
      // Hata özelliklerine erişmeden önce hata türünü kontrol et
      if (error instanceof Error) {
        console.error(`Genel hata: ${error.message}`);
      } else {
        console.error('Bilinmeyen bir hata oluştu:', error);
      }
    }
  }
}

main();

Python

from tronzap_sdk import TronZapClient, TronZapError

# İstemciyi başlat
api_token = 'your_api_token'
api_secret = 'your_api_secret'
client = TronZapClient(api_token, api_secret)

try:
    # Mevcut hizmetleri al
    services = client.get_services()

    # Enerji işlemi oluştur
    transaction = client.create_energy_transaction(
        address='TRX_ADDRESS',  # TRON cüzdan adresi
        energy_amount=65000,    # Enerji miktarı
        duration=1,             # Süre (saat)
        external_id='my-tx-id', # Dış kimlik (isteğe bağlı)
        activate_address=False  # Adresi etkinleştirmeyin (isteğe bağlı)
    )

    # İşlem durumunu kontrol et
    status = client.check_transaction(transaction['result']['transaction_id'])

except TronZapError as e:
    print(f"Hata: {e.message} (Kod: {e.code})")

Go

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	tronzap "github.com/tron-energy-market/tronzap-sdk-go"
)

func main() {
	// İstemciyi başlat
	client := tronzap.NewClient("your_api_token", "your_api_secret")
	ctx := context.Background()

	// Mevcut hizmetleri al
	services, err := client.GetServices(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", services)

	// Enerji işlemi oluştur
	tx, err := client.CreateEnergyTransaction(ctx, tronzap.EnergyTransactionRequest{
		Address:         "TRX_ADDRESS", // TRON cüzdan adresi
		Energy:          65000,         // Enerji miktarı
		Duration:        1,             // Süre (saat)
		ExternalID:      "my-tx-id",    // Dış kimlik (isteğe bağlı)
		ActivateAddress: false,         // Adresi etkinleştirmeyin (isteğe bağlı)
	})
	var apiErr *tronzap.APIError
	if errors.As(err, &apiErr) {
		log.Fatalf("Hata: %s (Kod: %d)", apiErr.Message, apiErr.Code)
	} else if err != nil {
		log.Fatal(err)
	}

	// İşlem durumunu kontrol et
	status, err := client.CheckTransaction(ctx, tronzap.CheckTransactionRequest{ID: tx.ID})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(status.Status)
}

Java

import com.tronzap.sdk.TronzapClient;
import com.tronzap.sdk.exception.ApiException;
import com.tronzap.sdk.exception.TronzapException;
import com.tronzap.sdk.request.CheckTransactionRequest;
import com.tronzap.sdk.request.EnergyTransactionRequest;
import com.tronzap.sdk.response.Services;
import com.tronzap.sdk.response.Transaction;

public class Example {
    public static void main(String[] args) {
        // İstemciyi başlat
        TronzapClient client = TronzapClient.builder()
                .apiToken("your_api_token")
                .apiSecret("your_api_secret")
                .build();

        try {
            // Mevcut hizmetleri al
            Services services = client.getServices();
            System.out.println(services);

            // Enerji işlemi oluştur
            Transaction tx = client.createEnergyTransaction(
                    EnergyTransactionRequest.builder("TRX_ADDRESS", 65000) // TRON cüzdan adresi, Enerji miktarı
                            .duration(1)              // Süre (saat)
                            .externalId("my-tx-id")   // Dış kimlik (isteğe bağlı)
                            .activateAddress(false)   // Adresi etkinleştirmeyin (isteğe bağlı)
                            .build());

            // İşlem durumunu kontrol et
            Transaction status = client.checkTransaction(CheckTransactionRequest.byId(tx.id()));
            System.out.println(status.status());

        } catch (ApiException e) {
            System.err.println("Hata: " + e.getMessage() + " (Kod: " + e.getCode() + ")");
        } catch (TronzapException e) {
            System.err.println("Hata: " + e.getMessage());
        }
    }
}

C#

using Tronzap.Sdk;
using Tronzap.Sdk.Exceptions;
using Tronzap.Sdk.Requests;
using Tronzap.Sdk.Responses;

// İstemciyi başlat
var client = new TronzapClient(new TronzapClientOptions
{
    ApiToken = "your_api_token",
    ApiSecret = "your_api_secret",
});

try
{
    // Mevcut hizmetleri al
    ServiceRates services = await client.GetServicesAsync();
    Console.WriteLine(services);

    // Enerji işlemi oluştur
    Transaction tx = await client.CreateEnergyTransactionAsync(new EnergyTransactionRequest
    {
        Address = "TRX_ADDRESS",   // TRON cüzdan adresi
        Energy = 65000,            // Enerji miktarı
        Duration = 1,              // Süre (saat)
        ExternalId = "my-tx-id",   // Dış kimlik (isteğe bağlı)
        ActivateAddress = false,   // Adresi etkinleştirmeyin (isteğe bağlı)
    });

    // İşlem durumunu kontrol et
    Transaction status = await client.CheckTransactionAsync(CheckTransactionRequest.ById(tx.Id));
    Console.WriteLine(status.Status);
}
catch (TronzapApiException e)
{
    Console.Error.WriteLine($"Hata: {e.Message} (Kod: {e.Code})");
}
catch (TronzapException e)
{
    Console.Error.WriteLine($"Hata: {e.Message}");
}

Ruby

require "tronzap"

# İstemciyi başlat
client = Tronzap::Client.new(
  api_token: "your_api_token",
  api_secret: "your_api_secret"
)

begin
  # Mevcut hizmetleri al
  services = client.get_services
  p services

  # Enerji işlemi oluştur
  transaction = client.create_energy_transaction(
    address: "TRX_ADDRESS",   # TRON cüzdan adresi
    energy: 65000,            # Enerji miktarı
    duration: 1,              # Süre (saat)
    external_id: "my-tx-id",  # Dış kimlik (isteğe bağlı)
    activate_address: false   # Adresi etkinleştirmeyin (isteğe bağlı)
  )

  # İşlem durumunu kontrol et
  status = client.check_transaction(id: transaction.id)
  puts status.status
rescue Tronzap::ApiError => e
  warn "Hata: #{e.message} (Kod: #{e.code})"
rescue Tronzap::Error => e
  warn "Hata: #{e.message}"
end

Rust

use tronzap_sdk::requests::{CheckTransactionRequest, EnergyTransactionRequest};
use tronzap_sdk::{TronzapClient, TronzapError};

async fn run() -> Result<(), TronzapError> {
    // İstemciyi başlat
    let client = TronzapClient::new("your_api_token", "your_api_secret")?;

    // Mevcut hizmetleri al
    let services = client.get_services().await?;
    println!("{services:?}");

    // Enerji işlemi oluştur
    let request = EnergyTransactionRequest::new("TRX_ADDRESS", 65000) // TRON cüzdan adresi, Enerji miktarı
        .duration(1)                // Süre (saat)
        .external_id("my-tx-id")    // Dış kimlik (isteğe bağlı)
        .activate_address(false);   // Adresi etkinleştirmeyin (isteğe bağlı)
    let tx = client.create_energy_transaction(&request).await?;

    // İşlem durumunu kontrol et
    let status = client
        .check_transaction(&CheckTransactionRequest::by_id(tx.id))
        .await?;
    println!("{}", status.status);
    Ok(())
}

#[tokio::main]
async fn main() {
    match run().await {
        Ok(()) => {}
        Err(TronzapError::Api(e)) => {
            eprintln!("Hata: {} (Kod: {:?})", e.message(), e.code())
        }
        Err(e) => eprintln!("Hata: {e}"),
    }
}

Özellikler

Tüm SDK'larımız aşağıdaki özellikleri sağlar:

• Kimlik Doğrulama: Güvenli istekler için API imzalarının otomatik oluşturulması
• Hizmet Bilgileri: Mevcut hizmetleri ve fiyatlandırmayı alma
• Enerji İşlemleri: Enerji satın alma için işlem oluşturma
• Bant Genişliği ve Kaynak Paketleri: Bant genişliği veya tek bir işlemde enerji ve bant genişliği satın alma
• Enerji Tahmini ve Adres Bilgisi: USDT transferi için gereken enerjiyi tahmin etme, adres kaynaklarını ve bakiyelerini alma
• AML Kontrolleri: Adresleri ve işlemleri risk açısından tarama
• Adres Etkinleştirme: Adres etkinleştirme için işlem oluşturma
• İşlem Durumu: İşlemlerinizin durumunu kontrol etme
• Hesap Yönetimi: Hesap bakiyesi ve kullanım bilgilerini alma

Dokümantasyon

Her SDK ile ilgili kapsamlı dokümantasyon için lütfen ilgili GitHub depolarına başvurun.