🎯 왜 라라벨인가?

먼저 왜 수많은 프레임워크 중에서 라라벨을 선택했는지 이야기해볼게. 사실 NFT 대시보드를 만들 수 있는 방법은 정말 많아. Node.js, Django, Ruby on Rails 등등... 그런데 라라벨이 특히 좋은 이유가 있어! 🌟

🏗️ 프로젝트 아키텍처 설계하기

본격적으로 코딩하기 전에, 우리 프로젝트의 전체 구조를 먼저 설계해야 해. 이게 정말 중요한데, 나중에 기능을 추가하거나 수정할 때 훨씬 편해지거든! 🏛️

⚙️ 개발 환경 세팅하기

자, 이제 실제로 손을 더럽혀볼 시간이야! 개발 환경을 세팅하는 것부터 시작해보자. 이 과정이 좀 지루할 수 있지만, 제대로 세팅해두면 나중에 정말 편해져. 😊

composer create-project laravel/laravel nft-dashboard
cd nft-dashboard
php artisan --version

마지막 명령어로 라라벨이 제대로 설치되었는지 확인할 수 있어. Laravel Framework 10.x.x 같은 메시지가 나오면 성공이야! 🎉

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nft_dashboard
DB_USERNAME=your_username
DB_PASSWORD=your_password

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

QUEUE_CONNECTION=redis
CACHE_DRIVER=redis
SESSION_DRIVER=redis

여기서 중요한 건 QUEUE_CONNECTION과 CACHE_DRIVER를 Redis로 설정하는 거야. 이렇게 하면 백그라운드 작업과 캐싱이 훨씬 빨라져! ⚡

# HTTP 클라이언트 (API 호출용)
composer require guzzlehttp/guzzle

# 큐 모니터링
composer require laravel/horizon

# API 리소스 변환
composer require spatie/laravel-query-builder

# 데이터 검증 및 변환
composer require spatie/laravel-data

# WebSocket 지원
composer require beyondcode/laravel-websockets

# 스케줄링 모니터링
composer require spatie/laravel-schedule-monitor

이 패키지들은 각각 특별한 역할을 해. 특히 Laravel Horizon은 큐 작업을 모니터링하는 데 정말 유용해. NFT 데이터를 백그라운드에서 수집할 때 어떤 작업이 진행 중인지 한눈에 볼 수 있거든! 👀

🗄️ 데이터베이스 마이그레이션 작성하기

이제 본격적으로 데이터베이스 구조를 만들어볼 거야. 라라벨의 마이그레이션 시스템을 사용하면 데이터베이스 스키마를 코드로 관리할 수 있어서 정말 편해! 🏗️

php artisan make:migration create_collections_table
php artisan make:migration create_nft_items_table
php artisan make:migration create_transactions_table
php artisan make:migration create_analytics_table

이제 각 마이그레이션 파일을 열어서 테이블 구조를 정의해야 해. 하나씩 살펴보자!

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('collections', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('slug')->unique();
            $table->string('contract_address')->unique();
            $table->string('blockchain')->default('ethereum');
            $table->text('description')->nullable();
            $table->string('image_url')->nullable();
            $table->string('banner_url')->nullable();
            $table->decimal('floor_price', 20, 8)->default(0);
            $table->decimal('volume_24h', 20, 8)->default(0);
            $table->decimal('volume_7d', 20, 8)->default(0);
            $table->decimal('volume_30d', 20, 8)->default(0);
            $table->decimal('volume_total', 20, 8)->default(0);
            $table->integer('total_supply')->default(0);
            $table->integer('owners_count')->default(0);
            $table->decimal('average_price', 20, 8)->default(0);
            $table->json('metadata')->nullable();
            $table->timestamp('last_synced_at')->nullable();
            $table->timestamps();
            
            // 인덱스 추가
            $table->index('blockchain');
            $table->index('floor_price');
            $table->index('volume_24h');
            $table->index('last_synced_at');
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('collections');
    }
};

여기서 주목할 점이 몇 가지 있어:

1. decimal 타입 사용
가격 정보는 decimal(20, 8)로 저장해. 암호화폐는 소수점 이하 자릿수가 많아서 float나 double을 사용하면 정확도 문제가 생길 수 있거든! 💰

2. JSON 컬럼
metadata 컬럼은 JSON 타입으로 만들어. NFT 컬렉션마다 다른 속성들을 유연하게 저장할 수 있어.

3. 인덱스 추가
자주 검색하거나 정렬할 컬럼에는 인덱스를 추가해야 해. 특히 floor_price나 volume_24h 같은 컬럼은 대시보드에서 자주 사용되니까 꼭 인덱스를 걸어줘야 해!

Schema::create('nft_items', function (Blueprint $table) {
    $table->id();
    $table->foreignId('collection_id')->constrained()->onDelete('cascade');
    $table->string('token_id');
    $table->string('owner_address')->index();
    $table->string('token_uri')->nullable();
    $table->string('image_url')->nullable();
    $table->string('name')->nullable();
    $table->text('description')->nullable();
    $table->json('attributes')->nullable();
    $table->decimal('last_price', 20, 8)->nullable();
    $table->decimal('highest_price', 20, 8)->nullable();
    $table->integer('transfer_count')->default(0);
    $table->timestamp('last_transfer_at')->nullable();
    $table->boolean('is_listed')->default(false);
    $table->decimal('listing_price', 20, 8)->nullable();
    $table->string('listing_marketplace')->nullable();
    $table->timestamps();
    
    // 복합 유니크 인덱스
    $table->unique(['collection_id', 'token_id']);
    $table->index('is_listed');
    $table->index('last_price');
});

여기서 foreignId를 사용해서 collections 테이블과 관계를 설정했어. onDelete('cascade')를 추가하면 컬렉션이 삭제될 때 관련된 NFT 아이템들도 자동으로 삭제돼. 편리하지? 😊

Schema::create('transactions', function (Blueprint $table) {
    $table->id();
    $table->foreignId('nft_item_id')->constrained()->onDelete('cascade');
    $table->string('transaction_hash')->unique();
    $table->string('from_address')->index();
    $table->string('to_address')->index();
    $table->decimal('price', 20, 8);
    $table->string('currency')->default('ETH');
    $table->decimal('price_usd', 20, 2)->nullable();
    $table->string('marketplace')->nullable();
    $table->enum('transaction_type', ['sale', 'transfer', 'mint', 'burn']);
    $table->integer('block_number');
    $table->timestamp('transaction_date');
    $table->json('raw_data')->nullable();
    $table->timestamps();
    
    $table->index('transaction_date');
    $table->index('price');
    $table->index('transaction_type');
});

