// 제안서와 투표 관계 설정이 이렇게 간단해!
class Proposal extends Model {
    public function votes() {
        return $this->hasMany(Vote::class);
    }
    
    public function author() {
        return $this->belongsTo(User::class);
    }
}

// 특정 제안서의 찬성 투표 수 조회
$yesVotes = Proposal::find($id)->votes()->where('choice', 'yes')->count();

// 제안서 생성 이벤트
event(new ProposalCreated($proposal));

// 리스너에서 처리
class NotifyProposalCreated {
    public function handle(ProposalCreated $event) {
        // 커뮤니티 멤버들에게 알림 발송
        // 블록체인에 해시 기록
        // 통계 업데이트
    }
}

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

// Web3 PHP 라이브러리
composer require web3p/web3.php

// API 인증 (Sanctum)
composer require laravel/sanctum

// 마크다운 파서
composer require league/commonmark

// 큐 작업을 위한 Redis
composer require predis/predis

// 파일 업로드 처리
composer require intervention/image

// IPFS 클라이언트
composer require rize/uri-template

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=dao_platform
DB_USERNAME=root
DB_PASSWORD=

# 블록체인 네트워크 설정
BLOCKCHAIN_NETWORK=polygon
BLOCKCHAIN_RPC_URL=https://polygon-rpc.com
CONTRACT_ADDRESS=0x...

# IPFS 설정
IPFS_HOST=ipfs.infura.io
IPFS_PORT=5001
IPFS_PROTOCOL=https

# 큐 설정
QUEUE_CONNECTION=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

php artisan make:migration create_users_table

// database/migrations/xxxx_create_users_table.php
public function up() {
    Schema::create('users', function (Blueprint $table) {
        $table->id();
        $table->string('wallet_address')->unique();
        $table->string('username')->nullable();
        $table->string('email')->nullable();
        $table->text('bio')->nullable();
        $table->string('avatar_url')->nullable();
        $table->decimal('token_balance', 20, 8)->default(0);
        $table->boolean('is_verified')->default(false);
        $table->timestamp('last_login_at')->nullable();
        $table->timestamps();
        
        $table->index('wallet_address');
    });
}

php artisan make:migration create_proposals_table

public function up() {
    Schema::create('proposals', function (Blueprint $table) {
        $table->id();
        $table->foreignId('author_id')->constrained('users');
        $table->string('title');
        $table->text('description');
        $table->longText('content'); // 마크다운 형식
        $table->string('category');
        $table->enum('status', ['draft', 'active', 'passed', 'rejected', 'executed']);
        $table->string('ipfs_hash')->nullable(); // IPFS에 저장된 원본 해시
        $table->string('blockchain_tx_hash')->nullable(); // 블록체인 트랜잭션 해시
        $table->timestamp('voting_starts_at')->nullable();
        $table->timestamp('voting_ends_at')->nullable();
        $table->integer('quorum_required')->default(0); // 최소 투표 참여 수
        $table->decimal('approval_threshold', 5, 2)->default(50.00); // 통과 기준 (%)
        $table->timestamps();
        $table->softDeletes();
        
        $table->index(['status', 'voting_ends_at']);
        $table->fulltext(['title', 'description']);
    });
}

php artisan make:migration create_votes_table

public function up() {
    Schema::create('votes', function (Blueprint $table) {
        $table->id();
        $table->foreignId('proposal_id')->constrained();
        $table->foreignId('user_id')->constrained();
        $table->enum('choice', ['yes', 'no', 'abstain']);
        $table->decimal('voting_power', 20, 8); // 투표 시점의 토큰 보유량
        $table->text('reason')->nullable(); // 투표 이유 (선택)
        $table->string('blockchain_tx_hash')->nullable();
        $table->timestamp('voted_at');
        $table->timestamps();
        
        // 한 사용자가 같은 제안서에 중복 투표 방지
        $table->unique(['proposal_id', 'user_id']);
        $table->index('blockchain_tx_hash');
    });
}

php artisan make:migration create_comments_table

public function up() {
    Schema::create('comments', function (Blueprint $table) {
        $table->id();
        $table->foreignId('proposal_id')->constrained();
        $table->foreignId('user_id')->constrained();
        $table->foreignId('parent_id')->nullable()->constrained('comments'); // 대댓글
        $table->text('content');
        $table->integer('likes_count')->default(0);
        $table->timestamps();
        $table->softDeletes();
        
        $table->index(['proposal_id', 'created_at']);
    });
}

php artisan make:migration create_proposal_statistics_table

public function up() {
    Schema::create('proposal_statistics', function (Blueprint $table) {
        $table->id();
        $table->foreignId('proposal_id')->constrained();
        $table->integer('total_votes')->default(0);
        $table->decimal('yes_votes', 20, 8)->default(0);
        $table->decimal('no_votes', 20, 8)->default(0);
        $table->decimal('abstain_votes', 20, 8)->default(0);
        $table->decimal('participation_rate', 5, 2)->default(0);
        $table->integer('comments_count')->default(0);
        $table->integer('views_count')->default(0);
        $table->timestamps();
        
        $table->unique('proposal_id');
    });
}

php artisan make:model Proposal

// app/Models/Proposal.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class Proposal extends Model
{
    use SoftDeletes;
    
    protected $fillable = [
        'author_id', 'title', 'description', 'content',
        'category', 'status', 'ipfs_hash', 'blockchain_tx_hash',
        'voting_starts_at', 'voting_ends_at',
        'quorum_required', 'approval_threshold'
    ];
    
    protected $casts = [
        'voting_starts_at' => 'datetime',
        'voting_ends_at' => 'datetime',
        'approval_threshold' => 'decimal:2'
    ];
    
    // 관계 정의
    public function author() {
        return $this->belongsTo(User::class, 'author_id');
    }
    
    public function votes() {
        return $this->hasMany(Vote::class);
    }
    
    public function comments() {
        return $this->hasMany(Comment::class);
    }
    
    public function statistics() {
        return $this->hasOne(ProposalStatistic::class);
    }
    
    // 비즈니스 로직
    public function isActive() {
        return $this->status === 'active' 
            && now()->between($this->voting_starts_at, $this->voting_ends_at);
    }
    
    public function canVote(User $user) {
        // 이미 투표했는지 확인
        if ($this->votes()->where('user_id', $user->id)->exists()) {
            return false;
        }
        
        // 투표 기간인지 확인
        if (!$this->isActive()) {
            return false;
        }
        
        // 토큰 보유량 확인
        return $user->token_balance > 0;
    }
    
    public function calculateResult() {
        $stats = $this->statistics;
        
        $totalVotingPower = $stats->yes_votes + $stats->no_votes + $stats->abstain_votes;
        
        if ($totalVotingPower == 0) {
            return 'no_votes';
        }
        
        $yesPercentage = ($stats->yes_votes / $totalVotingPower) * 100;
        
        // 정족수 충족 여부
        if ($stats->total_votes < $this->quorum_required) {
            return 'quorum_not_met';
        }
        
        // 통과 기준 충족 여부
        return $yesPercentage >= $this->approval_threshold ? 'passed' : 'rejected';
    }
}

