wallet/broadcasttransaction - Broadcast TRON Tr...

# Basic transaction broadcast
curl -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/broadcasttransaction" \
  -H "Content-Type: application/json" \
  -d '{
    "txID": "94eea63bb6774c8fc4f4c9d1b62c1e8c2f7c8c2e4d3a2b1c0d9e8f7a6b5c4d3e2f1",
    "raw_data": {
      "contract": [{
        "parameter": {
          "value": {
            "amount": 1000000,
            "owner_address": "TJmmqjb1DK9TTZbQXzRQ2AuA94z4gKAPFh",
            "to_address": "TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN"
          },
          "type_url": "type.googleapis.com/protocol.TransferContract"
        },
        "type": "TransferContract"
      }],
      "ref_block_bytes": "4a7b",
      "ref_block_hash": "e15e44aa73bd9e15",
      "expiration": 1734567890000,
      "timestamp": 1734567830000
    },
    "signature": ["c8f8f8e8d8c8b8a898887878686858484838281807060504030201"]
  }'

# Broadcast and check result
curl -s -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/broadcasttransaction" \
  -H "Content-Type: application/json" \
  -d @signed_transaction.json | jq '{
    success: .result,
    txid: .txid,
    error: .message
  }'

# Script with retry logic
#!/bin/bash
API_KEY="YOUR_API_KEY"
SIGNED_TX_FILE="signed_transaction.json"
MAX_RETRIES=3

broadcast_with_retry() {
  local attempt=1
  
  while [ $attempt -le $MAX_RETRIES ]; do
    echo "Broadcasting transaction (attempt $attempt/$MAX_RETRIES)..."
    
    RESULT=$(curl -s -X POST "https://api-tron-mainnet.n.dwellir.com/$API_KEY/wallet/broadcasttransaction" \
      -H "Content-Type: application/json" \
      -d @"$SIGNED_TX_FILE")
    
    SUCCESS=$(echo "$RESULT" | jq -r '.result // false')
    
    if [ "$SUCCESS" = "true" ]; then
      TXID=$(echo "$RESULT" | jq -r '.txid')
      echo "✓ Transaction broadcast successful: $TXID"
      return 0
    else
      ERROR=$(echo "$RESULT" | jq -r '.message // "Unknown error"')
      echo "✗ Attempt $attempt failed: $ERROR"
      
      if [ $attempt -eq $MAX_RETRIES ]; then
        echo "Transaction broadcast failed after $MAX_RETRIES attempts"
        return 1
      fi
      
      # Exponential backoff
      DELAY=$((2 ** (attempt - 1)))
      echo "Waiting ${DELAY}s before retry..."
      sleep $DELAY
    fi
    
    ((attempt++))
  done
}

# Check transaction confirmation
check_confirmation() {
  local txid=$1
  local timeout=${2:-30}
  local start_time=$(date +%s)
  
  echo "Waiting for confirmation of $txid..."
  
  while true; do
    current_time=$(date +%s)
    elapsed=$((current_time - start_time))
    
    if [ $elapsed -ge $timeout ]; then
      echo "Confirmation timeout after ${timeout}s"
      return 1
    fi
    
    TX_INFO=$(curl -s -X POST "https://api-tron-mainnet.n.dwellir.com/$API_KEY/wallet/gettransactionbyid" \
      -H "Content-Type: application/json" \
      -d "{\"value\": \"$txid\", \"visible\": true}")
    
    BLOCK_NUM=$(echo "$TX_INFO" | jq -r '.blockNumber // null')
    
    if [ "$BLOCK_NUM" != "null" ]; then
      echo "✓ Transaction confirmed in block $BLOCK_NUM"
      return 0
    fi
    
    echo "Checking confirmation... (${elapsed}s elapsed)"
    sleep 3
  done
}

# Batch broadcasting script
batch_broadcast() {
  local tx_files=("$@")
  local successful=0
  local failed=0
  
  echo "Broadcasting ${#tx_files[@]} transactions..."
  
  for tx_file in "${tx_files[@]}"; do
    echo "Processing $tx_file..."
    
    if broadcast_with_retry "$tx_file"; then
      ((successful++))
    else
      ((failed++))
    fi
    
    # Rate limiting
    sleep 0.1
  done
  
  echo "Batch complete: $successful successful, $failed failed"
}

