Datasets:

berryccc1
/

EVM-QuestBench

	"""
	ERC20 Burn Validator

	Validates that ERC20 tokens were successfully burned (destroyed) by transferring to zero address
	"""

	from typing import Dict, Any


	class ERC20BurnValidator:
	"""Validator for ERC20 token burn transactions"""

	def __init__(self, token_address: str, amount: float, token_decimals: int = 18):
	"""
	Initialize validator

	Args:
	token_address: ERC20 token contract address
	amount: Expected burn amount (in tokens, not wei)
	token_decimals: Token decimal places (default 18)
	"""
	from decimal import Decimal

	self.expected_token = token_address.lower()
	# Convert amount to smallest unit (wei equivalent for tokens)
	self.expected_amount = int(Decimal(str(amount)) * Decimal(10**token_decimals))
	self.token_decimals = token_decimals
	self.max_score = 100

	def validate(
	self,
	tx: Dict[str, Any],
	receipt: Dict[str, Any],
	state_before: Dict[str, Any],
	state_after: Dict[str, Any]
	) -> Dict[str, Any]:
	"""
	Validate the transaction execution results

	Args:
	tx: Transaction object
	receipt: Transaction receipt
	state_before: Blockchain state before transaction
	state_after: Blockchain state after transaction

	Returns:
	Validation results including score and details
	"""
	score = 0
	details = {}
	checks = []

	# Check 1: Transaction success (30 points)
	tx_success = receipt.get('status') == 1
	if tx_success:
	score += 30
	checks.append({
	'name': 'Transaction Success',
	'passed': True,
	'points': 30,
	'message': 'Transaction executed successfully'
	})
	else:
	checks.append({
	'name': 'Transaction Success',
	'passed': False,
	'points': 0,
	'message': f"Transaction failed with status: {receipt.get('status')}"
	})
	return {
	'score': score,
	'max_score': self.max_score,
	'passed': False,
	'checks': checks,
	'details': details
	}

	# Check 2: Token contract address correct (20 points)
	actual_to = tx.get('to', '').lower()
	contract_correct = actual_to == self.expected_token

	if contract_correct:
	score += 20
	checks.append({
	'name': 'Token Contract',
	'passed': True,
	'points': 20,
	'message': f'Correct token contract: {self.expected_token}'
	})
	else:
	checks.append({
	'name': 'Token Contract',
	'passed': False,
	'points': 0,
	'message': f'Expected: {self.expected_token}, Got: {actual_to}'
	})

	details['expected_token'] = self.expected_token
	details['actual_to'] = actual_to

	# Check 3: Function signature and zero address (20 points)
	# ERC20 transfer function selector: 0xa9059cbb (keccak256("transfer(address,uint256)"))
	# Zero address for burn: 0x0000000000000000000000000000000000000000
	tx_data = tx.get('data', '0x')

	if tx_data and len(tx_data) >= 10:
	function_selector = tx_data[:10].lower()
	expected_selector = '0xa9059cbb' # transfer(address,uint256)

	if function_selector == expected_selector:
	# Check if recipient is zero address (burn address)
	if len(tx_data) >= 74: # 0x(2) + selector(8) + address(64) = 74
	to_address_hex = tx_data[10:74]
	to_address = '0x' + to_address_hex[-40:].lower()
	zero_address = '0x0000000000000000000000000000000000000000'

	if to_address == zero_address:
	score += 20
	checks.append({
	'name': 'Function Signature & Zero Address',
	'passed': True,
	'points': 20,
	'message': 'Correct transfer to zero address (burn)'
	})
	else:
	checks.append({
	'name': 'Function Signature & Zero Address',
	'passed': False,
	'points': 0,
	'message': f'Transfer to wrong address: {to_address}, expected zero address'
	})

	details['transfer_to'] = to_address

	# Decode amount from data
	try:
	if len(tx_data) >= 138: # 0x(2) + selector(8) + address(64) + amount(64) = 138
	amount_hex = tx_data[74:138]
	amount_value = int(amount_hex, 16)
	details['decoded_amount'] = amount_value
	except Exception as e:
	details['decode_error'] = str(e)
	else:
	checks.append({
	'name': 'Function Signature & Zero Address',
	'passed': False,
	'points': 0,
	'message': 'Transaction data too short to decode'
	})
	else:
	checks.append({
	'name': 'Function Signature & Zero Address',
	'passed': False,
	'points': 0,
	'message': f'Expected transfer function: {expected_selector}, Got: {function_selector}'
	})
	else:
	checks.append({
	'name': 'Function Signature & Zero Address',
	'passed': False,
	'points': 0,
	'message': 'No data field or too short'
	})

	details['function_selector'] = tx_data[:10] if tx_data else None

	# Check 4: Token balance decreased (30 points)
	balance_before = state_before.get('token_balance', 0)
	balance_after = state_after.get('token_balance', 0)
	balance_decrease = balance_before - balance_after

	# Allow small tolerance for potential rounding
	tolerance = int(self.expected_amount * 0.001) or 1
	balance_correct = abs(balance_decrease - self.expected_amount) <= tolerance

	if balance_correct:
	score += 30
	checks.append({
	'name': 'Token Balance Decrease',
	'passed': True,
	'points': 30,
	'message': f'Token balance decreased by {balance_decrease} ({balance_decrease / 10**self.token_decimals:.6f})'
	})
	else:
	checks.append({
	'name': 'Token Balance Decrease',
	'passed': False,
	'points': 0,
	'message': f'Expected decrease: {self.expected_amount}, Got: {balance_decrease}'
	})

	details['balance_before'] = balance_before
	details['balance_after'] = balance_after
	details['balance_decrease'] = balance_decrease
	details['expected_burn'] = self.expected_amount

	# Final result
	passed = score >= self.max_score * 0.8 # 80% threshold

	return {
	'score': score,
	'max_score': self.max_score,
	'passed': passed,
	'checks': checks,
	'details': details
	}