php artisan make:model Vote

// app/Models/Vote.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Vote extends Model
{
    protected $fillable = [
        'proposal_id', 'user_id', 'choice',
        'voting_power', 'reason', 'blockchain_tx_hash', 'voted_at'
    ];
    
    protected $casts = [
        'voting_power' => 'decimal:8',
        'voted_at' => 'datetime'
    ];
    
    public function proposal() {
        return $this->belongsTo(Proposal::class);
    }
    
    public function user() {
        return $this->belongsTo(User::class);
    }
    
    // 투표 후 통계 업데이트
    protected static function booted() {
        static::created(function ($vote) {
            $vote->updateProposalStatistics();
        });
    }
    
    public function updateProposalStatistics() {
        $stats = $this->proposal->statistics;
        
        $stats->total_votes += 1;
        
        switch ($this->choice) {
            case 'yes':
                $stats->yes_votes += $this->voting_power;
                break;
            case 'no':
                $stats->no_votes += $this->voting_power;
                break;
            case 'abstain':
                $stats->abstain_votes += $this->voting_power;
                break;
        }
        
        // 참여율 계산 (전체 토큰 공급량 대비)
        $totalSupply = User::sum('token_balance');
        $stats->participation_rate = ($stats->yes_votes + $stats->no_votes + $stats->abstain_votes) / $totalSupply * 100;
        
        $stats->save();
    }
}

// resources/js/wallet-auth.js

async function connectWallet() {
    if (typeof window.ethereum === 'undefined') {
        alert('MetaMask를 설치해주세요!');
        return;
    }
    
    try {
        // 지갑 연결 요청
        const accounts = await window.ethereum.request({ 
            method: 'eth_requestAccounts' 
        });
        const walletAddress = accounts[0];
        
        // 서버에서 nonce 받아오기
        const nonceResponse = await fetch('/api/auth/nonce', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ wallet_address: walletAddress })
        });
        const { nonce } = await nonceResponse.json();
        
        // 메시지 서명
        const message = `DAO 플랫폼 로그인\n\nNonce: ${nonce}\n주소: ${walletAddress}`;
        const signature = await window.ethereum.request({
            method: 'personal_sign',
            params: [message, walletAddress]
        });
        
        // 서명 검증 및 토큰 받기
        const authResponse = await fetch('/api/auth/verify', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                wallet_address: walletAddress,
                signature: signature,
                nonce: nonce
            })
        });
        
        const { token, user } = await authResponse.json();
        
        // 토큰 저장
        localStorage.setItem('auth_token', token);
        localStorage.setItem('wallet_address', walletAddress);
        
        console.log('로그인 성공!', user);
        window.location.href = '/dashboard';
        
    } catch (error) {
        console.error('지갑 연결 실패:', error);
        alert('지갑 연결에 실패했습니다.');
    }
}

php artisan make:controller Api/AuthController

// app/Http/Controllers/Api/AuthController.php
namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Cache;
use Web3\Web3;
use Web3\Utils;

class AuthController extends Controller
{
    // Nonce 생성
    public function getNonce(Request $request) {
        $request->validate([
            'wallet_address' => 'required|string'
        ]);
        
        $walletAddress = strtolower($request->wallet_address);
        $nonce = Str::random(32);
        
        // Nonce를 5분간 캐시에 저장
        Cache::put("nonce:{$walletAddress}", $nonce, 300);
        
        return response()->json(['nonce' => $nonce]);
    }
    
    // 서명 검증 및 로그인
    public function verifySignature(Request $request) {
        $request->validate([
            'wallet_address' => 'required|string',
            'signature' => 'required|string',
            'nonce' => 'required|string'
        ]);
        
        $walletAddress = strtolower($request->wallet_address);
        $signature = $request->signature;
        $nonce = $request->nonce;
        
        // 캐시된 nonce 확인
        $cachedNonce = Cache::get("nonce:{$walletAddress}");
        if ($cachedNonce !== $nonce) {
            return response()->json(['error' => '유효하지 않은 nonce입니다.'], 401);
        }
        
        // 서명 검증
        $message = "DAO 플랫폼 로그인\n\nNonce: {$nonce}\n주소: {$walletAddress}";
        $recoveredAddress = $this->recoverAddress($message, $signature);
        
        if (strtolower($recoveredAddress) !== $walletAddress) {
            return response()->json(['error' => '서명 검증 실패'], 401);
        }
        
        // Nonce 삭제 (재사용 방지)
        Cache::forget("nonce:{$walletAddress}");
        
        // 사용자 조회 또는 생성
        $user = User::firstOrCreate(
            ['wallet_address' => $walletAddress],
            ['username' => 'User_' . substr($walletAddress, 0, 8)]
        );
        
        // 마지막 로그인 시간 업데이트
        $user->update(['last_login_at' => now()]);
        
        // JWT 토큰 생성 (Laravel Sanctum 사용)
        $token = $user->createToken('auth_token')->plainTextToken;
        
        return response()->json([
            'token' => $token,
            'user' => $user
        ]);
    }
    
    // 서명에서 주소 복구
    private function recoverAddress($message, $signature) {
        $web3 = new Web3('http://localhost:8545');
        $utils = new Utils();
        
        // 이더리움 서명 메시지 형식
        $hash = $utils->sha3("\x19Ethereum Signed Message:\n" . strlen($message) . $message);
        
        // 서명에서 r, s, v 추출
        $r = substr($signature, 0, 66);
        $s = '0x' . substr($signature, 66, 64);
        $v = hexdec(substr($signature, 130, 2));
        
        // 주소 복구 (실제로는 web3.php 라이브러리 사용)
        // 여기서는 간단히 표현
        return $this->ecRecover($hash, $v, $r, $s);
    }
    
    // 로그아웃
    public function logout(Request $request) {
        $request->user()->currentAccessToken()->delete();
        
        return response()->json(['message' => '로그아웃 되었습니다.']);
    }
}

php artisan make:controller ProposalController

// app/Http/Controllers/ProposalController.php
namespace App\Http\Controllers;

use App\Models\Proposal;
use App\Models\ProposalStatistic;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use League\CommonMark\CommonMarkConverter;

