pip install web3

pip install pandas numpy

pip install requests

from web3 import Web3
import json

# Infura 엔드포인트 설정
INFURA_URL = "https://mainnet.infura.io/v3/YOUR_PROJECT_ID"

# Web3 인스턴스 생성
w3 = Web3(Web3.HTTPProvider(INFURA_URL))

# 연결 확인
if w3.is_connected():
    print("✅ 이더리움 메인넷에 성공적으로 연결되었습니다!")
    print(f"현재 블록 높이: {w3.eth.block_number}")
else:
    print("❌ 연결 실패! API 키를 확인해주세요.")

def get_block_info(block_number):
    """
    특정 블록의 상세 정보를 가져오는 함수
    """
    try:
        # 블록 정보 조회
        block = w3.eth.get_block(block_number, full_transactions=True)
        
        block_info = {
            'block_number': block['number'],
            'timestamp': block['timestamp'],
            'hash': block['hash'].hex(),
            'parent_hash': block['parentHash'].hex(),
            'miner': block['miner'],
            'difficulty': block['difficulty'],
            'total_difficulty': block['totalDifficulty'],
            'size': block['size'],
            'gas_used': block['gasUsed'],
            'gas_limit': block['gasLimit'],
            'transaction_count': len(block['transactions'])
        }
        
        return block_info
    
    except Exception as e:
        print(f"❌ 블록 정보 조회 실패: {e}")
        return None

# 최신 블록 정보 가져오기
latest_block = w3.eth.block_number
block_data = get_block_info(latest_block)

if block_data:
    print(f"\n📦 블록 #{block_data['block_number']} 정보")
    print(f"⏰ 생성 시간: {block_data['timestamp']}")
    print(f"👷 채굴자: {block_data['miner']}")
    print(f"💼 거래 개수: {block_data['transaction_count']}")
    print(f"⛽ 사용된 가스: {block_data['gas_used']:,}")

def analyze_transactions(block_number):
    """
    블록 내 모든 거래를 분석하는 함수
    """
    block = w3.eth.get_block(block_number, full_transactions=True)
    transactions = []
    
    for tx in block['transactions']:
        # Wei를 Ether로 변환
        value_in_ether = w3.from_wei(tx['value'], 'ether')
        
        # 가스비 계산
        gas_price = w3.from_wei(tx['gasPrice'], 'gwei')
        
        tx_data = {
            'hash': tx['hash'].hex(),
            'from': tx['from'],
            'to': tx['to'] if tx['to'] else 'Contract Creation',
            'value': float(value_in_ether),
            'gas': tx['gas'],
            'gas_price': float(gas_price),
            'nonce': tx['nonce'],
            'transaction_index': tx['transactionIndex']
        }
        
        transactions.append(tx_data)
    
    return transactions

# 거래 분석 실행
latest_block = w3.eth.block_number
transactions = analyze_transactions(latest_block)

print(f"\n💼 블록 #{latest_block}의 거래 분석")
print(f"총 거래 수: {len(transactions)}")

# 거래량 통계
total_value = sum(tx['value'] for tx in transactions)
avg_gas_price = sum(tx['gas_price'] for tx in transactions) / len(transactions) if transactions else 0

print(f"💰 총 거래량: {total_value:.4f} ETH")
print(f"⛽ 평균 가스 가격: {avg_gas_price:.2f} Gwei")

# 상위 5개 거래 출력
print("\n🔝 상위 5개 거래:")
sorted_txs = sorted(transactions, key=lambda x: x['value'], reverse=True)[:5]
for i, tx in enumerate(sorted_txs, 1):
    print(f"{i}. {tx['value']:.4f} ETH - {tx['hash'][:10]}...")

import pandas as pd
from datetime import datetime

def create_transaction_dataframe(start_block, end_block):
    """
    여러 블록의 거래 데이터를 DataFrame으로 생성
    """
    all_transactions = []
    
    print(f"📥 블록 {start_block}부터 {end_block}까지 데이터 수집 중...")
    
    for block_num in range(start_block, end_block + 1):
        try:
            block = w3.eth.get_block(block_num, full_transactions=True)
            block_timestamp = datetime.fromtimestamp(block['timestamp'])
            
            for tx in block['transactions']:
                tx_data = {
                    'block_number': block_num,
                    'timestamp': block_timestamp,
                    'tx_hash': tx['hash'].hex(),
                    'from_address': tx['from'],
                    'to_address': tx['to'] if tx['to'] else 'Contract',
                    'value_eth': float(w3.from_wei(tx['value'], 'ether')),
                    'gas_price_gwei': float(w3.from_wei(tx['gasPrice'], 'gwei')),
                    'gas_used': tx['gas'],
                    'tx_fee_eth': float(w3.from_wei(tx['gas'] * tx['gasPrice'], 'ether'))
                }
                all_transactions.append(tx_data)
            
            if block_num % 10 == 0:
                print(f"✅ 블록 {block_num} 처리 완료")
                
        except Exception as e:
            print(f"❌ 블록 {block_num} 처리 실패: {e}")
            continue
    
    df = pd.DataFrame(all_transactions)
    return df

# 최근 50개 블록 분석
latest = w3.eth.block_number
df_transactions = create_transaction_dataframe(latest - 50, latest)

print(f"\n📊 수집된 데이터: {len(df_transactions)} 건")
print("\n데이터 미리보기:")
print(df_transactions.head())

# 기본 통계 정보
print("\n📈 거래 금액 통계")
print(df_transactions['value_eth'].describe())

print("\n⛽ 가스 가격 통계")
print(df_transactions['gas_price_gwei'].describe())

# 시간대별 거래량 분석
df_transactions['hour'] = df_transactions['timestamp'].dt.hour
hourly_stats = df_transactions.groupby('hour').agg({
    'value_eth': ['sum', 'mean', 'count'],
    'gas_price_gwei': 'mean'
}).round(4)

print("\n⏰ 시간대별 거래 패턴")
print(hourly_stats)

# 고액 거래 필터링
high_value_txs = df_transactions[df_transactions['value_eth'] > 10]
print(f"\n💎 10 ETH 이상 고액 거래: {len(high_value_txs)}건")
print(high_value_txs[['tx_hash', 'value_eth', 'from_address', 'to_address']].head())

