🧩 DID 레지스트리 스마트 컨트랙트 예제

아래는 Ethereum 블록체인에서 DID를 관리하는 간단한 스마트 컨트랙트 예제야:

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

contract DIDRegistry {
    // DID 문서 구조체
    struct DIDDocument {
        address controller;       // DID 소유자
        string publicKeyHex;      // 공개키 (16진수 문자열)
        string serviceEndpoint;   // 서비스 엔드포인트
        uint256 lastUpdated;      // 마지막 업데이트 시간
        bool active;              // 활성화 상태
    }
    
    // DID -> DID 문서 매핑
    mapping(string => DIDDocument) private didDocuments;
    
    // 이벤트 정의
    event DIDCreated(string did, address controller);
    event DIDUpdated(string did, address controller);
    event DIDDeactivated(string did, address controller);
    
    // DID 생성
    function createDID(
        string memory did,
        string memory publicKeyHex,
        string memory serviceEndpoint
    ) public {
        // 이미 존재하는 DID인지 확인
        require(!didDocuments[did].active, "DID already exists");
        
        // DID 문서 생성
        didDocuments[did] = DIDDocument({
            controller: msg.sender,
            publicKeyHex: publicKeyHex,
            serviceEndpoint: serviceEndpoint,
            lastUpdated: block.timestamp,
            active: true
        });
        
        // 이벤트 발생
        emit DIDCreated(did, msg.sender);
    }
    
    // DID 업데이트
    function updateDID(
        string memory did,
        string memory publicKeyHex,
        string memory serviceEndpoint
    ) public {
        // DID 존재 여부와 소유권 확인
        require(didDocuments[did].active, "DID does not exist");
        require(didDocuments[did].controller == msg.sender, "Not authorized");
        
        // DID 문서 업데이트
        didDocuments[did].publicKeyHex = publicKeyHex;
        didDocuments[did].serviceEndpoint = serviceEndpoint;
        didDocuments[did].lastUpdated = block.timestamp;
        
        // 이벤트 발생
        emit DIDUpdated(did, msg.sender);
    }
    
    // DID 비활성화
    function deactivateDID(string memory did) public {
        // DID 존재 여부와 소유권 확인
        require(didDocuments[did].active, "DID does not exist or already deactivated");
        require(didDocuments[did].controller == msg.sender, "Not authorized");
        
        // DID 비활성화
        didDocuments[did].active = false;
        didDocuments[did].lastUpdated = block.timestamp;
        
        // 이벤트 발생
        emit DIDDeactivated(did, msg.sender);
    }
    
    // DID 문서 조회
    function resolveDID(string memory did) public view returns (
        address controller,
        string memory publicKeyHex,
        string memory serviceEndpoint,
        uint256 lastUpdated,
        bool active
    ) {
        DIDDocument memory doc = didDocuments[did];
        return (
            doc.controller,
            doc.publicKeyHex,
            doc.serviceEndpoint,
            doc.lastUpdated,
            doc.active
        );
    }
}

🎓 VC 레지스트리 스마트 컨트랙트 예제

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

