🎯 왜 라라벨과 블록체인을 함께 사용할까?

먼저 이 조합이 왜 좋은지부터 이야기해보자. 라라벨은 PHP 기반의 웹 프레임워크 중에서 가장 인기 있는 녀석이야. 깔끔한 문법, 강력한 기능, 그리고 엄청난 커뮤니티 지원이 있지. 반면 블록체인은 탈중앙화, 투명성, 보안성이라는 강력한 무기를 가지고 있어.

이 둘을 합치면? 완벽한 시너지가 나오는 거야! 라라벨의 편리한 개발 환경에서 블록체인의 강력한 보안성을 활용할 수 있거든. 특히 결제 시스템에서는 이런 조합이 정말 빛을 발해. 💎

🛠️ 개발 환경 준비하기

자, 이제 본격적으로 시작해볼까? 먼저 개발 환경을 세팅해야 해. 걱정 마, 하나씩 차근차근 따라오면 돼! 😊

composer create-project laravel/laravel blockchain-payment-admin
cd blockchain-payment-admin
php artisan serve

이제 브라우저에서 http://localhost:8000에 접속하면 라라벨 환영 페이지가 보일 거야. 축하해! 첫 번째 단계 완료! 🎉

composer require web3p/web3.php
composer require kornrunner/keccak
composer require simplito/elliptic-php

만약 다른 블록체인 네트워크를 사용한다면 해당 네트워크의 SDK를 설치하면 돼. 예를 들어 비트코인이라면 BitWasp, 솔라나라면 Solana PHP SDK를 사용할 수 있어.

🏗️ 데이터베이스 설계하기

블록체인 결제 관리 시스템에서 데이터베이스는 정말 중요해. 블록체인에는 모든 거래 내역이 저장되지만, 빠른 조회와 관리를 위해서는 로컬 데이터베이스도 필요하거든.

생각해봐. 매번 블록체인을 조회하면 시간도 오래 걸리고 비용도 발생할 수 있어. 그래서 우리는 하이브리드 방식을 사용할 거야!

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('password');
        $table->enum('role', ['admin', 'user'])->default('user');
        $table->string('wallet_address')->nullable();
        $table->boolean('is_verified')->default(false);
        $table->timestamps();
    });
}

public function up()
{
    Schema::create('wallets', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->string('blockchain_type'); // ethereum, bitcoin, etc.
        $table->string('address')->unique();
        $table->string('public_key')->nullable();
        $table->decimal('balance', 20, 8)->default(0);
        $table->timestamp('last_synced_at')->nullable();
        $table->boolean('is_active')->default(true);
        $table->timestamps();
    });
}

public function up()
{
    Schema::create('transactions', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained();
        $table->foreignId('wallet_id')->constrained();
        $table->string('transaction_hash')->unique();
        $table->string('from_address');
        $table->string('to_address');
        $table->decimal('amount', 20, 8);
        $table->string('currency'); // ETH, BTC, USDT, etc.
        $table->decimal('fee', 20, 8)->default(0);
        $table->enum('status', ['pending', 'confirmed', 'failed', 'cancelled']);
        $table->enum('type', ['deposit', 'withdrawal', 'payment', 'refund']);
        $table->integer('block_number')->nullable();
        $table->integer('confirmations')->default(0);
        $table->text('metadata')->nullable(); // JSON 데이터
        $table->timestamp('confirmed_at')->nullable();
        $table->timestamps();
        
        $table->index(['user_id', 'status']);
        $table->index('transaction_hash');
    });
}

public function up()
{
    Schema::create('payment_settings', function (Blueprint $table) {
        $table->id();
        $table->string('key')->unique();
        $table->text('value');
        $table->string('type'); // string, integer, boolean, json
        $table->text('description')->nullable();
        $table->boolean('is_public')->default(false);
        $table->timestamps();
    });
}

이제 마이그레이션을 실행해보자:

php artisan migrate

🔐 블록체인 연동 서비스 구축하기

자, 이제 가장 핵심적인 부분이야. 블록체인과 실제로 통신하는 서비스를 만들어보자. 이더리움을 예시로 설명할게. 다른 블록체인도 원리는 비슷하니까 응용하면 돼! 🎨

php artisan make:service BlockchainService

namespace App\Services;

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

class BlockchainService
{
    protected $web3;
    protected $contractAddress;
    protected $contractAbi;
    
    public function __construct()
    {
        // Infura 또는 자체 노드 URL 사용
        $nodeUrl = config('blockchain.node_url');
        $this->web3 = new Web3($nodeUrl);
        
        $this->contractAddress = config('blockchain.contract_address');
        $this->contractAbi = json_decode(
            file_get_contents(storage_path('contracts/PaymentContract.json')),
            true
        );
    }
    
    /**
     * 지갑 잔액 조회
     */
    public function getBalance(string $address)
    {
        $balance = null;
        
        $this->web3->eth->getBalance($address, function ($err, $result) use (&$balance) {
            if ($err !== null) {
                throw new Exception('잔액 조회 실패: ' . $err->getMessage());
            }
            $balance = $result;
        });
        
        // Wei를 Ether로 변환
        return Utils::fromWei($balance, 'ether');
    }
    
    /**
     * 거래 내역 조회
     */
    public function getTransaction(string $txHash)
    {
        $transaction = null;
        
        $this->web3->eth->getTransactionByHash($txHash, function ($err, $tx) use (&$transaction) {
            if ($err !== null) {
                throw new Exception('거래 조회 실패: ' . $err->getMessage());
            }
            $transaction = $tx;
        });
        
        return $transaction;
    }
    
    /**
     * 거래 확인 수 조회
     */
    public function getConfirmations(string $txHash)
    {
        $transaction = $this->getTransaction($txHash);
        
        if (!$transaction || !isset($transaction->blockNumber)) {
            return 0;
        }
        
        $currentBlock = null;
        $this->web3->eth->blockNumber(function ($err, $block) use (&$currentBlock) {
            if ($err === null) {
                $currentBlock = $block;
            }
        });
        
        $txBlock = hexdec($transaction->blockNumber);
        $current = hexdec($currentBlock);
        
        return max(0, $current - $txBlock + 1);
    }
    
    /**
     * 결제 전송
     */
    public function sendPayment(string $fromAddress, string $toAddress, float $amount, string $privateKey)
    {
        try {
            $amountInWei = Utils::toWei((string)$amount, 'ether');
            
            // 트랜잭션 데이터 준비
            $transactionData = [
                'from' => $fromAddress,
                'to' => $toAddress,
                'value' => '0x' . dechex($amountInWei),
                'gas' => '0x5208', // 21000 gas
                'gasPrice' => $this->getGasPrice(),
            ];
            
            // 트랜잭션 서명 및 전송
            $signedTx = $this->signTransaction($transactionData, $privateKey);
            
            $txHash = null;
            $this->web3->eth->sendRawTransaction($signedTx, function ($err, $hash) use (&$txHash) {
                if ($err !== null) {
                    throw new Exception('전송 실패: ' . $err->getMessage());
                }
                $txHash = $hash;
            });
            
            return $txHash;
            
        } catch (Exception $e) {
            throw new Exception('결제 전송 중 오류: ' . $e->getMessage());
        }
    }
    