# 가장 활발한 주소 찾기
top_senders = df_transactions['from_address'].value_counts().head(10)
print("\n🔥 가장 활발한 송신 주소 TOP 10")
for i, (address, count) in enumerate(top_senders.items(), 1):
    print(f"{i}. {address}: {count}건")

# 컨트랙트 생성 거래 분석
contract_creations = df_transactions[df_transactions['to_address'] == 'Contract']
print(f"\n🏗️ 스마트 컨트랙트 생성: {len(contract_creations)}건")

import matplotlib.pyplot as plt
import seaborn as sns

# 한글 폰트 설정 (선택사항)
plt.rcParams['font.family'] = 'DejaVu Sans'
plt.rcParams['axes.unicode_minus'] = False

# 스타일 설정
sns.set_style("whitegrid")
plt.figure(figsize=(15, 10))

# 1. 시간대별 거래량 추이
plt.subplot(2, 2, 1)
hourly_volume = df_transactions.groupby('hour')['value_eth'].sum()
plt.plot(hourly_volume.index, hourly_volume.values, marker='o', linewidth=2, color='#667eea')
plt.title('시간대별 총 거래량', fontsize=14, fontweight='bold')
plt.xlabel('시간 (Hour)')
plt.ylabel('거래량 (ETH)')
plt.grid(True, alpha=0.3)

# 2. 가스 가격 분포
plt.subplot(2, 2, 2)
plt.hist(df_transactions['gas_price_gwei'], bins=50, color='#764ba2', alpha=0.7, edgecolor='black')
plt.title('가스 가격 분포', fontsize=14, fontweight='bold')
plt.xlabel('가스 가격 (Gwei)')
plt.ylabel('빈도')
plt.grid(True, alpha=0.3)

# 3. 거래 금액 분포 (로그 스케일)
plt.subplot(2, 2, 3)
value_data = df_transactions[df_transactions['value_eth'] > 0]['value_eth']
plt.hist(value_data, bins=50, color='#22c55e', alpha=0.7, edgecolor='black')
plt.yscale('log')
plt.title('거래 금액 분포 (로그 스케일)', fontsize=14, fontweight='bold')
plt.xlabel('거래 금액 (ETH)')
plt.ylabel('빈도 (로그)')
plt.grid(True, alpha=0.3)

# 4. 블록별 거래 수
plt.subplot(2, 2, 4)
block_tx_count = df_transactions.groupby('block_number').size()
plt.bar(block_tx_count.index, block_tx_count.values, color='#f59e0b', alpha=0.7)
plt.title('블록별 거래 수', fontsize=14, fontweight='bold')
plt.xlabel('블록 번호')
plt.ylabel('거래 수')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('blockchain_analysis.png', dpi=300, bbox_inches='tight')
print("\n📊 그래프가 'blockchain_analysis.png'로 저장되었습니다!")

import time
from datetime import datetime

