Datasets:

berryccc1
/

EVM-QuestBench

	"""
	ERC20 FlashLoan Validator

	Validate flashloan operation.
	"""

	from typing import Dict, Any


	class ERC20FlashLoanValidator:
	"""Validate ERC20 flashloan operation"""

	def __init__(
	self,
	flashloan_contract_address: str,
	token_address: str,
	amount: float,
	token_decimals: int,
	fee_percentage: float
	):
	self.flashloan_contract = flashloan_contract_address.lower()
	self.token_address = token_address.lower()
	self.amount = amount
	self.token_decimals = token_decimals
	self.fee_percentage = fee_percentage

	# Calculate fee (unit: token smallest unit)
	amount_smallest = int(amount * (10 ** token_decimals))
	self.expected_fee = int(amount_smallest * fee_percentage / 100)

	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 flashloan transaction

	Args:
	tx: Transaction object
	receipt: Transaction receipt
	state_before: State before transaction
	state_after: State after transaction

	Returns:
	Validation result dictionary

	Checks:
	1. Transaction executed successfully (30%)
	2. Correct contract called: Flashloan contract (20%)
	3. Used function: executeFlashLoan function (20%)
	4. Paid correct fee (30%)
	"""
	checks = []
	total_score = 0

	# 1. Validate transaction success (30 points)
	tx_status = receipt.get('status', 0)
	if tx_status == 1:
	checks.append({
	'name': 'Transaction Success',
	'passed': True,
	'message': 'Transaction executed successfully',
	'score': 30
	})
	total_score += 30
	else:
	checks.append({
	'name': 'Transaction Success',
	'passed': False,
	'message': f'Transaction failed with status: {tx_status}',
	'score': 30
	})
	# If transaction failed, return directly
	return {
	'passed': False,
	'score': 0,
	'max_score': self.max_score,
	'checks': checks,
	'details': {
	'flashloan_contract': self.flashloan_contract,
	'token_address': self.token_address,
	'amount': self.amount,
	'expected_fee': self.expected_fee / (10 ** self.token_decimals),
	'transaction_status': tx_status
	}
	}

	# 2. ValidateCorrect contract called: Flashloan contract (20 points)
	tx_to = tx.get('to', '').lower()
	if tx_to == self.flashloan_contract:
	checks.append({
	'name': 'Contract Address',
	'passed': True,
	'message': f'Correct flash loan contract: {tx_to}',
	'score': 20
	})
	total_score += 20
	else:
	checks.append({
	'name': 'Contract Address',
	'passed': False,
	'message': f'Wrong contract. Expected: {self.flashloan_contract}, Got: {tx_to}',
	'score': 20
	})

	# 3. ValidateUsed function: executeFlashLoan function (20 points)
	tx_data = tx.get('data', '') or tx.get('input', '')

	if isinstance(tx_data, bytes):
	tx_data = tx_data.hex()
	if isinstance(tx_data, str) and tx_data.startswith('0x'):
	tx_data = tx_data[2:]

	# executeFlashLoan(address,uint256) function selector
	# First 4 bytes of keccak256("executeFlashLoan(address,uint256)")
	expected_selector = '0x6065c245'
	actual_selector = 'N/A'

	if len(tx_data) >= 8:
	actual_selector = '0x' + tx_data[:8]

	if actual_selector.lower() == expected_selector.lower():
	checks.append({
	'name': 'Function Signature',
	'passed': True,
	'message': f'Correct executeFlashLoan selector: {actual_selector}',
	'score': 20,
	'details': {
	'expected': expected_selector,
	'actual': actual_selector
	}
	})
	total_score += 20
	else:
	checks.append({
	'name': 'Function Signature',
	'passed': False,
	'message': f'Incorrect function selector. Expected executeFlashLoan ({expected_selector}), got {actual_selector}',
	'score': 20,
	'details': {
	'expected': expected_selector,
	'actual': actual_selector
	}
	})
	else:
	checks.append({
	'name': 'Function Signature',
	'passed': False,
	'message': 'Transaction data too short or missing',
	'score': 20
	})

	# 4. Validate fee payment (30 points)
	# Flashloan causes user balance to decrease by fee amount
	balance_before = state_before.get('token_balance', 0)
	balance_after = state_after.get('token_balance', 0)

	balance_decrease = balance_before - balance_after

	# Allow some error (due to precision issues)
	fee_tolerance = max(1, self.expected_fee // 100) # 1% tolerance

	fee_check_passed = abs(balance_decrease - self.expected_fee) <= fee_tolerance

	if fee_check_passed:
	checks.append({
	'name': 'Fee Payment',
	'passed': True,
	'message': f'Flash loan fee paid correctly: {balance_decrease / (10 ** self.token_decimals):.6f} tokens',
	'score': 30,
	'details': {
	'balance_before': balance_before / (10 ** self.token_decimals),
	'balance_after': balance_after / (10 ** self.token_decimals),
	'balance_decrease': balance_decrease / (10 ** self.token_decimals),
	'expected_fee': self.expected_fee / (10 ** self.token_decimals),
	'fee_percentage': self.fee_percentage
	}
	})
	total_score += 30
	else:
	checks.append({
	'name': 'Fee Payment',
	'passed': False,
	'message': f'Fee mismatch. Expected: {self.expected_fee / (10 self.token_decimals):.6f}, Actual: {balance_decrease / (10 self.token_decimals):.6f}',
	'score': 30,
	'details': {
	'balance_before': balance_before / (10 ** self.token_decimals),
	'balance_after': balance_after / (10 ** self.token_decimals),
	'balance_decrease': balance_decrease / (10 ** self.token_decimals),
	'expected_fee': self.expected_fee / (10 ** self.token_decimals),
	'fee_percentage': self.fee_percentage
	}
	})

	# Aggregate results
	all_passed = all(check['passed'] for check in checks)

	return {
	'passed': all_passed,
	'score': total_score,
	'max_score': self.max_score,
	'checks': checks,
	'details': {
	'flashloan_contract': self.flashloan_contract,
	'token_address': self.token_address,
	'amount': self.amount,
	'expected_fee': self.expected_fee / (10 ** self.token_decimals),
	'balance_before': balance_before / (10 ** self.token_decimals),
	'balance_after': balance_after / (10 ** self.token_decimals),
	'balance_decrease': balance_decrease / (10 ** self.token_decimals),
	'actual_selector': actual_selector
	}
	}