🎯 블록체인 백엔드, 왜 Go언어일까?

🤔 DApp 백엔드가 뭐길래?

💪 Go언어의 강력한 장점들

🛠️ 개발 환경 세팅하기

# 설치 확인
go version

# 출력 예시: go version go1.21.0 linux/amd64

# 프로젝트 디렉토리 생성
mkdir dapp-backend
cd dapp-backend

# Go 모듈 초기화
go mod init github.com/yourusername/dapp-backend

# go-ethereum 설치
go get github.com/ethereum/go-ethereum

🔗 이더리움 클라이언트 연결하기

package main

import (
    "context"
    "fmt"
    "log"
    "math/big"
    
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    // Infura 또는 로컬 노드에 연결
    client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("이더리움 네트워크에 연결되었습니다!")
    
    // 최신 블록 번호 가져오기
    header, err := client.HeaderByNumber(context.Background(), nil)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("최신 블록:", header.Number.String())
    
    // 특정 주소의 잔액 조회
    address := "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
    balance, err := client.BalanceAt(context.Background(), 
        common.HexToAddress(address), nil)
    if err != nil {
        log.Fatal(err)
    }
    
    // Wei를 Ether로 변환
    fbalance := new(big.Float)
    fbalance.SetString(balance.String())
    ethValue := new(big.Float).Quo(fbalance, big.NewFloat(1e18))
    
    fmt.Printf("잔액: %f ETH\n", ethValue)
}

package main

import (
    "os"
    "github.com/joho/godotenv"
)

func init() {
    // .env 파일 로드
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
}

func main() {
    // 환경변수에서 API 키 가져오기
    infuraURL := os.Getenv("INFURA_URL")
    client, err := ethclient.Dial(infuraURL)
    // ... 나머지 코드
}

INFURA_URL=https://mainnet.infura.io/v3/your_project_id_here
PRIVATE_KEY=your_private_key_here
CONTRACT_ADDRESS=0x...

📝 스마트 컨트랙트와 상호작용하기

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

contract SimpleToken {
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    
    mapping(address => uint256) public balanceOf;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
    }
    
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value, "Insufficient balance");
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
}

# abigen 설치
go install github.com/ethereum/go-ethereum/cmd/abigen@latest

# 컨트랙트 컴파일 (solc 필요)
solc --abi --bin SimpleToken.sol -o build/

# Go 바인딩 생성
abigen --abi=build/SimpleToken.abi \
       --bin=build/SimpleToken.bin \
       --pkg=token \
       --out=token/SimpleToken.go

package main

import (
    "context"
    "crypto/ecdsa"
    "fmt"
    "log"
    "math/big"
    
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
    
    token "github.com/yourusername/dapp-backend/token"
)

