🎯 DAO 투표 시스템, 왜 지금 주목받을까?

요즘 블록체인 생태계에서 가장 핫한 키워드 중 하나가 바로 DAO(Decentralized Autonomous Organization)야. 탈중앙화 자율 조직이라는 거창한 이름이지만, 사실 핵심은 간단해. "중앙의 권력 없이도 구성원들이 투명하게 의사결정을 할 수 있는 시스템"이라는 거지! 🎪

전통적인 조직에서는 CEO나 이사회가 모든 결정을 내리잖아? 근데 DAO는 달라. 토큰을 보유한 모든 구성원이 투표권을 가지고, 스마트 컨트랙트가 그 결과를 자동으로 실행해. 완전 민주적이면서도 효율적이지! 💪

그런데 여기서 문제가 하나 있어. 순수하게 블록체인만으로 DAO를 구현하면 사용자 경험이 별로야. 가스비도 비싸고, 속도도 느리고, 일반 사용자들이 접근하기 어렵거든. 그래서 등장한 게 하이브리드 아키텍처야! 블록체인의 투명성과 보안성은 유지하면서, 웹 애플리케이션의 편리함을 더하는 거지. 🌉

🏗️ 시스템 아키텍처 설계하기

본격적으로 라라벨로 DAO 투표 시스템을 만들어보자! 먼저 전체 구조를 이해하는 게 중요해. 우리가 만들 시스템은 크게 세 가지 레이어로 구성돼. 🎯

📐 3-Tier 아키텍처

🔄 데이터 흐름 이해하기

투표 프로세스가 어떻게 진행되는지 단계별로 살펴보자:

1단계: 제안서 생성 📝
사용자가 제안서를 작성하면, 라라벨 백엔드가 MySQL에 저장해. 동시에 제안서 내용의 해시값을 생성해서 IPFS에 업로드하고, 그 CID(Content Identifier)를 스마트 컨트랙트에 기록해. 이렇게 하면 제안서가 위변조되지 않았다는 걸 증명할 수 있어! 🔐

2단계: 투표 진행 🗳️
사용자가 투표하면, 먼저 라라벨이 투표 자격을 검증해. 토큰 보유량, 이전 투표 여부, 제안서 기간 등을 체크하는 거지. 검증이 완료되면 Web3.js를 통해 메타마스크가 열리고, 사용자가 트랜잭션에 서명해. 이 트랜잭션이 블록체인에 기록되면 투표가 완료돼! ✅

3단계: 결과 집계 📊
투표 기간이 끝나면, 라라벨의 스케줄러가 자동으로 결과를 집계해. 블록체인에서 모든 투표 이벤트를 읽어와서 MySQL에 캐싱하고, 최종 결과를 스마트 컨트랙트에 기록해. 이때 Merkle Tree를 사용하면 가스비를 크게 절약할 수 있어! 🌳

4단계: 자동 실행 ⚡
제안이 통과되면, 스마트 컨트랙트가 미리 정의된 액션을 자동으로 실행해. 예를 들어 "프로토콜 수수료를 2%에서 1.5%로 변경"이라는 제안이 통과되면, 컨트랙트가 즉시 수수료 변수를 업데이트하는 거지. 사람의 개입이 전혀 필요 없어! 🤖

⚙️ 라라벨 프로젝트 세팅하기

자, 이제 실제로 코드를 작성해볼 시간이야! 먼저 라라벨 프로젝트를 세팅하고 필요한 패키지들을 설치하자. 🛠️

🚀 프로젝트 초기화

// Composer로 라라벨 프로젝트 생성
composer create-project laravel/laravel dao-voting-system

cd dao-voting-system

// 필수 패키지 설치
composer require web3p/web3.php
composer require kornrunner/keccak
composer require simplito/elliptic-php
composer require phpseclib/phpseclib

// 프론트엔드 의존성
npm install web3 ethers @metamask/detect-provider
npm install vue@next @vitejs/plugin-vue

🔧 환경 설정

.env 파일에 블록체인 관련 설정을 추가하자:

// .env 파일
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=dao_voting
DB_USERNAME=root
DB_PASSWORD=

// 블록체인 설정
BLOCKCHAIN_NETWORK=polygon_mumbai
BLOCKCHAIN_RPC_URL=https://rpc-mumbai.maticvigil.com
BLOCKCHAIN_CHAIN_ID=80001

// 스마트 컨트랙트 주소
VOTING_CONTRACT_ADDRESS=0x...
GOVERNANCE_TOKEN_ADDRESS=0x...

// IPFS 설정
IPFS_GATEWAY=https://ipfs.io/ipfs/
IPFS_API_URL=https://api.pinata.cloud

// 관리자 지갑 (서버 사이드 트랜잭션용)
ADMIN_WALLET_ADDRESS=0x...
ADMIN_WALLET_PRIVATE_KEY=...

📦 데이터베이스 마이그레이션

투표 시스템에 필요한 테이블들을 만들어보자. 라라벨의 마이그레이션 시스템을 활용하면 데이터베이스 스키마를 버전 관리할 수 있어서 정말 편해! 🗄️

// 마이그레이션 파일 생성
php artisan make:migration create_proposals_table
php artisan make:migration create_votes_table
php artisan make:migration create_vote_snapshots_table

각 마이그레이션 파일을 작성해보자:

// database/migrations/xxxx_create_proposals_table.php
public function up()
{
    Schema::create('proposals', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('description');
        $table->string('ipfs_hash')->nullable(); // IPFS CID
        $table->string('blockchain_tx_hash')->nullable();
        $table->unsignedBigInteger('proposal_id_onchain')->nullable();
        
        $table->string('proposer_address', 42);
        $table->enum('status', ['pending', 'active', 'passed', 'rejected', 'executed'])
              ->default('pending');
        
        $table->timestamp('voting_starts_at');
        $table->timestamp('voting_ends_at');
        
        $table->decimal('quorum_required', 5, 2)->default(10.00); // 10%
        $table->decimal('approval_threshold', 5, 2)->default(50.00); // 50%
        
        $table->bigInteger('votes_for')->default(0);
        $table->bigInteger('votes_against')->default(0);
        $table->bigInteger('votes_abstain')->default(0);
        
        $table->json('metadata')->nullable();
        $table->timestamps();
        $table->softDeletes();
        
        $table->index('proposer_address');
        $table->index('status');
        $table->index(['voting_starts_at', 'voting_ends_at']);
    });
}

// database/migrations/xxxx_create_votes_table.php
public function up()
{
    Schema::create('votes', function (Blueprint $table) {
        $table->id();
        $table->foreignId('proposal_id')->constrained()->onDelete('cascade');
        
        $table->string('voter_address', 42);
        $table->enum('vote_choice', ['for', 'against', 'abstain']);
        $table->bigInteger('voting_power'); // 토큰 보유량
        
        $table->string('blockchain_tx_hash')->unique();
        $table->unsignedBigInteger('block_number');
        $table->timestamp('voted_at');
        
        $table->string('signature')->nullable(); // 오프체인 서명
        $table->json('metadata')->nullable();
        
        $table->timestamps();
        
        $table->unique(['proposal_id', 'voter_address']);
        $table->index('voter_address');
        $table->index('blockchain_tx_hash');
    });
}

// database/migrations/xxxx_create_vote_snapshots_table.php
public function up()
{
    Schema::create('vote_snapshots', function (Blueprint $table) {
        $table->id();
        $table->foreignId('proposal_id')->constrained()->onDelete('cascade');
        
        $table->string('voter_address', 42);
        $table->bigInteger('token_balance');
        $table->unsignedBigInteger('snapshot_block');
        
        $table->timestamps();
        
        $table->unique(['proposal_id', 'voter_address']);
        $table->index('snapshot_block');
    });
}

마이그레이션을 실행하자:

php artisan migrate

🎨 Eloquent 모델 만들기

라라벨의 Eloquent ORM은 정말 강력해! 데이터베이스 작업을 객체지향적으로 처리할 수 있거든. 우리 투표 시스템에 필요한 모델들을 만들어보자. 🏛️

// 모델 생성
php artisan make:model Proposal
php artisan make:model Vote
php artisan make:model VoteSnapshot

📝 Proposal 모델

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

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

class Proposal extends Model
{
    use SoftDeletes;
    
    protected $fillable = [
        'title',
        'description',
        'ipfs_hash',
        'blockchain_tx_hash',
        'proposal_id_onchain',
        'proposer_address',
        'status',
        'voting_starts_at',
        'voting_ends_at',
        'quorum_required',
        'approval_threshold',
        'votes_for',
        'votes_against',
        'votes_abstain',
        'metadata'
    ];
    
    protected $casts = [
        'voting_starts_at' => 'datetime',
        'voting_ends_at' => 'datetime',
        'metadata' => 'array',
        'quorum_required' => 'decimal:2',
        'approval_threshold' => 'decimal:2'
    ];
    
    // 관계 정의
    public function votes()
    {
        return $this->hasMany(Vote::class);
    }
    
    public function snapshots()
    {
        return $this->hasMany(VoteSnapshot::class);
    }
    
