Quelle version de tronpy est requise ?

tronpy 0.6.0 ou version ultérieure. Installez via pip install tronpy. Le helper de signature calcule lui-même le hash keccak256 TIP-191, il produit donc une signature compatible avec TronWeb sur n'importe quelle version de tronpy.

Pourquoi ne pas utiliser priv.sign_msg() ?

Certaines versions de tronpy font un hash du message avec sha256 au lieu du schéma keccak256 TIP-191 que utilise signMessageV2, ce qui échoue la vérification. Calculer le hash explicitement (comme montré) maintient la signature correcte dans toutes les versions.

Louer de l'énergie Tron avec Python (tronpy) : exemples de code

Intégration Python complète utilisant tronpy. Chaque étape est un bloc de code autonome que vous pouvez copier dans votre projet. L'exemple complet de bout en bout se trouve au bas de la page.

Prérequis : Python 3.8+, tronpy installé (pip install tronpy), un portefeuille Tron financé.

Le flux

Aucune clé API. Pas d'inscription. Votre code envoie TRX sur la chaîne à l'adresse de paiement TronEnergy, signe un message prouvant la propriété, puis réclame la délégation. L'énergie arrive en environ 3 secondes. Ensuite, votre code envoie USDT en utilisant l'énergie déléguée.

La tarification est linéaire : 16 250 énergie par TRX. Commande minimale 4 TRX (65 000 énergie — un transfert USDT standard), maximale 1 000 TRX (16,25 M d'énergie). Le montant que vous envoyez détermine exactement la quantité d'énergie que vous récupérez — il n'y a pas de paliers ou de forfaits. Pour un transfert standard unique, envoyez 4. Pour un transfert de nouveau portefeuille, envoyez 8. Pour des travaux par lot, envoyez plus. Le code ci-dessous utilise une TRX_AMOUNT variable pour que vous puissiez la modifier en un seul endroit.

Étape par étape

1. Configuration

configuration

import os, requests
from tronpy import Tron
from tronpy.keys import PrivateKey, keccak256
from coincurve import PrivateKey as CCKey  # tronpy already depends on coincurve

client = Tron()  # mainnet — pass HTTPProvider(api_key=...) to avoid rate limits
priv   = PrivateKey(bytes.fromhex(os.environ['TRON_PRIVATE_KEY']))
sender = priv.public_key.to_base58check_address()

API  = 'https://api.tronnrg.com'
ADDR = 'TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx'  # API payment address
USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
  

2. Envoyer TRX

envoyer un paiement

TRX_AMOUNT = 4  # Linear: 16,250 energy per TRX. Min 4, max 1000.
# 4 → 65k (standard) · 8 → 130k (new wallet) · 40 → 650k (10 transfers)

payment = (
    client.trx.transfer(sender, ADDR, TRX_AMOUNT * 1_000_000)
    .build().sign(priv).broadcast()
)
print('Payment tx:', payment.txid)
  

3. Réclamer la délégation d'énergie

réclamer la délégation

# Sign: proves you are the sender. Must equal TronWeb signMessageV2 exactly:
# keccak256("\x19TRON Signed Message:\n" + len + msg), secp256k1, v = rec + 27.
def sign_message_v2(message, priv):
    msg    = message.encode()
    prefix = b"\x19TRON Signed Message:\n" + str(len(msg)).encode()
    digest = keccak256(prefix + msg)
    raw    = CCKey(priv.to_bytes()).sign_recoverable(digest, hasher=None)
    return '0x' + (raw[:64] + bytes([raw[64] + 27])).hex()

msg = f"{payment.txid}:{sender}"
sig = sign_message_v2(msg, priv)

delegation = requests.post(f"{API}/delegate", json={
    'tx_hash': payment.txid,
    'delegate_to': sender,
    'signature': sig,
}).json()

if delegation.get('error'):
    raise Exception(delegation['message'])

print('Energy delegated:', delegation['energy'])  # TRX_AMOUNT × 16,250
  

4. Envoyer l'USDT

envoyer USDT

recipient = 'TRecipientWallet'
contract  = client.get_contract(USDT)
tx = (
    contract.functions.transfer(recipient, 10 * 1_000_000)
    .with_owner(sender).fee_limit(50_000_000)
    .build().sign(priv).broadcast()
)
print('USDT sent:', tx.txid)
  

Gestion des erreurs

gestion des erreurs

result = requests.post(f"{API}/delegate", json=payload).json()

if result.get('error'):
    err = result['error']
    if   err == 'payment_verification_failed':
        pass  # Payment not yet indexed on-chain. Wait 3s and retry.
    elif err == 'hash_already_used':
        pass  # Already claimed. Do not retry.
    elif err == 'signature_mismatch':
        pass  # Sender of TRX != signer of the message. Sign with the same key.
    elif err == 'delegation_failed':
        pass  # Provider could not deliver. Retry or contact support with result['ref'].
  

Exemple complet

Copiez ceci dans un fichier, définissez votre variable d'environnement TRON_PRIVATE_KEY, et exécutez-le. Le script envoie du TRX, signe le message, réclame la délégation avec retry, puis envoie l'USDT.

delegate_energy.py

import os, time, requests
from tronpy import Tron
from tronpy.keys import PrivateKey, keccak256
from coincurve import PrivateKey as CCKey

client = Tron()  # mainnet — pass HTTPProvider(api_key=...) to avoid rate limits
priv   = PrivateKey(bytes.fromhex(os.environ['TRON_PRIVATE_KEY']))
sender = priv.public_key.to_base58check_address()

API  = 'https://api.tronnrg.com'
ADDR = 'TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx'
USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'


# Signature must match TronWeb signMessageV2 byte-for-byte.
def sign_message_v2(message, priv):
    msg    = message.encode()
    prefix = b"\x19TRON Signed Message:\n" + str(len(msg)).encode()
    digest = keccak256(prefix + msg)
    raw    = CCKey(priv.to_bytes()).sign_recoverable(digest, hasher=None)
    return '0x' + (raw[:64] + bytes([raw[64] + 27])).hex()


def claim_with_retry(tx_hash, delegate_to, signature, retries=3):
    for _ in range(retries):
        res = requests.post(f"{API}/delegate", json={
            'tx_hash': tx_hash, 'delegate_to': delegate_to, 'signature': signature,
        }).json()
        if not res.get('error'):
            return res
        if res['error'] != 'payment_verification_failed':
            raise Exception(res['message'])
        time.sleep(3)
    raise Exception('Transaction not found after retries')


def main():
    recipient  = 'TRecipientWallet'
    trx_amount = 4  # min 4, max 1000 — you get trx_amount × 16,250 energy

    # 1. Send TRX (linear pricing: 16,250 energy per TRX)
    payment = (
        client.trx.transfer(sender, ADDR, trx_amount * 1_000_000)
        .build().sign(priv).broadcast()
    )
    print('Payment:', payment.txid)

    # 2. Claim delegation (the signature proves you sent the TRX)
    signature = sign_message_v2(f"{payment.txid}:{recipient}", priv)
    result = claim_with_retry(payment.txid, recipient, signature)
    print('Delegated:', result['energy'], 'energy')
    print('Delegation tx:', result['delegations'][0]['tx'])  # verify on TronScan
    print('Ref:', result['ref'])

    # 3. Send USDT using the delegated energy
    contract = client.get_contract(USDT)
    tx = (
        contract.functions.transfer(recipient, 10 * 1_000_000)
        .with_owner(sender).fee_limit(50_000_000)
        .build().sign(priv).broadcast()
    )
    print('USDT sent:', tx.txid)


if __name__ == '__main__':
    main()
  

Incluez toujours la signature. Elle prouve que vous êtes le portefeuille qui a envoyé le TRX. Sans elle, l'API rejette la requête avec missing_signature.