Datasets:

berryccc1
/

EVM-QuestBench

	"""
	BNB Transfer with Message Validator

	Validates that a BNB transfer transaction includes a text message in the data field
	"""

	from typing import Dict, Any


	class BNBTransferWithMessageValidator:
	"""Validator for BNB transfers with attached text messages"""

	def __init__(self, to_address: str, amount: float, message: str):
	"""
	Initialize validator

	Args:
	to_address: Expected recipient address
	amount: Expected transfer amount in BNB (float)
	message: Expected message text
	"""
	from decimal import Decimal

	self.expected_to = to_address.lower()
	# Use Decimal for precise BNB to wei conversion
	self.expected_amount = int(Decimal(str(amount)) * Decimal(10**18))
	self.expected_message = message
	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 (20 points)
	tx_success = receipt.get('status') == 1
	if tx_success:
	score += 20
	checks.append({
	'name': 'Transaction Success',
	'passed': True,
	'points': 20,
	'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
	}

	# Use the transaction object and receipt
	tx_object = tx
	tx_receipt = receipt

	# Check 2: Recipient address (20 points)
	actual_to = tx_object.get('to', '').lower()
	to_correct = actual_to == self.expected_to

	if to_correct:
	score += 20
	checks.append({
	'name': 'Recipient Address',
	'passed': True,
	'points': 20,
	'message': f'Correct recipient: {self.expected_to}'
	})
	else:
	checks.append({
	'name': 'Recipient Address',
	'passed': False,
	'points': 0,
	'message': f'Expected: {self.expected_to}, Got: {actual_to}'
	})

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

	# Check 3: Transfer amount (20 points)
	actual_value = int(tx_object.get('value', 0))
	amount_correct = actual_value == self.expected_amount

	if amount_correct:
	score += 20
	checks.append({
	'name': 'Transfer Amount',
	'passed': True,
	'points': 20,
	'message': f'Correct amount: {self.expected_amount} wei'
	})
	else:
	checks.append({
	'name': 'Transfer Amount',
	'passed': False,
	'points': 0,
	'message': f'Expected: {self.expected_amount} wei, Got: {actual_value} wei'
	})

	details['expected_amount'] = self.expected_amount
	details['actual_amount'] = actual_value

	# Check 4: Message in transaction data (30 points)
	tx_data = tx_object.get('data', '0x')

	# Decode the data field
	message_found = False
	message_correct = False
	decoded_message = None

	if tx_data and tx_data != '0x':
	try:
	# Remove '0x' prefix and convert hex to bytes
	data_bytes = bytes.fromhex(tx_data[2:])

	# Try to decode as UTF-8
	try:
	decoded_message = data_bytes.decode('utf-8')
	message_found = True

	# Check if expected message is in the decoded data
	if self.expected_message in decoded_message:
	message_correct = True
	elif decoded_message.strip() == self.expected_message.strip():
	message_correct = True
	except UnicodeDecodeError:
	# Try to decode as ASCII
	try:
	decoded_message = data_bytes.decode('ascii', errors='ignore')
	message_found = True
	if self.expected_message in decoded_message:
	message_correct = True
	except:
	pass
	except Exception as e:
	details['decode_error'] = str(e)

	if message_correct:
	score += 30
	checks.append({
	'name': 'Message in Data Field',
	'passed': True,
	'points': 30,
	'message': f'Message correctly encoded: "{self.expected_message}"'
	})
	elif message_found:
	# Message found but not exact match - no partial credit for consistency
	checks.append({
	'name': 'Message in Data Field',
	'passed': False,
	'points': 0,
	'message': f'Message found but not exact match. Expected: "{self.expected_message}", Got: "{decoded_message}"'
	})
	else:
	checks.append({
	'name': 'Message in Data Field',
	'passed': False,
	'points': 0,
	'message': f'No message found in transaction data. Expected: "{self.expected_message}"'
	})

	details['expected_message'] = self.expected_message
	details['tx_data'] = tx_data
	details['decoded_message'] = decoded_message

	# Check 5: Balance change (10 points)
	balance_before = state_before.get('balance', 0)
	balance_after = state_after.get('balance', 0)
	gas_used = tx_receipt.get('gasUsed', 0)
	gas_price = tx_receipt.get('effectiveGasPrice', 0)
	gas_cost = gas_used * gas_price

	expected_balance = balance_before - self.expected_amount - gas_cost
	balance_diff = abs(balance_after - expected_balance)

	# Allow 0.1% tolerance for rounding errors
	tolerance = max(int(self.expected_amount * 0.001), 1)
	balance_correct = balance_diff <= tolerance

	if balance_correct:
	score += 10
	checks.append({
	'name': 'Balance Change',
	'passed': True,
	'points': 10,
	'message': 'Balance decreased correctly (including gas)'
	})
	else:
	checks.append({
	'name': 'Balance Change',
	'passed': False,
	'points': 0,
	'message': f'Balance mismatch. Expected: {expected_balance}, Got: {balance_after}, Diff: {balance_diff}'
	})

	details['balance_before'] = balance_before
	details['balance_after'] = balance_after
	details['gas_cost'] = gas_cost
	details['expected_balance'] = expected_balance

	# 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
	}