Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->string('wallet_address')->nullable()->unique();
    $table->enum('user_type', ['donor', 'beneficiary', 'admin']);
    $table->boolean('is_verified')->default(false);
    $table->timestamp('email_verified_at')->nullable();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
    $table->softDeletes();
});

Schema::create('campaigns', function (Blueprint $table) {
    $table->id();
    $table->foreignId('beneficiary_id')->constrained('users');
    $table->string('title');
    $table->text('description');
    $table->decimal('goal_amount', 20, 2);
    $table->decimal('current_amount', 20, 2)->default(0);
    $table->string('smart_contract_address')->nullable();
    $table->timestamp('start_date');
    $table->timestamp('end_date');
    $table->enum('status', ['draft', 'active', 'completed', 'cancelled']);
    $table->json('metadata')->nullable();
    $table->timestamps();
    $table->softDeletes();
    
    $table->index(['status', 'start_date', 'end_date']);
});

Schema::create('donations', function (Blueprint $table) {
    $table->id();
    $table->foreignId('campaign_id')->constrained();
    $table->foreignId('donor_id')->constrained('users');
    $table->decimal('amount', 20, 2);
    $table->string('currency', 10)->default('KRW');
    $table->string('transaction_hash')->unique();
    $table->string('block_number')->nullable();
    $table->timestamp('blockchain_confirmed_at')->nullable();
    $table->enum('status', ['pending', 'confirmed', 'failed']);
    $table->text('message')->nullable();
    $table->boolean('is_anonymous')->default(false);
    $table->timestamps();
    
    $table->index(['campaign_id', 'status']);
    $table->index('transaction_hash');
});

Schema::create('expenditures', function (Blueprint $table) {
    $table->id();
    $table->foreignId('campaign_id')->constrained();
    $table->decimal('amount', 20, 2);
    $table->string('category'); // 예: 의료비, 교육비, 생활비
    $table->text('description');
    $table->string('receipt_url')->nullable();
    $table->string('transaction_hash')->unique();
    $table->string('block_number')->nullable();
    $table->timestamp('executed_at');
    $table->timestamp('blockchain_confirmed_at')->nullable();
    $table->enum('status', ['pending', 'confirmed', 'rejected']);
    $table->foreignId('approved_by')->nullable()->constrained('users');
    $table->timestamps();
    
    $table->index(['campaign_id', 'status']);
});

Schema::create('blockchain_logs', function (Blueprint $table) {
    $table->id();
    $table->string('transaction_hash')->unique();
    $table->string('block_number')->nullable();
    $table->string('from_address');
    $table->string('to_address');
    $table->string('contract_address')->nullable();
    $table->string('event_type'); // donation, expenditure, contract_deploy
    $table->json('event_data');
    $table->decimal('gas_used', 20, 0)->nullable();
    $table->decimal('gas_price', 30, 0)->nullable();
    $table->timestamp('blockchain_timestamp');
    $table->timestamps();
    
    $table->index('transaction_hash');
    $table->index(['event_type', 'created_at']);
});

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

contract DonationCampaign {
    address public beneficiary;
    address public platformAdmin;
    uint256 public goalAmount;
    uint256 public currentAmount;
    uint256 public deadline;
    bool public isActive;
    bool public goalReached;
    
    uint256 public constant PLATFORM_FEE_PERCENT = 2; // 2% 플랫폼 수수료
    
    struct Donation {
        address donor;
        uint256 amount;
        uint256 timestamp;
        string message;
    }
    
    struct Expenditure {
        uint256 amount;
        string category;
        string description;
        uint256 timestamp;
        bool executed;
    }
    
    Donation[] public donations;
    Expenditure[] public expenditures;
    
    mapping(address => uint256) public donorContributions;
    
    event DonationReceived(
        address indexed donor,
        uint256 amount,
        uint256 timestamp,
        string message
    );
    
    event ExpenditureExecuted(
        uint256 indexed expenditureId,
        uint256 amount,
        string category,
        uint256 timestamp
    );
    
    event GoalReached(uint256 totalAmount, uint256 timestamp);
    
    event RefundIssued(address indexed donor, uint256 amount);
    
    modifier onlyBeneficiary() {
        require(msg.sender == beneficiary, "Only beneficiary can call this");
        _;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == platformAdmin, "Only admin can call this");
        _;
    }
    
    modifier campaignActive() {
        require(isActive, "Campaign is not active");
        require(block.timestamp < deadline, "Campaign has ended");
        _;
    }
    
    constructor(
        address _beneficiary,
        address _platformAdmin,
        uint256 _goalAmount,
        uint256 _durationInDays
    ) {
        require(_beneficiary != address(0), "Invalid beneficiary address");
        require(_goalAmount > 0, "Goal amount must be positive");
        
        beneficiary = _beneficiary;
        platformAdmin = _platformAdmin;
        goalAmount = _goalAmount;
        deadline = block.timestamp + (_durationInDays * 1 days);
        isActive = true;
        goalReached = false;
    }
    
    function donate(string memory _message) public payable campaignActive {
        require(msg.value > 0, "Donation amount must be positive");
        
        donations.push(Donation({
            donor: msg.sender,
            amount: msg.value,
            timestamp: block.timestamp,
            message: _message
        }));
        
        donorContributions[msg.sender] += msg.value;
        currentAmount += msg.value;
        
        emit DonationReceived(msg.sender, msg.value, block.timestamp, _message);
        
        if (currentAmount >= goalAmount && !goalReached) {
            goalReached = true;
            emit GoalReached(currentAmount, block.timestamp);
        }
    }
    
    function executeExpenditure(
        uint256 _amount,
        string memory _category,
        string memory _description
    ) public onlyBeneficiary {
        require(_amount > 0, "Amount must be positive");
        require(_amount <= currentAmount, "Insufficient funds");
        require(goalReached, "Goal not reached yet");
        
        uint256 platformFee = (_amount * PLATFORM_FEE_PERCENT) / 100;
        uint256 netAmount = _amount - platformFee;
        
        expenditures.push(Expenditure({
            amount: _amount,
            category: _category,
            description: _description,
            timestamp: block.timestamp,
            executed: true
        }));
        
        currentAmount -= _amount;
        
        // 수혜자에게 송금
        payable(beneficiary).transfer(netAmount);
        
        // 플랫폼 수수료 송금
        payable(platformAdmin).transfer(platformFee);
        
        emit ExpenditureExecuted(
            expenditures.length - 1,
            _amount,
            _category,
            block.timestamp
        );
    }
    
    function refund() public {
        require(!goalReached, "Goal was reached, no refunds");
        require(block.timestamp >= deadline, "Campaign still active");
        
        uint256 contribution = donorContributions[msg.sender];
        require(contribution > 0, "No contribution found");
        
        donorContributions[msg.sender] = 0;
        currentAmount -= contribution;
        
        payable(msg.sender).transfer(contribution);
        
        emit RefundIssued(msg.sender, contribution);
    }
    
    function getDonationsCount() public view returns (uint256) {
        return donations.length;
    }
    
    function getExpendituresCount() public view returns (uint256) {
        return expenditures.length;
    }
    
    function getDonation(uint256 _index) public view returns (
        address donor,
        uint256 amount,
        uint256 timestamp,
        string memory message
    ) {
        require(_index < donations.length, "Invalid index");
        Donation memory d = donations[_index];
        return (d.donor, d.amount, d.timestamp, d.message);
    }
    
    function getExpenditure(uint256 _index) public view returns (
        uint256 amount,
        string memory category,
        string memory description,
        uint256 timestamp,
        bool executed
    ) {
        require(_index < expenditures.length, "Invalid index");
        Expenditure memory e = expenditures[_index];
        return (e.amount, e.category, e.description, e.timestamp, e.executed);
    }
    
    function closeCampaign() public onlyAdmin {
        isActive = false;
    }
}