contract VCRegistry {
    // VC 상태 열거형
    enum VCStatus { ACTIVE, SUSPENDED, REVOKED }
    
    // VC 구조체
    struct VerifiableCredential {
        string id;                // VC의 고유 ID
        string issuerDID;         // 발급자 DID
        string subjectDID;        // 소유자 DID
        string schemaId;          // VC 스키마 ID
        string credentialHash;    // VC 내용의 해시
        uint256 issuanceDate;     // 발급 일자
        uint256 expirationDate;   // 만료 일자
        VCStatus status;          // VC 상태
    }
    
    // VC ID -> VC 매핑
    mapping(string => VerifiableCredential) private credentials;
    
    // 발급자 DID -> 발급자 주소 매핑
    mapping(string => address) private issuers;
    
    // 이벤트 정의
    event VCIssued(string vcId, string issuerDID, string subjectDID);
    event VCSuspended(string vcId, string issuerDID);
    event VCRevoked(string vcId, string issuerDID);
    event IssuerRegistered(string issuerDID, address issuerAddress);
    
    // 발급자 등록
    function registerIssuer(string memory issuerDID) public {
        issuers[issuerDID] = msg.sender;
        emit IssuerRegistered(issuerDID, msg.sender);
    }
    
    // VC 발급
    function issueVC(
        string memory vcId,
        string memory issuerDID,
        string memory subjectDID,
        string memory schemaId,
        string memory credentialHash,
        uint256 expirationDate
    ) public {
        // 발급자 확인
        require(issuers[issuerDID] == msg.sender, "Not authorized issuer");
        // VC ID 중복 확인
        require(bytes(credentials[vcId].id).length == 0, "VC ID already exists");
        
        // VC 생성
        credentials[vcId] = VerifiableCredential({
            id: vcId,
            issuerDID: issuerDID,
            subjectDID: subjectDID,
            schemaId: schemaId,
            credentialHash: credentialHash,
            issuanceDate: block.timestamp,
            expirationDate: expirationDate,
            status: VCStatus.ACTIVE
        });
        
        // 이벤트 발생
        emit VCIssued(vcId, issuerDID, subjectDID);
    }
    
    // VC 일시 중지
    function suspendVC(string memory vcId) public {
        VerifiableCredential storage vc = credentials[vcId];
        
        // VC 존재 여부 확인
        require(bytes(vc.id).length > 0, "VC does not exist");
        // 발급자 확인
        require(issuers[vc.issuerDID] == msg.sender, "Not authorized issuer");
        // 상태 확인
        require(vc.status == VCStatus.ACTIVE, "VC is not active");
        
        // VC 상태 변경
        vc.status = VCStatus.SUSPENDED;
        
        // 이벤트 발생
        emit VCSuspended(vcId, vc.issuerDID);
    }
    
    // VC 폐기
    function revokeVC(string memory vcId) public {
        VerifiableCredential storage vc = credentials[vcId];
        
        // VC 존재 여부 확인
        require(bytes(vc.id).length > 0, "VC does not exist");
        // 발급자 확인
        require(issuers[vc.issuerDID] == msg.sender, "Not authorized issuer");
        // 이미 폐기된 VC인지 확인
        require(vc.status != VCStatus.REVOKED, "VC already revoked");
        
        // VC 상태 변경
        vc.status = VCStatus.REVOKED;
        
        // 이벤트 발생
        emit VCRevoked(vcId, vc.issuerDID);
    }
    
    // VC 상태 확인
    function verifyVC(string memory vcId) public view returns (
        string memory issuerDID,
        string memory subjectDID,
        uint256 issuanceDate,
        uint256 expirationDate,
        VCStatus status
    ) {
        VerifiableCredential memory vc = credentials[vcId];
        
        // VC 존재 여부 확인
        require(bytes(vc.id).length > 0, "VC does not exist");
        
        return (
            vc.issuerDID,
            vc.subjectDID,
            vc.issuanceDate,
            vc.expirationDate,
            vc.status
        );
    }
}

🧩 React로 구현한 DID 생성 컴포넌트

import React, { useState } from 'react';
import { ethers } from 'ethers';
import DIDRegistryABI from '../abis/DIDRegistry.json';

const DIDCreator = () => {
  const [did, setDid] = useState('');
  const [publicKey, setPublicKey] = useState('');
  const [endpoint, setEndpoint] = useState('');
  const [loading, setLoading] = useState(false);
  const [success, setSuccess] = useState(false);
  const [error, setError] = useState('');

  // DID 생성 함수
  const createDID = async () => {
    try {
      setLoading(true);
      setError('');
      
      // MetaMask 연결
      if (!window.ethereum) {
        throw new Error('MetaMask가 설치되어 있지 않습니다.');
      }
      
      await window.ethereum.request({ method: 'eth_requestAccounts' });
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      
      // 컨트랙트 인스턴스 생성
      const contractAddress = '0x123...'; // DID 레지스트리 컨트랙트 주소
      const contract = new ethers.Contract(
        contractAddress,
        DIDRegistryABI,
        signer
      );
      
      // 랜덤 DID 생성 (실제로는 더 복잡한 로직이 필요)
      const randomDid = `did:example:${Math.random().toString(36).substring(2, 15)}`;
      setDid(randomDid);
      
      // 공개키 생성 (실제로는 암호학적으로 안전한 키 생성 필요)
      const wallet = ethers.Wallet.createRandom();
      const generatedPublicKey = wallet.publicKey;
      setPublicKey(generatedPublicKey);
      
      // 기본 엔드포인트 설정
      const defaultEndpoint = `https://example.com/identity/${randomDid}`;
      setEndpoint(defaultEndpoint);
      
      // 컨트랙트 호출
      const tx = await contract.createDID(
        randomDid,
        generatedPublicKey,
        defaultEndpoint
      );
      
      // 트랜잭션 완료 대기
      await tx.wait();
      
      setSuccess(true);
      setLoading(false);
    } catch (err) {
      console.error('DID 생성 오류:', err);
      setError(err.message || '알 수 없는 오류가 발생했습니다.');
      setLoading(false);
    }
  };

  return (
    <div classname="did-creator">
      <h2>새 디지털 신원(DID) 생성</h2>
      
      {!success ? (
        <div>
          <p>블록체인에 새로운 디지털 신원을 생성합니다. 이 과정은 약간의 시간이 소요될 수 있습니다.</p>
          
          <button onclick="{createDID}" disabled classname="create-button">
            {loading ? '처리 중...' : '신원 생성하기'}
          </button>
          
          {error && <p classname="error-message">{error}</p>}
        </div>
      ) : (
        <div classname="success-message">
          <h3>🎉 축하합니다! 디지털 신원이 생성되었습니다.</h3>
          <div classname="did-details">
            <p><strong>DID:</strong> {did}</p>
            <p><strong>공개키:</strong> {publicKey.substring(0, 20)}...</p>
            <p><strong>서비스 엔드포인트:</strong> {endpoint}</p>
          </div>
          <p classname="warning">
            ⚠️ 이 정보를 안전하게 보관하세요. 특히 개인키는 절대 공유하지 마세요!
          </p>
        </div>
      )}
    </div>
  );
};

