以太坊 DApp 開發完整實務指南：從架構設計到商業模式分析

概述

去中心化應用（DApp）是以太坊生態系統的核心價值載體。截至 2026 年第一季度，以太坊上運行著超過 5,000 個活躍 DApp，涵蓋去中心化金融（DeFi）、非同質化代幣（NFT）、遊戲、社交網路等多個領域。本文從工程師視角出發，提供完整的以太坊 DApp 開發指南，涵蓋技術架構設計、智慧合約開發、前後端整合、測試部署、以及商業模式分析，幫助開發者構建安全可靠的去中心化應用。

一、DApp 架構設計原則

1.1 區塊鏈應用的核心架構

一個完整的以太坊 DApp 通常由以下層次組成：

┌─────────────────────────────────────────────────────────────┐
│                    DApp 應用架構                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                   前端展示層                         │    │
│  │  - Web3.js / Ethers.js                              │    │
│  │  - React / Vue / Svelte                             │    │
│  │  - WalletConnect / MetaMask                         │    │
│  │  - IPFS 前端托管                                     │    │
│  └─────────────────────────────────────────────────────┘    │
│                            │                                 │
│                            ▼                                 │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                   業務邏輯層                         │    │
│  │  - 智慧合約（Solidity / Vyper）                     │    │
│  │  - 預言機服務（Chainlink / Band Protocol）          │    │
│  │  - IPFS 分散式存儲                                   │    │
│  └─────────────────────────────────────────────────────┘    │
│                            │                                 │
│                            ▼                                 │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                   區塊鏈層                           │    │
│  │  - 以太坊主網 / Layer 2                              │    │
│  │  - 合約部署與升級                                    │    │
│  │  - 事件監聽與索引                                    │    │
│  └─────────────────────────────────────────────────────┘    │
│                            │                                 │
│                            ▼                                 │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                   節點網路層                         │    │
│  │  - RPC 節點（Infura / Alchemy / QuickNode）         │    │
│  │  - 錢包簽名服務                                      │    │
│  │  - 交易池管理                                        │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.2 前端-後端-區塊鏈交互模式

// 完整的 DApp 前端架構示例
import { ethers } from 'ethers';
import React, { useState, useEffect, createContext, useContext } from 'react';

// Web3 上下文提供者
interface Web3ContextType {
  provider: ethers.BrowserProvider | null;
  signer: ethers.JsonRpcSigner | null;
  address: string | null;
  chainId: number | null;
  connect: () => Promise<void>;
  disconnect: () => void;
}

const Web3Context = createContext<Web3ContextType>({
  provider: null,
  signer: null,
  address: null,
  chainId: null,
  connect: async () => {},
  disconnect: () => {}
});

// 連接錢包
const useWeb3 = () => {
  const [state, setState] = useState<Web3ContextType>({
    provider: null,
    signer: null,
    address: null,
    chainId: null,
    connect: async () => {},
    disconnect: () => {}
  });

  const connect = async () => {
    if (typeof window.ethereum !== 'undefined') {
      try {
        // 請求帳戶連接
        const accounts = await window.ethereum.request({
          method: 'eth_requestAccounts'
        });
        
        const provider = new ethers.BrowserProvider(window.ethereum);
        const signer = await provider.getSigner();
        const network = await provider.getNetwork();
        
        setState({
          provider,
          signer,
          address: accounts[0],
          chainId: Number(network.chainId),
          connect,
          disconnect: () => {
            setState(prev => ({
              ...prev,
              provider: null,
              signer: null,
              address: null,
              chainId: null
            }));
          }
        });

        // 監聽帳戶變化
        window.ethereum.on('accountsChanged', (accounts: string[]) => {
          if (accounts.length === 0) {
            setState(prev => ({
              ...prev,
              address: null
            }));
          } else {
            setState(prev => ({
              ...prev,
              address: accounts[0]
            }));
          }
        });

        // 監聽網路變化
        window.ethereum.on('chainChanged', (chainId: string) => {
          window.location.reload();
        });

      } catch (error) {
        console.error('Failed to connect wallet:', error);
      }
    } else {
      alert('Please install MetaMask to use this DApp');
    }
  };

  useEffect(() => {
    // 檢查是否已連接
    const checkConnection = async () => {
      if (typeof window.ethereum !== 'undefined') {
        const accounts = await window.ethereum.request({
          method: 'eth_accounts'
        });
        if (accounts.length > 0) {
          await connect();
        }
      }
    };
    checkConnection();
  }, []);

  return state;
};

// 智能合約交互鉤子
const useContract = (contractAddress: string, abi: any) => {
  const { provider, signer } = useWeb3();
  
  const contract = useMemo(() => {
    if (!provider || !signer) return null;
    return new ethers.Contract(contractAddress, abi, signer);
  }, [provider, signer, contractAddress, abi]);

  return contract;
};

1.3 分散式存儲架構

對於需要存儲大量數據的 DApp，以太坊本身昂貴的 Gas 成本使其不適合直接存儲大文件。分散式存儲解決方案提供了經濟高效的替代方案：

// IPFS 文件上傳示例
import { create as ipfsHttpClient } from 'ipfs-http-client';

const ipfs = ipfsHttpClient({
  host: 'ipfs.infura.io',
  port: 5001,
  protocol: 'https'
});