composer require sc0vu/web3.php
composer require kornrunner/keccak

# Blockchain Configuration
BLOCKCHAIN_NETWORK=sepolia
BLOCKCHAIN_RPC_URL=https://sepolia.infura.io/v3/YOUR_INFURA_PROJECT_ID
BLOCKCHAIN_CHAIN_ID=11155111

# Platform Wallet
PLATFORM_WALLET_ADDRESS=0xYourPlatformWalletAddress
PLATFORM_WALLET_PRIVATE_KEY=YourPrivateKey

# Smart Contract
DONATION_CONTRACT_ADDRESS=0xYourDeployedContractAddress

# Gas Settings
GAS_LIMIT=300000
GAS_PRICE=20000000000

<?php

namespace App\Services;

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

class BlockchainService
{
    protected $web3;
    protected $contract;
    protected $contractAddress;
    protected $platformWalletAddress;
    protected $platformPrivateKey;
    
    public function __construct()
    {
        $this->web3 = new Web3(config('blockchain.rpc_url'));
        $this->contractAddress = config('blockchain.contract_address');
        $this->platformWalletAddress = config('blockchain.platform_wallet');
        $this->platformPrivateKey = config('blockchain.platform_private_key');
        
        // ABI 로드 (Application Binary Interface)
        $abi = json_decode(file_get_contents(storage_path('contracts/DonationCampaign.json')), true);
        
        $this->contract = new Contract($this->web3->provider, $abi);
    }
    
    /**
     * 새로운 기부 캠페인 컨트랙트 배포
     */
    public function deployCampaign(
        string $beneficiaryAddress,
        float $goalAmount,
        int $durationInDays
    ): array {
        try {
            $goalAmountWei = Utils::toWei((string)$goalAmount, 'ether');
            
            // 컨트랙트 배포 트랜잭션 생성
            $bytecode = file_get_contents(storage_path('contracts/DonationCampaign.bin'));
            
            $transaction = [
                'from' => $this->platformWalletAddress,
                'data' => $bytecode . $this->encodeConstructorParams(
                    $beneficiaryAddress,
                    $this->platformWalletAddress,
                    $goalAmountWei,
                    $durationInDays
                ),
                'gas' => Utils::toHex(config('blockchain.gas_limit'), true),
                'gasPrice' => Utils::toHex(config('blockchain.gas_price'), true),
            ];
            
            // 트랜잭션 서명 및 전송
            $signedTx = $this->signTransaction($transaction);
            $txHash = $this->sendRawTransaction($signedTx);
            
            // 트랜잭션 영수증 대기
            $receipt = $this->waitForTransactionReceipt($txHash);
            
            return [
                'success' => true,
                'contract_address' => $receipt['contractAddress'],
                'transaction_hash' => $txHash,
                'block_number' => hexdec($receipt['blockNumber']),
            ];
            
        } catch (\Exception $e) {
            Log::error('Contract deployment failed: ' . $e->getMessage());
            return [
                'success' => false,
                'error' => $e->getMessage(),
            ];
        }
    }
    
    /**
     * 기부 트랜잭션 생성
     */
    public function processDonation(
        string $contractAddress,
        string $donorAddress,
        float $amount,
        string $message
    ): array {
        try {
            $amountWei = Utils::toWei((string)$amount, 'ether');
            
            // donate 함수 호출 데이터 인코딩
            $functionData = $this->contract->at($contractAddress)
                ->getData('donate', $message);
            
            $transaction = [
                'from' => $donorAddress,
                'to' => $contractAddress,
                'value' => Utils::toHex($amountWei, true),
                'data' => $functionData,
                'gas' => Utils::toHex(config('blockchain.gas_limit'), true),
                'gasPrice' => Utils::toHex(config('blockchain.gas_price'), true),
            ];
            
            return [
                'success' => true,
                'transaction' => $transaction,
            ];
            
        } catch (\Exception $e) {
            Log::error('Donation processing failed: ' . $e->getMessage());
            return [
                'success' => false,
                'error' => $e->getMessage(),
            ];
        }
    }
    
    /**
     * 기부금 집행
     */
    public function executeExpenditure(
        string $contractAddress,
        float $amount,
        string $category,
        string $description
    ): array {
        try {
            $amountWei = Utils::toWei((string)$amount, 'ether');
            
            $functionData = $this->contract->at($contractAddress)
                ->getData('executeExpenditure', $amountWei, $category, $description);
            
            $transaction = [
                'from' => $this->platformWalletAddress,
                'to' => $contractAddress,
                'data' => $functionData,
                'gas' => Utils::toHex(config('blockchain.gas_limit'), true),
                'gasPrice' => Utils::toHex(config('blockchain.gas_price'), true),
            ];
            
            $signedTx = $this->signTransaction($transaction);
            $txHash = $this->sendRawTransaction($signedTx);
            
            $receipt = $this->waitForTransactionReceipt($txHash);
            
            return [
                'success' => true,
                'transaction_hash' => $txHash,
                'block_number' => hexdec($receipt['blockNumber']),
                'gas_used' => hexdec($receipt['gasUsed']),
            ];
            
        } catch (\Exception $e) {
            Log::error('Expenditure execution failed: ' . $e->getMessage());
            return [
                'success' => false,
                'error' => $e->getMessage(),
            ];
        }
    }
    