export default DIDCreator;

💼 디지털 지갑 컴포넌트

import React, { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import VCRegistryABI from '../abis/VCRegistry.json';
import QRCode from 'react-qr-code';

const DigitalWallet = () => {
  const [credentials, setCredentials] = useState([]);
  const [selectedVC, setSelectedVC] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState('');
  const [sharingMode, setSharingMode] = useState(false);
  
  // 자격 증명 목록 가져오기
  useEffect(() => {
    const fetchCredentials = async () => {
      try {
        // 실제 구현에서는 백엔드 API나 IPFS에서 사용자의 VC 목록을 가져옴
        // 여기서는 예시 데이터 사용
        const mockCredentials = [
          {
            id: 'vc:example:123',
            type: '학위 증명서',
            issuer: '서울대학교',
            issuanceDate: '2024-12-15',
            expirationDate: '2029-12-15',
            status: 'ACTIVE'
          },
          {
            id: 'vc:example:456',
            type: '전문가 인증',
            issuer: '재능넷',
            issuanceDate: '2025-01-20',
            expirationDate: '2026-01-20',
            status: 'ACTIVE'
          },
          {
            id: 'vc:example:789',
            type: '운전면허증',
            issuer: '도로교통공단',
            issuanceDate: '2023-05-10',
            expirationDate: '2028-05-10',
            status: 'ACTIVE'
          }
        ];
        
        setCredentials(mockCredentials);
        setLoading(false);
      } catch (err) {
        console.error('자격 증명 로딩 오류:', err);
        setError('자격 증명을 불러오는 중 오류가 발생했습니다.');
        setLoading(false);
      }
    };
    
    fetchCredentials();
  }, []);
  
  // 자격 증명 선택
  const handleSelectVC = (vc) => {
    setSelectedVC(vc);
    setSharingMode(false);
  };
  
  // 자격 증명 공유 모드 전환
  const toggleSharingMode = () => {
    setSharingMode(!sharingMode);
  };
  
  // 자격 증명 공유 데이터 생성
  const generateSharingData = () => {
    if (!selectedVC) return '';
    
    // 실제 구현에서는 ZKP나 선택적 공개를 위한 로직 추가
    const sharingData = {
      type: 'VerifiablePresentation',
      verifiableCredential: selectedVC,
      proof: {
        type: 'EcdsaSecp256k1Signature2019',
        created: new Date().toISOString(),
        challenge: 'challenge123',
        domain: 'example.com'
      }
    };
    
    return JSON.stringify(sharingData);
  };

  return (
    <div classname="digital-wallet">
      <h2>내 디지털 지갑</h2>
      
      {loading ? (
        <p>자격 증명을 불러오는 중...</p>
      ) : error ? (
        <p classname="error-message">{error}</p>
      ) : (
        <div classname="wallet-container">
          <div classname="credentials-list">
            <h3>내 자격 증명 목록</h3>
            {credentials.length === 0 ? (
              <p>보유한 자격 증명이 없습니다.</p>
            ) : (
              <ul>
                {credentials.map((vc) => (
                  <li key="{vc.id}" classname="{selectedVC?.id" vc.id : onclick="{()"> handleSelectVC(vc)}
                  >
                    <h4>{vc.type}</h4>
                    <p>발급자: {vc.issuer}</p>
                    <p>만료일: {vc.expirationDate}</p>
                  </li>
                ))}
              </ul>
            )}
          </div>
          
          {selectedVC && (
            <div classname="credential-details">
              <h3>{selectedVC.type} 상세 정보</h3>
              <div classname="details-container">
                <p><strong>ID:</strong> {selectedVC.id}</p>
                <p><strong>발급자:</strong> {selectedVC.issuer}</p>
                <p><strong>발급일:</strong> {selectedVC.issuanceDate}</p>
                <p><strong>만료일:</strong> {selectedVC.expirationDate}</p>
                <p><strong>상태:</strong> {selectedVC.status}</p>
              </div>
              
              <div classname="actions">
                <button onclick="{toggleSharingMode}">
                  {sharingMode ? '공유 취소' : '자격 증명 공유'}
                </button>
              </div>
              
              {sharingMode && (
                <div classname="sharing-container">
                  <h4>QR 코드로 공유</h4>
                  <div classname="qr-code">
                    <qrcode value="{generateSharingData()}" size="{200}"></qrcode>
                  </div>
                  <p classname="sharing-info">
                    이 QR 코드를 검증자에게 보여주세요. 코드는 5분 후 만료됩니다.
                  </p>
                </div>
              )}
            </div>
          )}
        </div>
      )}
    </div>
  );
};