    // 투표 가능 여부 체크
    public function isVotingActive(): bool
    {
        $now = Carbon::now();
        return $this->status === 'active' 
            && $now->between($this->voting_starts_at, $this->voting_ends_at);
    }
    
    // 정족수 달성 여부
    public function hasReachedQuorum(): bool
    {
        $totalVotes = $this->votes_for + $this->votes_against + $this->votes_abstain;
        $totalSupply = $this->getTotalTokenSupply();
        
        if ($totalSupply == 0) return false;
        
        $participationRate = ($totalVotes / $totalSupply) * 100;
        return $participationRate >= $this->quorum_required;
    }
    
    // 승인 여부
    public function isApproved(): bool
    {
        $totalVotes = $this->votes_for + $this->votes_against;
        
        if ($totalVotes == 0) return false;
        
        $approvalRate = ($this->votes_for / $totalVotes) * 100;
        return $approvalRate >= $this->approval_threshold;
    }
    
    // 최종 결과 계산
    public function calculateResult(): string
    {
        if (!$this->hasReachedQuorum()) {
            return 'rejected'; // 정족수 미달
        }
        
        return $this->isApproved() ? 'passed' : 'rejected';
    }
    
    // 총 토큰 공급량 가져오기 (블록체인에서)
    protected function getTotalTokenSupply(): int
    {
        // 이 부분은 나중에 Web3 서비스로 구현
        return cache()->remember(
            'total_token_supply',
            3600,
            fn() => app('App\Services\Web3Service')->getTotalSupply()
        );
    }
    
    // Accessor: 진행률
    public function getProgressPercentageAttribute(): float
    {
        $now = Carbon::now();
        
        if ($now->lt($this->voting_starts_at)) {
            return 0;
        }
        
        if ($now->gt($this->voting_ends_at)) {
            return 100;
        }
        
        $total = $this->voting_ends_at->diffInSeconds($this->voting_starts_at);
        $elapsed = $now->diffInSeconds($this->voting_starts_at);
        
        return ($elapsed / $total) * 100;
    }
    
    // Scope: 활성 제안만
    public function scopeActive($query)
    {
        return $query->where('status', 'active')
                    ->where('voting_starts_at', '<=', Carbon::now())
                    ->where('voting_ends_at', '>=', Carbon::now());
    }
    
    // Scope: 종료된 제안
    public function scopeEnded($query)
    {
        return $query->where('voting_ends_at', '<', Carbon::now())
                    ->whereIn('status', ['active', 'pending']);
    }
}

🗳️ Vote 모델

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

use Illuminate\Database\Eloquent\Model;

class Vote extends Model
{
    protected $fillable = [
        'proposal_id',
        'voter_address',
        'vote_choice',
        'voting_power',
        'blockchain_tx_hash',
        'block_number',
        'voted_at',
        'signature',
        'metadata'
    ];
    
    protected $casts = [
        'voted_at' => 'datetime',
        'metadata' => 'array'
    ];
    
    // 관계
    public function proposal()
    {
        return $this->belongsTo(Proposal::class);
    }
    
    // 투표 선택을 이모지로 표시
    public function getVoteEmojiAttribute(): string
    {
        return match($this->vote_choice) {
            'for' => '✅',
            'against' => '❌',
            'abstain' => '⏸️',
            default => '❓'
        };
    }
    
    // 블록체인 탐색기 링크
    public function getExplorerUrlAttribute(): string
    {
        $network = config('blockchain.network');
        $baseUrl = match($network) {
            'polygon_mumbai' => 'https://mumbai.polygonscan.com',
            'polygon_mainnet' => 'https://polygonscan.com',
            'ethereum_mainnet' => 'https://etherscan.io',
            default => 'https://etherscan.io'
        };
        
        return "{$baseUrl}/tx/{$this->blockchain_tx_hash}";
    }
}

📸 VoteSnapshot 모델

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

use Illuminate\Database\Eloquent\Model;

class VoteSnapshot extends Model
{
    protected $fillable = [
        'proposal_id',
        'voter_address',
        'token_balance',
        'snapshot_block'
    ];
    
    public function proposal()
    {
        return $this->belongsTo(Proposal::class);
    }
    
    // 특정 주소의 투표권 조회
    public static function getVotingPower(int $proposalId, string $address): int
    {
        $snapshot = static::where('proposal_id', $proposalId)
                          ->where('voter_address', $address)
                          ->first();
        
        return $snapshot ? $snapshot->token_balance : 0;
    }
}

🌐 Web3 서비스 구축하기

이제 블록체인과 통신하는 핵심 서비스를 만들어보자! 라라벨의 서비스 패턴을 활용하면 비즈니스 로직을 깔끔하게 분리할 수 있어. 🎯

⚡ Web3Service 클래스

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

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

class Web3Service
{
    protected $web3;
    protected $eth;
    protected $votingContract;
    protected $tokenContract;
    
    public function __construct()
    {
        $rpcUrl = config('blockchain.rpc_url');
        $this->web3 = new Web3($rpcUrl);
        $this->eth = $this->web3->eth;
        
        // 스마트 컨트랙트 초기화
        $this->initializeContracts();
    }
    
    protected function initializeContracts()
    {
        // Voting Contract ABI 로드
        $votingAbi = json_decode(
            file_get_contents(storage_path('contracts/VotingContract.json')),
            true
        );
        
        $this->votingContract = new Contract(
            $this->web3->provider,
            $votingAbi
        );
        
        $this->votingContract->at(config('blockchain.voting_contract_address'));
        
        // Token Contract 초기화
        $tokenAbi = json_decode(
            file_get_contents(storage_path('contracts/GovernanceToken.json')),
            true
        );
        
        $this->tokenContract = new Contract(
            $this->web3->provider,
            $tokenAbi
        );
        
        $this->tokenContract->at(config('blockchain.token_contract_address'));
    }
    
    // 토큰 잔액 조회
    public function getTokenBalance(string $address): int
    {
        $balance = 0;
        
        $this->tokenContract->call('balanceOf', $address, function ($err, $result) use (&$balance) {
            if ($err) {
                throw new Exception("Failed to get token balance: " . $err->getMessage());
            }
            $balance = hexdec($result[0]->toString());
        });
        
        return $balance;
    }
    
    // 특정 블록의 토큰 잔액 조회 (스냅샷용)
    public function getTokenBalanceAtBlock(string $address, int $blockNumber): int
    {
        // ERC20Snapshot 확장을 사용하는 경우
        $balance = 0;
        
        $this->tokenContract->call(
            'balanceOfAt',
            $address,
            '0x' . dechex($blockNumber),
            function ($err, $result) use (&$balance) {
                if ($err) {
                    throw new Exception("Failed to get historical balance: " . $err->getMessage());
                }
                $balance = hexdec($result[0]->toString());
            }
        );
        
        return $balance;
    }
    
    // 총 토큰 공급량
    public function getTotalSupply(): int
    {
        $supply = 0;
        
        $this->tokenContract->call('totalSupply', function ($err, $result) use (&$supply) {
            if ($err) {
                throw new Exception("Failed to get total supply: " . $err->getMessage());
            }
            $supply = hexdec($result[0]->toString());
        });
        
        return $supply;
    }
    
    // 제안서를 블록체인에 생성
    public function createProposal(array $proposalData): string
    {
        $privateKey = config('blockchain.admin_wallet_private_key');
        $fromAddress = config('blockchain.admin_wallet_address');
        
        // 트랜잭션 데이터 준비
        $data = $this->votingContract->getData(
            'createProposal',
            $proposalData['ipfs_hash'],
            $proposalData['voting_starts_at'],
            $proposalData['voting_ends_at'],
            $proposalData['quorum_required'],
            $proposalData['approval_threshold']
        );
        
        // 가스 추정
        $gasEstimate = $this->estimateGas($fromAddress, $data);
        
        // 트랜잭션 전송
        $txHash = $this->sendTransaction([
            'from' => $fromAddress,
            'to' => config('blockchain.voting_contract_address'),
            'data' => $data,
            'gas' => '0x' . dechex($gasEstimate * 1.2), // 20% 버퍼
            'gasPrice' => $this->getGasPrice()
        ], $privateKey);
        
        return $txHash;
    }
    
    // 투표 트랜잭션 검증
    public function verifyVoteTransaction(string $txHash): array
    {
        $receipt = null;
        
        $this->eth->getTransactionReceipt($txHash, function ($err, $result) use (&$receipt) {
            if ($err) {
                throw new Exception("Failed to get transaction receipt: " . $err->getMessage());
            }
            $receipt = $result;
        });
        
        if (!$receipt || $receipt->status !== '0x1') {
            throw new Exception("Transaction failed or not found");
        }
        
        // 이벤트 로그 파싱
        $logs = $receipt->logs;
        $voteData = $this->parseVoteEvent($logs);
        
        return [
            'proposal_id' => $voteData['proposalId'],
            'voter' => $voteData['voter'],
            'choice' => $voteData['choice'],
            'voting_power' => $voteData['votingPower'],
            'block_number' => hexdec($receipt->blockNumber)
        ];
    }
    