    /**
     * 캠페인 정보 조회
     */
    public function getCampaignInfo(string $contractAddress): array
    {
        try {
            $contract = $this->contract->at($contractAddress);
            
            $info = [];
            
            // 각 상태 변수 읽기
            $contract->call('beneficiary', function ($err, $result) use (&$info) {
                if (!$err) $info['beneficiary'] = $result[0];
            });
            
            $contract->call('goalAmount', function ($err, $result) use (&$info) {
                if (!$err) $info['goal_amount'] = Utils::fromWei($result[0], 'ether');
            });
            
            $contract->call('currentAmount', function ($err, $result) use (&$info) {
                if (!$err) $info['current_amount'] = Utils::fromWei($result[0], 'ether');
            });
            
            $contract->call('goalReached', function ($err, $result) use (&$info) {
                if (!$err) $info['goal_reached'] = $result[0];
            });
            
            $contract->call('getDonationsCount', function ($err, $result) use (&$info) {
                if (!$err) $info['donations_count'] = hexdec($result[0]);
            });
            
            return [
                'success' => true,
                'data' => $info,
            ];
            
        } catch (\Exception $e) {
            Log::error('Failed to get campaign info: ' . $e->getMessage());
            return [
                'success' => false,
                'error' => $e->getMessage(),
            ];
        }
    }
    
    /**
     * 이벤트 로그 조회
     */
    public function getEventLogs(
        string $contractAddress,
        string $eventName,
        int $fromBlock = 0,
        int $toBlock = null
    ): array {
        try {
            $toBlock = $toBlock ?? 'latest';
            
            $filter = [
                'fromBlock' => Utils::toHex($fromBlock, true),
                'toBlock' => $toBlock === 'latest' ? 'latest' : Utils::toHex($toBlock, true),
                'address' => $contractAddress,
            ];
            
            $logs = [];
            
            $this->web3->eth->getLogs($filter, function ($err, $result) use (&$logs) {
                if (!$err) {
                    $logs = $result;
                }
            });
            
            return [
                'success' => true,
                'logs' => $logs,
            ];
            
        } catch (\Exception $e) {
            Log::error('Failed to get event logs: ' . $e->getMessage());
            return [
                'success' => false,
                'error' => $e->getMessage(),
            ];
        }
    }
    
    /**
     * 트랜잭션 서명
     */
    protected function signTransaction(array $transaction): string
    {
        // 실제 구현에서는 eth-php 라이브러리 사용
        // 여기서는 간략화
        return '0xSignedTransactionData';
    }
    
    /**
     * Raw 트랜잭션 전송
     */
    protected function sendRawTransaction(string $signedTx): string
    {
        $txHash = '';
        
        $this->web3->eth->sendRawTransaction($signedTx, function ($err, $result) use (&$txHash) {
            if (!$err) {
                $txHash = $result;
            }
        });
        
        return $txHash;
    }
    
    /**
     * 트랜잭션 영수증 대기
     */
    protected function waitForTransactionReceipt(string $txHash, int $maxAttempts = 30): array
    {
        $attempts = 0;
        $receipt = null;
        
        while ($attempts < $maxAttempts) {
            $this->web3->eth->getTransactionReceipt($txHash, function ($err, $result) use (&$receipt) {
                if (!$err && $result) {
                    $receipt = $result;
                }
            });
            
            if ($receipt) {
                return $receipt;
            }
            
            sleep(2);
            $attempts++;
        }
        
        throw new \Exception('Transaction receipt not found after ' . $maxAttempts . ' attempts');
    }
    
    /**
     * 생성자 파라미터 인코딩
     */
    protected function encodeConstructorParams(...$params): string
    {
        // ABI 인코딩 로직
        // 실제로는 더 복잡한 구현 필요
        return '';
    }
}

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Campaign;
use App\Models\User;
use App\Services\BlockchainService;
use App\Jobs\DeployCampaignContract;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\DB;