export default DigitalWallet;

🔄 블록체인 연동 서비스

// blockchain.service.js
const ethers = require('ethers');
const DIDRegistryABI = require('../abis/DIDRegistry.json');
const VCRegistryABI = require('../abis/VCRegistry.json');
const config = require('../config');

class BlockchainService {
  constructor() {
    // 프로바이더 설정
    this.provider = new ethers.providers.JsonRpcProvider(config.blockchain.rpcUrl);
    
    // 서비스 계정 설정
    this.wallet = new ethers.Wallet(config.blockchain.privateKey, this.provider);
    
    // 컨트랙트 인스턴스 생성
    this.didRegistry = new ethers.Contract(
      config.contracts.didRegistryAddress,
      DIDRegistryABI,
      this.wallet
    );
    
    this.vcRegistry = new ethers.Contract(
      config.contracts.vcRegistryAddress,
      VCRegistryABI,
      this.wallet
    );
  }
  
  // DID 해결 (Resolve)
  async resolveDID(did) {
    try {
      const result = await this.didRegistry.resolveDID(did);
      
      return {
        controller: result.controller,
        publicKeyHex: result.publicKeyHex,
        serviceEndpoint: result.serviceEndpoint,
        lastUpdated: new Date(result.lastUpdated.toNumber() * 1000).toISOString(),
        active: result.active
      };
    } catch (error) {
      console.error(`DID 해결 오류: ${error.message}`);
      throw new Error(`DID를 해결할 수 없습니다: ${error.message}`);
    }
  }
  
  // VC 상태 확인
  async verifyVC(vcId) {
    try {
      const result = await this.vcRegistry.verifyVC(vcId);
      
      return {
        issuerDID: result.issuerDID,
        subjectDID: result.subjectDID,
        issuanceDate: new Date(result.issuanceDate.toNumber() * 1000).toISOString(),
        expirationDate: new Date(result.expirationDate.toNumber() * 1000).toISOString(),
        status: ['ACTIVE', 'SUSPENDED', 'REVOKED'][result.status]
      };
    } catch (error) {
      console.error(`VC 검증 오류: ${error.message}`);
      throw new Error(`VC를 검증할 수 없습니다: ${error.message}`);
    }
  }
  
  // 이벤트 리스너 설정
  setupEventListeners() {
    // DID 생성 이벤트 리스닝
    this.didRegistry.on('DIDCreated', (did, controller) => {
      console.log(`새 DID 생성됨: ${did}, 컨트롤러: ${controller}`);
      // 여기서 데이터베이스 업데이트 등의 작업 수행
    });
    
    // VC 발급 이벤트 리스닝
    this.vcRegistry.on('VCIssued', (vcId, issuerDID, subjectDID) => {
      console.log(`새 VC 발급됨: ${vcId}, 발급자: ${issuerDID}, 소유자: ${subjectDID}`);
      // 여기서 알림 발송 등의 작업 수행
    });
  }
}

module.exports = new BlockchainService();

💾 오프체인 데이터 관리 서비스

// storage.service.js
const IPFS = require('ipfs-http-client');
const crypto = require('crypto');
const config = require('../config');