class ProposalController extends Controller
{
    // 제안서 목록
    public function index(Request $request) {
        $query = Proposal::with(['author', 'statistics'])
            ->where('status', '!=', 'draft');
        
        // 카테고리 필터
        if ($request->has('category')) {
            $query->where('category', $request->category);
        }
        
        // 상태 필터
        if ($request->has('status')) {
            $query->where('status', $request->status);
        }
        
        // 검색
        if ($request->has('search')) {
            $query->where(function($q) use ($request) {
                $q->where('title', 'like', "%{$request->search}%")
                  ->orWhere('description', 'like', "%{$request->search}%");
            });
        }
        
        // 정렬
        $sortBy = $request->get('sort', 'created_at');
        $sortOrder = $request->get('order', 'desc');
        $query->orderBy($sortBy, $sortOrder);
        
        $proposals = $query->paginate(20);
        
        return view('proposals.index', compact('proposals'));
    }
    
    // 제안서 상세
    public function show($id) {
        $proposal = Proposal::with(['author', 'votes.user', 'comments.user', 'statistics'])
            ->findOrFail($id);
        
        // 조회수 증가
        $proposal->statistics->increment('views_count');
        
        // 마크다운을 HTML로 변환
        $converter = new CommonMarkConverter();
        $proposal->html_content = $converter->convert($proposal->content);
        
        // 현재 사용자가 투표했는지 확인
        $userVote = null;
        if (auth()->check()) {
            $userVote = $proposal->votes()
                ->where('user_id', auth()->id())
                ->first();
        }
        
        return view('proposals.show', compact('proposal', 'userVote'));
    }
    
    // 제안서 작성 폼
    public function create() {
        $categories = [
            'governance' => '거버넌스',
            'treasury' => '재무',
            'technical' => '기술',
            'community' => '커뮤니티',
            'partnership' => '파트너십'
        ];
        
        return view('proposals.create', compact('categories'));
    }
    
    // 제안서 저장
    public function store(Request $request) {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'required|string|max:500',
            'content' => 'required|string',
            'category' => 'required|string',
            'voting_duration' => 'required|integer|min:1|max:30', // 일 단위
            'quorum_required' => 'required|integer|min:1',
            'approval_threshold' => 'required|numeric|min:50|max:100'
        ]);
        
        // 제안서 생성
        $proposal = Proposal::create([
            'author_id' => auth()->id(),
            'title' => $validated['title'],
            'description' => $validated['description'],
            'content' => $validated['content'],
            'category' => $validated['category'],
            'status' => 'draft',
            'quorum_required' => $validated['quorum_required'],
            'approval_threshold' => $validated['approval_threshold']
        ]);
        
        // 통계 레코드 생성
        ProposalStatistic::create([
            'proposal_id' => $proposal->id
        ]);
        
        // IPFS에 업로드 (비동기 처리)
        dispatch(new \App\Jobs\UploadToIpfs($proposal));
        
        return redirect()
            ->route('proposals.show', $proposal->id)
            ->with('success', '제안서 초안이 저장되었습니다.');
    }
    
    // 제안서 제출 (투표 시작)
    public function submit($id) {
        $proposal = Proposal::findOrFail($id);
        
        // 작성자만 제출 가능
        if ($proposal->author_id !== auth()->id()) {
            abort(403, '권한이 없습니다.');
        }
        
        // 이미 제출된 제안서는 수정 불가
        if ($proposal->status !== 'draft') {
            return back()->with('error', '이미 제출된 제안서입니다.');
        }
        
        // 투표 기간 설정
        $votingDuration = request('voting_duration', 7); // 기본 7일
        $proposal->update([
            'status' => 'active',
            'voting_starts_at' => now(),
            'voting_ends_at' => now()->addDays($votingDuration)
        ]);
        
        // 블록체인에 제안서 해시 기록 (비동기)
        dispatch(new \App\Jobs\RecordProposalOnChain($proposal));
        
        // 커뮤니티 멤버들에게 알림
        dispatch(new \App\Jobs\NotifyNewProposal($proposal));
        
        return redirect()
            ->route('proposals.show', $proposal->id)
            ->with('success', '제안서가 제출되었습니다. 투표가 시작됩니다!');
    }
}

php artisan make:job UploadToIpfs

// app/Jobs/UploadToIpfs.php
namespace App\Jobs;

use App\Models\Proposal;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use GuzzleHttp\Client;

class UploadToIpfs implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $proposal;
    
    public function __construct(Proposal $proposal) {
        $this->proposal = $proposal;
    }
    
    public function handle() {
        // 제안서 데이터를 JSON으로 변환
        $data = [
            'title' => $this->proposal->title,
            'description' => $this->proposal->description,
            'content' => $this->proposal->content,
            'author' => $this->proposal->author->wallet_address,
            'category' => $this->proposal->category,
            'created_at' => $this->proposal->created_at->toIso8601String()
        ];
        
        $json = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
        
        // IPFS에 업로드
        $client = new Client();
        $response = $client->post(config('services.ipfs.url') . '/api/v0/add', [
            'multipart' => [
                [
                    'name' => 'file',
                    'contents' => $json,
                    'filename' => "proposal_{$this->proposal->id}.json"
                ]
            ]
        ]);
        
        $result = json_decode($response->getBody(), true);
        $ipfsHash = $result['Hash'];
        
        // IPFS 해시 저장
        $this->proposal->update(['ipfs_hash' => $ipfsHash]);
        
        \Log::info("Proposal {$this->proposal->id} uploaded to IPFS: {$ipfsHash}");
    }
}

php artisan make:controller VoteController

// app/Http/Controllers/VoteController.php
namespace App\Http\Controllers;