transaction_hash는 블록체인에서 고유한 값이니까 유니크 인덱스를 걸어줬어. 그리고 transaction_date로 시계열 분석을 할 거니까 이것도 인덱스를 추가했어! 📊

Schema::create('analytics', function (Blueprint $table) {
    $table->id();
    $table->foreignId('collection_id')->constrained()->onDelete('cascade');
    $table->date('date');
    $table->decimal('floor_price', 20, 8);
    $table->decimal('average_price', 20, 8);
    $table->decimal('highest_price', 20, 8);
    $table->decimal('lowest_price', 20, 8);
    $table->decimal('total_volume', 20, 8);
    $table->integer('sales_count');
    $table->integer('unique_buyers');
    $table->integer('unique_sellers');
    $table->decimal('market_cap', 20, 8)->nullable();
    $table->timestamps();
    
    $table->unique(['collection_id', 'date']);
    $table->index('date');
});

collection_id와 date의 조합을 유니크로 설정했어. 같은 날짜에 같은 컬렉션의 통계가 중복으로 저장되는 걸 방지하기 위해서야!

php artisan migrate

에러 없이 실행되면 성공이야! 데이터베이스에 테이블들이 생성되었을 거야. 확인하고 싶으면 MySQL 클라이언트나 phpMyAdmin으로 들어가서 확인해봐. 🎯

🎨 Eloquent 모델 만들기

데이터베이스 테이블을 만들었으니 이제 라라벨의 Eloquent ORM을 사용해서 모델을 만들어야 해. 모델은 데이터베이스와 상호작용하는 인터페이스 역할을 해. 정말 강력한 기능이야! 💪

php artisan make:model Collection
php artisan make:model NftItem
php artisan make:model Transaction
php artisan make:model Analytics

이제 각 모델 파일을 열어서 관계(Relationship)와 속성들을 정의해보자!

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Collection extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'slug',
        'contract_address',
        'blockchain',
        'description',
        'image_url',
        'banner_url',
        'floor_price',
        'volume_24h',
        'volume_7d',
        'volume_30d',
        'volume_total',
        'total_supply',
        'owners_count',
        'average_price',
        'metadata',
        'last_synced_at',
    ];

    protected $casts = [
        'floor_price' => 'decimal:8',
        'volume_24h' => 'decimal:8',
        'volume_7d' => 'decimal:8',
        'volume_30d' => 'decimal:8',
        'volume_total' => 'decimal:8',
        'average_price' => 'decimal:8',
        'metadata' => 'array',
        'last_synced_at' => 'datetime',
    ];

    // 관계 정의
    public function nftItems(): HasMany
    {
        return $this->hasMany(NftItem::class);
    }

    public function transactions(): HasMany
    {
        return $this->hasManyThrough(Transaction::class, NftItem::class);
    }

    public function analytics(): HasMany
    {
        return $this->hasMany(Analytics::class);
    }

    // 헬퍼 메서드
    public function getFloorPriceInUsdAttribute(): float
    {
        // ETH 가격을 USD로 변환 (실제로는 API에서 환율을 가져와야 함)
        $ethToUsd = 2000; // 예시 환율
        return $this->floor_price * $ethToUsd;
    }

    public function getVolumeChangePercentageAttribute(): float
    {
        if ($this->volume_7d == 0) {
            return 0;
        }
        return (($this->volume_24h * 7 - $this->volume_7d) / $this->volume_7d) * 100;
    }

    // 스코프
    public function scopePopular($query)
    {
        return $query->orderBy('volume_24h', 'desc');
    }

    public function scopeTrending($query)
    {
        return $query->where('volume_24h', '>', 0)
                     ->orderByRaw('(volume_24h / NULLIF(volume_7d, 0)) DESC');
    }
}

와, 코드가 좀 길지? 하나씩 설명해줄게! 😊

$fillable 속성
대량 할당(Mass Assignment)을 허용할 컬럼들을 정의해. 보안을 위해 꼭 필요한 컬럼만 포함시켜야 해!

$casts 속성
데이터베이스에서 가져온 값을 자동으로 변환해줘. metadata는 JSON으로 저장되지만 배열로 자동 변환되고, 날짜는 Carbon 인스턴스로 변환돼.

관계 메서드
hasMany로 일대다 관계를 정의했어. 하나의 컬렉션은 여러 NFT 아이템을 가질 수 있지!

Accessor (접근자)
getFloorPriceInUsdAttribute 같은 메서드는 가상 속성을 만들어줘. $collection->floor_price_in_usd로 접근할 수 있어!

Query Scope
scopePopular 같은 메서드는 재사용 가능한 쿼리를 만들어줘. Collection::popular()->get()처럼 사용할 수 있어!

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;

class NftItem extends Model
{
    protected $fillable = [
        'collection_id',
        'token_id',
        'owner_address',
        'token_uri',
        'image_url',
        'name',
        'description',
        'attributes',
        'last_price',
        'highest_price',
        'transfer_count',
        'last_transfer_at',
        'is_listed',
        'listing_price',
        'listing_marketplace',
    ];

    protected $casts = [
        'attributes' => 'array',
        'last_price' => 'decimal:8',
        'highest_price' => 'decimal:8',
        'listing_price' => 'decimal:8',
        'is_listed' => 'boolean',
        'last_transfer_at' => 'datetime',
    ];

    public function collection(): BelongsTo
    {
        return $this->belongsTo(Collection::class);
    }

    public function transactions(): HasMany
    {
        return $this->hasMany(Transaction::class);
    }

    // 가격 변동률 계산
    public function getPriceChangePercentageAttribute(): ?float
    {
        if (!$this->last_price || !$this->highest_price) {
            return null;
        }
        return (($this->last_price - $this->highest_price) / $this->highest_price) * 100;
    }

    // 희귀도 점수 계산 (attributes 기반)
    public function getRarityScoreAttribute(): float
    {
        if (!$this->attributes) {
            return 0;
        }
        
        $score = 0;
        foreach ($this->attributes as $attribute) {
            // 실제로는 더 복잡한 희귀도 계산 로직이 필요함
            $score += 1 / ($attribute['occurrence'] ?? 1);
        }
        
        return $score;
    }

    public function scopeListed($query)
    {
        return $query->where('is_listed', true);
    }

    public function scopeByOwner($query, string $address)
    {
        return $query->where('owner_address', $address);
    }
}

NFT 아이템 모델에는 희귀도 점수를 계산하는 로직도 추가했어. 실제로는 더 정교한 알고리즘이 필요하지만, 기본 개념은 이해했을 거야! 🎯

🔌 블록체인 API 연동하기