class CampaignController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    /**
     * 캠페인 목록 조회
     */
    public function index(Request $request)
    {
        $query = Campaign::with(['beneficiary', 'donations'])
            ->where('status', 'active');
        
        // 필터링
        if ($request->has('category')) {
            $query->where('category', $request->category);
        }
        
        if ($request->has('search')) {
            $query->where(function($q) use ($request) {
                $q->where('title', 'like', '%' . $request->search . '%')
                  ->orWhere('description', 'like', '%' . $request->search . '%');
            });
        }
        
        // 정렬
        $sortBy = $request->get('sort_by', 'created_at');
        $sortOrder = $request->get('sort_order', 'desc');
        $query->orderBy($sortBy, $sortOrder);
        
        // 페이지네이션
        $campaigns = $query->paginate(12);
        
        // 각 캠페인의 블록체인 정보 추가
        $campaigns->getCollection()->transform(function ($campaign) {
            if ($campaign->smart_contract_address) {
                $blockchainInfo = $this->blockchainService
                    ->getCampaignInfo($campaign->smart_contract_address);
                
                if ($blockchainInfo['success']) {
                    $campaign->blockchain_data = $blockchainInfo['data'];
                }
            }
            return $campaign;
        });
        
        return response()->json([
            'success' => true,
            'data' => $campaigns,
        ]);
    }
    
    /**
     * 캠페인 상세 조회
     */
    public function show($id)
    {
        $campaign = Campaign::with([
            'beneficiary',
            'donations.donor',
            'expenditures'
        ])->findOrFail($id);
        
        // 블록체인 데이터 조회
        if ($campaign->smart_contract_address) {
            $blockchainInfo = $this->blockchainService
                ->getCampaignInfo($campaign->smart_contract_address);
            
            if ($blockchainInfo['success']) {
                $campaign->blockchain_data = $blockchainInfo['data'];
            }
            
            // 최근 이벤트 로그 조회
            $logs = $this->blockchainService->getEventLogs(
                $campaign->smart_contract_address,
                'DonationReceived',
                $campaign->blockchain_start_block ?? 0
            );
            
            if ($logs['success']) {
                $campaign->recent_blockchain_events = $logs['logs'];
            }
        }
        
        return response()->json([
            'success' => true,
            'data' => $campaign,
        ]);
    }
    
    /**
     * 새 캠페인 생성
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|string|max:255',
            'description' => 'required|string',
            'goal_amount' => 'required|numeric|min:0',
            'duration_days' => 'required|integer|min:1|max:365',
            'category' => 'required|string',
            'beneficiary_wallet' => 'required|string|regex:/^0x[a-fA-F0-9]{40}$/',
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors(),
            ], 422);
        }
        
        DB::beginTransaction();
        
        try {
            // 수혜자 확인 또는 생성
            $beneficiary = User::where('wallet_address', $request->beneficiary_wallet)
                ->first();
            
            if (!$beneficiary) {
                return response()->json([
                    'success' => false,
                    'message' => 'Beneficiary wallet not registered',
                ], 404);
            }
            
            // 캠페인 생성
            $campaign = Campaign::create([
                'beneficiary_id' => $beneficiary->id,
                'title' => $request->title,
                'description' => $request->description,
                'goal_amount' => $request->goal_amount,
                'start_date' => now(),
                'end_date' => now()->addDays($request->duration_days),
                'status' => 'draft',
                'category' => $request->category,
                'metadata' => $request->metadata ?? [],
            ]);
            
            // 스마트 컨트랙트 배포 작업 큐에 추가
            DeployCampaignContract::dispatch($campaign);
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Campaign created successfully. Smart contract deployment in progress.',
                'data' => $campaign,
            ], 201);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to create campaign',
                'error' => $e->getMessage(),
            ], 500);
        }
    }
    
    /**
     * 캠페인 수정
     */
    public function update(Request $request, $id)
    {
        $campaign = Campaign::findOrFail($id);
        
        // 권한 체크
        if ($campaign->beneficiary_id !== auth()->id() && !auth()->user()->isAdmin()) {
            return response()->json([
                'success' => false,
                'message' => 'Unauthorized',
            ], 403);
        }
        
        // 활성화된 캠페인은 일부 필드만 수정 가능
        if ($campaign->status === 'active') {
            $allowedFields = ['description', 'metadata'];
            $updateData = $request->only($allowedFields);
        } else {
            $updateData = $request->all();
        }
        
        $campaign->update($updateData);
        
        return response()->json([
            'success' => true,
            'message' => 'Campaign updated successfully',
            'data' => $campaign,
        ]);
    }
    
    /**
     * 캠페인 활성화
     */
    public function activate($id)
    {
        $campaign = Campaign::findOrFail($id);
        
        if (!$campaign->smart_contract_address) {
            return response()->json([
                'success' => false,
                'message' => 'Smart contract not deployed yet',
            ], 400);
        }
        
        $campaign->update(['status' => 'active']);
        
        return response()->json([
            'success' => true,
            'message' => 'Campaign activated successfully',
            'data' => $campaign,
        ]);
    }
    
    /**
     * 캠페인 통계
     */
    public function statistics($id)
    {
        $campaign = Campaign::with(['donations', 'expenditures'])->findOrFail($id);
        
        $stats = [
            'total_donations' => $campaign->donations->count(),
            'total_amount' => $campaign->donations->sum('amount'),
            'unique_donors' => $campaign->donations->unique('donor_id')->count(),
            'total_expenditures' => $campaign->expenditures->count(),
            'total_spent' => $campaign->expenditures->sum('amount'),
            'remaining_amount' => $campaign->current_amount,
            'goal_percentage' => ($campaign->current_amount / $campaign->goal_amount) * 100,
            'days_remaining' => now()->diffInDays($campaign->end_date, false),
            'average_donation' => $campaign->donations->avg('amount'),
        ];
        
        // 일별 기부 추이
        $dailyDonations = $campaign->donations()
            ->selectRaw('DATE(created_at) as date, COUNT(*) as count, SUM(amount) as total')
            ->groupBy('date')
            ->orderBy('date')
            ->get();
        
        $stats['daily_trend'] = $dailyDonations;
        
        // 카테고리별 집행 내역
        $expendituresByCategory = $campaign->expenditures()
            ->selectRaw('category, COUNT(*) as count, SUM(amount) as total')
            ->groupBy('category')
            ->get();
        
        $stats['expenditures_by_category'] = $expendituresByCategory;
        
        return response()->json([
            'success' => true,
            'data' => $stats,
        ]);
    }
}

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Campaign;
use App\Models\Donation;
use App\Services\BlockchainService;
use App\Jobs\ProcessDonationTransaction;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\DB;

class DonationController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    /**
     * 기부하기
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'campaign_id' => 'required|exists:campaigns,id',
            'amount' => 'required|numeric|min:0.001',
            'message' => 'nullable|string|max:500',
            'is_anonymous' => 'boolean',
            'donor_wallet' => 'required|string|regex:/^0x[a-fA-F0-9]{40}$/',
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors(),
            ], 422);
        }
        
        $campaign = Campaign::findOrFail($request->campaign_id);
        
        // 캠페인 상태 확인
        if ($campaign->status !== 'active') {
            return response()->json([
                'success' => false,
                'message' => 'Campaign is not active',
            ], 400);
        }
        
        if (now()->gt($campaign->end_date)) {
            return response()->json([
                'success' => false,
                'message' => 'Campaign has ended',
            ], 400);
        }
        
        DB::beginTransaction();
        
        try {
            // 기부자 확인
            $donor = auth()->user();
            
            // 기부 레코드 생성
            $donation = Donation::create([
                'campaign_id' => $campaign->id,
                'donor_id' => $donor->id,
                'amount' => $request->amount,
                'currency' => 'ETH',
                'message' => $request->message,
                'is_anonymous' => $request->is_anonymous ?? false,
                'status' => 'pending',
            ]);
            
            // 블록체인 트랜잭션 준비
            $txData = $this->blockchainService->processDonation(
                $campaign->smart_contract_address,
                $request->donor_wallet,
                $request->amount,
                $request->message ?? ''
            );
            
            if (!$txData['success']) {
                throw new \Exception('Failed to prepare blockchain transaction');
            }
            
            // 트랜잭션 처리 작업 큐에 추가
            ProcessDonationTransaction::dispatch($donation, $txData['transaction']);
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Donation initiated. Please confirm the transaction in your wallet.',
                'data' => [
                    'donation' => $donation,
                    'transaction' => $txData['transaction'],
                ],
            ], 201);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to process donation',
                'error' => $e->getMessage(),
            ], 500);
        }
    }
    
    /**
     * 기부 내역 조회
     */
    public function index(Request $request)
    {
        $query = Donation::with(['campaign', 'donor']);
        
        // 필터링
        if ($request->has('campaign_id')) {
            $query->where('campaign_id', $request->campaign_id);
        }
        
        if ($request->has('donor_id')) {
            $query->where('donor_id', $request->donor_id);
        }
        
        if ($request->has('status')) {
            $query->where('status', $request->status);
        }
        
        // 익명 기부는 기부자 정보 숨김
        $donations = $query->latest()->paginate(20);
        
        $donations->getCollection()->transform(function ($donation) {
            if ($donation->is_anonymous && auth()->id() !== $donation->donor_id) {
                $donation->donor = null;
                $donation->donor_id = null;
            }
            return $donation;
        });
        
        return response()->json([
            'success' => true,
            'data' => $donations,
        ]);
    }
    
    /**
     * 기부 상세 조회
     */
    public function show($id)
    {
        $donation = Donation::with(['campaign', 'donor'])->findOrFail($id);
        
        // 익명 기부 처리
        if ($donation->is_anonymous && auth()->id() !== $donation->donor_id) {
            $donation->donor = null;
        }
        
        // 블록체인 트랜잭션 정보 조회
        if ($donation->transaction_hash) {
            // 실제로는 블록체인에서 트랜잭션 정보를 가져와야 함
            $donation->blockchain_confirmation = [
                'confirmed' => $donation->status === 'confirmed',
                'block_number' => $donation->block_number,
                'confirmations' => 12, // 예시
            ];
        }
        
        return response()->json([
            'success' => true,
            'data' => $donation,
        ]);
    }
    
    /**
     * 트랜잭션 상태 업데이트 (웹훅용)
     */
    public function updateTransactionStatus(Request $request, $id)
    {
        $donation = Donation::findOrFail($id);
        
        $validator = Validator::make($request->all(), [
            'transaction_hash' => 'required|string',
            'block_number' => 'nullable|string',
            'status' => 'required|in:confirmed,failed',
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors(),
            ], 422);
        }
        
        DB::beginTransaction();
        
        try {
            $donation->update([
                'transaction_hash' => $request->transaction_hash,
                'block_number' => $request->block_number,
                'status' => $request->status,
                'blockchain_confirmed_at' => $request->status === 'confirmed' ? now() : null,
            ]);
            
            // 캠페인 현재 금액 업데이트
            if ($request->status === 'confirmed') {
                $campaign = $donation->campaign;
                $campaign->increment('current_amount', $donation->amount);
            }
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Transaction status updated',
                'data' => $donation,
            ]);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to update transaction status',
                'error' => $e->getMessage(),
            ], 500);
        }
    }
}

