🎯 왜 DAO 리더보드 시스템이 필요할까?

🛠️ 프로젝트 준비하기: 개발 환경 세팅

📦 필요한 도구들

🚀 라라벨 프로젝트 생성

composer create-project laravel/laravel dao-leaderboard
cd dao-leaderboard
php artisan serve

🔌 Web3 패키지 설치

composer require web3p/web3.php
composer require kornrunner/keccak
npm install web3 ethers

🏗️ 데이터베이스 설계: 기여도를 어떻게 저장할까?

📊 핵심 테이블 구조

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('wallet_address')->unique();
    $table->string('username')->nullable();
    $table->string('avatar_url')->nullable();
    $table->integer('total_score')->default(0);
    $table->integer('rank')->nullable();
    $table->timestamps();
    
    $table->index('wallet_address');
    $table->index('total_score');
});

Schema::create('contributions', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->string('contribution_type'); // 'code', 'governance', 'community' 등
    $table->text('description');
    $table->integer('score');
    $table->string('transaction_hash')->nullable();
    $table->string('proof_url')->nullable(); // GitHub PR, 포럼 링크 등
    $table->enum('status', ['pending', 'approved', 'rejected'])->default('pending');
    $table->timestamp('verified_at')->nullable();
    $table->timestamps();
    
    $table->index(['user_id', 'created_at']);
    $table->index('contribution_type');
});

Schema::create('contribution_types', function (Blueprint $table) {
    $table->id();
    $table->string('name')->unique();
    $table->string('display_name');
    $table->text('description');
    $table->integer('base_score');
    $table->decimal('multiplier', 3, 2)->default(1.00);
    $table->boolean('requires_verification')->default(false);
    $table->timestamps();
});

Schema::create('leaderboard_snapshots', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained();
    $table->integer('rank');
    $table->integer('score');
    $table->string('period'); // 'daily', 'weekly', 'monthly', 'all-time'
    $table->date('snapshot_date');
    $table->timestamps();
    
    $table->index(['period', 'snapshot_date']);
    $table->unique(['user_id', 'period', 'snapshot_date']);
});

🔄 마이그레이션 실행

php artisan migrate

⚙️ 핵심 로직 구현: 기여도 계산 엔진

🎯 기여도 계산 전략

💻 ContributionService 클래스 만들기

php artisan make:service ContributionService

<?php

namespace App\Services;

use App\Models\Contribution;
use App\Models\User;
use App\Models\ContributionType;
use Carbon\Carbon;

class ContributionService
{
    /**
     * 기여도 점수 계산
     */
    public function calculateScore(Contribution $contribution): int
    {
        $type = ContributionType::where('name', $contribution->contribution_type)->first();
        
        if (!$type) {
            return 0;
        }
        
        $baseScore = $type->base_score;
        $multiplier = $type->multiplier;
        
        // 시간 가중치 적용 (최근 30일 내 기여는 1.5배)
        $timeWeight = $this->calculateTimeWeight($contribution->created_at);
        
        // 검증 보너스 (검증된 기여는 1.2배)
        $verificationBonus = $contribution->status === 'approved' ? 1.2 : 1.0;
        
        // 최종 점수 계산
        $finalScore = $baseScore * $multiplier * $timeWeight * $verificationBonus;
        
        return (int) round($finalScore);
    }
    
    /**
     * 시간 가중치 계산
     */
    private function calculateTimeWeight(Carbon $contributionDate): float
    {
        $daysAgo = now()->diffInDays($contributionDate);
        
        if ($daysAgo <= 30) {
            return 1.5; // 최근 30일
        } elseif ($daysAgo <= 90) {
            return 1.2; // 최근 90일
        } elseif ($daysAgo <= 180) {
            return 1.0; // 최근 180일
        } else {
            return 0.8; // 그 이전
        }
    }
    
    /**
     * 사용자 총 점수 업데이트
     */
    public function updateUserTotalScore(User $user): void
    {
        $totalScore = $user->contributions()
            ->where('status', 'approved')
            ->sum('score');
        
        $user->update(['total_score' => $totalScore]);
        
        // 랭킹도 업데이트
        $this->updateUserRank($user);
    }
    
    /**
     * 사용자 랭킹 업데이트
     */
    private function updateUserRank(User $user): void
    {
        $rank = User::where('total_score', '>', $user->total_score)->count() + 1;
        $user->update(['rank' => $rank]);
    }
    
    /**
     * 연속 기여 보너스 계산
     */
    public function calculateStreakBonus(User $user): int
    {
        $contributions = $user->contributions()
            ->where('status', 'approved')
            ->orderBy('created_at', 'desc')
            ->get();
        
        $streak = 0;
        $lastDate = null;
        
        foreach ($contributions as $contribution) {
            $currentDate = $contribution->created_at->startOfDay();
            
            if ($lastDate === null) {
                $streak = 1;
                $lastDate = $currentDate;
                continue;
            }
            
            $daysDiff = $lastDate->diffInDays($currentDate);
            
            if ($daysDiff <= 1) {
                $streak++;
                $lastDate = $currentDate;
            } else {
                break;
            }
        }
        
        // 7일 연속: 50점, 30일 연속: 200점, 90일 연속: 500점
        if ($streak >= 90) {
            return 500;
        } elseif ($streak >= 30) {
            return 200;
        } elseif ($streak >= 7) {
            return 50;
        }
        
        return 0;
    }
}

🔄 블록체인 데이터 동기화

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;
use Web3\Utils;

class Web3Service
{
    private $web3;
    private $contract;
    
    public function __construct()
    {
        // Infura나 Alchemy 같은 노드 프로바이더 사용
        $this->web3 = new Web3(env('WEB3_PROVIDER_URL'));
        
        // DAO 스마트 컨트랙트 연결
        $this->contract = new Contract(
            $this->web3->provider,
            file_get_contents(storage_path('contracts/DAO.abi.json'))
        );
        $this->contract->at(env('DAO_CONTRACT_ADDRESS'));
    }
    
    /**
     * 특정 주소의 거버넌스 투표 참여 횟수 조회
     */
    public function getVoteCount(string $address): int
    {
        $voteCount = 0;
        
        $this->contract->call('getVoteCount', $address, function ($err, $result) use (&$voteCount) {
            if ($err !== null) {
                throw new \Exception('Failed to get vote count: ' . $err->getMessage());
            }
            $voteCount = hexdec($result[0]->toString());
        });
        
        return $voteCount;
    }
    