async function uploadToIPFS(file: File): Promise<string> {
  try {
    const added = await ipfs.add(file, {
      progress: (prog) => console.log(`Received: ${prog}`)
    });
    return added.cid.toString(); // 返回 IPFS CID
  } catch (error) {
    console.error('Error uploading to IPFS:', error);
    throw error;
  }
}

// 從 IPFS 讀取文件
async function fetchFromIPFS(cid: string): Promise<any> {
  const response = await fetch(`https://ipfs.io/ipfs/${cid}`);
  return response.json();
}

// 將 IPFS 哈希存儲在智能合約中
interface IContentRegistry {
  function registerContent(
    string memory contentHash,
    string memory contentType,
    string memory metadata
  ) external returns (uint256);
  
  function getContent(uint256 id) external view returns (
    string memory contentHash,
    string memory contentType,
    address registrar,
    uint256 timestamp
  );
  
  function getContentCount() external view returns (uint256);
}

二、智慧合約開發實戰

2.1 開發環境配置

# 安裝开发工具
npm install -g hardhat
npm install -g forge

# 初始化 Hardhat 項目
mkdir my-dapp && cd my-dapp
npx hardhat init

# 安裝依賴
npm install @nomicfoundation/hardhat-toolbox
npm install dotenv
npm install @openzeppelin/contracts
npm install hardhat-gas-reporter
npm install solidity-coverage

2.2 Hardhat 配置文件

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();
require("hardhat-gas-reporter");
require("solidity-coverage");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    version: "0.8.24",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      },
      viaIR: true
    }
  },
  networks: {
    hardhat: {
      chainId: 31337
    },
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 11155111
    },
    mainnet: {
      url: process.env.MAINNET_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 1
    }
  },
  gasReporter: {
    enabled: process.env.REPORT_GAS === 'true',
    currency: 'USD',
    coinmarketcap: process.env.COINMARKETCAP_API_KEY
  },
  etherscan: {
    apiKey: {
      mainnet: process.env.ETHERSCAN_API_KEY,
      sepolia: process.env.ETHERSCAN_API_KEY
    }
  },
  paths: {
    sources: "./contracts",
    tests: "./test",
    cache: "./cache",
    artifacts: "./artifacts"
  }
};

2.3 完整 DApp 合約開發示例

讓我們開發一個完整的去中心化投票系統，作為 DApp 開發的實戰案例：

// contracts/DecentralizedVoting.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

/**
 * @title DecentralizedVoting
 * @notice 去中心化投票系統，支援多種投票類型、配額委托和即時結果
 * @dev 包含完整的訪問控制、投票權重計算和結果統計功能
 */
