wallet/broadcasthex - Broadcast Raw Transaction...

class TransactionBroadcaster {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = `https://api-tron-mainnet.n.dwellir.com/${apiKey}`;
  }

  // Broadcast with retry logic
  async broadcastWithRetry(hexTx, maxRetries = 3) {
    let lastError;
    
    for (let i = 0; i < maxRetries; i++) {
      try {
        const response = await fetch(`${this.baseUrl}/wallet/broadcasthex`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ transaction: hexTx })
        });
        
        const result = await response.json();
        
        if (result.result) {
          return {
            success: true,
            txid: result.txid,
            attempts: i + 1
          };
        }
        
        // Check if error is retryable
        if (result.code === 'DUP_TRANSACTION_ERROR') {
          // Transaction already broadcast, consider it success
          return {
            success: true,
            message: 'Transaction already broadcast',
            attempts: i + 1
          };
        }
        
        if (result.code === 'TRANSACTION_EXPIRATION_ERROR') {
          // Don't retry expired transactions
          throw new Error('Transaction expired, cannot retry');
        }
        
        lastError = result;
        
        // Wait before retry
        await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
        
      } catch (error) {
        lastError = error;
      }
    }
    
    return {
      success: false,
      error: lastError,
      attempts: maxRetries
    };
  }

  // Validate hex transaction before broadcasting
  validateHexTransaction(hexTx) {
    try {
      // Check if valid hex
      if (!/^[0-9a-fA-F]+$/.test(hexTx)) {
        return { valid: false, error: 'Invalid hex format' };
      }
      
      // Check minimum length (rough estimate)
      if (hexTx.length < 100) {
        return { valid: false, error: 'Transaction too short' };
      }
      
      // Check maximum length
      if (hexTx.length > 65536 * 2) { // 64KB in hex
        return { valid: false, error: 'Transaction too large' };
      }
      
      return { valid: true };
      
    } catch (error) {
      return { valid: false, error: error.message };
    }
  }

  // Batch broadcast multiple transactions
  async batchBroadcast(hexTransactions) {
    const results = [];
    
    for (const hexTx of hexTransactions) {
      // Validate before broadcasting
      const validation = this.validateHexTransaction(hexTx);
      
      if (!validation.valid) {
        results.push({
          success: false,
          error: validation.error
        });
        continue;
      }
      
      // Broadcast with retry
      const result = await this.broadcastWithRetry(hexTx);
      results.push(result);
      
      // Small delay between broadcasts
      await new Promise(resolve => setTimeout(resolve, 100));
    }
    
    return results;
  }
}

// Example usage
async function advancedBroadcast() {
  const broadcaster = new TransactionBroadcaster('YOUR_API_KEY');
  
  // Single transaction with retry
  const txHex = 'YOUR_SIGNED_TX_HEX';
  const result = await broadcaster.broadcastWithRetry(txHex);
  
  if (result.success) {
    console.log(`Transaction broadcast after ${result.attempts} attempts`);
    console.log(`TX ID: ${result.txid}`);
  } else {
    console.error('Broadcast failed:', result.error);
  }
  
  // Batch broadcast
  const transactions = [
    'SIGNED_TX_HEX_1',
    'SIGNED_TX_HEX_2',
    'SIGNED_TX_HEX_3'
  ];
  
  const batchResults = await broadcaster.batchBroadcast(transactions);
  
  batchResults.forEach((result, index) => {
    if (result.success) {
      console.log(`TX ${index + 1}: Success - ${result.txid}`);
    } else {
      console.log(`TX ${index + 1}: Failed - ${result.error}`);
    }
  });
}