<?php

namespace App\Jobs;

use App\Models\Campaign;
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;

class DeployCampaignContract implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public $campaign;
    public $tries = 3;
    public $timeout = 300;
    
    public function __construct(Campaign $campaign)
    {
        $this->campaign = $campaign;
    }
    
    public function handle(BlockchainService $blockchainService)
    {
        Log::info('Deploying smart contract for campaign: ' . $this->campaign->id);
        
        try {
            $beneficiary = $this->campaign->beneficiary;
            
            $result = $blockchainService->deployCampaign(
                $beneficiary->wallet_address,
                $this->campaign->goal_amount,
                now()->diffInDays($this->campaign->end_date)
            );
            
            if ($result['success']) {
                $this->campaign->update([
                    'smart_contract_address' => $result['contract_address'],
                    'deployment_transaction_hash' => $result['transaction_hash'],
                    'blockchain_start_block' => $result['block_number'],
                    'status' => 'active',
                ]);
                
                Log::info('Smart contract deployed successfully', [
                    'campaign_id' => $this->campaign->id,
                    'contract_address' => $result['contract_address'],
                ]);
                
                // 배포 성공 알림 발송
                // event(new CampaignContractDeployed($this->campaign));
                
            } else {
                throw new \Exception($result['error']);
            }
            
        } catch (\Exception $e) {
            Log::error('Failed to deploy smart contract', [
                'campaign_id' => $this->campaign->id,
                'error' => $e->getMessage(),
            ]);
            
            $this->campaign->update([
                'status' => 'failed',
                'metadata' => array_merge($this->campaign->metadata ?? [], [
                    'deployment_error' => $e->getMessage(),
                ]),
            ]);
            
            throw $e;
        }
    }
    
    public function failed(\Throwable $exception)
    {
        Log::error('Campaign contract deployment job failed permanently', [
            'campaign_id' => $this->campaign->id,
            'error' => $exception->getMessage(),
        ]);
        
        // 관리자에게 알림
        // event(new CampaignDeploymentFailed($this->campaign, $exception));
    }
}

<?php

namespace App\Jobs;

use App\Models\Donation;
use App\Models\BlockchainLog;
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;

class ProcessDonationTransaction implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public $donation;
    public $transactionData;
    public $tries = 3;
    public $timeout = 300;
    
    public function __construct(Donation $donation, array $transactionData)
    {
        $this->donation = $donation;
        $this->transactionData = $transactionData;
    }
    
    public function handle(BlockchainService $blockchainService)
    {
        Log::info('Processing donation transaction', [
            'donation_id' => $this->donation->id,
        ]);
        
        try {
            // 실제로는 사용자가 메타마스크 등에서 트랜잭션을 승인해야 함
            // 여기서는 트랜잭션 해시를 받았다고 가정
            
            // 트랜잭션 모니터링 시작
            $this->monitorTransaction($blockchainService);
            
        } catch (\Exception $e) {
            Log::error('Failed to process donation transaction', [
                'donation_id' => $this->donation->id,
                'error' => $e->getMessage(),
            ]);
            
            $this->donation->update(['status' => 'failed']);
            
            throw $e;
        }
    }
    
    protected function monitorTransaction(BlockchainService $blockchainService)
    {
        // 트랜잭션 해시로 상태 확인
        $maxAttempts = 30;
        $attempts = 0;
        
        while ($attempts < $maxAttempts) {
            $receipt = $blockchainService->getTransactionReceipt(
                $this->donation->transaction_hash
            );
            
            if ($receipt) {
                $this->handleTransactionConfirmed($receipt);
                return;
            }
            
            sleep(5);
            $attempts++;
        }
        
        throw new \Exception('Transaction not confirmed within timeout period');
    }
    
    protected function handleTransactionConfirmed(array $receipt)
    {
        $this->donation->update([
            'block_number' => hexdec($receipt['blockNumber']),
            'status' => 'confirmed',
            'blockchain_confirmed_at' => now(),
        ]);
        
        // 블록체인 로그 저장
        BlockchainLog::create([
            'transaction_hash' => $this->donation->transaction_hash,
            'block_number' => hexdec($receipt['blockNumber']),
            'from_address' => $receipt['from'],
            'to_address' => $receipt['to'],
            'contract_address' => $receipt['contractAddress'] ?? null,
            'event_type' => 'donation',
            'event_data' => [
                'donation_id' => $this->donation->id,
                'amount' => $this->donation->amount,
                'campaign_id' => $this->donation->campaign_id,
            ],
            'gas_used' => hexdec($receipt['gasUsed']),
            'blockchain_timestamp' => now(),
        ]);
        
        // 캠페인 금액 업데이트
        $this->donation->campaign->increment('current_amount', $this->donation->amount);
        
        Log::info('Donation transaction confirmed', [
            'donation_id' => $this->donation->id,
            'transaction_hash' => $this->donation->transaction_hash,
        ]);
        
        // 기부 완료 알림
        // event(new DonationConfirmed($this->donation));
    }
}