    /**
     * 특정 주소의 프로포절 제안 횟수 조회
     */
    public function getProposalCount(string $address): int
    {
        $proposalCount = 0;
        
        $this->contract->call('getProposalCount', $address, function ($err, $result) use (&$proposalCount) {
            if ($err !== null) {
                throw new \Exception('Failed to get proposal count: ' . $err->getMessage());
            }
            $proposalCount = hexdec($result[0]->toString());
        });
        
        return $proposalCount;
    }
    
    /**
     * 블록체인 이벤트 로그 파싱
     */
    public function parseContributionEvents(string $fromBlock = 'latest'): array
    {
        $events = [];
        
        $this->contract->eth->getLogs([
            'fromBlock' => $fromBlock,
            'toBlock' => 'latest',
            'address' => env('DAO_CONTRACT_ADDRESS'),
            'topics' => [
                Utils::sha3('ContributionRecorded(address,string,uint256)')
            ]
        ], function ($err, $logs) use (&$events) {
            if ($err !== null) {
                throw new \Exception('Failed to get logs: ' . $err->getMessage());
            }
            
            foreach ($logs as $log) {
                $events[] = $this->decodeContributionEvent($log);
            }
        });
        
        return $events;
    }
    
    /**
     * 이벤트 로그 디코딩
     */
    private function decodeContributionEvent($log): array
    {
        // 실제로는 ABI 디코더를 사용해야 함
        return [
            'address' => '0x' . substr($log->topics[1], 26),
            'contribution_type' => $this->hexToString($log->data),
            'transaction_hash' => $log->transactionHash,
            'block_number' => hexdec($log->blockNumber),
        ];
    }
    
    private function hexToString($hex): string
    {
        $string = '';
        for ($i = 0; $i < strlen($hex) - 1; $i += 2) {
            $string .= chr(hexdec($hex[$i] . $hex[$i + 1]));
        }
        return $string;
    }
}

🎨 API 엔드포인트 구축하기

🛣️ 라우트 정의

<?php

use App\Http\Controllers\Api\LeaderboardController;
use App\Http\Controllers\Api\ContributionController;
use App\Http\Controllers\Api\UserController;

// 리더보드 관련
Route::prefix('leaderboard')->group(function () {
    Route::get('/', [LeaderboardController::class, 'index']);
    Route::get('/top/{limit}', [LeaderboardController::class, 'top']);
    Route::get('/period/{period}', [LeaderboardController::class, 'byPeriod']);
    Route::get('/user/{address}', [LeaderboardController::class, 'userRank']);
});

// 기여 관련
Route::prefix('contributions')->group(function () {
    Route::get('/', [ContributionController::class, 'index']);
    Route::post('/', [ContributionController::class, 'store']);
    Route::get('/{id}', [ContributionController::class, 'show']);
    Route::put('/{id}/verify', [ContributionController::class, 'verify']);
    Route::get('/user/{address}', [ContributionController::class, 'userContributions']);
});

// 사용자 관련
Route::prefix('users')->group(function () {
    Route::get('/{address}', [UserController::class, 'show']);
    Route::get('/{address}/stats', [UserController::class, 'stats']);
    Route::post('/sync', [UserController::class, 'syncFromBlockchain']);
});

📊 LeaderboardController 구현

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\User;
use App\Models\LeaderboardSnapshot;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;

class LeaderboardController extends Controller
{
    /**
     * 전체 리더보드 조회
     */
    public function index(Request $request)
    {
        $perPage = $request->input('per_page', 50);
        
        // 캐싱으로 성능 최적화 (5분간 캐시)
        $leaderboard = Cache::remember('leaderboard:all', 300, function () use ($perPage) {
            return User::where('total_score', '>', 0)
                ->orderBy('total_score', 'desc')
                ->paginate($perPage);
        });
        
        return response()->json([
            'success' => true,
            'data' => $leaderboard->map(function ($user) {
                return [
                    'rank' => $user->rank,
                    'wallet_address' => $user->wallet_address,
                    'username' => $user->username ?? 'Anonymous',
                    'avatar_url' => $user->avatar_url,
                    'total_score' => $user->total_score,
                    'contribution_count' => $user->contributions()->count(),
                ];
            }),
            'meta' => [
                'current_page' => $leaderboard->currentPage(),
                'last_page' => $leaderboard->lastPage(),
                'per_page' => $leaderboard->perPage(),
                'total' => $leaderboard->total(),
            ]
        ]);
    }
    
    /**
     * 상위 N명 조회
     */
    public function top($limit = 10)
    {
        $limit = min($limit, 100); // 최대 100명까지
        
        $topUsers = Cache::remember("leaderboard:top:{$limit}", 300, function () use ($limit) {
            return User::where('total_score', '>', 0)
                ->orderBy('total_score', 'desc')
                ->limit($limit)
                ->get();
        });
        
        return response()->json([
            'success' => true,
            'data' => $topUsers->map(function ($user, $index) {
                return [
                    'rank' => $index + 1,
                    'wallet_address' => $user->wallet_address,
                    'username' => $user->username ?? 'Anonymous',
                    'avatar_url' => $user->avatar_url,
                    'total_score' => $user->total_score,
                    'badge' => $this->getRankBadge($index + 1),
                ];
            })
        ]);
    }
    
    /**
     * 기간별 리더보드 조회
     */
    public function byPeriod($period)
    {
        $validPeriods = ['daily', 'weekly', 'monthly', 'all-time'];
        
        if (!in_array($period, $validPeriods)) {
            return response()->json([
                'success' => false,
                'message' => 'Invalid period. Use: daily, weekly, monthly, or all-time'
            ], 400);
        }
        
        $date = now()->toDateString();
        
        $leaderboard = LeaderboardSnapshot::where('period', $period)
            ->where('snapshot_date', $date)
            ->orderBy('rank')
            ->get();
        
        return response()->json([
            'success' => true,
            'period' => $period,
            'date' => $date,
            'data' => $leaderboard
        ]);
    }
    
