// database/migrations/create_nfts_table.php
Schema::create('nfts', function (Blueprint $table) {
    $table->id();
    $table->string('token_id');
    $table->string('contract_address', 42)->index();
    $table->integer('chain_id')->default(1); // 1=Mainnet, 11155111=Sepolia
    $table->string('owner_address', 42)->index();
    $table->string('creator_address', 42)->index();
    $table->string('name');
    $table->text('description')->nullable();
    $table->string('image_url');
    $table->string('metadata_uri'); // ipfs://...
    $table->enum('token_standard', ['ERC721', 'ERC1155'])->default('ERC721');
    $table->decimal('royalty_percentage', 5, 2)->default(0);
    $table->boolean('is_minted')->default(false);
    $table->json('attributes')->nullable(); // NFT 속성
    $table->timestamps();
    
    $table->unique(['token_id', 'contract_address', 'chain_id']);
});

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

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

contract LaravelNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    // 로열티 정보
    mapping(uint256 => address) public creators;
    mapping(uint256 => uint256) public royaltyPercentage;
    
    // 민팅 수수료
    uint256 public mintingFee = 0.001 ether;
    
    event NFTMinted(
        uint256 indexed tokenId,
        address indexed creator,
        string tokenURI,
        uint256 royalty
    );
    
    constructor() ERC721("LaravelNFT", "LNFT") Ownable(msg.sender) {}
    
    function mintNFT(
        address recipient,
        string memory tokenURI,
        uint256 royalty // 100 = 1%, 최대 1000 = 10%
    ) public payable returns (uint256) {
        require(msg.value >= mintingFee, "Insufficient minting fee");
        require(royalty <= 1000, "Royalty too high");
        
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        
        _mint(recipient, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        
        creators[newTokenId] = recipient;
        royaltyPercentage[newTokenId] = royalty;
        
        emit NFTMinted(newTokenId, recipient, tokenURI, royalty);
        return newTokenId;
    }
    
    // EIP-2981 로열티 표준
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external view returns (address receiver, uint256 royaltyAmount) {
        receiver = creators[tokenId];
        royaltyAmount = (salePrice * royaltyPercentage[tokenId]) / 10000;
    }
    
    function withdraw() public onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

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

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract NFTMarketplace is ReentrancyGuard, Ownable {
    
    struct Listing {
        address seller;
        address nftContract;
        uint256 tokenId;
        uint256 price;
        bool isActive;
    }
    
    // listingId => Listing
    mapping(uint256 => Listing) public listings;
    uint256 private _listingCounter;
    
    // 플랫폼 수수료 (250 = 2.5%)
    uint256 public platformFee = 250;
    uint256 public constant FEE_DENOMINATOR = 10000;
    
    event Listed(uint256 indexed listingId, address indexed seller, 
                 address nftContract, uint256 tokenId, uint256 price);
    event Sold(uint256 indexed listingId, address indexed buyer, uint256 price);
    event Cancelled(uint256 indexed listingId);
    
    constructor() Ownable(msg.sender) {}
    
    function listNFT(
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) external returns (uint256) {
        require(price > 0, "Price must be greater than 0");
        IERC721 nft = IERC721(nftContract);
        require(nft.ownerOf(tokenId) == msg.sender, "Not the owner");
        require(nft.isApprovedForAll(msg.sender, address(this)) ||
                nft.getApproved(tokenId) == address(this), "Not approved");
        
        _listingCounter++;
        listings[_listingCounter] = Listing({
            seller: msg.sender,
            nftContract: nftContract,
            tokenId: tokenId,
            price: price,
            isActive: true
        });
        
        emit Listed(_listingCounter, msg.sender, nftContract, tokenId, price);
        return _listingCounter;
    }
    
    function buyNFT(uint256 listingId) external payable nonReentrant {
        Listing storage listing = listings[listingId];
        require(listing.isActive, "Listing not active");
        require(msg.value >= listing.price, "Insufficient payment");
        
        listing.isActive = false;
        
        // 수수료 계산
        uint256 fee = (listing.price * platformFee) / FEE_DENOMINATOR;
        uint256 sellerAmount = listing.price - fee;
        
        // NFT 전송
        IERC721(listing.nftContract).safeTransferFrom(
            listing.seller, msg.sender, listing.tokenId
        );
        
        // 대금 지급
        payable(listing.seller).transfer(sellerAmount);
        
        // 초과 지불 환불
        if (msg.value > listing.price) {
            payable(msg.sender).transfer(msg.value - listing.price);
        }
        
        emit Sold(listingId, msg.sender, listing.price);
    }
    
    function cancelListing(uint256 listingId) external {
        Listing storage listing = listings[listingId];
        require(listing.seller == msg.sender, "Not the seller");
        require(listing.isActive, "Already inactive");
        listing.isActive = false;
        emit Cancelled(listingId);
    }
    
    function setPlatformFee(uint256 newFee) external onlyOwner {
        require(newFee <= 1000, "Fee too high"); // 최대 10%
        platformFee = newFee;
    }
    
    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: process.env.ALCHEMY_SEPOLIA_URL,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY]
    },
    mainnet: {
      url: process.env.ALCHEMY_MAINNET_URL,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

// scripts/deploy.js
async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying with:", deployer.address);
  
  const NFT = await ethers.getContractFactory("LaravelNFT");
  const nft = await NFT.deploy();
  await nft.waitForDeployment();
  console.log("NFT Contract:", await nft.getAddress());
  
  const Marketplace = await ethers.getContractFactory("NFTMarketplace");
  const marketplace = await Marketplace.deploy();
  await marketplace.waitForDeployment();
  console.log("Marketplace:", await marketplace.getAddress());
}