<template>
  <div class="transparency-dashboard">
    <div class="dashboard-header">
      <h2>💎 투명성 대시보드</h2>
      <p>모든 거래 내역이 블록체인에 영구적으로 기록됩니다</p>
    </div>
    
    <!-- 실시간 통계 -->
    <div class="stats-grid">
      <div class="stat-card">
        <div class="stat-icon">💰</div>
        <div class="stat-value">{{ formatCurrency(campaign.current_amount) }}</div>
        <div class="stat-label">총 기부금</div>
        <div class="stat-blockchain">
          <span class="blockchain-badge">블록체인 검증됨</span>
        </div>
      </div>
      
      <div class="stat-card">
        <div class="stat-icon">👥</div>
        <div class="stat-value">{{ campaign.donors_count }}</div>
        <div class="stat-label">기부자 수</div>
      </div>
      
      <div class="stat-card">
        <div class="stat-icon">📤</div>
        <div class="stat-value">{{ formatCurrency(campaign.total_spent) }}</div>
        <div class="stat-label">집행 금액</div>
        <div class="stat-blockchain">
          <span class="blockchain-badge">블록체인 검증됨</span>
        </div>
      </div>
      
      <div class="stat-card">
        <div class="stat-icon">💵</div>
        <div class="stat-value">{{ formatCurrency(campaign.remaining_amount) }}</div>
        <div class="stat-label">잔여 금액</div>
      </div>
    </div>
    
    <!-- 진행률 -->
    <div class="progress-section">
      <div class="progress-header">
        <span>목표 달성률</span>
        <span class="progress-percentage">{{ goalPercentage }}%</span>
      </div>
      <div class="progress-bar">
        <div class="progress-fill" :style="{ width: goalPercentage + '%' }"></div>
      </div>
      <div class="progress-info">
        <span>현재: {{ formatCurrency(campaign.current_amount) }}</span>
        <span>목표: {{ formatCurrency(campaign.goal_amount) }}</span>
      </div>
    </div>
    
    <!-- 탭 메뉴 -->
    <div class="tabs">
      <button 
        v-for="tab in tabs" 
        :key="tab.id"
        :class="['tab-button', { active: activeTab === tab.id }]"
        @click="activeTab = tab.id"
      >
        {{ tab.icon }} {{ tab.label }}
      </button>
    </div>
    
    <!-- 기부 내역 -->
    <div v-show="activeTab === 'donations'" class="tab-content">
      <h3>💝 기부 내역</h3>
      <div class="transaction-list">
        <div 
          v-for="donation in donations" 
          :key="donation.id"
          class="transaction-item"
        >
          <div class="transaction-icon">💰</div>
          <div class="transaction-details">
            <div class="transaction-header">
              <span class="donor-name">
                {{ donation.is_anonymous ? '익명의 기부자' : donation.donor.name }}
              </span>
              <span class="transaction-amount">
                {{ formatCurrency(donation.amount) }} ETH
              </span>
            </div>
            <div class="transaction-meta">
              <span class="transaction-date">
                {{ formatDate(donation.created_at) }}
              </span>
              <a 
                :href="getEtherscanUrl(donation.transaction_hash)" 
                target="_blank"
                class="blockchain-link"
              >
                🔗 블록체인에서 확인
              </a>
            </div>
            <div v-if="donation.message" class="transaction-message">
              "{{ donation.message }}"
            </div>
          </div>
          <div class="transaction-status">
            <span :class="['status-badge', donation.status]">
              {{ getStatusText(donation.status) }}
            </span>
          </div>
        </div>
      </div>
      
      <button v-if="hasMoreDonations" @click="loadMoreDonations" class="load-more">
        더 보기
      </button>
    </div>
    
    <!-- 집행 내역 -->
    <div v-show="activeTab === 'expenditures'" class="tab-content">
      <h3>📤 집행 내역</h3>
      <div class="transaction-list">
        <div 
          v-for="expenditure in expenditures" 
          :key="expenditure.id"
          class="transaction-item expenditure"
        >
          <div class="transaction-icon">📤</div>
          <div class="transaction-details">
            <div class="transaction-header">
              <span class="category-badge">{{ expenditure.category }}</span>
              <span class="transaction-amount">
                -{{ formatCurrency(expenditure.amount) }} ETH
              </span>
            </div>
            <div class="transaction-description">
              {{ expenditure.description }}
            </div>
            <div class="transaction-meta">
              <span class="transaction-date">
                {{ formatDate(expenditure.executed_at) }}
              </span>
              <a 
                :href="getEtherscanUrl(expenditure.transaction_hash)" 
                target="_blank"
                class="blockchain-link"
              >
                🔗 블록체인에서 확인
              </a>
              <a 
                v-if="expenditure.receipt_url"
                :href="expenditure.receipt_url" 
                target="_blank"
                class="receipt-link"
              >
                📄 영수증 보기
              </a>
            </div>
          </div>
          <div class="transaction-status">
            <span :class="['status-badge', expenditure.status]">
              {{ getStatusText(expenditure.status) }}
            </span>
          </div>
        </div>
      </div>
    </div>
    
    <!-- 블록체인 이벤트 -->
    <div v-show="activeTab === 'blockchain'" class="tab-content">
      <h3>⛓️ 블록체인 이벤트</h3>
      <div class="blockchain-events">
        <div 
          v-for="event in blockchainEvents" 
          :key="event.id"
          class="event-item"
        >
          <div class="event-type">{{ event.event_type }}</div>
          <div class="event-details">
            <div class="event-data">{{ formatEventData(event.event_data) }}</div>
            <div class="event-meta">
              <span>블록: {{ event.block_number }}</span>
              <span>가스: {{ event.gas_used }}</span>
              <span>{{ formatDate(event.blockchain_timestamp) }}</span>
            </div>
          </div>
          <a 
            :href="getEtherscanUrl(event.transaction_hash)" 
            target="_blank"
            class="event-link"
          >
            상세보기 →
          </a>
        </div>
      </div>
    </div>
    
    <!-- 통계 차트 -->
    <div v-show="activeTab === 'statistics'" class="tab-content">
      <h3>📈 통계 분석</h3>
      
      <div class="chart-container">
        <h4>일별 기부 추이</h4>
        <canvas ref="donationTrendChart"></canvas>
      </div>
      
      <div class="chart-container">
        <h4>카테고리별 집행 내역</h4>
        <canvas ref="expenditureCategoryChart"></canvas>
      </div>
      
      <div class="stats-table">
        <h4>상세 통계</h4>
        <table>
          <tr>
            <td>평균 기부 금액</td>
            <td>{{ formatCurrency(statistics.average_donation) }} ETH</td>
          </tr>
          <tr>
            <td>최대 기부 금액</td>
            <td>{{ formatCurrency(statistics.max_donation) }} ETH</td>
          </tr>
          <tr>
            <td>최소 기부 금액</td>
            <td>{{ formatCurrency(statistics.min_donation) }} ETH</td>
          </tr>
          <tr>
            <td>재기부 비율</td>
            <td>{{ statistics.repeat_donor_rate }}%</td>
          </tr>
        </table>
      </div>
    </div>
  </div>
