Datasets:

berryccc1
/

EVM-QuestBench

	"""
	ERC721 Transfer Validator

	Validates that an ERC721 NFT was successfully transferred
	"""

	from typing import Dict, Any


	class ERC721TransferValidator:
	"""Validator for ERC721 NFT transfer transactions"""

	def __init__(self, nft_address: str, to_address: str, token_id: int, **kwargs):
	"""
	Initialize validator

	Args:
	nft_address: ERC721 NFT contract address
	to_address: Expected recipient address
	token_id: NFT token ID that should be transferred
	"""
	if not nft_address:
	raise ValueError("nft_address is required but was None or empty")
	if not to_address:
	raise ValueError("to_address is required but was None or empty")

	self.expected_nft = nft_address.lower()
	self.expected_recipient = to_address.lower()
	self.token_id = token_id
	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: NFT contract address correct (20 points)
	actual_to = tx.get('to', '').lower()
	contract_correct = actual_to == self.expected_nft

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

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

	# Check 3: Function signature (20 points)
	# ERC721 transferFrom function selector: 0x23b872dd (keccak256("transferFrom(address,address,uint256)"))
	tx_data = tx.get('data', '0x')

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

	if function_selector == expected_selector:
	score += 20
	checks.append({
	'name': 'Function Signature',
	'passed': True,
	'points': 20,
	'message': 'Correct ERC721 transferFrom function signature'
	})

	# Decode parameters from data
	try:
	if len(tx_data) >= 202: # 0x(2) + selector(8) + from(64) + to(64) + tokenId(64) = 202
	from_hex = tx_data[10:74] # Next 64 chars (32 bytes)
	to_hex = tx_data[74:138] # Next 64 chars (32 bytes)
	token_id_hex = tx_data[138:202] # Next 64 chars (32 bytes)

	# Extract addresses (last 40 hex chars of the 64 char field)
	from_addr = '0x' + from_hex[-40:].lower()
	to_addr = '0x' + to_hex[-40:].lower()
	token_id_value = int(token_id_hex, 16)

	details['decoded_from'] = from_addr
	details['decoded_to'] = to_addr
	details['decoded_token_id'] = token_id_value

	# Verify recipient address
	if to_addr == self.expected_recipient:
	details['recipient_address_correct'] = True
	else:
	details['recipient_address_correct'] = False
	details['recipient_mismatch'] = f'Expected: {self.expected_recipient}, Got: {to_addr}'

	# Verify token ID
	if token_id_value == self.token_id:
	details['token_id_correct'] = True
	else:
	details['token_id_correct'] = False
	details['token_id_mismatch'] = f'Expected: {self.token_id}, Got: {token_id_value}'

	except Exception as e:
	details['decode_error'] = str(e)
	else:
	checks.append({
	'name': 'Function Signature',
	'passed': False,
	'points': 0,
	'message': f'Expected: {expected_selector}, Got: {function_selector}'
	})
	else:
	checks.append({
	'name': 'Function Signature',
	'passed': False,
	'points': 0,
	'message': 'No data field or too short'
	})

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

	# Check 4: NFT ownership transferred (30 points)
	# Check if the NFT owner changed from agent to recipient
	owner_before = state_before.get('nft_owner', '').lower()
	owner_after = state_after.get('nft_owner', '').lower()

	ownership_transferred = owner_after == self.expected_recipient

	if ownership_transferred:
	score += 30
	checks.append({
	'name': 'NFT Ownership Transferred',
	'passed': True,
	'points': 30,
	'message': f'NFT #{self.token_id} ownership transferred to {self.expected_recipient}'
	})
	else:
	checks.append({
	'name': 'NFT Ownership Transferred',
	'passed': False,
	'points': 0,
	'message': f'Expected owner: {self.expected_recipient}, Actual owner: {owner_after}'
	})

	details['owner_before'] = owner_before
	details['owner_after'] = owner_after
	details['expected_owner'] = self.expected_recipient
	details['token_id'] = self.token_id

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