func main() {
    // 클라이언트 연결
    client, err := ethclient.Dial("http://localhost:8545") // Ganache
    if err != nil {
        log.Fatal(err)
    }
    
    // 개인키 로드
    privateKey, err := crypto.HexToECDSA("your_private_key_here")
    if err != nil {
        log.Fatal(err)
    }
    
    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
    if !ok {
        log.Fatal("error casting public key to ECDSA")
    }
    
    fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
    
    // Nonce 가져오기
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        log.Fatal(err)
    }
    
    // 가스 가격 설정
    gasPrice, err := client.SuggestGasPrice(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    
    // 트랜잭션 옵션 설정
    auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
    if err != nil {
        log.Fatal(err)
    }
    auth.Nonce = big.NewInt(int64(nonce))
    auth.Value = big.NewInt(0)
    auth.GasLimit = uint64(3000000)
    auth.GasPrice = gasPrice
    
    // 컨트랙트 배포
    initialSupply := big.NewInt(1000000)
    address, tx, instance, err := token.DeploySimpleToken(auth, client, initialSupply)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("컨트랙트 배포됨! 주소: %s\n", address.Hex())
    fmt.Printf("트랜잭션 해시: %s\n", tx.Hash().Hex())
    
    // 컨트랙트 인스턴스 사용
    name, err := instance.Name(nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("토큰 이름: %s\n", name)
}

🔄 컨트랙트 함수 호출하기

// 기존 컨트랙트에 연결
contractAddress := common.HexToAddress("0x...")
instance, err := token.NewSimpleToken(contractAddress, client)
if err != nil {
    log.Fatal(err)
}

// 토큰 이름 조회
name, err := instance.Name(&bind.CallOpts{})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("토큰 이름: %s\n", name)

// 특정 주소의 잔액 조회
userAddress := common.HexToAddress("0x...")
balance, err := instance.BalanceOf(&bind.CallOpts{}, userAddress)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("잔액: %s\n", balance.String())

// 총 공급량 조회
totalSupply, err := instance.TotalSupply(&bind.CallOpts{})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("총 공급량: %s\n", totalSupply.String())

// 트랜잭션 옵션 설정
auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
if err != nil {
    log.Fatal(err)
}

// Nonce 업데이트
nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
if err != nil {
    log.Fatal(err)
}
auth.Nonce = big.NewInt(int64(nonce))

// 가스 설정
auth.GasLimit = uint64(300000)
gasPrice, err := client.SuggestGasPrice(context.Background())
if err != nil {
    log.Fatal(err)
}
auth.GasPrice = gasPrice

// 토큰 전송
toAddress := common.HexToAddress("0x...")
amount := big.NewInt(1000000000000000000) // 1 토큰 (18 decimals)

tx, err := instance.Transfer(auth, toAddress, amount)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("트랜잭션 전송됨: %s\n", tx.Hash().Hex())

// 트랜잭션이 마이닝될 때까지 대기
receipt, err := bind.WaitMined(context.Background(), client, tx)
if err != nil {
    log.Fatal(err)
}

if receipt.Status == 1 {
    fmt.Println("트랜잭션 성공!")
} else {
    fmt.Println("트랜잭션 실패!")
}

📡 이벤트 리스닝하기

package main

import (
    "context"
    "fmt"
    "log"
    "math/big"
    
    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
    
    token "github.com/yourusername/dapp-backend/token"
)

func main() {
    client, err := ethclient.Dial("http://localhost:8545")
    if err != nil {
        log.Fatal(err)
    }
    
    contractAddress := common.HexToAddress("0x...")
    
    // 이벤트 필터 쿼리 생성
    query := ethereum.FilterQuery{
        FromBlock: big.NewInt(0),
        ToBlock:   big.NewInt(1000),
        Addresses: []common.Address{contractAddress},
    }
    
    // 로그 조회
    logs, err := client.FilterLogs(context.Background(), query)
    if err != nil {
        log.Fatal(err)
    }
    
    // 컨트랙트 ABI 파싱
    contractAbi, err := abi.JSON(strings.NewReader(token.SimpleTokenABI))
    if err != nil {
        log.Fatal(err)
    }
    
    // 각 로그 처리
    for _, vLog := range logs {
        // Transfer 이벤트인지 확인
        event := struct {
            From  common.Address
            To    common.Address
            Value *big.Int
        }{}
        
        err := contractAbi.UnpackIntoInterface(&event, "Transfer", vLog.Data)
        if err != nil {
            log.Fatal(err)
        }
        
        // Indexed 파라미터 처리
        event.From = common.HexToAddress(vLog.Topics[1].Hex())
        event.To = common.HexToAddress(vLog.Topics[2].Hex())
        
        fmt.Printf("Transfer: %s -> %s, Amount: %s\n", 
            event.From.Hex(), event.To.Hex(), event.Value.String())
    }
}

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    // WebSocket으로 연결 (중요!)
    client, err := ethclient.Dial("ws://localhost:8546")
    if err != nil {
        log.Fatal(err)
    }
    
    contractAddress := common.HexToAddress("0x...")
    
    // 구독 쿼리 생성
    query := ethereum.FilterQuery{
        Addresses: []common.Address{contractAddress},
    }
    
    // 로그 채널 생성
    logs := make(chan types.Log)
    
    // 구독 시작
    sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("이벤트 리스닝 시작...")
    
    // 무한 루프로 이벤트 대기
    for {
        select {
        case err := <-sub.Err():
            log.Fatal(err)
        case vLog := <-logs:
            fmt.Printf("새 이벤트 감지! 블록: %d, 트랜잭션: %s\n", 
                vLog.BlockNumber, vLog.TxHash.Hex())
            
            // 여기서 이벤트 처리 로직 구현
            // - 데이터베이스 업데이트
            // - 사용자에게 알림 전송
            // - 통계 데이터 갱신 등
        }
    }
}

🏗️ DApp 백엔드 아키텍처 설계

dapp-backend/
├── cmd/
│   └── server/
│       └── main.go              # 애플리케이션 진입점
├── internal/
│   ├── api/                     # HTTP API 핸들러
│   │   ├── handlers/
│   │   ├── middleware/
│   │   └── routes.go
│   ├── blockchain/              # 블록체인 상호작용
│   │   ├── client.go
│   │   ├── contract.go
│   │   └── listener.go
│   ├── service/                 # 비즈니스 로직
│   │   ├── token_service.go
│   │   ├── user_service.go
│   │   └── transaction_service.go
│   ├── repository/              # 데이터 접근
│   │   ├── postgres/
│   │   └── redis/
│   └── models/                  # 데이터 모델
│       ├── user.go
│       └── transaction.go
├── pkg/                         # 공용 패키지
│   ├── config/
│   ├── logger/
│   └── utils/
├── contracts/                   # 스마트 컨트랙트
│   ├── SimpleToken.sol
│   └── bindings/
└── docker-compose.yml

package blockchain

import (
    "context"
    "fmt"
    "sync"
    
    "github.com/ethereum/go-ethereum/ethclient"
)

type ClientManager struct {
    clients map[string]*ethclient.Client
    mu      sync.RWMutex
}

func NewClientManager() *ClientManager {
    return &ClientManager{
        clients: make(map[string]*ethclient.Client),
    }
}

func (cm *ClientManager) AddClient(name, url string) error {
    cm.mu.Lock()
    defer cm.mu.Unlock()
    
    client, err := ethclient.Dial(url)
    if err != nil {
        return fmt.Errorf("failed to connect to %s: %w", name, err)
    }
    
    // 연결 테스트
    _, err = client.ChainID(context.Background())
    if err != nil {
        return fmt.Errorf("failed to get chain ID: %w", err)
    }
    
    cm.clients[name] = client
    return nil
}