contract DecentralizedVoting is Ownable, ReentrancyGuard, Pausable {
    // ========================================
    // 錯誤定義
    // ========================================
    error Voting__NotStarted();
    error Voting__AlreadyEnded();
    error Voting__AlreadyVoted();
    error Voting__NotEligible();
    error Voting__InvalidOption();
    error Voting__InvalidWeight();
    error Voting__ProposalNotFound();
    error Voting__AlreadyExists();
    error Voting__DeadlineNotPassed();
    error Voting__Unauthorized();

    // ========================================
    // 枚舉定義
    // ========================================
    enum ProposalStatus {
        Pending,
        Active,
        Passed,
        Failed,
        Executed,
        Cancelled
    }

    enum VotingType {
        SingleChoice,      // 單選投票
        MultipleChoice,    // 多選投票
        QuadraticVoting,   // 二次投票
        WeightedVoting,    // 加權投票
        DelegatedVoting   // 委托投票
    }

    // ========================================
    // 結構體定義
    // ========================================
    struct Proposal {
        string title;
        string description;
        string metadataURI;
        VotingType votingType;
        uint256 startTime;
        uint256 endTime;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 abstainVotes;
        uint256 quorum;
        uint256 executionBudget;
        address proposer;
        bool executed;
        ProposalStatus status;
        bytes32 contentHash;
    }

    struct Voter {
        bool isRegistered;
        uint256 votingPower;
        uint256 votingPowerOverride;
        bool hasOverride;
        address delegate;
        bool isDelegating;
        uint256[] votedProposals;
        mapping(uint256 => bool) hasVotedOnProposal;
        mapping(uint256 => uint256) votesCast; // optionIndex => amount
    }

    struct VoteOption {
        string name;
        uint256 voteCount;
        bool isActive;
    }

    // ========================================
    // 狀態變量
    // ========================================
    uint256 public proposalCount;
    uint256 public totalVotingPower;
    uint256 public constantQuorum = 100; // 基礎法定人數 100 ETH 權力
    
    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => VoteOption[]) public proposalOptions;
    mapping(address => Voter) public voters;
    mapping(address => address[]) public delegators;
    mapping(bytes32 => bool) public registeredContent;
    
    // 事件定義
    event ProposalCreated(
        uint256 indexed proposalId,
        address indexed proposer,
        string title,
        VotingType votingType
    );
    
    event VoteCast(
        uint256 indexed proposalId,
        address indexed voter,
        uint256[] options,
        uint256[] weights
    );
    
    event VotingPowerChanged(
        address indexed voter,
        uint256 oldPower,
        uint256 newPower
    );
    
    event DelegateChanged(
        address indexed delegator,
        address indexed delegate,
        uint256 votingPower
    );
    
    event ProposalExecuted(
        uint256 indexed proposalId,
        bool success
    );

    // ========================================
    // 修改器
    // ========================================
    modifier onlyRegisteredVoter() {
        if (!voters[msg.sender].isRegistered) {
            revert Voting__NotEligible();
        }
        _;
    }

    modifier proposalExists(uint256 proposalId) {
        if (proposalId >= proposalCount) {
            revert Voting__ProposalNotFound();
        }
        _;
    }

    modifier isVotingActive(uint256 proposalId) {
        Proposal storage proposal = proposals[proposalId];
        if (block.timestamp < proposal.startTime) {
            revert Voting__NotStarted();
        }
        if (block.timestamp > proposal.endTime) {
            revert Voting__AlreadyEnded();
        }
        if (proposal.status != ProposalStatus.Active) {
            revert Voting__AlreadyEnded();
        }
        _;
    }

    // ========================================
    // 核心函數
    // ========================================
    
    /**
     * @notice 創建新的投票提案
     */
    function createProposal(
        string calldata title,
        string calldata description,
        string calldata metadataURI,
        VotingType votingType,
        uint256 duration,
        uint256 quorum_,
        string[] calldata options,
        bytes32 contentHash
    ) external whenNotPaused returns (uint256) {
        // 驗證輸入
        require(bytes(title).length > 0, "Title required");
        require(options.length >= 2, "At least 2 options required");
        require(options.length <= 10, "Max 10 options");
        
        uint256 proposalId = proposalCount++;
        Proposal storage proposal = proposals[proposalId];
        
        proposal.title = title;
        proposal.description = description;
        proposal.metadataURI = metadataURI;
        proposal.votingType = votingType;
        proposal.startTime = block.timestamp;
        proposal.endTime = block.timestamp + duration;
        proposal.quorum = quorum_;
        proposal.proposer = msg.sender;
        proposal.status = ProposalStatus.Active;
        proposal.contentHash = contentHash;
        
        // 初始化投票選項
        for (uint256 i = 0; i < options.length; i++) {
            proposalOptions[proposalId].push(VoteOption({
                name: options[i],
                voteCount: 0,
                isActive: true
            }));
        }
        
        if (bytes(metadataURI).length > 0) {
            registeredContent[contentHash] = true;
        }
        
        emit ProposalCreated(proposalId, msg.sender, title, votingType);
        
        return proposalId;
    }

    /**
     * @notice 投票函數 - 支援多種投票類型
     */
    function vote(
        uint256 proposalId,
        uint256[] calldata optionIndices,
        uint256[] calldata weights
    ) external nonReentrant proposalExists(proposalId) isVotingActive(proposalId) onlyRegisteredVoter {
        Proposal storage proposal = proposals[proposalId];
        Voter storage voter = voters[msg.sender];
        
        // 檢查是否已投票
        if (voter.hasVotedOnProposal[proposalId]) {
            revert Voting__AlreadyVoted();
        }
        
        // 處理委托投票
        if (voter.isDelegating) {
            revert Voting__Unauthorized();
        }
        
        // 驗證投票權力
        uint256 votingPower = _getVotingPower(msg.sender, proposalId);
        if (votingPower == 0) {
            revert Voting__InvalidWeight();
        }
        
        // 根據投票類型處理
        _processVote(proposal, voter, optionIndices, weights, votingPower);
        
        // 記錄投票
        voter.hasVotedOnProposal[proposalId] = true;
        voter.votedProposals.push(proposalId);
        
        emit VoteCast(proposalId, msg.sender, optionIndices, weights);
    }

    /**
     * @notice 處理不同類型的投票邏輯
     */
    function _processVote(
        Proposal storage proposal,
        Voter storage voter,
        uint256[] calldata optionIndices,
        uint256[] calldata weights,
        uint256 votingPower
    ) internal {
        VotingType vt = proposal.votingType;
        
        if (vt == VotingType.SingleChoice) {
            // 單選投票
            require(optionIndices.length == 1, "Single choice only");
            uint256 option = optionIndices[0];
            require(option < proposalOptions[proposal.proposalCount].length, "Invalid option");
            
            proposalOptions[proposal.proposalCount][option].voteCount += votingPower;
            voter.votesCast[proposal.proposalCount] = votingPower;
            
        } else if (vt == VotingType.MultipleChoice) {
            // 多選投票（每選項一票）
            uint256 totalVotes = 0;
            for (uint256 i = 0; i < optionIndices.length; i++) {
                require(optionIndices[i] < proposalOptions[proposal.proposalCount].length, "Invalid option");
                proposalOptions[proposal.proposalCount][optionIndices[i]].voteCount += 1;
                totalVotes++;
            }
            voter.votesCast[proposal.proposalCount] = totalVotes;
            
        } else if (vt == VotingType.QuadraticVoting) {
            // 二次投票：票數 = sqrt(代幣數量)
            uint256 totalCost;
            for (uint256 i = 0; i < optionIndices.length; i++) {
                uint256 option = optionIndices[i];
                uint256 weight = weights[i];
                
                // 二次成本計算：成本 = 權重^2
                uint256 cost = weight * weight;
                totalCost += cost;
                
                require(totalCost <= votingPower, "Insufficient voting power");
                proposalOptions[proposal.proposalCount][option].voteCount += weight;
            }
            
        } else if (vt == VotingType.WeightedVoting) {
            // 加權投票
            uint256 totalWeight;
            for (uint256 i = 0; i < optionIndices.length; i++) {
                uint256 option = optionIndices[i];
                uint256 weight = weights[i];
                
                require(option < proposalOptions[proposal.proposalCount].length, "Invalid option");
                require(weight > 0, "Invalid weight");
                
                proposalOptions[proposal.proposalCount][option].voteCount += weight;
                totalWeight += weight;
            }
            require(totalWeight <= votingPower, "Weight exceeds power");
        }
    }

    /**
     * @notice 計算投票權力
     */
    function _getVotingPower(address voterAddr, uint256 proposalId) 
        internal view returns (uint256) 
    {
        Voter storage voter = voters[voterAddr];
        
        // 優先使用覆蓋值
        if (voter.hasOverride) {
            return voter.votingPowerOverride;
        }
        
        // 如果正在委托，則使用被委托人的權力
        if (voter.isDelegating && voter.delegate != address(0)) {
            return _getVotingPower(voter.delegate, proposalId);
        }
        
        return voter.votingPower;
    }

    /**
     * @notice 委托投票權力
     */
    function delegate(address to) external onlyRegisteredVoter {
        require(to != msg.sender, "Cannot delegate to self");
        require(to != address(0), "Invalid delegate");
        
        Voter storage voter = voters[msg.sender];
        Voter storage delegatee = voters[to];
        
        require(delegatee.isRegistered, "Delegate not registered");
        
        // 移除舊的委托
        if (voter.isDelegating && voter.delegate != address(0)) {
            _removeDelegator(voter.delegate, msg.sender);
        }
        
        // 設置新委托
        voter.delegate = to;
        voter.isDelegating = true;
        
        delegators[to].push(msg.sender);
        
        emit DelegateChanged(msg.sender, to, voter.votingPower);
    }

    /**
     * @notice 取消委托
     */
    function undelegate() external {
        Voter storage voter = voters[msg.sender];
        
        if (voter.isDelegating && voter.delegate != address(0)) {
            _removeDelegator(voter.delegate, msg.sender);
            voter.delegate = address(0);
            voter.isDelegating = false;
        }
    }

    /**
     * @notice 移除委托者
     */
    function _removeDelegator(address delegatee, address delegator) internal {
        address[] storage delegatorsList = delegators[delegatee];
        for (uint256 i = 0; i < delegatorsList.length; i++) {
            if (delegatorsList[i] == delegator) {
                delegatorsList[i] = delegatorsList[delegatorsList.length - 1];
                delegatorsList.pop();
                break;
            }
        }
    }

    /**
     * @notice 結束投票並計算結果
     */
    function tallyVotes(uint256 proposalId) 
        external 
        proposalExists(proposalId) 
    {
        Proposal storage proposal = proposals[proposalId];
        
        require(
            block.timestamp > proposal.endTime || 
            proposal.status == ProposalStatus.Cancelled,
            "Voting not ended"
        );
        
        require(
            proposal.status == ProposalStatus.Active,
            "Already tallied"
        );
        
        // 計算總投票權力
        uint256 totalVotes = proposal.forVotes + 
                            proposal.againstVotes + 
                            proposal.abstainVotes;
        
        // 檢查法定人數
        bool quorumMet = totalVotes >= proposal.quorum;
        
        // 決定結果
        if (proposal.forVotes > proposal.againstVotes && quorumMet) {
            proposal.status = ProposalStatus.Passed;
        } else {
            proposal.status = ProposalStatus.Failed;
        }
    }

    /**
     * @notice 執行提案
     */
    function executeProposal(uint256 proposalId) 
        external 
        nonReentrant 
        proposalExists(proposalId) 
        onlyOwner 
    {
        Proposal storage proposal = proposals[proposalId];
        
        require(
            proposal.status == ProposalStatus.Passed,
            "Proposal not passed"
        );
        require(!proposal.executed, "Already executed");
        
        proposal.executed = true;
        proposal.status = ProposalStatus.Executed;
        
        emit ProposalExecuted(proposalId, true);
    }

    /**
     * @notice 註冊投票者（由管理員調用）
     */
    function registerVoter(address voter, uint256 votingPower) 
        external 
        onlyOwner 
    {
        require(voter != address(0), "Invalid address");
        
        Voter storage v = voters[voter];
        uint256 oldPower = v.votingPower;
        
        v.isRegistered = true;
        v.votingPower = votingPower;
        totalVotingPower += votingPower;
        
        emit VotingPowerChanged(voter, oldPower, votingPower);
    }

    /**
     * @notice 批量註冊投票者
     */
    function batchRegisterVoters(
        address[] calldata voterAddresses,
        uint256[] calldata votingPowers
    ) external onlyOwner {
        require(
            voterAddresses.length == votingPowers.length,
            "Length mismatch"
        );
        
        for (uint256 i = 0; i < voterAddresses.length; i++) {
            registerVoter(voterAddresses[i], votingPowers[i]);
        }
    }

    /**
     * @notice 查詢提案結果
     */
    function getProposalResults(uint256 proposalId) 
        external 
        view 
        proposalExists(proposalId) 
        returns (
            uint256 forVotes,
            uint256 againstVotes,
            uint256 abstainVotes,
            ProposalStatus status,
            string[] memory optionNames,
            uint256[] memory optionCounts
        ) 
    {
        Proposal storage proposal = proposals[proposalId];
        VoteOption[] storage options = proposalOptions[proposalId];
        
        string[] memory names = new string[](options.length);
        uint256[] memory counts = new uint256[](options.length);
        
        for (uint256 i = 0; i < options.length; i++) {
            names[i] = options[i].name;
            counts[i] = options[i].voteCount;
        }
        
        return (
            proposal.forVotes,
            proposal.againstVotes,
            proposal.abstainVotes,
            proposal.status,
            names,
            counts
        );
    }

    /**
     * @notice 查詢投票者信息
     */
    function getVoterInfo(address voter) 
        external 
        view 
        returns (
            bool isRegistered,
            uint256 votingPower,
            bool isDelegating,
            address delegatee,
            uint256[] memory votedProposals
        ) 
    {
        Voter storage v = voters[voter];
        return (
            v.isRegistered,
            v.votingPower,
            v.isDelegating,
            v.delegate,
            v.votedProposals
        );
    }

    // 緊急暫停功能
    function pause() external onlyOwner {
        _pause();
    }

    function unpause() external onlyOwner {
        _unpause();
    }
}