    // Vote 이벤트 파싱
    protected function parseVoteEvent(array $logs): array
    {
        // Vote 이벤트 시그니처
        $voteEventSignature = '0x' . hash('sha3-256', 'VoteCast(uint256,address,uint8,uint256)');
        
        foreach ($logs as $log) {
            if ($log->topics[0] === $voteEventSignature) {
                return [
                    'proposalId' => hexdec($log->topics[1]),
                    'voter' => '0x' . substr($log->topics[2], -40),
                    'choice' => hexdec($log->data),
                    'votingPower' => hexdec(substr($log->data, 66))
                ];
            }
        }
        
        throw new Exception("Vote event not found in transaction logs");
    }
    
    // 가스 가격 조회
    protected function getGasPrice(): string
    {
        $gasPrice = null;
        
        $this->eth->gasPrice(function ($err, $result) use (&$gasPrice) {
            if ($err) {
                throw new Exception("Failed to get gas price: " . $err->getMessage());
            }
            $gasPrice = $result->toString();
        });
        
        return $gasPrice;
    }
    
    // 가스 추정
    protected function estimateGas(string $from, string $data): int
    {
        $gas = 0;
        
        $this->eth->estimateGas([
            'from' => $from,
            'to' => config('blockchain.voting_contract_address'),
            'data' => $data
        ], function ($err, $result) use (&$gas) {
            if ($err) {
                throw new Exception("Failed to estimate gas: " . $err->getMessage());
            }
            $gas = hexdec($result->toString());
        });
        
        return $gas;
    }
    
    // 트랜잭션 전송 (서명 포함)
    protected function sendTransaction(array $tx, string $privateKey): string
    {
        // 논스 가져오기
        $nonce = null;
        $this->eth->getTransactionCount($tx['from'], 'pending', function ($err, $result) use (&$nonce) {
            if ($err) {
                throw new Exception("Failed to get nonce: " . $err->getMessage());
            }
            $nonce = $result->toString();
        });
        
        $tx['nonce'] = $nonce;
        $tx['chainId'] = config('blockchain.chain_id');
        
        // 트랜잭션 서명
        $signedTx = $this->signTransaction($tx, $privateKey);
        
        // 전송
        $txHash = null;
        $this->eth->sendRawTransaction('0x' . $signedTx, function ($err, $result) use (&$txHash) {
            if ($err) {
                throw new Exception("Failed to send transaction: " . $err->getMessage());
            }
            $txHash = $result;
        });
        
        return $txHash;
    }
    
    // 트랜잭션 서명 (간단한 구현)
    protected function signTransaction(array $tx, string $privateKey): string
    {
        // 실제로는 ethereum-tx 라이브러리를 사용하는 게 좋아
        // 여기서는 개념적인 코드만 보여줄게
        
        // RLP 인코딩 후 서명
        // ... (복잡한 서명 로직)
        
        return $signedTxHex;
    }
    
    // 현재 블록 번호
    public function getCurrentBlockNumber(): int
    {
        $blockNumber = 0;
        
        $this->eth->blockNumber(function ($err, $result) use (&$blockNumber) {
            if ($err) {
                throw new Exception("Failed to get block number: " . $err->getMessage());
            }
            $blockNumber = hexdec($result->toString());
        });
        
        return $blockNumber;
    }
    
    // 제안서 최종 결과를 블록체인에 기록
    public function finalizeProposal(int $proposalId, string $result): string
    {
        $privateKey = config('blockchain.admin_wallet_private_key');
        $fromAddress = config('blockchain.admin_wallet_address');
        
        $data = $this->votingContract->getData(
            'finalizeProposal',
            $proposalId,
            $result === 'passed' ? 1 : 0
        );
        
        $gasEstimate = $this->estimateGas($fromAddress, $data);
        
        $txHash = $this->sendTransaction([
            'from' => $fromAddress,
            'to' => config('blockchain.voting_contract_address'),
            'data' => $data,
            'gas' => '0x' . dechex($gasEstimate * 1.2),
            'gasPrice' => $this->getGasPrice()
        ], $privateKey);
        
        return $txHash;
    }
}

📦 IPFS 서비스

제안서 내용을 IPFS에 저장하는 서비스도 만들어보자. IPFS는 분산 파일 시스템이라 데이터가 영구적으로 보존돼! 🌐

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

use GuzzleHttp\Client;
use Exception;

class IpfsService
{
    protected $client;
    protected $apiUrl;
    protected $apiKey;
    
    public function __construct()
    {
        $this->apiUrl = config('ipfs.api_url');
        $this->apiKey = config('ipfs.api_key');
        
        $this->client = new Client([
            'base_uri' => $this->apiUrl,
            'headers' => [
                'Authorization' => 'Bearer ' . $this->apiKey
            ]
        ]);
    }
    
    // 제안서 데이터를 IPFS에 업로드
    public function uploadProposal(array $proposalData): string
    {
        $jsonData = json_encode([
            'title' => $proposalData['title'],
            'description' => $proposalData['description'],
            'proposer' => $proposalData['proposer_address'],
            'created_at' => now()->toIso8601String(),
            'metadata' => $proposalData['metadata'] ?? []
        ], JSON_PRETTY_PRINT);
        
        try {
            $response = $this->client->post('/pinning/pinJSONToIPFS', [
                'json' => [
                    'pinataContent' => json_decode($jsonData),
                    'pinataMetadata' => [
                        'name' => 'Proposal: ' . $proposalData['title']
                    ]
                ]
            ]);
            
            $result = json_decode($response->getBody(), true);
            return $result['IpfsHash'];
            
        } catch (Exception $e) {
            throw new Exception("Failed to upload to IPFS: " . $e->getMessage());
        }
    }
    
    // IPFS에서 제안서 데이터 가져오기
    public function getProposal(string $ipfsHash): array
    {
        try {
            $response = $this->client->get(
                config('ipfs.gateway') . $ipfsHash
            );
            
            return json_decode($response->getBody(), true);
            
        } catch (Exception $e) {
            throw new Exception("Failed to fetch from IPFS: " . $e->getMessage());
        }
    }
    
    // 데이터 해시 검증
    public function verifyHash(array $data, string $expectedHash): bool
    {
        $jsonData = json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
        $calculatedHash = hash('sha256', $jsonData);
        
        return $calculatedHash === $expectedHash;
    }
}

🎮 컨트롤러 구현하기

이제 사용자 요청을 처리할 컨트롤러를 만들어보자! 라라벨의 리소스 컨트롤러 패턴을 활용하면 RESTful API를 쉽게 구현할 수 있어. 🎯

📋 ProposalController

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

use App\Models\Proposal;
use App\Models\VoteSnapshot;
use App\Services\Web3Service;
use App\Services\IpfsService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Carbon\Carbon;

class ProposalController extends Controller
{
    protected $web3Service;
    protected $ipfsService;
    
    public function __construct(Web3Service $web3Service, IpfsService $ipfsService)
    {
        $this->web3Service = $web3Service;
        $this->ipfsService = $ipfsService;
    }
    
    // 제안서 목록 조회
    public function index(Request $request)
    {
        $status = $request->query('status', 'all');
        $perPage = $request->query('per_page', 20);
        
        $query = Proposal::with('votes')
                        ->orderBy('created_at', 'desc');
        
        if ($status !== 'all') {
            $query->where('status', $status);
        }
        
        $proposals = $query->paginate($perPage);
        
        // 각 제안서에 추가 정보 첨부
        $proposals->getCollection()->transform(function ($proposal) {
            $proposal->total_votes = $proposal->votes_for + 
                                    $proposal->votes_against + 
                                    $proposal->votes_abstain;
            
            $proposal->participation_rate = $this->calculateParticipationRate($proposal);
            $proposal->approval_rate = $this->calculateApprovalRate($proposal);
            
            return $proposal;
        });
        
        return response()->json([
            'success' => true,
            'data' => $proposals
        ]);
    }
    
    // 제안서 상세 조회
    public function show($id)
    {
        $proposal = Proposal::with(['votes' => function ($query) {
            $query->orderBy('voted_at', 'desc');
        }])->findOrFail($id);
        
        // IPFS에서 전체 내용 가져오기
        if ($proposal->ipfs_hash) {
            try {
                $ipfsData = $this->ipfsService->getProposal($proposal->ipfs_hash);
                $proposal->full_content = $ipfsData;
            } catch (\Exception $e) {
                $proposal->full_content = null;
            }
        }
        
        // 투표 통계
        $proposal->vote_statistics = [
            'total_votes' => $proposal->votes->count(),
            'votes_for' => $proposal->votes_for,
            'votes_against' => $proposal->votes_against,
            'votes_abstain' => $proposal->votes_abstain,
            'participation_rate' => $this->calculateParticipationRate($proposal),
            'approval_rate' => $this->calculateApprovalRate($proposal),
            'quorum_reached' => $proposal->hasReachedQuorum(),
            'is_approved' => $proposal->isApproved()
        ];
        
        return response()->json([
            'success' => true,
            'data' => $proposal
        ]);
    }
    
    // 새 제안서 생성
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|string|max:255',
            'description' => 'required|string|min:100',
            'proposer_address' => 'required|string|size:42',
            'voting_duration_hours' => 'required|integer|min:24|max:720',
            'quorum_required' => 'nullable|numeric|min:1|max:100',
            'approval_threshold' => 'nullable|numeric|min:50|max:100',
            'metadata' => 'nullable|array'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        // 제안자의 토큰 보유량 확인
        $proposerBalance = $this->web3Service->getTokenBalance(
            $request->proposer_address
        );
        