main().catch(console.error);

app/
├── Http/
│   ├── Controllers/
│   │   ├── NFTController.php
│   │   ├── MarketplaceController.php
│   │   ├── CollectionController.php
│   │   └── AuthController.php (지갑 인증)
│   ├── Requests/
│   │   ├── MintNFTRequest.php
│   │   └── ListNFTRequest.php
│   └── Resources/
│       ├── NFTResource.php
│       └── ListingResource.php
├── Models/
│   ├── User.php
│   ├── NFT.php
│   ├── Listing.php
│   └── Transaction.php
├── Services/
│   ├── IPFSService.php      ← Pinata 연동
│   ├── Web3Service.php      ← 블록체인 연동
│   └── NFTMetadataService.php
├── Jobs/
│   ├── SyncNFTFromChain.php
│   └── ProcessBlockchainEvent.php
└── Console/Commands/
    └── ListenBlockchainEvents.php

// app/Http/Controllers/AuthController.php
class AuthController extends Controller
{
    // 1단계: 논스(nonce) 발급
    public function getNonce(Request $request): JsonResponse
    {
        $walletAddress = strtolower($request->wallet_address);
        $nonce = bin2hex(random_bytes(16));
        
        Cache::put("nonce:{$walletAddress}", $nonce, now()->addMinutes(5));
        
        return response()->json([
            'nonce' => $nonce,
            'message' => "NFT 마켓플레이스에 로그인합니다.\n\n논스: {$nonce}"
        ]);
    }
    
    // 2단계: 서명 검증 & 로그인
    public function verifySignature(Request $request): JsonResponse
    {
        $walletAddress = strtolower($request->wallet_address);
        $signature = $request->signature;
        
        $cachedNonce = Cache::get("nonce:{$walletAddress}");
        if (!$cachedNonce) {
            return response()->json(['error' => '논스 만료'], 401);
        }
        
        $message = "NFT 마켓플레이스에 로그인합니다.\n\n논스: {$cachedNonce}";
        
        // 서명 검증 (web3.php 사용)
        $web3 = app(Web3Service::class);
        $recoveredAddress = $web3->recoverAddress($message, $signature);
        
        if (strtolower($recoveredAddress) !== $walletAddress) {
            return response()->json(['error' => '서명 검증 실패'], 401);
        }
        
        Cache::forget("nonce:{$walletAddress}");
        
        // 사용자 생성 또는 조회
        $user = User::firstOrCreate(
            ['wallet_address' => $walletAddress],
            ['username' => 'user_' . substr($walletAddress, 2, 8)]
        );
        
        $token = $user->createToken('auth-token')->plainTextToken;
        
        return response()->json([
            'token' => $token,
            'user' => new UserResource($user)
        ]);
    }
}

