composer create-project laravel/laravel blockchain-survey
cd blockchain-survey
php artisan serve

기본 라라벨 프로젝트가 생성됐어. 이제 블록체인 관련 패키지들을 설치해야 해.

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

web3.php는 PHP에서 이더리움 블록체인과 상호작용할 수 있게 해주는 핵심 라이브러리야. JSON-RPC를 통해 스마트 컨트랙트를 호출하고 트랜잭션을 전송할 수 있지. 🌐

npm install
npm install web3 ethers
npm install @metamask/detect-provider

프론트엔드에서도 블록체인과 직접 통신할 수 있도록 web3.js를 설치해. MetaMask 같은 지갑과 연동할 때 필요해.

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

contract SurveyContract {
    struct Survey {
        uint256 id;
        address creator;
        string title;
        string description;
        uint256 startTime;
        uint256 endTime;
        bool isActive;
        uint256 totalResponses;
    }
    
    struct Response {
        uint256 surveyId;
        address respondent;
        bytes32 dataHash;
        uint256 timestamp;
    }
    
    mapping(uint256 => Survey) public surveys;
    mapping(uint256 => mapping(address => bool)) public hasResponded;
    mapping(uint256 => Response[]) public responses;
    
    uint256 public surveyCount;
    
    event SurveyCreated(uint256 indexed surveyId, address indexed creator, string title);
    event ResponseSubmitted(uint256 indexed surveyId, address indexed respondent, bytes32 dataHash);
    event SurveyClosed(uint256 indexed surveyId);
    
    modifier onlyCreator(uint256 _surveyId) {
        require(surveys[_surveyId].creator == msg.sender, "Not the survey creator");
        _;
    }
    
    modifier surveyExists(uint256 _surveyId) {
        require(_surveyId > 0 && _surveyId <= surveyCount, "Survey does not exist");
        _;
    }
    
    modifier surveyActive(uint256 _surveyId) {
        require(surveys[_surveyId].isActive, "Survey is not active");
        require(block.timestamp >= surveys[_surveyId].startTime, "Survey has not started");
        require(block.timestamp <= surveys[_surveyId].endTime, "Survey has ended");
        _;
    }
}

이게 우리 컨트랙트의 뼈대야. Survey 구조체는 설문의 메타데이터를 담고, Response 구조체는 각 응답의 해시값을 저장해. 실제 응답 내용은 오프체인에 저장하고 해시만 온체인에 올리는 거지. 🔐

function createSurvey(
    string memory _title,
    string memory _description,
    uint256 _startTime,
    uint256 _endTime
) public returns (uint256) {
    require(_startTime < _endTime, "Invalid time range");
    require(_endTime > block.timestamp, "End time must be in the future");
    
    surveyCount++;
    
    surveys[surveyCount] = Survey({
        id: surveyCount,
        creator: msg.sender,
        title: _title,
        description: _description,
        startTime: _startTime,
        endTime: _endTime,
        isActive: true,
        totalResponses: 0
    });
    
    emit SurveyCreated(surveyCount, msg.sender, _title);
    
    return surveyCount;
}

설문을 생성하는 함수야. 시작 시간과 종료 시간을 검증하고, 새로운 설문을 매핑에 저장해. emit으로 이벤트를 발생시켜서 프론트엔드에서 실시간으로 감지할 수 있게 해줘. 📡

function submitResponse(
    uint256 _surveyId,
    bytes32 _dataHash
) public surveyExists(_surveyId) surveyActive(_surveyId) {
    require(!hasResponded[_surveyId][msg.sender], "Already responded to this survey");
    require(_dataHash != bytes32(0), "Invalid data hash");
    
    Response memory newResponse = Response({
        surveyId: _surveyId,
        respondent: msg.sender,
        dataHash: _dataHash,
        timestamp: block.timestamp
    });
    
    responses[_surveyId].push(newResponse);
    hasResponded[_surveyId][msg.sender] = true;
    surveys[_surveyId].totalResponses++;
    
    emit ResponseSubmitted(_surveyId, msg.sender, _dataHash);
}

응답 제출 함수는 여러 검증을 거쳐. 설문이 존재하는지, 활성화되어 있는지, 이미 응답했는지 등을 체크해. 중복 응답 방지는 블록체인의 큰 장점 중 하나야! 🛡️

namespace App\Services;

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

class BlockchainService
{
    protected $web3;
    protected $contract;
    protected $contractAddress;
    protected $abi;
    protected $account;
    protected $privateKey;
    
    public function __construct()
    {
        $this->web3 = new Web3(config('blockchain.rpc_url'));
        $this->contractAddress = config('blockchain.contract_address');
        $this->abi = json_decode(file_get_contents(storage_path('contracts/SurveyContract.json')), true);
        $this->account = config('blockchain.account');
        $this->privateKey = config('blockchain.private_key');
        
        $this->contract = new Contract($this->web3->provider, $this->abi);
    }
    