        $minTokenRequired = config('dao.min_token_to_propose', 1000);
        
        if ($proposerBalance < $minTokenRequired) {
            return response()->json([
                'success' => false,
                'message' => "Insufficient tokens. You need at least {$minTokenRequired} tokens to create a proposal."
            ], 403);
        }
        
        DB::beginTransaction();
        
        try {
            // IPFS에 제안서 업로드
            $ipfsHash = $this->ipfsService->uploadProposal([
                'title' => $request->title,
                'description' => $request->description,
                'proposer_address' => $request->proposer_address,
                'metadata' => $request->metadata
            ]);
            
            // 투표 시작/종료 시간 계산
            $votingStartsAt = Carbon::now()->addHours(1); // 1시간 후 시작
            $votingEndsAt = $votingStartsAt->copy()->addHours(
                $request->voting_duration_hours
            );
            
            // 데이터베이스에 제안서 생성
            $proposal = Proposal::create([
                'title' => $request->title,
                'description' => $request->description,
                'ipfs_hash' => $ipfsHash,
                'proposer_address' => $request->proposer_address,
                'status' => 'pending',
                'voting_starts_at' => $votingStartsAt,
                'voting_ends_at' => $votingEndsAt,
                'quorum_required' => $request->quorum_required ?? 10,
                'approval_threshold' => $request->approval_threshold ?? 50,
                'metadata' => $request->metadata
            ]);
            
            // 블록체인에 제안서 생성 (비동기 처리)
            dispatch(function () use ($proposal) {
                try {
                    $txHash = $this->web3Service->createProposal([
                        'ipfs_hash' => $proposal->ipfs_hash,
                        'voting_starts_at' => $proposal->voting_starts_at->timestamp,
                        'voting_ends_at' => $proposal->voting_ends_at->timestamp,
                        'quorum_required' => $proposal->quorum_required,
                        'approval_threshold' => $proposal->approval_threshold
                    ]);
                    
                    $proposal->update([
                        'blockchain_tx_hash' => $txHash,
                        'status' => 'active'
                    ]);
                    
                    // 스냅샷 생성 스케줄링
                    $this->scheduleSnapshotCreation($proposal);
                    
                } catch (\Exception $e) {
                    \Log::error("Failed to create proposal on blockchain: " . $e->getMessage());
                    $proposal->update(['status' => 'failed']);
                }
            })->afterResponse();
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Proposal created successfully',
                'data' => $proposal
            ], 201);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to create proposal: ' . $e->getMessage()
            ], 500);
        }
    }
    
    // 스냅샷 생성 스케줄링
    protected function scheduleSnapshotCreation(Proposal $proposal)
    {
        // 투표 시작 시점의 블록 번호에서 스냅샷 생성
        dispatch(function () use ($proposal) {
            // 투표 시작까지 대기
            sleep($proposal->voting_starts_at->diffInSeconds(now()));
            
            $snapshotBlock = $this->web3Service->getCurrentBlockNumber();
            
            // 모든 토큰 홀더의 잔액 스냅샷 (실제로는 이벤트 기반으로 처리)
            // 여기서는 개념적인 코드만 보여줄게
            
            $proposal->update([
                'metadata->snapshot_block' => $snapshotBlock
            ]);
            
        })->delay($proposal->voting_starts_at);
    }
    
    // 참여율 계산
    protected function calculateParticipationRate(Proposal $proposal): float
    {
        $totalVotes = $proposal->votes_for + 
                     $proposal->votes_against + 
                     $proposal->votes_abstain;
        
        $totalSupply = $this->web3Service->getTotalSupply();
        
        if ($totalSupply == 0) return 0;
        
        return round(($totalVotes / $totalSupply) * 100, 2);
    }
    
    // 찬성률 계산
    protected function calculateApprovalRate(Proposal $proposal): float
    {
        $totalVotes = $proposal->votes_for + $proposal->votes_against;
        
        if ($totalVotes == 0) return 0;
        
        return round(($proposal->votes_for / $totalVotes) * 100, 2);
    }
}

🗳️ VoteController

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

use App\Models\Proposal;
use App\Models\Vote;
use App\Models\VoteSnapshot;
use App\Services\Web3Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class VoteController extends Controller
{
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    // 투표하기
    public function store(Request $request, $proposalId)
    {
        $validator = Validator::make($request->all(), [
            'voter_address' => 'required|string|size:42',
            'vote_choice' => 'required|in:for,against,abstain',
            'transaction_hash' => 'required|string|size:66',
            'signature' => 'nullable|string'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        $proposal = Proposal::findOrFail($proposalId);
        
        // 투표 가능 여부 확인
        if (!$proposal->isVotingActive()) {
            return response()->json([
                'success' => false,
                'message' => 'Voting is not active for this proposal'
            ], 403);
        }
        
        // 중복 투표 확인
        $existingVote = Vote::where('proposal_id', $proposalId)
                           ->where('voter_address', $request->voter_address)
                           ->first();
        
        if ($existingVote) {
            return response()->json([
                'success' => false,
                'message' => 'You have already voted on this proposal'
            ], 403);
        }
        
        try {
            // 블록체인에서 트랜잭션 검증
            $txData = $this->web3Service->verifyVoteTransaction(
                $request->transaction_hash
            );
            
            // 트랜잭션 데이터와 요청 데이터 일치 확인
            if ($txData['proposal_id'] != $proposalId ||
                strtolower($txData['voter']) !== strtolower($request->voter_address)) {
                return response()->json([
                    'success' => false,
                    'message' => 'Transaction data does not match request'
                ], 400);
            }
            
            // 투표권 확인 (스냅샷 기반)
            $votingPower = VoteSnapshot::getVotingPower(
                $proposalId,
                $request->voter_address
            );
            
            if ($votingPower == 0) {
                // 스냅샷이 없으면 현재 잔액으로 생성
                $votingPower = $this->web3Service->getTokenBalance(
                    $request->voter_address
                );
                
                if ($votingPower == 0) {
                    return response()->json([
                        'success' => false,
                        'message' => 'You do not have voting power'
                    ], 403);
                }
                
                // 스냅샷 생성
                VoteSnapshot::create([
                    'proposal_id' => $proposalId,
                    'voter_address' => $request->voter_address,
                    'token_balance' => $votingPower,
                    'snapshot_block' => $txData['block_number']
                ]);
            }
            
            // 투표 기록 생성
            $vote = Vote::create([
                'proposal_id' => $proposalId,
                'voter_address' => $request->voter_address,
                'vote_choice' => $request->vote_choice,
                'voting_power' => $votingPower,
                'blockchain_tx_hash' => $request->transaction_hash,
                'block_number' => $txData['block_number'],
                'voted_at' => now(),
                'signature' => $request->signature
            ]);
            
            // 제안서 투표 카운트 업데이트
            $this->updateProposalVotes($proposal, $request->vote_choice, $votingPower);
            
            return response()->json([
                'success' => true,
                'message' => 'Vote recorded successfully',
                'data' => $vote
            ], 201);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Failed to record vote: ' . $e->getMessage()
            ], 500);
        }
    }
    
    // 제안서 투표 카운트 업데이트
    protected function updateProposalVotes(Proposal $proposal, string $choice, int $power)
    {
        switch ($choice) {
            case 'for':
                $proposal->increment('votes_for', $power);
                break;
            case 'against':
                $proposal->increment('votes_against', $power);
                break;
            case 'abstain':
                $proposal->increment('votes_abstain', $power);
                break;
        }
    }
    
    // 특정 제안서의 투표 목록
    public function index($proposalId)
    {
        $proposal = Proposal::findOrFail($proposalId);
        
        $votes = Vote::where('proposal_id', $proposalId)
                    ->orderBy('voted_at', 'desc')
                    ->paginate(50);
        
        return response()->json([
            'success' => true,
            'data' => $votes
        ]);
    }
    
    // 특정 주소의 투표 내역
    public function userVotes(Request $request)
    {
        $address = $request->query('address');
        
        if (!$address) {
            return response()->json([
                'success' => false,
                'message' => 'Address parameter is required'
            ], 400);
        }
        
        $votes = Vote::with('proposal')
                    ->where('voter_address', $address)
                    ->orderBy('voted_at', 'desc')
                    ->paginate(20);
        
        return response()->json([
            'success' => true,
            'data' => $votes
        ]);
    }
    
    // 투표 가능 여부 확인
    public function checkEligibility($proposalId, Request $request)
    {
        $address = $request->query('address');
        
        if (!$address) {
            return response()->json([
                'success' => false,
                'message' => 'Address parameter is required'
            ], 400);
        }
        
        $proposal = Proposal::findOrFail($proposalId);
        
        // 투표 기간 확인
        if (!$proposal->isVotingActive()) {
            return response()->json([
                'success' => false,
                'eligible' => false,
                'reason' => 'Voting period has ended or not started yet'
            ]);
        }
        
        // 중복 투표 확인
        $hasVoted = Vote::where('proposal_id', $proposalId)
                       ->where('voter_address', $address)
                       ->exists();
        
        if ($hasVoted) {
            return response()->json([
                'success' => false,
                'eligible' => false,
                'reason' => 'You have already voted'
            ]);
        }
        
        // 투표권 확인
        $votingPower = VoteSnapshot::getVotingPower($proposalId, $address);
        
        if ($votingPower == 0) {
            $votingPower = $this->web3Service->getTokenBalance($address);
        }
        
        if ($votingPower == 0) {
            return response()->json([
                'success' => false,
                'eligible' => false,
                'reason' => 'You do not have any voting power'
            ]);
        }
        
        return response()->json([
            'success' => true,
            'eligible' => true,
            'voting_power' => $votingPower
        ]);
    }
}