// app/Services/IPFSService.php
class IPFSService
{
    private string $apiKey;
    private string $secretKey;
    private string $baseUrl = 'https://api.pinata.cloud';
    
    public function __construct()
    {
        $this->apiKey = config('services.pinata.api_key');
        $this->secretKey = config('services.pinata.secret_key');
    }
    
    // 파일 업로드
    public function uploadFile(UploadedFile $file, string $name): array
    {
        $response = Http::withHeaders([
            'pinata_api_key' => $this->apiKey,
            'pinata_secret_api_key' => $this->secretKey,
        ])->attach(
            'file', $file->getContent(), $file->getClientOriginalName()
        )->post("{$this->baseUrl}/pinning/pinFileToIPFS", [
            'pinataMetadata' => json_encode(['name' => $name]),
        ]);
        
        if (!$response->successful()) {
            throw new \Exception('IPFS 업로드 실패: ' . $response->body());
        }
        
        $data = $response->json();
        return [
            'cid' => $data['IpfsHash'],
            'uri' => "ipfs://{$data['IpfsHash']}",
            'gateway_url' => "https://gateway.pinata.cloud/ipfs/{$data['IpfsHash']}"
        ];
    }
    
    // 메타데이터 JSON 업로드
    public function uploadMetadata(array $metadata, string $name): array
    {
        $response = Http::withHeaders([
            'pinata_api_key' => $this->apiKey,
            'pinata_secret_api_key' => $this->secretKey,
            'Content-Type' => 'application/json',
        ])->post("{$this->baseUrl}/pinning/pinJSONToIPFS", [
            'pinataContent' => $metadata,
            'pinataMetadata' => ['name' => $name],
        ]);
        
        $data = $response->json();
        return [
            'cid' => $data['IpfsHash'],
            'uri' => "ipfs://{$data['IpfsHash']}",
        ];
    }
}

// app/Http/Controllers/NFTController.php
class NFTController extends Controller
{
    public function __construct(
        private IPFSService $ipfsService,
        private NFTMetadataService $metadataService
    ) {}
    
    // NFT 민팅 준비 (파일 업로드 + 메타데이터 생성)
    public function prepareMint(MintNFTRequest $request): JsonResponse
    {
        // 1. 파일 IPFS 업로드
        $fileResult = $this->ipfsService->uploadFile(
            $request->file('nft_file'),
            $request->name
        );
        
        // 2. 메타데이터 구성
        $metadata = [
            'name' => $request->name,
            'description' => $request->description,
            'image' => $fileResult['uri'],
            'attributes' => $request->attributes ?? [],
            'external_url' => config('app.url') . '/nft/' . $fileResult['cid'],
        ];
        
        // 3. 메타데이터 IPFS 업로드
        $metadataResult = $this->ipfsService->uploadMetadata(
            $metadata,
            $request->name . '_metadata'
        );
        
        // 4. DB에 임시 저장 (민팅 전)
        $nft = NFT::create([
            'creator_address' => auth()->user()->wallet_address,
            'owner_address' => auth()->user()->wallet_address,
            'name' => $request->name,
            'description' => $request->description,
            'image_url' => $fileResult['gateway_url'],
            'metadata_uri' => $metadataResult['uri'],
            'royalty_percentage' => $request->royalty ?? 0,
            'is_minted' => false,
        ]);
        
        return response()->json([
            'nft_id' => $nft->id,
            'metadata_uri' => $metadataResult['uri'],
            'royalty_bps' => ($request->royalty ?? 0) * 100, // % → BPS 변환
            'message' => '메타데이터 준비 완료! 이제 지갑으로 민팅하세요.'
        ]);
    }
    