    /**
     * 현재 가스 가격 조회
     */
    protected function getGasPrice()
    {
        $gasPrice = null;
        
        $this->web3->eth->gasPrice(function ($err, $price) use (&$gasPrice) {
            if ($err === null) {
                $gasPrice = $price;
            }
        });
        
        return $gasPrice;
    }
    
    /**
     * 트랜잭션 서명
     */
    protected function signTransaction(array $transaction, string $privateKey)
    {
        // 실제 구현에서는 적절한 서명 라이브러리 사용
        // 보안을 위해 private key는 절대 클라이언트에 노출되면 안 됨!
        
        // 여기서는 개념적인 코드만 표시
        return '0x...'; // 서명된 트랜잭션
    }
    
    /**
     * 스마트 컨트랙트 함수 호출
     */
    public function callContractFunction(string $functionName, array $params = [])
    {
        $contract = new Contract($this->web3->provider, $this->contractAbi);
        $contract->at($this->contractAddress);
        
        $result = null;
        $contract->call($functionName, $params, function ($err, $data) use (&$result) {
            if ($err !== null) {
                throw new Exception('컨트랙트 호출 실패: ' . $err->getMessage());
            }
            $result = $data;
        });
        
        return $result;
    }
}

return [
    // 노드 URL (Infura, Alchemy, 또는 자체 노드)
    'node_url' => env('BLOCKCHAIN_NODE_URL', 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID'),
    
    // 네트워크 설정
    'network' => env('BLOCKCHAIN_NETWORK', 'mainnet'), // mainnet, testnet, ropsten, etc.
    
    // 스마트 컨트랙트 주소
    'contract_address' => env('BLOCKCHAIN_CONTRACT_ADDRESS'),
    
    // 가스 설정
    'gas_limit' => env('BLOCKCHAIN_GAS_LIMIT', 21000),
    'gas_price_multiplier' => env('BLOCKCHAIN_GAS_PRICE_MULTIPLIER', 1.2),
    
    // 확인 수 설정
    'required_confirmations' => env('BLOCKCHAIN_REQUIRED_CONFIRMATIONS', 12),
    
    // 지원하는 암호화폐
    'supported_currencies' => [
        'ETH' => [
            'name' => 'Ethereum',
            'decimals' => 18,
            'min_amount' => 0.001,
        ],
        'USDT' => [
            'name' => 'Tether USD',
            'decimals' => 6,
            'contract_address' => env('USDT_CONTRACT_ADDRESS'),
            'min_amount' => 1,
        ],
        'USDC' => [
            'name' => 'USD Coin',
            'decimals' => 6,
            'contract_address' => env('USDC_CONTRACT_ADDRESS'),
            'min_amount' => 1,
        ],
    ],
    
    // 웹훅 설정
    'webhook_url' => env('BLOCKCHAIN_WEBHOOK_URL'),
    'webhook_secret' => env('BLOCKCHAIN_WEBHOOK_SECRET'),
];

그리고 .env 파일에 실제 값들을 입력해:

BLOCKCHAIN_NODE_URL=https://mainnet.infura.io/v3/your_project_id
BLOCKCHAIN_NETWORK=mainnet
BLOCKCHAIN_CONTRACT_ADDRESS=0x...
BLOCKCHAIN_REQUIRED_CONFIRMATIONS=12
USDT_CONTRACT_ADDRESS=0xdac17f958d2ee523a2206206994597c13d831ec7
USDC_CONTRACT_ADDRESS=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48

🎨 관리자 페이지 컨트롤러 만들기

이제 실제 관리자가 사용할 페이지의 로직을 만들어보자. 컨트롤러는 사용자의 요청을 받아서 처리하고 결과를 반환하는 역할을 해. MVC 패턴의 핵심이지! 🎯

php artisan make:controller Admin/PaymentController
php artisan make:controller Admin/DashboardController
php artisan make:controller Admin/TransactionController

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Transaction;
use App\Models\User;
use App\Models\Wallet;
use App\Services\BlockchainService;
use Illuminate\Http\Request;
use Carbon\Carbon;

class DashboardController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    public function index()
    {
        // 오늘의 통계
        $todayStats = $this->getTodayStats();
        
        // 최근 거래 내역
        $recentTransactions = Transaction::with(['user', 'wallet'])
            ->orderBy('created_at', 'desc')
            ->limit(10)
            ->get();
        
        // 월별 거래량 차트 데이터
        $monthlyData = $this->getMonthlyChartData();
        
        // 대기중인 거래
        $pendingTransactions = Transaction::where('status', 'pending')
            ->count();
        
        // 활성 사용자 수
        $activeUsers = User::where('is_verified', true)
            ->whereHas('transactions', function($query) {
                $query->where('created_at', '>=', Carbon::now()->subDays(30));
            })
            ->count();
        
        return view('admin.dashboard', compact(
            'todayStats',
            'recentTransactions',
            'monthlyData',
            'pendingTransactions',
            'activeUsers'
        ));
    }
    
    protected function getTodayStats()
    {
        $today = Carbon::today();
        
        return [
            'total_transactions' => Transaction::whereDate('created_at', $today)->count(),
            'total_volume' => Transaction::whereDate('created_at', $today)
                ->where('status', 'confirmed')
                ->sum('amount'),
            'successful_rate' => $this->calculateSuccessRate($today),
            'average_confirmation_time' => $this->getAverageConfirmationTime($today),
        ];
    }
    
    protected function calculateSuccessRate($date)
    {
        $total = Transaction::whereDate('created_at', $date)->count();
        
        if ($total === 0) {
            return 0;
        }
        
        $successful = Transaction::whereDate('created_at', $date)
            ->where('status', 'confirmed')
            ->count();
        
        return round(($successful / $total) * 100, 2);
    }
    
    protected function getAverageConfirmationTime($date)
    {
        $transactions = Transaction::whereDate('created_at', $date)
            ->where('status', 'confirmed')
            ->whereNotNull('confirmed_at')
            ->get();
        
        if ($transactions->isEmpty()) {
            return 0;
        }
        
        $totalSeconds = 0;
        foreach ($transactions as $tx) {
            $totalSeconds += $tx->created_at->diffInSeconds($tx->confirmed_at);
        }
        
        return round($totalSeconds / $transactions->count() / 60, 2); // 분 단위
    }
    
    protected function getMonthlyChartData()
    {
        $months = [];
        $volumes = [];
        
        for ($i = 11; $i >= 0; $i--) {
            $date = Carbon::now()->subMonths($i);
            $months[] = $date->format('Y-m');
            
            $volume = Transaction::whereYear('created_at', $date->year)
                ->whereMonth('created_at', $date->month)
                ->where('status', 'confirmed')
                ->sum('amount');
            
            $volumes[] = $volume;
        }
        
        return [
            'labels' => $months,
            'data' => $volumes,
        ];
    }
    
    /**
     * 실시간 블록체인 상태 조회
     */
    public function getBlockchainStatus()
    {
        try {
            // 최신 블록 번호
            $latestBlock = $this->blockchainService->getLatestBlockNumber();
            
            // 현재 가스 가격
            $gasPrice = $this->blockchainService->getCurrentGasPrice();
            
            // 네트워크 상태
            $networkStatus = $this->blockchainService->getNetworkStatus();
            
            return response()->json([
                'success' => true,
                'data' => [
                    'latest_block' => $latestBlock,
                    'gas_price' => $gasPrice,
                    'network_status' => $networkStatus,
                    'timestamp' => now(),
                ]
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '블록체인 상태 조회 실패: ' . $e->getMessage()
            ], 500);
        }
    }
}

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Transaction;
use App\Services\BlockchainService;
use Illuminate\Http\Request;