자, 이제 진짜 재미있는 부분이야! 실제 블록체인 데이터를 가져와보자. 여러 API 서비스가 있는데, 우리는 OpenSea API와 Alchemy를 사용할 거야. 🌐

OPENSEA_API_KEY=your_opensea_api_key
ALCHEMY_API_KEY=your_alchemy_api_key
ETHERSCAN_API_KEY=your_etherscan_api_key

mkdir app/Services
touch app/Services/OpenSeaService.php
touch app/Services/AlchemyService.php

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;

class OpenSeaService
{
    private string $baseUrl = 'https://api.opensea.io/api/v2';
    private string $apiKey;

    public function __construct()
    {
        $this->apiKey = config('services.opensea.api_key');
    }

    /**
     * 컬렉션 정보 가져오기
     */
    public function getCollection(string $slug): ?array
    {
        $cacheKey = "opensea_collection_{$slug}";
        
        return Cache::remember($cacheKey, 3600, function () use ($slug) {
            $response = Http::withHeaders([
                'X-API-KEY' => $this->apiKey,
            ])->get("{$this->baseUrl}/collections/{$slug}");

            if ($response->successful()) {
                return $response->json();
            }

            return null;
        });
    }

    /**
     * 컬렉션 통계 가져오기
     */
    public function getCollectionStats(string $slug): ?array
    {
        $cacheKey = "opensea_stats_{$slug}";
        
        return Cache::remember($cacheKey, 300, function () use ($slug) {
            $response = Http::withHeaders([
                'X-API-KEY' => $this->apiKey,
            ])->get("{$this->baseUrl}/collections/{$slug}/stats");

            if ($response->successful()) {
                return $response->json()['stats'] ?? null;
            }

            return null;
        });
    }

    /**
     * NFT 아이템 정보 가져오기
     */
    public function getNFT(string $contractAddress, string $tokenId): ?array
    {
        $cacheKey = "opensea_nft_{$contractAddress}_{$tokenId}";
        
        return Cache::remember($cacheKey, 1800, function () use ($contractAddress, $tokenId) {
            $response = Http::withHeaders([
                'X-API-KEY' => $this->apiKey,
            ])->get("{$this->baseUrl}/chain/ethereum/contract/{$contractAddress}/nfts/{$tokenId}");

            if ($response->successful()) {
                return $response->json()['nft'] ?? null;
            }

            return null;
        });
    }

    /**
     * 최근 거래 내역 가져오기
     */
    public function getRecentSales(string $contractAddress, int $limit = 50): array
    {
        $response = Http::withHeaders([
            'X-API-KEY' => $this->apiKey,
        ])->get("{$this->baseUrl}/events/chain/ethereum/contract/{$contractAddress}", [
            'event_type' => 'sale',
            'limit' => $limit,
        ]);

        if ($response->successful()) {
            return $response->json()['asset_events'] ?? [];
        }

        return [];
    }

    /**
     * 트렌딩 컬렉션 가져오기
     */
    public function getTrendingCollections(int $limit = 10): array
    {
        $cacheKey = "opensea_trending_{$limit}";
        
        return Cache::remember($cacheKey, 600, function () use ($limit) {
            $response = Http::withHeaders([
                'X-API-KEY' => $this->apiKey,
            ])->get("{$this->baseUrl}/collections", [
                'order_by' => 'seven_day_volume',
                'limit' => $limit,
            ]);

            if ($response->successful()) {
                return $response->json()['collections'] ?? [];
            }

            return [];
        });
    }
}

여기서 중요한 포인트는 캐싱이야! API 호출은 비용이 들고 느릴 수 있어서, Redis 캐시를 사용해서 같은 요청을 반복하지 않도록 했어. 특히 컬렉션 정보 같은 건 자주 바뀌지 않으니까 1시간(3600초) 동안 캐시해도 괜찮아! ⚡

namespace App\Services;

use Illuminate\Support\Facades\Http;

class AlchemyService
{
    private string $baseUrl;
    private string $apiKey;

    public function __construct()
    {
        $this->apiKey = config('services.alchemy.api_key');
        $this->baseUrl = "https://eth-mainnet.g.alchemy.com/v2/{$this->apiKey}";
    }

    /**
     * NFT 메타데이터 가져오기
     */
    public function getNFTMetadata(string $contractAddress, string $tokenId): ?array
    {
        $response = Http::get("{$this->baseUrl}/getNFTMetadata", [
            'contractAddress' => $contractAddress,
            'tokenId' => $tokenId,
            'tokenType' => 'ERC721',
        ]);

        if ($response->successful()) {
            return $response->json();
        }

        return null;
    }

    /**
     * 컬렉션의 모든 NFT 가져오기 (페이지네이션)
     */
    public function getNFTsForCollection(
        string $contractAddress, 
        ?string $pageKey = null,
        int $limit = 100
    ): array {
        $params = [
            'contractAddress' => $contractAddress,
            'withMetadata' => true,
            'limit' => $limit,
        ];

        if ($pageKey) {
            $params['pageKey'] = $pageKey;
        }

        $response = Http::get("{$this->baseUrl}/getNFTsForCollection", $params);

        if ($response->successful()) {
            return $response->json();
        }

        return ['nfts' => [], 'pageKey' => null];
    }

    /**
     * 소유자의 NFT 목록 가져오기
     */
    public function getNFTsForOwner(string $ownerAddress): array
    {
        $response = Http::get("{$this->baseUrl}/getNFTs", [
            'owner' => $ownerAddress,
            'withMetadata' => true,
        ]);

        if ($response->successful()) {
            return $response->json()['ownedNfts'] ?? [];
        }

        return [];
    }

    /**
     * 트랜잭션 영수증 가져오기
     */
    public function getTransactionReceipt(string $txHash): ?array
    {
        $response = Http::post($this->baseUrl, [
            'jsonrpc' => '2.0',
            'id' => 1,
            'method' => 'eth_getTransactionReceipt',
            'params' => [$txHash],
        ]);

        if ($response->successful()) {
            return $response->json()['result'];
        }

        return null;
    }

    /**
     * 블록 번호로 NFT 전송 이벤트 가져오기
     */
    public function getNFTTransfers(
        string $contractAddress,
        int $fromBlock,
        int $toBlock
    ): array {
        $response = Http::post($this->baseUrl, [
            'jsonrpc' => '2.0',
            'id' => 1,
            'method' => 'alchemy_getAssetTransfers',
            'params' => [
                [
                    'fromBlock' => '0x' . dechex($fromBlock),
                    'toBlock' => '0x' . dechex($toBlock),
                    'contractAddresses' => [$contractAddress],
                    'category' => ['erc721', 'erc1155'],
                    'withMetadata' => true,
                ]
            ],
        ]);

        if ($response->successful()) {
            return $response->json()['result']['transfers'] ?? [];
        }

        return [];
    }
}