    // 민팅 완료 후 트랜잭션 해시 등록
    public function confirmMint(Request $request, NFT $nft): JsonResponse
    {
        $request->validate([
            'tx_hash' => 'required|string',
            'token_id' => 'required|integer',
            'contract_address' => 'required|string',
        ]);
        
        $nft->update([
            'token_id' => $request->token_id,
            'contract_address' => strtolower($request->contract_address),
            'is_minted' => true,
            'chain_id' => config('blockchain.chain_id'),
        ]);
        
        // 비동기로 블록체인 확인
        SyncNFTFromChain::dispatch($nft)->delay(now()->addSeconds(15));
        
        return response()->json([
            'success' => true,
            'nft' => new NFTResource($nft)
        ]);
    }
    
    // NFT 목록 조회
    public function index(Request $request): JsonResponse
    {
        $nfts = NFT::with(['collection', 'activeListing'])
            ->where('is_minted', true)
            ->when($request->collection, fn($q, $v) => $q->where('contract_address', $v))
            ->when($request->min_price, fn($q, $v) => $q->whereHas('activeListing', 
                fn($lq) => $lq->where('price_wei', '>=', $v)))
            ->latest()
            ->paginate(20);
            
        return NFTResource::collection($nfts)->response();
    }
}

// app/Console/Commands/ListenBlockchainEvents.php
class ListenBlockchainEvents extends Command
{
    protected $signature = 'blockchain:listen {--from-block=latest}';
    protected $description = '블록체인 이벤트를 실시간으로 감지합니다';
    
    public function handle(Web3Service $web3): void
    {
        $this->info('블록체인 이벤트 리스닝 시작...');
        
        $marketplaceAddress = config('blockchain.marketplace_address');
        $fromBlock = $this->option('from-block');
        
        // 마지막 처리 블록 가져오기
        if ($fromBlock === 'latest') {
            $fromBlock = Cache::get('last_processed_block', 'latest');
        }
        
        while (true) {
            try {
                // Sold 이벤트 조회
                $soldEvents = $web3->getEvents(
                    $marketplaceAddress,
                    'Sold(uint256,address,uint256)',
                    $fromBlock
                );
                
                foreach ($soldEvents as $event) {
                    ProcessBlockchainEvent::dispatch([
                        'type' => 'NFT_SOLD',
                        'listing_id' => $event['listingId'],
                        'buyer' => $event['buyer'],
                        'price' => $event['price'],
                        'tx_hash' => $event['transactionHash'],
                        'block_number' => $event['blockNumber'],
                    ]);
                    
                    $fromBlock = $event['blockNumber'] + 1;
                }
                
                Cache::put('last_processed_block', $fromBlock, now()->addDay());
                
            } catch (\Exception $e) {
                $this->error('이벤트 처리 오류: ' . $e->getMessage());
                Log::error('Blockchain event error', ['error' => $e->getMessage()]);
            }
            
            sleep(12); // 이더리움 블록 생성 주기 ~12초
        }
    }
}

// routes/api.php

// 인증 관련
Route::post('/auth/nonce', [AuthController::class, 'getNonce']);
Route::post('/auth/verify', [AuthController::class, 'verifySignature']);

// 공개 API (인증 불필요)
Route::prefix('v1')->group(function () {
    
    // NFT 조회
    Route::get('/nfts', [NFTController::class, 'index']);
    Route::get('/nfts/{nft}', [NFTController::class, 'show']);
    Route::get('/nfts/{nft}/history', [NFTController::class, 'history']);
    
    // 컬렉션
    Route::get('/collections', [CollectionController::class, 'index']);
    Route::get('/collections/{address}', [CollectionController::class, 'show']);
    Route::get('/collections/{address}/nfts', [CollectionController::class, 'nfts']);
    
    // 마켓플레이스
    Route::get('/listings', [MarketplaceController::class, 'index']);
    Route::get('/listings/{listing}', [MarketplaceController::class, 'show']);
    
    // 검색
    Route::get('/search', [SearchController::class, 'index']);
    
    // 통계
    Route::get('/stats', [StatsController::class, 'index']);
});

