Bibliothèques SDK

TronZap fournit des bibliothèques SDK officielles pour plusieurs langages de programmation pour vous aider à intégrer facilement notre API. Ces SDK gèrent l'authentification, les appels API et la gestion des erreurs, vous permettant de vous concentrer sur la construction de votre application.

SDK Disponibles

Nous proposons actuellement des SDK pour les langages suivants :

SDK PHP

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

Voir le SDK PHP sur GitHub

SDK Node.js

Ce SDK est conçu pour fonctionner sur plusieurs plateformes JavaScript/TypeScript :

• Node.js: v16.0.0 ou supérieur
• Bun: v1.0.0 ou supérieur
• Deno: v1.0.0 ou supérieur

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

Voir le SDK Node.js sur GitHub

SDK Python

pip install tronzap-sdk

Voir le SDK Python sur GitHub

Go SDK

Prérequis: Go 1.21 ou supérieur, aucune dépendance tierce.

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

Voir le SDK Go sur GitHub

Java SDK

Prérequis: Java 17 ou supérieur.

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")

Voir le SDK Java sur GitHub

.NET (C#) SDK

Prérequis: .NET 8 ou supérieur.

dotnet add package Tronzap.Sdk

Voir le SDK .NET sur GitHub

Ruby SDK

Prérequis: Ruby 3.3 ou supérieur.

# Ajoutez la gem à votre Gemfile
gem "tronzap-sdk"

# ou installez-la directement
gem install tronzap-sdk

Voir le SDK Ruby sur GitHub

Rust SDK

Prérequis: Rust 1.85 ou supérieur, un runtime Tokio.

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

Voir le SDK Rust sur GitHub

Utilisation de Base

Tous les SDK fournissent une interface similaire pour interagir avec l'API TronZap. Voici quelques exemples de base :

PHP

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

// Initialiser le client
$apiToken = 'votre_token_api';
$apiSecret = 'votre_secret_api';
$client = new Client($apiToken, $apiSecret);

try {
    // Obtenir les services disponibles
    $services = $client->getServices();

    // Créer une transaction d'énergie
    $transaction = $client->createEnergyTransaction(
        'ADRESSE_TRX', // Adresse du portefeuille TRON
        65000,         // Quantité d'énergie
        1,             // Durée (heures)
        'mon-tx-id',   // ID externe (optionnel)
        false          // Ne pas activer l'adresse (optionnel)
    );

    // Vérifier le statut de la transaction
    $status = $client->checkTransaction($transaction['result']['transaction_id']);

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

Node.js

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

// Initialiser le client
const client = new TronZapClient({
  apiToken: 'votre_token_api',
  apiSecret: 'votre_secret_api'
});

async function main() {
  try {
    // Obtenir les services disponibles
    const services = await client.getServices();
    console.log(services);

    // Créer une transaction d'énergie
    const transaction = await client.createEnergyTransaction(
      'ADRESSE_PORTEFEUILLE_TRON',
      65150,
      1,
      'mon-tx-id',  // ID externe optionnel
      true         // Optionnel: activer l'adresse si nécessaire
    );
    console.log(transaction);

    // Vérifier le statut de la transaction
    const status = await client.checkTransaction(transaction.result.transaction_id);
    console.log(status);

  } catch (error) {
    if (error instanceof TronZapError) {
      console.error(`Erreur API TronZap: ${error.message} (Code: ${error.code})`);
    } else {
      // Vérifier le type d'erreur avant d'accéder à ses propriétés
      if (error instanceof Error) {
        console.error(`Erreur générale: ${error.message}`);
      } else {
        console.error('Une erreur inconnue s\'est produite:', error);
      }
    }
  }
}

main();

Python

from tronzap_sdk import TronZapClient, TronZapError

# Initialiser le client
api_token = 'votre_token_api'
api_secret = 'votre_secret_api'
client = TronZapClient(api_token, api_secret)

try:
    # Obtenir les services disponibles
    services = client.get_services()

    # Créer une transaction d'énergie
    transaction = client.create_energy_transaction(
        address='ADRESSE_TRX',  # Adresse du portefeuille TRON
        energy_amount=65000,    # Quantité d'énergie
        duration=1,             # Durée (heures)
        external_id='mon-tx-id', # ID externe (optionnel)
        activate_address=False  # Ne pas activer l'adresse (optionnel)
    )

    # Vérifier le statut de la transaction
    status = client.check_transaction(transaction['result']['transaction_id'])

except TronZapError as e:
    print(f"Erreur: {e.message} (Code: {e.code})")

Go

package main

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

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

func main() {
	// Initialiser le client
	client := tronzap.NewClient("your_api_token", "your_api_secret")
	ctx := context.Background()

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

	// Créer une transaction d'énergie
	tx, err := client.CreateEnergyTransaction(ctx, tronzap.EnergyTransactionRequest{
		Address:         "TRX_ADDRESS", // Adresse du portefeuille TRON
		Energy:          65000,         // Quantité d'énergie
		Duration:        1,             // Durée (heures)
		ExternalID:      "my-tx-id",    // ID externe (optionnel)
		ActivateAddress: false,         // Ne pas activer l'adresse (optionnel)
	})
	var apiErr *tronzap.APIError
	if errors.As(err, &apiErr) {
		log.Fatalf("Erreur: %s (Code: %d)", apiErr.Message, apiErr.Code)
	} else if err != nil {
		log.Fatal(err)
	}

	// Vérifier le statut de la transaction
	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) {
        // Initialiser le client
        TronzapClient client = TronzapClient.builder()
                .apiToken("your_api_token")
                .apiSecret("your_api_secret")
                .build();

        try {
            // Obtenir les services disponibles
            Services services = client.getServices();
            System.out.println(services);

            // Créer une transaction d'énergie
            Transaction tx = client.createEnergyTransaction(
                    EnergyTransactionRequest.builder("TRX_ADDRESS", 65000) // Adresse du portefeuille TRON, Quantité d'énergie
                            .duration(1)              // Durée (heures)
                            .externalId("my-tx-id")   // ID externe (optionnel)
                            .activateAddress(false)   // Ne pas activer l'adresse (optionnel)
                            .build());

            // Vérifier le statut de la transaction
            Transaction status = client.checkTransaction(CheckTransactionRequest.byId(tx.id()));
            System.out.println(status.status());

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

C#

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

// Initialiser le client
var client = new TronzapClient(new TronzapClientOptions
{
    ApiToken = "your_api_token",
    ApiSecret = "your_api_secret",
});

try
{
    // Obtenir les services disponibles
    ServiceRates services = await client.GetServicesAsync();
    Console.WriteLine(services);

    // Créer une transaction d'énergie
    Transaction tx = await client.CreateEnergyTransactionAsync(new EnergyTransactionRequest
    {
        Address = "TRX_ADDRESS",   // Adresse du portefeuille TRON
        Energy = 65000,            // Quantité d'énergie
        Duration = 1,              // Durée (heures)
        ExternalId = "my-tx-id",   // ID externe (optionnel)
        ActivateAddress = false,   // Ne pas activer l'adresse (optionnel)
    });

    // Vérifier le statut de la transaction
    Transaction status = await client.CheckTransactionAsync(CheckTransactionRequest.ById(tx.Id));
    Console.WriteLine(status.Status);
}
catch (TronzapApiException e)
{
    Console.Error.WriteLine($"Erreur: {e.Message} (Code: {e.Code})");
}
catch (TronzapException e)
{
    Console.Error.WriteLine($"Erreur: {e.Message}");
}

Ruby

require "tronzap"

# Initialiser le client
client = Tronzap::Client.new(
  api_token: "your_api_token",
  api_secret: "your_api_secret"
)

begin
  # Obtenir les services disponibles
  services = client.get_services
  p services

  # Créer une transaction d'énergie
  transaction = client.create_energy_transaction(
    address: "TRX_ADDRESS",   # Adresse du portefeuille TRON
    energy: 65000,            # Quantité d'énergie
    duration: 1,              # Durée (heures)
    external_id: "my-tx-id",  # ID externe (optionnel)
    activate_address: false   # Ne pas activer l'adresse (optionnel)
  )

  # Vérifier le statut de la transaction
  status = client.check_transaction(id: transaction.id)
  puts status.status
rescue Tronzap::ApiError => e
  warn "Erreur: #{e.message} (Code: #{e.code})"
rescue Tronzap::Error => e
  warn "Erreur: #{e.message}"
end

Rust

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

async fn run() -> Result<(), TronzapError> {
    // Initialiser le client
    let client = TronzapClient::new("your_api_token", "your_api_secret")?;

    // Obtenir les services disponibles
    let services = client.get_services().await?;
    println!("{services:?}");

    // Créer une transaction d'énergie
    let request = EnergyTransactionRequest::new("TRX_ADDRESS", 65000) // Adresse du portefeuille TRON, Quantité d'énergie
        .duration(1)                // Durée (heures)
        .external_id("my-tx-id")    // ID externe (optionnel)
        .activate_address(false);   // Ne pas activer l'adresse (optionnel)
    let tx = client.create_energy_transaction(&request).await?;

    // Vérifier le statut de la transaction
    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!("Erreur: {} (Code: {:?})", e.message(), e.code())
        }
        Err(e) => eprintln!("Erreur: {e}"),
    }
}

Fonctionnalités

Tous nos SDK fournissent les fonctionnalités suivantes :

• Authentification : Génération automatique de signatures API pour des requêtes sécurisées
• Informations sur les Services : Obtenir les services disponibles et leurs tarifs
• Transactions d'Énergie : Créer des transactions pour l'achat d'énergie
• Bande passante et lots de ressources : Acheter de la bande passante, ou de l'énergie et de la bande passante en une seule transaction
• Estimation d'énergie et informations d'adresse : Estimer l'énergie nécessaire à un transfert USDT et obtenir les ressources et soldes d'une adresse
• Vérifications AML : Analyser le risque des adresses et des transactions
• Activation d'Adresse : Créer des transactions pour l'activation d'adresse
• Statut des Transactions : Vérifier le statut de vos transactions
• Gestion de Compte : Obtenir le solde du compte et les informations d'utilisation

Documentation

Pour la documentation complète sur chaque SDK, veuillez vous référer à leurs dépôts GitHub respectifs.