Alchemy는 더 로우레벨의 블록체인 데이터에 접근할 수 있어. 특히 getNFTTransfers 메서드는 특정 블록 범위의 모든 NFT 전송을 추적할 수 있어서 정말 유용해! 🔍

return [
    // ... 기존 설정들

    'opensea' => [
        'api_key' => env('OPENSEA_API_KEY'),
    ],

    'alchemy' => [
        'api_key' => env('ALCHEMY_API_KEY'),
    ],

    'etherscan' => [
        'api_key' => env('ETHERSCAN_API_KEY'),
    ],
];

⚙️ 데이터 수집 Job 만들기

API 서비스를 만들었으니 이제 실제로 데이터를 수집하는 Job을 만들어야 해. 라라벨의 큐 시스템을 사용하면 백그라운드에서 효율적으로 데이터를 수집할 수 있어! 🚀

php artisan make:job SyncCollectionData
php artisan make:job SyncNFTItems
php artisan make:job SyncTransactions
php artisan make:job CalculateAnalytics

namespace App\Jobs;

use App\Models\Collection;
use App\Services\OpenSeaService;
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 SyncCollectionData implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 3;
    public $timeout = 120;

    public function __construct(
        private string $collectionSlug
    ) {}

    public function handle(OpenSeaService $openSea): void
    {
        try {
            // 컬렉션 정보 가져오기
            $collectionData = $openSea->getCollection($this->collectionSlug);
            if (!$collectionData) {
                Log::warning("Collection not found: {$this->collectionSlug}");
                return;
            }

            // 통계 정보 가져오기
            $stats = $openSea->getCollectionStats($this->collectionSlug);

            // 데이터베이스 업데이트
            $collection = Collection::updateOrCreate(
                ['slug' => $this->collectionSlug],
                [
                    'name' => $collectionData['name'] ?? '',
                    'contract_address' => $collectionData['primary_asset_contracts'][0]['address'] ?? '',
                    'description' => $collectionData['description'] ?? '',
                    'image_url' => $collectionData['image_url'] ?? '',
                    'banner_url' => $collectionData['banner_image_url'] ?? '',
                    'floor_price' => $stats['floor_price'] ?? 0,
                    'volume_24h' => $stats['one_day_volume'] ?? 0,
                    'volume_7d' => $stats['seven_day_volume'] ?? 0,
                    'volume_30d' => $stats['thirty_day_volume'] ?? 0,
                    'volume_total' => $stats['total_volume'] ?? 0,
                    'total_supply' => $stats['total_supply'] ?? 0,
                    'owners_count' => $stats['num_owners'] ?? 0,
                    'average_price' => $stats['average_price'] ?? 0,
                    'metadata' => [
                        'discord_url' => $collectionData['discord_url'] ?? null,
                        'twitter_username' => $collectionData['twitter_username'] ?? null,
                        'instagram_username' => $collectionData['instagram_username'] ?? null,
                        'external_url' => $collectionData['external_url'] ?? null,
                    ],
                    'last_synced_at' => now(),
                ]
            );

            Log::info("Collection synced: {$collection->name}");

            // NFT 아이템 동기화 Job 디스패치
            SyncNFTItems::dispatch($collection->id)->delay(now()->addSeconds(5));

        } catch (\Exception $e) {
            Log::error("Error syncing collection {$this->collectionSlug}: " . $e->getMessage());
            throw $e;
        }
    }

    public function failed(\Throwable $exception): void
    {
        Log::error("Failed to sync collection {$this->collectionSlug}: " . $exception->getMessage());
    }
}

여기서 주목할 점들:

1. 재시도 로직
$tries = 3으로 설정해서 실패하면 최대 3번까지 재시도해. API가 일시적으로 다운되었을 때 유용해!

2. 타임아웃
$timeout = 120으로 2분 제한을 둬. 너무 오래 걸리는 작업은 자동으로 실패 처리돼.

3. 체이닝
컬렉션 동기화가 끝나면 자동으로 NFT 아이템 동기화 Job을 디스패치해. 5초 딜레이를 줘서 API Rate Limit을 피해! 🎯

4. 에러 핸들링
failed() 메서드로 실패한 Job을 로깅해. 나중에 문제를 추적하기 쉬워져.

namespace App\Jobs;

use App\Models\Collection;
use App\Models\NftItem;
use App\Services\AlchemyService;
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 SyncNFTItems implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 3;
    public $timeout = 300;

    public function __construct(
        private int $collectionId
    ) {}

    public function handle(AlchemyService $alchemy): void
    {
        $collection = Collection::find($this->collectionId);
        if (!$collection) {
            return;
        }

        try {
            $pageKey = null;
            $totalSynced = 0;

            do {
                // 페이지네이션으로 NFT 가져오기
                $result = $alchemy->getNFTsForCollection(
                    $collection->contract_address,
                    $pageKey,
                    100
                );

                foreach ($result['nfts'] ?? [] as $nftData) {
                    $this->syncNFTItem($collection, $nftData);
                    $totalSynced++;
                }

                $pageKey = $result['pageKey'] ?? null;

                // Rate limiting을 위한 짧은 대기
                if ($pageKey) {
                    sleep(1);
                }

            } while ($pageKey && $totalSynced < 1000); // 최대 1000개까지만

            Log::info("Synced {$totalSynced} NFT items for collection: {$collection->name}");

        } catch (\Exception $e) {
            Log::error("Error syncing NFT items for collection {$this->collectionId}: " . $e->getMessage());
            throw $e;
        }
    }

    private function syncNFTItem(Collection $collection, array $nftData): void
    {
        $tokenId = $nftData['id']['tokenId'] ?? null;
        if (!$tokenId) {
            return;
        }

        NftItem::updateOrCreate(
            [
                'collection_id' => $collection->id,
                'token_id' => $tokenId,
            ],
            [
                'owner_address' => $nftData['contract']['address'] ?? '',
                'token_uri' => $nftData['tokenUri']['raw'] ?? '',
                'image_url' => $nftData['media'][0]['gateway'] ?? '',
                'name' => $nftData['title'] ?? "#{$tokenId}",
                'description' => $nftData['description'] ?? '',
                'attributes' => $nftData['metadata']['attributes'] ?? [],
            ]
        );
    }
}

NFT 아이템은 수가 정말 많을 수 있어서 페이지네이션을 사용했어. 한 번에 100개씩 가져오고, 각 페이지 사이에 1초씩 대기해서 API Rate Limit을 피해! 💤

