Ver3.0 ๐ ํ์ด์ฌ์ผ๋ก ์ค๋งํธ์ปจํธ๋ํธ ์ํ ๋ชจ๋ํฐ๋ง ์์คํ ๋ง๋ค๊ธฐ

๐ ํ์ด์ฌ์ผ๋ก ์ค๋งํธ์ปจํธ๋ํธ ์ํ ๋ชจ๋ํฐ๋ง ์์คํ ๋ง๋ค๊ธฐ
๋ธ๋ก์ฒด์ธ ์์์ ๋์๊ฐ๋ ์ค๋งํธ์ปจํธ๋ํธ, ์ค์๊ฐ์ผ๋ก ๊ฐ์ํด๋ณด์!
์์ฆ Web3 ๊ฐ๋ฐํ๋ฉด์ ๊ฐ์ฅ ๋ต๋ตํ ๊ฒ ๋ญ์ง ์์? ๋ฐ๋ก ์ค๋งํธ์ปจํธ๋ํธ๊ฐ ์ ๋๋ก ๋์๊ฐ๋์ง ์ค์๊ฐ์ผ๋ก ํ์ธํ๊ธฐ ์ด๋ ต๋ค๋ ๊ฑฐใ
ใ
ใ
๐
์ด๋๋ฆฌ์์ด๋ ํด๋ฆฌ๊ณค ๊ฐ์ ๋ธ๋ก์ฒด์ธ์ ๋ฐฐํฌํ ์ปจํธ๋ํธ๊ฐ ์๋๋ฐ, ํธ๋์ญ์
์ด ๋ค์ด์๋์ง, ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋์ง, ์ํ๊ฐ์ด ๋ฐ๋์๋์ง... ์ด๋ฐ ๊ฑฐ ์ผ์ผ์ด ๋ธ๋ก ์ต์คํ๋ก๋ฌ ๋ค์ด๊ฐ์ ํ์ธํ๋ ๊ฑฐ ์ง์ง ๋นํจ์จ์ ์ด์์? ๐คฆโโ๏ธ
๊ทธ๋์ ์ค๋์ ํ์ด์ฌ์ผ๋ก ์ค๋งํธ์ปจํธ๋ํธ ์ํ๋ฅผ ์ค์๊ฐ์ผ๋ก ๋ชจ๋ํฐ๋งํ๋ ์์คํ
์ ์ง์ ๋ง๋ค์ด๋ณด๋ ค๊ณ ํด! ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์๊ณ , ํ ๋ฒ ๋ง๋ค์ด๋๋ฉด ์ง์ง ๊ฐ๋ฐ ํจ์จ์ด ์์ฒญ ์ฌ๋ผ๊ฐ๊ฑฐ๋ ๐ช
๐ค ์ ๋ชจ๋ํฐ๋ง ์์คํ ์ด ํ์ํ๊ฐ?
์ค๋งํธ์ปจํธ๋ํธ ๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์ง์ง ๋ต๋ตํ ์๊ฐ๋ค์ด ๋ง์ ใ
ใ
์๋ฅผ ๋ค์ด์ NFT ๋ง์ผํ๋ ์ด์ค๋ฅผ ๋ง๋ค์๋ค๊ณ ์ณ๋ด. ๋๊ตฐ๊ฐ NFT๋ฅผ ๊ตฌ๋งคํ๋ฉด ์ปจํธ๋ํธ์์ Transfer ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋๋ฐ, ์ด๊ฑธ ์ค์๊ฐ์ผ๋ก ๊ฐ์งํด์ ๊ตฌ๋งค์ํํ
์๋ฆผ์ ๋ณด๋ด์ผ ํ์์? ๊ทผ๋ฐ ๋งค๋ฒ ์๋์ผ๋ก ํ์ธํ ์๋ ์๋ ๋
ธ๋ฆ์ด๊ณ ... ๐
๋ DeFi ํ๋กํ ์ฝ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ ์ฌ๊ฐํด. ์ ๋์ฑ ํ์ ์ํ๊ฐ ๊ณ์ ๋ฐ๋๋๋ฐ, ํน์ ์๊ณ๊ฐ์ ๋์ผ๋ฉด ์๋์ผ๋ก ๋ฆฌ๋ฐธ๋ฐ์ฑ์ ํด์ผ ํ๊ฑฐ๋ . ์ด๋ฐ ๊ฑธ ์ฌ๋์ด 24์๊ฐ ๋ชจ๋ํฐ๋งํ ์๋ ์์์?
๐ ๋ชจ๋ํฐ๋ง ์์คํ
์ด ํ์ํ ํต์ฌ ์ด์ ๋ค:
1. ์ค์๊ฐ ์ด๋ฒคํธ ๊ฐ์ง - ์ปจํธ๋ํธ์์ ๋ฐ์ํ๋ ๋ชจ๋ ์ด๋ฒคํธ๋ฅผ ๋์น์ง ์๊ณ ์บ์น
2. ์ํ๊ฐ ์ถ์ - ์ค์ํ ๋ณ์๋ค์ ๋ณํ๋ฅผ ์๊ฐ์์ผ๋ก ๊ธฐ๋ก
3. ์ด์ ์งํ ํ์ง - ๋น์ ์์ ์ธ ํธ๋์ญ์
์ด๋ ํจํด์ ์๋์ผ๋ก ๊ฐ์ง
4. ์๋ํ๋ ๋์ - ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋๋ฉด ์๋์ผ๋ก ์ก์
์คํ
5. ๋ฐ์ดํฐ ๋ถ์ - ์ปจํธ๋ํธ ์ฌ์ฉ ํจํด๊ณผ ํต๊ณ ๋ฐ์ดํฐ ์์ง
๐ ๏ธ ํ์ํ ๋๊ตฌ๋ค๊ณผ ํ๊ฒฝ ์ค์
๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ๊ธฐ ์ ์ ํ์ํ ๊ฒ๋ค๋ถํฐ ์ฑ๊ฒจ๋ณด์! ์๊ฐ๋ณด๋ค ๊ฐ๋จํด ใ ใ
๐ง ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
๊ฐ์ฅ ์ค์ํ ๊ฑด Web3.py์ผ. ์ด๊ฒ ํ์ด์ฌ์์ ์ด๋๋ฆฌ์ ๋ธ๋ก์ฒด์ธ๊ณผ ํต์ ํ ์ ์๊ฒ ํด์ฃผ๋ ํต์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฑฐ๋ . ๊ทธ ์ธ์๋ ๋ช ๊ฐ์ง ๋ ํ์ํด:
# ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
pip install web3
pip install python-dotenv # ํ๊ฒฝ๋ณ์ ๊ด๋ฆฌ์ฉ
pip install requests # API ํธ์ถ์ฉ
pip install asyncio # ๋น๋๊ธฐ ์ฒ๋ฆฌ์ฉ
pip install aiohttp # ๋น๋๊ธฐ HTTP ์์ฒญ์ฉ
pip install sqlalchemy # ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋์ฉ (์ ํ)
pip install discord-webhook # ๋์ค์ฝ๋ ์๋ฆผ์ฉ (์ ํ)
์ค์น๊ฐ ๋๋ฌ์ผ๋ฉด ์ด์ ๋ธ๋ก์ฒด์ธ ๋ ธ๋์ ์ ์ํ ๋ฐฉ๋ฒ์ด ํ์ํด. ์ง์ ๋ ธ๋๋ฅผ ์ด์ํ ์๋ ์์ง๋ง, ์์งํ ๊ฐ๋ฐ ๋จ๊ณ์์๋ Infura๋ Alchemy ๊ฐ์ ์๋น์ค๋ฅผ ์ฐ๋ ๊ฒ ํจ์ฌ ํธํด ใ ใ ๋ฌด๋ฃ ํ๋๋ ์์ด์ ํ ์คํธํ๊ธฐ ๋ฑ ์ข๊ฑฐ๋ ! ๐ฏ
๐ก Pro Tip: Infura๋ ํ๋ฃจ 10๋ง ์์ฒญ๊น์ง ๋ฌด๋ฃ๊ณ , Alchemy๋ ๋ ๋ง์ ๊ธฐ๋ฅ์ ์ ๊ณตํด. ๋ ๋ค ๊ฐ์ ํด์ API ํค๋ฅผ ๋ฐ์๋๋ฉด ์ข์. ๋์ค์ ํ๋๊ฐ ๋ค์ด๋๋ฉด ๋ค๋ฅธ ๊ฑธ๋ก ๋ฐ๋ก ์ ํํ ์ ์๊ฑฐ๋ !
# .env ํ์ผ ์ค์ ์์
INFURA_URL=https://mainnet.infura.io/v3/YOUR_PROJECT_ID
ALCHEMY_URL=https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY
CONTRACT_ADDRESS=0x1234567890abcdef...
PRIVATE_KEY=your_private_key_here # ์ฝ๊ธฐ ์ ์ฉ์ด๋ฉด ํ์์์
DISCORD_WEBHOOK=https://discord.com/api/webhooks/...
๐ ๊ธฐ๋ณธ ์ฐ๊ฒฐ ์ฝ๋ ์์ฑํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝ๋๋ฅผ ์ง๋ณผ๊น? ๋จผ์ ๋ธ๋ก์ฒด์ธ์ ์ฐ๊ฒฐํ๋ ๊ธฐ๋ณธ ์ฝ๋๋ถํฐ ์์ํด๋ณด์ ๐
from web3 import Web3
from dotenv import load_dotenv
import os
import json
# ํ๊ฒฝ๋ณ์ ๋ก๋
load_dotenv()
class BlockchainMonitor:
def __init__(self):
# Web3 ์ธ์คํด์ค ์์ฑ
self.w3 = Web3(Web3.HTTPProvider(os.getenv('INFURA_URL')))
# ์ฐ๊ฒฐ ํ์ธ
if self.w3.is_connected():
print("โ
๋ธ๋ก์ฒด์ธ ์ฐ๊ฒฐ ์ฑ๊ณต!")
print(f"ํ์ฌ ๋ธ๋ก ๋ฒํธ: {self.w3.eth.block_number}")
else:
print("โ ์ฐ๊ฒฐ ์คํจ... URL์ ํ์ธํด์ฃผ์ธ์")
# ์ปจํธ๋ํธ ์ฃผ์
self.contract_address = os.getenv('CONTRACT_ADDRESS')
def load_contract(self, abi_path):
"""์ปจํธ๋ํธ ABI ๋ก๋ ๋ฐ ์ธ์คํด์ค ์์ฑ"""
with open(abi_path, 'r') as f:
contract_abi = json.load(f)
self.contract = self.w3.eth.contract(
address=Web3.to_checksum_address(self.contract_address),
abi=contract_abi
)
print(f"๐ ์ปจํธ๋ํธ ๋ก๋ ์๋ฃ: {self.contract_address}")
# ์ฌ์ฉ ์์
monitor = BlockchainMonitor()
monitor.load_contract('contract_abi.json')
์ด ์ฝ๋๊ฐ ๊ธฐ๋ณธ ๋ผ๋์ผ. Web3 ์ธ์คํด์ค๋ฅผ ๋ง๋ค๊ณ , ๋ธ๋ก์ฒด์ธ์ ์ฐ๊ฒฐํ๊ณ , ์ปจํธ๋ํธ๋ฅผ ๋ก๋ํ๋ ๊ณผ์ ์ด์ง. ์ฌ๊ธฐ์ ์ค์ํ ๊ฑด ABI(Application Binary Interface)์ธ๋ฐ, ์ด๊ฑด ์ปจํธ๋ํธ์ ํจ์์ ์ด๋ฒคํธ ์ ๋ณด๊ฐ ๋ด๊ธด JSON ํ์ผ์ด์ผ ๐
ABI๋ ๋ณดํต ์ปจํธ๋ํธ๋ฅผ ์ปดํ์ผํ๋ฉด ์๋์ผ๋ก ์์ฑ๋๋๋ฐ, Remix๋ Hardhat ๊ฐ์ ๊ฐ๋ฐ ๋๊ตฌ๋ฅผ ์ฐ๋ฉด ์ฝ๊ฒ ์ป์ ์ ์์ด!
๐ฏ ์ค์๊ฐ ์ด๋ฒคํธ ๋ชจ๋ํฐ๋ง ๊ตฌํ
์ด์ ์ง์ง ํต์ฌ ๊ธฐ๋ฅ์ธ ์ด๋ฒคํธ ๋ชจ๋ํฐ๋ง์ ๋ง๋ค์ด๋ณด์! ๋ธ๋ก์ฒด์ธ์์ ์๋ก์ด ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ๋ฐ๋ก๋ฐ๋ก ์บ์นํ๋ ๊ฑฐ์ง ใ ใ
import time
from datetime import datetime
class EventMonitor(BlockchainMonitor):
def __init__(self):
super().__init__()
self.last_block = self.w3.eth.block_number
def monitor_events(self, event_name, callback=None):
"""ํน์ ์ด๋ฒคํธ๋ฅผ ์ค์๊ฐ์ผ๋ก ๋ชจ๋ํฐ๋ง"""
print(f"๐ {event_name} ์ด๋ฒคํธ ๋ชจ๋ํฐ๋ง ์์...")
# ์ด๋ฒคํธ ํํฐ ์์ฑ
event_filter = getattr(self.contract.events, event_name).create_filter(
fromBlock=self.last_block
)
while True:
try:
# ์๋ก์ด ์ด๋ฒคํธ ํ์ธ
for event in event_filter.get_new_entries():
self.process_event(event, callback)
# ํ์ฌ ๋ธ๋ก ์
๋ฐ์ดํธ
current_block = self.w3.eth.block_number
if current_block > self.last_block:
print(f"๐ฆ ์ ๋ธ๋ก ๊ฐ์ง: {current_block}")
self.last_block = current_block
time.sleep(2) # 2์ด๋ง๋ค ์ฒดํฌ
except Exception as e:
print(f"โ ์๋ฌ ๋ฐ์: {str(e)}")
time.sleep(5)
def process_event(self, event, callback=None):
"""์ด๋ฒคํธ ์ฒ๋ฆฌ ๋ฐ ๋ก๊น
"""
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"\n๐ ์ ์ด๋ฒคํธ ๊ฐ์ง! [{timestamp}]")
print(f"๋ธ๋ก ๋ฒํธ: {event['blockNumber']}")
print(f"ํธ๋์ญ์
ํด์: {event['transactionHash'].hex()}")
print(f"์ด๋ฒคํธ ๋ฐ์ดํฐ: {event['args']}")
# ์ฝ๋ฐฑ ํจ์๊ฐ ์์ผ๋ฉด ์คํ
if callback:
callback(event)
# ์ฌ์ฉ ์์
def on_transfer(event):
"""Transfer ์ด๋ฒคํธ ๋ฐ์ ์ ์คํ๋ ํจ์"""
from_addr = event['args']['from']
to_addr = event['args']['to']
amount = event['args']['value']
print(f"๐ธ ์ ์ก ๋ฐ์: {from_addr[:10]}... โ {to_addr[:10]}...")
print(f"๊ธ์ก: {Web3.from_wei(amount, 'ether')} ETH")
monitor = EventMonitor()
monitor.load_contract('contract_abi.json')
monitor.monitor_events('Transfer', callback=on_transfer)
์ด ์ฝ๋๋ ๊ณ์ ๋๋ฉด์ ์๋ก์ด ์ด๋ฒคํธ๋ฅผ ๊ฐ์งํด. 2์ด๋ง๋ค ์ฒดํฌํ๋๋ฐ, ์ด ๊ฐ๊ฒฉ์ ๋คํธ์ํฌ ์ํฉ์ ๋ฐ๋ผ ์กฐ์ ํ๋ฉด ๋ผ. ๋๋ฌด ์งง์ผ๋ฉด API ํธ์ถ ์ ํ์ ๊ฑธ๋ฆด ์ ์๊ณ , ๋๋ฌด ๊ธธ๋ฉด ์ค์๊ฐ์ฑ์ด ๋จ์ด์ง๊ฑฐ๋ โฑ๏ธ
โ ๏ธ ์ฃผ์์ฌํญ: ๋ฌด๋ฃ API ํ๋์ ์์ฒญ ํ์ ์ ํ์ด ์์ด! Infura ๊ธฐ์ค์ผ๋ก ํ๋ฃจ 10๋ง ์์ฒญ์ธ๋ฐ, 2์ด๋ง๋ค ์ฒดํฌํ๋ฉด ํ๋ฃจ์ ์ฝ 43,200๋ฒ ์์ฒญํ๊ฒ ๋ผ. ์ฌ์ ๋ ์์ง๋ง ์ฌ๋ฌ ๊ฐ ๋๋ฆฌ๋ฉด ๊ธ๋ฐฉ ํ๊ณ์ ๋๋ฌํ ์ ์์ผ๋ ์กฐ์ฌํด์ผ ํด!
โก ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ก ์ฑ๋ฅ ์ต์ ํ
์ ์ฝ๋๋ ๋์์ง ์์ง๋ง, ์ฌ๋ฌ ์ด๋ฒคํธ๋ฅผ ๋์์ ๋ชจ๋ํฐ๋งํ๋ ค๋ฉด ๋น๋๊ธฐ ์ฒ๋ฆฌ๊ฐ ํ์์ผ! asyncio๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์ฌ ํจ์จ์ ์ผ๋ก ๋ง๋ค ์ ์์ด ๐จ
import asyncio
from web3 import Web3
from web3.middleware import geth_poa_middleware
class AsyncEventMonitor:
def __init__(self, provider_url):
self.w3 = Web3(Web3.HTTPProvider(provider_url))
# POA ์ฒด์ธ(ํด๋ฆฌ๊ณค ๋ฑ)์ ์ํ ๋ฏธ๋ค์จ์ด
self.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
async def monitor_multiple_events(self, contract, event_names):
"""์ฌ๋ฌ ์ด๋ฒคํธ๋ฅผ ๋์์ ๋ชจ๋ํฐ๋ง"""
tasks = []
for event_name in event_names:
task = asyncio.create_task(
self.monitor_single_event(contract, event_name)
)
tasks.append(task)
await asyncio.gather(*tasks)
async def monitor_single_event(self, contract, event_name):
"""๋จ์ผ ์ด๋ฒคํธ ๋น๋๊ธฐ ๋ชจ๋ํฐ๋ง"""
event = getattr(contract.events, event_name)
last_block = self.w3.eth.block_number
print(f"๐ {event_name} ๋ชจ๋ํฐ๋ง ์์ (๋ธ๋ก: {last_block})")
while True:
try:
current_block = self.w3.eth.block_number
if current_block > last_block:
# ์ ๋ธ๋ก์์ ์ด๋ฒคํธ ๊ฒ์
events = event.get_logs(
fromBlock=last_block + 1,
toBlock=current_block
)
for evt in events:
await self.handle_event(event_name, evt)
last_block = current_block
await asyncio.sleep(3) # ๋น๋๊ธฐ sleep
except Exception as e:
print(f"โ {event_name} ์๋ฌ: {str(e)}")
await asyncio.sleep(5)
async def handle_event(self, event_name, event_data):
"""์ด๋ฒคํธ ํธ๋ค๋ง (๋น๋๊ธฐ)"""
print(f"\nโจ [{event_name}] ์ด๋ฒคํธ ๊ฐ์ง!")
print(f"๋ธ๋ก: {event_data['blockNumber']}")
print(f"TX: {event_data['transactionHash'].hex()[:20]}...")
# ์ฌ๊ธฐ์ ์ถ๊ฐ ๋น๋๊ธฐ ์์
๊ฐ๋ฅ (DB ์ ์ฅ, API ํธ์ถ ๋ฑ)
await self.save_to_database(event_data)
await self.send_notification(event_name, event_data)
async def save_to_database(self, event_data):
"""DB ์ ์ฅ (์์)"""
# ์ค์ ๋ก๋ SQLAlchemy async ์ธ์
์ฌ์ฉ
await asyncio.sleep(0.1) # DB ์์
์๋ฎฌ๋ ์ด์
async def send_notification(self, event_name, event_data):
"""์๋ฆผ ์ ์ก (์์)"""
await asyncio.sleep(0.1) # ์๋ฆผ ์ ์ก ์๋ฎฌ๋ ์ด์
# ์ฌ์ฉ ์์
async def main():
monitor = AsyncEventMonitor(os.getenv('INFURA_URL'))
# ์ปจํธ๋ํธ ๋ก๋
with open('contract_abi.json', 'r') as f:
abi = json.load(f)
contract = monitor.w3.eth.contract(
address=Web3.to_checksum_address(os.getenv('CONTRACT_ADDRESS')),
abi=abi
)
# ์ฌ๋ฌ ์ด๋ฒคํธ ๋์ ๋ชจ๋ํฐ๋ง
events_to_monitor = ['Transfer', 'Approval', 'Mint', 'Burn']
await monitor.monitor_multiple_events(contract, events_to_monitor)
# ์คํ
if __name__ == "__main__":
asyncio.run(main())
๋น๋๊ธฐ ๋ฒ์ ์ ์ฌ๋ฌ ์ด๋ฒคํธ๋ฅผ ๋์์ ๋ชจ๋ํฐ๋งํ ์ ์์ด์ ํจ์ฌ ํจ์จ์ ์ด์ผ! ๊ฐ ์ด๋ฒคํธ๊ฐ ๋
๋ฆฝ์ ์ผ๋ก ๋์๊ฐ๋ฉด์ ์๋ก ๋ธ๋กํนํ์ง ์๊ฑฐ๋ ๐ช
ํนํ DeFi ํ๋กํ ์ฝ์ฒ๋ผ ์ด๋ฒคํธ๊ฐ ๋ง์ด ๋ฐ์ํ๋ ์ปจํธ๋ํธ๋ฅผ ๋ชจ๋ํฐ๋งํ ๋ ์ง์ง ์ ์ฉํด. ๋๊ธฐ ๋ฐฉ์์ผ๋ก ํ๋ฉด ํ๋ ์ฒ๋ฆฌํ๋ ๋์ ๋ค๋ฅธ ์ด๋ฒคํธ๋ฅผ ๋์น ์ ์๋๋ฐ, ๋น๋๊ธฐ๋ ๊ทธ๋ฐ ๊ฑฑ์ ์ด ์์ด!
๐ ์ํ๊ฐ ์ถ์ ๋ฐ ๋ณํ ๊ฐ์ง
์ด๋ฒคํธ ๋ชจ๋ํฐ๋ง๋ ์ค์ํ์ง๋ง, ์ปจํธ๋ํธ์ ์ํ๊ฐ์ ์ฃผ๊ธฐ์ ์ผ๋ก ์ฒดํฌํ๋ ๊ฒ๋ ์์ฒญ ์ค์ํด! ์๋ฅผ ๋ค์ด ํ ํฐ ์ด ๊ณต๊ธ๋, ์ ๋์ฑ ํ ์์ก, ๊ฑฐ๋ฒ๋์ค ํฌํ ํํฉ ๊ฐ์ ๊ฑฐ ๋ง์ด์ผ ๐
class StateMonitor:
def __init__(self, w3, contract):
self.w3 = w3
self.contract = contract
self.state_history = {}
def track_state_variable(self, var_name, threshold=None):
"""์ํ ๋ณ์ ์ถ์ """
try:
# ์ปจํธ๋ํธ ํจ์ ํธ์ถ
current_value = getattr(self.contract.functions, var_name)().call()
# ์ด์ ๊ฐ๊ณผ ๋น๊ต
if var_name in self.state_history:
previous_value = self.state_history[var_name]
if current_value != previous_value:
change = current_value - previous_value
change_percent = (change / previous_value * 100) if previous_value != 0 else 0
print(f"\n๐ [{var_name}] ์ํ ๋ณํ ๊ฐ์ง!")
print(f"์ด์ ๊ฐ: {previous_value}")
print(f"ํ์ฌ ๊ฐ: {current_value}")
print(f"๋ณํ๋: {change} ({change_percent:.2f}%)")
# ์๊ณ๊ฐ ์ฒดํฌ
if threshold and abs(change_percent) > threshold:
self.alert_threshold_exceeded(var_name, change_percent)
# ํ์ฌ ๊ฐ ์ ์ฅ
self.state_history[var_name] = current_value
return current_value
except Exception as e:
print(f"โ {var_name} ์กฐํ ์คํจ: {str(e)}")
return None
def alert_threshold_exceeded(self, var_name, change_percent):
"""์๊ณ๊ฐ ์ด๊ณผ ์๋ฆผ"""
print(f"๐จ ๊ฒฝ๊ณ ! {var_name}์ด(๊ฐ) {change_percent:.2f}% ๋ณ๋!")
# ์ฌ๊ธฐ์ ๋์ค์ฝ๋, ํ
๋ ๊ทธ๋จ, ์ด๋ฉ์ผ ๋ฑ์ผ๋ก ์๋ฆผ ์ ์ก
async def continuous_monitoring(self, variables, interval=10):
"""์ง์์ ์ธ ์ํ ๋ชจ๋ํฐ๋ง"""
print(f"๐ ์ํ ๋ชจ๋ํฐ๋ง ์์ (๊ฐ๊ฒฉ: {interval}์ด)")
while True:
print(f"\nโฐ {datetime.now().strftime('%H:%M:%S')} - ์ํ ์ฒดํฌ")
for var_name, threshold in variables.items():
self.track_state_variable(var_name, threshold)
await asyncio.sleep(interval)
# ์ฌ์ฉ ์์
async def monitor_defi_protocol():
# Web3 ๋ฐ ์ปจํธ๋ํธ ์ค์
w3 = Web3(Web3.HTTPProvider(os.getenv('INFURA_URL')))
with open('defi_abi.json', 'r') as f:
abi = json.load(f)
contract = w3.eth.contract(
address=Web3.to_checksum_address(os.getenv('CONTRACT_ADDRESS')),
abi=abi
)
monitor = StateMonitor(w3, contract)
# ๋ชจ๋ํฐ๋งํ ๋ณ์์ ์๊ณ๊ฐ ์ค์
variables_to_track = {
'totalSupply': 5.0, # 5% ์ด์ ๋ณ๋ ์ ์๋ฆผ
'totalLiquidity': 10.0, # 10% ์ด์ ๋ณ๋ ์ ์๋ฆผ
'rewardRate': 2.0, # 2% ์ด์ ๋ณ๋ ์ ์๋ฆผ
}
await monitor.continuous_monitoring(variables_to_track, interval=30)
asyncio.run(monitor_defi_protocol())
์ด ์ฝ๋๋ ์ฃผ๊ธฐ์ ์ผ๋ก ์ปจํธ๋ํธ์ ์ํ๊ฐ์ ์ฝ์ด์์ ์ด์ ๊ฐ๊ณผ ๋น๊ตํด. ๋ณํ๊ฐ ์์ผ๋ฉด ๋ก๊ทธ๋ฅผ ๋จ๊ธฐ๊ณ , ์ค์ ํ ์๊ณ๊ฐ์ ๋์ผ๋ฉด ์๋ฆผ์ ๋ณด๋ด๋ ๊ฑฐ์ง! ๐ฌ
์ค์ ๋ก DeFi ํ๋กํ ์ฝ ์ด์ํ ๋ ์ด๋ฐ ๋ชจ๋ํฐ๋ง์ด ์ง์ง ์ค์ํด. ๊ฐ์๊ธฐ ์ ๋์ฑ์ด ๋น ์ง๊ฑฐ๋ ์ด์ํ ํจํด์ด ๊ฐ์ง๋๋ฉด ๋ฐ๋ก ๋์ํ ์ ์๊ฑฐ๋ !
๐ ์๋ฆผ ์์คํ ๊ตฌ์ถํ๊ธฐ
๋ชจ๋ํฐ๋ง๋ง ํ๊ณ ์๋ฆผ์ด ์์ผ๋ฉด ๋ฌด์จ ์์ฉ์ด์ผ? ใ ใ ใ ์ค์ํ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ์ ๋ ๋ฐ๋ก ์๋ ค์ฃผ๋ ์์คํ ์ ๋ง๋ค์ด๋ณด์! ๋์ค์ฝ๋ ์นํ ์ ์ฌ์ฉํ๋ฉด ์ง์ง ๊ฐ๋จํด ๐
import aiohttp
import json
class NotificationSystem:
def __init__(self, discord_webhook=None, telegram_token=None):
self.discord_webhook = discord_webhook
self.telegram_token = telegram_token
async def send_discord_alert(self, title, description, color=0x5865F2):
"""๋์ค์ฝ๋ ์๋ฆผ ์ ์ก"""
if not self.discord_webhook:
return
embed = {
"embeds": [{
"title": title,
"description": description,
"color": color,
"timestamp": datetime.utcnow().isoformat(),
"footer": {
"text": "์ค๋งํธ์ปจํธ๋ํธ ๋ชจ๋ํฐ๋ง ์์คํ
"
}
}]
}
async with aiohttp.ClientSession() as session:
async with session.post(self.discord_webhook, json=embed) as resp:
if resp.status == 204:
print("โ
๋์ค์ฝ๋ ์๋ฆผ ์ ์ก ์๋ฃ")
else:
print(f"โ ๋์ค์ฝ๋ ์๋ฆผ ์คํจ: {resp.status}")
async def send_critical_alert(self, event_name, event_data):
"""๊ธด๊ธ ์๋ฆผ (์ฌ๋ฌ ์ฑ๋๋ก ๋์ ์ ์ก)"""
title = f"๐จ ๊ธด๊ธ: {event_name} ์ด๋ฒคํธ ๋ฐ์!"
description = f"""
**๋ธ๋ก ๋ฒํธ:** {event_data['blockNumber']}
**ํธ๋์ญ์
:** {event_data['transactionHash'].hex()[:20]}...
**์๊ฐ:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
**์ด๋ฒคํธ ๋ฐ์ดํฐ:**
```json
{json.dumps(dict(event_data['args']), indent=2, default=str)}
```
"""
# ๋์ค์ฝ๋๋ก ์ ์ก
await self.send_discord_alert(title, description, color=0xFF0000)
# ํ
๋ ๊ทธ๋จ์ผ๋ก๋ ์ ์ก ๊ฐ๋ฅ
# await self.send_telegram_alert(title, description)
def format_transfer_alert(self, event):
"""Transfer ์ด๋ฒคํธ ์ ์ฉ ํฌ๋งท"""
from_addr = event['args']['from']
to_addr = event['args']['to']
value = Web3.from_wei(event['args']['value'], 'ether')
# ๊ณ ๋ ๊ฑฐ๋ ๊ฐ์ง (์: 1000 ETH ์ด์)
if value > 1000:
return {
'title': '๐ ๊ณ ๋ ๊ฑฐ๋ ๊ฐ์ง!',
'description': f"""
**๋๋ ์ ์ก ๋ฐ์**
From: `{from_addr[:10]}...{from_addr[-8:]}`
To: `{to_addr[:10]}...{to_addr[-8:]}`
Amount: **{value:.2f} ETH**
[ํธ๋์ญ์
๋ณด๊ธฐ](https://etherscan.io/tx/{event['transactionHash'].hex()})
""",
'color': 0xFFD700 # ๊ธ์
}
return None
# ํตํฉ ๋ชจ๋ํฐ๋ง ์์คํ
class IntegratedMonitor:
def __init__(self, provider_url, contract_address, abi_path):
self.w3 = Web3(Web3.HTTPProvider(provider_url))
with open(abi_path, 'r') as f:
abi = json.load(f)
self.contract = self.w3.eth.contract(
address=Web3.to_checksum_address(contract_address),
abi=abi
)
self.notifier = NotificationSystem(
discord_webhook=os.getenv('DISCORD_WEBHOOK')
)
async def smart_event_handler(self, event_name, event_data):
"""์ค๋งํธ ์ด๋ฒคํธ ํธ๋ค๋ฌ"""
# ์ด๋ฒคํธ ํ์
๋ณ ์ฒ๋ฆฌ
if event_name == 'Transfer':
alert = self.notifier.format_transfer_alert(event_data)
if alert:
await self.notifier.send_discord_alert(**alert)
elif event_name == 'Approval':
# Approval ์ด๋ฒคํธ ์ฒ๋ฆฌ
pass
elif event_name == 'Mint' or event_name == 'Burn':
# ๊ณต๊ธ๋ ๋ณํ ์ด๋ฒคํธ๋ ํญ์ ์๋ฆผ
await self.notifier.send_critical_alert(event_name, event_data)
# ๋ชจ๋ ์ด๋ฒคํธ DB์ ์ ์ฅ
await self.save_event_to_db(event_name, event_data)
async def save_event_to_db(self, event_name, event_data):
"""์ด๋ฒคํธ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฅ"""
# SQLAlchemy ๋ฑ์ ์ฌ์ฉํ DB ์ ์ฅ ๋ก์ง
pass
์ด๋ ๊ฒ ํ๋ฉด ์ค์ํ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ์ ๋ ๋์ค์ฝ๋๋ก ๋ฐ๋ก ์๋ฆผ์ด ์! ํนํ ๊ณ ๋ ๊ฑฐ๋ ๊ฐ์ ํน์ด ์ผ์ด์ค๋ฅผ ๋ฐ๋ก ๊ฐ์งํด์ ์๋ ค์ฃผ๋ ๊ฒ ํฌ์ธํธ์ผ ๐
์ฌ๋ฅ๋ท์์ ๋ธ๋ก์ฒด์ธ ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ฑฐ๋ํ๋ ๋ถ๋ค๋ ์ด๋ฐ ๋ชจ๋ํฐ๋ง ์์คํ
๊ตฌ์ถ ์๋น์ค๋ฅผ ์ ๊ณตํ๋ฉด ์ข์ ๊ฒ ๊ฐ์. ์์๊ฐ ๊ฝค ์์ ๊ฑฐ์ผ!
๐พ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐ ๋ถ์
๋ชจ๋ํฐ๋งํ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋ฅ ๋ฒ๋ฆฌ๋ฉด ์๊น์! ๋์ค์ ๋ถ์ํ๋ ค๋ฉด DB์ ์ ์ฅํด๋๋ ๊ฒ ์ข์. SQLite๋ก ๊ฐ๋จํ๊ฒ ์์ํ ์๋ ์๊ณ , PostgreSQL๋ก ๋ณธ๊ฒฉ์ ์ผ๋ก ํ ์๋ ์์ด ๐๏ธ
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, JSON
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
Base = declarative_base()
class BlockchainEvent(Base):
"""๋ธ๋ก์ฒด์ธ ์ด๋ฒคํธ ํ
์ด๋ธ"""
__tablename__ = 'blockchain_events'
id = Column(Integer, primary_key=True)
event_name = Column(String(100), nullable=False)
block_number = Column(Integer, nullable=False, index=True)
transaction_hash = Column(String(66), nullable=False, unique=True)
contract_address = Column(String(42), nullable=False)
event_data = Column(JSON)
timestamp = Column(DateTime, default=datetime.utcnow)
class StateSnapshot(Base):
"""์ํ ์ค๋
์ท ํ
์ด๋ธ"""
__tablename__ = 'state_snapshots'
id = Column(Integer, primary_key=True)
variable_name = Column(String(100), nullable=False)
value = Column(Float, nullable=False)
block_number = Column(Integer, nullable=False)
timestamp = Column(DateTime, default=datetime.utcnow)
class DatabaseManager:
def __init__(self, db_url='sqlite:///blockchain_monitor.db'):
self.engine = create_engine(db_url)
Base.metadata.create_all(self.engine)
Session = sessionmaker(bind=self.engine)
self.session = Session()
async def save_event(self, event_name, event_data):
"""์ด๋ฒคํธ ์ ์ฅ"""
try:
event_record = BlockchainEvent(
event_name=event_name,
block_number=event_data['blockNumber'],
transaction_hash=event_data['transactionHash'].hex(),
contract_address=event_data['address'],
event_data=dict(event_data['args'])
)
self.session.add(event_record)
self.session.commit()
print(f"๐พ ์ด๋ฒคํธ ์ ์ฅ ์๋ฃ: {event_name}")
except Exception as e:
self.session.rollback()
print(f"โ DB ์ ์ฅ ์คํจ: {str(e)}")
async def save_state_snapshot(self, var_name, value, block_number):
"""์ํ ์ค๋
์ท ์ ์ฅ"""
snapshot = StateSnapshot(
variable_name=var_name,
value=float(value),
block_number=block_number
)
self.session.add(snapshot)
self.session.commit()
def get_event_history(self, event_name, limit=100):
"""์ด๋ฒคํธ ํ์คํ ๋ฆฌ ์กฐํ"""
return self.session.query(BlockchainEvent)\
.filter_by(event_name=event_name)\
.order_by(BlockchainEvent.timestamp.desc())\
.limit(limit)\
.all()
def get_state_trend(self, var_name, hours=24):
"""์ํ ๋ณํ ํธ๋ ๋ ์กฐํ"""
cutoff = datetime.utcnow() - timedelta(hours=hours)
return self.session.query(StateSnapshot)\
.filter_by(variable_name=var_name)\
.filter(StateSnapshot.timestamp >= cutoff)\
.order_by(StateSnapshot.timestamp.asc())\
.all()
def analyze_transaction_pattern(self):
"""ํธ๋์ญ์
ํจํด ๋ถ์"""
# ์๊ฐ๋๋ณ ํธ๋์ญ์
์
# ๊ฐ์ฅ ํ๋ฐํ ์ฃผ์
# ํ๊ท ๊ฑฐ๋ ๊ธ์ก ๋ฑ
pass
# ์ฌ์ฉ ์์
db = DatabaseManager()
# ์ด๋ฒคํธ ์ ์ฅ
await db.save_event('Transfer', event_data)
# ํ์คํ ๋ฆฌ ์กฐํ
recent_transfers = db.get_event_history('Transfer', limit=50)
for transfer in recent_transfers:
print(f"{transfer.timestamp}: {transfer.event_data}")
DB์ ์ ์ฅํด๋๋ฉด ๋์ค์ ๋์๋ณด๋ ๋ง๋ค ๋๋ ์ ์ฉํ๊ณ , ํจํด ๋ถ์ํ ๋๋ ์ข์! ์๋ฅผ ๋ค์ด ํน์ ์๊ฐ๋์ ๊ฑฐ๋๊ฐ ๋ชฐ๋ฆฌ๋์ง, ์ด๋ค ์ฃผ์๊ฐ ๊ฐ์ฅ ํ๋ฐํ์ง ์ด๋ฐ ๊ฑธ ๋ถ์ํ ์ ์๊ฑฐ๋ ๐
๐จ ๋์๋ณด๋ ๋ง๋ค๊ธฐ
๋ฐ์ดํฐ๋ฅผ ์๊ฐํํ๋ฉด ํจ์ฌ ์ง๊ด์ ์ด์์? Streamlit์ด๋ Dash ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐ๋ฉด ๊ฐ๋จํ๊ฒ ์น ๋์๋ณด๋๋ฅผ ๋ง๋ค ์ ์์ด! ใ ใ
import streamlit as st
import pandas as pd
import plotly.express as px
from datetime import datetime, timedelta
class MonitoringDashboard:
def __init__(self, db_manager):
self.db = db_manager
def run(self):
st.set_page_config(
page_title="์ค๋งํธ์ปจํธ๋ํธ ๋ชจ๋ํฐ๋ง",
page_icon="๐",
layout="wide"
)
st.title("๐ ์ค๋งํธ์ปจํธ๋ํธ ์ค์๊ฐ ๋ชจ๋ํฐ๋ง ๋์๋ณด๋")
# ์ฌ์ด๋๋ฐ
with st.sidebar:
st.header("โ๏ธ ์ค์ ")
time_range = st.selectbox(
"์๊ฐ ๋ฒ์",
["1์๊ฐ", "6์๊ฐ", "24์๊ฐ", "7์ผ"]
)
event_filter = st.multiselect(
"์ด๋ฒคํธ ํํฐ",
["Transfer", "Approval", "Mint", "Burn"],
default=["Transfer"]
)
# ๋ฉ์ธ ๋์๋ณด๋
col1, col2, col3 = st.columns(3)
with col1:
st.metric(
label="์ด ์ด๋ฒคํธ ์",
value="1,234",
delta="โ 15%"
)
with col2:
st.metric(
label="ํ์ฑ ์ฃผ์",
value="456",
delta="โ 8%"
)
with col3:
st.metric(
label="์ด ๊ฑฐ๋๋",
value="12,345 ETH",
delta="โ 3%"
)
# ์ฐจํธ
st.subheader("๐ ์๊ฐ๋ณ ํธ๋์ญ์
์ถ์ด")
# ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
df = self.get_transaction_data(time_range)
fig = px.line(
df,
x='timestamp',
y='count',
title='์๊ฐ๋ณ ํธ๋์ญ์
์'
)
st.plotly_chart(fig, use_container_width=True)
# ์ต๊ทผ ์ด๋ฒคํธ ํ
์ด๋ธ
st.subheader("๐ ์ต๊ทผ ์ด๋ฒคํธ")
recent_events = self.db.get_event_history('Transfer', limit=20)
events_df = pd.DataFrame([
{
'์๊ฐ': e.timestamp.strftime('%Y-%m-%d %H:%M:%S'),
'์ด๋ฒคํธ': e.event_name,
'๋ธ๋ก': e.block_number,
'TX Hash': e.transaction_hash[:20] + '...'
}
for e in recent_events
])
st.dataframe(events_df, use_container_width=True)
def get_transaction_data(self, time_range):
"""์๊ฐ๋ณ ํธ๋์ญ์
๋ฐ์ดํฐ ์์ฑ"""
# ์ค์ ๋ก๋ DB์์ ๊ฐ์ ธ์์ผ ํจ
hours = {'1์๊ฐ': 1, '6์๊ฐ': 6, '24์๊ฐ': 24, '7์ผ': 168}[time_range]
dates = pd.date_range(
end=datetime.now(),
periods=hours,
freq='H'
)
df = pd.DataFrame({
'timestamp': dates,
'count': [random.randint(10, 100) for _ in range(hours)]
})
return df
# ์คํ
if __name__ == "__main__":
db = DatabaseManager()
dashboard = MonitoringDashboard(db)
dashboard.run()
Streamlit์ผ๋ก ๋ง๋ค๋ฉด ์ง์ง ๋น ๋ฅด๊ฒ ํ๋กํ ํ์ ์ ๋ง๋ค ์ ์์ด! ์ค์๊ฐ์ผ๋ก ๋ฐ์ดํฐ๊ฐ ์ ๋ฐ์ดํธ๋๋ ๋์๋ณด๋๋ฅผ ๋ช ์ค ์ ๋๋ ์ฝ๋๋ก ๋๋ฑ ๋ง๋ค ์ ์๊ฑฐ๋ ใ ใ ๐
๐ก ์ฌ๋ฅ๋ท ํ์ฉ ํ: ๋์๋ณด๋ ๋์์ธ์ด๋ ๋ฐ์ดํฐ ์๊ฐํ์ ์์ ์์ผ๋ฉด ์ฌ๋ฅ๋ท์์ ํ๋ก ํธ์๋ ๊ฐ๋ฐ์๋ ๋์์ด๋์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๋ฐฑ์๋๋ ๋ด๊ฐ ํ๊ณ UI/UX๋ ์ ๋ฌธ๊ฐํํ ๋งก๊ธฐ๋ ๊ฑฐ์ง ๐จ
โ ๏ธ ์๋ฌ ์ฒ๋ฆฌ ๋ฐ ์์ ์ฑ ํ๋ณด
์ค์ ์ด์ ํ๊ฒฝ์์๋ ์๋ฌ ์ฒ๋ฆฌ๊ฐ ์ง์ง ์ค์ํด! ๋คํธ์ํฌ ๋๊น, API ์ ํ, ์์์น ๋ชปํ ๋ฐ์ดํฐ ํ์ ๋ฑ๋ฑ... ์จ๊ฐ ๋ฌธ์ ๊ฐ ๋ค ์๊ธฐ๊ฑฐ๋ ใ ใ
import logging
from tenacity import retry, stop_after_attempt, wait_exponential
# ๋ก๊น
์ค์
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('monitor.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
class RobustMonitor:
def __init__(self, provider_urls):
"""์ฌ๋ฌ ํ๋ก๋ฐ์ด๋๋ก ์ฅ์ ๋์"""
self.provider_urls = provider_urls
self.current_provider_index = 0
self.w3 = self.connect_to_provider()
def connect_to_provider(self):
"""ํ๋ก๋ฐ์ด๋ ์ฐ๊ฒฐ (์ฅ์ ์ ๋ค์ ํ๋ก๋ฐ์ด๋๋ก ์ ํ)"""
for i in range(len(self.provider_urls)):
try:
url = self.provider_urls[self.current_provider_index]
w3 = Web3(Web3.HTTPProvider(url))
if w3.is_connected():
logger.info(f"โ
ํ๋ก๋ฐ์ด๋ ์ฐ๊ฒฐ ์ฑ๊ณต: {url}")
return w3
except Exception as e:
logger.error(f"โ ํ๋ก๋ฐ์ด๋ ์ฐ๊ฒฐ ์คํจ: {str(e)}")
self.current_provider_index = (self.current_provider_index + 1) % len(self.provider_urls)
raise Exception("๋ชจ๋ ํ๋ก๋ฐ์ด๋ ์ฐ๊ฒฐ ์คํจ!")
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=2, max=10)
)
async def fetch_events_with_retry(self, event_filter):
"""์ฌ์๋ ๋ก์ง์ด ์๋ ์ด๋ฒคํธ ์กฐํ"""
try:
events = event_filter.get_new_entries()
return events
except Exception as e:
logger.warning(f"โ ๏ธ ์ด๋ฒคํธ ์กฐํ ์คํจ, ์ฌ์๋ ์ค... {str(e)}")
# ํ๋ก๋ฐ์ด๋ ์ ํ
self.w3 = self.connect_to_provider()
raise # ์ฌ์๋๋ฅผ ์ํด ์์ธ ๋ค์ ๋ฐ์
async def safe_event_processing(self, event_data):
"""์์ ํ ์ด๋ฒคํธ ์ฒ๋ฆฌ"""
try:
# ๋ฐ์ดํฐ ๊ฒ์ฆ
if not self.validate_event_data(event_data):
logger.error(f"โ ์ ํจํ์ง ์์ ์ด๋ฒคํธ ๋ฐ์ดํฐ: {event_data}")
return
# ์ฒ๋ฆฌ
await self.process_event(event_data)
except Exception as e:
logger.error(f"โ ์ด๋ฒคํธ ์ฒ๋ฆฌ ์ค ์๋ฌ: {str(e)}", exc_info=True)
# ์คํจํ ์ด๋ฒคํธ๋ ๋ณ๋ ํ์ ์ ์ฅ
await self.save_failed_event(event_data, str(e))
def validate_event_data(self, event_data):
"""์ด๋ฒคํธ ๋ฐ์ดํฐ ๊ฒ์ฆ"""
required_fields = ['blockNumber', 'transactionHash', 'args']
for field in required_fields:
if field not in event_data:
return False
return True
async def health_check(self):
"""์์คํ
ํฌ์ค ์ฒดํฌ"""
try:
# ๋ธ๋ก์ฒด์ธ ์ฐ๊ฒฐ ํ์ธ
block_number = self.w3.eth.block_number
logger.info(f"๐ ํฌ์ค ์ฒดํฌ OK - ํ์ฌ ๋ธ๋ก: {block_number}")
# DB ์ฐ๊ฒฐ ํ์ธ
# API ์ฐ๊ฒฐ ํ์ธ
# ๋ฑ๋ฑ...
return True
except Exception as e:
logger.error(f"๐ ํฌ์ค ์ฒดํฌ ์คํจ: {str(e)}")
return False
async def monitoring_loop_with_recovery(self):
"""๋ณต๊ตฌ ๊ธฐ๋ฅ์ด ์๋ ๋ชจ๋ํฐ๋ง ๋ฃจํ"""
consecutive_failures = 0
max_failures = 5
while True:
try:
# ํฌ์ค ์ฒดํฌ
if not await self.health_check():
consecutive_failures += 1
if consecutive_failures >= max_failures:
logger.critical("๐จ ์ฐ์ ์คํจ ํ๊ณ ๋๋ฌ! ์์คํ
์ฌ์์ ํ์")
# ์๋ฆผ ์ ์ก
await self.send_critical_alert("์์คํ
์ฅ์ ๋ฐ์")
# ์ฌ์์ ์๋
await self.restart_system()
consecutive_failures = 0
await asyncio.sleep(30)
continue
# ์ ์ ๋์
consecutive_failures = 0
await self.monitor_events()
await asyncio.sleep(2)
except KeyboardInterrupt:
logger.info("๐ ๋ชจ๋ํฐ๋ง ์ข
๋ฃ")
break
except Exception as e:
logger.error(f"โ ์์์น ๋ชปํ ์๋ฌ: {str(e)}", exc_info=True)
await asyncio.sleep(10)
์ด๋ ๊ฒ ์๋ฌ ์ฒ๋ฆฌ๋ฅผ ํํํ๊ฒ ํด๋๋ฉด ๋ฐค์ ํน ์ ์ ์์ด ใ
ใ
ใ
๐ด
ํนํ ์ฌ๋ฌ ํ๋ก๋ฐ์ด๋๋ฅผ ์ค์ ํด๋๊ณ ํ๋๊ฐ ๋ค์ด๋๋ฉด ์๋์ผ๋ก ๋ค๋ฅธ ๊ฑธ๋ก ์ ํ๋๊ฒ ํ๋ ๊ฒ ์ง์ง ์ค์ํด. Infura๊ฐ ๊ฐ๋ ๋ถ์์ ํ ๋๊ฐ ์๊ฑฐ๋ !
๐ ์ฑ๋ฅ ์ต์ ํ ํ
๋ชจ๋ํฐ๋ง ์์คํ ์ด ๋ฌด๊ฑฐ์์ง๋ฉด ๋ธ๋ก์ ๋์น ์๋ ์์ด. ์ฑ๋ฅ ์ต์ ํ๋ ํ์์ผ! ๐จ
| ์ต์ ํ ํญ๋ชฉ | ๋ฐฉ๋ฒ | ํจ๊ณผ |
|---|---|---|
| ๋ฐฐ์น ์ฒ๋ฆฌ | ์ฌ๋ฌ ๋ธ๋ก์ ํ ๋ฒ์ ์กฐํ | API ํธ์ถ 50% ๊ฐ์ |
| ์บ์ฑ | ์์ฃผ ์กฐํํ๋ ๋ฐ์ดํฐ ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ | ์๋ต ์๋ 10๋ฐฐ ํฅ์ |
| ๋น๋๊ธฐ ์ฒ๋ฆฌ | asyncio ํ์ฉ | ๋์ ์ฒ๋ฆฌ๋ 5๋ฐฐ ์ฆ๊ฐ |
| ์ธ๋ฑ์ฑ | DB ์ธ๋ฑ์ค ์ต์ ํ | ์ฟผ๋ฆฌ ์๋ 100๋ฐฐ ํฅ์ |
| ์ฐ๊ฒฐ ํ๋ง | DB ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ | ์ค๋ฒํค๋ 80% ๊ฐ์ |
from functools import lru_cache
import asyncio
class OptimizedMonitor:
def __init__(self):
self.cache = {}
self.batch_size = 10 # ํ ๋ฒ์ 10๊ฐ ๋ธ๋ก ์ฒ๋ฆฌ
@lru_cache(maxsize=1000)
def get_contract_abi(self, address):
"""ABI ์บ์ฑ"""
# ํ ๋ฒ ๋ก๋ํ ABI๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ
pass
async def batch_process_blocks(self, start_block, end_block):
"""๋ธ๋ก ๋ฐฐ์น ์ฒ๋ฆฌ"""
tasks = []
for block_num in range(start_block, end_block, self.batch_size):
batch_end = min(block_num + self.batch_size, end_block)
task = self.process_block_range(block_num, batch_end)
tasks.append(task)
results = await asyncio.gather(*tasks)
return results
async def process_block_range(self, start, end):
"""๋ธ๋ก ๋ฒ์ ์ฒ๋ฆฌ"""
events = []
# ํ ๋ฒ์ API ํธ์ถ๋ก ์ฌ๋ฌ ๋ธ๋ก์ ์ด๋ฒคํธ ์กฐํ
event_filter = self.contract.events.Transfer.create_filter(
fromBlock=start,
toBlock=end
)
events = event_filter.get_all_entries()
return events
def use_connection_pool(self):
"""DB ์ฐ๊ฒฐ ํ ์ฌ์ฉ"""
from sqlalchemy.pool import QueuePool
engine = create_engine(
'postgresql://user:pass@localhost/db',
poolclass=QueuePool,
pool_size=10,
max_overflow=20
)
return engine
๋ฐฐ์น ์ฒ๋ฆฌ๋ ์บ์ฑ๋ง ์ ์จ๋ ์ฑ๋ฅ์ด ์์ฒญ ์ฌ๋ผ๊ฐ! ํนํ ๊ณผ๊ฑฐ ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํ ๋๋ ๋ฐฐ์น ์ฒ๋ฆฌ๊ฐ ํ์์ผ ๐ฅ
๐ ๋ณด์ ๊ณ ๋ ค์ฌํญ
๋ชจ๋ํฐ๋ง ์์คํ ๋ ๋ณด์์ด ์ค์ํด! ํนํ ํ๋ผ์ด๋น ํค๋ฅผ ๋ค๋ฃจ๋ ๊ฒฝ์ฐ๋ ๋๋์ฑ ์กฐ์ฌํด์ผ ํด ๐
โ ๏ธ ์ ๋ ํ์ง ๋ง์์ผ ํ ๊ฒ๋ค:
โ ํ๋ผ์ด๋น ํค๋ฅผ ์ฝ๋์ ํ๋์ฝ๋ฉ
โ .env ํ์ผ์ Git์ ์ปค๋ฐ
โ API ํค๋ฅผ ๋ก๊ทธ์ ์ถ๋ ฅ
โ ๊ฒ์ฆ๋์ง ์์ ์
๋ ฅ๊ฐ ์ฌ์ฉ
โ HTTPS ์์ด ๋ฏผ๊ฐํ ๋ฐ์ดํฐ ์ ์ก
import os
from cryptography.fernet import Fernet
class SecureMonitor:
def __init__(self):
# ํ๊ฒฝ๋ณ์์์ ์ํธํ ํค ๋ก๋
self.cipher_suite = Fernet(os.getenv('ENCRYPTION_KEY').encode())
def encrypt_sensitive_data(self, data):
"""๋ฏผ๊ฐํ ๋ฐ์ดํฐ ์ํธํ"""
encrypted = self.cipher_suite.encrypt(data.encode())
return encrypted
def decrypt_sensitive_data(self, encrypted_data):
"""์ํธํ๋ ๋ฐ์ดํฐ ๋ณตํธํ"""
decrypted = self.cipher_suite.decrypt(encrypted_data)
return decrypted.decode()
def sanitize_log_data(self, data):
"""๋ก๊ทธ ๋ฐ์ดํฐ ์ ์ (๋ฏผ๊ฐ ์ ๋ณด ์ ๊ฑฐ)"""
if isinstance(data, dict):
sanitized = data.copy()
# ํ๋ผ์ด๋น ํค, ์๋ ๋ฑ ์ ๊ฑฐ
sensitive_keys = ['privateKey', 'seed', 'password', 'secret']
for key in sensitive_keys:
if key in sanitized:
sanitized[key] = '***REDACTED***'
return sanitized
return data
def validate_contract_address(self, address):
"""์ปจํธ๋ํธ ์ฃผ์ ๊ฒ์ฆ"""
if not Web3.is_address(address):
raise ValueError(f"์ ํจํ์ง ์์ ์ฃผ์: {address}")
# ์ฒดํฌ์ฌ ์ฃผ์๋ก ๋ณํ
return Web3.to_checksum_address(address)
๋ณด์์ ์๋ฌด๋ฆฌ ๊ฐ์กฐํด๋ ์ง๋์น์ง ์์! ํนํ ๋ฉ์ธ๋ท์์ ์ค์ ์์ฐ์ ๋ค๋ฃจ๋ ์ปจํธ๋ํธ๋ฅผ ๋ชจ๋ํฐ๋งํ ๋๋ ๋๋์ฑ ์กฐ์ฌํด์ผ ํด ๐ก๏ธ
๐ฑ ์ค์ ํ์ฉ ์ฌ๋ก
์ด๋ก ๋ง ์์์๋ ์ฌ๋ฏธ์์์? ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ๋์ง ๋ช ๊ฐ์ง ์ฌ๋ก๋ฅผ ๋ณด์ฌ์ค๊ฒ! ๐ฏ
์ฌ๋ก 1: NFT ๋ง์ผํ๋ ์ด์ค ๋ชจ๋ํฐ๋ง OpenSea ๊ฐ์ NFT ๋ง์ผํ๋ ์ด์ค์ ๊ฑฐ๋๋ฅผ ์ค์๊ฐ์ผ๋ก ์ถ์ ํด์ ํฌ๊ท NFT๊ฐ ๊ฑฐ๋๋๋ฉด ๋ฐ๋ก ์๋ฆผ์ ๋ฐ์ ์ ์์ด. ํนํ ํ๋ก์ด ํ๋ผ์ด์ค๋ณด๋ค ๋ฎ์ ๊ฐ๊ฒฉ์ ๋ฆฌ์คํ ๋๋ฉด ์ค๋์ดํ ๊ธฐํ๋ฅผ ์ก์ ์ ์์ง! ๐จ
class NFTMarketMonitor:
async def monitor_listings(self):
"""์ ๋ฆฌ์คํ
๋ชจ๋ํฐ๋ง"""
event_filter = self.contract.events.ItemListed.create_filter(
fromBlock='latest'
)
while True:
for event in event_filter.get_new_entries():
listing = event['args']
# ํ๋ก์ด ํ๋ผ์ด์ค ํ์ธ
floor_price = await self.get_floor_price(listing['collection'])
if listing['price'] < floor_price * 0.8: # 20% ์ดํ
await self.send_alert(
f"๐ฅ ์ค๋์ดํ ๊ธฐํ! {listing['tokenId']} "
f"ํ๋ก์ด ๋๋น {((floor_price - listing['price']) / floor_price * 100):.1f}% ์ ๋ ด"
)
await asyncio.sleep(1)
์ฌ๋ก 2: DeFi ํ๋กํ ์ฝ ๋ฆฌ์คํฌ ๋ชจ๋ํฐ๋ง ์ ๋์ฑ ํ์ ์ํ๋ฅผ ์ค์๊ฐ์ผ๋ก ์ฒดํฌํด์ ์ํฉํธ ํ๋ผ์ด์ค๊ฐ ๋๋ฌด ๋์์ง๊ฑฐ๋, ์ ๋์ฑ์ด ๊ธ๊ฒฉํ ๋น ์ง๋ ๊ฑธ ๊ฐ์งํ ์ ์์ด. ์ด๋ฐ ์ ๋ณด๋ ํฌ์ ๊ฒฐ์ ์ ์์ฒญ ์ค์ํ๊ฑฐ๋ ! ๐ฐ
class DeFiRiskMonitor:
async def monitor_liquidity_pool(self):
"""์ ๋์ฑ ํ ๋ชจ๋ํฐ๋ง"""
while True:
# ํ์ฌ ์ ๋์ฑ ์กฐํ
reserves = await self.get_reserves()
total_liquidity = reserves[0] * reserves[1]
# ์ด์ ๊ฐ๊ณผ ๋น๊ต
if hasattr(self, 'prev_liquidity'):
change = (total_liquidity - self.prev_liquidity) / self.prev_liquidity
if abs(change) > 0.1: # 10% ์ด์ ๋ณ๋
await self.send_alert(
f"โ ๏ธ ์ ๋์ฑ ๊ธ๋ณ! {change*100:.1f}% ๋ณ๋\n"
f"ํ์ฌ ์ ๋์ฑ: ${total_liquidity:,.0f}"
)
self.prev_liquidity = total_liquidity
await asyncio.sleep(60) # 1๋ถ๋ง๋ค ์ฒดํฌ
์ฌ๋ก 3: ๊ฐ์ค๋น ์ต์ ํ ๋ชจ๋ํฐ๋ง ๊ฐ์ค๋น๊ฐ ๋ฎ์ ๋๋ฅผ ๋ ธ๋ ค์ ํธ๋์ญ์ ์ ๋ณด๋ด๋ฉด ๋น์ฉ์ ์์ฒญ ์ ์ฝํ ์ ์์ด! ํนํ ๋๋์ ํธ๋์ญ์ ์ ์ฒ๋ฆฌํด์ผ ํ ๋ ์ ์ฉํด โฝ
class GasPriceMonitor:
async def wait_for_low_gas(self, threshold_gwei=30):
"""๋ฎ์ ๊ฐ์ค๋น ๋๊ธฐ"""
print(f"โณ {threshold_gwei} Gwei ์ดํ ๋๊ธฐ ์ค...")
while True:
gas_price = self.w3.eth.gas_price
gas_gwei = Web3.from_wei(gas_price, 'gwei')
print(f"ํ์ฌ ๊ฐ์ค๋น: {gas_gwei:.1f} Gwei")
if gas_gwei <= threshold_gwei:
await self.send_alert(
f"โ
๊ฐ์ค๋น ๋ฎ์! {gas_gwei:.1f} Gwei\n"
f"ํธ๋์ญ์
์ ์กํ๊ธฐ ์ข์ ํ์ด๋ฐ!"
)
return True
await asyncio.sleep(60) # 1๋ถ๋ง๋ค ์ฒดํฌ
๐ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์... ์ฌ๊ธฐ๊น์ง ์ฝ์์ผ๋ฉด ์ง์ง ๋๋จํ ๊ฑฐ์ผ! ใ
ใ
ใ
๐
์ค๋งํธ์ปจํธ๋ํธ ๋ชจ๋ํฐ๋ง ์์คํ
์ ์ฒ์์๋ ๋ณต์กํด ๋ณด์ด์ง๋ง, ํ๋์ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ง๋ค๋ค ๋ณด๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์. ๊ทธ๋ฆฌ๊ณ ํ ๋ฒ ๋ง๋ค์ด๋๋ฉด ์ ๋ง์ ๋ง ์ ์ฉํ๊ฒ ์ธ ์ ์์ด!
ํนํ Web3 ๊ฐ๋ฐ์๋ผ๋ฉด ์ด๋ฐ ๋ชจ๋ํฐ๋ง ์์คํ
์ ํ์ ๋๊ตฌ์ผ. ์ปจํธ๋ํธ ๋ฐฐํฌํ๊ณ ๋์ ๋ญ๊ฐ ์ด์ํ๋ฐ ์์ธ์ ๋ชจ๋ฅด๊ฒ ๋ค? ๊ทธ๋ด ๋ ๋ชจ๋ํฐ๋ง ์์คํ
์ด ์์ผ๋ฉด ๋ฐ๋ก ๋ฌธ์ ๋ฅผ ์ฐพ์ ์ ์๊ฑฐ๋ ! ๐
๐ก ๋ค์ ๋จ๊ณ๋ก ๋์๊ฐ๊ธฐ:
1. ๋จธ์ ๋ฌ๋ ํตํฉ - ์ด์ ํจํด์ ์๋์ผ๋ก ๊ฐ์งํ๋ AI ๋ชจ๋ธ ์ถ๊ฐ
2. ๋ฉํฐ์ฒด์ธ ์ง์ - ์ด๋๋ฆฌ์๋ฟ๋ง ์๋๋ผ ํด๋ฆฌ๊ณค, BSC, ์๋นํธ๋ผ ๋ฑ ์ฌ๋ฌ ์ฒด์ธ ๋์ ๋ชจ๋ํฐ๋ง
3. ๊ณ ๊ธ ๋ถ์ - ์จ์ฒด์ธ ๋ฐ์ดํฐ ๋ถ์์ผ๋ก ํธ๋ ๋ ์์ธก
4. ์๋ ๊ฑฐ๋ - ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋๋ฉด ์๋์ผ๋ก ํธ๋์ญ์
์คํ (MEV ๋ด ๋ฑ)
5. ์ปค๋ฎค๋ํฐ ๊ณต์ - ์คํ์์ค๋ก ๊ณต๊ฐํ๊ฑฐ๋ ์ฌ๋ฅ๋ท์์ ์๋น์ค๋ก ์ ๊ณต
๋ง์ง๋ง์ผ๋ก ํ ๊ฐ์ง ํ! ๋ชจ๋ํฐ๋ง ์์คํ
๊ฐ๋ฐํ๋ค๊ฐ ๋งํ๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ์ฌ๋ฅ๋ท์์ ๋ธ๋ก์ฒด์ธ ์ ๋ฌธ๊ฐ๋คํํ
๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ. ํผ์ ์ฝ์งํ๋ ๊ฒ๋ณด๋ค ์ ๋ฌธ๊ฐ์ ์กฐ์ธ ํ ๋ง๋๊ฐ ํจ์ฌ ํจ์จ์ ์ผ ๋๊ฐ ๋ง๊ฑฐ๋ ! ๐ช
๊ทธ๋ฆฌ๊ณ ๋ฐ๋๋ก ๋ค๊ฐ ์ด ๋ถ์ผ์ ์์ ์๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ์ค๋งํธ์ปจํธ๋ํธ ๋ชจ๋ํฐ๋ง ์์คํ
๊ตฌ์ถ ์๋น์ค๋ฅผ ์ ๊ณตํด๋ณด๋ ๊ฒ๋ ์ข์ ๊ฒ ๊ฐ์. ์์๊ฐ ๊ฝค ์์ ๊ฑฐ์ผ ใ
ใ
์, ์ด์ ์ง์ ๋ง๋ค์ด๋ณผ ์ฐจ๋ก์ผ! ์ฝ๋ ๋ณต๋ถ๋ง ํ์ง ๋ง๊ณ ํ๋ํ๋ ์ดํดํ๋ฉด์ ๋ค ํ๋ก์ ํธ์ ๋ง๊ฒ ์ปค์คํฐ๋ง์ด์งํด๋ด. ๊ทธ๊ฒ ์ง์ง ์ค๋ ฅ์ด ๋์ด๋๋ ๊ธธ์ด๊ฑฐ๋ ! ๐
ํ์ดํ
! ๋ฉ์ง ๋ชจ๋ํฐ๋ง ์์คํ
๋ง๋ค์ด๋ณด์๊ตฌ! ๐ฅ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.