func (cm *ClientManager) GetClient(name string) (*ethclient.Client, error) {
    cm.mu.RLock()
    defer cm.mu.RUnlock()
    
    client, exists := cm.clients[name]
    if !exists {
        return nil, fmt.Errorf("client %s not found", name)
    }
    
    return client, nil
}

func (cm *ClientManager) Close() {
    cm.mu.Lock()
    defer cm.mu.Unlock()
    
    for _, client := range cm.clients {
        client.Close()
    }
}

package service

import (
    "context"
    "crypto/ecdsa"
    "fmt"
    "math/big"
    "time"
    
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
)

type TransactionService struct {
    client     *ethclient.Client
    privateKey *ecdsa.PrivateKey
    chainID    *big.Int
}

func NewTransactionService(client *ethclient.Client, privateKeyHex string) (*TransactionService, error) {
    privateKey, err := crypto.HexToECDSA(privateKeyHex)
    if err != nil {
        return nil, err
    }
    
    chainID, err := client.ChainID(context.Background())
    if err != nil {
        return nil, err
    }
    
    return &TransactionService{
        client:     client,
        privateKey: privateKey,
        chainID:    chainID,
    }, nil
}

func (ts *TransactionService) SendTransaction(
    ctx context.Context,
    to common.Address,
    value *big.Int,
    data []byte,
) (*types.Transaction, error) {
    
    fromAddress := crypto.PubkeyToAddress(ts.privateKey.Public().(*ecdsa.PublicKey))
    
    nonce, err := ts.client.PendingNonceAt(ctx, fromAddress)
    if err != nil {
        return nil, fmt.Errorf("failed to get nonce: %w", err)
    }
    
    gasPrice, err := ts.client.SuggestGasPrice(ctx)
    if err != nil {
        return nil, fmt.Errorf("failed to get gas price: %w", err)
    }
    
    // 가스 리미트 추정
    gasLimit, err := ts.client.EstimateGas(ctx, ethereum.CallMsg{
        From:  fromAddress,
        To:    &to,
        Value: value,
        Data:  data,
    })
    if err != nil {
        gasLimit = 300000 // 기본값
    }
    
    tx := types.NewTransaction(nonce, to, value, gasLimit, gasPrice, data)
    
    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(ts.chainID), ts.privateKey)
    if err != nil {
        return nil, fmt.Errorf("failed to sign transaction: %w", err)
    }
    
    err = ts.client.SendTransaction(ctx, signedTx)
    if err != nil {
        return nil, fmt.Errorf("failed to send transaction: %w", err)
    }
    
    return signedTx, nil
}

func (ts *TransactionService) WaitForReceipt(
    ctx context.Context,
    txHash common.Hash,
    timeout time.Duration,
) (*types.Receipt, error) {
    
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()
    
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            return nil, fmt.Errorf("timeout waiting for receipt")
        case <-ticker.C:
            receipt, err := ts.client.TransactionReceipt(ctx, txHash)
            if err == nil {
                return receipt, nil
            }
        }
    }
}

🗄️ 데이터 인덱싱과 캐싱

package repository

import (
    "context"
    "database/sql"
    "time"
    
    _ "github.com/lib/pq"
)

type Transaction struct {
    ID          int64
    TxHash      string
    From        string
    To          string
    Value       string
    BlockNumber int64
    Timestamp   time.Time
    Status      int
}

type TransactionRepository struct {
    db *sql.DB
}

func NewTransactionRepository(db *sql.DB) *TransactionRepository {
    return &TransactionRepository{db: db}
}

func (r *TransactionRepository) Create(ctx context.Context, tx *Transaction) error {
    query := `
        INSERT INTO transactions (tx_hash, from_address, to_address, value, block_number, timestamp, status)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
        RETURNING id
    `
    
    return r.db.QueryRowContext(
        ctx, query,
        tx.TxHash, tx.From, tx.To, tx.Value, tx.BlockNumber, tx.Timestamp, tx.Status,
    ).Scan(&tx.ID)
}

func (r *TransactionRepository) GetByAddress(ctx context.Context, address string, limit int) ([]Transaction, error) {
    query := `
        SELECT id, tx_hash, from_address, to_address, value, block_number, timestamp, status
        FROM transactions
        WHERE from_address = $1 OR to_address = $1
        ORDER BY block_number DESC
        LIMIT $2
    `
    
    rows, err := r.db.QueryContext(ctx, query, address, limit)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var transactions []Transaction
    for rows.Next() {
        var tx Transaction
        err := rows.Scan(
            &tx.ID, &tx.TxHash, &tx.From, &tx.To,
            &tx.Value, &tx.BlockNumber, &tx.Timestamp, &tx.Status,
        )
        if err != nil {
            return nil, err
        }
        transactions = append(transactions, tx)
    }
    
    return transactions, nil
}

package repository

import (
    "context"
    "encoding/json"
    "fmt"
    "time"
    
    "github.com/go-redis/redis/v8"
)