namespace App\Jobs;

use App\Models\Collection;
use App\Models\NftItem;
use App\Models\Transaction;
use App\Services\OpenSeaService;
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 SyncTransactions implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 3;
    public $timeout = 180;

    public function __construct(
        private int $collectionId
    ) {}

    public function handle(OpenSeaService $openSea): void
    {
        $collection = Collection::find($this->collectionId);
        if (!$collection) {
            return;
        }

        try {
            $sales = $openSea->getRecentSales($collection->contract_address, 100);
            $syncedCount = 0;

            foreach ($sales as $sale) {
                if ($this->syncTransaction($collection, $sale)) {
                    $syncedCount++;
                }
            }

            Log::info("Synced {$syncedCount} transactions for collection: {$collection->name}");

            // 통계 계산 Job 디스패치
            CalculateAnalytics::dispatch($collection->id)->delay(now()->addMinutes(1));

        } catch (\Exception $e) {
            Log::error("Error syncing transactions for collection {$this->collectionId}: " . $e->getMessage());
            throw $e;
        }
    }

    private function syncTransaction(Collection $collection, array $saleData): bool
    {
        $txHash = $saleData['transaction']['transaction_hash'] ?? null;
        if (!$txHash) {
            return false;
        }

        // 이미 존재하는 거래는 스킵
        if (Transaction::where('transaction_hash', $txHash)->exists()) {
            return false;
        }

        $tokenId = $saleData['nft']['identifier'] ?? null;
        if (!$tokenId) {
            return false;
        }

        // NFT 아이템 찾기
        $nftItem = NftItem::where('collection_id', $collection->id)
            ->where('token_id', $tokenId)
            ->first();

        if (!$nftItem) {
            return false;
        }

        // 가격 정보 추출
        $payment = $saleData['payment'] ?? [];
        $price = isset($payment['quantity']) ? 
            $payment['quantity'] / pow(10, $payment['decimals'] ?? 18) : 0;

        Transaction::create([
            'nft_item_id' => $nftItem->id,
            'transaction_hash' => $txHash,
            'from_address' => $saleData['seller']['address'] ?? '',
            'to_address' => $saleData['winner_account']['address'] ?? '',
            'price' => $price,
            'currency' => $payment['symbol'] ?? 'ETH',
            'price_usd' => $saleData['payment']['usd_price'] ?? null,
            'marketplace' => 'OpenSea',
            'transaction_type' => 'sale',
            'block_number' => $saleData['transaction']['block_number'] ?? 0,
            'transaction_date' => $saleData['event_timestamp'] ?? now(),
            'raw_data' => $saleData,
        ]);

        // NFT 아이템의 최근 가격 업데이트
        $nftItem->update([
            'last_price' => $price,
            'highest_price' => max($nftItem->highest_price ?? 0, $price),
            'transfer_count' => $nftItem->transfer_count + 1,
            'last_transfer_at' => now(),
        ]);

        return true;
    }
}

거래 데이터를 동기화하면서 NFT 아이템의 가격 정보도 함께 업데이트해. 이렇게 하면 최신 가격을 빠르게 조회할 수 있어! 📈

📊 통계 분석 로직 구현하기

이제 수집한 데이터를 분석해서 의미 있는 통계를 만들어보자! 이 부분이 대시보드의 핵심이야. 🎯

namespace App\Jobs;

use App\Models\Analytics;
use App\Models\Collection;
use App\Models\Transaction;
use Carbon\Carbon;
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\DB;
use Illuminate\Support\Facades\Log;

class CalculateAnalytics implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 2;
    public $timeout = 300;

    public function __construct(
        private int $collectionId,
        private ?Carbon $date = null
    ) {
        $this->date = $this->date ?? now()->subDay();
    }

    public function handle(): void
    {
        $collection = Collection::find($this->collectionId);
        if (!$collection) {
            return;
        }

        try {
            $analytics = $this->calculateDailyAnalytics($collection, $this->date);
            
            Analytics::updateOrCreate(
                [
                    'collection_id' => $collection->id,
                    'date' => $this->date->toDateString(),
                ],
                $analytics
            );

            Log::info("Calculated analytics for {$collection->name} on {$this->date->toDateString()}");

        } catch (\Exception $e) {
            Log::error("Error calculating analytics: " . $e->getMessage());
            throw $e;
        }
    }

    private function calculateDailyAnalytics(Collection $collection, Carbon $date): array
    {
        $startOfDay = $date->copy()->startOfDay();
        $endOfDay = $date->copy()->endOfDay();

        // 해당 날짜의 모든 거래 가져오기
        $transactions = Transaction::whereHas('nftItem', function ($query) use ($collection) {
                $query->where('collection_id', $collection->id);
            })
            ->whereBetween('transaction_date', [$startOfDay, $endOfDay])
            ->where('transaction_type', 'sale')
            ->get();

        if ($transactions->isEmpty()) {
            return $this->getEmptyAnalytics();
        }

        // 기본 통계 계산
        $prices = $transactions->pluck('price');
        $totalVolume = $prices->sum();
        $salesCount = $transactions->count();
        $averagePrice = $prices->average();
        $floorPrice = $prices->min();
        $highestPrice = $prices->max();
        $lowestPrice = $prices->min();

        // 고유 구매자/판매자 수
        $uniqueBuyers = $transactions->pluck('to_address')->unique()->count();
        $uniqueSellers = $transactions->pluck('from_address')->unique()->count();

        // 시가총액 계산 (floor price * total supply)
        $marketCap = $floorPrice * $collection->total_supply;

        return [
            'floor_price' => $floorPrice,
            'average_price' => $averagePrice,
            'highest_price' => $highestPrice,
            'lowest_price' => $lowestPrice,
            'total_volume' => $totalVolume,
            'sales_count' => $salesCount,
            'unique_buyers' => $uniqueBuyers,
            'unique_sellers' => $uniqueSellers,
            'market_cap' => $marketCap,
        ];
    }

    private function getEmptyAnalytics(): array
    {
        return [
            'floor_price' => 0,
            'average_price' => 0,
            'highest_price' => 0,
            'lowest_price' => 0,
            'total_volume' => 0,
            'sales_count' => 0,
            'unique_buyers' => 0,
            'unique_sellers' => 0,
            'market_cap' => 0,
        ];
    }
}

이 Job은 하루 단위로 통계를 계산해. 매일 자정에 실행되도록 스케줄링하면 돼! 📅

namespace App\Console;