    public function createSurvey($title, $description, $startTime, $endTime)
    {
        try {
            $this->contract->at($this->contractAddress);
            
            $data = $this->contract->getData('createSurvey', 
                $title, 
                $description, 
                $startTime, 
                $endTime
            );
            
            $transaction = [
                'from' => $this->account,
                'to' => $this->contractAddress,
                'data' => $data,
                'gas' => '0x' . dechex(3000000),
            ];
            
            $signedTransaction = $this->signTransaction($transaction);
            
            $txHash = null;
            $this->web3->eth->sendRawTransaction($signedTransaction, function ($err, $hash) use (&$txHash) {
                if ($err !== null) {
                    throw new \Exception($err->getMessage());
                }
                $txHash = $hash;
            });
            
            return $txHash;
            
        } catch (\Exception $e) {
            \Log::error('Blockchain Error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    private function signTransaction($transaction)
    {
        // 트랜잭션 서명 로직
        // 실제 구현에서는 eth-php 같은 라이브러리 사용
        return $signedTx;
    }
}

이 서비스 클래스는 블록체인과의 모든 상호작용을 캡슐화해. 설정 파일에서 RPC URL, 컨트랙트 주소, 계정 정보를 가져와서 사용하지. 🔑

return [
    'rpc_url' => env('BLOCKCHAIN_RPC_URL', 'http://127.0.0.1:7545'),
    'contract_address' => env('BLOCKCHAIN_CONTRACT_ADDRESS'),
    'account' => env('BLOCKCHAIN_ACCOUNT'),
    'private_key' => env('BLOCKCHAIN_PRIVATE_KEY'),
    'chain_id' => env('BLOCKCHAIN_CHAIN_ID', 1337),
    'gas_limit' => env('BLOCKCHAIN_GAS_LIMIT', 3000000),
];

환경 변수로 관리하면 개발/스테이징/프로덕션 환경을 쉽게 전환할 수 있어. 특히 프라이빗 키는 절대 코드에 하드코딩하면 안 돼! 🚨

php artisan make:migration create_surveys_table

public function up()
{
    Schema::create('surveys', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->string('title');
        $table->text('description');
        $table->json('questions');
        $table->timestamp('start_time');
        $table->timestamp('end_time');
        $table->string('blockchain_tx_hash')->nullable();
        $table->unsignedBigInteger('blockchain_survey_id')->nullable();
        $table->boolean('is_active')->default(true);
        $table->timestamps();
        
        $table->index('blockchain_survey_id');
        $table->index('is_active');
    });
    
    Schema::create('survey_responses', function (Blueprint $table) {
        $table->id();
        $table->foreignId('survey_id')->constrained()->onDelete('cascade');
        $table->foreignId('user_id')->nullable()->constrained()->onDelete('set null');
        $table->string('respondent_address');
        $table->json('answers');
        $table->string('data_hash');
        $table->string('blockchain_tx_hash')->nullable();
        $table->timestamp('submitted_at');
        $table->timestamps();
        
        $table->unique(['survey_id', 'respondent_address']);
        $table->index('data_hash');
    });
}

blockchain_tx_hash와 blockchain_survey_id 필드로 온체인 데이터와 연결해. data_hash는 응답 데이터의 무결성을 검증하는 데 사용돼. 🔗

namespace App\Http\Controllers;

use App\Models\Survey;
use App\Services\BlockchainService;
use App\Jobs\CreateSurveyOnBlockchain;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class SurveyController extends Controller
{
    protected $blockchainService;
    
    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }
    
    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'required|string',
            'questions' => 'required|array',
            'questions.*.question' => 'required|string',
            'questions.*.type' => 'required|in:text,multiple_choice,rating',
            'questions.*.options' => 'array',
            'start_time' => 'required|date|after:now',
            'end_time' => 'required|date|after:start_time',
        ]);
        
        DB::beginTransaction();
        
        try {
            // 1. DB에 설문 저장
            $survey = Survey::create([
                'user_id' => auth()->id(),
                'title' => $validated['title'],
                'description' => $validated['description'],
                'questions' => $validated['questions'],
                'start_time' => $validated['start_time'],
                'end_time' => $validated['end_time'],
            ]);
            
            // 2. 블록체인에 등록 (비동기)
            CreateSurveyOnBlockchain::dispatch($survey);
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Survey created successfully',
                'data' => $survey,
            ], 201);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to create survey',
                'error' => $e->getMessage(),
            ], 500);
        }
    }
    
    public function submitResponse(Request $request, Survey $survey)
    {
        $validated = $request->validate([
            'answers' => 'required|array',
            'wallet_address' => 'required|string',
        ]);
        
        // 중복 응답 체크
        if ($survey->responses()->where('respondent_address', $validated['wallet_address'])->exists()) {
            return response()->json([
                'success' => false,
                'message' => 'You have already responded to this survey',
            ], 422);
        }
        
        DB::beginTransaction();
        
        try {
            // 데이터 해시 생성
            $dataHash = hash('sha256', json_encode($validated['answers']));
            
            // DB에 응답 저장
            $response = $survey->responses()->create([
                'user_id' => auth()->id(),
                'respondent_address' => $validated['wallet_address'],
                'answers' => $validated['answers'],
                'data_hash' => $dataHash,
                'submitted_at' => now(),
            ]);
            
            // 블록체인에 해시 기록 (비동기)
            SubmitResponseToBlockchain::dispatch($response, $survey);
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'message' => 'Response submitted successfully',
                'data_hash' => $dataHash,
            ], 201);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to submit response',
                'error' => $e->getMessage(),
            ], 500);
        }
    }
}