</template>

<script>
import { ref, computed, onMounted } from 'vue';
import { Chart } from 'chart.js/auto';
import axios from 'axios';

export default {
  name: 'TransparencyDashboard',
  props: {
    campaignId: {
      type: Number,
      required: true
    }
  },
  setup(props) {
    const campaign = ref({});
    const donations = ref([]);
    const expenditures = ref([]);
    const blockchainEvents = ref([]);
    const statistics = ref({});
    const activeTab = ref('donations');
    const hasMoreDonations = ref(false);
    
    const tabs = [
      { id: 'donations', label: '기부 내역', icon: '💝' },
      { id: 'expenditures', label: '집행 내역', icon: '📤' },
      { id: 'blockchain', label: '블록체인', icon: '⛓️' },
      { id: 'statistics', label: '통계', icon: '📈' }
    ];
    
    const goalPercentage = computed(() => {
      if (!campaign.value.goal_amount) return 0;
      return Math.min(
        (campaign.value.current_amount / campaign.value.goal_amount) * 100,
        100
      ).toFixed(1);
    });
    
    const loadCampaignData = async () => {
      try {
        const response = await axios.get(`/api/campaigns/${props.campaignId}`);
        campaign.value = response.data.data;
      } catch (error) {
        console.error('Failed to load campaign data:', error);
      }
    };
    
    const loadDonations = async () => {
      try {
        const response = await axios.get(`/api/donations`, {
          params: { campaign_id: props.campaignId }
        });
        donations.value = response.data.data.data;
        hasMoreDonations.value = response.data.data.next_page_url !== null;
      } catch (error) {
        console.error('Failed to load donations:', error);
      }
    };
    
    const loadExpenditures = async () => {
      try {
        const response = await axios.get(`/api/expenditures`, {
          params: { campaign_id: props.campaignId }
        });
        expenditures.value = response.data.data;
      } catch (error) {
        console.error('Failed to load expenditures:', error);
      }
    };
    
    const loadBlockchainEvents = async () => {
      try {
        const response = await axios.get(`/api/blockchain-logs`, {
          params: { campaign_id: props.campaignId }
        });
        blockchainEvents.value = response.data.data;
      } catch (error) {
        console.error('Failed to load blockchain events:', error);
      }
    };
    
    const loadStatistics = async () => {
      try {
        const response = await axios.get(`/api/campaigns/${props.campaignId}/statistics`);
        statistics.value = response.data.data;
        
        // 차트 그리기
        drawCharts();
      } catch (error) {
        console.error('Failed to load statistics:', error);
      }
    };
    
    const drawCharts = () => {
      // 일별 기부 추이 차트
      // Chart.js 구현...
    };
    
    const formatCurrency = (amount) => {
      return new Intl.NumberFormat('ko-KR', {
        minimumFractionDigits: 2,
        maximumFractionDigits: 4
      }).format(amount);
    };
    
    const formatDate = (date) => {
      return new Date(date).toLocaleString('ko-KR');
    };
    
    const getEtherscanUrl = (txHash) => {
      const network = process.env.VUE_APP_BLOCKCHAIN_NETWORK;
      const baseUrl = network === 'mainnet' 
        ? 'https://etherscan.io' 
        : `https://${network}.etherscan.io`;
      return `${baseUrl}/tx/${txHash}`;
    };
    
    const getStatusText = (status) => {
      const statusMap = {
        pending: '대기중',
        confirmed: '확인됨',
        failed: '실패'
      };
      return statusMap[status] || status;
    };
    
    const formatEventData = (data) => {
      return JSON.stringify(data, null, 2);
    };
    
    onMounted(() => {
      loadCampaignData();
      loadDonations();
      loadExpenditures();
      loadBlockchainEvents();
      loadStatistics();
      
      // 실시간 업데이트 (웹소켓 또는 폴링)
      setInterval(loadCampaignData, 30000);
    });
    
    return {
      campaign,
      donations,
      expenditures,
      blockchainEvents,
      statistics,
      activeTab,
      tabs,
      goalPercentage,
      hasMoreDonations,
      formatCurrency,
      formatDate,
      getEtherscanUrl,
      getStatusText,
      formatEventData
    };
  }
};
</script>