use App\Jobs\CalculateAnalytics;
use App\Jobs\SyncCollectionData;
use App\Models\Collection;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule): void
    {
        // 매시간마다 모든 컬렉션의 데이터 동기화
        $schedule->call(function () {
            Collection::all()->each(function ($collection) {
                SyncCollectionData::dispatch($collection->slug);
            });
        })->hourly();

        // 매일 자정에 전날 통계 계산
        $schedule->call(function () {
            Collection::all()->each(function ($collection) {
                CalculateAnalytics::dispatch($collection->id);
            });
        })->dailyAt('00:30');

        // Horizon 스냅샷 (큐 모니터링용)
        $schedule->command('horizon:snapshot')->everyFiveMinutes();

        // 실패한 Job 정리
        $schedule->command('queue:prune-failed --hours=48')->daily();
    }
}

스케줄러가 작동하려면 서버의 cron에 다음 명령어를 추가해야 해:

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

이렇게 하면 매분마다 라라벨 스케줄러가 실행되고, 설정한 시간에 맞춰서 Job들이 자동으로 실행돼! ⏰

🎨 API 엔드포인트 만들기

백엔드에서 데이터를 수집하고 처리했으니, 이제 프론트엔드에서 사용할 API를 만들어야 해. RESTful API를 설계해보자! 🌐

php artisan make:controller Api/CollectionController
php artisan make:controller Api/NftItemController
php artisan make:controller Api/AnalyticsController
php artisan make:controller Api/DashboardController

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Collection;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class CollectionController extends Controller
{
    /**
     * 컬렉션 목록 조회
     */
    public function index(Request $request): JsonResponse
    {
        $query = Collection::query();

        // 필터링
        if ($request->has('blockchain')) {
            $query->where('blockchain', $request->blockchain);
        }

        // 정렬
        $sortBy = $request->get('sort_by', 'volume_24h');
        $sortOrder = $request->get('sort_order', 'desc');
        $query->orderBy($sortBy, $sortOrder);

        // 페이지네이션
        $perPage = min($request->get('per_page', 20), 100);
        $collections = $query->paginate($perPage);

        return response()->json($collections);
    }

    /**
     * 특정 컬렉션 상세 조회
     */
    public function show(string $slug): JsonResponse
    {
        $collection = Collection::where('slug', $slug)
            ->with(['analytics' => function ($query) {
                $query->orderBy('date', 'desc')->limit(30);
            }])
            ->firstOrFail();

        return response()->json([
            'collection' => $collection,
            'stats' => [
                'floor_price' => $collection->floor_price,
                'volume_24h' => $collection->volume_24h,
                'volume_7d' => $collection->volume_7d,
                'owners_count' => $collection->owners_count,
                'total_supply' => $collection->total_supply,
                'average_price' => $collection->average_price,
            ],
        ]);
    }

    /**
     * 트렌딩 컬렉션
     */
    public function trending(): JsonResponse
    {
        $collections = Collection::trending()
            ->limit(10)
            ->get();

        return response()->json($collections);
    }

    /**
     * 인기 컬렉션
     */
    public function popular(): JsonResponse
    {
        $collections = Collection::popular()
            ->limit(10)
            ->get();

        return response()->json($collections);
    }
}

API 컨트롤러는 간단하게 유지하는 게 좋아. 복잡한 로직은 Service 클래스나 Model에 넣고, 컨트롤러는 요청을 받아서 응답만 돌려주는 역할만 해야 해! 🎯

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Analytics;
use App\Models\Collection;
use Carbon\Carbon;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class AnalyticsController extends Controller
{
    /**
     * 컬렉션의 시계열 데이터
     */
    public function timeSeries(string $slug, Request $request): JsonResponse
    {
        $collection = Collection::where('slug', $slug)->firstOrFail();
        
        $days = min($request->get('days', 30), 365);
        $startDate = now()->subDays($days);

        $analytics = Analytics::where('collection_id', $collection->id)
            ->where('date', '>=', $startDate)
            ->orderBy('date', 'asc')
            ->get();

        return response()->json([
            'collection' => $collection->only(['name', 'slug', 'image_url']),
            'period' => [
                'start' => $startDate->toDateString(),
                'end' => now()->toDateString(),
                'days' => $days,
            ],
            'data' => $analytics->map(function ($item) {
                return [
                    'date' => $item->date,
                    'floor_price' => $item->floor_price,
                    'average_price' => $item->average_price,
                    'volume' => $item->total_volume,
                    'sales_count' => $item->sales_count,
                ];
            }),
        ]);
    }

    /**
     * 가격 변동 분석
     */
    public function priceChange(string $slug): JsonResponse
    {
        $collection = Collection::where('slug', $slug)->firstOrFail();

        $today = Analytics::where('collection_id', $collection->id)
            ->whereDate('date', today())
            ->first();

        $yesterday = Analytics::where('collection_id', $collection->id)
            ->whereDate('date', today()->subDay())
            ->first();

        $weekAgo = Analytics::where('collection_id', $collection->id)
            ->whereDate('date', today()->subWeek())
            ->first();

        return response()->json([
            'current_floor_price' => $collection->floor_price,
            'changes' => [
                '24h' => $this->calculateChange($yesterday?->floor_price, $today?->floor_price),
                '7d' => $this->calculateChange($weekAgo?->floor_price, $today?->floor_price),
            ],
            'volume_changes' => [
                '24h' => $this->calculateChange($yesterday?->total_volume, $today?->total_volume),
                '7d' => $this->calculateChange($weekAgo?->total_volume, $today?->total_volume),
            ],
        ]);
    }

    private function calculateChange(?float $old, ?float $new): array
    {
        if (!$old || !$new) {
            return ['value' => 0, 'percentage' => 0];
        }

        $change = $new - $old;
        $percentage = ($change / $old) * 100;

        return [
            'value' => round($change, 4),
            'percentage' => round($percentage, 2),
        ];
    }

    /**
     * 시장 개요
     */
    public function marketOverview(): JsonResponse
    {
        $totalVolume = Collection::sum('volume_24h');
        $totalCollections = Collection::count();
        $avgFloorPrice = Collection::avg('floor_price');

        $topCollections = Collection::orderBy('volume_24h', 'desc')
            ->limit(5)
            ->get(['name', 'slug', 'volume_24h', 'floor_price']);

        return response()->json([
            'market_stats' => [
                'total_volume_24h' => $totalVolume,
                'total_collections' => $totalCollections,
                'average_floor_price' => $avgFloorPrice,
            ],
            'top_collections' => $topCollections,
        ]);
    }
}

통계 API는 대시보드의 차트를 그리는 데 사용될 거야. 시계열 데이터, 가격 변동, 시장 개요 등 다양한 정보를 제공해! 📈