// 인증 필요 API
Route::prefix('v1')->middleware('auth:sanctum')->group(function () {
    
    // NFT 민팅
    Route::post('/nfts/prepare-mint', [NFTController::class, 'prepareMint']);
    Route::post('/nfts/{nft}/confirm-mint', [NFTController::class, 'confirmMint']);
    
    // 마켓플레이스
    Route::post('/listings', [MarketplaceController::class, 'create']);
    Route::delete('/listings/{listing}', [MarketplaceController::class, 'cancel']);
    Route::post('/listings/{listing}/buy', [MarketplaceController::class, 'confirmPurchase']);
    
    // 경매
    Route::post('/listings/{listing}/bids', [BidController::class, 'place']);
    Route::get('/my/bids', [BidController::class, 'myBids']);
    
    // 프로필
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::put('/profile', [ProfileController::class, 'update']);
    Route::get('/profile/nfts', [ProfileController::class, 'nfts']);
    Route::get('/profile/activity', [ProfileController::class, 'activity']);
});

// app/Http/Resources/NFTResource.php
class NFTResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'token_id' => $this->token_id,
            'contract_address' => $this->contract_address,
            'chain_id' => $this->chain_id,
            'name' => $this->name,
            'description' => $this->description,
            'image_url' => $this->image_url,
            'metadata_uri' => $this->metadata_uri,
            'attributes' => $this->attributes,
            'owner' => [
                'address' => $this->owner_address,
                'username' => $this->owner?->username,
                'avatar' => $this->owner?->avatar_url,
            ],
            'creator' => [
                'address' => $this->creator_address,
                'username' => $this->creator?->username,
            ],
            'royalty_percentage' => $this->royalty_percentage,
            'token_standard' => $this->token_standard,
            'listing' => $this->whenLoaded('activeListing', function () {
                return [
                    'id' => $this->activeListing->id,
                    'price_eth' => $this->activeListing->price_eth, // Wei → ETH 변환
                    'price_wei' => $this->activeListing->price_wei,
                    'listing_type' => $this->activeListing->listing_type,
                    'end_time' => $this->activeListing->end_time,
                ];
            }),
            'is_minted' => $this->is_minted,
            'created_at' => $this->created_at->toISOString(),
        ];
    }
}

// composables/useWallet.js (Vue 3 Composable)
import { ref, computed } from 'vue'
import { ethers } from 'ethers'
import axios from 'axios'

export function useWallet() {
    const address = ref(null)
    const isConnected = computed(() => !!address.value)
    const provider = ref(null)
    const signer = ref(null)
    
    async function connect() {
        if (!window.ethereum) {
            alert('MetaMask를 설치해주세요!')
            return
        }
        
        try {
            // MetaMask 연결
            provider.value = new ethers.BrowserProvider(window.ethereum)
            await provider.value.send('eth_requestAccounts', [])
            signer.value = await provider.value.getSigner()
            address.value = await signer.value.getAddress()
            
            // Laravel 백엔드에 로그인
            await signIn()
            
        } catch (error) {
            console.error('지갑 연결 실패:', error)
        }
    }
    
    async function signIn() {
        // 1. 논스 요청
        const { data: { nonce, message } } = await axios.post('/api/auth/nonce', {
            wallet_address: address.value
        })
        
        // 2. 메시지 서명 (MetaMask 팝업)
        const signature = await signer.value.signMessage(message)
        
        // 3. 서명 검증 & 토큰 발급
        const { data } = await axios.post('/api/auth/verify', {
            wallet_address: address.value,
            signature: signature
        })
        
        // 4. 토큰 저장
        localStorage.setItem('auth_token', data.token)
        axios.defaults.headers.common['Authorization'] = `Bearer ${data.token}`
        
        return data.user
    }
    
    return { address, isConnected, provider, signer, connect }
}

// composables/useNFTMint.js
import { ref } from 'vue'
import { ethers } from 'ethers'
import NFT_ABI from '@/abis/LaravelNFT.json'