컨트롤러에서는 즉시 DB에 저장하고, 블록체인 작업은 Job으로 큐에 넣어. 사용자는 바로 응답을 받을 수 있고, 블록체인 기록은 백그라운드에서 처리되지. 이게 바로 사용자 경험과 블록체인의 완벽한 조화야! 🎭

namespace App\Jobs;

use App\Models\Survey;
use App\Services\BlockchainService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class CreateSurveyOnBlockchain implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $survey;
    public $tries = 3;
    public $timeout = 120;
    
    public function __construct(Survey $survey)
    {
        $this->survey = $survey;
    }
    
    public function handle(BlockchainService $blockchainService)
    {
        try {
            $startTime = strtotime($this->survey->start_time);
            $endTime = strtotime($this->survey->end_time);
            
            $txHash = $blockchainService->createSurvey(
                $this->survey->title,
                $this->survey->description,
                $startTime,
                $endTime
            );
            
            // 트랜잭션 해시 저장
            $this->survey->update([
                'blockchain_tx_hash' => $txHash,
            ]);
            
            // 트랜잭션 확인 대기
            $receipt = $blockchainService->waitForTransactionReceipt($txHash);
            
            // 블록체인 설문 ID 추출 및 저장
            $surveyId = $blockchainService->getSurveyIdFromReceipt($receipt);
            
            $this->survey->update([
                'blockchain_survey_id' => $surveyId,
            ]);
            
            \Log::info("Survey {$this->survey->id} successfully recorded on blockchain with ID {$surveyId}");
            
        } catch (\Exception $e) {
            \Log::error("Failed to create survey on blockchain: " . $e->getMessage());
            
            // 재시도 횟수 초과 시 관리자에게 알림
            if ($this->attempts() >= $this->tries) {
                // 알림 발송 로직
            }
            
            throw $e;
        }
    }
}

Job은 실패 시 자동으로 재시도해. $tries로 재시도 횟수를 설정하고, $timeout으로 최대 실행 시간을 제한해. 블록체인 네트워크가 혼잡할 때를 대비한 안전장치야. 🛡️

// resources/js/components/WalletConnect.vue
<template>
  <div class="wallet-connect">
    <div v-if="!isConnected" class="connect-section">
      <button @click="connectWallet" class="connect-btn">
        🦊 Connect MetaMask
      </button>
    </div>
    
    <div v-else class="connected-section">
      <div class="wallet-info">
        <span class="address">{{ shortenAddress(account) }}</span>
        <span class="balance">{{ balance }} ETH</span>
      </div>
      <button @click="disconnectWallet" class="disconnect-btn">
        Disconnect
      </button>
    </div>
  </div>
</template>

<script>
import { ref, onMounted } from 'vue';
import detectEthereumProvider from '@metamask/detect-provider';
import Web3 from 'web3';

export default {
  name: 'WalletConnect',
  
  setup() {
    const isConnected = ref(false);
    const account = ref('');
    const balance = ref('0');
    const web3 = ref(null);
    
    const connectWallet = async () => {
      try {
        const provider = await detectEthereumProvider();
        
        if (!provider) {
          alert('Please install MetaMask!');
          return;
        }
        
        web3.value = new Web3(provider);
        
        const accounts = await provider.request({ 
          method: 'eth_requestAccounts' 
        });
        
        account.value = accounts[0];
        isConnected.value = true;
        
        await updateBalance();
        
        // 계정 변경 감지
        provider.on('accountsChanged', handleAccountsChanged);
        
        // 체인 변경 감지
        provider.on('chainChanged', () => {
          window.location.reload();
        });
        
      } catch (error) {
        console.error('Failed to connect wallet:', error);
        alert('Failed to connect wallet. Please try again.');
      }
    };
    
    const updateBalance = async () => {
      if (!web3.value || !account.value) return;
      
      const balanceWei = await web3.value.eth.getBalance(account.value);
      balance.value = web3.value.utils.fromWei(balanceWei, 'ether');
    };
    
    const handleAccountsChanged = (accounts) => {
      if (accounts.length === 0) {
        disconnectWallet();
      } else {
        account.value = accounts[0];
        updateBalance();
      }
    };
    
    const disconnectWallet = () => {
      isConnected.value = false;
      account.value = '';
      balance.value = '0';
    };
    
    const shortenAddress = (address) => {
      if (!address) return '';
      return `${address.slice(0, 6)}...${address.slice(-4)}`;
    };
    
    onMounted(async () => {
      const provider = await detectEthereumProvider();
      if (provider && provider.selectedAddress) {
        account.value = provider.selectedAddress;
        isConnected.value = true;
        web3.value = new Web3(provider);
        await updateBalance();
      }
    });
    
    return {
      isConnected,
      account,
      balance,
      connectWallet,
      disconnectWallet,
      shortenAddress,
    };
  },
};
</script>

MetaMask 연동은 생각보다 간단해. eth_requestAccounts로 계정 접근 권한을 요청하고, 이벤트 리스너로 계정 변경을 감지해. 사용자가 지갑을 전환하면 자동으로 업데이트되지! 🔄