2.4 合約測試

// test/DecentralizedVoting.test.js
const { expect } = require("chai");
const { ethers } = require("hardhat");
const { time } = require("@nomicfoundation/hardhat-network-helpers");

describe("DecentralizedVoting", function () {
  let voting;
  let owner;
  let voter1;
  let voter2;
  let voter3;
  let addrs;

  beforeEach(async function () {
    const Voting = await ethers.getContractFactory("DecentralizedVoting");
    
    [owner, voter1, voter2, voter3, ...addrs] = await ethers.getSigners();
    
    voting = await Voting.deploy();
    await voting.deployed();
    
    // 註冊投票者
    await voting.registerVoter(voter1.address, 100);
    await voting.registerVoter(voter2.address, 200);
    await voting.registerVoter(voter3.address, 50);
  });

  describe("Proposal Creation", function () {
    it("should create a proposal with correct parameters", async function () {
      const options = ["Yes", "No"];
      
      const tx = await voting.createProposal(
        "Test Proposal",
        "This is a test proposal",
        "",
        0, // SingleChoice
        86400, // 1 day duration
        50,
        options,
        ethers.utils.formatBytes32String("")
      );
      
      const receipt = await tx.wait();
      const event = receipt.events.find(e => e.event === "ProposalCreated");
      
      expect(event).to.not.be.undefined;
      expect(event.args.title).to.equal("Test Proposal");
    });

    it("should revert if options less than 2", async function () {
      await expect(
        voting.createProposal(
          "Invalid Proposal",
          "Description",
          "",
          0,
          86400,
          50,
          ["Only One"],
          ethers.utils.formatBytes32String("")
        )
      ).to.be.revertedWith("At least 2 options required");
    });
  });

  describe("Voting", function () {
    let proposalId;

    beforeEach(async function () {
      const options = ["Yes", "No"];
      const tx = await voting.createProposal(
        "Vote Test",
        "Testing voting mechanism",
        "",
        0,
        86400,
        50,
        options,
        ethers.utils.formatBytes32String("")
      );
      
      const receipt = await tx.wait();
      proposalId = receipt.events[0].args.proposalId;
    });

    it("should record vote correctly", async function () {
      await voting.connect(voter1).vote(proposalId, [0], [100]);
      
      const [, , , , , optionCounts] = await voting.getProposalResults(proposalId);
      
      expect(optionCounts[0]).to.equal(100);
      expect(optionCounts[1]).to.equal(0);
    });

    it("should prevent double voting", async function () {
      await voting.connect(voter1).vote(proposalId, [0], [100]);
      
      await expect(
        voting.connect(voter1).vote(proposalId, [1], [100])
      ).to.be.revertedWithCustomError(voting, "Voting__AlreadyVoted");
    });
  });

  describe("Delegation", function () {
    it("should delegate voting power", async function () {
      await voting.connect(voter1).delegate(voter2.address);
      
      const [, , isDelegating, delegatee] = await voting.getVoterInfo(voter1.address);
      
      expect(isDelegating).to.be.true;
      expect(delegatee).to.equal(voter2.address);
    });

    it("should transfer voting power to delegate", async function () {
      await voting.connect(voter1).delegate(voter2.address);
      
      const [, votingPower, ,] = await voting.getVoterInfo(voter1.address);
      
      expect(votingPower).to.equal(100);
    });
  });

  describe("Vote Counting", function () {
    it("should correctly tally votes after voting ends", async function () {
      const options = ["Yes", "No"];
      const tx = await voting.createProposal(
        "Tally Test",
        "Testing vote tallying",
        "",
        0,
        1, // 1 second duration
        50,
        options,
        ethers.utils.formatBytes32String("")
      );
      
      const receipt = await tx.wait();
      const proposalId = receipt.events[0].args.proposalId;
      
      // 投票
      await voting.connect(voter1).vote(proposalId, [0], [100]);
      await voting.connect(voter2).vote(proposalId, [1], [200]);
      
      // 等待投票結束
      await time.increase(2);
      
      // 計算票數
      await voting.tallyVotes(proposalId);
      
      const [forVotes, againstVotes, status] = await voting.getProposalResults(proposalId);
      
      expect(forVotes).to.equal(100);
      expect(againstVotes).to.equal(200);
    });
  });
});