    /**
     * 특정 사용자 순위 조회
     */
    public function userRank($address)
    {
        $user = User::where('wallet_address', $address)->first();
        
        if (!$user) {
            return response()->json([
                'success' => false,
                'message' => 'User not found'
            ], 404);
        }
        
        $totalUsers = User::where('total_score', '>', 0)->count();
        $percentile = $totalUsers > 0 ? (($totalUsers - $user->rank + 1) / $totalUsers) * 100 : 0;
        
        return response()->json([
            'success' => true,
            'data' => [
                'rank' => $user->rank,
                'total_score' => $user->total_score,
                'percentile' => round($percentile, 2),
                'total_users' => $totalUsers,
                'badge' => $this->getRankBadge($user->rank),
            ]
        ]);
    }
    
    /**
     * 순위에 따른 뱃지 부여
     */
    private function getRankBadge($rank): array
    {
        if ($rank === 1) {
            return ['name' => 'Champion', 'emoji' => '🏆', 'color' => '#FFD700'];
        } elseif ($rank === 2) {
            return ['name' => 'Elite', 'emoji' => '🥈', 'color' => '#C0C0C0'];
        } elseif ($rank === 3) {
            return ['name' => 'Master', 'emoji' => '🥉', 'color' => '#CD7F32'];
        } elseif ($rank <= 10) {
            return ['name' => 'Expert', 'emoji' => '⭐', 'color' => '#4A90E2'];
        } elseif ($rank <= 50) {
            return ['name' => 'Advanced', 'emoji' => '💎', 'color' => '#50C878'];
        } else {
            return ['name' => 'Contributor', 'emoji' => '🌟', 'color' => '#9B59B6'];
        }
    }
}

📝 ContributionController 구현

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Contribution;
use App\Models\User;
use App\Services\ContributionService;
use App\Services\Web3Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class ContributionController extends Controller
{
    private $contributionService;
    private $web3Service;
    
    public function __construct(ContributionService $contributionService, Web3Service $web3Service)
    {
        $this->contributionService = $contributionService;
        $this->web3Service = $web3Service;
    }
    
    /**
     * 기여 등록
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'wallet_address' => 'required|string',
            'contribution_type' => 'required|string',
            'description' => 'required|string|max:1000',
            'proof_url' => 'nullable|url',
            'transaction_hash' => 'nullable|string',
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        // 사용자 찾기 또는 생성
        $user = User::firstOrCreate(
            ['wallet_address' => $request->wallet_address],
            ['username' => null, 'total_score' => 0]
        );
        
        // 기여 생성
        $contribution = Contribution::create([
            'user_id' => $user->id,
            'contribution_type' => $request->contribution_type,
            'description' => $request->description,
            'proof_url' => $request->proof_url,
            'transaction_hash' => $request->transaction_hash,
            'status' => 'pending',
            'score' => 0, // 검증 후 계산
        ]);
        
        return response()->json([
            'success' => true,
            'message' => 'Contribution submitted successfully',
            'data' => $contribution
        ], 201);
    }
    
    /**
     * 기여 검증 (관리자용)
     */
    public function verify(Request $request, $id)
    {
        $contribution = Contribution::findOrFail($id);
        
        $validator = Validator::make($request->all(), [
            'status' => 'required|in:approved,rejected',
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        $contribution->status = $request->status;
        
        if ($request->status === 'approved') {
            // 점수 계산
            $score = $this->contributionService->calculateScore($contribution);
            $contribution->score = $score;
            $contribution->verified_at = now();
            
            // 사용자 총점 업데이트
            $this->contributionService->updateUserTotalScore($contribution->user);
        }
        
        $contribution->save();
        
        return response()->json([
            'success' => true,
            'message' => 'Contribution verified successfully',
            'data' => $contribution
        ]);
    }
    
    /**
     * 사용자별 기여 목록
     */
    public function userContributions($address)
    {
        $user = User::where('wallet_address', $address)->first();
        
        if (!$user) {
            return response()->json([
                'success' => false,
                'message' => 'User not found'
            ], 404);
        }
        
        $contributions = $user->contributions()
            ->orderBy('created_at', 'desc')
            ->paginate(20);
        
        return response()->json([
            'success' => true,
            'data' => $contributions
        ]);
    }
}

🔄 실시간 업데이트: WebSocket과 이벤트 브로드캐스팅

📡 Laravel Broadcasting 설정

composer require pusher/pusher-php-server
npm install --save-dev laravel-echo pusher-js

BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=your-cluster

📢 이벤트 생성

php artisan make:event LeaderboardUpdated

<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class LeaderboardUpdated implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $topUsers;
    public $updatedUser;
    
    public function __construct($topUsers, $updatedUser = null)
    {
        $this->topUsers = $topUsers;
        $this->updatedUser = $updatedUser;
    }
    
    public function broadcastOn()
    {
        return new Channel('leaderboard');
    }
    
    public function broadcastAs()
    {
        return 'updated';
    }
    
    public function broadcastWith()
    {
        return [
            'top_users' => $this->topUsers,
            'updated_user' => $this->updatedUser,
            'timestamp' => now()->toIso8601String(),
        ];
    }
}

🎯 이벤트 발생시키기

// ContributionController의 verify 메서드에 추가
if ($request->status === 'approved') {
    // ... 점수 계산 로직 ...
    
    // 상위 10명 조회
    $topUsers = User::orderBy('total_score', 'desc')->limit(10)->get();
    
    // 이벤트 브로드캐스트
    event(new LeaderboardUpdated($topUsers, $contribution->user));
}

🎨 프론트엔드에서 실시간 수신

// resources/js/app.js
import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: process.env.MIX_PUSHER_APP_KEY,
    cluster: process.env.MIX_PUSHER_APP_CLUSTER,
    forceTLS: true
});

// Leaderboard.vue
export default {
    data() {
        return {
            leaderboard: [],
            isLive: true
        }
    },
    mounted() {
        this.fetchLeaderboard();
        this.listenForUpdates();
    },
    methods: {
        fetchLeaderboard() {
            axios.get('/api/leaderboard/top/10')
                .then(response => {
                    this.leaderboard = response.data.data;
                });
        },
        listenForUpdates() {
            window.Echo.channel('leaderboard')
                .listen('.updated', (e) => {
                    console.log('Leaderboard updated!', e);
                    
                    // 애니메이션과 함께 업데이트
                    this.animateUpdate(e.top_users);
                    
                    // 알림 표시
                    if (e.updated_user) {
                        this.showNotification(e.updated_user);
                    }
                });
        },
        animateUpdate(newData) {
            // 부드러운 전환 효과
            this.leaderboard = newData;
        },
        showNotification(user) {
            this.$notify({
                title: '🎉 New Contribution!',
                message: `${user.username || 'Anonymous'} just earned points!`,
                type: 'success'
            });
        }
    }
}