use App\Models\Proposal;
use App\Models\Vote;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class VoteController extends Controller
{
    // 투표하기
    public function store(Request $request, $proposalId) {
        $validated = $request->validate([
            'choice' => 'required|in:yes,no,abstain',
            'reason' => 'nullable|string|max:1000'
        ]);
        
        $proposal = Proposal::findOrFail($proposalId);
        $user = auth()->user();
        
        // 투표 가능 여부 확인
        if (!$proposal->canVote($user)) {
            return back()->with('error', '투표할 수 없습니다.');
        }
        
        // 트랜잭션으로 투표 처리
        DB::beginTransaction();
        try {
            // 투표 기록 생성
            $vote = Vote::create([
                'proposal_id' => $proposal->id,
                'user_id' => $user->id,
                'choice' => $validated['choice'],
                'voting_power' => $user->token_balance,
                'reason' => $validated['reason'] ?? null,
                'voted_at' => now()
            ]);
            
            // 블록체인에 투표 기록 (비동기)
            dispatch(new \App\Jobs\RecordVoteOnChain($vote));
            
            DB::commit();
            
            return back()->with('success', '투표가 완료되었습니다!');
            
        } catch (\Exception $e) {
            DB::rollBack();
            \Log::error('Vote failed: ' . $e->getMessage());
            return back()->with('error', '투표 처리 중 오류가 발생했습니다.');
        }
    }
    
    // 투표 취소 (투표 기간 중에만 가능)
    public function destroy($proposalId) {
        $proposal = Proposal::findOrFail($proposalId);
        $user = auth()->user();
        
        // 투표 기간이 아니면 취소 불가
        if (!$proposal->isActive()) {
            return back()->with('error', '투표 기간이 아닙니다.');
        }
        
        $vote = Vote::where('proposal_id', $proposalId)
            ->where('user_id', $user->id)
            ->first();
        
        if (!$vote) {
            return back()->with('error', '투표 기록이 없습니다.');
        }
        
        DB::beginTransaction();
        try {
            // 통계 업데이트 (투표 취소 반영)
            $stats = $proposal->statistics;
            $stats->total_votes -= 1;
            
            switch ($vote->choice) {
                case 'yes':
                    $stats->yes_votes -= $vote->voting_power;
                    break;
                case 'no':
                    $stats->no_votes -= $vote->voting_power;
                    break;
                case 'abstain':
                    $stats->abstain_votes -= $vote->voting_power;
                    break;
            }
            
            $stats->save();
            
            // 투표 삭제
            $vote->delete();
            
            DB::commit();
            
            return back()->with('success', '투표가 취소되었습니다.');
            
        } catch (\Exception $e) {
            DB::rollBack();
            return back()->with('error', '투표 취소 중 오류가 발생했습니다.');
        }
    }
    
    // 투표 결과 조회
    public function results($proposalId) {
        $proposal = Proposal::with(['statistics', 'votes.user'])
            ->findOrFail($proposalId);
        
        // 투표가 종료되지 않았으면 접근 불가
        if ($proposal->isActive()) {
            return back()->with('error', '투표가 아직 진행 중입니다.');
        }
        
        $stats = $proposal->statistics;
        
        // 투표 결과 계산
        $totalVotingPower = $stats->yes_votes + $stats->no_votes + $stats->abstain_votes;
        
        $results = [
            'yes' => [
                'count' => $proposal->votes()->where('choice', 'yes')->count(),
                'power' => $stats->yes_votes,
                'percentage' => $totalVotingPower > 0 ? ($stats->yes_votes / $totalVotingPower * 100) : 0
            ],
            'no' => [
                'count' => $proposal->votes()->where('choice', 'no')->count(),
                'power' => $stats->no_votes,
                'percentage' => $totalVotingPower > 0 ? ($stats->no_votes / $totalVotingPower * 100) : 0
            ],
            'abstain' => [
                'count' => $proposal->votes()->where('choice', 'abstain')->count(),
                'power' => $stats->abstain_votes,
                'percentage' => $totalVotingPower > 0 ? ($stats->abstain_votes / $totalVotingPower * 100) : 0
            ]
        ];
        
        // 최종 결과
        $finalResult = $proposal->calculateResult();
        
        return view('proposals.results', compact('proposal', 'results', 'finalResult'));
    }
}

php artisan make:job RecordVoteOnChain

// app/Jobs/RecordVoteOnChain.php
namespace App\Jobs;

use App\Models\Vote;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Web3\Web3;
use Web3\Contract;

class RecordVoteOnChain implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $vote;
    
    public function __construct(Vote $vote) {
        $this->vote = $vote;
    }
    
    public function handle() {
        try {
            $web3 = new Web3(config('blockchain.rpc_url'));
            
            // 스마트 컨트랙트 ABI 로드
            $abi = json_decode(file_get_contents(storage_path('contracts/DAOGovernance.json')), true);
            
            $contract = new Contract($web3->provider, $abi);
            $contractAddress = config('blockchain.contract_address');
            
            // 투표 데이터 준비
            $proposalId = $this->vote->proposal_id;
            $voter = $this->vote->user->wallet_address;
            $choice = $this->vote->choice === 'yes' ? 1 : ($this->vote->choice === 'no' ? 2 : 0);
            $votingPower = $this->vote->voting_power * 1e18; // Wei 단위로 변환
            
            // 트랜잭션 전송
            $contract->at($contractAddress)->send('recordVote', 
                $proposalId, 
                $voter, 
                $choice, 
                $votingPower, 
                [
                    'from' => config('blockchain.admin_address'),
                    'gas' => '200000'
                ], 
                function ($err, $txHash) {
                    if ($err !== null) {
                        \Log::error('Blockchain vote recording failed: ' . $err->getMessage());
                        return;
                    }
                    
                    // 트랜잭션 해시 저장
                    $this->vote->update(['blockchain_tx_hash' => $txHash]);
                    \Log::info("Vote recorded on blockchain: {$txHash}");
                }
            );
            
        } catch (\Exception $e) {
            \Log::error('RecordVoteOnChain failed: ' . $e->getMessage());
            
            // 재시도 (최대 3번)
            if ($this->attempts() < 3) {
                $this->release(60); // 1분 후 재시도
            }
        }
    }
}

// Pusher 패키지 설치
composer require pusher/pusher-php-server

// .env 설정
BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your_app_id
PUSHER_APP_KEY=your_app_key
PUSHER_APP_SECRET=your_app_secret
PUSHER_APP_CLUSTER=ap3

// config/broadcasting.php 확인
'pusher' => [
    'driver' => 'pusher',
    'key' => env('PUSHER_APP_KEY'),
    'secret' => env('PUSHER_APP_SECRET'),
    'app_id' => env('PUSHER_APP_ID'),
    'options' => [
        'cluster' => env('PUSHER_APP_CLUSTER'),
        'encrypted' => true,
    ],
],

php artisan make:event VoteCasted

// app/Events/VoteCasted.php
namespace App\Events;

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

class VoteCasted implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $vote;
    public $proposalId;
    
    public function __construct(Vote $vote) {
        $this->vote = $vote;
        $this->proposalId = $vote->proposal_id;
    }
    
    public function broadcastOn() {
        return new Channel('proposal.' . $this->proposalId);
    }
    
    public function broadcastWith() {
        $proposal = $this->vote->proposal;
        $stats = $proposal->statistics;
        
        return [
            'vote_id' => $this->vote->id,
            'choice' => $this->vote->choice,
            'voter' => $this->vote->user->username,
            'voting_power' => $this->vote->voting_power,
            'statistics' => [
                'total_votes' => $stats->total_votes,
                'yes_votes' => $stats->yes_votes,
                'no_votes' => $stats->no_votes,
                'abstain_votes' => $stats->abstain_votes,
                'participation_rate' => $stats->participation_rate
            ]
        ];
    }
}

// resources/js/proposal-realtime.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,
    encrypted: true
});

// 제안서 상세 페이지에서
const proposalId = document.querySelector('[data-proposal-id]').dataset.proposalId;