2.5 合約部署腳本

// scripts/deploy.js
const { ethers } = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();
  
  console.log("Deploying contracts with the account:", deployer.address);
  console.log("Account balance:", (await deployer.getBalance()).toString());
  
  // 部署投票合約
  const Voting = await ethers.getContractFactory("DecentralizedVoting");
  const voting = await Voting.deploy();
  
  console.log("Voting contract address:", voting.address);
  
  // 等待區塊確認
  await voting.deployed();
  
  console.log("Deployment completed!");
  
  // 驗證合約
  if (process.env.ETHERSCAN_API_KEY) {
    await hre.run("verify:verify", {
      address: voting.address,
      constructorArguments: [],
    });
    console.log("Contract verified on Etherscan");
  }
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

三、商業模式分析

3.1 DApp 商業模式分類

以太坊 DApp 的商業模式可分為以下幾類：

3.2 Uniswap 的協議費用模式深度分析

Uniswap 是最成功的 DeFi 協議之一，其商業模式值得深入研究：

收入模型：

• LP（流動性提供者）提供交易對
• 交易者支付 0.3% 的交易費（V2）或 0.05%/0.30%/1% 可變費用（V3）
• 協議不直接收取費用，但透過代幣持有者治理分享費用

代幣經濟學：

• UNI 代幣總供應量：10 億枚
• 分配：60% 社區金庫、21.51% 團隊、17.49% 投資者、1% 社區空投
• 質押收益：交易費用的分成