<style>.tx-header{background:linear-gradient(135deg,#f5f7fa 0%,#e8ecf1 100%);
border-radius:16px;
padding:40px;
text-align:center;
margin-bottom:40px;
box-shadow:0 4px 15px rgba(0,0,0,0.08);}
.tx-section{margin:50px 0;
padding:30px;
background:#fafbfc;
border-radius:12px;
border-left:4px solid #7c9cbf;}
.tx-highlight{background:linear-gradient(120deg,#fef6e4 0%,#f3e7d3 100%);
padding:25px;
border-radius:10px;
margin:25px 0;
border:2px solid #e8d5b7;}
.tx-tip{background:#e8f4f8;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:5px solid #4a9ebb;}
.tx-warning{background:#fff4e6;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:5px solid #f59e0b;}
.tx-table-wrap{overflow-x:auto;
margin:25px 0;}
.tx-table{width:100%;
border-collapse:collapse;
background:#fff;
border-radius:8px;
overflow:hidden;}
.tx-table th{background:#7c9cbf;
color:#fff;
padding:15px;
text-align:left;
font-weight:600;}
.tx-table td{padding:12px 15px;
border-bottom:1px solid #e5e7eb;}
.tx-step{background:#f0f4f8;
padding:20px;
margin:20px 0;
border-radius:10px;
border-left:5px solid #5a7a9b;}
.tx-card{background:#fff;
padding:25px;
border-radius:12px;
margin:20px 0;
box-shadow:0 2px 10px rgba(0,0,0,0.06);}
.tx-emphasis{color:#5a7a9b;
font-weight:600;}
.tx-subtitle{color:#6b7280;
font-size:1.1em;
margin:15px 0;}</style>

<?php

namespace App\Services;

use Illuminate\Support\Facades\Crypt;

class PrivacyService
{
    /**
     * 민감한 정보 암호화
     */
    public function encryptSensitiveData(array $data): string
    {
        return Crypt::encryptString(json_encode($data));
    }
    
    /**
     * 암호화된 정보 복호화
     */
    public function decryptSensitiveData(string $encrypted): array
    {
        return json_decode(Crypt::decryptString($encrypted), true);
    }
    
    /**
     * 지갑 주소 마스킹
     */
    public function maskWalletAddress(string $address): string
    {
        if (strlen($address) < 10) {
            return $address;
        }
        
        return substr($address, 0, 6) . '...' . substr($address, -4);
    }
    
    /**
     * 익명 기부자 표시명 생성
     */
    public function generateAnonymousName(int $donationId): string
    {
        $adjectives = ['따뜻한', '선한', '빛나는', '아름다운', '고마운'];
        $nouns = ['마음', '천사', '별', '손길', '희망'];
        
        $adj = $adjectives[$donationId % count($adjectives)];
        $noun = $nouns[($donationId * 7) % count($nouns)];
        
        return $adj . ' ' . $noun;
    }
}

# Hardhat 설치 및 설정
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers

# hardhat.config.js
require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: "0.8.19",
  networks: {
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 11155111
    }
  }
};

# 배포 스크립트 (scripts/deploy.js)
const hre = require("hardhat");

async function main() {
  const DonationCampaign = await hre.ethers.getContractFactory("DonationCampaign");
  
  const beneficiary = "0xBeneficiaryAddress";
  const platformAdmin = "0xPlatformAdminAddress";
  const goalAmount = hre.ethers.utils.parseEther("10.0");
  const durationInDays = 30;
  
  console.log("Deploying DonationCampaign...");
  
  const campaign = await DonationCampaign.deploy(
    beneficiary,
    platformAdmin,
    goalAmount,
    durationInDays
  );
  
  await campaign.deployed();
  
  console.log("DonationCampaign deployed to:", campaign.address);
  
  // 배포 정보 저장
  const fs = require('fs');
  const deploymentInfo = {
    address: campaign.address,
    network: "sepolia",
    deployer: (await hre.ethers.getSigners())[0].address,
    timestamp: new Date().toISOString(),
    constructorArgs: {
      beneficiary,
      platformAdmin,
      goalAmount: goalAmount.toString(),
      durationInDays
    }
  };
  
  fs.writeFileSync(
    'deployments/sepolia.json',
    JSON.stringify(deploymentInfo, null, 2)
  );
}

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

# .env.production
APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-donation-platform.com

# Database
DB_CONNECTION=pgsql
DB_HOST=your-db-host
DB_DATABASE=donation_platform
DB_USERNAME=your-username
DB_PASSWORD=your-password

# Blockchain
BLOCKCHAIN_NETWORK=mainnet
BLOCKCHAIN_RPC_URL=https://mainnet.infura.io/v3/YOUR_PROJECT_ID
BLOCKCHAIN_CHAIN_ID=1

# Redis (for queues)
REDIS_HOST=your-redis-host
REDIS_PASSWORD=your-redis-password

# Queue
QUEUE_CONNECTION=redis

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

echo "🚀 Starting deployment..."

# Git pull
git pull origin main

# Install dependencies
composer install --no-dev --optimize-autoloader

# Run migrations
php artisan migrate --force

# Clear and cache config
php artisan config:cache
php artisan route:cache
php artisan view:cache

# Restart queue workers
php artisan queue:restart

# Restart PHP-FPM
sudo systemctl restart php8.2-fpm

echo "✅ Deployment completed!"

<?php

namespace App\Console\Commands;

use App\Models\Donation;
use App\Models\Campaign;
use App\Services\BlockchainService;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Log;

class MonitorBlockchainTransactions extends Command
{
    protected $signature = 'blockchain:monitor';
    protected $description = 'Monitor pending blockchain transactions';
    
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        parent::__construct();
        $this->blockchainService = $blockchainService;
    }
    
    public function handle()
    {
        $this->info('Monitoring blockchain transactions...');
        
        // 대기 중인 기부 트랜잭션 확인
        $pendingDonations = Donation::where('status', 'pending')
            ->whereNotNull('transaction_hash')
            ->where('created_at', '>', now()->subHours(24))
            ->get();
        
        foreach ($pendingDonations as $donation) {
            $this->checkTransactionStatus($donation);
        }
        
        // 블록체인 데이터와 DB 동기화 확인
        $this->syncBlockchainData();
        
        $this->info('Monitoring completed.');
    }
    
    protected function checkTransactionStatus(Donation $donation)
    {
        try {
            $receipt = $this->blockchainService->getTransactionReceipt(
                $donation->transaction_hash
            );
            
            if ($receipt) {
                if ($receipt['status'] === '0x1') {
                    // 성공
                    $donation->update([
                        'status' => 'confirmed',
                        'block_number' => hexdec($receipt['blockNumber']),
                        'blockchain_confirmed_at' => now(),
                    ]);
                    
                    $this->info("✅ Donation {$donation->id} confirmed");
                } else {
                    // 실패
                    $donation->update(['status' => 'failed']);
                    $this->error("❌ Donation {$donation->id} failed");
                    
                    // 관리자에게 알림
                    Log::error('Donation transaction failed', [
                        'donation_id' => $donation->id,
                        'transaction_hash' => $donation->transaction_hash,
                    ]);
                }
            } else {
                // 아직 대기 중
                $hoursSinceDonation = $donation->created_at->diffInHours(now());
                
                if ($hoursSinceDonation > 2) {
                    $this->warn("⏰ Donation {$donation->id} pending for {$hoursSinceDonation} hours");
                }
            }
            
        } catch (\Exception $e) {
            $this->error("Error checking donation {$donation->id}: " . $e->getMessage());
        }
    }
    
    protected function syncBlockchainData()
    {
        $campaigns = Campaign::where('status', 'active')
            ->whereNotNull('smart_contract_address')
            ->get();
        
        foreach ($campaigns as $campaign) {
            try {
                $blockchainInfo = $this->blockchainService->getCampaignInfo(
                    $campaign->smart_contract_address
                );
                
                if ($blockchainInfo['success']) {
                    $blockchainAmount = $blockchainInfo['data']['current_amount'];
                    $dbAmount = $campaign->current_amount;
                    
                    // 금액 불일치 확인
                    if (abs($blockchainAmount - $dbAmount) > 0.0001) {
                        $this->warn("⚠️  Amount mismatch for campaign {$campaign->id}");
                        $this->warn("   Blockchain: {$blockchainAmount}, DB: {$dbAmount}");
                        
                        Log::warning('Campaign amount mismatch', [
                            'campaign_id' => $campaign->id,
                            'blockchain_amount' => $blockchainAmount,
                            'db_amount' => $dbAmount,
                        ]);
                    }
                }
                
            } catch (\Exception $e) {
                $this->error("Error syncing campaign {$campaign->id}: " . $e->getMessage());
            }
        }
    }
}

// 스케줄러에 등록 (app/Console/Kernel.php)
protected function schedule(Schedule $schedule)
{
    // 5분마다 블록체인 트랜잭션 모니터링
    $schedule->command('blockchain:monitor')
        ->everyFiveMinutes()
        ->withoutOverlapping();
    
    // 매일 자정에 통계 집계
    $schedule->command('statistics:aggregate')
        ->daily();
}