⏰ 스케줄러와 큐 작업 설정하기

DAO 투표 시스템은 자동화가 생명이야! 투표 기간 종료, 결과 집계, 스냅샷 생성 등을 자동으로 처리해야 하거든. 라라벨의 Task Scheduling과 Queue 시스템을 활용해보자. ⚙️

📅 스케줄러 설정

// app/Console/Kernel.php
namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule)
    {
        // 매 5분마다 종료된 제안서 확인 및 결과 집계
        $schedule->command('dao:finalize-proposals')
                 ->everyFiveMinutes()
                 ->withoutOverlapping();
        
        // 매 시간마다 활성 제안서 상태 동기화
        $schedule->command('dao:sync-proposals')
                 ->hourly()
                 ->withoutOverlapping();
        
        // 매일 자정에 통계 업데이트
        $schedule->command('dao:update-statistics')
                 ->daily()
                 ->at('00:00');
        
        // 매 10분마다 블록체인 이벤트 리스닝
        $schedule->command('dao:listen-events')
                 ->everyTenMinutes()
                 ->withoutOverlapping();
    }
}

🔨 Artisan 커맨드 구현

// app/Console/Commands/FinalizeProposals.php
namespace App\Console\Commands;

use App\Models\Proposal;
use App\Services\Web3Service;
use Illuminate\Console\Command;
use Carbon\Carbon;

class FinalizeProposals extends Command
{
    protected $signature = 'dao:finalize-proposals';
    protected $description = 'Finalize ended proposals and record results on blockchain';
    
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        parent::__construct();
        $this->web3Service = $web3Service;
    }
    
    public function handle()
    {
        $this->info('Checking for proposals to finalize...');
        
        // 종료되었지만 아직 최종화되지 않은 제안서들
        $proposals = Proposal::ended()
                            ->whereIn('status', ['active', 'pending'])
                            ->get();
        
        if ($proposals->isEmpty()) {
            $this->info('No proposals to finalize.');
            return 0;
        }
        
        $this->info("Found {$proposals->count()} proposals to finalize.");
        
        foreach ($proposals as $proposal) {
            try {
                $this->info("Finalizing proposal #{$proposal->id}: {$proposal->title}");
                
                // 최종 결과 계산
                $result = $proposal->calculateResult();
                
                $this->info("Result: {$result}");
                $this->info("Votes For: {$proposal->votes_for}");
                $this->info("Votes Against: {$proposal->votes_against}");
                $this->info("Votes Abstain: {$proposal->votes_abstain}");
                
                // 블록체인에 결과 기록
                if ($proposal->proposal_id_onchain) {
                    $txHash = $this->web3Service->finalizeProposal(
                        $proposal->proposal_id_onchain,
                        $result
                    );
                    
                    $this->info("Blockchain transaction: {$txHash}");
                }
                
                // 상태 업데이트
                $proposal->update([
                    'status' => $result,
                    'metadata->finalized_at' => Carbon::now()->toIso8601String()
                ]);
                
                $this->info("✅ Proposal #{$proposal->id} finalized successfully.\n");
                
            } catch (\Exception $e) {
                $this->error("❌ Failed to finalize proposal #{$proposal->id}: " . $e->getMessage());
                continue;
            }
        }
        
        $this->info('Finalization complete!');
        return 0;
    }
}

// app/Console/Commands/SyncProposals.php
namespace App\Console\Commands;

use App\Models\Proposal;
use App\Models\Vote;
use App\Services\Web3Service;
use Illuminate\Console\Command;

class SyncProposals extends Command
{
    protected $signature = 'dao:sync-proposals';
    protected $description = 'Sync proposal data with blockchain';
    
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        parent::__construct();
        $this->web3Service = $web3Service;
    }
    
    public function handle()
    {
        $this->info('Syncing proposals with blockchain...');
        
        $activeProposals = Proposal::active()->get();
        
        if ($activeProposals->isEmpty()) {
            $this->info('No active proposals to sync.');
            return 0;
        }
        
        foreach ($activeProposals as $proposal) {
            try {
                $this->info("Syncing proposal #{$proposal->id}");
                
                // 블록체인에서 최신 투표 데이터 가져오기
                // (실제로는 이벤트 로그를 파싱해서 가져와야 해)
                
                // 여기서는 개념적인 코드만
                $onchainData = $this->web3Service->getProposalData(
                    $proposal->proposal_id_onchain
                );
                
                // 데이터 동기화
                if ($onchainData) {
                    $proposal->update([
                        'votes_for' => $onchainData['votesFor'],
                        'votes_against' => $onchainData['votesAgainst'],
                        'votes_abstain' => $onchainData['votesAbstain']
                    ]);
                    
                    $this->info("✅ Synced proposal #{$proposal->id}");
                }
                
            } catch (\Exception $e) {
                $this->error("❌ Failed to sync proposal #{$proposal->id}: " . $e->getMessage());
                continue;
            }
        }
        
        $this->info('Sync complete!');
        return 0;
    }
}

📬 큐 작업 (Jobs)

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

use App\Models\Proposal;
use App\Models\Vote;
use App\Services\Web3Service;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProcessVoteJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public $tries = 3;
    public $timeout = 120;
    
    protected $voteData;
    
    public function __construct(array $voteData)
    {
        $this->voteData = $voteData;
    }
    
    public function handle(Web3Service $web3Service)
    {
        try {
            // 트랜잭션 검증
            $txData = $web3Service->verifyVoteTransaction(
                $this->voteData['transaction_hash']
            );
            
            // 투표 기록 생성
            $vote = Vote::create([
                'proposal_id' => $this->voteData['proposal_id'],
                'voter_address' => $this->voteData['voter_address'],
                'vote_choice' => $this->voteData['vote_choice'],
                'voting_power' => $txData['voting_power'],
                'blockchain_tx_hash' => $this->voteData['transaction_hash'],
                'block_number' => $txData['block_number'],
                'voted_at' => now()
            ]);
            
            // 제안서 카운트 업데이트
            $proposal = Proposal::find($this->voteData['proposal_id']);
            
            switch ($this->voteData['vote_choice']) {
                case 'for':
                    $proposal->increment('votes_for', $txData['voting_power']);
                    break;
                case 'against':
                    $proposal->increment('votes_against', $txData['voting_power']);
                    break;
                case 'abstain':
                    $proposal->increment('votes_abstain', $txData['voting_power']);
                    break;
            }
            
            \Log::info("Vote processed successfully", [
                'vote_id' => $vote->id,
                'proposal_id' => $proposal->id
            ]);
            
        } catch (\Exception $e) {
            \Log::error("Failed to process vote", [
                'error' => $e->getMessage(),
                'vote_data' => $this->voteData
            ]);
            
            throw $e; // 재시도를 위해 예외를 다시 던짐
        }
    }
    
    public function failed(\Throwable $exception)
    {
        // 작업이 완전히 실패했을 때 처리
        \Log::error("Vote processing failed permanently", [
            'error' => $exception->getMessage(),
            'vote_data' => $this->voteData
        ]);
        
        // 관리자에게 알림 발송 등
    }
}

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

use App\Models\Proposal;
use App\Models\VoteSnapshot;
use App\Services\Web3Service;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class CreateSnapshotJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $proposal;
    
    public function __construct(Proposal $proposal)
    {
        $this->proposal = $proposal;
    }
    
    public function handle(Web3Service $web3Service)
    {
        try {
            $snapshotBlock = $web3Service->getCurrentBlockNumber();
            
            // 모든 토큰 홀더 목록 가져오기
            // (실제로는 Transfer 이벤트를 파싱해서 홀더 목록을 만들어야 해)
            $holders = $this->getTokenHolders();
            
            foreach ($holders as $holder) {
                $balance = $web3Service->getTokenBalanceAtBlock(
                    $holder,
                    $snapshotBlock
                );
                
                if ($balance > 0) {
                    VoteSnapshot::create([
                        'proposal_id' => $this->proposal->id,
                        'voter_address' => $holder,
                        'token_balance' => $balance,
                        'snapshot_block' => $snapshotBlock
                    ]);
                }
            }
            
            $this->proposal->update([
                'metadata->snapshot_block' => $snapshotBlock,
                'metadata->snapshot_created_at' => now()->toIso8601String()
            ]);
            
            \Log::info("Snapshot created for proposal #{$this->proposal->id}", [
                'block' => $snapshotBlock,
                'holders_count' => count($holders)
            ]);
            
        } catch (\Exception $e) {
            \Log::error("Failed to create snapshot", [
                'proposal_id' => $this->proposal->id,
                'error' => $e->getMessage()
            ]);
            
            throw $e;
        }
    }
    
    protected function getTokenHolders(): array
    {
        // 캐시된 홀더 목록 반환
        // 실제로는 블록체인 이벤트를 파싱해서 만들어야 해
        return cache()->remember('token_holders', 3600, function () {
            // Transfer 이벤트 파싱 로직
            return [];
        });
    }
}