// 前端交易費計算
interface SwapQuote {
  inputAmount: bigint;
  outputAmount: bigint;
  priceImpact: number;
  minimumReceived: bigint;
  route: string[];
  gasEstimate: bigint;
}

async function getSwapQuote(
  tokenIn: string,
  tokenOut: string,
  amountIn: bigint,
  slippageTolerance: number = 0.5
): Promise<SwapQuote> {
  // 計算輸出金額（考慮 0.3% 費用）
  const feeFactor = 997n; // 0.3% fee = 1000 - 997
  const amountInWithFee = amountIn * feeFactor / 1000n;
  
  // 獲取交換路徑
  const path = [tokenIn, tokenOut];
  const [reserveIn, reserveOut] = await getReserves(path);
  
  // 計算輸出
  const amountOut = getAmountOut(amountInWithFee, reserveIn, reserveOut);
  
  // 計算價格影響
  const priceImpact = calculatePriceImpact(
    amountIn,
    amountOut,
    reserveIn,
    reserveOut
  );
  
  // 最小輸出（考慮滑點）
  const minimumReceived = amountOut * (1000n - BigInt(slippageTolerance * 10)) / 1000n;
  
  return {
    inputAmount: amountIn,
    outputAmount: amountOut,
    priceImpact,
    minimumReceived,
    route: path,
    gasEstimate: estimateSwapGas(path, amountIn, amountOut)
  };
}

3.3 The Graph 的去中心化數據服務模式

The Graph 採用獨特的去中心化索引和查詢服務模式：

參與者：

• 索引者（Indexers）：運行節點索引區塊鏈數據，賺取查詢費用和通證獎勵
• 策展人（Curators）：標記高質量子圖，賺取策展獎勵
• 委託人（Delegators）：委託 GRT 給索引者，分享收益
• 開發者：創建子圖，為應用提供數據

費用機制：

• 查詢費用：按查詢次數和複雜度收費
• 網路獎勵：通脹發行（約 3% 年通脹）
• 查詢費用的 1% 燒毀

// The Graph 子圖定義示例
// schema.graphql
type Transfer @entity {
  id: ID!
  block: BigInt!
  timestamp: BigInt!
  from: Bytes!
  to: Bytes!
  value: BigInt!
  gasUsed: BigInt!
  gasPrice: BigInt!
}

type DailyTransferAggregate @entity {
  id: String!  # YYYY-MM-DD
  date: String!
  totalTransfers: BigInt!
  totalVolume: BigInt!
  averageGasPrice: BigInt!
}

// mapping.ts
import { Transfer as TransferEvent } from "../generated/ERC20/Transfer";
import { Transfer, DailyTransferAggregate } from "../generated/schema";