type CacheRepository struct {
    client *redis.Client
}

func NewCacheRepository(client *redis.Client) *CacheRepository {
    return &CacheRepository{client: client}
}

func (r *CacheRepository) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
    data, err := json.Marshal(value)
    if err != nil {
        return err
    }
    
    return r.client.Set(ctx, key, data, expiration).Err()
}

func (r *CacheRepository) Get(ctx context.Context, key string, dest interface{}) error {
    data, err := r.client.Get(ctx, key).Bytes()
    if err != nil {
        return err
    }
    
    return json.Unmarshal(data, dest)
}

func (r *CacheRepository) GetBalance(ctx context.Context, address string) (string, error) {
    key := fmt.Sprintf("balance:%s", address)
    return r.client.Get(ctx, key).Result()
}

func (r *CacheRepository) SetBalance(ctx context.Context, address, balance string) error {
    key := fmt.Sprintf("balance:%s", address)
    return r.client.Set(ctx, key, balance, 5*time.Minute).Err()
}

package blockchain

import (
    "context"
    "log"
    "math/big"
    "time"
    
    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
)

type EventIndexer struct {
    client     *ethclient.Client
    repository *TransactionRepository
    cache      *CacheRepository
}

func NewEventIndexer(
    client *ethclient.Client,
    repo *TransactionRepository,
    cache *CacheRepository,
) *EventIndexer {
    return &EventIndexer{
        client:     client,
        repository: repo,
        cache:      cache,
    }
}

func (ei *EventIndexer) Start(ctx context.Context, contractAddress common.Address) error {
    query := ethereum.FilterQuery{
        Addresses: []common.Address{contractAddress},
    }
    
    logs := make(chan types.Log)
    sub, err := ei.client.SubscribeFilterLogs(ctx, query, logs)
    if err != nil {
        return err
    }
    
    log.Println("이벤트 인덱서 시작...")
    
    for {
        select {
        case err := <-sub.Err():
            log.Printf("구독 에러: %v", err)
            return err
            
        case vLog := <-logs:
            if err := ei.processLog(ctx, vLog); err != nil {
                log.Printf("로그 처리 에러: %v", err)
            }
            
        case <-ctx.Done():
            log.Println("인덱서 종료...")
            return ctx.Err()
        }
    }
}

func (ei *EventIndexer) processLog(ctx context.Context, vLog types.Log) error {
    // 트랜잭션 정보 가져오기
    tx, _, err := ei.client.TransactionByHash(ctx, vLog.TxHash)
    if err != nil {
        return err
    }
    
    // 블록 정보 가져오기
    block, err := ei.client.BlockByNumber(ctx, big.NewInt(int64(vLog.BlockNumber)))
    if err != nil {
        return err
    }
    
    // 데이터베이스에 저장
    transaction := &Transaction{
        TxHash:      vLog.TxHash.Hex(),
        From:        tx.From().Hex(),
        To:          tx.To().Hex(),
        Value:       tx.Value().String(),
        BlockNumber: int64(vLog.BlockNumber),
        Timestamp:   time.Unix(int64(block.Time()), 0),
        Status:      1,
    }
    
    if err := ei.repository.Create(ctx, transaction); err != nil {
        return err
    }
    
    // 캐시 무효화
    ei.cache.Delete(ctx, fmt.Sprintf("balance:%s", transaction.From))
    ei.cache.Delete(ctx, fmt.Sprintf("balance:%s", transaction.To))
    
    log.Printf("트랜잭션 인덱싱 완료: %s", transaction.TxHash)
    return nil
}

🌐 RESTful API 구현

package handlers

import (
    "net/http"
    
    "github.com/ethereum/go-ethereum/common"
    "github.com/gin-gonic/gin"
)

type TokenHandler struct {
    tokenService *TokenService
}

func NewTokenHandler(tokenService *TokenService) *TokenHandler {
    return &TokenHandler{tokenService: tokenService}
}

// GET /api/tokens/:address/balance
func (h *TokenHandler) GetBalance(c *gin.Context) {
    address := c.Param("address")
    
    if !common.IsHexAddress(address) {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": "Invalid address format",
        })
        return
    }
    
    balance, err := h.tokenService.GetBalance(c.Request.Context(), address)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "address": address,
        "balance": balance,
    })
}

// POST /api/tokens/transfer
func (h *TokenHandler) Transfer(c *gin.Context) {
    var req struct {
        From   string `json:"from" binding:"required"`
        To     string `json:"to" binding:"required"`
        Amount string `json:"amount" binding:"required"`
    }
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": err.Error(),
        })
        return
    }
    
    txHash, err := h.tokenService.Transfer(
        c.Request.Context(),
        req.From,
        req.To,
        req.Amount,
    )
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "tx_hash": txHash,
        "status":  "pending",
    })
}

// GET /api/transactions/:address
func (h *TokenHandler) GetTransactions(c *gin.Context) {
    address := c.Param("address")
    
    transactions, err := h.tokenService.GetTransactionHistory(
        c.Request.Context(),
        address,
        50, // limit
    )
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "address":      address,
        "transactions": transactions,
    })
}

package api

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/dapp-backend/internal/api/handlers"
    "github.com/yourusername/dapp-backend/internal/api/middleware"
)

