# 라라벨 프로젝트 생성
composer create-project laravel/laravel blockchain-learning-platform

# 프로젝트 디렉토리로 이동
cd blockchain-learning-platform

# 필요한 패키지 설치
composer require web3p/web3.php
composer require simplito/elliptic-php

# 프론트엔드 의존성 설치
npm install
npm install web3 ethers

# 개발 서버 실행
php artisan serve

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=blockchain_learning
DB_USERNAME=root
DB_PASSWORD=your_password

# 블록체인 네트워크 설정
BLOCKCHAIN_NETWORK=ganache
BLOCKCHAIN_RPC_URL=http://127.0.0.1:7545
CONTRACT_ADDRESS=0x...
PRIVATE_KEY=0x...

php artisan make:migration create_users_table

public function up()
{
    Schema::create('users', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->string('email')->unique();
        $table->string('wallet_address')->unique()->nullable();
        $table->timestamp('email_verified_at')->nullable();
        $table->string('password');
        $table->enum('role', ['student', 'instructor', 'admin'])->default('student');
        $table->rememberToken();
        $table->timestamps();
    });
}

public function up()
{
    Schema::create('courses', function (Blueprint $table) {
        $table->id();
        $table->foreignId('instructor_id')->constrained('users')->onDelete('cascade');
        $table->string('title');
        $table->text('description');
        $table->string('thumbnail')->nullable();
        $table->integer('duration_hours');
        $table->decimal('price', 10, 2)->default(0);
        $table->enum('difficulty', ['beginner', 'intermediate', 'advanced']);
        $table->boolean('is_published')->default(false);
        $table->string('contract_address')->nullable(); // 스마트 컨트랙트 주소
        $table->timestamps();
    });
}

public function up()
{
    Schema::create('enrollments', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->foreignId('course_id')->constrained()->onDelete('cascade');
        $table->integer('progress_percentage')->default(0);
        $table->timestamp('enrolled_at');
        $table->timestamp('completed_at')->nullable();
        $table->string('blockchain_tx_hash')->nullable(); // 블록체인 트랜잭션 해시
        $table->boolean('certificate_issued')->default(false);
        $table->string('certificate_token_id')->nullable(); // NFT 토큰 ID
        $table->timestamps();
        
        $table->unique(['user_id', 'course_id']);
    });
}

public function up()
{
    Schema::create('learning_records', function (Blueprint $table) {
        $table->id();
        $table->foreignId('enrollment_id')->constrained()->onDelete('cascade');
        $table->foreignId('lesson_id')->constrained()->onDelete('cascade');
        $table->integer('watch_duration_seconds');
        $table->boolean('completed')->default(false);
        $table->timestamp('completed_at')->nullable();
        $table->string('blockchain_tx_hash')->nullable();
        $table->timestamps();
    });
}

public function up()
{
    Schema::create('certificates', function (Blueprint $table) {
        $table->id();
        $table->foreignId('enrollment_id')->constrained()->onDelete('cascade');
        $table->string('certificate_number')->unique();
        $table->string('token_id')->unique(); // NFT 토큰 ID
        $table->string('token_uri'); // 메타데이터 URI
        $table->string('blockchain_tx_hash');
        $table->string('ipfs_hash')->nullable(); // IPFS에 저장된 증명서 해시
        $table->timestamp('issued_at');
        $table->timestamps();
    });
}

# Hardhat 설치 및 초기화
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers
npx hardhat

# OpenZeppelin 컨트랙트 라이브러리 설치
npm install @openzeppelin/contracts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract LearningCertificate is ERC721, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;
    
    // 수료증 정보 구조체
    struct Certificate {
        uint256 tokenId;
        address student;
        uint256 courseId;
        string courseName;
        uint256 completionDate;
        uint256 score;
        bool isValid;
    }
    
    // 토큰 ID로 수료증 정보 매핑
    mapping(uint256 => Certificate) public certificates;
    
    // 학생 주소로 수료증 목록 매핑
    mapping(address => uint256[]) public studentCertificates;
    
    // 강의 ID로 수료증 목록 매핑
    mapping(uint256 => uint256[]) public courseCertificates;
    
    // 이벤트 정의
    event CertificateIssued(
        uint256 indexed tokenId,
        address indexed student,
        uint256 indexed courseId,
        string courseName,
        uint256 completionDate
    );
    
    event CertificateRevoked(uint256 indexed tokenId);
    
    constructor() ERC721("Learning Certificate", "LCERT") {}
    
    // 수료증 발급 함수
    function issueCertificate(
        address student,
        uint256 courseId,
        string memory courseName,
        string memory tokenURI,
        uint256 score
    ) public onlyOwner returns (uint256) {
        require(student != address(0), "Invalid student address");
        require(score <= 100, "Score must be between 0 and 100");
        
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        
        _safeMint(student, tokenId);
        _setTokenURI(tokenId, tokenURI);
        
        certificates[tokenId] = Certificate({
            tokenId: tokenId,
            student: student,
            courseId: courseId,
            courseName: courseName,
            completionDate: block.timestamp,
            score: score,
            isValid: true
        });
        
        studentCertificates[student].push(tokenId);
        courseCertificates[courseId].push(tokenId);
        
        emit CertificateIssued(tokenId, student, courseId, courseName, block.timestamp);
        
        return tokenId;
    }
    
    // 수료증 검증 함수
    function verifyCertificate(uint256 tokenId) public view returns (
        bool isValid,
        address student,
        uint256 courseId,
        string memory courseName,
        uint256 completionDate,
        uint256 score
    ) {
        require(_exists(tokenId), "Certificate does not exist");
        
        Certificate memory cert = certificates[tokenId];
        return (
            cert.isValid,
            cert.student,
            cert.courseId,
            cert.courseName,
            cert.completionDate,
            cert.score
        );
    }
    
    // 학생의 모든 수료증 조회
    function getStudentCertificates(address student) public view returns (uint256[] memory) {
        return studentCertificates[student];
    }
    
    // 강의의 모든 수료증 조회
    function getCourseCertificates(uint256 courseId) public view returns (uint256[] memory) {
        return courseCertificates[courseId];
    }
    
    // 수료증 무효화 (관리자만 가능)
    function revokeCertificate(uint256 tokenId) public onlyOwner {
        require(_exists(tokenId), "Certificate does not exist");
        certificates[tokenId].isValid = false;
        emit CertificateRevoked(tokenId);
    }
    
    // 필수 오버라이드 함수들
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }
    
    function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
        return super.tokenURI(tokenId);
    }
    
    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721URIStorage) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