// resources/js/components/SurveyResponse.vue
<template>
  <div class="survey-response">
    <div class="survey-header">
      <h2>{{ survey.title }}</h2>
      <p>{{ survey.description }}</p>
    </div>
    
    <form @submit.prevent="submitResponse">
      <div 
        v-for="(question, index) in survey.questions" 
        :key="index"
        class="question-block"
      >
        <label>{{ index + 1 }}. {{ question.question }}</label>
        
        <input 
          v-if="question.type === 'text'"
          v-model="answers[index]"
          type="text"
          required
        />
        
        <div v-else-if="question.type === 'multiple_choice'">
          <label 
            v-for="(option, optIndex) in question.options"
            :key="optIndex"
          >
            <input 
              v-model="answers[index]"
              type="radio"
              :value="option"
              required
            />
            {{ option }}
          </label>
        </div>
        
        <input 
          v-else-if="question.type === 'rating'"
          v-model="answers[index]"
          type="range"
          min="1"
          max="5"
          required
        />
      </div>
      
      <div class="submit-section">
        <button 
          type="submit" 
          :disabled="isSubmitting || !walletConnected"
          class="submit-btn"
        >
          {{ isSubmitting ? 'Submitting...' : 'Submit Response' }}
        </button>
        
        <div v-if="txHash" class="tx-info">
          <p>✅ Response submitted!</p>
          <a :href="getEtherscanLink(txHash)" target="_blank">
            View on Blockchain
          </a>
        </div>
      </div>
    </form>
  </div>
</template>

<script>
import { ref, computed } from 'vue';
import axios from 'axios';

export default {
  name: 'SurveyResponse',
  
  props: {
    survey: {
      type: Object,
      required: true,
    },
    walletAddress: {
      type: String,
      required: true,
    },
  },
  
  setup(props) {
    const answers = ref({});
    const isSubmitting = ref(false);
    const txHash = ref('');
    
    const walletConnected = computed(() => {
      return props.walletAddress && props.walletAddress.length > 0;
    });
    
    const submitResponse = async () => {
      if (!walletConnected.value) {
        alert('Please connect your wallet first!');
        return;
      }
      
      isSubmitting.value = true;
      
      try {
        const response = await axios.post(
          `/api/surveys/${props.survey.id}/responses`,
          {
            answers: answers.value,
            wallet_address: props.walletAddress,
          }
        );
        
        if (response.data.success) {
          txHash.value = response.data.blockchain_tx_hash;
          alert('Response submitted successfully! 🎉');
          
          // 블록체인 확인 대기
          await waitForConfirmation(txHash.value);
        }
        
      } catch (error) {
        console.error('Failed to submit response:', error);
        
        if (error.response?.data?.message) {
          alert(error.response.data.message);
        } else {
          alert('Failed to submit response. Please try again.');
        }
      } finally {
        isSubmitting.value = false;
      }
    };
    
    const waitForConfirmation = async (hash) => {
      // 트랜잭션 확인 폴링
      const maxAttempts = 30;
      let attempts = 0;
      
      const checkStatus = async () => {
        try {
          const response = await axios.get(`/api/transactions/${hash}/status`);
          
          if (response.data.confirmed) {
            console.log('Transaction confirmed!');
            return true;
          }
          
          if (attempts < maxAttempts) {
            attempts++;
            setTimeout(checkStatus, 2000);
          }
        } catch (error) {
          console.error('Failed to check transaction status:', error);
        }
      };
      
      await checkStatus();
    };
    
    const getEtherscanLink = (hash) => {
      const network = process.env.MIX_BLOCKCHAIN_NETWORK || 'localhost';
      
      if (network === 'mainnet') {
        return `https://etherscan.io/tx/${hash}`;
      } else if (network === 'goerli') {
        return `https://goerli.etherscan.io/tx/${hash}`;
      }
      
      return '#';
    };
    
    return {
      answers,
      isSubmitting,
      txHash,
      walletConnected,
      submitResponse,
      getEtherscanLink,
    };
  },
};
</script>

응답 제출 후에는 트랜잭션 해시를 받아서 Etherscan 같은 블록 익스플로러 링크를 제공해. 사용자가 직접 블록체인에서 자신의 응답을 확인할 수 있어서 투명성이 극대화되지! 🔍

public function getResults(Survey $survey)
{
    // 권한 체크 (설문 생성자만 조회 가능)
    if ($survey->user_id !== auth()->id()) {
        return response()->json([
            'success' => false,
            'message' => 'Unauthorized',
        ], 403);
    }
    
    $responses = $survey->responses()
        ->with('user')
        ->get();
    
    // 통계 계산
    $statistics = $this->calculateStatistics($survey, $responses);
    
    // 블록체인 검증
    $blockchainVerification = $this->verifyOnBlockchain($survey);
    
    return response()->json([
        'success' => true,
        'data' => [
            'survey' => $survey,
            'total_responses' => $responses->count(),
            'responses' => $responses,
            'statistics' => $statistics,
            'blockchain_verification' => $blockchainVerification,
        ],
    ]);
}