🎮 게이미피케이션: 더 재미있게 만들기

🏆 업적(Achievement) 시스템

php artisan make:model Achievement -m

Schema::create('achievements', function (Blueprint $table) {
    $table->id();
    $table->string('name')->unique();
    $table->string('display_name');
    $table->text('description');
    $table->string('icon'); // 이모지나 이미지 URL
    $table->integer('points');
    $table->json('criteria'); // 달성 조건
    $table->enum('rarity', ['common', 'rare', 'epic', 'legendary']);
    $table->timestamps();
});

Schema::create('user_achievements', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->foreignId('achievement_id')->constrained()->onDelete('cascade');
    $table->timestamp('unlocked_at');
    $table->timestamps();
    
    $table->unique(['user_id', 'achievement_id']);
});

🎖️ 업적 정의하기

<?php

namespace Database\Seeders;

use App\Models\Achievement;
use Illuminate\Database\Seeder;

class AchievementSeeder extends Seeder
{
    public function run()
    {
        $achievements = [
            [
                'name' => 'first_contribution',
                'display_name' => 'First Steps',
                'description' => '첫 번째 기여를 완료했습니다!',
                'icon' => '🌱',
                'points' => 50,
                'criteria' => json_encode(['contribution_count' => 1]),
                'rarity' => 'common',
            ],
            [
                'name' => 'week_streak',
                'display_name' => 'Dedicated',
                'description' => '7일 연속 기여했습니다!',
                'icon' => '🔥',
                'points' => 200,
                'criteria' => json_encode(['streak_days' => 7]),
                'rarity' => 'rare',
            ],
            [
                'name' => 'code_master',
                'display_name' => 'Code Master',
                'description' => '코드 기여 50개를 달성했습니다!',
                'icon' => '💻',
                'points' => 500,
                'criteria' => json_encode(['contribution_type' => 'code', 'count' => 50]),
                'rarity' => 'epic',
            ],
            [
                'name' => 'top_ten',
                'display_name' => 'Elite Club',
                'description' => '리더보드 상위 10위에 진입했습니다!',
                'icon' => '⭐',
                'points' => 1000,
                'criteria' => json_encode(['rank' => 10]),
                'rarity' => 'epic',
            ],
            [
                'name' => 'champion',
                'display_name' => 'Champion',
                'description' => '리더보드 1위를 달성했습니다!',
                'icon' => '👑',
                'points' => 5000,
                'criteria' => json_encode(['rank' => 1]),
                'rarity' => 'legendary',
            ],
            [
                'name' => 'governance_guru',
                'display_name' => 'Governance Guru',
                'description' => '거버넌스 투표에 100번 참여했습니다!',
                'icon' => '🗳️',
                'points' => 800,
                'criteria' => json_encode(['contribution_type' => 'governance', 'count' => 100]),
                'rarity' => 'epic',
            ],
        ];
        
        foreach ($achievements as $achievement) {
            Achievement::create($achievement);
        }
    }
}

🎯 업적 체크 서비스

<?php

namespace App\Services;

use App\Models\User;
use App\Models\Achievement;
use App\Events\AchievementUnlocked;

class AchievementService
{
    /**
     * 사용자의 업적 달성 여부 체크
     */
    public function checkAchievements(User $user): array
    {
        $unlockedAchievements = [];
        $achievements = Achievement::all();
        
        foreach ($achievements as $achievement) {
            // 이미 획득한 업적은 스킵
            if ($user->achievements()->where('achievement_id', $achievement->id)->exists()) {
                continue;
            }
            
            // 달성 조건 체크
            if ($this->checkCriteria($user, $achievement)) {
                $this->unlockAchievement($user, $achievement);
                $unlockedAchievements[] = $achievement;
            }
        }
        
        return $unlockedAchievements;
    }
    