use App\Http\Controllers\Api\AnalyticsController;
use App\Http\Controllers\Api\CollectionController;
use App\Http\Controllers\Api\DashboardController;
use App\Http\Controllers\Api\NftItemController;
use Illuminate\Support\Facades\Route;

// 공개 API (인증 불필요)
Route::prefix('v1')->group(function () {
    
    // 컬렉션
    Route::get('/collections', [CollectionController::class, 'index']);
    Route::get('/collections/trending', [CollectionController::class, 'trending']);
    Route::get('/collections/popular', [CollectionController::class, 'popular']);
    Route::get('/collections/{slug}', [CollectionController::class, 'show']);
    
    // NFT 아이템
    Route::get('/collections/{slug}/items', [NftItemController::class, 'index']);
    Route::get('/items/{id}', [NftItemController::class, 'show']);
    
    // 분석
    Route::get('/analytics/{slug}/timeseries', [AnalyticsController::class, 'timeSeries']);
    Route::get('/analytics/{slug}/price-change', [AnalyticsController::class, 'priceChange']);
    Route::get('/analytics/market-overview', [AnalyticsController::class, 'marketOverview']);
    
    // 대시보드
    Route::get('/dashboard', [DashboardController::class, 'index']);
});

// 인증이 필요한 API
Route::middleware('auth:sanctum')->prefix('v1')->group(function () {
    Route::post('/collections/{slug}/watch', [CollectionController::class, 'watch']);
    Route::delete('/collections/{slug}/unwatch', [CollectionController::class, 'unwatch']);
});

API 버전을 /v1로 명시했어. 나중에 API를 업데이트할 때 하위 호환성을 유지하기 위해서야. 그리고 일부 기능은 인증이 필요하도록 auth:sanctum 미들웨어를 사용했어! 🔐

🎨 프론트엔드 대시보드 구축하기

백엔드 API가 준비되었으니 이제 멋진 프론트엔드 대시보드를 만들어보자! Vue.js와 Chart.js를 사용할 거야. 🎨

npm install vue@next
npm install vue-router@4
npm install axios
npm install chart.js vue-chartjs
npm install @headlessui/vue
npm install @heroicons/vue
npm install tailwindcss@latest postcss@latest autoprefixer@latest

Tailwind CSS를 사용하면 빠르게 예쁜 UI를 만들 수 있어. 그리고 Chart.js는 차트를 그리는 데 최고야! 📊

<template>
  <div class="min-h-screen bg-gray-50">
    <!-- 헤더 -->
    <header class="bg-white shadow">
      <div class="max-w-7xl mx-auto px-4 py-6">
        <h1 class="text-3xl font-bold text-gray-900">
          NFT Analytics Dashboard
        </h1>
      </div>
    </header>

    <main class="max-w-7xl mx-auto px-4 py-8">
      <!-- 시장 개요 -->
      <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-8">
        <StatCard
          title="24h Volume"
          :value="formatEth(marketStats.total_volume_24h)"
          :change="volumeChange"
          icon="chart-bar"
        />
        <StatCard
          title="Total Collections"
          :value="marketStats.total_collections"
          icon="collection"
        />
        <StatCard
          title="Avg Floor Price"
          :value="formatEth(marketStats.average_floor_price)"
          icon="currency-dollar"
        />
      </div>

      <!-- 트렌딩 컬렉션 -->
      <div class="bg-white rounded-lg shadow mb-8">
        <div class="px-6 py-4 border-b">
          <h2 class="text-xl font-semibold">Trending Collections</h2>
        </div>
        <div class="p-6">
          <CollectionList :collections="trendingCollections" />
        </div>
      </div>

      <!-- 가격 차트 -->
      <div class="bg-white rounded-lg shadow">
        <div class="px-6 py-4 border-b">
          <h2 class="text-xl font-semibold">Price Trends</h2>
        </div>
        <div class="p-6">
          <PriceChart :data="chartData" />
        </div>
      </div>
    </main>
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue';
import axios from 'axios';
import StatCard from './StatCard.vue';
import CollectionList from './CollectionList.vue';
import PriceChart from './PriceChart.vue';

const marketStats = ref({
  total_volume_24h: 0,
  total_collections: 0,
  average_floor_price: 0,
});

const trendingCollections = ref([]);
const chartData = ref(null);
const volumeChange = ref(0);

onMounted(async () => {
  await loadDashboardData();
});

async function loadDashboardData() {
  try {
    // 시장 개요 로드
    const marketResponse = await axios.get('/api/v1/analytics/market-overview');
    marketStats.value = marketResponse.data.market_stats;

    // 트렌딩 컬렉션 로드
    const trendingResponse = await axios.get('/api/v1/collections/trending');
    trendingCollections.value = trendingResponse.data;

    // 차트 데이터 로드 (첫 번째 트렌딩 컬렉션)
    if (trendingCollections.value.length > 0) {
      const slug = trendingCollections.value[0].slug;
      const chartResponse = await axios.get(`/api/v1/analytics/${slug}/timeseries?days=30`);
      chartData.value = chartResponse.data;
    }
  } catch (error) {
    console.error('Failed to load dashboard data:', error);
  }
}

function formatEth(value) {
  return `${parseFloat(value).toFixed(2)} ETH`;
}
</script>

Vue 3의 Composition API를 사용했어. setup 함수에서 데이터를 로드하고, 반응형 변수들을 관리해. 정말 깔끔하지? 😊

<template>
  <div class="relative h-96">
    <Line :data="chartData" :options="chartOptions" />
  </div>
</template>

<script setup>
import { computed } from 'vue';
import { Line } from 'vue-chartjs';
import {
  Chart as ChartJS,
  CategoryScale,
  LinearScale,
  PointElement,
  LineElement,
  Title,
  Tooltip,
  Legend,
  Filler
} from 'chart.js';

ChartJS.register(
  CategoryScale,
  LinearScale,
  PointElement,
  LineElement,
  Title,
  Tooltip,
  Legend,
  Filler
);

const props = defineProps({
  data: {
    type: Object,
    required: true
  }
});

const chartData = computed(() => {
  if (!props.data || !props.data.data) {
    return { labels: [], datasets: [] };
  }

  const labels = props.data.data.map(item => item.date);
  const floorPrices = props.data.data.map(item => item.floor_price);
  const volumes = props.data.data.map(item => item.volume);

  return {
    labels,
    datasets: [
      {
        label: 'Floor Price',
        data: floorPrices,
        borderColor: 'rgb(102, 126, 234)',
        backgroundColor: 'rgba(102, 126, 234, 0.1)',
        fill: true,
        tension: 0.4,
        yAxisID: 'y',
      },
      {
        label: 'Volume',
        data: volumes,
        borderColor: 'rgb(32, 201, 151)',
        backgroundColor: 'rgba(32, 201, 151, 0.1)',
        fill: true,
        tension: 0.4,
        yAxisID: 'y1',
      }
    ]
  };
});