private function calculateStatistics($survey, $responses)
{
    $statistics = [];
    
    foreach ($survey->questions as $index => $question) {
        $questionStats = [
            'question' => $question['question'],
            'type' => $question['type'],
        ];
        
        if ($question['type'] === 'multiple_choice') {
            $choices = [];
            
            foreach ($responses as $response) {
                $answer = $response->answers[$index] ?? null;
                if ($answer) {
                    $choices[$answer] = ($choices[$answer] ?? 0) + 1;
                }
            }
            
            $questionStats['choices'] = $choices;
            
        } elseif ($question['type'] === 'rating') {
            $ratings = [];
            
            foreach ($responses as $response) {
                $rating = $response->answers[$index] ?? null;
                if ($rating) {
                    $ratings[] = (int)$rating;
                }
            }
            
            $questionStats['average'] = count($ratings) > 0 
                ? array_sum($ratings) / count($ratings) 
                : 0;
            $questionStats['distribution'] = array_count_values($ratings);
        }
        
        $statistics[] = $questionStats;
    }
    
    return $statistics;
}

private function verifyOnBlockchain($survey)
{
    try {
        $blockchainData = $this->blockchainService->getSurveyData(
            $survey->blockchain_survey_id
        );
        
        $dbResponseCount = $survey->responses()->count();
        $blockchainResponseCount = $blockchainData['totalResponses'];
        
        $isValid = ($dbResponseCount === $blockchainResponseCount);
        
        return [
            'is_valid' => $isValid,
            'db_count' => $dbResponseCount,
            'blockchain_count' => $blockchainResponseCount,
            'blockchain_tx' => $survey->blockchain_tx_hash,
            'verified_at' => now(),
        ];
        
    } catch (\Exception $e) {
        return [
            'is_valid' => false,
            'error' => $e->getMessage(),
        ];
    }
}

결과 조회 시 DB의 응답 수와 블록체인의 응답 수를 비교해서 데이터 무결성을 검증해. 만약 불일치하면 데이터 조작 가능성을 의심할 수 있지. 이게 바로 블록체인의 힘이야! 💪

public function verifyResponse(Request $request)
{
    $validated = $request->validate([
        'response_id' => 'required|exists:survey_responses,id',
        'data_hash' => 'required|string',
    ]);
    
    $response = SurveyResponse::findOrFail($validated['response_id']);
    
    // 1. DB 해시 확인
    $dbHashMatch = ($response->data_hash === $validated['data_hash']);
    
    // 2. 블록체인에서 해시 조회
    try {
        $blockchainHash = $this->blockchainService->getResponseHash(
            $response->survey->blockchain_survey_id,
            $response->respondent_address
        );
        
        $blockchainHashMatch = ($blockchainHash === $validated['data_hash']);
        
        // 3. 실제 데이터로 해시 재계산
        $calculatedHash = hash('sha256', json_encode($response->answers));
        $dataIntegrityCheck = ($calculatedHash === $validated['data_hash']);
        
        return response()->json([
            'success' => true,
            'verification' => [
                'db_hash_match' => $dbHashMatch,
                'blockchain_hash_match' => $blockchainHashMatch,
                'data_integrity_check' => $dataIntegrityCheck,
                'is_verified' => $dbHashMatch && $blockchainHashMatch && $dataIntegrityCheck,
                'verified_at' => now(),
            ],
        ]);
        
    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => 'Verification failed',
            'error' => $e->getMessage(),
        ], 500);
    }
}

3중 검증 시스템이야. DB 해시, 블록체인 해시, 실제 데이터 해시를 모두 비교해서 완벽한 무결성을 보장해. 하나라도 다르면 데이터가 변조된 거지. 🔒

namespace App\Services;

use Illuminate\Support\Facades\Crypt;

class EncryptionService
{
    public function encryptSurveyResponse($answers, $publicKey = null)
    {
        // 1. 응답 데이터를 JSON으로 직렬화
        $jsonData = json_encode($answers);
        
        // 2. 대칭키 암호화 (Laravel의 기본 암호화)
        $encrypted = Crypt::encryptString($jsonData);
        
        // 3. 해시 생성 (블록체인에 저장할 용도)
        $hash = hash('sha256', $jsonData);
        
        // 4. 공개키 암호화 (선택적, 특정 수신자만 복호화 가능)
        if ($publicKey) {
            $encrypted = $this->publicKeyEncrypt($encrypted, $publicKey);
        }
        
        return [
            'encrypted_data' => $encrypted,
            'hash' => $hash,
        ];
    }
    
    public function decryptSurveyResponse($encryptedData, $privateKey = null)
    {
        try {
            // 공개키 암호화가 적용된 경우
            if ($privateKey) {
                $encryptedData = $this->privateKeyDecrypt($encryptedData, $privateKey);
            }
            
            // 대칭키 복호화
            $jsonData = Crypt::decryptString($encryptedData);
            
            return json_decode($jsonData, true);
            
        } catch (\Exception $e) {
            throw new \Exception('Decryption failed: ' . $e->getMessage());
        }
    }
    
    private function publicKeyEncrypt($data, $publicKey)
    {
        openssl_public_encrypt($data, $encrypted, $publicKey);
        return base64_encode($encrypted);
    }
    