    /**
     * 달성 조건 체크
     */
    private function checkCriteria(User $user, Achievement $achievement): bool
    {
        $criteria = json_decode($achievement->criteria, true);
        
        // 기여 횟수 체크
        if (isset($criteria['contribution_count'])) {
            $count = $user->contributions()->where('status', 'approved')->count();
            if ($count < $criteria['contribution_count']) {
                return false;
            }
        }
        
        // 연속 기여 일수 체크
        if (isset($criteria['streak_days'])) {
            $streak = app(ContributionService::class)->calculateStreakBonus($user);
            if ($streak < $criteria['streak_days']) {
                return false;
            }
        }
        
        // 특정 유형 기여 횟수 체크
        if (isset($criteria['contribution_type']) && isset($criteria['count'])) {
            $count = $user->contributions()
                ->where('contribution_type', $criteria['contribution_type'])
                ->where('status', 'approved')
                ->count();
            if ($count < $criteria['count']) {
                return false;
            }
        }
        
        // 순위 체크
        if (isset($criteria['rank'])) {
            if ($user->rank > $criteria['rank']) {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * 업적 잠금 해제
     */
    private function unlockAchievement(User $user, Achievement $achievement): void
    {
        $user->achievements()->attach($achievement->id, [
            'unlocked_at' => now()
        ]);
        
        // 업적 포인트를 총점에 추가
        $user->increment('total_score', $achievement->points);
        
        // 이벤트 발생
        event(new AchievementUnlocked($user, $achievement));
    }
}

// ContributionObserver.php
public function updated(Contribution $contribution)
{
    if ($contribution->status === 'approved') {
        app(AchievementService::class)->checkAchievements($contribution->user);
    }
}

🎁 레벨 시스템

<?php

namespace App\Services;

class LevelService
{
    private $levels = [
        1 => ['min' => 0, 'max' => 100, 'title' => 'Newbie', 'color' => '#95a5a6'],
        2 => ['min' => 101, 'max' => 500, 'title' => 'Beginner', 'color' => '#3498db'],
        3 => ['min' => 501, 'max' => 1500, 'title' => 'Intermediate', 'color' => '#2ecc71'],
        4 => ['min' => 1501, 'max' => 3000, 'title' => 'Advanced', 'color' => '#f39c12'],
        5 => ['min' => 3001, 'max' => 5000, 'title' => 'Expert', 'color' => '#e74c3c'],
        6 => ['min' => 5001, 'max' => 10000, 'title' => 'Master', 'color' => '#9b59b6'],
        7 => ['min' => 10001, 'max' => 20000, 'title' => 'Grandmaster', 'color' => '#e91e63'],
        8 => ['min' => 20001, 'max' => PHP_INT_MAX, 'title' => 'Legend', 'color' => '#ffd700'],
    ];
    
    public function getUserLevel(int $score): array
    {
        foreach ($this->levels as $level => $data) {
            if ($score >= $data['min'] && $score <= $data['max']) {
                $progress = $this->calculateProgress($score, $data['min'], $data['max']);
                
                return [
                    'level' => $level,
                    'title' => $data['title'],
                    'color' => $data['color'],
                    'current_score' => $score,
                    'min_score' => $data['min'],
                    'max_score' => $data['max'],
                    'progress' => $progress,
                    'next_level' => $level < 8 ? $this->levels[$level + 1]['title'] : null,
                ];
            }
        }
        
        return $this->levels[1];
    }
    
    private function calculateProgress(int $current, int $min, int $max): float
    {
        if ($max === PHP_INT_MAX) {
            return 100.0;
        }
        
        $range = $max - $min;
        $progress = (($current - $min) / $range) * 100;
        
        return round($progress, 2);
    }
}

🔐 보안과 검증: 부정행위 방지하기

🔍 블록체인 검증

<?php

namespace App\Services;

class BlockchainVerificationService
{
    private $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    /**
     * 트랜잭션 검증
     */
    public function verifyTransaction(string $txHash, string $expectedAddress): bool
    {
        try {
            $transaction = $this->web3Service->getTransaction($txHash);
            
            if (!$transaction) {
                return false;
            }
            
            // 발신자 주소 확인
            if (strtolower($transaction['from']) !== strtolower($expectedAddress)) {
                return false;
            }
            
            // 트랜잭션이 성공했는지 확인
            $receipt = $this->web3Service->getTransactionReceipt($txHash);
            if (!$receipt || $receipt['status'] !== '0x1') {
                return false;
            }
            
            // 컨트랙트 주소 확인
            if (strtolower($receipt['to']) !== strtolower(env('DAO_CONTRACT_ADDRESS'))) {
                return false;
            }
            
            return true;
            
        } catch (\Exception $e) {
            \Log::error('Transaction verification failed: ' . $e->getMessage());
            return false;
        }
    }
    
    /**
     * 서명 검증
     */
    public function verifySignature(string $message, string $signature, string $address): bool
    {
        try {
            $recoveredAddress = $this->web3Service->recoverAddress($message, $signature);
            return strtolower($recoveredAddress) === strtolower($address);
        } catch (\Exception $e) {
            \Log::error('Signature verification failed: ' . $e->getMessage());
            return false;
        }
    }
}

⚠️ Rate Limiting

// routes/api.php
Route::middleware(['throttle:contributions'])->group(function () {
    Route::post('/contributions', [ContributionController::class, 'store']);
});

// app/Providers/RouteServiceProvider.php
protected function configureRateLimiting()
{
    RateLimiter::for('contributions', function (Request $request) {
        return Limit::perHour(10)->by($request->ip());
    });
}

🤖 이상 패턴 감지

<?php

namespace App\Services;

use App\Models\User;
use App\Models\Contribution;

class FraudDetectionService
{
    /**
     * 의심스러운 활동 감지
     */
    public function detectSuspiciousActivity(User $user): array
    {
        $flags = [];
        
        // 1. 짧은 시간에 너무 많은 기여
        $recentContributions = $user->contributions()
            ->where('created_at', '>=', now()->subHour())
            ->count();
        
        if ($recentContributions > 5) {
            $flags[] = [
                'type' => 'high_frequency',
                'severity' => 'medium',
                'message' => '1시간 내 5개 이상의 기여'
            ];
        }
        
        // 2. 비정상적으로 높은 점수
        $avgScore = Contribution::where('status', 'approved')->avg('score');
        $userAvgScore = $user->contributions()
            ->where('status', 'approved')
            ->avg('score');
        
        if ($userAvgScore > $avgScore * 2) {
            $flags[] = [
                'type' => 'abnormal_score',
                'severity' => 'high',
                'message' => '평균보다 2배 이상 높은 점수'
            ];
        }
        
        // 3. 검증되지 않은 기여가 너무 많음
        $pendingRatio = $user->contributions()
            ->where('status', 'pending')
            ->count() / max($user->contributions()->count(), 1);
        
        if ($pendingRatio > 0.7) {
            $flags[] = [
                'type' => 'high_pending_ratio',
                'severity' => 'low',
                'message' => '검증 대기 중인 기여가 70% 이상'
            ];
        }
        
        // 4. 동일한 proof_url 반복 사용
        $duplicateProofs = $user->contributions()
            ->select('proof_url')
            ->groupBy('proof_url')
            ->havingRaw('COUNT(*) > 1')
            ->count();
        
        if ($duplicateProofs > 0) {
            $flags[] = [
                'type' => 'duplicate_proof',
                'severity' => 'high',
                'message' => '동일한 증거 URL 반복 사용'
            ];
        }
        
        return $flags;
    }
    
    /**
     * 자동 조치
     */
    public function takeAction(User $user, array $flags): void
    {
        $highSeverityCount = collect($flags)->where('severity', 'high')->count();
        
        if ($highSeverityCount >= 2) {
            // 계정 일시 정지
            $user->update(['is_suspended' => true]);
            
            // 관리자에게 알림
            \Notification::route('mail', env('ADMIN_EMAIL'))
                ->notify(new SuspiciousActivityDetected($user, $flags));
        }
    }
}

📊 분석과 인사이트: 데이터 시각화

📉 통계 API 만들기

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\User;
use App\Models\Contribution;
use Illuminate\Support\Facades\DB;
use Carbon\Carbon;

class AnalyticsController extends Controller
{
    /**
     * 전체 통계
     */
    public function overview()
    {
        $stats = [
            'total_users' => User::count(),
            'active_users' => User::whereHas('contributions', function ($query) {
                $query->where('created_at', '>=', now()->subDays(30));
            })->count(),
            'total_contributions' => Contribution::where('status', 'approved')->count(),
            'total_score' => User::sum('total_score'),
            'avg_score_per_user' => round(User::avg('total_score'), 2),
        ];
        
        return response()->json([
            'success' => true,
            'data' => $stats
        ]);
    }
    
    /**
     * 기여 트렌드 (일별)
     */
    public function contributionTrend($days = 30)
    {
        $trend = Contribution::where('status', 'approved')
            ->where('created_at', '>=', now()->subDays($days))
            ->select(
                DB::raw('DATE(created_at) as date'),
                DB::raw('COUNT(*) as count'),
                DB::raw('SUM(score) as total_score')
            )
            ->groupBy('date')
            ->orderBy('date')
            ->get();
        
        return response()->json([
            'success' => true,
            'period' => $days . ' days',
            'data' => $trend
        ]);
    }
    
    /**
     * 기여 유형별 분포
     */
    public function contributionTypeDistribution()
    {
        $distribution = Contribution::where('status', 'approved')
            ->select('contribution_type', DB::raw('COUNT(*) as count'), DB::raw('SUM(score) as total_score'))
            ->groupBy('contribution_type')
            ->get();
        
        return response()->json([
            'success' => true,
            'data' => $distribution
        ]);
    }
    
    /**
     * 상위 기여자 성장 추이
     */
    public function topContributorsGrowth()
    {
        $topUsers = User::orderBy('total_score', 'desc')->limit(10)->get();
        
        $growth = $topUsers->map(function ($user) {
            $monthlyScores = [];
            
            for ($i = 5; $i >= 0; $i--) {
                $month = now()->subMonths($i);
                $score = $user->contributions()
                    ->where('status', 'approved')
                    ->whereYear('created_at', $month->year)
                    ->whereMonth('created_at', $month->month)
                    ->sum('score');
                
                $monthlyScores[] = [
                    'month' => $month->format('Y-m'),
                    'score' => $score
                ];
            }
            
            return [
                'user' => [
                    'wallet_address' => $user->wallet_address,
                    'username' => $user->username,
                    'total_score' => $user->total_score,
                ],
                'monthly_scores' => $monthlyScores
            ];
        });
        
        return response()->json([
            'success' => true,
            'data' => $growth
        ]);
    }
}

📊 대시보드 컴포넌트

<template>
  <div class="analytics-dashboard">
    <div class="stats-grid">
      <div class="stat-card">
        <h3>총 사용자</h3>
        <p class="stat-value">{{ stats.total_users }}</p>
      </div>
      <div class="stat-card">
        <h3>활성 사용자</h3>
        <p class="stat-value">{{ stats.active_users }}</p>
      </div>
      <div class="stat-card">
        <h3>총 기여</h3>
        <p class="stat-value">{{ stats.total_contributions }}</p>
      </div>
      <div class="stat-card">
        <h3>평균 점수</h3>
        <p class="stat-value">{{ stats.avg_score_per_user }}</p>
      </div>
    </div>
    
    <div class="chart-container">
      <h2>기여 트렌드</h2>
      <canvas ref="trendChart"></canvas>
    </div>
    
    <div class="chart-container">
      <h2>기여 유형별 분포</h2>
      <canvas ref="distributionChart"></canvas>
    </div>
  </div>
</template>

<script>
import Chart from 'chart.js/auto';

export default {
  data() {
    return {
      stats: {},
      trendChart: null,
      distributionChart: null
    }
  },
  mounted() {
    this.fetchStats();
    this.fetchTrend();
    this.fetchDistribution();
  },
  methods: {
    async fetchStats() {
      const response = await axios.get('/api/analytics/overview');
      this.stats = response.data.data;
    },
    async fetchTrend() {
      const response = await axios.get('/api/analytics/contribution-trend/30');
      const data = response.data.data;
      
      this.trendChart = new Chart(this.$refs.trendChart, {
        type: 'line',
        data: {
          labels: data.map(d => d.date),
          datasets: [{
            label: '일별 기여 수',
            data: data.map(d => d.count),
            borderColor: '#6c5ce7',
            backgroundColor: 'rgba(108, 92, 231, 0.1)',
            tension: 0.4
          }]
        },
        options: {
          responsive: true,
          plugins: {
            legend: {
              display: true
            }
          }
        }
      });
    },
    async fetchDistribution() {
      const response = await axios.get('/api/analytics/contribution-type-distribution');
      const data = response.data.data;
      
      this.distributionChart = new Chart(this.$refs.distributionChart, {
        type: 'doughnut',
        data: {
          labels: data.map(d => d.contribution_type),
          datasets: [{
            data: data.map(d => d.count),
            backgroundColor: [
              '#6c5ce7',
              '#00b894',
              '#fd79a8',
              '#fdcb6e',
              '#74b9ff'
            ]
          }]
        },
        options: {
          responsive: true,
          plugins: {
            legend: {
              position: 'bottom'
            }
          }
        }
      });
    }
  }
}
</script>

🚀 성능 최적화: 빠르게 만들기

💾 캐싱 전략

<?php

namespace App\Services;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Redis;

class CacheService
{
    /**
     * 리더보드 캐싱
     */
    public function cacheLeaderboard($limit = 100)
    {
        $key = "leaderboard:top:{$limit}";
        
        return Cache::remember($key, 300, function () use ($limit) {
            return User::where('total_score', '>', 0)
                ->orderBy('total_score', 'desc')
                ->limit($limit)
                ->get();
        });
    }
    
    /**
     * 사용자 랭킹 캐싱 (Redis Sorted Set 사용)
     */
    public function updateUserRankCache(User $user)
    {
        Redis::zadd('leaderboard:scores', $user->total_score, $user->wallet_address);
    }
    
    /**
     * 사용자 순위 조회 (O(log N) 시간 복잡도)
     */
    public function getUserRankFromCache($walletAddress)
    {
        $rank = Redis::zrevrank('leaderboard:scores', $walletAddress);
        return $rank !== null ? $rank + 1 : null;
    }
    
    /**
     * 캐시 무효화
     */
    public function invalidateLeaderboardCache()
    {
        $keys = Cache::get('leaderboard:keys', []);
        foreach ($keys as $key) {
            Cache::forget($key);
        }
    }
}

🔍 데이터베이스 최적화

// 마이그레이션에서
$table->index(['user_id', 'status', 'created_at']);
$table->index(['contribution_type', 'status']);
$table->index('total_score');

// ❌ 나쁜 예
$users = User::all();
foreach ($users as $user) {
    echo $user->contributions->count(); // N+1 쿼리!
}

// ✅ 좋은 예
$users = User::withCount('contributions')->get();
foreach ($users as $user) {
    echo $user->contributions_count; // 단일 쿼리!
}

// ❌ 느린 쿼리
$topUsers = User::all()->sortByDesc('total_score')->take(10);

// ✅ 빠른 쿼리
$topUsers = User::orderBy('total_score', 'desc')->limit(10)->get();

⚙️ 큐(Queue) 활용

<?php

namespace App\Jobs;

use App\Models\User;
use App\Services\ContributionService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class UpdateLeaderboardJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    /**
     * 리더보드 전체 업데이트
     */
    public function handle(ContributionService $contributionService)
    {
        $users = User::where('total_score', '>', 0)->get();
        
        foreach ($users as $user) {
            $contributionService->updateUserTotalScore($user);
        }
        
        \Log::info('Leaderboard updated successfully');
    }
}

// 스케줄러에 등록
// app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    $schedule->job(new UpdateLeaderboardJob)->everyFiveMinutes();
}

🎨 프론트엔드 구현: 멋진 UI 만들기

🏆 리더보드 컴포넌트

<template>
  <div class="leaderboard-container">
    <div class="header">
      <h1>🏆 DAO 기여도 리더보드</h1>
      <div class="period-selector">
        <button 
          v-for="period in periods" 
          :key="period.value"
          @click="selectPeriod(period.value)"
          :class="{ active: selectedPeriod === period.value }"
        >
          {{ period.label }}
        </button>
      </div>
    </div>
    