export function useNFTMint() {
    const isMinting = ref(false)
    const mintStep = ref('')
    
    async function mintNFT(formData, signer) {
        isMinting.value = true
        
        try {
            // Step 1: 백엔드에 파일 업로드 & 메타데이터 준비
            mintStep.value = '📦 IPFS에 파일 업로드 중...'
            const { data } = await axios.post('/api/v1/nfts/prepare-mint', formData, {
                headers: { 'Content-Type': 'multipart/form-data' }
            })
            
            // Step 2: 스마트 컨트랙트 민팅
            mintStep.value = '⛓️ 블록체인에 민팅 중...'
            const contract = new ethers.Contract(
                import.meta.env.VITE_NFT_CONTRACT_ADDRESS,
                NFT_ABI,
                signer
            )
            
            const mintingFee = await contract.mintingFee()
            
            const tx = await contract.mintNFT(
                await signer.getAddress(),
                data.metadata_uri,
                data.royalty_bps,
                { value: mintingFee }
            )
            
            mintStep.value = '⏳ 트랜잭션 확인 대기 중...'
            const receipt = await tx.wait()
            
            // Step 3: 이벤트에서 tokenId 추출
            const mintedEvent = receipt.logs.find(log => {
                try {
                    const parsed = contract.interface.parseLog(log)
                    return parsed?.name === 'NFTMinted'
                } catch { return false }
            })
            
            const parsedEvent = contract.interface.parseLog(mintedEvent)
            const tokenId = parsedEvent.args.tokenId.toString()
            
            // Step 4: 백엔드에 민팅 완료 알림
            mintStep.value = '✅ 데이터베이스 동기화 중...'
            await axios.post(`/api/v1/nfts/${data.nft_id}/confirm-mint`, {
                tx_hash: receipt.hash,
                token_id: tokenId,
                contract_address: import.meta.env.VITE_NFT_CONTRACT_ADDRESS
            })
            
            mintStep.value = '🎉 민팅 완료!'
            return { success: true, tokenId, txHash: receipt.hash }
            
        } catch (error) {
            mintStep.value = '❌ 민팅 실패'
            throw error
        } finally {
            isMinting.value = false
        }
    }
    
    return { isMinting, mintStep, mintNFT }
}

// app/Services/NFTCacheService.php
class NFTCacheService
{
    // NFT 상세 정보 캐싱 (1시간)
    public function getNFT(int $id): NFT
    {
        return Cache::remember("nft:{$id}", 3600, function () use ($id) {
            return NFT::with(['collection', 'activeListing', 'creator', 'owner'])
                ->findOrFail($id);
        });
    }
    
    // 컬렉션 통계 캐싱 (5분)
    public function getCollectionStats(string $address): array
    {
        return Cache::remember("collection:stats:{$address}", 300, function () use ($address) {
            return [
                'floor_price' => Listing::whereHas('nft', fn($q) => 
                    $q->where('contract_address', $address))
                    ->where('is_active', true)
                    ->min('price_wei'),
                'volume_24h' => Transaction::whereHas('nft', fn($q) => 
                    $q->where('contract_address', $address))
                    ->where('created_at', '>=', now()->subDay())
                    ->sum('price_wei'),
                'total_supply' => NFT::where('contract_address', $address)
                    ->where('is_minted', true)->count(),
            ];
        });
    }
    
    // NFT 목록 캐싱 (2분)
    public function getListings(array $filters): LengthAwarePaginator
    {
        $cacheKey = 'listings:' . md5(serialize($filters));
        return Cache::remember($cacheKey, 120, function () use ($filters) {
            return Listing::with(['nft.collection'])
                ->where('is_active', true)
                ->when($filters['sort'] ?? null, function ($q, $sort) {
                    match($sort) {
                        'price_asc' => $q->orderBy('price_wei', 'asc'),
                        'price_desc' => $q->orderBy('price_wei', 'desc'),
                        default => $q->latest()
                    };
                })
                ->paginate(20);
        });
    }
    
    // 캐시 무효화
    public function invalidateNFT(int $id): void
    {
        Cache::forget("nft:{$id}");
        Cache::tags(['nft-listings'])->flush(); // 태그 기반 캐시 무효화
    }
}

// 성능 최적화를 위한 인덱스 추가 마이그레이션
Schema::table('nfts', function (Blueprint $table) {
    $table->index(['contract_address', 'is_minted']); // 컬렉션 조회
    $table->index(['owner_address', 'is_minted']);     // 소유자별 조회
    $table->index(['creator_address']);                 // 크리에이터별 조회
    $table->index(['created_at']);                      // 최신순 정렬
});