    private function privateKeyDecrypt($data, $privateKey)
    {
        $data = base64_decode($data);
        openssl_private_decrypt($data, $decrypted, $privateKey);
        return $decrypted;
    }
}

민감한 응답 데이터는 암호화해서 DB에 저장하고, 해시만 블록체인에 올려. 이렇게 하면 블록체인의 투명성은 유지하면서도 프라이버시를 보호할 수 있어. 🔐

public function submitAnonymousResponse(Request $request, Survey $survey)
{
    $validated = $request->validate([
        'answers' => 'required|array',
        'wallet_signature' => 'required|string',
    ]);
    
    // 1. 서명 검증 (지갑 소유 증명)
    $isValidSignature = $this->verifyWalletSignature(
        $validated['wallet_signature'],
        $request->ip()
    );
    
    if (!$isValidSignature) {
        return response()->json([
            'success' => false,
            'message' => 'Invalid signature',
        ], 422);
    }
    
    // 2. 익명 식별자 생성 (지갑 주소를 직접 저장하지 않음)
    $anonymousId = hash('sha256', $validated['wallet_signature'] . $survey->id);
    
    // 3. 중복 응답 체크 (익명 ID로)
    if ($survey->responses()->where('anonymous_id', $anonymousId)->exists()) {
        return response()->json([
            'success' => false,
            'message' => 'Already responded',
        ], 422);
    }
    
    // 4. 응답 저장 (지갑 주소 없이)
    $response = $survey->responses()->create([
        'anonymous_id' => $anonymousId,
        'answers' => $this->encryptionService->encryptSurveyResponse($validated['answers']),
        'data_hash' => hash('sha256', json_encode($validated['answers'])),
        'submitted_at' => now(),
    ]);
    
    // 5. 블록체인에는 익명 ID의 해시만 기록
    SubmitAnonymousResponseToBlockchain::dispatch($response, $survey);
    
    return response()->json([
        'success' => true,
        'message' => 'Anonymous response submitted',
    ]);
}

완전한 익명성이 필요한 경우, 지갑 주소 대신 익명 식별자를 사용해. 서명으로 본인 인증은 하되, 실제 주소는 저장하지 않는 거지. 이렇게 하면 프라이버시와 무결성을 동시에 달성할 수 있어! 🎭

// 스마트 컨트랙트에 배치 제출 함수 추가
function submitResponseBatch(
    uint256 _surveyId,
    bytes32[] memory _dataHashes,
    address[] memory _respondents
) public surveyExists(_surveyId) surveyActive(_surveyId) {
    require(_dataHashes.length == _respondents.length, "Array length mismatch");
    require(_dataHashes.length <= 50, "Batch size too large");
    
    for (uint256 i = 0; i < _dataHashes.length; i++) {
        require(!hasResponded[_surveyId][_respondents[i]], "Duplicate respondent");
        require(_dataHashes[i] != bytes32(0), "Invalid hash");
        
        Response memory newResponse = Response({
            surveyId: _surveyId,
            respondent: _respondents[i],
            dataHash: _dataHashes[i],
            timestamp: block.timestamp
        });
        
        responses[_surveyId].push(newResponse);
        hasResponded[_surveyId][_respondents[i]] = true;
    }
    
    surveys[_surveyId].totalResponses += _dataHashes.length;
    
    emit ResponseBatchSubmitted(_surveyId, _dataHashes.length);
}

여러 응답을 한 번의 트랜잭션으로 처리하면 가스비를 크게 절약할 수 있어. 개별 트랜잭션 대비 최대 70% 이상 절감도 가능해! 💰

namespace App\Services;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Redis;

class BlockchainCacheService
{
    public function getCachedSurveyData($surveyId)
    {
        $cacheKey = "blockchain:survey:{$surveyId}";
        
        return Cache::remember($cacheKey, 300, function () use ($surveyId) {
            return $this->blockchainService->getSurveyData($surveyId);
        });
    }
    
    public function getCachedResponseCount($surveyId)
    {
        $cacheKey = "blockchain:survey:{$surveyId}:responses";
        
        // Redis를 사용한 실시간 카운터
        $count = Redis::get($cacheKey);
        
        if ($count === null) {
            $count = $this->blockchainService->getResponseCount($surveyId);
            Redis::setex($cacheKey, 60, $count);
        }
        
        return (int)$count;
    }
    
    public function invalidateSurveyCache($surveyId)
    {
        Cache::forget("blockchain:survey:{$surveyId}");
        Redis::del("blockchain:survey:{$surveyId}:responses");
    }
    
    public function warmUpCache($surveyId)
    {
        // 자주 조회되는 데이터를 미리 캐싱
        $this->getCachedSurveyData($surveyId);
        $this->getCachedResponseCount($surveyId);
    }
}

블록체인 조회는 느릴 수 있으니까 적극적으로 캐싱해. 특히 자주 변하지 않는 설문 메타데이터는 5분 정도 캐싱해도 문제없어. 응답 수 같은 실시간 데이터는 Redis로 짧게 캐싱하면 돼! ⚡