class StorageService {
  constructor() {
    // IPFS 클라이언트 설정
    this.ipfs = IPFS.create({
      host: config.ipfs.host,
      port: config.ipfs.port,
      protocol: config.ipfs.protocol
    });
    
    // 암호화 키 설정
    this.encryptionKey = Buffer.from(config.encryption.key, 'hex');
  }
  
  // 데이터 암호화
  encrypt(data) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-cbc', this.encryptionKey, iv);
    
    let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
    encrypted += cipher.final('hex');
    
    return {
      iv: iv.toString('hex'),
      encryptedData: encrypted
    };
  }
  
  // 데이터 복호화
  decrypt(encryptedData, iv) {
    const decipher = crypto.createDecipheriv(
      'aes-256-cbc',
      this.encryptionKey,
      Buffer.from(iv, 'hex')
    );
    
    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    
    return JSON.parse(decrypted);
  }
  
  // IPFS에 데이터 저장
  async storeData(data) {
    try {
      // 데이터 암호화
      const encryptedData = this.encrypt(data);
      
      // IPFS에 업로드
      const result = await this.ipfs.add(Buffer.from(JSON.stringify(encryptedData)));
      
      return {
        cid: result.cid.toString(),
        encryptionIv: encryptedData.iv
      };
    } catch (error) {
      console.error(`데이터 저장 오류: ${error.message}`);
      throw new Error(`데이터를 저장할 수 없습니다: ${error.message}`);
    }
  }
  
  // IPFS에서 데이터 검색
  async retrieveData(cid, iv) {
    try {
      // IPFS에서 데이터 가져오기
      const chunks = [];
      for await (const chunk of this.ipfs.cat(cid)) {
        chunks.push(chunk);
      }
      
      const encryptedData = JSON.parse(Buffer.concat(chunks).toString());
      
      // 데이터 복호화
      return this.decrypt(encryptedData.encryptedData, iv);
    } catch (error) {
      console.error(`데이터 검색 오류: ${error.message}`);
      throw new Error(`데이터를 검색할 수 없습니다: ${error.message}`);
    }
  }
}

module.exports = new StorageService();

🌐 API 라우터

// identity.routes.js
const express = require('express');
const router = express.Router();
const blockchainService = require('../services/blockchain.service');
const storageService = require('../services/storage.service');
const authMiddleware = require('../middlewares/auth.middleware');

// DID 해결 API
router.get('/did/:did', async (req, res) => {
  try {
    const { did } = req.params;
    const didDocument = await blockchainService.resolveDID(did);
    
    res.json({
      success: true,
      data: didDocument
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
});

// VC 발급 API
router.post('/vc/issue', authMiddleware, async (req, res) => {
  try {
    const { subjectDID, claims, expirationDate, schemaId } = req.body;
    
    // 요청 검증
    if (!subjectDID || !claims || !schemaId) {
      return res.status(400).json({
        success: false,
        error: '필수 파라미터가 누락되었습니다.'
      });
    }
    
    // VC 생성
    const vcData = {
      '@context': ['https://www.w3.org/2018/credentials/v1'],
      type: ['VerifiableCredential'],
      issuer: req.user.did,
      issuanceDate: new Date().toISOString(),
      expirationDate: expirationDate || new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(),
      credentialSubject: {
        id: subjectDID,
        ...claims
      }
    };
    
    // 오프체인 저장
    const { cid, encryptionIv } = await storageService.storeData(vcData);
    
    // VC 해시 생성
    const vcHash = require('crypto')
      .createHash('sha256')
      .update(JSON.stringify(vcData))
      .digest('hex');
    
    // 블록체인에 VC 등록
    const vcId = `vc:${req.user.did.split(':')[1]}:${Date.now()}`;
    await blockchainService.vcRegistry.issueVC(
      vcId,
      req.user.did,
      subjectDID,
      schemaId,
      vcHash,
      Math.floor(new Date(expirationDate).getTime() / 1000)
    );
    
    // 응답
    res.json({
      success: true,
      data: {
        vcId,
        cid,
        encryptionIv
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// VC 검증 API
router.post('/vc/verify', async (req, res) => {
  try {
    const { vcId, presentation } = req.body;
    
    // VC 상태 확인
    const vcStatus = await blockchainService.verifyVC(vcId);
    
    if (vcStatus.status !== 'ACTIVE') {
      return res.json({
        success: false,
        error: `VC가 유효하지 않습니다. 상태: ${vcStatus.status}`
      });
    }
    
    // 서명 검증 등 추가 검증 로직
    // ...
    
    res.json({
      success: true,
      data: {
        isValid: true,
        vcStatus
      }
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
});

module.exports = router;