Tech Support 플랫폼: 블록체인 토큰으로 재구성한 기술 지원 서비스

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# backend/app/routers/auth.py

@router.get("/verify-email")
async def verify_email(token: str, db: Session = Depends(get_db)):
    # 1. 토큰 검증
    payload = decode_email_token(token)
    user_id = payload.get("user_id")
    
    # 2. 사용자 조회
    user = db.query(User).filter(User.id == user_id).first()
    
    # 3. 이미 인증됨?
    if user.email_verified:
        raise HTTPException(400, "이미 인증됨")
    
    # 4. ✅ 블록체인 지갑 생성
    from eth_account import Account
    account = Account.create()
    
    # 5. 개인키 암호화 저장
    from cryptography.fernet import Fernet
    fernet = Fernet(settings.WALLET_ENCRYPTION_KEY.encode())
    encrypted_key = fernet.encrypt(account.key.hex().encode())
    
    wallet_key = WalletKey(
        user_id=user.id,
        encrypted_private_key=encrypted_key
    )
    db.add(wallet_key)
    
    # 6. 사용자에 지갑 주소 저장
    user.wallet_address = account.address
    user.email_verified = True
    
    # 7. ✅ KRW 200,000원 지급
    wallet = Wallet(
        user_id=user.id,
        krw_balance=200000.0,  # ← 신규 가입 보너스
        cht_balance=0.0
    )
    db.add(wallet)
    db.commit()
    
    # 8. (TODO) ETH 0.1개 자동 전송
    # send_eth(account.address, 0.1)
    
    return {"message": "이메일 인증 완료! 지갑이 생성되었습니다."}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# backend/app/models.py

class ExchangeRate(Base):
    __tablename__ = "exchange_rates"
    
    id = Column(Integer, primary_key=True)
    base_currency = Column(String, default="USD")
    target_currency = Column(String, default="KRW")
    rate = Column(Numeric(precision=10, scale=4))  # 1477.31
    updated_at = Column(DateTime, default=datetime.utcnow)

1
2
3
4
5
6
7
8

# backend/app/utils/exchange_rate.py

async def fetch_exchange_rate() -> float:
    url = "https://api.exchangerate-api.com/v4/latest/USD"
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        data = response.json()
        return data["rates"]["KRW"]  # 1477.31

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# gateway/cron_jobs.json

{
  "name": "Daily Exchange Rate Update",
  "schedule": {
    "kind": "cron",
    "expr": "0 9 * * *",  # 매일 오전 9시
    "tz": "Asia/Seoul"
  },
  "payload": {
    "kind": "systemEvent",
    "text": "환율 업데이트 요청"
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# backend/app/routers/wallet.py

@router.post("/swap")
async def swap_currency(
    request: SwapRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    wallet = db.query(Wallet).filter(Wallet.user_id == current_user.id).first()
    
    # 최신 환율 조회
    rate = get_latest_exchange_rate(db)
    
    if request.direction == "krw_to_cht":
        # KRW → CHT
        krw_amount = request.amount
        cht_amount = krw_amount / rate.rate
        
        if wallet.krw_balance < krw_amount:
            raise HTTPException(400, "KRW 잔액 부족")
        
        wallet.krw_balance -= krw_amount
        wallet.cht_balance += cht_amount
    
    elif request.direction == "cht_to_krw":
        # CHT → KRW
        cht_amount = request.amount
        krw_amount = cht_amount * rate.rate
        
        if wallet.cht_balance < cht_amount:
            raise HTTPException(400, "CHT 잔액 부족")
        
        wallet.cht_balance -= cht_amount
        wallet.krw_balance += krw_amount
    
    db.commit()
    return {"new_krw_balance": wallet.krw_balance, "new_cht_balance": wallet.cht_balance}

1
2
3
4
5
6
7

categories = [
    {"name": "DevOps", "rate_per_hour": 50000},
    {"name": "인프라/보안", "rate_per_hour": 60000},
    {"name": "개발 컨설팅", "rate_per_hour": 70000},
    {"name": "모니터링/로깅", "rate_per_hour": 50000},
    {"name": "기타", "rate_per_hour": 0}  # 맞춤 가격
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@router.post("/tickets")
async def create_ticket(
    request: TicketCreateRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    category = db.query(Category).filter(Category.id == request.category_id).first()
    
    # 예상 비용 계산
    estimated_cost = category.rate_per_hour * request.estimated_hours
    
    ticket = Ticket(
        user_id=current_user.id,
        category_id=request.category_id,
        title=request.title,
        description=request.description,
        estimated_hours=request.estimated_hours,
        estimated_cost_krw=estimated_cost,
        status="requested"  # requested → approved → processing → completed → paid
    )
    db.add(ticket)
    db.commit()
    
    return TicketResponse.from_orm(ticket)

1
2
3
4

pytest backend/tests/ -v --cov=backend/app --cov-report=term-missing

============== 112 tests passed in 70.43s ==============
Coverage: 81%

1
2
3
4
5

# ❌ Before: 회원가입 시 지갑 생성
@router.post("/register")
async def register(...):
    user = create_user(...)
    wallet = create_wallet(user.id)  # ← 문제: 인증 안 해도 생성

1
2
3
4
5

# ✅ After: 이메일 인증 시 지갑 생성
@router.get("/verify-email")
async def verify_email(...):
    user.email_verified = True
    wallet = create_wallet(user.id)  # ← 인증 완료 후에만 생성

1
2

# ❌ 느림: 매번 DB 조회
rate = db.query(ExchangeRate).order_by(ExchangeRate.updated_at.desc()).first()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# ✅ 빠름: 캐싱 (60초)
from functools import lru_cache
from datetime import datetime, timedelta

@lru_cache(maxsize=1)
def get_cached_rate(cache_key: str):
    # cache_key = "2026-03-04T09:00" (1분 단위)
    return db.query(ExchangeRate).order_by(ExchangeRate.updated_at.desc()).first()

def get_current_rate():
    cache_key = datetime.now().strftime("%Y-%m-%dT%H:%M")
    return get_cached_rate(cache_key)

1
2
3
4
5

# ❌ 안 됨
docker compose restart frontend

# ✅ 됨
docker compose up -d --force-recreate