// config/blockchain.php에 레이어2 설정 추가
return [
    'layer2' => [
        'enabled' => env('BLOCKCHAIN_LAYER2_ENABLED', false),
        'provider' => env('BLOCKCHAIN_LAYER2_PROVIDER', 'polygon'),
        'rpc_url' => env('BLOCKCHAIN_LAYER2_RPC_URL'),
        'chain_id' => env('BLOCKCHAIN_LAYER2_CHAIN_ID'),
    ],
    
    // 트랜잭션 우선순위 설정
    'transaction_priority' => [
        'survey_creation' => 'layer1', // 중요한 건 메인넷
        'response_submission' => 'layer2', // 빈번한 건 레이어2
        'result_finalization' => 'layer1',
    ],
];

Polygon이나 Arbitrum 같은 레이어2를 사용하면 가스비를 100분의 1 수준으로 줄일 수 있어. 응답 제출처럼 빈번한 트랜잭션은 레이어2에서 처리하고, 설문 생성이나 최종 결과 같은 중요한 건 메인넷에 기록하는 하이브리드 전략이 효과적이야! 🎯

// test/SurveyContract.test.js
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("SurveyContract", function () {
    let surveyContract;
    let owner;
    let addr1;
    let addr2;
    
    beforeEach(async function () {
        [owner, addr1, addr2] = await ethers.getSigners();
        
        const SurveyContract = await ethers.getContractFactory("SurveyContract");
        surveyContract = await SurveyContract.deploy();
        await surveyContract.deployed();
    });
    
    describe("Survey Creation", function () {
        it("Should create a survey successfully", async function () {
            const title = "Test Survey";
            const description = "This is a test";
            const startTime = Math.floor(Date.now() / 1000) + 3600;
            const endTime = startTime + 86400;
            
            await expect(
                surveyContract.createSurvey(title, description, startTime, endTime)
            ).to.emit(surveyContract, "SurveyCreated");
            
            const survey = await surveyContract.surveys(1);
            expect(survey.title).to.equal(title);
            expect(survey.creator).to.equal(owner.address);
        });
        
        it("Should reject invalid time range", async function () {
            const startTime = Math.floor(Date.now() / 1000) + 3600;
            const endTime = startTime - 1000;
            
            await expect(
                surveyContract.createSurvey("Test", "Test", startTime, endTime)
            ).to.be.revertedWith("Invalid time range");
        });
    });
    
    describe("Response Submission", function () {
        let surveyId;
        
        beforeEach(async function () {
            const startTime = Math.floor(Date.now() / 1000);
            const endTime = startTime + 86400;
            
            const tx = await surveyContract.createSurvey(
                "Test Survey",
                "Description",
                startTime,
                endTime
            );
            
            const receipt = await tx.wait();
            surveyId = receipt.events[0].args.surveyId;
        });
        
        it("Should submit response successfully", async function () {
            const dataHash = ethers.utils.id("test response data");
            
            await expect(
                surveyContract.connect(addr1).submitResponse(surveyId, dataHash)
            ).to.emit(surveyContract, "ResponseSubmitted");
            
            const hasResponded = await surveyContract.hasResponded(surveyId, addr1.address);
            expect(hasResponded).to.be.true;
        });
        
        it("Should prevent duplicate responses", async function () {
            const dataHash = ethers.utils.id("test response data");
            
            await surveyContract.connect(addr1).submitResponse(surveyId, dataHash);
            
            await expect(
                surveyContract.connect(addr1).submitResponse(surveyId, dataHash)
            ).to.be.revertedWith("Already responded to this survey");
        });
    });
});

Hardhat으로 스마트 컨트랙트를 철저히 테스트해. 모든 엣지 케이스를 커버하고, 가스 사용량도 측정해야 해. 테스트 커버리지 90% 이상을 목표로 하자! 📊

namespace Tests\Feature;

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

class SurveyTest extends TestCase
{
    use RefreshDatabase;
    
    protected $user;
    
    protected function setUp(): void
    {
        parent::setUp();
        $this->user = User::factory()->create();
    }
    
    public function test_user_can_create_survey()
    {
        $this->actingAs($this->user);
        
        $surveyData = [
            'title' => 'Test Survey',
            'description' => 'This is a test survey',
            'questions' => [
                [
                    'question' => 'What is your favorite color?',
                    'type' => 'multiple_choice',
                    'options' => ['Red', 'Blue', 'Green'],
                ],
            ],
            'start_time' => now()->addHour(),
            'end_time' => now()->addDay(),
        ];
        
        $response = $this->postJson('/api/surveys', $surveyData);
        
        $response->assertStatus(201)
            ->assertJson([
                'success' => true,
            ]);
        
        $this->assertDatabaseHas('surveys', [
            'title' => 'Test Survey',
            'user_id' => $this->user->id,
        ]);
    }
    
    public function test_user_can_submit_response()
    {
        $survey = Survey::factory()->create([
            'start_time' => now()->subHour(),
            'end_time' => now()->addDay(),
        ]);
        
        $responseData = [
            'answers' => [
                0 => 'Blue',
            ],
            'wallet_address' => '0x1234567890123456789012345678901234567890',
        ];
        
        $response = $this->postJson("/api/surveys/{$survey->id}/responses", $responseData);
        
        $response->assertStatus(201)
            ->assertJson([
                'success' => true,
            ]);
        
        $this->assertDatabaseHas('survey_responses', [
            'survey_id' => $survey->id,
            'respondent_address' => $responseData['wallet_address'],
        ]);
    }
    