Schema::table('listings', function (Blueprint $table) {
    $table->index(['is_active', 'price_wei']);          // 가격 필터링
    $table->index(['is_active', 'listing_type']);       // 경매/고정가 필터
    $table->index(['seller_address', 'is_active']);     // 판매자별 조회
    $table->index(['end_time', 'is_active']);           // 경매 만료 처리
});

Schema::table('transactions', function (Blueprint $table) {
    $table->index(['from_address']);
    $table->index(['to_address']);
    $table->index(['nft_id', 'created_at']);
    $table->index(['tx_hash'], 'idx_tx_hash');
});

// config/horizon.php
'environments' => [
    'production' => [
        'supervisor-1' => [
            'maxProcesses' => 10,
            'balanceMaxShift' => 1,
            'balanceCooldown' => 3,
        ],
        // 블록체인 이벤트 처리 전용 큐
        'blockchain-supervisor' => [
            'connection' => 'redis',
            'queue' => ['blockchain-events'],
            'balance' => 'auto',
            'processes' => 3,
            'tries' => 3,
            'timeout' => 60,
        ],
        // IPFS 업로드 전용 큐
        'ipfs-supervisor' => [
            'connection' => 'redis',
            'queue' => ['ipfs-uploads'],
            'balance' => 'auto',
            'processes' => 5,
            'tries' => 3,
            'timeout' => 120,
        ],
    ],
],

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - .:/var/www/html
    environment:
      - APP_ENV=production
    depends_on:
      - mysql
      - redis
    networks:
      - nft-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - app
    networks:
      - nft-network

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: nft_marketplace
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - nft-network

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    networks:
      - nft-network

  horizon:
    build:
      context: .
      dockerfile: Dockerfile
    command: php artisan horizon
    depends_on:
      - mysql
      - redis
    networks:
      - nft-network

  blockchain-listener:
    build:
      context: .
      dockerfile: Dockerfile
    command: php artisan blockchain:listen
    restart: unless-stopped
    depends_on:
      - mysql
      - redis
    networks:
      - nft-network

volumes:
  mysql_data:
  redis_data:

networks:
  nft-network:
    driver: bridge

# .github/workflows/deploy.yml
name: NFT Marketplace Deploy

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: PHP 설정
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
          
      - name: Composer 의존성 설치
        run: composer install --no-dev --optimize-autoloader
        
      - name: 환경 설정
        run: |
          cp .env.testing .env
          php artisan key:generate
          
      - name: 테스트 실행
        run: php artisan test --parallel
        
      - name: Hardhat 테스트
        run: |
          npm install
          npx hardhat test

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Docker 이미지 빌드 & 푸시
        run: |
          docker build -t nft-marketplace:${{ github.sha }} .
          docker push registry.example.com/nft-marketplace:${{ github.sha }}
          
      - name: 서버 배포
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /app/nft-marketplace
            docker-compose pull
            docker-compose up -d --no-deps app horizon
            docker-compose exec -T app php artisan migrate --force
            docker-compose exec -T app php artisan config:cache
            docker-compose exec -T app php artisan route:cache
            docker-compose exec -T app php artisan view:cache

// app/Events/NFTSold.php
class NFTSold implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public function __construct(
        public NFT $nft,
        public string $buyerAddress,
        public string $priceWei,
        public string $txHash
    ) {}
    
    public function broadcastOn(): array
    {
        return [
            new Channel('marketplace'),                    // 전체 마켓 채널
            new PrivateChannel("user.{$this->nft->owner_address}"), // 판매자 채널
            new PrivateChannel("user.{$this->buyerAddress}"),       // 구매자 채널
        ];
    }
    
    public function broadcastWith(): array
    {
        return [
            'nft_id' => $this->nft->id,
            'nft_name' => $this->nft->name,
            'nft_image' => $this->nft->image_url,
            'price_eth' => number_format(
                (float) \Web3\Utils::fromWei($this->priceWei, 'ether'), 4
            ),
            'buyer' => $this->buyerAddress,
            'tx_hash' => $this->txHash,
            'timestamp' => now()->toISOString(),
        ];
    }
    
    public function broadcastAs(): string
    {
        return 'nft.sold';
    }
}