const chartOptions = {
  responsive: true,
  maintainAspectRatio: false,
  interaction: {
    mode: 'index',
    intersect: false,
  },
  plugins: {
    legend: {
      position: 'top',
    },
    tooltip: {
      callbacks: {
        label: function(context) {
          let label = context.dataset.label || '';
          if (label) {
            label += ': ';
          }
          label += context.parsed.y.toFixed(4) + ' ETH';
          return label;
        }
      }
    }
  },
  scales: {
    y: {
      type: 'linear',
      display: true,
      position: 'left',
      title: {
        display: true,
        text: 'Floor Price (ETH)'
      }
    },
    y1: {
      type: 'linear',
      display: true,
      position: 'right',
      title: {
        display: true,
        text: 'Volume (ETH)'
      },
      grid: {
        drawOnChartArea: false,
      },
    },
  }
};
</script>

이 차트는 Floor Price와 Volume을 동시에 보여줘. 두 개의 Y축을 사용해서 서로 다른 스케일의 데이터를 한 차트에 표시할 수 있어! 📈

🔒 보안 및 최적화

대시보드가 거의 완성되었어! 하지만 프로덕션에 배포하기 전에 보안과 성능 최적화를 해야 해. 이 부분이 정말 중요해! 🛡️

namespace App\Services;

use Illuminate\Support\Facades\Cache;

class CacheService
{
    // 캐시 키 접두사
    private const PREFIX = 'nft_dashboard:';

    // TTL 상수 (초 단위)
    private const TTL_SHORT = 300;      // 5분
    private const TTL_MEDIUM = 1800;    // 30분
    private const TTL_LONG = 3600;      // 1시간
    private const TTL_VERY_LONG = 86400; // 24시간

    /**
     * 컬렉션 데이터 캐싱
     */
    public function cacheCollection(string $slug, callable $callback): mixed
    {
        $key = self::PREFIX . "collection:{$slug}";
        return Cache::remember($key, self::TTL_MEDIUM, $callback);
    }

    /**
     * 트렌딩 컬렉션 캐싱
     */
    public function cacheTrending(callable $callback): mixed
    {
        $key = self::PREFIX . 'trending';
        return Cache::remember($key, self::TTL_SHORT, $callback);
    }

    /**
     * 통계 데이터 캐싱
     */
    public function cacheAnalytics(string $slug, string $period, callable $callback): mixed
    {
        $key = self::PREFIX . "analytics:{$slug}:{$period}";
        return Cache::remember($key, self::TTL_LONG, $callback);
    }

    /**
     * 시장 개요 캐싱
     */
    public function cacheMarketOverview(callable $callback): mixed
    {
        $key = self::PREFIX . 'market_overview';
        return Cache::remember($key, self::TTL_SHORT, $callback);
    }

    /**
     * 특정 컬렉션의 캐시 무효화
     */
    public function invalidateCollection(string $slug): void
    {
        Cache::forget(self::PREFIX . "collection:{$slug}");
        Cache::forget(self::PREFIX . "analytics:{$slug}:*");
    }

    /**
     * 모든 캐시 무효화
     */
    public function invalidateAll(): void
    {
        Cache::tags(['nft_dashboard'])->flush();
    }
}

이 서비스를 사용하면 캐싱 로직을 중앙에서 관리할 수 있어. TTL(Time To Live)도 데이터의 특성에 따라 다르게 설정했어! ⏰

🚀 배포 및 운영

드디어 마지막 단계야! 완성된 대시보드를 실제 서버에 배포해보자. 🎉

FROM php:8.2-fpm

# 시스템 의존성 설치
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip \
    nodejs \
    npm

# 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 --optimize-autoloader --no-dev
RUN npm install && npm run build

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

EXPOSE 9000
CMD ["php-fpm"]

그리고 docker-compose.yml도 만들어:

version: '3.8'

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

  nginx:
    image: nginx:alpine
    container_name: nft-dashboard-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./docker/nginx:/etc/nginx/conf.d
    networks:
      - nft-network

  mysql:
    image: mysql:8.0
    container_name: nft-dashboard-mysql
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: nft_dashboard
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_PASSWORD: secret
      MYSQL_USER: nft_user
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - nft-network

  redis:
    image: redis:alpine
    container_name: nft-dashboard-redis
    restart: unless-stopped
    networks:
      - nft-network

  horizon:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: nft-dashboard-horizon
    restart: unless-stopped
    command: php artisan horizon
    volumes:
      - ./:/var/www
    networks:
      - nft-network

networks:
  nft-network:
    driver: bridge

volumes:
  mysql-data:

이제 docker-compose up -d 명령어 하나로 모든 서비스를 실행할 수 있어! 정말 편하지? 🐳

🎓 추가 기능 아이디어

기본 대시보드는 완성했지만, 더 멋진 기능들을 추가할 수 있어! 몇 가지 아이디어를 공유해줄게. 💡

🎯 마무리하며

와! 정말 긴 여정이었지? 우리는 라라벨을 사용해서 완전히 동작하는 NFT 통계 분석 대시보드를 처음부터 끝까지 만들어봤어. 🎉

이 프로젝트를 통해 배운 것들을 정리해보면:

이 대시보드는 시작점일 뿐이야. 여기서 배운 개념들을 활용하면 훨씬 더 복잡하고 강력한 시스템을 만들 수 있어! 🚀

NFT 시장은 계속 진화하고 있고, 새로운 기회들이 계속 생겨나고 있어. 데이터를 잘 활용하면 시장을 이해하고, 더 나은 결정을 내릴 수 있지.

혹시 프로젝트를 진행하다가 막히는 부분이 있거나, 더 전문적인 도움이 필요하다면 재능넷 같은 플랫폼에서 전문가들의 도움을 받을 수도 있어. 라라벨 개발자, 블록체인 전문가, UI/UX 디자이너 등 다양한 분야의 전문가들이 있으니까 협업하면 더 빠르게 프로젝트를 완성할 수 있을 거야! 💪

자, 이제 당신 차례야! 이 가이드를 참고해서 멋진 NFT 대시보드를 만들어보자. 그리고 만든 결과물을 커뮤니티와 공유하면 더 좋겠지? 😊

행운을 빌어! Happy coding! 🎨✨