    public function test_duplicate_response_is_prevented()
    {
        $survey = Survey::factory()->create([
            'start_time' => now()->subHour(),
            'end_time' => now()->addDay(),
        ]);
        
        $walletAddress = '0x1234567890123456789012345678901234567890';
        
        $responseData = [
            'answers' => [0 => 'Blue'],
            'wallet_address' => $walletAddress,
        ];
        
        // 첫 번째 응답
        $this->postJson("/api/surveys/{$survey->id}/responses", $responseData);
        
        // 두 번째 응답 시도
        $response = $this->postJson("/api/surveys/{$survey->id}/responses", $responseData);
        
        $response->assertStatus(422)
            ->assertJson([
                'success' => false,
                'message' => 'You have already responded to this survey',
            ]);
    }
}

라라벨의 테스트 기능을 활용해서 API 엔드포인트를 검증해. 블록체인 부분은 Mock으로 처리하면 테스트 속도가 빨라져. 🏃‍♂️

전통적인 주주총회는 대리인 투표나 우편 투표로 진행되는데, 투명성 문제가 항상 제기돼. 블록체인 기반 투표 시스템을 사용하면:

• 각 주주의 투표가 블록체인에 기록되어 조작 불가
• 실시간 개표 결과 확인 가능
• 투표 참여율 향상 (모바일로 간편하게)
• 법적 분쟁 시 명확한 증거 자료

실제로 나스닥은 2015년부터 블록체인 기반 주주 투표 시스템을 테스트하고 있어. 우리가 만든 시스템도 충분히 이런 용도로 사용할 수 있지! 📈

정부가 중요한 정책을 결정할 때 국민 의견을 수렴하는데, 기존 방식은 신뢰도가 낮았어. 블록체인을 활용하면:

• 조작 불가능한 투명한 여론조사
• 익명성 보장으로 솔직한 의견 수렴
• 실시간 결과 공개로 신뢰도 향상
• 지역별, 연령별 통계 분석 가능

스위스 일부 지역에서는 이미 블록체인 기반 주민투표를 시범 운영 중이야. 미래에는 이게 표준이 될 거야! 🗳️

학술 연구에서 설문조사 데이터의 무결성은 정말 중요해. 논문 심사나 재현 연구에서 데이터 조작 의혹이 제기되면 큰 문제가 되거든. 블록체인을 사용하면:

• 연구 데이터의 타임스탬프 증명
• 데이터 수집 과정의 투명성 확보
• 동료 평가(peer review) 시 신뢰도 향상
• 데이터 공유 및 재현 연구 용이

이미 몇몇 학술지는 블록체인 기반 데이터 검증을 요구하기 시작했어. 연구 윤리가 강화되는 추세야! 🔬

ZK-SNARK 같은 영지식 증명 기술을 사용하면, 응답 내용을 공개하지 않고도 유효성을 증명할 수 있어. 예를 들어 "나는 18세 이상이다"를 증명하되, 정확한 나이는 공개하지 않는 거지.

// 미래의 코드 예시 (개념적)
function submitZKProof(
    uint256 _surveyId,
    bytes memory _proof,
    bytes32 _publicInputHash
) public {
    require(verifyZKProof(_proof, _publicInputHash), "Invalid proof");
    
    // 실제 데이터 없이 유효성만 검증
    recordResponse(_surveyId, msg.sender, _publicInputHash);
}

설문 생성, 검증, 결과 공개 등의 과정을 DAO(탈중앙화 자율조직)로 관리할 수 있어. 토큰 홀더들이 투표로 중요한 결정을 내리는 거지.

• 설문 주제 제안 및 투표
• 부적절한 설문 신고 및 제재
• 보상 시스템 운영 (응답자에게 토큰 지급)
• 플랫폼 수수료 및 정책 결정

완전히 탈중앙화된 설문 플랫폼이 가능해지는 거야! 🌐

블록체인으로 수집된 신뢰할 수 있는 데이터를 AI 학습에 활용할 수 있어. 특히 감정 분석, 트렌드 예측, 이상 응답 탐지 등에 유용하지.

// AI 분석 서비스 예시
class AIAnalysisService
{
    public function analyzeSentiment($surveyId)
    {
        $responses = $this->getVerifiedResponses($surveyId);
        
        // 블록체인으로 검증된 데이터만 사용
        $verifiedData = $responses->filter(function ($response) {
            return $this->verifyOnBlockchain($response);
        });
        
        // AI 모델로 감정 분석
        $sentiment = $this->aiModel->analyze($verifiedData);
        
        return $sentiment;
    }
}

여러 블록체인 네트워크에서 설문 데이터를 공유하고 검증할 수 있어. 예를 들어 이더리움에서 생성한 설문을 Polygon에서 응답하고, BSC에서 결과를 조회하는 식이지.

• Chainlink 같은 오라클로 크로스체인 데이터 전송
• Cosmos IBC나 Polkadot 파라체인 활용
• 멀티체인 지갑 지원으로 사용자 편의성 향상

블록체인 생태계가 통합되면서 더 강력한 서비스가 가능해질 거야! 🌉