🎨 프론트엔드 구현하기

이제 사용자가 실제로 사용할 인터페이스를 만들어보자! Vue.js와 Web3.js를 조합하면 정말 멋진 DApp을 만들 수 있어. 🖼️

🔌 Web3 연결 컴포넌트

// resources/js/components/WalletConnect.vue
<template>
  <div class="wallet-connect">
    <div v-if="!isConnected" class="connect-section">
      <button @click="connectWallet" class="connect-btn">
        🦊 Connect Wallet
      </button>
      <p class="hint">Connect your MetaMask to participate in DAO voting</p>
    </div>
    
    <div v-else class="connected-section">
      <div class="wallet-info">
        <span class="address">{{ shortAddress }}</span>
        <span class="balance">{{ tokenBalance }} GOV</span>
      </div>
      <button @click="disconnectWallet" class="disconnect-btn">
        Disconnect
      </button>
    </div>
    
    <div v-if="error" class="error-message">
      ⚠️ {{ error }}
    </div>
  </div>
</template>

<script>
import { ref, computed, onMounted } from 'vue';
import detectEthereumProvider from '@metamask/detect-provider';
import Web3 from 'web3';

export default {
  name: 'WalletConnect',
  
  setup() {
    const isConnected = ref(false);
    const account = ref(null);
    const tokenBalance = ref(0);
    const error = ref(null);
    const web3 = ref(null);
    
    const shortAddress = computed(() => {
      if (!account.value) return '';
      return `${account.value.slice(0, 6)}...${account.value.slice(-4)}`;
    });
    
    const connectWallet = async () => {
      try {
        error.value = null;
        
        const provider = await detectEthereumProvider();
        
        if (!provider) {
          error.value = 'Please install MetaMask!';
          return;
        }
        
        web3.value = new Web3(provider);
        
        // 계정 연결 요청
        const accounts = await provider.request({
          method: 'eth_requestAccounts'
        });
        
        account.value = accounts[0];
        isConnected.value = true;
        
        // 네트워크 확인
        const chainId = await web3.value.eth.getChainId();
        const expectedChainId = import.meta.env.VITE_CHAIN_ID;
        
        if (chainId !== parseInt(expectedChainId)) {
          await switchNetwork();
        }
        
        // 토큰 잔액 조회
        await fetchTokenBalance();
        
        // 이벤트 리스너 등록
        provider.on('accountsChanged', handleAccountsChanged);
        provider.on('chainChanged', handleChainChanged);
        
      } catch (err) {
        console.error('Failed to connect wallet:', err);
        error.value = err.message;
      }
    };
    
    const disconnectWallet = () => {
      isConnected.value = false;
      account.value = null;
      tokenBalance.value = 0;
    };
    
    const switchNetwork = async () => {
      try {
        await window.ethereum.request({
          method: 'wallet_switchEthereumChain',
          params: [{ chainId: '0x' + parseInt(import.meta.env.VITE_CHAIN_ID).toString(16) }]
        });
      } catch (switchError) {
        // 네트워크가 없으면 추가
        if (switchError.code === 4902) {
          await addNetwork();
        }
      }
    };
    
    const addNetwork = async () => {
      await window.ethereum.request({
        method: 'wallet_addEthereumChain',
        params: [{
          chainId: '0x' + parseInt(import.meta.env.VITE_CHAIN_ID).toString(16),
          chainName: 'Polygon Mumbai Testnet',
          nativeCurrency: {
            name: 'MATIC',
            symbol: 'MATIC',
            decimals: 18
          },
          rpcUrls: ['https://rpc-mumbai.maticvigil.com'],
          blockExplorerUrls: ['https://mumbai.polygonscan.com']
        }]
      });
    };
    
    const fetchTokenBalance = async () => {
      if (!web3.value || !account.value) return;
      
      const tokenContract = new web3.value.eth.Contract(
        JSON.parse(import.meta.env.VITE_TOKEN_ABI),
        import.meta.env.VITE_TOKEN_ADDRESS
      );
      
      const balance = await tokenContract.methods.balanceOf(account.value).call();
      tokenBalance.value = web3.value.utils.fromWei(balance, 'ether');
    };
    
    const handleAccountsChanged = (accounts) => {
      if (accounts.length === 0) {
        disconnectWallet();
      } else {
        account.value = accounts[0];
        fetchTokenBalance();
      }
    };
    
    const handleChainChanged = () => {
      window.location.reload();
    };
    
    onMounted(async () => {
      // 이전에 연결했었는지 확인
      const provider = await detectEthereumProvider();
      if (provider && provider.selectedAddress) {
        await connectWallet();
      }
    });
    
    return {
      isConnected,
      account,
      tokenBalance,
      error,
      shortAddress,
      connectWallet,
      disconnectWallet
    };
  }
};
</script>

<style scoped>
.wallet-connect {
  padding: 20px;
}

.connect-btn {
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  color: white;
  border: none;
  padding: 12px 24px;
  border-radius: 8px;
  font-size: 16px;
  font-weight: 600;
  cursor: pointer;
  transition: transform 0.2s;
}

.connect-btn:hover {
  transform: translateY(-2px);
}

.connected-section {
  display: flex;
  align-items: center;
  gap: 15px;
}

.wallet-info {
  background: #f5f7fa;
  padding: 10px 15px;
  border-radius: 8px;
  display: flex;
  gap: 10px;
}

.error-message {
  margin-top: 10px;
  padding: 10px;
  background: #fee;
  color: #c33;
  border-radius: 6px;
}
</style>

🗳️ 투표 컴포넌트

// resources/js/components/VoteProposal.vue
<template>
  <div class="vote-proposal">
    <div class="proposal-header">
      <h2>{{ proposal.title }}</h2>
      <span class="status-badge" :class="proposal.status">
        {{ proposal.status }}
      </span>
    </div>
    
    <div class="proposal-content">
      <p>{{ proposal.description }}</p>
    </div>
    
    <div class="voting-stats">
      <div class="stat-item">
        <span class="label">Voting Power:</span>
        <span class="value">{{ votingPower }} GOV</span>
      </div>
      <div class="stat-item">
        <span class="label">Ends in:</span>
        <span class="value">{{ timeRemaining }}</span>
      </div>
    </div>
    
    <div class="vote-results">
      <div class="result-bar">
        <div class="bar-segment for" :style="{ width: forPercentage + '%' }">
          <span>✅ For: {{ forPercentage }}%</span>
        </div>
        <div class="bar-segment against" :style="{ width: againstPercentage + '%' }">
          <span>❌ Against: {{ againstPercentage }}%</span>
        </div>
      </div>
      
      <div class="vote-counts">
        <div>For: {{ proposal.votes_for }}</div>
        <div>Against: {{ proposal.votes_against }}</div>
        <div>Abstain: {{ proposal.votes_abstain }}</div>
      </div>
    </div>
    
    <div v-if="canVote" class="vote-actions">
      <button 
        @click="vote('for')" 
        class="vote-btn for"
        :disabled="isVoting"
      >
        ✅ Vote For
      </button>
      
      <button 
        @click="vote('against')" 
        class="vote-btn against"
        :disabled="isVoting"
      >
        ❌ Vote Against
      </button>
      
      <button 
        @click="vote('abstain')" 
        class="vote-btn abstain"
        :disabled="isVoting"
      >
        ⏸️ Abstain
      </button>
    </div>
    
    <div v-if="hasVoted" class="voted-message">
      ✅ You have already voted on this proposal
    </div>
    
    <div v-if="isVoting" class="loading-overlay">
      <div class="spinner"></div>
      <p>Processing your vote...</p>
    </div>
  </div>
</template>

<script>
import { ref, computed, onMounted } from 'vue';
import axios from 'axios';
import Web3 from 'web3';