Echo.channel(`proposal.${proposalId}`)
    .listen('VoteCasted', (e) => {
        console.log('새로운 투표:', e);
        
        // 통계 업데이트
        updateStatistics(e.statistics);
        
        // 차트 업데이트
        updateChart(e.statistics);
        
        // 최근 투표 목록에 추가
        addRecentVote(e);
        
        // 알림 표시
        showNotification(`${e.voter}님이 투표했습니다!`);
    });

function updateStatistics(stats) {
    document.getElementById('total-votes').textContent = stats.total_votes;
    document.getElementById('yes-votes').textContent = stats.yes_votes.toFixed(2);
    document.getElementById('no-votes').textContent = stats.no_votes.toFixed(2);
    document.getElementById('participation-rate').textContent = stats.participation_rate.toFixed(2) + '%';
    
    // 프로그레스 바 업데이트
    const totalPower = stats.yes_votes + stats.no_votes + stats.abstain_votes;
    const yesPercentage = (stats.yes_votes / totalPower * 100).toFixed(1);
    const noPercentage = (stats.no_votes / totalPower * 100).toFixed(1);
    
    document.getElementById('yes-bar').style.width = yesPercentage + '%';
    document.getElementById('no-bar').style.width = noPercentage + '%';
    
    document.getElementById('yes-percentage').textContent = yesPercentage + '%';
    document.getElementById('no-percentage').textContent = noPercentage + '%';
}

function updateChart(stats) {
    // Chart.js 업데이트
    if (window.voteChart) {
        window.voteChart.data.datasets[0].data = [
            stats.yes_votes,
            stats.no_votes,
            stats.abstain_votes
        ];
        window.voteChart.update();
    }
}

function addRecentVote(vote) {
    const votesList = document.getElementById('recent-votes');
    const voteElement = document.createElement('div');
    voteElement.className = 'vote-item';
    voteElement.innerHTML = `
        <span class="voter">${vote.voter}</span>
        <span class="choice ${vote.choice}">${vote.choice.toUpperCase()}</span>
        <span class="power">${vote.voting_power} 토큰</span>
        <span class="time">방금 전</span>
    `;
    votesList.prepend(voteElement);
}

function showNotification(message) {
    // 토스트 알림 표시
    const toast = document.createElement('div');
    toast.className = 'toast-notification';
    toast.textContent = message;
    document.body.appendChild(toast);
    
    setTimeout(() => {
        toast.classList.add('show');
    }, 100);
    
    setTimeout(() => {
        toast.classList.remove('show');
        setTimeout(() => toast.remove(), 300);
    }, 3000);
}

// contracts/DAOGovernance.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DAOGovernance {
    struct Proposal {
        uint256 id;
        bytes32 ipfsHash;
        uint256 votingStartTime;
        uint256 votingEndTime;
        uint256 yesVotes;
        uint256 noVotes;
        uint256 abstainVotes;
        bool executed;
        mapping(address => bool) hasVoted;
    }
    
    mapping(uint256 => Proposal) public proposals;
    uint256 public proposalCount;
    
    event ProposalCreated(uint256 indexed proposalId, bytes32 ipfsHash);
    event VoteCasted(uint256 indexed proposalId, address indexed voter, uint8 choice, uint256 votingPower);
    event ProposalExecuted(uint256 indexed proposalId);
    
    function createProposal(bytes32 _ipfsHash, uint256 _votingDuration) external returns (uint256) {
        proposalCount++;
        Proposal storage newProposal = proposals[proposalCount];
        newProposal.id = proposalCount;
        newProposal.ipfsHash = _ipfsHash;
        newProposal.votingStartTime = block.timestamp;
        newProposal.votingEndTime = block.timestamp + _votingDuration;
        
        emit ProposalCreated(proposalCount, _ipfsHash);
        return proposalCount;
    }
    
    function vote(uint256 _proposalId, uint8 _choice, uint256 _votingPower) external {
        Proposal storage proposal = proposals[_proposalId];
        
        require(block.timestamp >= proposal.votingStartTime, "Voting not started");
        require(block.timestamp <= proposal.votingEndTime, "Voting ended");
        require(!proposal.hasVoted[msg.sender], "Already voted");
        require(_choice <= 2, "Invalid choice");
        
        proposal.hasVoted[msg.sender] = true;
        
        if (_choice == 0) {
            proposal.yesVotes += _votingPower;
        } else if (_choice == 1) {
            proposal.noVotes += _votingPower;
        } else {
            proposal.abstainVotes += _votingPower;
        }
        
        emit VoteCasted(_proposalId, msg.sender, _choice, _votingPower);
    }
    
    function executeProposal(uint256 _proposalId) external {
        Proposal storage proposal = proposals[_proposalId];
        
        require(block.timestamp > proposal.votingEndTime, "Voting not ended");
        require(!proposal.executed, "Already executed");
        require(proposal.yesVotes > proposal.noVotes, "Proposal rejected");
        
        proposal.executed = true;
        
        emit ProposalExecuted(_proposalId);
    }
}

php artisan make:service Web3Service

// app/Services/Web3Service.php
namespace App\Services;

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

class Web3Service
{
    protected $web3;
    protected $contract;
    protected $contractAddress;
    
    public function __construct() {
        $this->web3 = new Web3(config('blockchain.rpc_url'));
        $this->contractAddress = config('blockchain.contract_address');
        
        $abi = json_decode(
            file_get_contents(storage_path('contracts/DAOGovernance.json')), 
            true
        );
        
        $this->contract = new Contract($this->web3->provider, $abi);
    }
    
    // 제안서를 블록체인에 생성
    public function createProposal($ipfsHash, $votingDuration) {
        $ipfsHashBytes32 = $this->stringToBytes32($ipfsHash);
        
        return new Promise(function ($resolve, $reject) use ($ipfsHashBytes32, $votingDuration) {
            $this->contract->at($this->contractAddress)->send(
                'createProposal',
                $ipfsHashBytes32,
                $votingDuration,
                [
                    'from' => config('blockchain.admin_address'),
                    'gas' => '300000'
                ],
                function ($err, $txHash) use ($resolve, $reject) {
                    if ($err !== null) {
                        $reject($err);
                        return;
                    }
                    $resolve($txHash);
                }
            );
        });
    }
    
    // 투표를 블록체인에 기록
    public function castVote($proposalId, $voterAddress, $choice, $votingPower) {
        $choiceInt = $choice === 'yes' ? 0 : ($choice === 'no' ? 1 : 2);
        $votingPowerWei = bcmul($votingPower, '1000000000000000000'); // Wei 변환
        
        return new Promise(function ($resolve, $reject) use ($proposalId, $voterAddress, $choiceInt, $votingPowerWei) {
            $this->contract->at($this->contractAddress)->send(
                'vote',
                $proposalId,
                $choiceInt,
                $votingPowerWei,
                [
                    'from' => $voterAddress,
                    'gas' => '200000'
                ],
                function ($err, $txHash) use ($resolve, $reject) {
                    if ($err !== null) {
                        $reject($err);
                        return;
                    }
                    $resolve($txHash);
                }
            );
        });
    }
    