export function handleTransfer(event: TransferEvent): void {
  // 創建轉帳記錄
  let transfer = new Transfer(
    event.transaction.hash.toHex() + "-" + event.logIndex.toString()
  );
  transfer.block = event.block.number;
  transfer.timestamp = event.block.timestamp;
  transfer.from = event.params.from;
  transfer.to = event.params.to;
  transfer.value = event.params.value;
  transfer.gasUsed = event.gas;
  transfer.gasPrice = event.gasPrice;
  transfer.save();
  
  // 更新日聚合
  let dateStr = new Date(event.block.timestamp.toI64() * 1000).toISOString().slice(0, 10);
  let aggregate = DailyTransferAggregate.load(dateStr);
  
  if (!aggregate) {
    aggregate = new DailyTransferAggregate(dateStr);
    aggregate.date = dateStr;
    aggregate.totalTransfers = BigInt.zero();
    aggregate.totalVolume = BigInt.zero();
    aggregate.averageGasPrice = BigInt.zero();
  }
  
  aggregate.totalTransfers = aggregate.totalTransfers + BigInt.fromI32(1);
  aggregate.totalVolume = aggregate.totalVolume + event.params.value;
  
  // 更新平均 Gas Price（滾動平均）
  let prevTotal = aggregate.totalTransfers - BigInt.fromI32(1);
  if (prevTotal > BigInt.zero()) {
    let prevAvg = aggregate.averageGasPrice;
    aggregate.averageGasPrice = (
      prevAvg * prevTotal + event.gasPrice
    ) / aggregate.totalTransfers;
  } else {
    aggregate.averageGasPrice = event.gasPrice;
  }
  
  aggregate.save();
}

3.4 NFT 市場交易模式分析

OpenSea 作為最大的 NFT 市場，其商業模式包含多個收入來源：

// NFT 市場合約核心邏輯
interface IMarketplace {
    // 掛單
    function createListing(
        address nftContract,
        uint256 tokenId,
        uint256 price,
        address currency
    ) external returns (uint256 listingId);
    
    // 購買
    function buyListing(uint256 listingId) external payable;
    
    // 修改價格
    function updateListing(uint256 listingId, uint256 newPrice) external;
    
    // 取消掛單
    function cancelListing(uint256 listingId) external;
}

contract NFTMarketplace {
    uint256 public constant PLATFORM_FEE = 250; // 2.5% = 250 basis points
    
    mapping(uint256 => Listing) public listings;
    
    struct Listing {
        address seller;
        address nftContract;
        uint256 tokenId;
        uint256 price;
        address currency;  // address(0) for ETH
        bool active;
        uint256 createdAt;
    }
    
    // 創建掛單
    function createListing(
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) external returns (uint256 listingId) {
        // 轉移 NFT 到市場合約
        IERC721(nftContract).transferFrom(
            msg.sender,
            address(this),
            tokenId
        );
        
        listingId = nextListingId++;
        listings[listingId] = Listing({
            seller: msg.sender,
            nftContract: nftContract,
            tokenId: tokenId,
            price: price,
            currency: address(0), // ETH
            active: true,
            createdAt: block.timestamp
        });
        
        emit ListingCreated(listingId, msg.sender, nftContract, tokenId, price);
    }
    
    // 購買 NFT
    function buyListing(uint256 listingId) external payable {
        Listing storage listing = listings[listingId];
        
        require(listing.active, "Listing not active");
        require(msg.value >= listing.price, "Insufficient payment");
        
        // 計算費用
        uint256 platformFee = (listing.price * PLATFORM_FEE) / 10000;
        uint256 sellerProceeds = listing.price - platformFee;
        
        // 轉帳給賣家
        payable(listing.seller).transfer(sellerProceeds);
        
        // 轉帳 NFT 給買家
        IERC721(listing.nftContract).transferFrom(
            address(this),
            msg.sender,
            listing.tokenId
        );
        
        // 標記為已售出
        listing.active = false;
        
        emit SaleCompleted(listingId, msg.sender, listing.price);
    }
    
    // 計算版稅並分發
    function _distributeRoyalties(
        uint256 listingId,
        uint256 salePrice
    ) internal {
        // 查詢 NFT 合約的版稅信息（ERC-2981）
        (address royaltyRecipient, uint256 royaltyAmount) = 
            IERC2981(listings[listingId].nftContract).royaltyInfo(
                listings[listingId].tokenId,
                salePrice
            );
        
        if (royaltyAmount > 0 && royaltyRecipient != address(0)) {
            // 支付版稅給創作者
            payable(royaltyRecipient).transfer(royaltyAmount);
        }
    }
}

四、安全最佳實踐

4.1 智慧合約安全清單

□ 使用 SafeMath 或 Solidity 0.8+ 內建溢出檢查
□ 實作 ReentrancyGuard
□ 驗證所有輸入參數
□ 限制管理員權限
□ 實現緊急暫停機制
□ 完整的測試覆蓋（> 95%）
□ 第三方審計
□ 時間鎖延遲（Timelock）治理
□ 多重簽名錢包管理
□ 定期安全監控

4.2 常用安全模式

// 安全轉帳模式
function safeTransfer(address to, uint256 amount) internal {
    (bool success, ) = to.call{value: amount}("");
    require(success, "Transfer failed");
}

// 閃電貸安全模式
function secureFlashLoan(uint256 amount) internal {
    uint256 balanceBefore = IERC20(token).balanceOf(address(this));
    require(balanceBefore >= amount, "Insufficient balance");
    
    // 業務邏輯
    // ...
    
    uint256 balanceAfter = IERC20(token).balanceOf(address(this));
    require(balanceAfter >= balanceBefore, "Flash loan not repaid");
}

// 速率限制模式
contract RateLimiter {
    uint256 public rateLimit;
    uint256 public lastUpdate;
    uint256 public currentUsage;
    
    function updateUsage(uint256 amount) internal {
        uint256 timePassed = block.timestamp - lastUpdate;
        // 每秒恢復 rateLimit / 86400 的額度
        currentUsage = currentUsage > (timePassed * rateLimit / 86400) 
            ? currentUsage - (timePassed * rateLimit / 86400)
            : 0;
        lastUpdate = block.timestamp;
        
        require(currentUsage + amount <= rateLimit, "Rate limit exceeded");
        currentUsage += amount;
    }
}