# Usage
if [ "$1" = "single" ]; then
  broadcast_with_retry && check_confirmation "$(echo "$RESULT" | jq -r '.txid')"
elif [ "$1" = "batch" ]; then
  shift
  batch_broadcast "$@"
else
  echo "Usage: $0 {single|batch} [tx_files...]"
fi

const TRON_API = 'https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY';

// Broadcast a signed transaction
async function broadcastTransaction(signedTransaction) {
  const response = await fetch(`${TRON_API}/wallet/broadcasttransaction`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(signedTransaction)
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return await response.json();
}

// Enhanced broadcast with monitoring and retry logic
async function broadcastWithMonitoring(signedTransaction, options = {}) {
  const {
    maxRetries = 3,
    retryDelay = 1000,
    confirmationTimeout = 30000
  } = options;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Broadcasting transaction (attempt ${attempt}/${maxRetries})...`);
      
      const result = await broadcastTransaction(signedTransaction);
      
      if (result.result) {
        console.log(`✓ Transaction broadcast successful: ${result.txid}`);
        
        // Optional: Wait for confirmation
        if (options.waitForConfirmation) {
          const confirmation = await waitForConfirmation(result.txid, confirmationTimeout);
          return { ...result, confirmation };
        }
        
        return result;
      } else {
        throw new Error(`Broadcast failed: ${result.message || 'Unknown error'}`);
      }
    } catch (error) {
      console.log(`✗ Attempt ${attempt} failed:`, error.message);
      
      if (attempt === maxRetries) {
        throw new Error(`Transaction broadcast failed after ${maxRetries} attempts: ${error.message}`);
      }
      
      // Exponential backoff
      await new Promise(resolve => setTimeout(resolve, retryDelay * Math.pow(2, attempt - 1)));
    }
  }
}

// Wait for transaction confirmation
async function waitForConfirmation(txId, timeout = 30000) {
  const startTime = Date.now();
  const checkInterval = 3000; // Check every 3 seconds
  
  while (Date.now() - startTime < timeout) {
    try {
      const txInfo = await getTransactionInfo(txId);
      
      if (txInfo && txInfo.blockNumber) {
        return {
          confirmed: true,
          blockNumber: txInfo.blockNumber,
          confirmationTime: Date.now() - startTime,
          fee: txInfo.fee || 0
        };
      }
    } catch (error) {
      console.log('Checking confirmation...', error.message);
    }
    
    await new Promise(resolve => setTimeout(resolve, checkInterval));
  }
  
  return {
    confirmed: false,
    timeout: true,
    message: 'Transaction confirmation timeout'
  };
}

// Get transaction information for confirmation
async function getTransactionInfo(txId) {
  const response = await fetch(`${TRON_API}/wallet/gettransactionbyid`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ value: txId, visible: true })
  });
  
  return await response.json();
}

// Batch transaction broadcasting
async function broadcastBatch(signedTransactions, options = {}) {
  const { 
    concurrency = 5,
    delayBetween = 100 
  } = options;
  
  const results = [];
  
  // Process in chunks to respect rate limits
  for (let i = 0; i < signedTransactions.length; i += concurrency) {
    const chunk = signedTransactions.slice(i, i + concurrency);
    
    const chunkPromises = chunk.map(async (tx, index) => {
      try {
        // Stagger requests slightly
        await new Promise(resolve => setTimeout(resolve, index * delayBetween));
        
        const result = await broadcastWithMonitoring(tx);
        return {
          success: true,
          txId: tx.txID,
          result: result,
          index: i + index
        };
      } catch (error) {
        return {
          success: false,
          txId: tx.txID,
          error: error.message,
          index: i + index
        };
      }
    });
    
    const chunkResults = await Promise.allSettled(chunkPromises);
    results.push(...chunkResults.map(r => r.status === 'fulfilled' ? r.value : r.reason));
    
    // Delay between chunks
    if (i + concurrency < signedTransactions.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetween * concurrency));
    }
  }
  
  return {
    total: signedTransactions.length,
    successful: results.filter(r => r.success).length,
    failed: results.filter(r => !r.success).length,
    results: results
  };
}

// Complete transaction flow example
async function sendTRXTransaction(fromAddress, toAddress, amount, privateKey) {
  try {
    // Step 1: Create transaction
    console.log('Creating transaction...');
    const transaction = await createTransaction(fromAddress, toAddress, amount);
    
    // Step 2: Sign transaction (simplified - use proper signing library)
    console.log('Signing transaction...');
    const signedTransaction = await signTransaction(transaction, privateKey);
    
    // Step 3: Broadcast transaction
    console.log('Broadcasting transaction...');
    const result = await broadcastWithMonitoring(signedTransaction, {
      waitForConfirmation: true,
      maxRetries: 3
    });
    
    console.log('Transaction completed:', result);
    return result;
    
  } catch (error) {
    console.error('Transaction failed:', error.message);
    throw error;
  }
}

// Usage examples
(async () => {
  try {
    // Single transaction broadcast
    const signedTx = {
      // ... signed transaction object
    };
    
    const result = await broadcastWithMonitoring(signedTx, {
      waitForConfirmation: true,
      maxRetries: 3
    });
    console.log('Broadcast result:', result);
    
    // Batch broadcasting
    const signedTransactions = [
      // ... array of signed transactions
    ];
    
    const batchResult = await broadcastBatch(signedTransactions, {
      concurrency: 3,
      delayBetween: 200
    });
    console.log(`Batch complete: ${batchResult.successful}/${batchResult.total} successful`);
    
  } catch (error) {
    console.error('Error:', error);
  }
})();

import requests
import json
import time
import asyncio
import aiohttp
from typing import Dict, List, Optional

class TronBroadcaster:
    def __init__(self, api_key: str):
        self.base_url = f"https://api-tron-mainnet.n.dwellir.com/{api_key}"
        self.headers = {
            'Content-Type': 'application/json'
        }
    
    def broadcast_transaction(self, signed_transaction: Dict) -> Dict:
        """Broadcast a signed transaction to TRON network"""
        url = f"{self.base_url}/wallet/broadcasttransaction"
        
        response = requests.post(url, headers=self.headers, json=signed_transaction)
        response.raise_for_status()
        
        return response.json()
    
    def broadcast_with_monitoring(self, signed_transaction: Dict, 
                                 max_retries: int = 3,
                                 retry_delay: int = 1000,
                                 wait_for_confirmation: bool = False,
                                 confirmation_timeout: int = 30000) -> Dict:
        """Broadcast transaction with retry logic and optional confirmation"""
        
        for attempt in range(1, max_retries + 1):
            try:
                print(f"Broadcasting transaction (attempt {attempt}/{max_retries})...")
                
                result = self.broadcast_transaction(signed_transaction)
                
                if result.get('result'):
                    print(f"✓ Transaction broadcast successful: {result.get('txid')}")
                    
                    # Optional: Wait for confirmation
                    if wait_for_confirmation:
                        confirmation = self.wait_for_confirmation(
                            result['txid'], 
                            confirmation_timeout
                        )
                        result['confirmation'] = confirmation
                    
                    return result
                else:
                    raise Exception(f"Broadcast failed: {result.get('message', 'Unknown error')}")
                    
            except Exception as e:
                print(f"✗ Attempt {attempt} failed: {str(e)}")
                
                if attempt == max_retries:
                    raise Exception(f"Transaction broadcast failed after {max_retries} attempts: {str(e)}")
                
                # Exponential backoff
                time.sleep((retry_delay / 1000) * (2 ** (attempt - 1)))
        
        raise Exception("Unexpected error in broadcast_with_monitoring")
    
    def wait_for_confirmation(self, tx_id: str, timeout: int = 30000) -> Dict:
        """Wait for transaction confirmation"""
        start_time = time.time() * 1000
        check_interval = 3000  # Check every 3 seconds
        
        while (time.time() * 1000) - start_time < timeout:
            try:
                tx_info = self.get_transaction_info(tx_id)
                
                if tx_info and tx_info.get('blockNumber'):
                    return {
                        'confirmed': True,
                        'block_number': tx_info['blockNumber'],
                        'confirmation_time': (time.time() * 1000) - start_time,
                        'fee': tx_info.get('fee', 0)
                    }
            except Exception as e:
                print(f"Checking confirmation... {str(e)}")
            
            time.sleep(check_interval / 1000)
        
        return {
            'confirmed': False,
            'timeout': True,
            'message': 'Transaction confirmation timeout'
        }
    
    def get_transaction_info(self, tx_id: str) -> Dict:
        """Get transaction information for confirmation"""
        url = f"{self.base_url}/wallet/gettransactionbyid"
        
        payload = {
            'value': tx_id,
            'visible': True
        }
        
        response = requests.post(url, headers=self.headers, json=payload)
        response.raise_for_status()
        
        return response.json()
    
    def broadcast_batch(self, signed_transactions: List[Dict], 
                       concurrency: int = 5,
                       delay_between: float = 0.1) -> Dict:
        """Broadcast multiple transactions in batch"""
        results = []
        
        # Process in chunks to respect rate limits
        for i in range(0, len(signed_transactions), concurrency):
            chunk = signed_transactions[i:i + concurrency]
            
            chunk_results = []
            for index, tx in enumerate(chunk):
                try:
                    # Stagger requests slightly
                    time.sleep(index * delay_between)
                    
                    result = self.broadcast_with_monitoring(tx)
                    chunk_results.append({
                        'success': True,
                        'tx_id': tx['txID'],
                        'result': result,
                        'index': i + index
                    })
                except Exception as e:
                    chunk_results.append({
                        'success': False,
                        'tx_id': tx['txID'],
                        'error': str(e),
                        'index': i + index
                    })
            
            results.extend(chunk_results)
            
            # Delay between chunks
            if i + concurrency < len(signed_transactions):
                time.sleep(delay_between * concurrency)
        
        successful = [r for r in results if r['success']]
        failed = [r for r in results if not r['success']]
        
        return {
            'total': len(signed_transactions),
            'successful': len(successful),
            'failed': len(failed),
            'results': results
        }
    
    async def broadcast_async(self, signed_transactions: List[Dict], 
                             concurrency: int = 5) -> Dict:
        """Asynchronous batch broadcasting"""
        semaphore = asyncio.Semaphore(concurrency)
        
        async def broadcast_single(session, tx, index):
            async with semaphore:
                try:
                    async with session.post(
                        f"{self.base_url}/wallet/broadcasttransaction",
                        headers=self.headers,
                        json=tx
                    ) as response:
                        result = await response.json()
                        return {
                            'success': True,
                            'tx_id': tx['txID'],
                            'result': result,
                            'index': index
                        }
                except Exception as e:
                    return {
                        'success': False,
                        'tx_id': tx['txID'],
                        'error': str(e),
                        'index': index
                    }
        
        async with aiohttp.ClientSession() as session:
            tasks = [
                broadcast_single(session, tx, i) 
                for i, tx in enumerate(signed_transactions)
            ]
            results = await asyncio.gather(*tasks, return_exceptions=True)
        
        successful = [r for r in results if isinstance(r, dict) and r.get('success')]
        failed = [r for r in results if isinstance(r, dict) and not r.get('success')]
        
        return {
            'total': len(signed_transactions),
            'successful': len(successful),
            'failed': len(failed),
            'results': results
        }

# Usage examples
if __name__ == "__main__":
    broadcaster = TronBroadcaster('YOUR_API_KEY')
    
    # Example signed transaction
    signed_tx = {
        "txID": "94eea63bb6774c8fc4f4c9d1b62c1e8c2f7c8c2e4d3a2b1c0d9e8f7a6b5c4d3e2f1",
        "raw_data": {
            # ... transaction data
        },
        "signature": ["c8f8f8e8d8c8b8a898887878686858484838281807060504030201"]
    }
    
    try:
        # Single transaction broadcast
        result = broadcaster.broadcast_with_monitoring(
            signed_tx,
            wait_for_confirmation=True,
            max_retries=3
        )
        print(f"Broadcast result: {result}")
        
        # Batch broadcasting
        signed_transactions = [signed_tx]  # List of signed transactions
        
        batch_result = broadcaster.broadcast_batch(
            signed_transactions,
            concurrency=3,
            delay_between=0.2
        )
        print(f"Batch complete: {batch_result['successful']}/{batch_result['total']} successful")
        
    except Exception as e:
        print(f"Error: {e}")