func SetupRouter(
    tokenHandler *handlers.TokenHandler,
    userHandler *handlers.UserHandler,
) *gin.Engine {
    
    router := gin.Default()
    
    // 미들웨어 설정
    router.Use(middleware.CORS())
    router.Use(middleware.RateLimiter())
    router.Use(middleware.Logger())
    
    // Health check
    router.GET("/health", func(c *gin.Context) {
        c.JSON(200, gin.H{"status": "ok"})
    })
    
    // API v1 그룹
    v1 := router.Group("/api/v1")
    {
        // 토큰 관련 엔드포인트
        tokens := v1.Group("/tokens")
        {
            tokens.GET("/:address/balance", tokenHandler.GetBalance)
            tokens.POST("/transfer", tokenHandler.Transfer)
            tokens.GET("/transactions/:address", tokenHandler.GetTransactions)
        }
        
        // 사용자 관련 엔드포인트
        users := v1.Group("/users")
        {
            users.POST("/register", userHandler.Register)
            users.GET("/:address", userHandler.GetProfile)
            users.PUT("/:address", userHandler.UpdateProfile)
        }
    }
    
    return router
}

package middleware

import (
    "time"
    
    "github.com/gin-gonic/gin"
    "golang.org/x/time/rate"
)

// CORS 미들웨어
func CORS() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        
        c.Next()
    }
}

// Rate Limiter 미들웨어
func RateLimiter() gin.HandlerFunc {
    limiter := rate.NewLimiter(rate.Every(time.Second), 10) // 초당 10개 요청
    
    return func(c *gin.Context) {
        if !limiter.Allow() {
            c.JSON(429, gin.H{
                "error": "Too many requests",
            })
            c.Abort()
            return
        }
        c.Next()
    }
}

// 로거 미들웨어
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        
        c.Next()
        
        latency := time.Since(start)
        statusCode := c.Writer.Status()
        
        log.Printf("[%s] %s - %d (%v)",
            c.Request.Method,
            path,
            statusCode,
            latency,
        )
    }
}

🔐 보안 고려사항

package config

import (
    "os"
    "github.com/joho/godotenv"
)

type Config struct {
    PrivateKey      string
    InfuraURL       string
    ContractAddress string
    DatabaseURL     string
    RedisURL        string
}

func Load() (*Config, error) {
    if err := godotenv.Load(); err != nil {
        return nil, err
    }
    
    return &Config{
        PrivateKey:      os.Getenv("PRIVATE_KEY"),
        InfuraURL:       os.Getenv("INFURA_URL"),
        ContractAddress: os.Getenv("CONTRACT_ADDRESS"),
        DatabaseURL:     os.Getenv("DATABASE_URL"),
        RedisURL:        os.Getenv("REDIS_URL"),
    }, nil
}

package secrets

import (
    "context"
    "encoding/json"
    
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)

type SecretsManager struct {
    client *secretsmanager.Client
}

func NewSecretsManager(cfg aws.Config) *SecretsManager {
    return &SecretsManager{
        client: secretsmanager.NewFromConfig(cfg),
    }
}

func (sm *SecretsManager) GetSecret(ctx context.Context, secretName string) (map[string]string, error) {
    result, err := sm.client.GetSecretValue(ctx, &secretsmanager.GetSecretValueInput{
        SecretId: aws.String(secretName),
    })
    if err != nil {
        return nil, err
    }
    
    var secrets map[string]string
    if err := json.Unmarshal([]byte(*result.SecretString), &secrets); err != nil {
        return nil, err
    }
    
    return secrets, nil
}

package validator

import (
    "errors"
    "math/big"
    "regexp"
    
    "github.com/ethereum/go-ethereum/common"
)

var (
    ErrInvalidAddress = errors.New("invalid ethereum address")
    ErrInvalidAmount  = errors.New("invalid amount")
)

func ValidateAddress(address string) error {
    if !common.IsHexAddress(address) {
        return ErrInvalidAddress
    }
    return nil
}

func ValidateAmount(amount string) (*big.Int, error) {
    value, ok := new(big.Int).SetString(amount, 10)
    if !ok {
        return nil, ErrInvalidAmount
    }
    
    if value.Sign() <= 0 {
        return nil, errors.New("amount must be positive")
    }
    
    // 최대값 체크 (예: 1억 토큰)
    maxValue := new(big.Int).Mul(big.NewInt(100000000), big.NewInt(1e18))
    if value.Cmp(maxValue) > 0 {
        return nil, errors.New("amount too large")
    }
    
    return value, nil
}

func ValidateTxHash(txHash string) error {
    matched, err := regexp.MatchString("^0x[0-9a-fA-F]{64}$", txHash)
    if err != nil || !matched {
        return errors.New("invalid transaction hash")
    }
    return nil
}

package blockchain

import (
    "context"
    "sync"
    
    "github.com/ethereum/go-ethereum/common"
)

type NonceManager struct {
    nonces map[common.Address]uint64
    mu     sync.Mutex
}

func NewNonceManager() *NonceManager {
    return &NonceManager{
        nonces: make(map[common.Address]uint64),
    }
}