    // 블록체인에서 제안서 정보 조회
    public function getProposal($proposalId) {
        return new Promise(function ($resolve, $reject) use ($proposalId) {
            $this->contract->at($this->contractAddress)->call(
                'proposals',
                $proposalId,
                function ($err, $result) use ($resolve, $reject) {
                    if ($err !== null) {
                        $reject($err);
                        return;
                    }
                    $resolve($result);
                }
            );
        });
    }
    
    // 문자열을 bytes32로 변환
    private function stringToBytes32($string) {
        $hex = bin2hex($string);
        return '0x' . str_pad($hex, 64, '0', STR_PAD_RIGHT);
    }
}

// routes/api.php

use App\Http\Controllers\Api\{
    AuthController,
    ProposalController,
    VoteController,
    UserController
};

// 인증 관련
Route::post('/auth/nonce', [AuthController::class, 'getNonce']);
Route::post('/auth/verify', [AuthController::class, 'verifySignature']);

// 인증 필요한 라우트
Route::middleware('auth:sanctum')->group(function () {
    Route::post('/auth/logout', [AuthController::class, 'logout']);
    
    // 사용자
    Route::get('/user/profile', [UserController::class, 'profile']);
    Route::put('/user/profile', [UserController::class, 'updateProfile']);
    Route::get('/user/votes', [UserController::class, 'myVotes']);
    Route::get('/user/proposals', [UserController::class, 'myProposals']);
    
    // 제안서
    Route::apiResource('proposals', ProposalController::class);
    Route::post('/proposals/{id}/submit', [ProposalController::class, 'submit']);
    Route::get('/proposals/{id}/statistics', [ProposalController::class, 'statistics']);
    
    // 투표
    Route::post('/proposals/{id}/vote', [VoteController::class, 'store']);
    Route::delete('/proposals/{id}/vote', [VoteController::class, 'destroy']);
    Route::get('/proposals/{id}/votes', [VoteController::class, 'index']);
    
    // 댓글
    Route::post('/proposals/{id}/comments', [CommentController::class, 'store']);
    Route::put('/comments/{id}', [CommentController::class, 'update']);
    Route::delete('/comments/{id}', [CommentController::class, 'destroy']);
});

// 공개 API
Route::get('/proposals', [ProposalController::class, 'index']);
Route::get('/proposals/{id}', [ProposalController::class, 'show']);
Route::get('/statistics/overview', [StatisticsController::class, 'overview']);

php artisan make:resource ProposalResource

// app/Http/Resources/ProposalResource.php
namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class ProposalResource extends JsonResource
{
    public function toArray($request) {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'description' => $this->description,
            'content' => $this->content,
            'category' => $this->category,
            'status' => $this->status,
            'author' => [
                'id' => $this->author->id,
                'username' => $this->author->username,
                'wallet_address' => $this->author->wallet_address,
                'avatar_url' => $this->author->avatar_url
            ],
            'voting' => [
                'starts_at' => $this->voting_starts_at?->toIso8601String(),
                'ends_at' => $this->voting_ends_at?->toIso8601String(),
                'is_active' => $this->isActive(),
                'time_remaining' => $this->voting_ends_at ? 
                    now()->diffInSeconds($this->voting_ends_at) : null
            ],
            'statistics' => [
                'total_votes' => $this->statistics->total_votes,
                'yes_votes' => (float) $this->statistics->yes_votes,
                'no_votes' => (float) $this->statistics->no_votes,
                'abstain_votes' => (float) $this->statistics->abstain_votes,
                'participation_rate' => (float) $this->statistics->participation_rate,
                'comments_count' => $this->statistics->comments_count,
                'views_count' => $this->statistics->views_count
            ],
            'blockchain' => [
                'ipfs_hash' => $this->ipfs_hash,
                'tx_hash' => $this->blockchain_tx_hash,
                'ipfs_url' => $this->ipfs_hash ? 
                    "https://ipfs.io/ipfs/{$this->ipfs_hash}" : null
            ],
            'created_at' => $this->created_at->toIso8601String(),
            'updated_at' => $this->updated_at->toIso8601String()
        ];
    }
}

// resources/js/components/VoteWidget.vue
<template>
  <div class="vote-widget">
    <div v-if="!hasVoted" class="vote-buttons">
      <button 
        @click="vote('yes')" 
        class="vote-btn yes"
        :disabled="!canVote">
        👍 찬성
      </button>
      <button 
        @click="vote('no')" 
        class="vote-btn no"
        :disabled="!canVote">
        👎 반대
      </button>
      <button 
        @click="vote('abstain')" 
        class="vote-btn abstain"
        :disabled="!canVote">
        🤷 기권
      </button>
    </div>
    
    <div v-else class="voted-status">
      <p>✅ 투표 완료: {{ userVote.choice.toUpperCase() }}</p>
      <button @click="cancelVote" class="cancel-btn">
        투표 취소
      </button>
    </div>
    
    <div class="vote-stats">
      <div class="stat-bar">
        <div class="bar yes" :style="{ width: yesPercentage + '%' }">
          <span>{{ yesPercentage }}%</span>
        </div>
        <div class="bar no" :style="{ width: noPercentage + '%' }">
          <span>{{ noPercentage }}%</span>
        </div>
      </div>
      
      <div class="stat-details">
        <p>총 투표: {{ statistics.total_votes }}명</p>
        <p>참여율: {{ statistics.participation_rate }}%</p>
      </div>
    </div>
  </div>
</template>

<script>
export default {
  props: ['proposalId', 'initialStatistics', 'userVote'],
  
  data() {
    return {
      statistics: this.initialStatistics,
      hasVoted: !!this.userVote,
      canVote: true
    }
  },
  
  computed: {
    totalPower() {
      return this.statistics.yes_votes + 
             this.statistics.no_votes + 
             this.statistics.abstain_votes;
    },
    yesPercentage() {
      return this.totalPower > 0 ? 
        (this.statistics.yes_votes / this.totalPower * 100).toFixed(1) : 0;
    },
    noPercentage() {
      return this.totalPower > 0 ? 
        (this.statistics.no_votes / this.totalPower * 100).toFixed(1) : 0;
    }
  },
  
  methods: {
    async vote(choice) {
      try {
        const response = await axios.post(
          `/api/proposals/${this.proposalId}/vote`,
          { choice }
        );
        
        this.hasVoted = true;
        this.$emit('voted', response.data);
        
      } catch (error) {
        alert('투표 실패: ' + error.response.data.message);
      }
    },
    
    async cancelVote() {
      if (!confirm('투표를 취소하시겠습니까?')) return;
      
      try {
        await axios.delete(`/api/proposals/${this.proposalId}/vote`);
        this.hasVoted = false;
        this.$emit('vote-cancelled');
        
      } catch (error) {
        alert('투표 취소 실패');
      }
    }
  },
  
  mounted() {
    // 실시간 업데이트 리스너
    Echo.channel(`proposal.${this.proposalId}`)
      .listen('VoteCasted', (e) => {
        this.statistics = e.statistics;
      });
  }
}
</script>