    <div class="top-three">
      <div class="rank-card second" v-if="leaderboard[1]">
        <div class="rank-badge">🥈</div>
        <img :src="leaderboard[1].avatar_url || defaultAvatar" alt="Avatar">
        <h3>{{ leaderboard[1].username || 'Anonymous' }}</h3>
        <p class="score">{{ formatScore(leaderboard[1].total_score) }}</p>
      </div>
      
      <div class="rank-card first" v-if="leaderboard[0]">
        <div class="rank-badge">👑</div>
        <img :src="leaderboard[0].avatar_url || defaultAvatar" alt="Avatar">
        <h3>{{ leaderboard[0].username || 'Anonymous' }}</h3>
        <p class="score">{{ formatScore(leaderboard[0].total_score) }}</p>
      </div>
      
      <div class="rank-card third" v-if="leaderboard[2]">
        <div class="rank-badge">🥉</div>
        <img :src="leaderboard[2].avatar_url || defaultAvatar" alt="Avatar">
        <h3>{{ leaderboard[2].username || 'Anonymous' }}</h3>
        <p class="score">{{ formatScore(leaderboard[2].total_score) }}</p>
      </div>
    </div>
    
    <div class="leaderboard-list">
      <div 
        v-for="(user, index) in leaderboard.slice(3)" 
        :key="user.wallet_address"
        class="leaderboard-item"
        :class="{ 'is-current-user': isCurrentUser(user.wallet_address) }"
      >
        <div class="rank">#{{ index + 4 }}</div>
        <img :src="user.avatar_url || defaultAvatar" alt="Avatar" class="avatar">
        <div class="user-info">
          <h4>{{ user.username || 'Anonymous' }}</h4>
          <p class="wallet">{{ shortenAddress(user.wallet_address) }}</p>
        </div>
        <div class="stats">
          <span class="score">{{ formatScore(user.total_score) }}</span>
          <span class="contributions">{{ user.contribution_count }} 기여</span>
        </div>
      </div>
    </div>
    