export default {
  name: 'VoteProposal',
  
  props: {
    proposalId: {
      type: Number,
      required: true
    },
    walletAddress: {
      type: String,
      required: true
    }
  },
  
  setup(props) {
    const proposal = ref(null);
    const votingPower = ref(0);
    const canVote = ref(false);
    const hasVoted = ref(false);
    const isVoting = ref(false);
    const web3 = ref(null);
    
    const forPercentage = computed(() => {
      if (!proposal.value) return 0;
      const total = proposal.value.votes_for + proposal.value.votes_against;
      if (total === 0) return 0;
      return Math.round((proposal.value.votes_for / total) * 100);
    });
    
    const againstPercentage = computed(() => {
      return 100 - forPercentage.value;
    });
    
    const timeRemaining = computed(() => {
      if (!proposal.value) return '';
      const end = new Date(proposal.value.voting_ends_at);
      const now = new Date();
      const diff = end - now;
      
      if (diff <= 0) return 'Ended';
      
      const days = Math.floor(diff / (1000 * 60 * 60 * 24));
      const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
      
      return `${days}d ${hours}h`;
    });
    
    const fetchProposal = async () => {
      try {
        const response = await axios.get(`/api/proposals/${props.proposalId}`);
        proposal.value = response.data.data;
      } catch (error) {
        console.error('Failed to fetch proposal:', error);
      }
    };
    
    const checkEligibility = async () => {
      try {
        const response = await axios.get(
          `/api/proposals/${props.proposalId}/check-eligibility`,
          { params: { address: props.walletAddress } }
        );
        
        if (response.data.eligible) {
          canVote.value = true;
          votingPower.value = response.data.voting_power;
        } else {
          canVote.value = false;
          if (response.data.reason.includes('already voted')) {
            hasVoted.value = true;
          }
        }
      } catch (error) {
        console.error('Failed to check eligibility:', error);
      }
    };
    
    const vote = async (choice) => {
      if (!canVote.value || isVoting.value) return;
      
      try {
        isVoting.value = true;
        
        // Web3 초기화
        web3.value = new Web3(window.ethereum);
        
        // 스마트 컨트랙트 인스턴스
        const votingContract = new web3.value.eth.Contract(
          JSON.parse(import.meta.env.VITE_VOTING_ABI),
          import.meta.env.VITE_VOTING_ADDRESS
        );
        
        // 투표 선택을 숫자로 변환 (0: for, 1: against, 2: abstain)
        const voteChoice = choice === 'for' ? 0 : choice === 'against' ? 1 : 2;
        
        // 트랜잭션 전송
        const tx = await votingContract.methods
          .castVote(proposal.value.proposal_id_onchain, voteChoice)
          .send({ from: props.walletAddress });
        
        console.log('Transaction hash:', tx.transactionHash);
        
        // 백엔드에 투표 기록
        await axios.post(`/api/proposals/${props.proposalId}/vote`, {
          voter_address: props.walletAddress,
          vote_choice: choice,
          transaction_hash: tx.transactionHash
        });
        
        // 상태 업데이트
        hasVoted.value = true;
        canVote.value = false;
        
        // 제안서 데이터 새로고침
        await fetchProposal();
        
        alert('✅ Your vote has been recorded successfully!');
        
      } catch (error) {
        console.error('Failed to vote:', error);
        alert('❌ Failed to vote: ' + error.message);
      } finally {
        isVoting.value = false;
      }
    };
    
    onMounted(async () => {
      await fetchProposal();
      if (props.walletAddress) {
        await checkEligibility();
      }
    });
    
    return {
      proposal,
      votingPower,
      canVote,
      hasVoted,
      isVoting,
      forPercentage,
      againstPercentage,
      timeRemaining,
      vote
    };
  }
};
</script>

<style scoped>
.vote-proposal {
  max-width: 800px;
  margin: 0 auto;
  padding: 20px;
}

.proposal-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 20px;
}

.status-badge {
  padding: 6px 12px;
  border-radius: 20px;
  font-size: 14px;
  font-weight: 600;
}

.status-badge.active {
  background: #e8f5e9;
  color: #2e7d32;
}

.vote-results {
  margin: 30px 0;
}

.result-bar {
  display: flex;
  height: 40px;
  border-radius: 8px;
  overflow: hidden;
  margin-bottom: 15px;
}

.bar-segment {
  display: flex;
  align-items: center;
  justify-content: center;
  color: white;
  font-weight: 600;
  transition: width 0.3s ease;
}

.bar-segment.for {
  background: #66bb6a;
}

.bar-segment.against {
  background: #ef5350;
}

.vote-actions {
  display: flex;
  gap: 15px;
  margin-top: 30px;
}

.vote-btn {
  flex: 1;
  padding: 15px;
  border: none;
  border-radius: 8px;
  font-size: 16px;
  font-weight: 600;
  cursor: pointer;
  transition: transform 0.2s;
}

.vote-btn:hover:not(:disabled) {
  transform: translateY(-2px);
}

.vote-btn.for {
  background: #66bb6a;
  color: white;
}

.vote-btn.against {
  background: #ef5350;
  color: white;
}

.vote-btn.abstain {
  background: #9e9e9e;
  color: white;
}

.vote-btn:disabled {
  opacity: 0.5;
  cursor: not-allowed;
}

.loading-overlay {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: rgba(0, 0, 0, 0.7);
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  color: white;
  z-index: 1000;
}

.spinner {
  width: 50px;
  height: 50px;
  border: 5px solid rgba(255, 255, 255, 0.3);
  border-top-color: white;
  border-radius: 50%;
  animation: spin 1s linear infinite;
}

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

🔒 보안 고려사항

DAO 투표 시스템은 돈과 권력이 걸린 문제라 보안이 정말 중요해! 실제 프로덕션에 배포하기 전에 반드시 체크해야 할 보안 사항들을 정리해봤어. 🛡️

🚨 주요 보안 위협

🔐 스마트 컨트랙트 보안

스마트 컨트랙트는 한 번 배포하면 수정이 불가능하니까 배포 전에 철저한 감사가 필요해! 💎

// 안전한 Voting Contract 예시 (Solidity)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

contract DAOVoting is Ownable, ReentrancyGuard, Pausable {
    IERC20 public governanceToken;
    
    struct Proposal {
        uint256 id;
        string ipfsHash;
        address proposer;
        uint256 startBlock;
        uint256 endBlock;
        uint256 snapshotBlock;
        uint256 votesFor;
        uint256 votesAgainst;
        uint256 votesAbstain;
        bool executed;
        bool passed;
    }
    
    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => mapping(address => bool)) public hasVoted;
    mapping(uint256 => mapping(address => uint256)) public votingPower;
    
    uint256 public proposalCount;
    uint256 public quorumPercentage = 10; // 10%
    uint256 public approvalThreshold = 50; // 50%
    
    event ProposalCreated(
        uint256 indexed proposalId,
        string ipfsHash,
        address indexed proposer,
        uint256 startBlock,
        uint256 endBlock
    );
    
    event VoteCast(
        uint256 indexed proposalId,
        address indexed voter,
        uint8 choice,
        uint256 votingPower
    );
    
    event ProposalExecuted(
        uint256 indexed proposalId,
        bool passed
    );
    
    modifier onlyDuringVoting(uint256 proposalId) {
        require(
            block.number >= proposals[proposalId].startBlock &&
            block.number <= proposals[proposalId].endBlock,
            "Voting is not active"
        );
        _;
    }
    
    constructor(address _governanceToken) {
        governanceToken = IERC20(_governanceToken);
    }
    
    function createProposal(
        string memory ipfsHash,
        uint256 votingDuration
    ) external whenNotPaused returns (uint256) {
        // 최소 토큰 보유량 확인
        require(
            governanceToken.balanceOf(msg.sender) >= 1000 * 10**18,
            "Insufficient tokens to propose"
        );
        
        uint256 proposalId = proposalCount++;
        uint256 startBlock = block.number + 100; // 100블록 후 시작
        uint256 snapshotBlock = startBlock - 1;
        
        proposals[proposalId] = Proposal({
            id: proposalId,
            ipfsHash: ipfsHash,
            proposer: msg.sender,
            startBlock: startBlock,
            endBlock: startBlock + votingDuration,
            snapshotBlock: snapshotBlock,
            votesFor: 0,
            votesAgainst: 0,
            votesAbstain: 0,
            executed: false,
            passed: false
        });
        
        emit ProposalCreated(
            proposalId,
            ipfsHash,
            msg.sender,
            startBlock,
            startBlock + votingDuration
        );
        
        return proposalId;
    }
    
    function castVote(
        uint256 proposalId,
        uint8 choice // 0: for, 1: against, 2: abstain
    ) external nonReentrant onlyDuringVoting(proposalId) whenNotPaused {
        require(choice <= 2, "Invalid vote choice");
        require(!hasVoted[proposalId][msg.sender], "Already voted");
        
        Proposal storage proposal = proposals[proposalId];
        
        // 스냅샷 블록 기준 투표권 계산
        uint256 power = getVotingPowerAt(
            msg.sender,
            proposal.snapshotBlock
        );
        
        require(power > 0, "No voting power");
        
        hasVoted[proposalId][msg.sender] = true;
        votingPower[proposalId][msg.sender] = power;
        
        if (choice == 0) {
            proposal.votesFor += power;
        } else if (choice == 1) {
            proposal.votesAgainst += power;
        } else {
            proposal.votesAbstain += power;
        }
        
        emit VoteCast(proposalId, msg.sender, choice, power);
    }
    
    function executeProposal(uint256 proposalId) external nonReentrant {
        Proposal storage proposal = proposals[proposalId];
        
        require(block.number > proposal.endBlock, "Voting still active");
        require(!proposal.executed, "Already executed");
        
        uint256 totalVotes = proposal.votesFor + 
                            proposal.votesAgainst + 
                            proposal.votesAbstain;
        
        uint256 totalSupply = governanceToken.totalSupply();
        uint256 participationRate = (totalVotes * 100) / totalSupply;
        
        // 정족수 확인
        require(
            participationRate >= quorumPercentage,
            "Quorum not reached"
        );
        
        // 승인 여부 확인
        uint256 approvalRate = (proposal.votesFor * 100) / 
                              (proposal.votesFor + proposal.votesAgainst);
        
        proposal.passed = approvalRate >= approvalThreshold;
        proposal.executed = true;
        
        emit ProposalExecuted(proposalId, proposal.passed);
    }
    
    function getVotingPowerAt(
        address account,
        uint256 blockNumber
    ) public view returns (uint256) {
        // ERC20Snapshot을 사용하는 경우
        // return governanceToken.balanceOfAt(account, blockNumber);
        
        // 일반 ERC20의 경우 현재 잔액 반환 (실제로는 스냅샷 구현 필요)
        return governanceToken.balanceOf(account);
    }
    
    function pause() external onlyOwner {
        _pause();
    }
    
    function unpause() external onlyOwner {
        _unpause();
    }
}