php artisan make:notification NewProposalNotification

// app/Notifications/NewProposalNotification.php
namespace App\Notifications;

use App\Models\Proposal;
use Illuminate\Bus\Queueable;
use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Messages\BroadcastMessage;

class NewProposalNotification extends Notification
{
    use Queueable;
    
    protected $proposal;
    
    public function __construct(Proposal $proposal) {
        $this->proposal = $proposal;
    }
    
    public function via($notifiable) {
        return ['mail', 'database', 'broadcast'];
    }
    
    public function toMail($notifiable) {
        return (new MailMessage)
            ->subject('새로운 제안서: ' . $this->proposal->title)
            ->greeting('안녕하세요!')
            ->line('새로운 제안서가 등록되었습니다.')
            ->line('제목: ' . $this->proposal->title)
            ->line('작성자: ' . $this->proposal->author->username)
            ->action('제안서 보기', url('/proposals/' . $this->proposal->id))
            ->line('투표 기간: ' . $this->proposal->voting_ends_at->diffForHumans());
    }
    
    public function toDatabase($notifiable) {
        return [
            'proposal_id' => $this->proposal->id,
            'title' => $this->proposal->title,
            'author' => $this->proposal->author->username,
            'type' => 'new_proposal'
        ];
    }
    
    public function toBroadcast($notifiable) {
        return new BroadcastMessage([
            'proposal_id' => $this->proposal->id,
            'title' => $this->proposal->title,
            'message' => '새로운 제안서가 등록되었습니다.'
        ]);
    }
}

// 제안서가 제출될 때 모든 활성 사용자에게 알림
$activeUsers = User::where('is_verified', true)
    ->where('last_login_at', '>', now()->subDays(30))
    ->get();

foreach ($activeUsers as $user) {
    $user->notify(new NewProposalNotification($proposal));
}

// 또는 큐를 사용한 대량 알림
Notification::send($activeUsers, new NewProposalNotification($proposal));

php artisan make:controller StatisticsController

// app/Http/Controllers/StatisticsController.php
namespace App\Http\Controllers;

use App\Models\{Proposal, Vote, User};
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Cache;

class StatisticsController extends Controller
{
    // 전체 통계 대시보드
    public function overview() {
        $stats = Cache::remember('dao_statistics', 3600, function () {
            return [
                'total_proposals' => Proposal::count(),
                'active_proposals' => Proposal::where('status', 'active')->count(),
                'passed_proposals' => Proposal::where('status', 'passed')->count(),
                'total_votes' => Vote::count(),
                'active_voters' => User::whereHas('votes')->count(),
                'total_members' => User::count(),
                'avg_participation_rate' => ProposalStatistic::avg('participation_rate'),
                'avg_approval_rate' => $this->calculateAverageApprovalRate()
            ];
        });
        
        return view('statistics.overview', compact('stats'));
    }
    
    // 카테고리별 통계
    public function byCategory() {
        $categoryStats = Proposal::select('category')
            ->selectRaw('COUNT(*) as total')
            ->selectRaw('SUM(CASE WHEN status = "passed" THEN 1 ELSE 0 END) as passed')
            ->selectRaw('SUM(CASE WHEN status = "rejected" THEN 1 ELSE 0 END) as rejected')
            ->groupBy('category')
            ->get();
        
        return response()->json($categoryStats);
    }
    
    // 시간대별 투표 활동
    public function votingActivity(Request $request) {
        $period = $request->get('period', 30); // 기본 30일
        
        $activity = Vote::select(DB::raw('DATE(voted_at) as date'))
            ->selectRaw('COUNT(*) as votes_count')
            ->selectRaw('COUNT(DISTINCT user_id) as unique_voters')
            ->where('voted_at', '>', now()->subDays($period))
            ->groupBy('date')
            ->orderBy('date')
            ->get();
        
        return response()->json($activity);
    }
    
    // 상위 기여자
    public function topContributors() {
        $topVoters = User::withCount('votes')
            ->orderBy('votes_count', 'desc')
            ->limit(10)
            ->get();
        
        $topProposers = User::withCount('proposals')
            ->orderBy('proposals_count', 'desc')
            ->limit(10)
            ->get();
        
        return response()->json([
            'top_voters' => $topVoters,
            'top_proposers' => $topProposers
        ]);
    }
    
    // 평균 승인율 계산
    private function calculateAverageApprovalRate() {
        $completedProposals = Proposal::whereIn('status', ['passed', 'rejected'])
            ->with('statistics')
            ->get();
        
        if ($completedProposals->isEmpty()) {
            return 0;
        }
        
        $totalApprovalRate = $completedProposals->sum(function ($proposal) {
            $stats = $proposal->statistics;
            $totalPower = $stats->yes_votes + $stats->no_votes + $stats->abstain_votes;
            
            return $totalPower > 0 ? ($stats->yes_votes / $totalPower * 100) : 0;
        });
        
        return $totalApprovalRate / $completedProposals->count();
    }
}

php artisan make:middleware CheckVotingEligibility

// app/Http/Middleware/CheckVotingEligibility.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class CheckVotingEligibility
{
    public function handle(Request $request, Closure $next) {
        $user = $request->user();
        
        // 1. 계정 검증 확인
        if (!$user->is_verified) {
            return response()->json([
                'error' => '계정 검증이 필요합니다.'
            ], 403);
        }
        
        // 2. 최소 토큰 보유량 확인
        $minTokenRequired = config('dao.min_token_for_voting', 1);
        if ($user->token_balance < $minTokenRequired) {
            return response()->json([
                'error' => '투표하려면 최소 ' . $minTokenRequired . ' 토큰이 필요합니다.'
            ], 403);
        }
        
        // 3. 계정 생성 후 최소 기간 확인 (Sybil 공격 방지)
        $minAccountAge = config('dao.min_account_age_days', 7);
        if ($user->created_at->diffInDays(now()) < $minAccountAge) {
            return response()->json([
                'error' => '계정 생성 후 ' . $minAccountAge . '일이 지나야 투표할 수 있습니다.'
            ], 403);
        }
        
        // 4. Rate Limiting (과도한 요청 방지)
        $key = 'vote_attempt:' . $user->id;
        $attempts = Cache::get($key, 0);
        
        if ($attempts > 10) {
            return response()->json([
                'error' => '너무 많은 투표 시도입니다. 잠시 후 다시 시도해주세요.'
            ], 429);
        }
        
        Cache::put($key, $attempts + 1, 60); // 1분간 유지
        
        return $next($request);
    }
}