func (nm *NonceManager) GetNonce(ctx context.Context, client *ethclient.Client, address common.Address) (uint64, error) {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    
    // 캐시된 논스 확인
    if nonce, exists := nm.nonces[address]; exists {
        nm.nonces[address]++
        return nonce, nil
    }
    
    // 블록체인에서 논스 가져오기
    nonce, err := client.PendingNonceAt(ctx, address)
    if err != nil {
        return 0, err
    }
    
    nm.nonces[address] = nonce + 1
    return nonce, nil
}

func (nm *NonceManager) Reset(address common.Address) {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    delete(nm.nonces, address)
}

📈 모니터링과 로깅

package logger

import (
    "os"
    
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

var Log *zap.Logger

func Init() error {
    config := zap.NewProductionConfig()
    config.EncoderConfig.TimeKey = "timestamp"
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    
    var err error
    Log, err = config.Build()
    if err != nil {
        return err
    }
    
    return nil
}

func Info(msg string, fields ...zap.Field) {
    Log.Info(msg, fields...)
}

func Error(msg string, fields ...zap.Field) {
    Log.Error(msg, fields...)
}

func Debug(msg string, fields ...zap.Field) {
    Log.Debug(msg, fields...)
}

// 사용 예시
func ExampleUsage() {
    logger.Info("Transaction sent",
        zap.String("tx_hash", "0x..."),
        zap.String("from", "0x..."),
        zap.String("to", "0x..."),
        zap.String("value", "1000000000000000000"),
    )
}

package metrics

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    TransactionCounter = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "dapp_transactions_total",
            Help: "Total number of transactions",
        },
        []string{"status"},
    )
    
    TransactionDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "dapp_transaction_duration_seconds",
            Help:    "Transaction processing duration",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method"},
    )
    
    BlockHeight = promauto.NewGauge(
        prometheus.GaugeOpts{
            Name: "dapp_block_height",
            Help: "Current block height",
        },
    )
    
    GasPrice = promauto.NewGauge(
        prometheus.GaugeOpts{
            Name: "dapp_gas_price_gwei",
            Help: "Current gas price in Gwei",
        },
    )
)

// 사용 예시
func RecordTransaction(status string) {
    TransactionCounter.WithLabelValues(status).Inc()
}

func RecordDuration(method string, duration float64) {
    TransactionDuration.WithLabelValues(method).Observe(duration)
}

package handlers

import (
    "context"
    "net/http"
    "time"
    
    "github.com/gin-gonic/gin"
)

type HealthHandler struct {
    client     *ethclient.Client
    db         *sql.DB
    redis      *redis.Client
}

func (h *HealthHandler) Check(c *gin.Context) {
    ctx, cancel := context.WithTimeout(c.Request.Context(), 5*time.Second)
    defer cancel()
    
    health := gin.H{
        "status": "ok",
        "checks": gin.H{},
    }
    
    // 블록체인 연결 체크
    if _, err := h.client.ChainID(ctx); err != nil {
        health["checks"].(gin.H)["blockchain"] = "unhealthy"
        health["status"] = "degraded"
    } else {
        health["checks"].(gin.H)["blockchain"] = "healthy"
    }
    
    // 데이터베이스 체크
    if err := h.db.PingContext(ctx); err != nil {
        health["checks"].(gin.H)["database"] = "unhealthy"
        health["status"] = "degraded"
    } else {
        health["checks"].(gin.H)["database"] = "healthy"
    }
    
    // Redis 체크
    if err := h.redis.Ping(ctx).Err(); err != nil {
        health["checks"].(gin.H)["cache"] = "unhealthy"
        health["status"] = "degraded"
    } else {
        health["checks"].(gin.H)["cache"] = "healthy"
    }
    
    statusCode := http.StatusOK
    if health["status"] == "degraded" {
        statusCode = http.StatusServiceUnavailable
    }
    
    c.JSON(statusCode, health)
}

🚀 배포와 운영

# 빌드 스테이지
FROM golang:1.21-alpine AS builder

WORKDIR /app

# 의존성 복사 및 다운로드
COPY go.mod go.sum ./
RUN go mod download

# 소스 코드 복사
COPY . .

# 빌드
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main ./cmd/server

# 실행 스테이지
FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /root/

# 빌드된 바이너리 복사
COPY --from=builder /app/main .
COPY --from=builder /app/.env .

EXPOSE 8080

CMD ["./main"]

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:password@postgres:5432/dapp
      - REDIS_URL=redis://redis:6379
    depends_on:
      - postgres
      - redis
    networks:
      - dapp-network

  postgres:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=dapp
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - dapp-network

  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
    networks:
      - dapp-network

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - dapp-network

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    networks:
      - dapp-network

volumes:
  postgres-data:
  redis-data:
  prometheus-data:
  grafana-data:

networks:
  dapp-network:
    driver: bridge

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dapp-backend
  labels:
    app: dapp-backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: dapp-backend
  template:
    metadata:
      labels:
        app: dapp-backend
    spec:
      containers:
      - name: dapp-backend
        image: yourusername/dapp-backend:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: dapp-secrets
              key: database-url
        - name: PRIVATE_KEY
          valueFrom:
            secretKeyRef:
              name: dapp-secrets
              key: private-key
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: dapp-backend-service
spec:
  selector:
    app: dapp-backend
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer

🎨 실전 프로젝트: NFT 마켓플레이스 백엔드

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

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

contract NFTMarketplace is ERC721URIStorage, Ownable {
    uint256 private _tokenIds;
    uint256 private _itemsSold;
    
    uint256 listingPrice = 0.025 ether;
    
    struct MarketItem {
        uint256 tokenId;
        address payable seller;
        address payable owner;
        uint256 price;
        bool sold;
    }
    
    mapping(uint256 => MarketItem) private idToMarketItem;
    
    event MarketItemCreated(
        uint256 indexed tokenId,
        address seller,
        address owner,
        uint256 price,
        bool sold
    );
    
    constructor() ERC721("NFT Marketplace", "NFTM") {}
    
    function createToken(string memory tokenURI, uint256 price) public payable returns (uint256) {
        _tokenIds++;
        uint256 newTokenId = _tokenIds;
        
        _mint(msg.sender, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        createMarketItem(newTokenId, price);
        
        return newTokenId;
    }
    
    function createMarketItem(uint256 tokenId, uint256 price) private {
        require(price > 0, "Price must be at least 1 wei");
        require(msg.value == listingPrice, "Must pay listing price");
        
        idToMarketItem[tokenId] = MarketItem(
            tokenId,
            payable(msg.sender),
            payable(address(this)),
            price,
            false
        );
        
        _transfer(msg.sender, address(this), tokenId);
        
        emit MarketItemCreated(
            tokenId,
            msg.sender,
            address(this),
            price,
            false
        );
    }
    
    function createMarketSale(uint256 tokenId) public payable {
        uint256 price = idToMarketItem[tokenId].price;
        address seller = idToMarketItem[tokenId].seller;
        
        require(msg.value == price, "Please submit the asking price");
        
        idToMarketItem[tokenId].owner = payable(msg.sender);
        idToMarketItem[tokenId].sold = true;
        idToMarketItem[tokenId].seller = payable(address(0));
        _itemsSold++;
        
        _transfer(address(this), msg.sender, tokenId);
        payable(owner()).transfer(listingPrice);
        payable(seller).transfer(msg.value);
    }
}

package service

import (
    "context"
    "fmt"
    "math/big"
    
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
)

type NFTService struct {
    contract *nft.NFTMarketplace
    client   *ethclient.Client
}

func NewNFTService(contractAddress common.Address, client *ethclient.Client) (*NFTService, error) {
    contract, err := nft.NewNFTMarketplace(contractAddress, client)
    if err != nil {
        return nil, err
    }
    
    return &NFTService{
        contract: contract,
        client:   client,
    }, nil
}

// NFT 민팅
func (s *NFTService) MintNFT(
    ctx context.Context,
    auth *bind.TransactOpts,
    tokenURI string,
    price *big.Int,
) (uint64, error) {
    
    tx, err := s.contract.CreateToken(auth, tokenURI, price)
    if err != nil {
        return 0, fmt.Errorf("failed to mint NFT: %w", err)
    }
    
    receipt, err := bind.WaitMined(ctx, s.client, tx)
    if err != nil {
        return 0, fmt.Errorf("failed to wait for transaction: %w", err)
    }
    
    // 이벤트에서 토큰 ID 추출
    for _, log := range receipt.Logs {
        event, err := s.contract.ParseMarketItemCreated(*log)
        if err == nil {
            return event.TokenId.Uint64(), nil
        }
    }
    
    return 0, fmt.Errorf("token ID not found in events")
}

// NFT 구매
func (s *NFTService) BuyNFT(
    ctx context.Context,
    auth *bind.TransactOpts,
    tokenId *big.Int,
) error {
    
    // 가격 조회
    item, err := s.contract.IdToMarketItem(nil, tokenId)
    if err != nil {
        return fmt.Errorf("failed to get market item: %w", err)
    }
    
    // 가격 설정
    auth.Value = item.Price
    
    tx, err := s.contract.CreateMarketSale(auth, tokenId)
    if err != nil {
        return fmt.Errorf("failed to buy NFT: %w", err)
    }
    
    _, err = bind.WaitMined(ctx, s.client, tx)
    if err != nil {
        return fmt.Errorf("failed to wait for transaction: %w", err)
    }
    
    return nil
}

// 마켓 아이템 조회
func (s *NFTService) GetMarketItems(ctx context.Context) ([]MarketItem, error) {
    // 이벤트 필터링으로 모든 마켓 아이템 조회
    // 실제로는 데이터베이스에서 조회하는 게 더 효율적
    
    // ... 구현
    
    return items, nil
}

package ipfs

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
)

type IPFSClient struct {
    apiURL string
    apiKey string
}

type NFTMetadata struct {
    Name        string            `json:"name"`
    Description string            `json:"description"`
    Image       string            `json:"image"`
    Attributes  []NFTAttribute    `json:"attributes"`
}

type NFTAttribute struct {
    TraitType string `json:"trait_type"`
    Value     string `json:"value"`
}