五、部署與運維

5.1 Layer 2 部署策略

// 部署到多個網路的配置
const deploymentConfig = {
  mainnet: {
    network: 'mainnet',
    chainId: 1,
    confirmations: 12,
    gasPrice: 'auto'
  },
  arbitrum: {
    network: 'arbitrum',
    chainId: 42161,
    confirmations: 1,
    gasPrice: 'auto'
  },
  optimism: {
    network: 'optimism',
    chainId: 10,
    confirmations: 1,
    gasPrice: 'auto'
  },
  polygon: {
    network: 'polygon',
    chainId: 137,
    confirmations: 10,
    gasPrice: 'auto'
  }
};

async function deployToAllNetworks() {
  const results = {};
  
  for (const [network, config] of Object.entries(deploymentConfig)) {
    console.log(`Deploying to ${network}...`);
    
    // 部署
    const Voting = await ethers.getContractFactory("DecentralizedVoting");
    const voting = await Voting.deploy({
      ...config
    });
    await voting.deployed();
    
    results[network] = {
      address: voting.address,
      chainId: config.chainId,
      timestamp: new Date().toISOString()
    };
    
    console.log(`Deployed to ${network}: ${voting.address}`);
  }
  
  // 導出部署結果
  const fs = require('fs');
  fs.writeFileSync(
    'deployments.json',
    JSON.stringify(results, null, 2)
  );
}

5.2 監控與告警

// 智能合約監控腳本
import { ethers } from 'ethers';

interface MonitoringConfig {
  contractAddress: string;
  rpcUrl: string;
  alertWebhook: string;
  walletThreshold: number;
}

class ContractMonitor {
  private provider: ethers.JsonRpcProvider;
  private contract: ethers.Contract;
  private config: MonitoringConfig;
  
  constructor(config: MonitoringConfig) {
    this.provider = new ethers.JsonRpcProvider(config.rpcUrl);
    this.config = config;
    
    const abi = [
      "event Transfer(address indexed from, address indexed to, uint256 value)",
      "event AdminChanged(address indexed oldAdmin, address indexed newAdmin)",
      "event Paused(address account)",
      "event Unpaused(address account)"
    ];
    
    this.contract = new ethers.Contract(
      config.contractAddress,
      abi,
      this.provider
    );
  }
  
  async start() {
    // 監控大額轉帳
    this.contract.on("Transfer", async (from, to, value, event) => {
      const valueInEth = ethers.formatEther(value);
      
      if (parseFloat(valueInEth) > this.config.walletThreshold) {
        await this.sendAlert({
          type: 'LARGE_TRANSFER',
          from,
          to,
          value: valueInEth,
          txHash: event.log.transactionHash,
          blockNumber: event.log.blockNumber
        });
      }
    });
    
    // 監控管理員變更
    this.contract.on("AdminChanged", async (oldAdmin, newAdmin, event) => {
      await this.sendAlert({
        type: 'ADMIN_CHANGE',
        oldAdmin,
        newAdmin,
        txHash: event.log.transactionHash
      });
    });
    
    // 監控暫停事件
    this.contract.on("Paused", async (account, event) => {
      await this.sendAlert({
        type: 'CONTRACT_PAUSED',
        account,
        txHash: event.log.transactionHash
      });
    });
    
    console.log('Monitoring started...');
  }
  
  private async sendAlert(data: any) {
    // 實現告警邏輯（Webhook、Email 等）
    console.error('ALERT:', JSON.stringify(data));
  }
  
  async getContractStats() {
    const blockNumber = await this.provider.getBlockNumber();
    const gasPrice = await this.provider.getFeeData();
    
    return {
      blockNumber,
      gasPrice: gasPrice.gasPrice?.toString(),
      timestamp: new Date().toISOString()
    };
  }
}

結論

以太坊 DApp 開發是一個系統性工程，需要兼顧區塊鏈技術、業務邏輯、安全性和用戶體驗。本指南涵蓋了從架構設計、智慧合約開發、測試部署到商業模式分析的完整流程。

成功的 DApp 關鍵要素：

1. 安全性第一：智慧合約一旦部署難以修改，安全審計不可或缺
2. 用戶體驗：Gas 優化、簡化操作流程、錢包整合
3. 可擴展性：選擇合適的 Layer 2 方案，支援未來增長
4. 商業可持續性：清晰的代幣經濟學和收入模型
5. 社區建設：開發者社區和用戶社群的長期經營

參考資源：

• Solidity 官方文檔：https://docs.soliditylang.org
• Hardhat 開發框架：https://hardhat.org
• OpenZeppelin 合約庫：https://openzeppelin.com/contracts
• The Graph 文檔：https://thegraph.com/docs
• 智慧合約安全指南：https://consensys.github.io/smart-contract-best-practices

免責聲明：本網站內容僅供教育與資訊目的，不構成任何投資建議或推薦。在進行任何加密貨幣相關操作前，請自行研究並諮詢專業人士意見。所有投資均有風險，請謹慎評估您的風險承受能力。