// app/Models/Proposal.php

public function createSnapshot() {
    // 투표 시작 시점의 모든 사용자 토큰 잔액 스냅샷
    $users = User::where('token_balance', '>', 0)->get();
    
    foreach ($users as $user) {
        VotingSnapshot::create([
            'proposal_id' => $this->id,
            'user_id' => $user->id,
            'token_balance' => $user->token_balance,
            'snapshot_at' => now()
        ]);
    }
}

// 투표 시 스냅샷 잔액 사용
public function getVotingPower(User $user) {
    $snapshot = VotingSnapshot::where('proposal_id', $this->id)
        ->where('user_id', $user->id)
        ->first();
    
    return $snapshot ? $snapshot->token_balance : 0;
}

php artisan make:model AuditLog -m

// 마이그레이션
Schema::create('audit_logs', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->nullable()->constrained();
    $table->string('action'); // 'vote', 'proposal_create', 'proposal_edit' 등
    $table->string('entity_type'); // 'Proposal', 'Vote' 등
    $table->unsignedBigInteger('entity_id');
    $table->json('old_values')->nullable();
    $table->json('new_values')->nullable();
    $table->string('ip_address');
    $table->string('user_agent');
    $table->timestamps();
    
    $table->index(['user_id', 'action', 'created_at']);
});

// 사용 예시
AuditLog::create([
    'user_id' => auth()->id(),
    'action' => 'vote_cast',
    'entity_type' => 'Vote',
    'entity_id' => $vote->id,
    'new_values' => [
        'proposal_id' => $vote->proposal_id,
        'choice' => $vote->choice,
        'voting_power' => $vote->voting_power
    ],
    'ip_address' => request()->ip(),
    'user_agent' => request()->userAgent()
]);

// 제안서 목록 캐싱
public function index() {
    $cacheKey = 'proposals:list:' . request('page', 1);
    
    $proposals = Cache::remember($cacheKey, 300, function () {
        return Proposal::with(['author', 'statistics'])
            ->where('status', '!=', 'draft')
            ->orderBy('created_at', 'desc')
            ->paginate(20);
    });
    
    return view('proposals.index', compact('proposals'));
}

// 투표 통계 캐싱
public function statistics($id) {
    $cacheKey = "proposal:{$id}:statistics";
    
    $stats = Cache::remember($cacheKey, 60, function () use ($id) {
        $proposal = Proposal::with('statistics')->findOrFail($id);
        return $proposal->statistics;
    });
    
    return response()->json($stats);
}

// 투표 발생 시 캐시 무효화
public function store(Request $request, $proposalId) {
    // ... 투표 처리 ...
    
    // 관련 캐시 삭제
    Cache::forget("proposal:{$proposalId}:statistics");
    Cache::forget("proposals:list:1"); // 첫 페이지 캐시 삭제
    
    return response()->json(['success' => true]);
}

// ❌ 나쁜 예: N+1 쿼리 문제
$proposals = Proposal::all();
foreach ($proposals as $proposal) {
    echo $proposal->author->username; // 매번 쿼리 실행!
    echo $proposal->statistics->total_votes; // 또 쿼리!
}

// ✅ 좋은 예: Eager Loading
$proposals = Proposal::with(['author', 'statistics'])
    ->get();
foreach ($proposals as $proposal) {
    echo $proposal->author->username; // 이미 로드됨
    echo $proposal->statistics->total_votes; // 이미 로드됨
}

// ✅ 더 좋은 예: 필요한 컬럼만 선택
$proposals = Proposal::select(['id', 'title', 'author_id', 'status'])
    ->with([
        'author:id,username,avatar_url',
        'statistics:proposal_id,total_votes,yes_votes,no_votes'
    ])
    ->get();

php artisan make:test VoteTest

// tests/Feature/VoteTest.php
namespace Tests\Feature;

use Tests\TestCase;
use App\Models\{User, Proposal, Vote};
use Illuminate\Foundation\Testing\RefreshDatabase;

class VoteTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_user_can_vote_on_active_proposal() {
        $user = User::factory()->create(['token_balance' => 100]);
        $proposal = Proposal::factory()->create([
            'status' => 'active',
            'voting_starts_at' => now()->subDay(),
            'voting_ends_at' => now()->addDay()
        ]);
        
        $response = $this->actingAs($user)
            ->postJson("/api/proposals/{$proposal->id}/vote", [
                'choice' => 'yes'
            ]);
        
        $response->assertStatus(200);
        $this->assertDatabaseHas('votes', [
            'proposal_id' => $proposal->id,
            'user_id' => $user->id,
            'choice' => 'yes'
        ]);
    }
    
    public function test_user_cannot_vote_twice() {
        $user = User::factory()->create(['token_balance' => 100]);
        $proposal = Proposal::factory()->create(['status' => 'active']);
        
        Vote::factory()->create([
            'proposal_id' => $proposal->id,
            'user_id' => $user->id
        ]);
        
        $response = $this->actingAs($user)
            ->postJson("/api/proposals/{$proposal->id}/vote", [
                'choice' => 'yes'
            ]);
        
        $response->assertStatus(403);
    }
    
    public function test_user_without_tokens_cannot_vote() {
        $user = User::factory()->create(['token_balance' => 0]);
        $proposal = Proposal::factory()->create(['status' => 'active']);
        
        $response = $this->actingAs($user)
            ->postJson("/api/proposals/{$proposal->id}/vote", [
                'choice' => 'yes'
            ]);
        
        $response->assertStatus(403);
    }
}

# 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

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

WORKDIR /var/www

COPY . .

RUN composer install --no-dev --optimize-autoloader

RUN php artisan config:cache
RUN php artisan route:cache
RUN php artisan view:cache

CMD php artisan serve --host=0.0.0.0 --port=8000

# .env.production
APP_ENV=production
APP_DEBUG=false
APP_URL=https://dao.example.com

DB_CONNECTION=mysql
DB_HOST=production-db.example.com
DB_DATABASE=dao_production

CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis

BLOCKCHAIN_NETWORK=mainnet
BLOCKCHAIN_RPC_URL=https://mainnet.infura.io/v3/YOUR_KEY

# 모니터링
SENTRY_LARAVEL_DSN=your_sentry_dsn