func NewIPFSClient(apiURL, apiKey string) *IPFSClient {
    return &IPFSClient{
        apiURL: apiURL,
        apiKey: apiKey,
    }
}

// 파일 업로드
func (c *IPFSClient) UploadFile(file multipart.File, filename string) (string, error) {
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    
    part, err := writer.CreateFormFile("file", filename)
    if err != nil {
        return "", err
    }
    
    _, err = io.Copy(part, file)
    if err != nil {
        return "", err
    }
    
    writer.Close()
    
    req, err := http.NewRequest("POST", c.apiURL+"/api/v0/add", body)
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Content-Type", writer.FormDataContentType())
    req.Header.Set("Authorization", "Bearer "+c.apiKey)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    var result struct {
        Hash string `json:"Hash"`
    }
    
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return "", err
    }
    
    return fmt.Sprintf("ipfs://%s", result.Hash), nil
}

// 메타데이터 업로드
func (c *IPFSClient) UploadMetadata(metadata *NFTMetadata) (string, error) {
    data, err := json.Marshal(metadata)
    if err != nil {
        return "", err
    }
    
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    
    part, err := writer.CreateFormFile("file", "metadata.json")
    if err != nil {
        return "", err
    }
    
    part.Write(data)
    writer.Close()
    
    req, err := http.NewRequest("POST", c.apiURL+"/api/v0/add", body)
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Content-Type", writer.FormDataContentType())
    req.Header.Set("Authorization", "Bearer "+c.apiKey)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    var result struct {
        Hash string `json:"Hash"`
    }
    
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return "", err
    }
    
    return fmt.Sprintf("ipfs://%s", result.Hash), nil
}

⚡ 성능 최적화 팁

package blockchain

import (
    "context"
    "sync"
    
    "github.com/ethereum/go-ethereum/common"
)

type BatchBalanceChecker struct {
    client *ethclient.Client
}

func (b *BatchBalanceChecker) GetBalances(
    ctx context.Context,
    addresses []common.Address,
) (map[common.Address]*big.Int, error) {
    
    results := make(map[common.Address]*big.Int)
    var mu sync.Mutex
    var wg sync.WaitGroup
    
    // 동시에 10개씩 처리
    semaphore := make(chan struct{}, 10)
    
    for _, addr := range addresses {
        wg.Add(1)
        go func(address common.Address) {
            defer wg.Done()
            
            semaphore <- struct{}{}
            defer func() { <-semaphore }()
            
            balance, err := b.client.BalanceAt(ctx, address, nil)
            if err != nil {
                return
            }
            
            mu.Lock()
            results[address] = balance
            mu.Unlock()
        }(addr)
    }
    
    wg.Wait()
    return results, nil
}

package blockchain

import (
    "sync"
    
    "github.com/ethereum/go-ethereum/ethclient"
)

type ClientPool struct {
    clients []*ethclient.Client
    current int
    mu      sync.Mutex
}

func NewClientPool(urls []string) (*ClientPool, error) {
    pool := &ClientPool{
        clients: make([]*ethclient.Client, len(urls)),
    }
    
    for i, url := range urls {
        client, err := ethclient.Dial(url)
        if err != nil {
            return nil, err
        }
        pool.clients[i] = client
    }
    
    return pool, nil
}

func (p *ClientPool) GetClient() *ethclient.Client {
    p.mu.Lock()
    defer p.mu.Unlock()
    
    client := p.clients[p.current]
    p.current = (p.current + 1) % len(p.clients)
    
    return client
}

package cache

import (
    "context"
    "encoding/json"
    "fmt"
    "time"
    
    "github.com/go-redis/redis/v8"
)

type SmartCache struct {
    redis *redis.Client
}

func NewSmartCache(redis *redis.Client) *SmartCache {
    return &SmartCache{redis: redis}
}

// 계층적 캐싱
func (c *SmartCache) GetOrSet(
    ctx context.Context,
    key string,
    ttl time.Duration,
    fetchFunc func() (interface{}, error),
) (interface{}, error) {
    
    // 1단계: 캐시에서 조회
    cached, err := c.redis.Get(ctx, key).Bytes()
    if err == nil {
        var result interface{}
        if err := json.Unmarshal(cached, &result); err == nil {
            return result, nil
        }
    }
    
    // 2단계: 원본 데이터 가져오기
    data, err := fetchFunc()
    if err != nil {
        return nil, err
    }
    
    // 3단계: 캐시에 저장
    jsonData, err := json.Marshal(data)
    if err == nil {
        c.redis.Set(ctx, key, jsonData, ttl)
    }
    
    return data, nil
}

// 블록 번호 기반 캐싱 (불변 데이터)
func (c *SmartCache) CacheByBlock(
    ctx context.Context,
    blockNumber uint64,
    key string,
    data interface{},
) error {
    
    cacheKey := fmt.Sprintf("block:%d:%s", blockNumber, key)
    jsonData, err := json.Marshal(data)
    if err != nil {
        return err
    }
    
    // 확정된 블록은 영구 캐싱
    return c.redis.Set(ctx, cacheKey, jsonData, 0).Err()
}

🔧 문제 해결 가이드

📚 추가 학습 리소스

🎓 마무리하며