// 이벤트 발생 (Job에서)
event(new NFTSold($nft, $buyerAddress, $priceWei, $txHash));

// app/Models/NFT.php
class NFT extends Model
{
    use HasFactory, Searchable;
    
    public function toSearchableArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'collection_name' => $this->collection?->name,
            'creator_address' => $this->creator_address,
            'attributes' => collect($this->attributes)->pluck('value')->implode(' '),
            'token_standard' => $this->token_standard,
        ];
    }
}

// 검색 컨트롤러
public function search(Request $request): JsonResponse
{
    $results = NFT::search($request->q)
        ->where('is_minted', true)
        ->paginate(20);
        
    return NFTResource::collection($results)->response();
}

// tests/Feature/NFTMintTest.php
class NFTMintTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_authenticated_user_can_prepare_mint(): void
    {
        // 지갑 인증된 사용자 생성
        $user = User::factory()->create([
            'wallet_address' => '0x742d35cc6634c0532925a3b8d4c9b4c4c4c4c4c4'
        ]);
        
        // IPFS 서비스 Mock
        $this->mock(IPFSService::class, function ($mock) {
            $mock->shouldReceive('uploadFile')->once()->andReturn([
                'cid' => 'QmTest123',
                'uri' => 'ipfs://QmTest123',
                'gateway_url' => 'https://gateway.pinata.cloud/ipfs/QmTest123'
            ]);
            $mock->shouldReceive('uploadMetadata')->once()->andReturn([
                'cid' => 'QmMeta456',
                'uri' => 'ipfs://QmMeta456',
            ]);
        });
        
        $response = $this->actingAs($user)
            ->postJson('/api/v1/nfts/prepare-mint', [
                'name' => '테스트 NFT',
                'description' => '테스트용 NFT입니다',
                'nft_file' => UploadedFile::fake()->image('test.jpg', 800, 800),
                'royalty' => 5,
            ]);
        
        $response->assertStatus(200)
            ->assertJsonStructure([
                'nft_id',
                'metadata_uri',
                'royalty_bps',
                'message'
            ]);
        
        $this->assertDatabaseHas('nfts', [
            'name' => '테스트 NFT',
            'creator_address' => $user->wallet_address,
            'is_minted' => false,
        ]);
    }
    
    public function test_unauthenticated_user_cannot_mint(): void
    {
        $response = $this->postJson('/api/v1/nfts/prepare-mint', [
            'name' => '테스트 NFT',
        ]);
        
        $response->assertStatus(401);
    }
}

// Hardhat 스마트 컨트랙트 테스트
// test/NFTMarketplace.test.js
describe("NFTMarketplace", function () {
    it("Should list and buy NFT correctly", async function () {
        const [owner, seller, buyer] = await ethers.getSigners();
        
        // NFT 민팅
        const NFT = await ethers.getContractFactory("LaravelNFT");
        const nft = await NFT.deploy();
        
        const mintTx = await nft.connect(seller).mintNFT(
            seller.address, "ipfs://test", 500,
            { value: ethers.parseEther("0.001") }
        );
        const receipt = await mintTx.wait();
        const tokenId = 1;
        
        // 마켓플레이스 배포
        const Marketplace = await ethers.getContractFactory("NFTMarketplace");
        const marketplace = await Marketplace.deploy();
        
        // 승인 & 리스팅
        await nft.connect(seller).approve(marketplace.target, tokenId);
        const listPrice = ethers.parseEther("1.0");
        await marketplace.connect(seller).listNFT(nft.target, tokenId, listPrice);
        
        // 구매
        const buyerBalanceBefore = await ethers.provider.getBalance(buyer.address);
        await marketplace.connect(buyer).buyNFT(1, { value: listPrice });
        
        // 검증
        expect(await nft.ownerOf(tokenId)).to.equal(buyer.address);
    });
});