🔑 백엔드 보안

// 라라벨 미들웨어로 API 보호
// app/Http/Middleware/VerifySignature.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Elliptic\EC;

class VerifySignature
{
    public function handle(Request $request, Closure $next)
    {
        $signature = $request->header('X-Signature');
        $address = $request->header('X-Address');
        $message = $request->getContent();
        
        if (!$signature || !$address) {
            return response()->json([
                'error' => 'Missing signature or address'
            ], 401);
        }
        
        // 서명 검증
        if (!$this->verifySignature($message, $signature, $address)) {
            return response()->json([
                'error' => 'Invalid signature'
            ], 401);
        }
        
        $request->merge(['verified_address' => $address]);
        
        return $next($request);
    }
    
    protected function verifySignature(
        string $message,
        string $signature,
        string $address
    ): bool {
        try {
            $ec = new EC('secp256k1');
            
            // 메시지 해시
            $messageHash = hash('sha3-256', $message);
            
            // 서명 파싱
            $r = substr($signature, 2, 64);
            $s = substr($signature, 66, 64);
            $v = hexdec(substr($signature, 130, 2));
            
            // 공개키 복구
            $publicKey = $ec->recoverPubKey(
                $messageHash,
                ['r' => $r, 's' => $s],
                $v
            );
            
            // 주소 계산
            $recoveredAddress = '0x' . substr(
                hash('sha3-256', $publicKey->encode('hex')),
                -40
            );
            
            return strtolower($recoveredAddress) === strtolower($address);
            
        } catch (\Exception $e) {
            \Log::error('Signature verification failed: ' . $e->getMessage());
            return false;
        }
    }
}

🚀 배포 및 운영

개발이 끝났다면 이제 실제 서비스로 배포할 차례야! 안정적인 운영을 위한 배포 전략과 모니터링 방법을 알아보자. 🌐

📦 배포 체크리스트

// 프로덕션 배포 명령어
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan optimize

// 큐 워커 실행 (Supervisor로 관리)
php artisan queue:work --tries=3 --timeout=90

// 프론트엔드 빌드
npm run build

// 빌드된 파일을 public 디렉토리로 복사
cp -r dist/* public/

📊 모니터링 설정

시스템이 제대로 작동하는지 실시간으로 모니터링하는 게 중요해. 라라벨 Telescope와 Horizon을 활용하면 좋아! 🔭

// Laravel Telescope 설치
composer require laravel/telescope
php artisan telescope:install
php artisan migrate

// Laravel Horizon 설치 (큐 모니터링)
composer require laravel/horizon
php artisan horizon:install

🔄 CI/CD 파이프라인

GitHub Actions를 사용해서 자동 배포 파이프라인을 구축해보자! 🤖

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

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.1'
      
      - name: Install Dependencies
        run: composer install --no-dev --optimize-autoloader
      
      - name: Run Tests
        run: php artisan test
      
      - name: Run Static Analysis
        run: ./vendor/bin/phpstan analyse

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - 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-voting
            git pull origin main
            composer install --no-dev
            php artisan migrate --force
            php artisan config:cache
            php artisan route:cache
            php artisan queue:restart

💡 실전 팁과 최적화

실제로 DAO 투표 시스템을 운영하면서 배운 노하우들을 공유할게! 이런 팁들을 알고 있으면 훨씬 효율적으로 개발하고 운영할 수 있어. 🎯

⚡ 성능 최적화

// 복합 인덱스 추가 마이그레이션
Schema::table('votes', function (Blueprint $table) {
    $table->index(['proposal_id', 'voter_address']);
    $table->index(['proposal_id', 'voted_at']);
});

// 캐싱 예시
public function getActiveProposals()
{
    return Cache::remember('active_proposals', 300, function () {
        return Proposal::active()
                      ->with('votes')
                      ->get();
    });
}

// 투표 후 캐시 무효화
public function afterVote(Proposal $proposal)
{
    Cache::forget('active_proposals');
    Cache::forget("proposal_{$proposal->id}_stats");
}

// 블록체인 이벤트 리스닝
const votingContract = new web3.eth.Contract(abi, address);

votingContract.events.VoteCast({
    fromBlock: 'latest'
})
.on('data', async (event) => {
    const { proposalId, voter, choice, votingPower } = event.returnValues;
    
    // 데이터베이스 업데이트
    await axios.post('/api/internal/sync-vote', {
        proposal_id: proposalId,
        voter_address: voter,
        vote_choice: choice,
        voting_power: votingPower,
        transaction_hash: event.transactionHash,
        block_number: event.blockNumber
    });
})
.on('error', console.error);

💰 가스비 최적화

이더리움 메인넷은 가스비가 비싸니까 최적화가 필수야! 몇 가지 전략을 소개할게. 💸

🎨 UX 개선 아이디어

기술적으로 완벽해도 사용자 경험이 나쁘면 아무도 안 써. 실제 사용자들이 좋아하는 기능들을 정리해봤어! 😊

재능넷 같은 플랫폼에서도 이런 DAO 거버넌스 시스템을 도입하면 정말 멋질 것 같아! 사용자들이 직접 플랫폼의 정책을 결정하고, 수수료 구조를 투표로 정하고, 새로운 기능 개발 우선순위를 정할 수 있잖아? 완전 혁신적이지! 🚀

🎓 학습 리소스와 커뮤니티

DAO와 블록체인 개발은 계속 진화하는 분야야. 최신 트렌드를 따라가고 싶다면 이런 리소스들을 활용해봐! 📚

🌟 유명 DAO 프로젝트 분석

실제 운영 중인 DAO들을 분석하면 많은 걸 배울 수 있어. 각 프로젝트의 GitHub 저장소를 살펴보면 실전 코드를 볼 수 있지! 🔍

🎯 마무리하며

자, 여기까지 라라벨로 DAO 투표 시스템을 구현하는 전체 과정을 살펴봤어! 정말 긴 여정이었지? 😅

우리가 다룬 내용을 정리해보면:

✅ DAO의 개념과 왜 중요한지
✅ 하이브리드 아키텍처 설계 (온체인 + 오프체인)
✅ 라라벨 백엔드 구현 (모델, 컨트롤러, 서비스)
✅ 스마트 컨트랙트 작성 및 보안
✅ Vue.js 프론트엔드와 Web3 연동
✅ 스케줄러와 큐로 자동화
✅ 보안 고려사항과 최적화
✅ 배포 및 운영 전략

이 모든 걸 완벽하게 구현하려면 시간이 좀 걸리겠지만, 한 단계씩 차근차근 진행하면 충분히 할 수 있어! 💪

특히 기억해야 할 핵심 포인트는:

1. 보안이 최우선이야. 스마트 컨트랙트는 한 번 배포하면 수정이 불가능하니까 배포 전에 철저한 감사가 필수야. 🔒

2. 사용자 경험을 고려해야 해. 아무리 기술적으로 완벽해도 사용하기 어려우면 아무도 안 써. 메타마스크 연결, 트랜잭션 서명, 결과 확인까지 모든 과정이 직관적이어야 해. 🎨

3. 점진적 탈중앙화를 추구하자. 처음부터 완전한 탈중앙화를 목표로 하면 복잡도가 너무 높아져. 초기에는 중앙화된 요소를 일부 남겨두고, 시스템이 안정화되면 점점 더 탈중앙화하는 게 현실적이야. 📈

4. 커뮤니티가 핵심이야. DAO는 결국 사람들의 참여로 작동하는 시스템이거든. 활발한 토론과 투명한 의사결정 과정이 DAO의 성공을 좌우해. 👥

블록체인과 Web3는 정말 빠르게 발전하는 분야야. 오늘 배운 내용도 몇 달 후면 더 좋은 방법이 나올 수 있어. 그러니까 항상 최신 트렌드를 주시하고, 커뮤니티와 소통하면서 계속 배워나가는 게 중요해! 🚀

마지막으로, 이 글이 여러분의 DAO 프로젝트에 도움이 되었으면 좋겠어. 궁금한 점이 있거나 막히는 부분이 있으면 언제든지 커뮤니티에 질문해봐. 블록체인 개발자 커뮤니티는 정말 친절하고 도움을 잘 주거든! 😊

그럼 여러분의 멋진 DAO 프로젝트를 응원할게! 화이팅! 🎉