    <div v-if="loading" class="loading">
      <div class="spinner"></div>
      <p>로딩 중...</p>
    </div>
  </div>
</template>

<script>
export default {
  data() {
    return {
      leaderboard: [],
      selectedPeriod: 'all-time',
      periods: [
        { value: 'daily', label: '오늘' },
        { value: 'weekly', label: '이번 주' },
        { value: 'monthly', label: '이번 달' },
        { value: 'all-time', label: '전체' }
      ],
      loading: false,
      defaultAvatar: '/images/default-avatar.png',
      currentUserAddress: null
    }
  },
  mounted() {
    this.fetchLeaderboard();
    this.getCurrentUser();
    this.listenForUpdates();
  },
  methods: {
    async fetchLeaderboard() {
      this.loading = true;
      try {
        const response = await axios.get(`/api/leaderboard/period/${this.selectedPeriod}`);
        this.leaderboard = response.data.data;
      } catch (error) {
        console.error('Failed to fetch leaderboard:', error);
        this.$notify({
          type: 'error',
          title: '오류',
          message: '리더보드를 불러오는데 실패했습니다.'
        });
      } finally {
        this.loading = false;
      }
    },
    selectPeriod(period) {
      this.selectedPeriod = period;
      this.fetchLeaderboard();
    },
    formatScore(score) {
      return new Intl.NumberFormat('ko-KR').format(score);
    },
    shortenAddress(address) {
      return `${address.slice(0, 6)}...${address.slice(-4)}`;
    },
    isCurrentUser(address) {
      return this.currentUserAddress && 
             address.toLowerCase() === this.currentUserAddress.toLowerCase();
    },
    async getCurrentUser() {
      if (window.ethereum) {
        const accounts = await window.ethereum.request({ method: 'eth_accounts' });
        if (accounts.length > 0) {
          this.currentUserAddress = accounts[0];
        }
      }
    },
    listenForUpdates() {
      window.Echo.channel('leaderboard')
        .listen('.updated', (e) => {
          this.fetchLeaderboard();
          this.$notify({
            type: 'success',
            title: '🎉 업데이트!',
            message: '리더보드가 업데이트되었습니다.'
          });
        });
    }
  }
}
</script>

<style scoped>
.leaderboard-container {
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
}

.header {
  text-align: center;
  margin-bottom: 40px;
}

.header h1 {
  font-size: 2.5rem;
  margin-bottom: 20px;
}

.period-selector {
  display: flex;
  gap: 10px;
  justify-content: center;
}

.period-selector button {
  padding: 10px 20px;
  border: 2px solid #e0e0e0;
  border-radius: 8px;
  background: white;
  cursor: pointer;
  transition: all 0.3s;
}

.period-selector button.active {
  background: #6c5ce7;
  color: white;
  border-color: #6c5ce7;
}

.top-three {
  display: flex;
  justify-content: center;
  align-items: flex-end;
  gap: 20px;
  margin-bottom: 40px;
}

.rank-card {
  background: white;
  border-radius: 16px;
  padding: 30px;
  text-align: center;
  box-shadow: 0 4px 15px rgba(0,0,0,0.1);
  transition: transform 0.3s;
}

.rank-card:hover {
  transform: translateY(-5px);
}

.rank-card.first {
  width: 280px;
  background: linear-gradient(135deg, #ffd700 0%, #ffed4e 100%);
}

.rank-card.second {
  width: 240px;
  background: linear-gradient(135deg, #c0c0c0 0%, #e8e8e8 100%);
}

.rank-card.third {
  width: 240px;
  background: linear-gradient(135deg, #cd7f32 0%, #e8a87c 100%);
}

.rank-badge {
  font-size: 3rem;
  margin-bottom: 10px;
}

.rank-card img {
  width: 100px;
  height: 100px;
  border-radius: 50%;
  margin-bottom: 15px;
  border: 4px solid white;
}

.rank-card h3 {
  font-size: 1.5rem;
  margin-bottom: 10px;
}

.rank-card .score {
  font-size: 2rem;
  font-weight: bold;
}

.leaderboard-list {
  background: white;
  border-radius: 16px;
  padding: 20px;
  box-shadow: 0 2px 10px rgba(0,0,0,0.05);
}

.leaderboard-item {
  display: flex;
  align-items: center;
  padding: 20px;
  border-bottom: 1px solid #f0f0f0;
  transition: background 0.3s;
}

.leaderboard-item:hover {
  background: #f8f9fa;
}

.leaderboard-item.is-current-user {
  background: #e3f2fd;
  border-left: 4px solid #2196f3;
}

.leaderboard-item .rank {
  font-size: 1.5rem;
  font-weight: bold;
  width: 60px;
  color: #636e72;
}

.leaderboard-item .avatar {
  width: 50px;
  height: 50px;
  border-radius: 50%;
  margin-right: 15px;
}

.leaderboard-item .user-info {
  flex: 1;
}

.leaderboard-item .user-info h4 {
  font-size: 1.1rem;
  margin-bottom: 5px;
}

.leaderboard-item .wallet {
  font-size: 0.9rem;
  color: #95a5a6;
}

.leaderboard-item .stats {
  text-align: right;
}

.leaderboard-item .score {
  display: block;
  font-size: 1.3rem;
  font-weight: bold;
  color: #6c5ce7;
}

.leaderboard-item .contributions {
  font-size: 0.9rem;
  color: #95a5a6;
}

.loading {
  text-align: center;
  padding: 40px;
}

.spinner {
  width: 50px;
  height: 50px;
  border: 4px solid #f3f3f3;
  border-top: 4px solid #6c5ce7;
  border-radius: 50%;
  animation: spin 1s linear infinite;
  margin: 0 auto 20px;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}
</style>

🔧 배포와 운영: 실전 투입하기

☁️ 서버 환경 구성

📦 Docker로 배포하기

# Dockerfile
FROM php:8.2-fpm

# 필요한 확장 설치
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Composer 설치
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# 작업 디렉토리 설정
WORKDIR /var/www

# 애플리케이션 파일 복사
COPY . .

# 의존성 설치
RUN composer install --no-dev --optimize-autoloader

# 권한 설정
RUN chown -R www-data:www-data /var/www

EXPOSE 9000
CMD ["php-fpm"]

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: dao-leaderboard-app
    restart: unless-stopped
    working_dir: /var/www
    volumes:
      - ./:/var/www
    networks:
      - dao-network

  nginx:
    image: nginx:alpine
    container_name: dao-leaderboard-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./docker/nginx:/etc/nginx/conf.d
    networks:
      - dao-network

  mysql:
    image: mysql:8.0
    container_name: dao-leaderboard-mysql
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: dao_leaderboard
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_PASSWORD: secret
      MYSQL_USER: dao_user
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - dao-network

  redis:
    image: redis:alpine
    container_name: dao-leaderboard-redis
    restart: unless-stopped
    networks:
      - dao-network

networks:
  dao-network:
    driver: bridge

volumes:
  mysql-data:

docker-compose up -d
docker-compose exec app php artisan migrate --force
docker-compose exec app php artisan db:seed --force
docker-compose exec app php artisan optimize

🔄 CI/CD 파이프라인

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
    
    - name: Install Dependencies
      run: composer install --no-dev --optimize-autoloader
    
    - name: Run Tests
      run: php artisan test
    
    - name: Deploy to Server
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        script: |
          cd /var/www/dao-leaderboard
          git pull origin main
          composer install --no-dev --optimize-autoloader
          php artisan migrate --force
          php artisan optimize
          php artisan queue:restart
          sudo systemctl reload nginx

📊 모니터링과 로깅

composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

// config/logging.php
'channels' => [
    'stack' => [
        'driver' => 'stack',
        'channels' => ['daily', 'slack'],
    ],
    
    'slack' => [
        'driver' => 'slack',
        'url' => env('LOG_SLACK_WEBHOOK_URL'),
        'username' => 'DAO Leaderboard Bot',
        'emoji' => ':boom:',
        'level' => 'error',
    ],
];

🌟 실전 활용 사례와 확장 아이디어

🎯 활용 사례

🚀 확장 아이디어

Schema::create('teams', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->text('description');
    $table->integer('total_score')->default(0);
    $table->timestamps();
});

Schema::create('team_members', function (Blueprint $table) {
    $table->foreignId('team_id')->constrained();
    $table->foreignId('user_id')->constrained();
    $table->enum('role', ['leader', 'member']);
    $table->timestamps();
});

Schema::create('seasons', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->date('start_date');
    $table->date('end_date');
    $table->json('rewards');
    $table->boolean('is_active')->default(false);
    $table->timestamps();
});

Schema::create('quests', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('description');
    $table->json('requirements');
    $table->integer('reward_points');
    $table->date('expires_at')->nullable();
    $table->timestamps();
});

Schema::create('follows', function (Blueprint $table) {
    $table->foreignId('follower_id')->constrained('users');
    $table->foreignId('following_id')->constrained('users');
    $table->timestamps();
    
    $table->unique(['follower_id', 'following_id']);
});

Schema::create('blockchain_accounts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained();
    $table->string('chain'); // 'ethereum', 'polygon', 'bsc' 등
    $table->string('address');
    $table->boolean('is_verified')->default(false);
    $table->timestamps();
    
    $table->unique(['chain', 'address']);
});

💼 재능넷에서의 활용

🎓 마무리하며

💪 다음 단계

🌈 커뮤니티와 함께

🎉 축하해!