class BlockchainMonitor:
    def __init__(self, w3_instance):
        self.w3 = w3_instance
        self.last_block = self.w3.eth.block_number
        self.alert_threshold = 100  # ETH 단위
        
    def check_new_blocks(self):
        """
        새로운 블록을 확인하고 분석
        """
        current_block = self.w3.eth.block_number
        
        if current_block > self.last_block:
            print(f"\n🆕 새로운 블록 발견: #{current_block}")
            
            # 새로운 블록들 처리
            for block_num in range(self.last_block + 1, current_block + 1):
                self.analyze_block(block_num)
            
            self.last_block = current_block
    
    def analyze_block(self, block_number):
        """
        블록 분석 및 알림
        """
        try:
            block = self.w3.eth.get_block(block_number, full_transactions=True)
            timestamp = datetime.fromtimestamp(block['timestamp'])
            
            print(f"\n📦 블록 #{block_number}")
            print(f"⏰ 시간: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
            print(f"💼 거래 수: {len(block['transactions'])}")
            
            # 고액 거래 감지
            for tx in block['transactions']:
                value_eth = float(self.w3.from_wei(tx['value'], 'ether'))
                
                if value_eth >= self.alert_threshold:
                    print(f"\n🚨 고액 거래 감지!")
                    print(f"   금액: {value_eth:.2f} ETH")
                    print(f"   From: {tx['from']}")
                    print(f"   To: {tx['to'] if tx['to'] else 'Contract Creation'}")
                    print(f"   Hash: {tx['hash'].hex()}")
                    
                    # 여기에 알림 로직 추가 (이메일, 텔레그램 등)
                    self.send_alert(tx, value_eth)
        
        except Exception as e:
            print(f"❌ 블록 분석 실패: {e}")
    
    def send_alert(self, transaction, value):
        """
        알림 전송 (예시)
        """
        # 실제로는 이메일, SMS, 텔레그램 등으로 알림 전송
        alert_message = f"고액 거래 감지: {value:.2f} ETH"
        print(f"📧 알림 전송: {alert_message}")
    
    def run(self, interval=12):
        """
        모니터링 실행 (interval: 확인 주기, 초 단위)
        """
        print("🔍 블록체인 모니터링 시작...")
        print(f"현재 블록: #{self.last_block}")
        print(f"알림 임계값: {self.alert_threshold} ETH")
        
        try:
            while True:
                self.check_new_blocks()
                time.sleep(interval)
        except KeyboardInterrupt:
            print("\n⏹️ 모니터링 종료")

# 모니터링 시작
monitor = BlockchainMonitor(w3)
monitor.alert_threshold = 50  # 50 ETH 이상 거래 알림

# 실행 (Ctrl+C로 종료)
# monitor.run(interval=15)  # 15초마다 확인

class AddressTracker:
    def __init__(self, w3_instance, target_address):
        self.w3 = w3_instance
        self.target_address = w3_instance.to_checksum_address(target_address)
        self.transaction_history = []
        
    def get_balance(self):
        """
        현재 잔액 조회
        """
        balance_wei = self.w3.eth.get_balance(self.target_address)
        balance_eth = self.w3.from_wei(balance_wei, 'ether')
        return float(balance_eth)
    
    def scan_blocks(self, start_block, end_block):
        """
        특정 블록 범위에서 해당 주소의 거래 찾기
        """
        print(f"🔍 주소 {self.target_address} 스캔 중...")
        found_transactions = []
        
        for block_num in range(start_block, end_block + 1):
            try:
                block = self.w3.eth.get_block(block_num, full_transactions=True)
                
                for tx in block['transactions']:
                    # 송신자 또는 수신자가 타겟 주소인 경우
                    if tx['from'] == self.target_address or tx['to'] == self.target_address:
                        tx_data = {
                            'block': block_num,
                            'timestamp': datetime.fromtimestamp(block['timestamp']),
                            'hash': tx['hash'].hex(),
                            'from': tx['from'],
                            'to': tx['to'] if tx['to'] else 'Contract',
                            'value': float(self.w3.from_wei(tx['value'], 'ether')),
                            'type': 'OUT' if tx['from'] == self.target_address else 'IN'
                        }
                        found_transactions.append(tx_data)
                        print(f"✅ 거래 발견: 블록 #{block_num}")
                
                if block_num % 100 == 0:
                    print(f"진행률: 블록 {block_num}/{end_block}")
                    
            except Exception as e:
                print(f"❌ 블록 {block_num} 스캔 실패: {e}")
                continue
        
        self.transaction_history.extend(found_transactions)
        return found_transactions
    
    def analyze_activity(self):
        """
        거래 활동 분석
        """
        if not self.transaction_history:
            print("거래 내역이 없습니다.")
            return
        
        df = pd.DataFrame(self.transaction_history)
        
        print(f"\n📊 {self.target_address} 활동 분석")
        print(f"총 거래 수: {len(df)}")
        
        # 입출금 통계
        incoming = df[df['type'] == 'IN']
        outgoing = df[df['type'] == 'OUT']
        
        print(f"\n💰 입금 거래: {len(incoming)}건")
        print(f"   총 입금액: {incoming['value'].sum():.4f} ETH")
        print(f"   평균 입금액: {incoming['value'].mean():.4f} ETH")
        
        print(f"\n💸 출금 거래: {len(outgoing)}건")
        print(f"   총 출금액: {outgoing['value'].sum():.4f} ETH")
        print(f"   평균 출금액: {outgoing['value'].mean():.4f} ETH")
        
        print(f"\n💼 현재 잔액: {self.get_balance():.4f} ETH")
        
        # 거래 상대방 분석
        print(f"\n🤝 주요 거래 상대방 TOP 5")
        counterparties = []
        for _, tx in df.iterrows():
            if tx['type'] == 'IN':
                counterparties.append(tx['from'])
            else:
                counterparties.append(tx['to'])
        
        from collections import Counter
        top_counterparties = Counter(counterparties).most_common(5)
        for i, (address, count) in enumerate(top_counterparties, 1):
            print(f"{i}. {address}: {count}건")
        
        return df

# 사용 예시
target_wallet = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"  # 예시 주소
tracker = AddressTracker(w3, target_wallet)

# 최근 1000블록 스캔
latest = w3.eth.block_number
transactions = tracker.scan_blocks(latest - 1000, latest)

# 분석 결과 출력
analysis_df = tracker.analyze_activity()

from web3 import Web3

# ERC-20 표준 ABI (Transfer 이벤트)
ERC20_ABI = [
    {
        "anonymous": False,
        "inputs": [
            {"indexed": True, "name": "from", "type": "address"},
            {"indexed": True, "name": "to", "type": "address"},
            {"indexed": False, "name": "value", "type": "uint256"}
        ],
        "name": "Transfer",
        "type": "event"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "name",
        "outputs": [{"name": "", "type": "string"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "symbol",
        "outputs": [{"name": "", "type": "string"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "decimals",
        "outputs": [{"name": "", "type": "uint8"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [{"name": "_owner", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"name": "balance", "type": "uint256"}],
        "type": "function"
    }
]

class TokenAnalyzer:
    def __init__(self, w3_instance, token_address):
        self.w3 = w3_instance
        self.token_address = w3_instance.to_checksum_address(token_address)
        self.contract = w3_instance.eth.contract(
            address=self.token_address,
            abi=ERC20_ABI
        )
        
    def get_token_info(self):
        """
        토큰 기본 정보 조회
        """
        try:
            name = self.contract.functions.name().call()
            symbol = self.contract.functions.symbol().call()
            decimals = self.contract.functions.decimals().call()
            
            return {
                'name': name,
                'symbol': symbol,
                'decimals': decimals,
                'address': self.token_address
            }
        except Exception as e:
            print(f"❌ 토큰 정보 조회 실패: {e}")
            return None
    
    def get_balance(self, address):
        """
        특정 주소의 토큰 잔액 조회
        """
        try:
            address = self.w3.to_checksum_address(address)
            balance = self.contract.functions.balanceOf(address).call()
            decimals = self.contract.functions.decimals().call()
            
            # 실제 잔액으로 변환
            actual_balance = balance / (10 ** decimals)
            return actual_balance
        except Exception as e:
            print(f"❌ 잔액 조회 실패: {e}")
            return 0
    
    def get_transfer_events(self, from_block, to_block):
        """
        Transfer 이벤트 조회
        """
        try:
            # Transfer 이벤트 필터 생성
            event_filter = self.contract.events.Transfer.create_filter(
                fromBlock=from_block,
                toBlock=to_block
            )
            
            events = event_filter.get_all_entries()
            transfers = []
            
            decimals = self.contract.functions.decimals().call()
            
            for event in events:
                transfer_data = {
                    'block': event['blockNumber'],
                    'tx_hash': event['transactionHash'].hex(),
                    'from': event['args']['from'],
                    'to': event['args']['to'],
                    'value': event['args']['value'] / (10 ** decimals)
                }
                transfers.append(transfer_data)
            
            return transfers
        
        except Exception as e:
            print(f"❌ 이벤트 조회 실패: {e}")
            return []
    
    def analyze_transfers(self, from_block, to_block):
        """
        토큰 전송 분석
        """
        token_info = self.get_token_info()
        if not token_info:
            return
        
        print(f"\n🪙 토큰 분석: {token_info['name']} ({token_info['symbol']})")
        print(f"📍 컨트랙트 주소: {token_info['address']}")
        
        transfers = self.get_transfer_events(from_block, to_block)
        
        if not transfers:
            print("전송 내역이 없습니다.")
            return
        
        df = pd.DataFrame(transfers)
        
        print(f"\n📊 전송 통계 (블록 {from_block} ~ {to_block})")
        print(f"총 전송 횟수: {len(df)}")
        print(f"총 전송량: {df['value'].sum():,.2f} {token_info['symbol']}")
        print(f"평균 전송량: {df['value'].mean():,.2f} {token_info['symbol']}")
        print(f"최대 전송량: {df['value'].max():,.2f} {token_info['symbol']}")
        
        # 상위 송신자
        print(f"\n📤 상위 송신자 TOP 5")
        top_senders = df['from'].value_counts().head(5)
        for i, (address, count) in enumerate(top_senders.items(), 1):
            total_sent = df[df['from'] == address]['value'].sum()
            print(f"{i}. {address[:10]}...: {count}건, {total_sent:,.2f} {token_info['symbol']}")
        
        # 상위 수신자
        print(f"\n📥 상위 수신자 TOP 5")
        top_receivers = df['to'].value_counts().head(5)
        for i, (address, count) in enumerate(top_receivers.items(), 1):
            total_received = df[df['to'] == address]['value'].sum()
            print(f"{i}. {address[:10]}...: {count}건, {total_received:,.2f} {token_info['symbol']}")
        
        return df

# USDT 토큰 분석 예시
usdt_address = "0xdAC17F958D2ee523a2206206994597C13D831ec7"
token_analyzer = TokenAnalyzer(w3, usdt_address)

# 토큰 정보 조회
token_info = token_analyzer.get_token_info()
print(token_info)

# 최근 100블록의 전송 내역 분석
latest = w3.eth.block_number
transfer_df = token_analyzer.analyze_transfers(latest - 100, latest)

import requests
import time

class EtherscanAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.etherscan.io/api"
        
    def get_normal_transactions(self, address, startblock=0, endblock=99999999):
        """
        일반 이더리움 거래 내역 조회
        """
        params = {
            'module': 'account',
            'action': 'txlist',
            'address': address,
            'startblock': startblock,
            'endblock': endblock,
            'sort': 'desc',
            'apikey': self.api_key
        }
        
        response = requests.get(self.base_url, params=params)
        data = response.json()
        
        if data['status'] == '1':
            return data['result']
        else:
            print(f"❌ API 오류: {data['message']}")
            return []
    
    def get_token_transactions(self, address, contractaddress=None):
        """
        ERC-20 토큰 거래 내역 조회
        """
        params = {
            'module': 'account',
            'action': 'tokentx',
            'address': address,
            'sort': 'desc',
            'apikey': self.api_key
        }
        
        if contractaddress:
            params['contractaddress'] = contractaddress
        
        response = requests.get(self.base_url, params=params)
        data = response.json()
        
        if data['status'] == '1':
            return data['result']
        else:
            print(f"❌ API 오류: {data['message']}")
            return []
    
    def get_internal_transactions(self, address):
        """
        내부 거래 내역 조회 (스마트 컨트랙트 실행)
        """
        params = {
            'module': 'account',
            'action': 'txlistinternal',
            'address': address,
            'sort': 'desc',
            'apikey': self.api_key
        }
        
        response = requests.get(self.base_url, params=params)
        data = response.json()
        
        if data['status'] == '1':
            return data['result']
        else:
            return []
    
    def get_contract_abi(self, contract_address):
        """
        스마트 컨트랙트 ABI 조회
        """
        params = {
            'module': 'contract',
            'action': 'getabi',
            'address': contract_address,
            'apikey': self.api_key
        }
        
        response = requests.get(self.base_url, params=params)
        data = response.json()
        
        if data['status'] == '1':
            return data['result']
        else:
            print(f"❌ ABI 조회 실패: {data['message']}")
            return None
    
    def get_eth_price(self):
        """
        현재 이더리움 가격 조회
        """
        params = {
            'module': 'stats',
            'action': 'ethprice',
            'apikey': self.api_key
        }
        
        response = requests.get(self.base_url, params=params)
        data = response.json()
        
        if data['status'] == '1':
            return {
                'usd': float(data['result']['ethusd']),
                'btc': float(data['result']['ethbtc'])
            }
        return None
    
    def analyze_address_complete(self, address):
        """
        주소 종합 분석
        """
        print(f"\n🔍 주소 종합 분석: {address}\n")
        
        # 1. 일반 거래
        print("📊 일반 ETH 거래 조회 중...")
        normal_txs = self.get_normal_transactions(address)
        print(f"✅ {len(normal_txs)}건 발견")
        
        time.sleep(0.2)  # API 제한 고려
        
        # 2. 토큰 거래
        print("\n🪙 토큰 거래 조회 중...")
        token_txs = self.get_token_transactions(address)
        print(f"✅ {len(token_txs)}건 발견")
        
        time.sleep(0.2)
        
        # 3. 내부 거래
        print("\n🔄 내부 거래 조회 중...")
        internal_txs = self.get_internal_transactions(address)
        print(f"✅ {len(internal_txs)}건 발견")
        
        # 통계 분석
        if normal_txs:
            df_normal = pd.DataFrame(normal_txs)
            df_normal['value'] = df_normal['value'].astype(float) / 1e18
            
            print(f"\n💰 ETH 거래 통계")
            print(f"총 거래 수: {len(df_normal)}")
            print(f"총 거래량: {df_normal['value'].sum():.4f} ETH")
            
            # 입출금 구분
            incoming = df_normal[df_normal['to'].str.lower() == address.lower()]
            outgoing = df_normal[df_normal['from'].str.lower() == address.lower()]
            
            print(f"입금: {len(incoming)}건, {incoming['value'].sum():.4f} ETH")
            print(f"출금: {len(outgoing)}건, {outgoing['value'].sum():.4f} ETH")
        
        if token_txs:
            df_tokens = pd.DataFrame(token_txs)
            
            print(f"\n🪙 토큰 거래 통계")
            print(f"총 토큰 거래: {len(df_tokens)}건")
            
            # 거래된 토큰 종류
            unique_tokens = df_tokens['tokenSymbol'].value_counts()
            print(f"\n거래된 토큰 종류 ({len(unique_tokens)}개):")
            for token, count in unique_tokens.head(10).items():
                print(f"  • {token}: {count}건")
        
        return {
            'normal': normal_txs,
            'token': token_txs,
            'internal': internal_txs
        }

# Etherscan API 사용 예시
etherscan = EtherscanAPI("YOUR_ETHERSCAN_API_KEY")

# 이더리움 가격 조회
eth_price = etherscan.get_eth_price()
print(f"💵 현재 ETH 가격: ${eth_price['usd']:,.2f}")

# 주소 종합 분석
target_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
analysis_result = etherscan.analyze_address_complete(target_address)

import os
from datetime import datetime

class DataManager:
    def __init__(self, data_dir='blockchain_data'):
        self.data_dir = data_dir
        
        # 데이터 디렉토리 생성
        if not os.path.exists(data_dir):
            os.makedirs(data_dir)
            print(f"📁 데이터 디렉토리 생성: {data_dir}")
    
    def save_transactions(self, df, filename=None):
        """
        거래 데이터를 CSV로 저장
        """
        if filename is None:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"transactions_{timestamp}.csv"
        
        filepath = os.path.join(self.data_dir, filename)
        df.to_csv(filepath, index=False, encoding='utf-8-sig')
        print(f"💾 데이터 저장 완료: {filepath}")
        print(f"   총 {len(df)}건의 거래 저장")
        
        return filepath
    
    def load_transactions(self, filename):
        """
        저장된 거래 데이터 불러오기
        """
        filepath = os.path.join(self.data_dir, filename)
        
        if not os.path.exists(filepath):
            print(f"❌ 파일을 찾을 수 없습니다: {filepath}")
            return None
        
        df = pd.read_csv(filepath)
        print(f"📂 데이터 로드 완료: {len(df)}건")
        return df
    
    def list_saved_files(self):
        """
        저장된 파일 목록 조회
        """
        files = [f for f in os.listdir(self.data_dir) if f.endswith('.csv')]
        
        if not files:
            print("저장된 파일이 없습니다.")
            return []
        
        print(f"\n📚 저장된 파일 목록 ({len(files)}개)")
        for i, file in enumerate(sorted(files), 1):
            filepath = os.path.join(self.data_dir, file)
            size = os.path.getsize(filepath) / 1024  # KB
            print(f"{i}. {file} ({size:.2f} KB)")
        
        return files
    
    def merge_data(self, filenames):
        """
        여러 파일의 데이터 병합
        """
        dfs = []
        
        for filename in filenames:
            df = self.load_transactions(filename)
            if df is not None:
                dfs.append(df)
        
        if not dfs:
            print("병합할 데이터가 없습니다.")
            return None
        
        merged_df = pd.concat(dfs, ignore_index=True)
        
        # 중복 제거 (tx_hash 기준)
        if 'tx_hash' in merged_df.columns:
            before = len(merged_df)
            merged_df = merged_df.drop_duplicates(subset=['tx_hash'])
            after = len(merged_df)
            print(f"🔄 중복 제거: {before - after}건")
        
        print(f"✅ 병합 완료: 총 {len(merged_df)}건")
        return merged_df
    
    def export_to_excel(self, df, filename):
        """
        Excel 파일로 내보내기
        """
        filepath = os.path.join(self.data_dir, filename)
        
        try:
            df.to_excel(filepath, index=False, engine='openpyxl')
            print(f"📊 Excel 파일 생성: {filepath}")
        except ImportError:
            print("❌ openpyxl 라이브러리가 필요합니다: pip install openpyxl")

# 데이터 관리자 생성
data_manager = DataManager()

# 거래 데이터 저장
if 'df_transactions' in locals():
    saved_file = data_manager.save_transactions(df_transactions)

# 저장된 파일 목록 확인
data_manager.list_saved_files()

# 데이터 불러오기
# loaded_df = data_manager.load_transactions('transactions_20240101_120000.csv')

import sqlite3
from contextlib import contextmanager

class BlockchainDB:
    def __init__(self, db_name='blockchain.db'):
        self.db_name = db_name
        self.init_database()
    
    @contextmanager
    def get_connection(self):
        """
        데이터베이스 연결 컨텍스트 매니저
        """
        conn = sqlite3.connect(self.db_name)
        try:
            yield conn
        finally:
            conn.close()
    
    def init_database(self):
        """
        데이터베이스 테이블 초기화
        """
        with self.get_connection() as conn:
            cursor = conn.cursor()
            
            # 거래 테이블
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS transactions (
                    tx_hash TEXT PRIMARY KEY,
                    block_number INTEGER,
                    timestamp DATETIME,
                    from_address TEXT,
                    to_address TEXT,
                    value REAL,
                    gas_price REAL,
                    gas_used INTEGER,
                    tx_fee REAL,
                    status INTEGER
                )
            ''')
            
            # 토큰 전송 테이블
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS token_transfers (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    tx_hash TEXT,
                    block_number INTEGER,
                    token_address TEXT,
                    token_symbol TEXT,
                    from_address TEXT,
                    to_address TEXT,
                    value REAL,
                    timestamp DATETIME
                )
            ''')
            
            # 주소 테이블
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS addresses (
                    address TEXT PRIMARY KEY,
                    label TEXT,
                    first_seen DATETIME,
                    last_seen DATETIME,
                    tx_count INTEGER DEFAULT 0,
                    total_received REAL DEFAULT 0,
                    total_sent REAL DEFAULT 0
                )
            ''')
            
            # 인덱스 생성
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_block ON transactions(block_number)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_from ON transactions(from_address)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_to ON transactions(to_address)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_timestamp ON transactions(timestamp)')
            
            conn.commit()
            print("✅ 데이터베이스 초기화 완료")
    
    def insert_transaction(self, tx_data):
        """
        거래 데이터 삽입
        """
        with self.get_connection() as conn:
            cursor = conn.cursor()
            
            try:
                cursor.execute('''
                    INSERT OR REPLACE INTO transactions 
                    (tx_hash, block_number, timestamp, from_address, to_address, 
                     value, gas_price, gas_used, tx_fee, status)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                ''', (
                    tx_data['tx_hash'],
                    tx_data['block_number'],
                    tx_data['timestamp'],
                    tx_data['from_address'],
                    tx_data['to_address'],
                    tx_data['value'],
                    tx_data.get('gas_price', 0),
                    tx_data.get('gas_used', 0),
                    tx_data.get('tx_fee', 0),
                    tx_data.get('status', 1)
                ))
                
                conn.commit()
                return True
            
            except Exception as e:
                print(f"❌ 데이터 삽입 실패: {e}")
                return False
    
    def insert_transactions_bulk(self, transactions):
        """
        대량 거래 데이터 삽입
        """
        with self.get_connection() as conn:
            cursor = conn.cursor()
            
            data = [
                (
                    tx['tx_hash'],
                    tx['block_number'],
                    tx['timestamp'],
                    tx['from_address'],
                    tx['to_address'],
                    tx['value'],
                    tx.get('gas_price', 0),
                    tx.get('gas_used', 0),
                    tx.get('tx_fee', 0),
                    tx.get('status', 1)
                )
                for tx in transactions
            ]
            
            try:
                cursor.executemany('''
                    INSERT OR REPLACE INTO transactions 
                    (tx_hash, block_number, timestamp, from_address, to_address, 
                     value, gas_price, gas_used, tx_fee, status)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                ''', data)
                
                conn.commit()
                print(f"✅ {len(data)}건의 거래 저장 완료")
                return True
            
            except Exception as e:
                print(f"❌ 대량 삽입 실패: {e}")
                return False
    
    def get_transactions_by_address(self, address, limit=100):
        """
        특정 주소의 거래 조회
        """
        with self.get_connection() as conn:
            query = '''
                SELECT * FROM transactions 
                WHERE from_address = ? OR to_address = ?
                ORDER BY timestamp DESC
                LIMIT ?
            '''
            
            df = pd.read_sql_query(query, conn, params=(address, address, limit))
            return df
    
    def get_transactions_by_date(self, start_date, end_date):
        """
        날짜 범위로 거래 조회
        """
        with self.get_connection() as conn:
            query = '''
                SELECT * FROM transactions 
                WHERE timestamp BETWEEN ? AND ?
                ORDER BY timestamp DESC
            '''
            
            df = pd.read_sql_query(query, conn, params=(start_date, end_date))
            return df
    
    def get_statistics(self):
        """
        전체 통계 조회
        """
        with self.get_connection() as conn:
            cursor = conn.cursor()
            
            # 총 거래 수
            cursor.execute('SELECT COUNT(*) FROM transactions')
            total_txs = cursor.fetchone()[0]
            
            # 총 거래량
            cursor.execute('SELECT SUM(value) FROM transactions')
            total_volume = cursor.fetchone()[0] or 0
            
            # 고유 주소 수
            cursor.execute('''
                SELECT COUNT(DISTINCT address) FROM (
                    SELECT from_address as address FROM transactions
                    UNION
                    SELECT to_address as address FROM transactions
                )
            ''')
            unique_addresses = cursor.fetchone()[0]
            
            # 블록 범위
            cursor.execute('SELECT MIN(block_number), MAX(block_number) FROM transactions')
            block_range = cursor.fetchone()
            
            stats = {
                'total_transactions': total_txs,
                'total_volume': total_volume,
                'unique_addresses': unique_addresses,
                'block_range': block_range
            }
            
            return stats
    
    def export_to_csv(self, output_file, query=None):
        """
        데이터베이스 내용을 CSV로 내보내기
        """
        with self.get_connection() as conn:
            if query is None:
                query = 'SELECT * FROM transactions'
            
            df = pd.read_sql_query(query, conn)
            df.to_csv(output_file, index=False)
            print(f"📊 CSV 파일 생성: {output_file} ({len(df)}건)")

# 데이터베이스 사용 예시
db = BlockchainDB('my_blockchain.db')

# DataFrame을 데이터베이스에 저장
if 'df_transactions' in locals():
    transactions_list = df_transactions.to_dict('records')
    db.insert_transactions_bulk(transactions_list)

# 통계 조회
stats = db.get_statistics()
print(f"\n📊 데이터베이스 통계")
print(f"총 거래 수: {stats['total_transactions']:,}")
print(f"총 거래량: {stats['total_volume']:.4f} ETH")
print(f"고유 주소 수: {stats['unique_addresses']:,}")
print(f"블록 범위: {stats['block_range'][0]} ~ {stats['block_range'][1]}")

class ExchangeMonitor:
    def __init__(self, w3_instance, db_instance):
        self.w3 = w3_instance
        self.db = db_instance
        self.exchange_addresses = {}
        self.alert_threshold = 100  # ETH
        
    def add_exchange(self, name, address):
        """
        모니터링할 거래소 추가
        """
        checksum_address = self.w3.to_checksum_address(address)
        self.exchange_addresses[name] = checksum_address
        print(f"✅ 거래소 추가: {name} ({checksum_address})")
    
    def check_balance(self, exchange_name):
        """
        거래소 잔액 확인
        """
        if exchange_name not in self.exchange_addresses:
            print(f"❌ 등록되지 않은 거래소: {exchange_name}")
            return None
        
        address = self.exchange_addresses[exchange_name]
        balance_wei = self.w3.eth.get_balance(address)
        balance_eth = float(self.w3.from_wei(balance_wei, 'ether'))
        
        return balance_eth
    
    def analyze_flow(self, exchange_name, hours=24):
        """
        특정 기간 동안의 입출금 흐름 분석
        """
        if exchange_name not in self.exchange_addresses:
            return None
        
        address = self.exchange_addresses[exchange_name]
        
        # 데이터베이스에서 거래 조회
        from datetime import datetime, timedelta
        end_time = datetime.now()
        start_time = end_time - timedelta(hours=hours)
        
        df = self.db.get_transactions_by_date(
            start_time.strftime('%Y-%m-%d %H:%M:%S'),
            end_time.strftime('%Y-%m-%d %H:%M:%S')
        )
        
        # 해당 거래소 관련 거래만 필터링
        exchange_txs = df[
            (df['from_address'] == address) | 
            (df['to_address'] == address)
        ]
        
        if len(exchange_txs) == 0:
            print(f"최근 {hours}시간 동안 거래 없음")
            return None
        
        # 입출금 구분
        deposits = exchange_txs[exchange_txs['to_address'] == address]
        withdrawals = exchange_txs[exchange_txs['from_address'] == address]
        
        analysis = {
            'exchange': exchange_name,
            'period_hours': hours,
            'total_transactions': len(exchange_txs),
            'deposits': {
                'count': len(deposits),
                'total': deposits['value'].sum(),
                'average': deposits['value'].mean() if len(deposits) > 0 else 0
            },
            'withdrawals': {
                'count': len(withdrawals),
                'total': withdrawals['value'].sum(),
                'average': withdrawals['value'].mean() if len(withdrawals) > 0 else 0
            },
            'net_flow': deposits['value'].sum() - withdrawals['value'].sum()
        }
        
        return analysis
    
    def print_flow_report(self, analysis):
        """
        입출금 분석 리포트 출력
        """
        if not analysis:
            return
        
        print(f"\n{'='*60}")
        print(f"🏦 {analysis['exchange']} 입출금 분석 리포트")
        print(f"📅 분석 기간: 최근 {analysis['period_hours']}시간")
        print(f"{'='*60}")
        
        print(f"\n📥 입금 (Deposits)")
        print(f"   거래 수: {analysis['deposits']['count']}건")
        print(f"   총 입금액: {analysis['deposits']['total']:.4f} ETH")
        print(f"   평균 입금액: {analysis['deposits']['average']:.4f} ETH")
        
        print(f"\n📤 출금 (Withdrawals)")
        print(f"   거래 수: {analysis['withdrawals']['count']}건")
        print(f"   총 출금액: {analysis['withdrawals']['total']:.4f} ETH")
        print(f"   평균 출금액: {analysis['withdrawals']['average']:.4f} ETH")
        
        net_flow = analysis['net_flow']
        flow_direction = "유입" if net_flow > 0 else "유출"
        print(f"\n💰 순 흐름: {abs(net_flow):.4f} ETH ({flow_direction})")
        
        # 현재 잔액
        current_balance = self.check_balance(analysis['exchange'])
        print(f"💼 현재 잔액: {current_balance:.4f} ETH")
        
        print(f"{'='*60}\n")
    
    def monitor_large_transactions(self, block_number):
        """
        대량 거래 모니터링
        """
        try:
            block = self.w3.eth.get_block(block_number, full_transactions=True)
            alerts = []
            
            for tx in block['transactions']:
                value_eth = float(self.w3.from_wei(tx['value'], 'ether'))
                
                # 거래소 관련 대량 거래 감지
                for exchange_name, exchange_address in self.exchange_addresses.items():
                    if value_eth >= self.alert_threshold:
                        if tx['from'] == exchange_address:
                            alert = {
                                'type': 'WITHDRAWAL',
                                'exchange': exchange_name,
                                'amount': value_eth,
                                'to': tx['to'],
                                'tx_hash': tx['hash'].hex()
                            }
                            alerts.append(alert)
                            self.send_alert(alert)
                        
                        elif tx['to'] == exchange_address:
                            alert = {
                                'type': 'DEPOSIT',
                                'exchange': exchange_name,
                                'amount': value_eth,
                                'from': tx['from'],
                                'tx_hash': tx['hash'].hex()
                            }
                            alerts.append(alert)
                            self.send_alert(alert)
            
            return alerts
        
        except Exception as e:
            print(f"❌ 블록 모니터링 실패: {e}")
            return []
    
    def send_alert(self, alert):
        """
        알림 전송
        """
        emoji = "📤" if alert['type'] == 'WITHDRAWAL' else "📥"
        print(f"\n🚨 {emoji} 대량 거래 감지!")
        print(f"   거래소: {alert['exchange']}")
        print(f"   유형: {alert['type']}")
        print(f"   금액: {alert['amount']:.2f} ETH")
        
        if alert['type'] == 'WITHDRAWAL':
            print(f"   수신자: {alert['to']}")
        else:
            print(f"   송신자: {alert['from']}")
        
        print(f"   TX: {alert['tx_hash']}")
    
    def run_monitoring(self, interval=15):
        """
        실시간 모니터링 실행
        """
        print("🔍 거래소 모니터링 시작...")
        print(f"모니터링 대상: {', '.join(self.exchange_addresses.keys())}")
        print(f"알림 임계값: {self.alert_threshold} ETH\n")
        
        last_block = self.w3.eth.block_number
        
        try:
            while True:
                current_block = self.w3.eth.block_number
                
                if current_block > last_block:
                    for block_num in range(last_block + 1, current_block + 1):
                        print(f"📦 블록 #{block_num} 분석 중...")
                        alerts = self.monitor_large_transactions(block_num)
                        
                        if alerts:
                            print(f"✅ {len(alerts)}건의 알림 발생")
                    
                    last_block = current_block
                
                time.sleep(interval)
        
        except KeyboardInterrupt:
            print("\n⏹️ 모니터링 종료")

# 거래소 모니터링 시스템 설정
monitor = ExchangeMonitor(w3, db)

# 주요 거래소 주소 추가 (예시)
monitor.add_exchange("Binance", "0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE")
monitor.add_exchange("Coinbase", "0x71660c4005BA85c37ccec55d0C4493E66Fe775d3")
monitor.add_exchange("Kraken", "0x2910543Af39abA0Cd09dBb2D50200b3E800A63D2")

# 입출금 흐름 분석
analysis = monitor.analyze_flow("Binance", hours=24)
monitor.print_flow_report(analysis)

# 실시간 모니터링 시작 (주석 해제하여 실행)
# monitor.run_monitoring(interval=15)

from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

class ParallelBlockAnalyzer:
    def __init__(self, w3_instance, max_workers=5):
        self.w3 = w3_instance
        self.max_workers = max_workers
        self.lock = threading.Lock()
        self.results = []
    
    def analyze_single_block(self, block_number):
        """
        단일 블록 분석
        """
        try:
            block = self.w3.eth.get_block(block_number, full_transactions=True)
            
            block_data = {
                'block_number': block_number,
                'timestamp': block['timestamp'],
                'tx_count': len(block['transactions']),
                'total_value': sum(
                    float(self.w3.from_wei(tx['value'], 'ether')) 
                    for tx in block['transactions']
                )
            }
            
            return block_data
        
        except Exception as e:
            print(f"❌ 블록 {block_number} 분석 실패: {e}")
            return None
    
    def analyze_blocks_parallel(self, start_block, end_block):
        """
        여러 블록을 병렬로 분석
        """
        block_numbers = range(start_block, end_block + 1)
        results = []
        
        print(f"🚀 {len(block_numbers)}개 블록 병렬 분석 시작...")
        print(f"워커 수: {self.max_workers}")
        
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            # 모든 블록 분석 작업 제출
            future_to_block = {
                executor.submit(self.analyze_single_block, block_num): block_num 
                for block_num in block_numbers
            }
            
            # 완료된 작업 처리
            completed = 0
            for future in as_completed(future_to_block):
                block_num = future_to_block[future]
                try:
                    result = future.result()
                    if result:
                        results.append(result)
                    
                    completed += 1
                    if completed % 10 == 0:
                        progress = (completed / len(block_numbers)) * 100
                        print(f"진행률: {progress:.1f}% ({completed}/{len(block_numbers)})")
                
                except Exception as e:
                    print(f"❌ 블록 {block_num} 처리 중 오류: {e}")
        
        print(f"✅ 분석 완료: {len(results)}개 블록")
        return results

# 병렬 분석 실행
analyzer = ParallelBlockAnalyzer(w3, max_workers=10)
latest = w3.eth.block_number

# 최근 100개 블록을 병렬로 분석
results = analyzer.analyze_blocks_parallel(latest - 100, latest)

# 결과를 DataFrame으로 변환
df_results = pd.DataFrame(results)
print(f"\n📊 분석 결과 요약")
print(f"평균 거래 수: {df_results['tx_count'].mean():.2f}")
print(f"평균 거래량: {df_results['total_value'].mean():.4f} ETH")

from functools import lru_cache
import pickle
import hashlib

class CachedWeb3:
    def __init__(self, w3_instance, cache_dir='cache'):
        self.w3 = w3_instance
        self.cache_dir = cache_dir
        
        if not os.path.exists(cache_dir):
            os.makedirs(cache_dir)
    
    def _get_cache_key(self, method, *args):
        """
        캐시 키 생성
        """
        key_string = f"{method}_{args}"
        return hashlib.md5(key_string.encode()).hexdigest()
    
    def _get_cache_path(self, cache_key):
        """
        캐시 파일 경로
        """
        return os.path.join(self.cache_dir, f"{cache_key}.pkl")
    
    def _load_from_cache(self, cache_key):
        """
        캐시에서 데이터 로드
        """
        cache_path = self._get_cache_path(cache_key)
        
        if os.path.exists(cache_path):
            try:
                with open(cache_path, 'rb') as f:
                    return pickle.load(f)
            except:
                return None
        
        return None
    
    def _save_to_cache(self, cache_key, data):
        """
        데이터를 캐시에 저장
        """
        cache_path = self._get_cache_path(cache_key)
        
        try:
            with open(cache_path, 'wb') as f:
                pickle.dump(data, f)
        except Exception as e:
            print(f"⚠️ 캐시 저장 실패: {e}")
    
    def get_block(self, block_number, full_transactions=False):
        """
        블록 정보 조회 (캐싱)
        """
        cache_key = self._get_cache_key('block', block_number, full_transactions)
        
        # 캐시 확인
        cached_data = self._load_from_cache(cache_key)
        if cached_data:
            print(f"💾 캐시에서 블록 #{block_number} 로드")
            return cached_data
        
        # 블록체인에서 조회
        print(f"🔍 블록체인에서 블록 #{block_number} 조회")
        block = self.w3.eth.get_block(block_number, full_transactions=full_transactions)
        
        # 캐시에 저장
        self._save_to_cache(cache_key, block)
        
        return block
    
    def clear_cache(self):
        """
        캐시 전체 삭제
        """
        import shutil
        if os.path.exists(self.cache_dir):
            shutil.rmtree(self.cache_dir)
            os.makedirs(self.cache_dir)
            print("🗑️ 캐시 삭제 완료")

# 캐싱 적용
cached_w3 = CachedWeb3(w3)

# 첫 번째 호출 - 블록체인에서 조회
block1 = cached_w3.get_block(19000000)

# 두 번째 호출 - 캐시에서 로드 (훨씬 빠름!)
block2 = cached_w3.get_block(19000000)

import time
from functools import wraps

def retry_on_failure(max_retries=3, delay=1, backoff=2):
    """
    실패 시 재시도하는 데코레이터
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            current_delay = delay
            
            while retries < max_retries:
                try:
                    return func(*args, **kwargs)
                
                except Exception as e:
                    retries += 1
                    if retries >= max_retries:
                        print(f"❌ {func.__name__} 최종 실패: {e}")
                        raise
                    
                    print(f"⚠️ {func.__name__} 실패 (시도 {retries}/{max_retries}): {e}")
                    print(f"   {current_delay}초 후 재시도...")
                    time.sleep(current_delay)
                    current_delay *= backoff
            
            return None
        
        return wrapper
    return decorator

class RobustBlockchainClient:
    def __init__(self, w3_instance):
        self.w3 = w3_instance
    
    @retry_on_failure(max_retries=3, delay=1, backoff=2)
    def get_block_safe(self, block_number):
        """
        안전한 블록 조회
        """
        return self.w3.eth.get_block(block_number, full_transactions=True)
    
    @retry_on_failure(max_retries=5, delay=2, backoff=1.5)
    def get_transaction_receipt(self, tx_hash):
        """
        안전한 트랜잭션 영수증 조회
        """
        return self.w3.eth.get_transaction_receipt(tx_hash)
    
    def batch_get_blocks(self, block_numbers):
        """
        여러 블록을 안전하게 조회
        """
        results = []
        failed = []
        
        for block_num in block_numbers:
            try:
                block = self.get_block_safe(block_num)
                results.append(block)
            except Exception as e:
                print(f"❌ 블록 {block_num} 조회 실패")
                failed.append(block_num)
        
        print(f"\n✅ 성공: {len(results)}개")
        print(f"❌ 실패: {len(failed)}개")
        
        if failed:
            print(f"실패한 블록: {failed}")
        
        return results, failed

# 안정적인 클라이언트 사용
robust_client = RobustBlockchainClient(w3)

# 블록 조회 (자동 재시도)
try:
    block = robust_client.get_block_safe(19000000)
    print("✅ 블록 조회 성공")
except Exception as e:
    print(f"❌ 모든 재시도 실패: {e}")