const hre = require("hardhat");

async function main() {
    console.log("Deploying LearningCertificate contract...");
    
    const LearningCertificate = await hre.ethers.getContractFactory("LearningCertificate");
    const certificate = await LearningCertificate.deploy();
    
    await certificate.deployed();
    
    console.log("LearningCertificate deployed to:", certificate.address);
    
    // 배포 정보를 파일로 저장
    const fs = require('fs');
    const deploymentInfo = {
        contractAddress: certificate.address,
        deployedAt: new Date().toISOString(),
        network: hre.network.name
    };
    
    fs.writeFileSync(
        './deployment-info.json',
        JSON.stringify(deploymentInfo, null, 2)
    );
    
    console.log("Deployment info saved to deployment-info.json");
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

# 로컬 네트워크 실행 (별도 터미널)
npx hardhat node

# 컨트랙트 배포
npx hardhat run scripts/deploy.js --network localhost

php artisan make:service BlockchainService

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;
use Web3\Utils;
use Exception;
use Illuminate\Support\Facades\Log;

class BlockchainService
{
    protected $web3;
    protected $contract;
    protected $contractAddress;
    protected $contractAbi;
    protected $privateKey;
    protected $fromAddress;
    
    public function __construct()
    {
        $this->web3 = new Web3(config('blockchain.rpc_url'));
        $this->contractAddress = config('blockchain.contract_address');
        $this->privateKey = config('blockchain.private_key');
        $this->fromAddress = config('blockchain.from_address');
        
        // ABI 파일 로드
        $abiPath = storage_path('blockchain/LearningCertificate.json');
        $abiJson = json_decode(file_get_contents($abiPath), true);
        $this->contractAbi = $abiJson['abi'];
        
        $this->contract = new Contract($this->web3->provider, $this->contractAbi);
    }
    
    /**
     * 수료증 NFT 발급
     */
    public function issueCertificate(
        string $studentAddress,
        int $courseId,
        string $courseName,
        string $tokenURI,
        int $score
    ): array {
        try {
            $contract = $this->contract->at($this->contractAddress);
            
            // 트랜잭션 데이터 준비
            $data = $contract->getData('issueCertificate', 
                $studentAddress,
                $courseId,
                $courseName,
                $tokenURI,
                $score
            );
            
            // 가스 추정
            $gasEstimate = $this->estimateGas($data);
            
            // 트랜잭션 전송
            $txHash = $this->sendTransaction([
                'from' => $this->fromAddress,
                'to' => $this->contractAddress,
                'data' => $data,
                'gas' => Utils::toHex($gasEstimate, true),
            ]);
            
            // 트랜잭션 영수증 대기
            $receipt = $this->waitForReceipt($txHash);
            
            // 이벤트 로그에서 토큰 ID 추출
            $tokenId = $this->extractTokenIdFromReceipt($receipt);
            
            Log::info('Certificate issued', [
                'tx_hash' => $txHash,
                'token_id' => $tokenId,
                'student' => $studentAddress,
                'course_id' => $courseId
            ]);
            
            return [
                'success' => true,
                'tx_hash' => $txHash,
                'token_id' => $tokenId,
                'gas_used' => $receipt['gasUsed']
            ];
            
        } catch (Exception $e) {
            Log::error('Failed to issue certificate', [
                'error' => $e->getMessage(),
                'student' => $studentAddress,
                'course_id' => $courseId
            ]);
            
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 수료증 검증
     */
    public function verifyCertificate(int $tokenId): array
    {
        try {
            $contract = $this->contract->at($this->contractAddress);
            
            $result = null;
            $contract->call('verifyCertificate', $tokenId, function ($err, $res) use (&$result) {
                if ($err !== null) {
                    throw new Exception($err->getMessage());
                }
                $result = $res;
            });
            
            return [
                'success' => true,
                'is_valid' => $result['isValid'],
                'student' => $result['student'],
                'course_id' => $result['courseId'],
                'course_name' => $result['courseName'],
                'completion_date' => $result['completionDate'],
                'score' => $result['score']
            ];
            
        } catch (Exception $e) {
            Log::error('Failed to verify certificate', [
                'error' => $e->getMessage(),
                'token_id' => $tokenId
            ]);
            
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 학생의 모든 수료증 조회
     */
    public function getStudentCertificates(string $studentAddress): array
    {
        try {
            $contract = $this->contract->at($this->contractAddress);
            
            $tokenIds = null;
            $contract->call('getStudentCertificates', $studentAddress, function ($err, $res) use (&$tokenIds) {
                if ($err !== null) {
                    throw new Exception($err->getMessage());
                }
                $tokenIds = $res;
            });
            
            return [
                'success' => true,
                'token_ids' => $tokenIds
            ];
            
        } catch (Exception $e) {
            Log::error('Failed to get student certificates', [
                'error' => $e->getMessage(),
                'student' => $studentAddress
            ]);
            
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 가스 추정
     */
    protected function estimateGas(string $data): int
    {
        $gasEstimate = 0;
        
        $this->web3->eth->estimateGas([
            'from' => $this->fromAddress,
            'to' => $this->contractAddress,
            'data' => $data
        ], function ($err, $gas) use (&$gasEstimate) {
            if ($err !== null) {
                throw new Exception('Gas estimation failed: ' . $err->getMessage());
            }
            $gasEstimate = hexdec($gas);
        });
        
        // 안전 마진 추가 (20%)
        return (int)($gasEstimate * 1.2);
    }
    
    /**
     * 트랜잭션 전송
     */
    protected function sendTransaction(array $txParams): string
    {
        // 실제 구현에서는 개인키로 서명하고 전송
        // 여기서는 간소화된 버전
        $txHash = null;
        
        $this->web3->eth->sendTransaction($txParams, function ($err, $hash) use (&$txHash) {
            if ($err !== null) {
                throw new Exception('Transaction failed: ' . $err->getMessage());
            }
            $txHash = $hash;
        });
        
        return $txHash;
    }
    
    /**
     * 트랜잭션 영수증 대기
     */
    protected function waitForReceipt(string $txHash, int $maxAttempts = 30): array
    {
        $attempts = 0;
        $receipt = null;
        
        while ($attempts < $maxAttempts) {
            $this->web3->eth->getTransactionReceipt($txHash, function ($err, $rec) use (&$receipt) {
                if ($err === null && $rec !== null) {
                    $receipt = $rec;
                }
            });
            
            if ($receipt !== null) {
                return $receipt;
            }
            
            sleep(2);
            $attempts++;
        }
        
        throw new Exception('Transaction receipt timeout');
    }
    
    /**
     * 영수증에서 토큰 ID 추출
     */
    protected function extractTokenIdFromReceipt(array $receipt): int
    {
        // 이벤트 로그 파싱하여 토큰 ID 추출
        // 실제 구현에서는 ABI 디코딩 필요
        $logs = $receipt['logs'];
        
        foreach ($logs as $log) {
            // CertificateIssued 이벤트의 토큰 ID 추출
            if (count($log['topics']) > 1) {
                return hexdec($log['topics'][1]);
            }
        }
        
        throw new Exception('Token ID not found in receipt');
    }
}

<?php

return [
    'rpc_url' => env('BLOCKCHAIN_RPC_URL', 'http://127.0.0.1:7545'),
    'contract_address' => env('CONTRACT_ADDRESS'),
    'private_key' => env('PRIVATE_KEY'),
    'from_address' => env('FROM_ADDRESS'),
    'network_id' => env('BLOCKCHAIN_NETWORK_ID', 1337),
    'gas_limit' => env('BLOCKCHAIN_GAS_LIMIT', 3000000),
    'gas_price' => env('BLOCKCHAIN_GAS_PRICE', '20000000000'), // 20 Gwei
];

php artisan make:controller CertificateController

<?php

namespace App\Http\Controllers;

use App\Models\Enrollment;
use App\Models\Certificate;
use App\Services\BlockchainService;
use App\Jobs\IssueCertificateJob;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class CertificateController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    /**
     * 수료증 발급 요청
     */
    public function issue(Request $request, $enrollmentId)
    {
        $enrollment = Enrollment::with(['user', 'course'])->findOrFail($enrollmentId);
        
        // 권한 확인
        if ($request->user()->id !== $enrollment->user_id && !$request->user()->isAdmin()) {
            return response()->json(['error' => 'Unauthorized'], 403);
        }
        
        // 이미 발급되었는지 확인
        if ($enrollment->certificate_issued) {
            return response()->json([
                'error' => 'Certificate already issued',
                'certificate' => $enrollment->certificate
            ], 400);
        }
        
        // 완료 여부 확인
        if ($enrollment->progress_percentage < 100) {
            return response()->json([
                'error' => 'Course not completed',
                'progress' => $enrollment->progress_percentage
            ], 400);
        }
        
        // 지갑 주소 확인
        if (!$enrollment->user->wallet_address) {
            return response()->json([
                'error' => 'Wallet address not set'
            ], 400);
        }
        
        // 비동기로 수료증 발급 작업 큐에 추가
        IssueCertificateJob::dispatch($enrollment);
        
        return response()->json([
            'message' => 'Certificate issuance started',
            'enrollment_id' => $enrollment->id
        ]);
    }
    
    /**
     * 수료증 조회
     */
    public function show($certificateId)
    {
        $certificate = Certificate::with(['enrollment.user', 'enrollment.course'])
            ->findOrFail($certificateId);
        
        // 블록체인에서 검증
        $verification = $this->blockchainService->verifyCertificate(
            (int)$certificate->token_id
        );
        
        return response()->json([
            'certificate' => $certificate,
            'blockchain_verification' => $verification
        ]);
    }
    
    /**
     * 사용자의 모든 수료증 조회
     */
    public function userCertificates(Request $request)
    {
        $user = $request->user();
        
        $certificates = Certificate::whereHas('enrollment', function ($query) use ($user) {
            $query->where('user_id', $user->id);
        })->with(['enrollment.course'])->get();
        
        // 블록체인에서도 조회
        if ($user->wallet_address) {
            $blockchainCerts = $this->blockchainService->getStudentCertificates(
                $user->wallet_address
            );
            
            return response()->json([
                'certificates' => $certificates,
                'blockchain_token_ids' => $blockchainCerts['token_ids'] ?? []
            ]);
        }
        
        return response()->json([
            'certificates' => $certificates
        ]);
    }
    
    /**
     * 수료증 검증 (공개 API)
     */
    public function verify(Request $request)
    {
        $request->validate([
            'certificate_number' => 'required_without:token_id|string',
            'token_id' => 'required_without:certificate_number|integer'
        ]);
        
        if ($request->has('certificate_number')) {
            $certificate = Certificate::where('certificate_number', $request->certificate_number)
                ->with(['enrollment.user', 'enrollment.course'])
                ->first();
            
            if (!$certificate) {
                return response()->json([
                    'valid' => false,
                    'message' => 'Certificate not found'
                ], 404);
            }
            
            $tokenId = (int)$certificate->token_id;
        } else {
            $tokenId = $request->token_id;
        }
        
        // 블록체인에서 검증
        $verification = $this->blockchainService->verifyCertificate($tokenId);
        
        if (!$verification['success']) {
            return response()->json([
                'valid' => false,
                'message' => 'Blockchain verification failed',
                'error' => $verification['error']
            ], 400);
        }
        
        return response()->json([
            'valid' => $verification['is_valid'],
            'certificate' => $certificate ?? null,
            'blockchain_data' => $verification
        ]);
    }
    
    /**
     * 수료증 메타데이터 생성
     */
    protected function generateMetadata(Enrollment $enrollment): string
    {
        $metadata = [
            'name' => "Certificate of Completion - {$enrollment->course->title}",
            'description' => "This certificate is awarded to {$enrollment->user->name} for successfully completing the course: {$enrollment->course->title}",
            'image' => $this->generateCertificateImage($enrollment),
            'attributes' => [
                [
                    'trait_type' => 'Student Name',
                    'value' => $enrollment->user->name
                ],
                [
                    'trait_type' => 'Course Title',
                    'value' => $enrollment->course->title
                ],
                [
                    'trait_type' => 'Completion Date',
                    'value' => $enrollment->completed_at->format('Y-m-d')
                ],
                [
                    'trait_type' => 'Progress',
                    'value' => $enrollment->progress_percentage
                ],
                [
                    'trait_type' => 'Instructor',
                    'value' => $enrollment->course->instructor->name
                ]
            ]
        ];
        
        // IPFS에 업로드하거나 로컬 저장
        $filename = "metadata/{$enrollment->id}.json";
        Storage::put($filename, json_encode($metadata, JSON_PRETTY_PRINT));
        
        // 공개 URL 반환
        return Storage::url($filename);
    }
    
    /**
     * 수료증 이미지 생성
     */
    protected function generateCertificateImage(Enrollment $enrollment): string
    {
        // 실제로는 이미지 생성 라이브러리를 사용
        // 여기서는 간단히 URL만 반환
        return url("/certificates/image/{$enrollment->id}");
    }
}

php artisan make:job IssueCertificateJob

<?php

namespace App\Jobs;

use App\Models\Enrollment;
use App\Models\Certificate;
use App\Services\BlockchainService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;

class IssueCertificateJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $enrollment;
    public $tries = 3;
    public $timeout = 300;
    
    public function __construct(Enrollment $enrollment)
    {
        $this->enrollment = $enrollment;
    }
    
    public function handle(BlockchainService $blockchainService)
    {
        try {
            Log::info('Starting certificate issuance', [
                'enrollment_id' => $this->enrollment->id
            ]);
            
            // 메타데이터 생성
            $tokenURI = $this->generateMetadata();
            
            // 블록체인에 수료증 발급
            $result = $blockchainService->issueCertificate(
                $this->enrollment->user->wallet_address,
                $this->enrollment->course_id,
                $this->enrollment->course->title,
                $tokenURI,
                $this->enrollment->progress_percentage
            );
            
            if (!$result['success']) {
                throw new \Exception('Blockchain issuance failed: ' . $result['error']);
            }
            
            // 데이터베이스에 수료증 정보 저장
            $certificate = Certificate::create([
                'enrollment_id' => $this->enrollment->id,
                'certificate_number' => $this->generateCertificateNumber(),
                'token_id' => $result['token_id'],
                'token_uri' => $tokenURI,
                'blockchain_tx_hash' => $result['tx_hash'],
                'issued_at' => now()
            ]);
            
            // Enrollment 업데이트
            $this->enrollment->update([
                'certificate_issued' => true,
                'certificate_token_id' => $result['token_id'],
                'blockchain_tx_hash' => $result['tx_hash']
            ]);
            
            Log::info('Certificate issued successfully', [
                'certificate_id' => $certificate->id,
                'token_id' => $result['token_id'],
                'tx_hash' => $result['tx_hash']
            ]);
            
            // 사용자에게 알림 전송 (선택사항)
            // $this->enrollment->user->notify(new CertificateIssuedNotification($certificate));
            
        } catch (\Exception $e) {
            Log::error('Certificate issuance failed', [
                'enrollment_id' => $this->enrollment->id,
                'error' => $e->getMessage()
            ]);
            
            throw $e;
        }
    }
    
    protected function generateMetadata(): string
    {
        $metadata = [
            'name' => "Certificate - {$this->enrollment->course->title}",
            'description' => "Awarded to {$this->enrollment->user->name}",
            'image' => url("/api/certificates/image/{$this->enrollment->id}"),
            'attributes' => [
                ['trait_type' => 'Student', 'value' => $this->enrollment->user->name],
                ['trait_type' => 'Course', 'value' => $this->enrollment->course->title],
                ['trait_type' => 'Date', 'value' => now()->format('Y-m-d')],
            ]
        ];
        
        // 실제로는 IPFS에 업로드
        $filename = "metadata/{$this->enrollment->id}.json";
        \Storage::put($filename, json_encode($metadata));
        
        return \Storage::url($filename);
    }
    
    protected function generateCertificateNumber(): string
    {
        return 'CERT-' . strtoupper(Str::random(12));
    }
}

<template>
  <div class="wallet-connect">
    <div v-if="!isConnected" class="connect-section">
      <button @click="connectWallet" class="connect-btn">
        🦊 Connect MetaMask
      </button>
      <p class="info-text">
        Connect your wallet to receive certificates as NFTs
      </p>
    </div>
    
    <div v-else class="connected-section">
      <div class="wallet-info">
        <span class="status-badge">✅ Connected</span>
        <p class="address">{{ shortenAddress(account) }}</p>
        <p class="network">Network: {{ networkName }}</p>
      </div>
      <button @click="disconnectWallet" class="disconnect-btn">
        Disconnect
      </button>
    </div>
    
    <div v-if="error" class="error-message">
      {{ error }}
    </div>
  </div>
</template>

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

export default {
  name: 'WalletConnect',
  
  setup() {
    const account = ref(null);
    const chainId = ref(null);
    const error = ref(null);
    const web3 = ref(null);
    
    const isConnected = computed(() => account.value !== null);
    
    const networkName = computed(() => {
      const networks = {
        '0x1': 'Ethereum Mainnet',
        '0x5': 'Goerli Testnet',
        '0xaa36a7': 'Sepolia Testnet',
        '0x539': 'Local Network'
      };
      return networks[chainId.value] || 'Unknown Network';
    });
    
    const connectWallet = async () => {
      try {
        error.value = null;
        
        if (typeof window.ethereum === 'undefined') {
          error.value = 'MetaMask is not installed. Please install it to continue.';
          return;
        }
        
        web3.value = new Web3(window.ethereum);
        
        const accounts = await window.ethereum.request({
          method: 'eth_requestAccounts'
        });
        
        account.value = accounts[0];
        chainId.value = await window.ethereum.request({
          method: 'eth_chainId'
        });
        
        // 백엔드에 지갑 주소 저장
        await saveWalletAddress(account.value);
        
        console.log('Wallet connected:', account.value);
        
      } catch (err) {
        console.error('Connection error:', err);
        error.value = err.message;
      }
    };
    
    const disconnectWallet = () => {
      account.value = null;
      chainId.value = null;
      web3.value = null;
    };
    
    const saveWalletAddress = async (address) => {
      try {
        await axios.post('/api/user/wallet', {
          wallet_address: address
        });
      } catch (err) {
        console.error('Failed to save wallet address:', err);
      }
    };
    
    const shortenAddress = (address) => {
      if (!address) return '';
      return `${address.substring(0, 6)}...${address.substring(address.length - 4)}`;
    };
    
    // 계정 변경 감지
    const handleAccountsChanged = (accounts) => {
      if (accounts.length === 0) {
        disconnectWallet();
      } else {
        account.value = accounts[0];
        saveWalletAddress(accounts[0]);
      }
    };
    
    // 네트워크 변경 감지
    const handleChainChanged = (newChainId) => {
      chainId.value = newChainId;
      window.location.reload();
    };
    
    onMounted(() => {
      if (typeof window.ethereum !== 'undefined') {
        window.ethereum.on('accountsChanged', handleAccountsChanged);
        window.ethereum.on('chainChanged', handleChainChanged);
        
        // 이미 연결되어 있는지 확인
        window.ethereum.request({ method: 'eth_accounts' })
          .then(accounts => {
            if (accounts.length > 0) {
              account.value = accounts[0];
              window.ethereum.request({ method: 'eth_chainId' })
                .then(id => chainId.value = id);
            }
          });
      }
    });
    
    return {
      account,
      chainId,
      error,
      isConnected,
      networkName,
      connectWallet,
      disconnectWallet,
      shortenAddress
    };
  }
};
</script>

<style scoped>
.wallet-connect {
  padding: 20px;
  border-radius: 12px;
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  color: white;
}

.connect-btn {
  background: white;
  color: #667eea;
  border: none;
  padding: 12px 24px;
  border-radius: 8px;
  font-size: 16px;
  font-weight: bold;
  cursor: pointer;
  transition: transform 0.2s;
}

.connect-btn:hover {
  transform: scale(1.05);
}

.connected-section {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.wallet-info {
  flex: 1;
}

.status-badge {
  background: rgba(255, 255, 255, 0.2);
  padding: 4px 12px;
  border-radius: 20px;
  font-size: 14px;
}

.address {
  font-family: monospace;
  font-size: 18px;
  margin: 8px 0;
}

.network {
  font-size: 14px;
  opacity: 0.9;
}

.disconnect-btn {
  background: rgba(255, 255, 255, 0.2);
  color: white;
  border: 1px solid white;
  padding: 8px 16px;
  border-radius: 6px;
  cursor: pointer;
}

.error-message {
  margin-top: 12px;
  padding: 12px;
  background: rgba(255, 0, 0, 0.2);
  border-radius: 6px;
  border-left: 4px solid #ff4444;
}
</style>

<template>
  <div class="certificate-list">
    <h2>🎓 My Certificates</h2>
    
    <div v-if="loading" class="loading">
      Loading certificates...
    </div>
    
    <div v-else-if="certificates.length === 0" class="empty-state">
      <p>You don't have any certificates yet.</p>
      <p>Complete a course to earn your first certificate!</p>
    </div>
    
    <div v-else class="certificates-grid">
      <div 
        v-for="cert in certificates" 
        :key="cert.id"
        class="certificate-card"
        @click="viewCertificate(cert)"
      >
        <div class="card-header">
          <span class="nft-badge">NFT #{{ cert.token_id }}</span>
          <span class="verified-badge" v-if="cert.is_verified">✓ Verified</span>
        </div>
        
        <div class="card-body">
          <h3>{{ cert.course_name }}</h3>
          <p class="date">Issued: {{ formatDate(cert.issued_at) }}</p>
          <p class="cert-number">{{ cert.certificate_number }}</p>
        </div>
        
        <div class="card-footer">
          <button @click.stop="downloadCertificate(cert)" class="download-btn">
            📥 Download
          </button>
          <button @click.stop="viewOnBlockchain(cert)" class="blockchain-btn">
            🔗 View on Blockchain
          </button>
        </div>
      </div>
    </div>
    
    <CertificateModal 
      v-if="selectedCertificate"
      :certificate="selectedCertificate"
      @close="selectedCertificate = null"
    />
  </div>
</template>

<script>
import { ref, onMounted } from 'vue';
import axios from 'axios';
import CertificateModal from './CertificateModal.vue';

export default {
  name: 'CertificateList',
  components: { CertificateModal },
  
  setup() {
    const certificates = ref([]);
    const loading = ref(true);
    const selectedCertificate = ref(null);
    
    const loadCertificates = async () => {
      try {
        loading.value = true;
        const response = await axios.get('/api/certificates/my');
        certificates.value = response.data.certificates;
        
        // 각 수료증의 블록체인 검증 상태 확인
        for (let cert of certificates.value) {
          await verifyCertificate(cert);
        }
      } catch (error) {
        console.error('Failed to load certificates:', error);
      } finally {
        loading.value = false;
      }
    };
    
    const verifyCertificate = async (cert) => {
      try {
        const response = await axios.post('/api/certificates/verify', {
          token_id: cert.token_id
        });
        cert.is_verified = response.data.valid;
      } catch (error) {
        cert.is_verified = false;
      }
    };
    
    const viewCertificate = (cert) => {
      selectedCertificate.value = cert;
    };
    
    const downloadCertificate = async (cert) => {
      try {
        const response = await axios.get(`/api/certificates/${cert.id}/download`, {
          responseType: 'blob'
        });
        
        const url = window.URL.createObjectURL(new Blob([response.data]));
        const link = document.createElement('a');
        link.href = url;
        link.setAttribute('download', `certificate-${cert.certificate_number}.pdf`);
        document.body.appendChild(link);
        link.click();
        link.remove();
      } catch (error) {
        console.error('Download failed:', error);
      }
    };
    
    const viewOnBlockchain = (cert) => {
      const explorerUrl = `https://etherscan.io/tx/${cert.blockchain_tx_hash}`;
      window.open(explorerUrl, '_blank');
    };
    
    const formatDate = (dateString) => {
      return new Date(dateString).toLocaleDateString('en-US', {
        year: 'numeric',
        month: 'long',
        day: 'numeric'
      });
    };
    
    onMounted(() => {
      loadCertificates();
    });
    
    return {
      certificates,
      loading,
      selectedCertificate,
      viewCertificate,
      downloadCertificate,
      viewOnBlockchain,
      formatDate
    };
  }
};
</script>

<style scoped>
.certificate-list {
  padding: 20px;
}

.certificates-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
  gap: 20px;
  margin-top: 20px;
}

.certificate-card {
  background: white;
  border-radius: 12px;
  padding: 20px;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
  cursor: pointer;
  transition: transform 0.2s, box-shadow 0.2s;
}

.certificate-card:hover {
  transform: translateY(-4px);
  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.15);
}

.card-header {
  display: flex;
  justify-content: space-between;
  margin-bottom: 12px;
}

.nft-badge {
  background: linear-gradient(135deg, #667eea, #764ba2);
  color: white;
  padding: 4px 12px;
  border-radius: 20px;
  font-size: 12px;
  font-weight: bold;
}

.verified-badge {
  background: #4caf50;
  color: white;
  padding: 4px 12px;
  border-radius: 20px;
  font-size: 12px;
}

.card-body h3 {
  margin: 0 0 8px 0;
  color: #2d3748;
}

.date {
  color: #718096;
  font-size: 14px;
}

.cert-number {
  font-family: monospace;
  color: #4a5568;
  font-size: 12px;
  margin-top: 8px;
}

.card-footer {
  display: flex;
  gap: 8px;
  margin-top: 16px;
}

.download-btn, .blockchain-btn {
  flex: 1;
  padding: 8px;
  border: none;
  border-radius: 6px;
  cursor: pointer;
  font-size: 14px;
  transition: opacity 0.2s;
}

.download-btn {
  background: #667eea;
  color: white;
}

.blockchain-btn {
  background: #f7fafc;
  color: #4a5568;
  border: 1px solid #e2e8f0;
}

.download-btn:hover, .blockchain-btn:hover {
  opacity: 0.8;
}

.empty-state {
  text-align: center;
  padding: 60px 20px;
  color: #718096;
}

.loading {
  text-align: center;
  padding: 40px;
  color: #718096;
}
</style>

// 보안 미들웨어 예시
class BlockchainSecurityMiddleware
{
    public function handle($request, Closure $next)
    {
        // Rate limiting 체크
        if ($this->isRateLimitExceeded($request)) {
            return response()->json(['error' => 'Too many requests'], 429);
        }
        
        // 지갑 주소 검증
        if ($request->has('wallet_address')) {
            if (!$this->isValidAddress($request->wallet_address)) {
                return response()->json(['error' => 'Invalid wallet address'], 400);
            }
        }
        
        // 트랜잭션 서명 검증 (필요시)
        if ($request->has('signature')) {
            if (!$this->verifySignature($request)) {
                return response()->json(['error' => 'Invalid signature'], 401);
            }
        }
        
        return $next($request);
    }
    
    protected function isValidAddress($address)
    {
        return preg_match('/^0x[a-fA-F0-9]{40}$/', $address);
    }
    
    protected function verifySignature($request)
    {
        // 서명 검증 로직
        // Web3를 사용해서 메시지와 서명을 검증
        return true;
    }
}

use Illuminate\Support\Facades\Cache;

class CertificateService
{
    public function getCertificateWithCache($tokenId)
    {
        $cacheKey = "certificate:{$tokenId}";
        
        return Cache::remember($cacheKey, 3600, function () use ($tokenId) {
            return $this->blockchainService->verifyCertificate($tokenId);
        });
    }
    
    public function invalidateCertificateCache($tokenId)
    {
        Cache::forget("certificate:{$tokenId}");
    }
}

Schema::table('certificates', function (Blueprint $table) {
    $table->index('token_id');
    $table->index('blockchain_tx_hash');
    $table->index('certificate_number');
});

Schema::table('users', function (Blueprint $table) {
    $table->index('wallet_address');
});

// Job에 재시도 로직 추가
class IssueCertificateJob implements ShouldQueue
{
    public $tries = 5;
    public $backoff = [60, 120, 300, 600, 1200]; // 지수 백오프
    
    public function handle()
    {
        // 트랜잭션 처리
    }
    
    public function failed(Exception $exception)
    {
        // 실패 알림 전송
        Log::error('Certificate issuance failed permanently', [
            'enrollment_id' => $this->enrollment->id,
            'error' => $exception->getMessage()
        ]);
        
        // 사용자에게 알림
        $this->enrollment->user->notify(
            new CertificateIssuanceFailedNotification($exception->getMessage())
        );
    }
}

// 스마트 컨트랙트에 배치 발급 함수 추가
function batchIssueCertificates(
    address[] memory students,
    uint256[] memory courseIds,
    string[] memory courseNames,
    string[] memory tokenURIs,
    uint256[] memory scores
) public onlyOwner returns (uint256[] memory) {
    require(students.length == courseIds.length, "Array length mismatch");
    
    uint256[] memory tokenIds = new uint256[](students.length);
    
    for (uint256 i = 0; i < students.length; i++) {
        tokenIds[i] = issueCertificate(
            students[i],
            courseIds[i],
            courseNames[i],
            tokenURIs[i],
            scores[i]
        );
    }
    
    return tokenIds;
}

<?php

namespace Tests\Unit;

use Tests\TestCase;
use App\Services\BlockchainService;
use Mockery;

class BlockchainServiceTest extends TestCase
{
    public function test_validates_ethereum_address()
    {
        $service = new BlockchainService();
        
        $this->assertTrue($service->isValidAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'));
        $this->assertFalse($service->isValidAddress('invalid_address'));
        $this->assertFalse($service->isValidAddress('0x123')); // 너무 짧음
    }
    
    public function test_generates_certificate_metadata()
    {
        $enrollment = Enrollment::factory()->create();
        $service = new CertificateService();
        
        $metadata = $service->generateMetadata($enrollment);
        
        $this->assertArrayHasKey('name', $metadata);
        $this->assertArrayHasKey('description', $metadata);
        $this->assertArrayHasKey('attributes', $metadata);
        $this->assertIsArray($metadata['attributes']);
    }
}

<?php

namespace Tests\Feature;

use Tests\TestCase;
use App\Models\User;
use App\Models\Course;
use App\Models\Enrollment;
use Illuminate\Foundation\Testing\RefreshDatabase;

class CertificateIssuanceTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_issues_certificate_when_course_completed()
    {
        $user = User::factory()->create([
            'wallet_address' => '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'
        ]);
        
        $course = Course::factory()->create();
        
        $enrollment = Enrollment::factory()->create([
            'user_id' => $user->id,
            'course_id' => $course->id,
            'progress_percentage' => 100,
            'completed_at' => now()
        ]);
        
        $response = $this->actingAs($user)
            ->postJson("/api/certificates/issue/{$enrollment->id}");
        
        $response->assertStatus(200)
            ->assertJson([
                'message' => 'Certificate issuance started'
            ]);
        
        // 큐 작업이 디스패치되었는지 확인
        $this->assertDatabaseHas('jobs', [
            'queue' => 'default'
        ]);
    }
    
    public function test_cannot_issue_certificate_for_incomplete_course()
    {
        $user = User::factory()->create();
        $enrollment = Enrollment::factory()->create([
            'user_id' => $user->id,
            'progress_percentage' => 50
        ]);
        
        $response = $this->actingAs($user)
            ->postJson("/api/certificates/issue/{$enrollment->id}");
        
        $response->assertStatus(400)
            ->assertJson([
                'error' => 'Course not completed'
            ]);
    }
}

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("LearningCertificate", function () {
    let certificate;
    let owner;
    let student;
    
    beforeEach(async function () {
        [owner, student] = await ethers.getSigners();
        
        const LearningCertificate = await ethers.getContractFactory("LearningCertificate");
        certificate = await LearningCertificate.deploy();
        await certificate.deployed();
    });
    
    it("Should issue a certificate", async function () {
        const tx = await certificate.issueCertificate(
            student.address,
            1,
            "Blockchain Development",
            "https://example.com/metadata/1.json",
            95
        );
        
        const receipt = await tx.wait();
        const event = receipt.events.find(e => e.event === "CertificateIssued");
        
        expect(event).to.not.be.undefined;
        expect(event.args.student).to.equal(student.address);
        expect(event.args.courseId).to.equal(1);
    });
    
    it("Should verify a certificate", async function () {
        await certificate.issueCertificate(
            student.address,
            1,
            "Blockchain Development",
            "https://example.com/metadata/1.json",
            95
        );
        
        const result = await certificate.verifyCertificate(0);
        
        expect(result.isValid).to.be.true;
        expect(result.student).to.equal(student.address);
        expect(result.courseId).to.equal(1);
        expect(result.score).to.equal(95);
    });
    
    it("Should get student certificates", async function () {
        await certificate.issueCertificate(
            student.address,
            1,
            "Course 1",
            "https://example.com/1.json",
            90
        );
        
        await certificate.issueCertificate(
            student.address,
            2,
            "Course 2",
            "https://example.com/2.json",
            85
        );
        
        const certs = await certificate.getStudentCertificates(student.address);
        expect(certs.length).to.equal(2);
    });
    
    it("Should revoke a certificate", async function () {
        await certificate.issueCertificate(
            student.address,
            1,
            "Course 1",
            "https://example.com/1.json",
            90
        );
        
        await certificate.revokeCertificate(0);
        
        const result = await certificate.verifyCertificate(0);
        expect(result.isValid).to.be.false;
    });
    
    it("Should not allow non-owner to issue certificates", async function () {
        await expect(
            certificate.connect(student).issueCertificate(
                student.address,
                1,
                "Course 1",
                "https://example.com/1.json",
                90
            )
        ).to.be.revertedWith("Ownable: caller is not the owner");
    });
});

// hardhat.config.js 설정
require("@nomiclabs/hardhat-ethers");
require("@nomiclabs/hardhat-etherscan");
require("dotenv").config();

module.exports = {
  solidity: "0.8.20",
  networks: {
    goerli: {
      url: process.env.GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    },
    mainnet: {
      url: process.env.MAINNET_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    },
    polygon: {
      url: process.env.POLYGON_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

// 배포 명령어
// 테스트넷: npx hardhat run scripts/deploy.js --network goerli
// 메인넷: npx hardhat run scripts/deploy.js --network mainnet
// Polygon: npx hardhat run scripts/deploy.js --network polygon

# 프로덕션 환경 설정
APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-domain.com

# 데이터베이스
DB_CONNECTION=mysql
DB_HOST=your-db-host
DB_DATABASE=production_db
DB_USERNAME=db_user
DB_PASSWORD=secure_password

# 블록체인 설정
BLOCKCHAIN_RPC_URL=https://mainnet.infura.io/v3/YOUR_PROJECT_ID
CONTRACT_ADDRESS=0x... # 배포된 컨트랙트 주소
FROM_ADDRESS=0x... # 서버 지갑 주소
PRIVATE_KEY=0x... # 절대 노출되면 안 됨!

# 큐 설정
QUEUE_CONNECTION=redis
REDIS_HOST=your-redis-host

# 캐시 설정
CACHE_DRIVER=redis

# 세션 설정
SESSION_DRIVER=redis

# 배포 스크립트 (deploy.sh)
#!/bin/bash

echo "Starting deployment..."

# Git pull
git pull origin main

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

# NPM 빌드
npm install
npm run production

# 캐시 클리어
php artisan config:clear
php artisan cache:clear
php artisan view:clear

# 캐시 생성
php artisan config:cache
php artisan route:cache
php artisan view:cache

# 마이그레이션 실행
php artisan migrate --force

# 큐 워커 재시작
php artisan queue:restart

# 권한 설정
chmod -R 755 storage bootstrap/cache

echo "Deployment completed!"

# Laravel Telescope 설치 (개발/스테이징 환경)
composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

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

# Sentry 설치 (에러 추적)
composer require sentry/sentry-laravel
php artisan sentry:publish --dsn=YOUR_DSN

// 토큰 이코노미 예시 - ERC-20 토큰 컨트랙트
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract LearningToken is ERC20, Ownable {
    // 강의 완료 시 보상 토큰 양
    mapping(uint256 => uint256) public courseRewards;
    
    // 사용자별 획득 토큰 이력
    mapping(address => uint256[]) public userRewardHistory;
    
    constructor() ERC20("Learning Token", "LEARN") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
    
    function setCourseReward(uint256 courseId, uint256 reward) public onlyOwner {
        courseRewards[courseId] = reward;
    }
    
    function rewardStudent(address student, uint256 courseId) public onlyOwner {
        uint256 reward = courseRewards[courseId];
        require(reward > 0, "No reward set for this course");
        
        _mint(student, reward);
        userRewardHistory[student].push(courseId);
        
        emit StudentRewarded(student, courseId, reward);
    }
    
    event StudentRewarded(address indexed student, uint256 indexed courseId, uint256 amount);
}