class TransactionController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    /**
     * 거래 목록 조회
     */
    public function index(Request $request)
    {
        $query = Transaction::with(['user', 'wallet']);
        
        // 상태 필터
        if ($request->has('status') && $request->status !== 'all') {
            $query->where('status', $request->status);
        }
        
        // 타입 필터
        if ($request->has('type') && $request->type !== 'all') {
            $query->where('type', $request->type);
        }
        
        // 날짜 범위 필터
        if ($request->has('date_from')) {
            $query->whereDate('created_at', '>=', $request->date_from);
        }
        if ($request->has('date_to')) {
            $query->whereDate('created_at', '<=', $request->date_to);
        }
        
        // 검색 (트랜잭션 해시, 주소, 사용자명)
        if ($request->has('search') && $request->search) {
            $search = $request->search;
            $query->where(function($q) use ($search) {
                $q->where('transaction_hash', 'like', "%{$search}%")
                  ->orWhere('from_address', 'like', "%{$search}%")
                  ->orWhere('to_address', 'like', "%{$search}%")
                  ->orWhereHas('user', function($userQuery) use ($search) {
                      $userQuery->where('name', 'like', "%{$search}%")
                                ->orWhere('email', 'like', "%{$search}%");
                  });
            });
        }
        
        // 정렬
        $sortBy = $request->get('sort_by', 'created_at');
        $sortOrder = $request->get('sort_order', 'desc');
        $query->orderBy($sortBy, $sortOrder);
        
        // 페이지네이션
        $transactions = $query->paginate(20);
        
        return view('admin.transactions.index', compact('transactions'));
    }
    
    /**
     * 거래 상세 조회
     */
    public function show($id)
    {
        $transaction = Transaction::with(['user', 'wallet'])->findOrFail($id);
        
        // 블록체인에서 최신 정보 가져오기
        try {
            $blockchainData = $this->blockchainService->getTransaction($transaction->transaction_hash);
            $confirmations = $this->blockchainService->getConfirmations($transaction->transaction_hash);
            
            // 데이터베이스 업데이트
            if ($confirmations !== $transaction->confirmations) {
                $transaction->update(['confirmations' => $confirmations]);
            }
            
        } catch (\Exception $e) {
            $blockchainData = null;
            $confirmations = $transaction->confirmations;
        }
        
        return view('admin.transactions.show', compact('transaction', 'blockchainData', 'confirmations'));
    }
    
    /**
     * 거래 동기화 (블록체인에서 최신 정보 가져오기)
     */
    public function sync($id)
    {
        try {
            $transaction = Transaction::findOrFail($id);
            
            // 블록체인에서 정보 조회
            $blockchainTx = $this->blockchainService->getTransaction($transaction->transaction_hash);
            
            if (!$blockchainTx) {
                return response()->json([
                    'success' => false,
                    'message' => '블록체인에서 거래를 찾을 수 없습니다.'
                ], 404);
            }
            
            // 확인 수 업데이트
            $confirmations = $this->blockchainService->getConfirmations($transaction->transaction_hash);
            
            // 상태 업데이트
            $status = $transaction->status;
            $requiredConfirmations = config('blockchain.required_confirmations');
            
            if ($confirmations >= $requiredConfirmations && $status === 'pending') {
                $status = 'confirmed';
                $transaction->confirmed_at = now();
            }
            
            $transaction->update([
                'confirmations' => $confirmations,
                'status' => $status,
                'block_number' => hexdec($blockchainTx->blockNumber ?? 0),
            ]);
            
            return response()->json([
                'success' => true,
                'message' => '거래 정보가 동기화되었습니다.',
                'data' => $transaction
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '동기화 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 거래 취소 (pending 상태만 가능)
     */
    public function cancel($id)
    {
        try {
            $transaction = Transaction::findOrFail($id);
            
            if ($transaction->status !== 'pending') {
                return response()->json([
                    'success' => false,
                    'message' => 'pending 상태의 거래만 취소할 수 있습니다.'
                ], 400);
            }
            
            $transaction->update(['status' => 'cancelled']);
            
            return response()->json([
                'success' => true,
                'message' => '거래가 취소되었습니다.'
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '취소 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 거래 통계 내보내기 (CSV)
     */
    public function export(Request $request)
    {
        $query = Transaction::with(['user', 'wallet']);
        
        // 필터 적용 (index 메서드와 동일)
        // ... (필터 로직 생략)
        
        $transactions = $query->get();
        
        $filename = 'transactions_' . now()->format('Y-m-d_His') . '.csv';
        
        $headers = [
            'Content-Type' => 'text/csv',
            'Content-Disposition' => "attachment; filename=\"{$filename}\"",
        ];
        
        $callback = function() use ($transactions) {
            $file = fopen('php://output', 'w');
            
            // CSV 헤더
            fputcsv($file, [
                'ID', '거래 해시', '사용자', '보낸 주소', '받는 주소',
                '금액', '통화', '수수료', '상태', '타입',
                '확인 수', '생성일시', '확인일시'
            ]);
            
            // 데이터 행
            foreach ($transactions as $tx) {
                fputcsv($file, [
                    $tx->id,
                    $tx->transaction_hash,
                    $tx->user->name ?? 'N/A',
                    $tx->from_address,
                    $tx->to_address,
                    $tx->amount,
                    $tx->currency,
                    $tx->fee,
                    $tx->status,
                    $tx->type,
                    $tx->confirmations,
                    $tx->created_at,
                    $tx->confirmed_at ?? 'N/A',
                ]);
            }
            
            fclose($file);
        };
        
        return response()->stream($callback, 200, $headers);
    }
}

🎭 프론트엔드 뷰 만들기

백엔드 로직은 완성했으니 이제 사용자가 실제로 볼 화면을 만들어야 해. 라라벨의 Blade 템플릿 엔진을 사용하면 정말 편하게 만들 수 있어! 😊

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="csrf-token" content="{{ csrf_token() }}">
    <title>@yield('title', '블록체인 결제 관리자') - Admin</title>
    
    <!-- Tailwind CSS -->
    <script src="https://cdn.tailwindcss.com"></script>
    
    <!-- Chart.js -->
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    
    <!-- Alpine.js -->
    <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
    
    @stack('styles')
</head>
<body class="bg-gray-50">
    <div class="flex h-screen">
        <!-- 사이드바 -->
        <aside class="w-64 bg-gradient-to-b from-indigo-600 to-purple-700 text-white">
            <div class="p-6">
                <h1 class="text-2xl font-bold">💎 Blockchain Pay</h1>
                <p class="text-sm text-indigo-200 mt-1">관리자 대시보드</p>
            </div>
            
            <nav class="mt-6">
                <a href="{{ route('admin.dashboard') }}" 
                   class="flex items-center px-6 py-3 hover:bg-white/10 transition">
                    <span class="mr-3">📊</span>
                    대시보드
                </a>
                
                <a href="{{ route('admin.transactions.index') }}" 
                   class="flex items-center px-6 py-3 hover:bg-white/10 transition">
                    <span class="mr-3">💳</span>
                    거래 관리
                </a>
                
                <a href="{{ route('admin.users.index') }}" 
                   class="flex items-center px-6 py-3 hover:bg-white/10 transition">
                    <span class="mr-3">👥</span>
                    사용자 관리
                </a>
                
                <a href="{{ route('admin.wallets.index') }}" 
                   class="flex items-center px-6 py-3 hover:bg-white/10 transition">
                    <span class="mr-3">👛</span>
                    지갑 관리
                </a>
                
                <a href="{{ route('admin.settings') }}" 
                   class="flex items-center px-6 py-3 hover:bg-white/10 transition">
                    <span class="mr-3">⚙️</span>
                    설정
                </a>
            </nav>
        </aside>
        
        <!-- 메인 컨텐츠 -->
        <div class="flex-1 flex flex-col overflow-hidden">
            <!-- 헤더 -->
            <header class="bg-white shadow-sm">
                <div class="flex items-center justify-between px-6 py-4">
                    <h2 class="text-xl font-semibold text-gray-800">
                        @yield('page-title', '대시보드')
                    </h2>
                    
                    <div class="flex items-center space-x-4">
                        <!-- 블록체인 상태 -->
                        <div class="flex items-center space-x-2" x-data="blockchainStatus()">
                            <div class="w-2 h-2 rounded-full" 
                                 :class="status === 'online' ? 'bg-green-500' : 'bg-red-500'">
                            </div>
                            <span class="text-sm text-gray-600" x-text="statusText"></span>
                        </div>
                        
                        <!-- 사용자 메뉴 -->
                        <div class="relative" x-data="{ open: false }">
                            <button @click="open = !open" 
                                    class="flex items-center space-x-2 text-gray-700 hover:text-gray-900">
                                <span>{{ auth()->user()->name }}</span>
                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path>
                                </svg>
                            </button>
                            
                            <div x-show="open" 
                                 @click.away="open = false"
                                 class="absolute right-0 mt-2 w-48 bg-white rounded-lg shadow-lg py-2">
                                <a href="{{ route('admin.profile') }}" 
                                   class="block px-4 py-2 text-gray-700 hover:bg-gray-100">
                                    프로필
                                </a>
                                <form method="POST" action="{{ route('logout') }}">
                                    @csrf
                                    <button type="submit" 
                                            class="block w-full text-left px-4 py-2 text-gray-700 hover:bg-gray-100">
                                        로그아웃
                                    </button>
                                </form>
                            </div>
                        </div>
                    </div>
                </div>
            </header>
            
            <!-- 메인 컨텐츠 영역 -->
            <main class="flex-1 overflow-y-auto p-6">
                @if(session('success'))
                    <div class="mb-4 p-4 bg-green-100 border border-green-400 text-green-700 rounded-lg">
                        {{ session('success') }}
                    </div>
                @endif
                
                @if(session('error'))
                    <div class="mb-4 p-4 bg-red-100 border border-red-400 text-red-700 rounded-lg">
                        {{ session('error') }}
                    </div>
                @endif
                
                @yield('content')
            </main>
        </div>
    </div>
    
    <script>
        // 블록체인 상태 체크
        function blockchainStatus() {
            return {
                status: 'checking',
                statusText: '확인 중...',
                
                init() {
                    this.checkStatus();
                    setInterval(() => this.checkStatus(), 30000); // 30초마다 체크
                },
                
                async checkStatus() {
                    try {
                        const response = await fetch('/admin/blockchain/status');
                        const data = await response.json();
                        
                        if (data.success) {
                            this.status = 'online';
                            this.statusText = '블록체인 연결됨';
                        } else {
                            this.status = 'offline';
                            this.statusText = '연결 실패';
                        }
                    } catch (error) {
                        this.status = 'offline';
                        this.statusText = '연결 실패';
                    }
                }
            }
        }
    </script>
    
    @stack('scripts')
</body>
</html>

@extends('layouts.admin')

@section('title', '대시보드')
@section('page-title', '📊 대시보드')

@section('content')
<div class="space-y-6">
    <!-- 통계 카드 -->
    <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6">
        <!-- 오늘의 거래 -->
        <div class="bg-white rounded-lg shadow p-6">
            <div class="flex items-center justify-between">
                <div>
                    <p class="text-sm text-gray-600">오늘의 거래</p>
                    <p class="text-3xl font-bold text-gray-900 mt-2">
                        {{ number_format($todayStats['total_transactions']) }}
                    </p>
                </div>
                <div class="w-12 h-12 bg-blue-100 rounded-full flex items-center justify-center">
                    <span class="text-2xl">💳</span>
                </div>
            </div>
        </div>
        
        <!-- 거래량 -->
        <div class="bg-white rounded-lg shadow p-6">
            <div class="flex items-center justify-between">
                <div>
                    <p class="text-sm text-gray-600">오늘의 거래량</p>
                    <p class="text-3xl font-bold text-gray-900 mt-2">
                        {{ number_format($todayStats['total_volume'], 4) }} ETH
                    </p>
                </div>
                <div class="w-12 h-12 bg-green-100 rounded-full flex items-center justify-center">
                    <span class="text-2xl">💰</span>
                </div>
            </div>
        </div>
        
        <!-- 성공률 -->
        <div class="bg-white rounded-lg shadow p-6">
            <div class="flex items-center justify-between">
                <div>
                    <p class="text-sm text-gray-600">성공률</p>
                    <p class="text-3xl font-bold text-gray-900 mt-2">
                        {{ $todayStats['successful_rate'] }}%
                    </p>
                </div>
                <div class="w-12 h-12 bg-purple-100 rounded-full flex items-center justify-center">
                    <span class="text-2xl">📈</span>
                </div>
            </div>
        </div>
        
        <!-- 대기중 -->
        <div class="bg-white rounded-lg shadow p-6">
            <div class="flex items-center justify-between">
                <div>
                    <p class="text-sm text-gray-600">대기중인 거래</p>
                    <p class="text-3xl font-bold text-gray-900 mt-2">
                        {{ number_format($pendingTransactions) }}
                    </p>
                </div>
                <div class="w-12 h-12 bg-yellow-100 rounded-full flex items-center justify-center">
                    <span class="text-2xl">⏳</span>
                </div>
            </div>
        </div>
    </div>
    
    <!-- 차트 -->
    <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
        <!-- 월별 거래량 차트 -->
        <div class="bg-white rounded-lg shadow p-6">
            <h3 class="text-lg font-semibold text-gray-900 mb-4">월별 거래량</h3>
            <canvas id="monthlyChart"></canvas>
        </div>
        
        <!-- 거래 타입 분포 -->
        <div class="bg-white rounded-lg shadow p-6">
            <h3 class="text-lg font-semibold text-gray-900 mb-4">거래 타입 분포</h3>
            <canvas id="typeChart"></canvas>
        </div>
    </div>
    
    <!-- 최근 거래 -->
    <div class="bg-white rounded-lg shadow">
        <div class="p-6 border-b border-gray-200">
            <h3 class="text-lg font-semibold text-gray-900">최근 거래 내역</h3>
        </div>
        
        <div class="overflow-x-auto">
            <table class="w-full">
                <thead class="bg-gray-50">
                    <tr>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">거래 해시</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">사용자</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">금액</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">타입</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">상태</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">시간</th>
                    </tr>
                </thead>
                <tbody class="divide-y divide-gray-200">
                    @foreach($recentTransactions as $tx)
                    <tr class="hover:bg-gray-50">
                        <td class="px-6 py-4 whitespace-nowrap">
                            <a href="{{ route('admin.transactions.show', $tx->id) }}" 
                               class="text-indigo-600 hover:text-indigo-900 font-mono text-sm">
                                {{ Str::limit($tx->transaction_hash, 20) }}
                            </a>
                        </td>
                        <td class="px-6 py-4 whitespace-nowrap">
                            {{ $tx->user->name ?? 'N/A' }}
                        </td>
                        <td class="px-6 py-4 whitespace-nowrap">
                            {{ number_format($tx->amount, 4) }} {{ $tx->currency }}
                        </td>
                        <td class="px-6 py-4 whitespace-nowrap">
                            <span class="px-2 py-1 text-xs rounded-full bg-blue-100 text-blue-800">
                                {{ $tx->type }}
                            </span>
                        </td>
                        <td class="px-6 py-4 whitespace-nowrap">
                            @if($tx->status === 'confirmed')
                                <span class="px-2 py-1 text-xs rounded-full bg-green-100 text-green-800">
                                    ✓ 확인됨
                                </span>
                            @elseif($tx->status === 'pending')
                                <span class="px-2 py-1 text-xs rounded-full bg-yellow-100 text-yellow-800">
                                    ⏳ 대기중
                                </span>
                            @else
                                <span class="px-2 py-1 text-xs rounded-full bg-red-100 text-red-800">
                                    ✗ {{ $tx->status }}
                                </span>
                            @endif
                        </td>
                        <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
                            {{ $tx->created_at->diffForHumans() }}
                        </td>
                    </tr>
                    @endforeach
                </tbody>
            </table>
        </div>
        
        <div class="p-4 border-t border-gray-200">
            <a href="{{ route('admin.transactions.index') }}" 
               class="text-indigo-600 hover:text-indigo-900 text-sm font-medium">
                모든 거래 보기 →
            </a>
        </div>
    </div>
</div>
@endsection

@push('scripts')
<script>
    // 월별 거래량 차트
    const monthlyCtx = document.getElementById('monthlyChart').getContext('2d');
    new Chart(monthlyCtx, {
        type: 'line',
        data: {
            labels: @json($monthlyData['labels']),
            datasets: [{
                label: '거래량 (ETH)',
                data: @json($monthlyData['data']),
                borderColor: 'rgb(99, 102, 241)',
                backgroundColor: 'rgba(99, 102, 241, 0.1)',
                tension: 0.4,
                fill: true
            }]
        },
        options: {
            responsive: true,
            maintainAspectRatio: false,
            plugins: {
                legend: {
                    display: false
                }
            },
            scales: {
                y: {
                    beginAtZero: true
                }
            }
        }
    });
</script>
@endpush

🔄 실시간 거래 모니터링 구현하기

블록체인 결제 시스템에서 가장 중요한 건 실시간성이야. 거래가 발생하면 즉시 감지하고 처리해야 하거든. 이를 위해 웹소켓과 큐 시스템을 활용할 거야! 🚀

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

BROADCAST_DRIVER=pusher

PUSHER_APP_ID=your_app_id
PUSHER_APP_KEY=your_app_key
PUSHER_APP_SECRET=your_app_secret
PUSHER_APP_CLUSTER=ap3

php artisan make:event TransactionStatusChanged

namespace App\Events;

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

class TransactionStatusChanged implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $transaction;
    public $oldStatus;
    public $newStatus;
    
    public function __construct(Transaction $transaction, $oldStatus, $newStatus)
    {
        $this->transaction = $transaction;
        $this->oldStatus = $oldStatus;
        $this->newStatus = $newStatus;
    }
    
    /**
     * 브로드캐스트할 채널
     */
    public function broadcastOn()
    {
        return [
            new Channel('transactions'),
            new Channel('user.' . $this->transaction->user_id),
        ];
    }
    
    /**
     * 브로드캐스트 데이터
     */
    public function broadcastWith()
    {
        return [
            'transaction_id' => $this->transaction->id,
            'transaction_hash' => $this->transaction->transaction_hash,
            'old_status' => $this->oldStatus,
            'new_status' => $this->newStatus,
            'amount' => $this->transaction->amount,
            'currency' => $this->transaction->currency,
            'confirmations' => $this->transaction->confirmations,
            'timestamp' => now()->toIso8601String(),
        ];
    }
    
    /**
     * 브로드캐스트 이벤트 이름
     */
    public function broadcastAs()
    {
        return 'transaction.status.changed';
    }
}

php artisan make:job MonitorBlockchainTransactions

namespace App\Jobs;

use App\Models\Transaction;
use App\Services\BlockchainService;
use App\Events\TransactionStatusChanged;
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 MonitorBlockchainTransactions implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $blockchainService;
    
    public function __construct()
    {
        $this->blockchainService = app(BlockchainService::class);
    }
    
    public function handle()
    {
        // pending 상태인 거래들 조회
        $pendingTransactions = Transaction::where('status', 'pending')
            ->where('created_at', '>=', now()->subDays(7)) // 7일 이내
            ->get();
        
        foreach ($pendingTransactions as $transaction) {
            try {
                $this->checkTransaction($transaction);
            } catch (\Exception $e) {
                Log::error('거래 모니터링 실패', [
                    'transaction_id' => $transaction->id,
                    'error' => $e->getMessage()
                ]);
            }
        }
    }
    
    protected function checkTransaction(Transaction $transaction)
    {
        // 블록체인에서 거래 정보 조회
        $blockchainTx = $this->blockchainService->getTransaction($transaction->transaction_hash);
        
        if (!$blockchainTx) {
            // 거래를 찾을 수 없으면 일정 시간 후 실패 처리
            if ($transaction->created_at->diffInHours(now()) > 24) {
                $this->updateTransactionStatus($transaction, 'failed');
            }
            return;
        }
        
        // 확인 수 업데이트
        $confirmations = $this->blockchainService->getConfirmations($transaction->transaction_hash);
        $transaction->confirmations = $confirmations;
        
        // 블록 번호 업데이트
        if (isset($blockchainTx->blockNumber)) {
            $transaction->block_number = hexdec($blockchainTx->blockNumber);
        }
        
        // 필요한 확인 수 체크
        $requiredConfirmations = config('blockchain.required_confirmations');
        
        if ($confirmations >= $requiredConfirmations) {
            $this->updateTransactionStatus($transaction, 'confirmed');
            $transaction->confirmed_at = now();
        }
        
        $transaction->save();
    }
    
    protected function updateTransactionStatus(Transaction $transaction, $newStatus)
    {
        $oldStatus = $transaction->status;
        $transaction->status = $newStatus;
        $transaction->save();
        
        // 이벤트 발생
        event(new TransactionStatusChanged($transaction, $oldStatus, $newStatus));
        
        // 사용자에게 알림 전송
        $this->notifyUser($transaction, $newStatus);
    }
    
    protected function notifyUser(Transaction $transaction, $status)
    {
        // 이메일, SMS, 푸시 알림 등 발송
        // 실제 구현은 프로젝트 요구사항에 따라 다름
        
        Log::info('사용자 알림 전송', [
            'user_id' => $transaction->user_id,
            'transaction_id' => $transaction->id,
            'status' => $status
        ]);
    }
}

protected function schedule(Schedule $schedule)
{
    // 1분마다 블록체인 거래 모니터링
    $schedule->job(new MonitorBlockchainTransactions)
             ->everyMinute()
             ->withoutOverlapping();
    
    // 매일 자정에 오래된 거래 정리
    $schedule->call(function () {
        Transaction::where('status', 'pending')
                   ->where('created_at', '<', now()->subDays(30))
                   ->update(['status' => 'expired']);
    })->daily();
    
    // 매시간 지갑 잔액 동기화
    $schedule->job(new SyncWalletBalances)
             ->hourly();
}

스케줄러를 실행하려면 서버의 cron에 다음을 추가해야 해:

* * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1

🛡️ 보안 강화하기

블록체인 결제 시스템에서 보안은 정말정말 중요해! 한 번 실수하면 돈이 날아가니까 말이야. 😱

여러 보안 레이어를 추가해서 시스템을 튼튼하게 만들어보자!

composer require pragmarx/google2fa-laravel

php artisan make:migration add_two_factor_to_users_table

public function up()
{
    Schema::table('users', function (Blueprint $table) {
        $table->string('two_factor_secret')->nullable();
        $table->text('two_factor_recovery_codes')->nullable();
        $table->boolean('two_factor_enabled')->default(false);
    });
}

namespace App\Services;

use Illuminate\Support\Facades\Crypt;
use Exception;

class KeyManagementService
{
    /**
     * Private Key 암호화 저장
     */
    public function storePrivateKey(string $privateKey, int $userId)
    {
        try {
            $encrypted = Crypt::encryptString($privateKey);
            
            // 데이터베이스에 저장
            // 실제로는 별도의 보안 저장소(HSM, KMS 등) 사용 권장
            
            return $encrypted;
            
        } catch (Exception $e) {
            throw new Exception('Private Key 저장 실패: ' . $e->getMessage());
        }
    }
    
    /**
     * Private Key 복호화
     */
    public function retrievePrivateKey(string $encryptedKey)
    {
        try {
            return Crypt::decryptString($encryptedKey);
            
        } catch (Exception $e) {
            throw new Exception('Private Key 복호화 실패: ' . $e->getMessage());
        }
    }
    
    /**
     * Private Key 검증
     */
    public function validatePrivateKey(string $privateKey)
    {
        // Private Key 형식 검증
        if (strlen($privateKey) !== 64) {
            return false;
        }
        
        if (!ctype_xdigit($privateKey)) {
            return false;
        }
        
        return true;
    }
}

php artisan make:migration create_audit_logs_table

public function up()
{
    Schema::create('audit_logs', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->nullable()->constrained();
        $table->string('action'); // login, transaction_create, settings_change, etc.
        $table->string('model_type')->nullable();
        $table->unsignedBigInteger('model_id')->nullable();
        $table->json('old_values')->nullable();
        $table->json('new_values')->nullable();
        $table->string('ip_address');
        $table->text('user_agent')->nullable();
        $table->timestamps();
        
        $table->index(['user_id', 'action']);
        $table->index('created_at');
    });
}

namespace App\Services;

use App\Models\AuditLog;
use Illuminate\Support\Facades\Auth;
use Illuminate\Http\Request;

class AuditLogService
{
    public function log(string $action, $model = null, array $oldValues = [], array $newValues = [])
    {
        $request = request();
        
        AuditLog::create([
            'user_id' => Auth::id(),
            'action' => $action,
            'model_type' => $model ? get_class($model) : null,
            'model_id' => $model ? $model->id : null,
            'old_values' => $oldValues,
            'new_values' => $newValues,
            'ip_address' => $request->ip(),
            'user_agent' => $request->userAgent(),
        ]);
    }
}

namespace App\Http\Middleware;

use Closure;
use Illuminate\Cache\RateLimiter;
use Symfony\Component\HttpFoundation\Response;

class ApiRateLimiter
{
    protected $limiter;
    
    public function __construct(RateLimiter $limiter)
    {
        $this->limiter = $limiter;
    }
    
    public function handle($request, Closure $next, $maxAttempts = 60, $decayMinutes = 1)
    {
        $key = $this->resolveRequestSignature($request);
        
        if ($this->limiter->tooManyAttempts($key, $maxAttempts)) {
            return response()->json([
                'message' => '너무 많은 요청입니다. 잠시 후 다시 시도해주세요.',
                'retry_after' => $this->limiter->availableIn($key)
            ], Response::HTTP_TOO_MANY_REQUESTS);
        }
        
        $this->limiter->hit($key, $decayMinutes * 60);
        
        $response = $next($request);
        
        return $this->addHeaders(
            $response,
            $maxAttempts,
            $this->calculateRemainingAttempts($key, $maxAttempts)
        );
    }
    
    protected function resolveRequestSignature($request)
    {
        return sha1(
            $request->method() .
            '|' . $request->server('SERVER_NAME') .
            '|' . $request->path() .
            '|' . $request->ip()
        );
    }
    
    protected function calculateRemainingAttempts($key, $maxAttempts)
    {
        return $this->limiter->retriesLeft($key, $maxAttempts);
    }
    
    protected function addHeaders($response, $maxAttempts, $remainingAttempts)
    {
        $response->headers->add([
            'X-RateLimit-Limit' => $maxAttempts,
            'X-RateLimit-Remaining' => $remainingAttempts,
        ]);
        
        return $response;
    }
}

🧪 테스트 코드 작성하기

테스트 코드는 선택이 아니라 필수야! 특히 돈이 오가는 시스템에서는 더더욱 그래. 버그 하나가 큰 손실로 이어질 수 있거든. 😰

라라벨은 PHPUnit을 기본으로 제공하니까 테스트 작성이 정말 쉬워!

php artisan make:test TransactionTest

namespace Tests\Feature;

use Tests\TestCase;
use App\Models\User;
use App\Models\Transaction;
use App\Models\Wallet;
use Illuminate\Foundation\Testing\RefreshDatabase;

class TransactionTest extends TestCase
{
    use RefreshDatabase;
    
    protected $admin;
    protected $user;
    protected $wallet;
    
    protected function setUp(): void
    {
        parent::setUp();
        
        // 테스트 데이터 준비
        $this->admin = User::factory()->create(['role' => 'admin']);
        $this->user = User::factory()->create();
        $this->wallet = Wallet::factory()->create(['user_id' => $this->user->id]);
    }
    
    /** @test */
    public function admin_can_view_transaction_list()
    {
        $this->actingAs($this->admin);
        
        Transaction::factory()->count(5)->create();
        
        $response = $this->get(route('admin.transactions.index'));
        
        $response->assertStatus(200);
        $response->assertViewIs('admin.transactions.index');
        $response->assertViewHas('transactions');
    }
    
    /** @test */
    public function admin_can_view_transaction_details()
    {
        $this->actingAs($this->admin);
        
        $transaction = Transaction::factory()->create([
            'user_id' => $this->user->id,
            'wallet_id' => $this->wallet->id,
        ]);
        
        $response = $this->get(route('admin.transactions.show', $transaction->id));
        
        $response->assertStatus(200);
        $response->assertSee($transaction->transaction_hash);
    }
    
    /** @test */
    public function admin_can_sync_transaction_from_blockchain()
    {
        $this->actingAs($this->admin);
        
        $transaction = Transaction::factory()->create([
            'status' => 'pending',
            'confirmations' => 0,
        ]);
        
        // 블록체인 서비스 모킹
        $this->mock(BlockchainService::class, function ($mock) {
            $mock->shouldReceive('getTransaction')
                 ->andReturn((object)['blockNumber' => '0x123456']);
            
            $mock->shouldReceive('getConfirmations')
                 ->andReturn(15);
        });
        
        $response = $this->post(route('admin.transactions.sync', $transaction->id));
        
        $response->assertStatus(200);
        $response->assertJson(['success' => true]);
        
        $transaction->refresh();
        $this->assertEquals('confirmed', $transaction->status);
        $this->assertEquals(15, $transaction->confirmations);
    }
    
    /** @test */
    public function regular_user_cannot_access_admin_pages()
    {
        $this->actingAs($this->user);
        
        $response = $this->get(route('admin.dashboard'));
        
        $response->assertStatus(403); // Forbidden
    }
    
    /** @test */
    public function transaction_status_changes_trigger_event()
    {
        Event::fake();
        
        $transaction = Transaction::factory()->create(['status' => 'pending']);
        
        $transaction->update(['status' => 'confirmed']);
        
        Event::assertDispatched(TransactionStatusChanged::class, function ($event) use ($transaction) {
            return $event->transaction->id === $transaction->id
                && $event->oldStatus === 'pending'
                && $event->newStatus === 'confirmed';
        });
    }
    
    /** @test */
    public function transaction_export_generates_csv_file()
    {
        $this->actingAs($this->admin);
        
        Transaction::factory()->count(10)->create();
        
        $response = $this->get(route('admin.transactions.export'));
        
        $response->assertStatus(200);
        $response->assertHeader('content-type', 'text/csv; charset=UTF-8');
    }
}

php artisan make:test BlockchainServiceTest --unit

namespace Tests\Unit;

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

class BlockchainServiceTest extends TestCase
{
    protected $service;
    
    protected function setUp(): void
    {
        parent::setUp();
        $this->service = new BlockchainService();
    }
    
    /** @test */
    public function it_can_get_balance_from_address()
    {
        $address = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
        
        $balance = $this->service->getBalance($address);
        
        $this->assertIsNumeric($balance);
        $this->assertGreaterThanOrEqual(0, $balance);
    }
    
    /** @test */
    public function it_validates_ethereum_address_format()
    {
        $validAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
        $invalidAddress = 'not-an-address';
        
        $this->assertTrue($this->service->isValidAddress($validAddress));
        $this->assertFalse($this->service->isValidAddress($invalidAddress));
    }
    
    /** @test */
    public function it_converts_wei_to_ether_correctly()
    {
        $wei = '1000000000000000000'; // 1 ETH in Wei
        
        $ether = $this->service->weiToEther($wei);
        
        $this->assertEquals(1.0, $ether);
    }
    
    /** @test */
    public function it_handles_blockchain_connection_errors_gracefully()
    {
        $this->expectException(\Exception::class);
        
        // 잘못된 노드 URL로 서비스 생성
        $service = new BlockchainService('http://invalid-node-url');
        $service->getBalance('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
    }
}

테스트를 실행해보자:

# 모든 테스트 실행
php artisan test

# 특정 테스트만 실행
php artisan test --filter TransactionTest

# 커버리지 리포트 생성
php artisan test --coverage

🚀 배포 및 운영

개발이 끝났으면 이제 실제 서버에 배포해야지! 배포 과정과 운영 팁을 알려줄게. 🎉

APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-domain.com

# 데이터베이스
DB_CONNECTION=mysql
DB_HOST=your-db-host
DB_DATABASE=your-db-name
DB_USERNAME=your-db-user
DB_PASSWORD=your-secure-password

# 캐시 드라이버
CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

# Redis
REDIS_HOST=your-redis-host
REDIS_PASSWORD=your-redis-password

# 블록체인 (메인넷)
BLOCKCHAIN_NODE_URL=https://mainnet.infura.io/v3/your-project-id
BLOCKCHAIN_NETWORK=mainnet

# 보안
SESSION_SECURE_COOKIE=true
SESSION_SAME_SITE=strict

#!/bin/bash

echo "🚀 배포 시작..."

# Git 최신 코드 가져오기
git pull origin main

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

# NPM 빌드
npm install
npm run build

# 캐시 최적화
php artisan config:cache
php artisan route:cache
php artisan view:cache

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

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

# 스케줄러 확인
php artisan schedule:list

echo "✅ 배포 완료!"

FROM php:8.2-fpm

# 시스템 패키지 설치
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# PHP 확장 설치
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

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

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

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

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

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

EXPOSE 9000

CMD ["php-fpm"]

version: '3.8'

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

  nginx:
    image: nginx:alpine
    container_name: blockchain-payment-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    networks:
      - blockchain-network

  mysql:
    image: mysql:8.0
    container_name: blockchain-payment-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - blockchain-network

  redis:
    image: redis:alpine
    container_name: blockchain-payment-redis
    restart: unless-stopped
    networks:
      - blockchain-network

  queue:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: blockchain-payment-queue
    restart: unless-stopped
    command: php artisan queue:work --tries=3
    volumes:
      - ./:/var/www
    networks:
      - blockchain-network

networks:
  blockchain-network:
    driver: bridge

volumes:
  mysql-data:

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

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

# New Relic (성능 모니터링)
# 또는 DataDog, Prometheus + Grafana

이렇게 하면 에러가 발생하거나 성능 이슈가 생겼을 때 즉시 알림을 받을 수 있어!

💡 실전 팁과 베스트 프랙티스

마지막으로 실제 운영하면서 배운 꿀팁들을 공유할게! 이거 알았으면 시행착오를 많이 줄일 수 있었을 텐데... 😅

$transactions = Transaction::all();
foreach ($transactions as $tx) {
    echo $tx->user->name; // N+1 쿼리 발생!
}

$transactions = Transaction::with('user', 'wallet')->get();
foreach ($transactions as $tx) {
    echo $tx->user->name; // 단 2개의 쿼리만 실행!
}

// 블록체인 가스 가격 (1분마다 갱신)
$gasPrice = Cache::remember('gas_price', 60, function () {
    return $this->blockchainService->getCurrentGasPrice();
});

// 사용자 통계 (10분마다 갱신)
$userStats = Cache::remember("user_stats_{$userId}", 600, function () use ($userId) {
    return $this->calculateUserStatistics($userId);
});

// 동기 처리 (느림)
$this->blockchainService->syncAllTransactions(); // 30초 소요

// 비동기 처리 (빠름)
dispatch(new SyncAllTransactionsJob())->onQueue('blockchain'); // 즉시 반환

1. 가스비 최적화
거래를 보낼 때 가스 가격이 낮은 시간대를 활용하자. 주말이나 새벽 시간대가 보통 저렴해.

2. 배치 처리
여러 거래를 한 번에 처리하면 가스비를 절약할 수 있어.

3. Layer 2 솔루션 활용
Polygon, Arbitrum 같은 Layer 2를 사용하면 수수료를 크게 줄일 수 있어.

4. 테스트넷 적극 활용
개발 단계에서는 반드시 테스트넷을 사용해서 실제 비용이 들지 않도록 하자.

1. 실시간 거래 상태 표시
사용자가 거래 진행 상황을 실시간으로 볼 수 있게 하자. 불안감을 줄일 수 있어.

2. 예상 확인 시간 표시
"약 5분 후 확인 완료 예정"처럼 예상 시간을 보여주면 좋아.

3. 거래 히스토리 필터링
날짜, 금액, 상태별로 쉽게 필터링할 수 있게 하자.

4. 모바일 최적화
요즘은 모바일에서 많이 접속하니까 반응형 디자인은 필수!

5. 다크 모드 지원
관리자들이 밤에 작업할 때 눈이 편하도록 다크 모드를 제공하자.

🌟 마무리하며

와! 여기까지 정말 긴 여정이었어. 라라벨로 블록체인 결제 관리자 페이지를 만드는 방법을 처음부터 끝까지 다뤄봤어. 🎉

이제 너도 Web3 시대의 개발자로서 블록체인 기반 결제 시스템을 구축할 수 있게 됐어! 물론 처음에는 어려울 수 있지만, 하나씩 차근차근 따라하다 보면 금방 익숙해질 거야.

핵심 포인트를 다시 정리하면:

혹시 블록체인 개발이나 Web3 프로젝트에 관심이 있다면, 재능넷(https://www.jaenung.net)에서 관련 전문가들을 만나볼 수 있어. 스마트 컨트랙트 개발, 블록체인 컨설팅, NFT 프로젝트 등 다양한 재능을 거래할 수 있는 플랫폼이니까 한번 둘러보는 것도 좋을 거야!

그리고 이 글에서 다룬 내용은 기본적인 구조와 개념이야. 실제 프로덕션 환경에서는 더 많은 고려사항들이 있어. 예를 들면:

이런 기능들을 추가하면 더욱 강력한 시스템이 될 거야. 하지만 처음부터 모든 걸 다 구현하려고 하지 말고, MVP(Minimum Viable Product)부터 만들어서 점진적으로 개선해 나가는 게 좋아.

블록체인 기술은 계속 발전하고 있어. 새로운 프로토콜, 더 빠른 네트워크, 더 저렴한 수수료... 이런 변화들을 계속 주시하면서 시스템을 업데이트해 나가야 해.

마지막으로, 개발하면서 막히는 부분이 있으면 공식 문서를 꼭 읽어봐. 라라벨 공식 문서(https://laravel.com/docs)와 Web3.js 문서(https://web3js.readthedocs.io)는 정말 잘 되어 있어. 그리고 커뮤니티에 질문하는 것도 좋은 방법이야!

자, 이제 정말로 끝이야! 너의 블록체인 결제 시스템 개발을 응원할게. 화이팅! 💪✨