DEV Community: richard202605

Web3 开发者入门完全指南：从零构建你的第一个 DApp

richard202605 — Wed, 13 May 2026 14:25:24 +0000

Web3 开发者入门完全指南：从零构建你的第一个 DApp

想进入 Web3 开发但不知道从哪开始？这篇指南带你从零搭建开发环境，写第一个智能合约，部署到测试网，并用前端连接它。

为什么学 Web3 开发？

💰 Web3 开发者薪资普遍高于传统开发者
🌍 去中心化应用正在重塑金融、游戏、社交
🔧 工具链已经成熟，入门门槛大幅降低
📈 2026 年 Web3 岗位需求持续增长

1. 开发环境搭建

1.1 安装 Node.js

# 使用 nvm 安装（推荐）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install 18
nvm use 18

# 验证
node --version  # v18.x.x
npm --version   # 9.x.x

1.2 安装开发框架

Hardhat（推荐新手）：

mkdir my-first-dapp && cd my-first-dapp
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npx hardhat init

选择 "Create a JavaScript project"，其余默认即可。

项目结构：

my-first-dapp/
├── contracts/          # 智能合约
├── scripts/            # 部署脚本
├── test/               # 测试文件
├── hardhat.config.js   # 配置文件
└── package.json

1.3 安装 MetaMask

访问 https://metamask.io
安装浏览器扩展
创建钱包（保管好助记词！）
添加 Sepolia 测试网

2. Solidity 基础

Solidity 是以太坊的智能合约语言，语法类似 JavaScript。

2.1 Hello World 合约

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

contract HelloWorld {
    string public greeting;
    address public owner;

    constructor() {
        greeting = "Hello, Web3!";
        owner = msg.sender;
    }

    function setGreeting(string memory _greeting) public {
        require(msg.sender == owner, "Only owner can change greeting");
        greeting = _greeting;
    }

    function getGreeting() public view returns (string memory) {
        return greeting;
    }
}

2.2 核心概念

概念	说明
`pragma`	指定编译器版本
`contract`	类似 class，是合约的基本单位
`public`	自动生成 getter 函数
`view`	只读函数，不修改状态
`msg.sender`	调用者的地址
`constructor`	部署时执行一次

2.3 数据类型

// 基础类型
uint256 public number = 42;        // 无符号整数
bool public active = true;          // 布尔值
address public addr;                // 以太坊地址
string public name = "FlowForge";   // 字符串

// 映射（类似字典）
mapping(address => uint256) public balances;

// 数组
uint256[] public numbers;

3. 编写第一个完整合约

让我们创建一个简单的投票合约：

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

contract SimpleVoting {
    // 数据结构
    struct Proposal {
        string name;
        uint256 voteCount;
    }

    // 状态变量
    address public chairperson;
    mapping(address => bool) public hasVoted;
    Proposal[] public proposals;

    // 事件
    event Voted(address indexed voter, uint256 proposalIndex);

    // 构造函数
    constructor(string[] memory proposalNames) {
        chairperson = msg.sender;
        for (uint256 i = 0; i < proposalNames.length; i++) {
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }

    // 投票函数
    function vote(uint256 proposalIndex) public {
        require(!hasVoted[msg.sender], "Already voted");
        require(proposalIndex < proposals.length, "Invalid proposal");

        hasVoted[msg.sender] = true;
        proposals[proposalIndex].voteCount++;

        emit Voted(msg.sender, proposalIndex);
    }

    // 获取提案数量
    function getProposalCount() public view returns (uint256) {
        return proposals.length;
    }

    // 获取提案信息
    function getProposal(uint256 index) public view returns (string memory name, uint256 voteCount) {
        require(index < proposals.length, "Invalid index");
        Proposal storage p = proposals[index];
        return (p.name, p.voteCount);
    }
}

4. 编写测试

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("SimpleVoting", function () {
  let voting;
  let owner, voter1, voter2;

  beforeEach(async function () {
    [owner, voter1, voter2] = await ethers.getSigners();
    const SimpleVoting = await ethers.getContractFactory("SimpleVoting");
    voting = await SimpleVoting.deploy(["Alice", "Bob", "Charlie"]);
  });

  it("Should initialize proposals", async function () {
    expect(await voting.getProposalCount()).to.equal(3);

    const [name, votes] = await voting.getProposal(0);
    expect(name).to.equal("Alice");
    expect(votes).to.equal(0);
  });

  it("Should allow voting", async function () {
    await voting.connect(voter1).vote(0);

    const [, votes] = await voting.getProposal(0);
    expect(votes).to.equal(1);
  });

  it("Should prevent double voting", async function () {
    await voting.connect(voter1).vote(0);
    await expect(voting.connect(voter1).vote(1)).to.be.revertedWith("Already voted");
  });
});

运行测试：

npx hardhat test

5. 部署到测试网

5.1 配置 Sepolia 网络

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

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: "https://ethereum-sepolia-rpc.publicnode.com",
      accounts: ["YOUR_PRIVATE_KEY"]  // MetaMask 导出的私钥
    }
  }
};

5.2 编写部署脚本

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const SimpleVoting = await hre.ethers.getContractFactory("SimpleVoting");
  const voting = await SimpleVoting.deploy(["Alice", "Bob", "Charlie"]);

  await voting.waitForDeployment();
  console.log("SimpleVoting deployed to:", await voting.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

5.3 执行部署

# 确保钱包有测试 ETH
npx hardhat run scripts/deploy.js --network sepolia

6. 前端连接钱包

6.1 安装 ethers.js

npm install ethers

6.2 连接 MetaMask

import { ethers } from "ethers";

// 连接钱包
async function connectWallet() {
  if (typeof window.ethereum === "undefined") {
    alert("请安装 MetaMask!");
    return;
  }

  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  const address = await signer.getAddress();

  console.log("连接成功:", address);
  return { provider, signer };
}

6.3 与合约交互

// 合约 ABI（编译后生成）
const CONTRACT_ABI = [...]; // 从 artifacts/contracts/SimpleVoting.sol/SimpleVoting.json 复制
const CONTRACT_ADDRESS = "0x..."; // 部署后的合约地址

async function vote(proposalIndex) {
  const { signer } = await connectWallet();
  const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signer);

  const tx = await contract.vote(proposalIndex);
  await tx.wait();

  console.log("投票成功!");
}

async function getProposals() {
  const { provider } = await connectWallet();
  const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, provider);

  const count = await contract.getProposalCount();
  const proposals = [];

  for (let i = 0; i < count; i++) {
    const [name, votes] = await contract.getProposal(i);
    proposals.push({ name, votes: Number(votes) });
  }

  return proposals;
}

7. 安全最佳实践

7.1 常见漏洞

漏洞	说明	防御
重入攻击	外部调用中重复进入函数	使用 ReentrancyGuard
整数溢出	数值超出范围	Solidity 0.8+ 自动检查
权限漏洞	未限制关键函数	使用 modifier 验证
前端攻击	用户签署恶意交易	验证交易参数

7.2 安全检查清单

[ ] 使用最新 Solidity 版本
[ ] 所有外部调用放在最后
[ ] 关键函数添加权限控制
[ ] 使用 OpenZeppelin 库
[ ] 充分测试边界情况
[ ] 部署前进行审计

8. 进阶学习路线

初级 → 中级 → 高级
│       │       │
│       │       └── 形式化验证、MEV、跨链
│       │
│       └── DeFi 协议、NFT、DAO
│
└── Solidity 基础、ERC-20、测试

推荐资源：

📚 Solidity 官方文档
🎮 CryptoZombies — 游戏化学习
🛠️ OpenZeppelin — 安全合约库
💬 Ethereum Stack Exchange — 问答社区

总结

你已经学会了：

✅ 搭建 Hardhat 开发环境
✅ 编写 Solidity 智能合约
✅ 编写和运行测试
✅ 部署到 Sepolia 测试网
✅ 用前端连接钱包和合约

下一步： 尝试构建一个完整的 DApp，比如 NFT 铸造、DeFi 借贷、或去中心化投票系统。

📌 免责声明： 本文仅供教育目的。智能合约涉及真金白银，请充分测试后再部署到主网。

觉得有帮助？关注 @richard202605 获取更多 Web3 开发教程。有问题？评论区见！

Web3 开发者入门完全指南：从零开始构建你的第一个 DApp

richard202605 — Wed, 13 May 2026 14:21:52 +0000

Web3 开发者入门完全指南：从零开始构建你的第一个 DApp

Web3 正在重新定义互联网的未来。作为一名开发者，掌握区块链和智能合约开发技能已经成为一项极具竞争力的能力。本文将带你从零开始，一步步搭建 Web3 开发环境，编写智能合约，部署到测试网，并构建一个完整的去中心化应用（DApp）。

无论你是前端开发者、后端工程师，还是对区块链技术充满好奇的初学者，这篇指南都能帮你快速入门。

一、Web3 开发环境搭建

1.1 安装 Node.js

Web3 开发工具链大量依赖 Node.js 生态，因此首先需要安装 Node.js（推荐 v18+）。

# 使用 nvm 安装 Node.js（推荐方式）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install 20
nvm use 20

# 验证安装
node -v  # 应输出 v20.x.x
npm -v   # 应输出 10.x.x

1.2 安装 Hardhat（推荐）

Hardhat 是目前最流行的以太坊开发框架，提供了编译、测试、部署等一站式工具。

# 创建项目目录
mkdir my-web3-project && cd my-web3-project

# 初始化 npm 项目
npm init -y

# 安装 Hardhat 及其依赖
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

# 初始化 Hardhat 项目
npx hardhat

选择 "Create a JavaScript project"，然后按回车使用默认配置。初始化完成后，项目目录结构如下：

my-web3-project/
├── contracts/          # 智能合约目录
│   └── Lock.sol       # 示例合约
├── scripts/            # 部署脚本
│   └── deploy.js
├── test/               # 测试文件
│   └── Lock.js
├── hardhat.config.js   # Hardhat 配置文件
└── package.json

1.3 可选：安装 Foundry

Foundry 是用 Rust 编写的高性能 Solidity 开发工具，速度极快，深受高级开发者喜爱。

# 安装 Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

# 初始化 Foundry 项目
forge init my-foundry-project
cd my-foundry-project

# 编译合约
forge build

# 运行测试
forge test

💡 建议：初学者优先使用 Hardhat，熟悉后再学习 Foundry。两者都是优秀的工具，可以根据项目需求选择。

1.4 安装 VS Code 插件

推荐安装以下 VS Code 扩展来提升开发体验：

Solidity (Juan Blanco)：Solidity 语法高亮和智能提示
Hardhat VSCode：Hardhat 官方插件
Prettier：代码格式化

二、Solidity 基础语法：Hello World 合约

Solidity 是以太坊上最主流的智能合约编程语言，语法类似于 JavaScript 和 C++。

2.1 第一个智能合约

在 contracts/ 目录下创建 HelloWeb3.sol：

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

/**
 * @title HelloWeb3
 * @dev 一个简单的智能合约示例
 */
contract HelloWeb3 {
    // 状态变量（存储在区块链上）
    string public greeting;
    address public owner;
    uint256 public createdAt;

    // 事件（用于前端监听）
    event GreetingChanged(address indexed changer, string newGreeting);

    // 构造函数：部署时自动执行一次
    constructor(string memory _greeting) {
        greeting = _greeting;
        owner = msg.sender;
        createdAt = block.timestamp;
    }

    // 修改状态的函数（需要发送交易）
    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
        emit GreetingChanged(msg.sender, _greeting);
    }

    // 只读函数（不需要 gas）
    function getGreeting() public view returns (string memory) {
        return greeting;
    }

    // 获取合约信息
    function getContractInfo() public view returns (
        string memory,
        address,
        uint256
    ) {
        return (greeting, owner, createdAt);
    }
}

2.2 Solidity 核心概念速览

概念	说明	示例
`state variable`	存储在区块链上的变量	`string public greeting`
`msg.sender`	调用函数的钱包地址	`owner = msg.sender`
`event`	可被前端监听的日志	`emit GreetingChanged(...)`
`view`	只读函数，不消耗 gas	`function getGreeting() public view`
`modifier`	函数的访问控制	`onlyOwner`
`mapping`	键值对数据结构	`mapping(address => uint256)`

2.3 编译合约

npx hardhat compile

成功编译后，artifacts/ 目录会生成 ABI 和字节码文件，这些是部署和交互的必需品。

三、部署到测试网（Sepolia）

在部署到主网之前，我们先在 Sepolia 测试网上进行测试。测试网使用的是没有实际价值的测试 ETH。

3.1 获取测试 ETH

前往以下水龙头领取 Sepolia 测试 ETH：

你需要至少 0.1 ETH 来进行测试。

3.2 配置 Hardhat 网络

安装 dotenv 来管理私钥：

npm install dotenv

创建 .env 文件（⚠️ 绝对不要将此文件提交到 Git）：

# .env
PRIVATE_KEY=your_wallet_private_key_here
SEPOLIA_RPC_URL=https://eth-sepolia.g.alchemy.com/v2/your-api-key
ETHERSCAN_API_KEY=your_etherscan_api_key

更新 hardhat.config.js：

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

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL || "",
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
      chainId: 11155111,
    },
  },
};

3.3 编写部署脚本

创建 scripts/deploy-hello.js：

const hre = require("hardhat");

async function main() {
  console.log("🚀 开始部署 HelloWeb3 合约...");

  // 获取合约工厂
  const HelloWeb3 = await hre.ethers.getContractFactory("HelloWeb3");

  // 部署合约，传入构造函数参数
  const helloWeb3 = await HelloWeb3.deploy("你好，Web3 世界！");

  // 等待部署确认
  await helloWeb3.waitForDeployment();

  const address = await helloWeb3.getAddress();
  console.log(`✅ HelloWeb3 已部署到: ${address}`);

  // 读取合约状态
  const greeting = await helloWeb3.getGreeting();
  console.log(`📝 当前问候语: ${greeting}`);

  const [greet, owner, timestamp] = await helloWeb3.getContractInfo();
  console.log(`👤 合约所有者: ${owner}`);
  console.log(`⏰ 创建时间: ${new Date(Number(timestamp) * 1000).toLocaleString()}`);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error("❌ 部署失败:", error);
    process.exit(1);
  });

3.4 执行部署

# 部署到本地 Hardhat 网络（用于开发测试）
npx hardhat run scripts/deploy-hello.js

# 部署到 Sepolia 测试网
npx hardhat run scripts/deploy-hello.js --network sepolia

部署成功后，你会看到类似输出：

🚀 开始部署 HelloWeb3 合约...
✅ HelloWeb3 已部署到: 0x1234...abcd
📝 当前问候语: 你好，Web3 世界！
👤 合约所有者: 0xYourAddress
⏰ 创建时间: 2024/1/15 14:30:00

📌 记下合约地址，后面连接前端时会用到！

3.5 在 Etherscan 上验证合约

npx hardhat verify --network sepolia DEPLOYED_CONTRACT_ADDRESS "你好，Web3 世界！"

验证后，用户可以在 Etherscan 上直接查看源码和交互合约。

四、前端连接钱包（ethers.js）

现在让我们构建一个 React 前端来连接用户的钱包并与合约交互。

4.1 创建 React 项目

cd ..
npx create-react-app web3-frontend
cd web3-frontend

# 安装 ethers.js
npm install ethers

💡 也可以使用 Vite + React 来获得更快的开发体验：npm create vite@latest web3-frontend -- --template react

4.2 连接 MetaMask 钱包

创建 src/hooks/useWallet.js：

import { useState, useCallback } from 'react';
import { BrowserProvider } from 'ethers';

export function useWallet() {
  const [account, setAccount] = useState(null);
  const [provider, setProvider] = useState(null);
  const [chainId, setChainId] = useState(null);
  const [isConnecting, setIsConnecting] = useState(false);
  const [error, setError] = useState(null);

  const connectWallet = useCallback(async () => {
    if (!window.ethereum) {
      setError('请安装 MetaMask 钱包！');
      return;
    }

    setIsConnecting(true);
    setError(null);

    try {
      // 请求连接钱包
      const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts',
      });

      const provider = new BrowserProvider(window.ethereum);
      const network = await provider.getNetwork();

      setAccount(accounts[0]);
      setProvider(provider);
      setChainId(Number(network.chainId));
    } catch (err) {
      setError(err.message || '连接钱包失败');
    } finally {
      setIsConnecting(false);
    }
  }, []);

  const disconnectWallet = useCallback(() => {
    setAccount(null);
    setProvider(null);
    setChainId(null);
  }, []);

  return {
    account,
    provider,
    chainId,
    isConnecting,
    error,
    connectWallet,
    disconnectWallet,
  };
}

4.3 创建钱包连接组件

创建 src/components/ConnectWallet.jsx：

import React from 'react';
import { useWallet } from '../hooks/useWallet';

function ConnectWallet() {
  const { account, isConnecting, error, connectWallet, disconnectWallet } = useWallet();

  const formatAddress = (addr) => {
    return `${addr.slice(0, 6)}...${addr.slice(-4)}`;
  };

  if (error) {
    return (
      <div className="wallet-error">
        <p>⚠️ {error}</p>
        <a href="https://metamask.io" target="_blank" rel="noopener noreferrer">
          下载 MetaMask
        </a>
      </div>
    );
  }

  if (account) {
    return (
      <div className="wallet-connected">
        <span className="wallet-address">
          🔗 {formatAddress(account)}
        </span>
        <button onClick={disconnectWallet} className="btn-disconnect">
          断开连接
        </button>
      </div>
    );
  }

  return (
    <button
      onClick={connectWallet}
      disabled={isConnecting}
      className="btn-connect"
    >
      {isConnecting ? '连接中...' : '🦊 连接 MetaMask'}
    </button>
  );
}

export default ConnectWallet;

五、读写合约数据

5.1 创建合约实例工具

创建 src/utils/contract.js：

import { Contract, parseUnits } from 'ethers';

// 合约 ABI（从编译产物中获取，这里展示关键部分）
const CONTRACT_ABI = [
  "function greeting() public view returns (string)",
  "function owner() public view returns (address)",
  "function createdAt() public view returns (uint256)",
  "function setGreeting(string memory _greeting) public",
  "function getGreeting() public view returns (string memory)",
  "function getContractInfo() public view returns (string memory, address, uint256)",
  "event GreetingChanged(address indexed changer, string newGreeting)"
];

// ⚠️ 替换为你实际部署的合约地址
const CONTRACT_ADDRESS = "0xYourContractAddressHere";

export function getContract(signerOrProvider) {
  return new Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signerOrProvider);
}

export { CONTRACT_ABI, CONTRACT_ADDRESS };

5.2 读取合约数据

import { useEffect, useState } from 'react';
import { getContract } from '../utils/contract';

function useContractData(provider) {
  const [greeting, setGreeting] = useState('');
  const [owner, setOwner] = useState('');
  const [loading, setLoading] = useState(true);

  const fetchData = async () => {
    if (!provider) return;
    try {
      setLoading(true);
      const contract = getContract(provider);

      // 读取数据（不需要 gas）
      const currentGreeting = await contract.getGreeting();
      const contractOwner = await contract.owner();

      setGreeting(currentGreeting);
      setOwner(contractOwner);
    } catch (err) {
      console.error('读取合约数据失败:', err);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    fetchData();
  }, [provider]);

  return { greeting, owner, loading, refresh: fetchData };
}

5.3 写入合约数据

import { useState } from 'react';
import { getContract } from '../utils/contract';

function useContractWrite(signer) {
  const [txPending, setTxPending] = useState(false);
  const [txHash, setTxHash] = useState('');

  const updateGreeting = async (newGreeting) => {
    if (!signer) {
      alert('请先连接钱包');
      return;
    }

    try {
      setTxPending(true);
      const contract = getContract(signer);

      // 发送交易（需要 gas）
      const tx = await contract.setGreeting(newGreeting);
      setTxHash(tx.hash);

      console.log('📤 交易已发送，等待确认...');

      // 等待交易被确认
      const receipt = await tx.wait();
      console.log('✅ 交易已确认！区块号:', receipt.blockNumber);

      return receipt;
    } catch (err) {
      console.error('写入合约失败:', err);
      throw err;
    } finally {
      setTxPending(false);
    }
  };

  return { updateGreeting, txPending, txHash };
}

5.4 监听合约事件

// 在 React 组件中监听实时事件
useEffect(() => {
  if (!provider) return;

  const contract = getContract(provider);

  // 监听 GreetingChanged 事件
  const onGreetingChanged = (changer, newGreeting, event) => {
    console.log(`📢 事件: ${changer} 更新了问候语为 "${newGreeting}"`);
    // 刷新数据
    fetchData();
  };

  contract.on("GreetingChanged", onGreetingChanged);

  // 清理监听器
  return () => {
    contract.off("GreetingChanged", onGreetingChanged);
  };
}, [provider]);

六、实战：构建一个完整的投票 DApp

让我们把所学的知识整合起来，构建一个完整的去中心化投票应用。

6.1 投票智能合约

创建 contracts/Voting.sol：

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

contract Voting {
    struct Proposal {
        string name;
        string description;
        uint256 voteCount;
        bool exists;
    }

    address public owner;
    string public title;
    bool public votingActive;

    mapping(uint256 => Proposal) public proposals;
    mapping(address => bool) public hasVoted;
    mapping(address => uint256) public voterChoice;

    uint256 public proposalCount;

    event ProposalCreated(uint256 indexed id, string name);
    event VoteCast(address indexed voter, uint256 indexed proposalId);
    event VotingStatusChanged(bool active);

    modifier onlyOwner() {
        require(msg.sender == owner, "只有管理员可以执行此操作");
        _;
    }

    constructor(string memory _title) {
        owner = msg.sender;
        title = _title;
        votingActive = true;
    }

    function createProposal(
        string memory _name,
        string memory _description
    ) public onlyOwner returns (uint256) {
        require(votingActive, "投票已结束");

        uint256 proposalId = proposalCount++;
        proposals[proposalId] = Proposal({
            name: _name,
            description: _description,
            voteCount: 0,
            exists: true
        });

        emit ProposalCreated(proposalId, _name);
        return proposalId;
    }

    function vote(uint256 _proposalId) public {
        require(votingActive, "投票已结束");
        require(!hasVoted[msg.sender], "你已经投过票了");
        require(proposals[_proposalId].exists, "提案不存在");

        hasVoted[msg.sender] = true;
        voterChoice[msg.sender] = _proposalId;
        proposals[_proposalId].voteCount++;

        emit VoteCast(msg.sender, _proposalId);
    }

    function getProposal(uint256 _proposalId) public view returns (
        string memory name,
        string memory description,
        uint256 voteCount
    ) {
        require(proposals[_proposalId].exists, "提案不存在");
        Proposal storage p = proposals[_proposalId];
        return (p.name, p.description, p.voteCount);
    }

    function toggleVoting() public onlyOwner {
        votingActive = !votingActive;
        emit VotingStatusChanged(votingActive);
    }

    function checkVoted(address _voter) public view returns (bool) {
        return hasVoted[_voter];
    }
}

6.2 投票 DApp 前端组件

创建 src/components/VotingDApp.jsx：

import React, { useState, useEffect } from 'react';
import { BrowserProvider, Contract } from 'ethers';

const VOTING_ABI = [
  "function title() view returns (string)",
  "function votingActive() view returns (bool)",
  "function proposalCount() view returns (uint256)",
  "function proposals(uint256) view returns (string, string, uint256, bool)",
  "function hasVoted(address) view returns (bool)",
  "function createProposal(string, string) returns (uint256)",
  "function vote(uint256)",
  "function toggleVoting()",
  "event VoteCast(address indexed voter, uint256 indexed proposalId)",
];

const CONTRACT_ADDRESS = "0xYourVotingContractAddress";

function VotingDApp() {
  const [proposals, setProposals] = useState([]);
  const [title, setTitle] = useState('');
  const [isActive, setIsActive] = useState(true);
  const [userVoted, setUserVoted] = useState(false);
  const [signer, setSigner] = useState(null);
  const [loading, setLoading] = useState(false);

  // 连接钱包
  const connect = async () => {
    const provider = new BrowserProvider(window.ethereum);
    const s = await provider.getSigner();
    setSigner(s);
    loadData(provider, s);
  };

  // 加载数据
  const loadData = async (provider, signer) => {
    const contract = new Contract(CONTRACT_ADDRESS, VOTING_ABI, provider);

    const t = await contract.title();
    const active = await contract.votingActive();
    const count = await contract.proposalCount();
    const voted = await contract.hasVoted(await signer.getAddress());

    setTitle(t);
    setIsActive(active);
    setUserVoted(voted);

    const loadedProposals = [];
    for (let i = 0; i < Number(count); i++) {
      const [name, desc, votes] = await contract.proposals(i);
      loadedProposals.push({
        id: i,
        name,
        description: desc,
        voteCount: Number(votes),
      });
    }
    setProposals(loadedProposals);
  };

  // 投票
  const castVote = async (proposalId) => {
    if (!signer) return alert('请先连接钱包');

    setLoading(true);
    try {
      const contract = new Contract(CONTRACT_ADDRESS, VOTING_ABI, signer);
      const tx = await contract.vote(proposalId);
      await tx.wait();
      alert('投票成功！🎉');

      const provider = new BrowserProvider(window.ethereum);
      loadData(provider, signer);
    } catch (err) {
      alert('投票失败: ' + err.message);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="voting-dapp">
      <h1>🗳️ {title || '去中心化投票系统'}</h1>

      {!signer ? (
        <button onClick={connect} className="btn-connect">
          🦊 连接钱包开始投票
        </button>
      ) : (
        <>
          <div className="status">
            <span className={`badge ${isActive ? 'active' : 'closed'}`}>
              {isActive ? '🟢 投票进行中' : '🔴 投票已结束'}
            </span>
            {userVoted && <span className="badge voted">✅ 你已投票</span>}
          </div>

          <div className="proposals">
            {proposals.map((p) => (
              <div key={p.id} className="proposal-card">
                <h3>{p.name}</h3>
                <p>{p.description}</p>
                <div className="vote-section">
                  <span className="vote-count">票数: {p.voteCount}</span>
                  <button
                    onClick={() => castVote(p.id)}
                    disabled={!isActive || userVoted || loading}
                    className="btn-vote"
                  >
                    {loading ? '处理中...' : '投票'}
                  </button>
                </div>
              </div>
            ))}
          </div>
        </>
      )}
    </div>
  );
}

export default VotingDApp;

七、安全最佳实践

智能合约一旦部署就无法修改，安全问题可能导致巨额资金损失。以下是必须遵守的安全准则：

7.1 常见安全漏洞

// ❌ 重入攻击漏洞
function withdraw() public {
    uint256 balance = balances[msg.sender];
    (bool success, ) = msg.sender.call{value: balance}("");  // 外部调用在更新状态之前
    require(success, "转账失败");
    balances[msg.sender] = 0;  // 状态更新在外部调用之后，有重入风险
}

// ✅ 使用 checks-effects-interactions 模式
function withdraw() public {
    uint256 balance = balances[msg.sender];
    require(balance > 0, "余额不足");
    balances[msg.sender] = 0;  // 先更新状态
    (bool success, ) = msg.sender.call{value: balance}("");  // 再进行外部调用
    require(success, "转账失败");
}

7.2 安全检查清单

使用 OpenZeppelin 合约库：经过审计的标准化实现
整数溢出保护：Solidity 0.8+ 默认开启
访问控制：使用 onlyOwner 等 modifier 限制敏感操作
输入验证：检查所有外部输入
重入保护：使用 ReentrancyGuard
事件日志：所有关键操作都应发出事件

# 安装 OpenZeppelin 合约库
npm install @openzeppelin/contracts

// 使用 OpenZeppelin 的 Ownable 和 ReentrancyGuard
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract SecureContract is Ownable, ReentrancyGuard {
    // 你的安全合约代码
    function safeWithdraw() external nonReentrancy onlyOwner {
        // 安全的提款逻辑
    }
}

7.3 测试的重要性

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

describe("Voting", function () {
  let voting, owner, voter1, voter2;

  beforeEach(async function () {
    [owner, voter1, voter2] = await ethers.getSigners();
    const Voting = await ethers.getContractFactory("Voting");
    voting = await Voting.deploy("测试投票");
    await voting.waitForDeployment();
  });

  it("应该成功创建提案", async function () {
    await voting.createProposal("提案一", "这是第一个提案");
    const [name, desc, votes] = await voting.getProposal(0);
    expect(name).to.equal("提案一");
    expect(votes).to.equal(0);
  });

  it("应该允许用户投票", async function () {
    await voting.createProposal("提案一", "描述");
    await voting.connect(voter1).vote(0);

    const [, , votes] = await voting.getProposal(0);
    expect(votes).to.equal(1);
  });

  it("不应该允许重复投票", async function () {
    await voting.createProposal("提案一", "描述");
    await voting.connect(voter1).vote(0);

    await expect(
      voting.connect(voter1).vote(0)
    ).to.be.revertedWith("你已经投过票了");
  });
});

八、进阶学习路线图

完成本文的学习后，你已经掌握了 Web3 开发的基础。以下是一条推荐的进阶路线：

初级阶段 ✅ （你在这里）

[x] Solidity 基础语法
[x] Hardhat 开发框架
[x] 合约部署与交互
[x] ethers.js 前端集成

中级阶段 📚

[ ] ERC-20 代币标准
[ ] ERC-721 NFT 标准
[ ] ERC-1155 多重代币标准
[ ] DeFi 协议原理（Uniswap、Aave）
[ ] The Graph 子图查询
[ ] IPFS / Arweave 去中心化存储

高级阶段 🚀

[ ] Solidity Assembly / Yul
[ ] 代理合约与升级模式
[ ] 跨链桥开发
[ ] Layer 2 方案（Optimism、Arbitrum、zkSync）
[ ] 形式化验证
[ ] MEV 和闪电贷

资源	类型	链接
CryptoZombies	交互式教程	cryptozombies.io
Solidity by Example	文档	solidity-by-example.org
Ethereum.org	官方文档	ethereum.org/developers
OpenZeppelin Docs	合约库	docs.openzeppelin.com
Ethernaut	安全挑战	ethernaut.openzeppelin.com
Speed Run Ethereum	实战挑战	speedrunethereum.com

工具推荐

开发框架：Hardhat、Foundry
前端库：ethers.js v6、wagmi、RainbowKit
测试工具：Hardhat Network、Tenderly
安全工具：Slither、Mythril、Aderyn
合约库：OpenZeppelin、Solmate

总结

恭喜你完成了这篇 Web3 开发入门指南！让我们回顾一下你学到的内容：

✅ 搭建了完整的 Web3 开发环境
✅ 编写了你的第一个 Solidity 智能合约
✅ 将合约部署到了 Sepolia 测试网
✅ 使用 ethers.js 连接了前端和区块链
✅ 构建了一个完整的投票 DApp
✅ 了解了智能合约的安全最佳实践

Web3 开发是一个快速发展的领域，新的工具和技术层出不穷。保持学习，多动手实践，加入开发者社区，你会发现自己进步飞速。

🚀 觉得有帮助吗？关注我获取更多 Web3 开发教程！点赞 + 收藏，让更多人看到这份指南。

有任何问题欢迎在评论区留言，我会逐一回复。让我们一起探索 Web3 的无限可能！

Midnight dApp 部署前安全检查清单：开发者完整指南

richard202605 — Wed, 13 May 2026 13:35:24 +0000

Midnight dApp 部署前安全检查清单：开发者指南

Midnight Network 通过零知识证明和可编程隐私控制，为 Web3 带来了隐私保护智能合约。但强大的隐私能力也意味着更高的安全要求。本清单帮助你在 dApp 上线前发现常见漏洞。

为什么需要这份清单

Midnight 的 Compact 语言默认保护隐私——所有数据都是私有的，除非你显式调用 disclose()。这意味着：

一个错误放置的 disclose() 可能永久泄露敏感数据
Witness 函数在 ZK 电路外运行，可以被操纵
ownPublicKey() 函数有一个已知漏洞，很多开发者忽略了
重放保护需要仔细实现 nonces 和 nullifiers

让我们系统地检查每个安全领域。

部署前检查清单

✅ 1. disclose() 审计——无秘密泄露

disclose() 是将私有数据移动到公开账本的唯一机制。代码中的每个 disclose() 调用都是一个有意识地公开某数据的决定。

需要检查的内容：

// ❌ 错误：过早公开会在后续操作中暴露值
export circuit store(flag: Boolean): [] {
  const secret = disclose(getSecret());  // 公开太早了！
  const derived = computeValue(secret);  // `secret` 现在可见了
  result = disclose(flag) ? derived : 0;
}

// ✅ 正确：仅在使用点公开
export circuit store(flag: Boolean): [] {
  const secret = getSecret();
  const derived = computeValue(secret);  // 仍然私有
  result = disclose(flag) ? disclose(derived) : 0;  // 具体、有针对性的公开
}

检查项：

[ ] 搜索代码库中的每个 disclose() 调用
[ ] 验证每次公开都是有意且最小化的
[ ] 确保 disclose() 尽可能靠近使用点
[ ] 检查没有代码路径意外公开应保持私有的值
[ ] 对必须保持私有的值使用下划线前缀（_sk、_secret）

专业提示： Compact 编译器会捕获将私有值赋给账本字段而没有 disclose() 的尝试，但不会捕获过早的公开。手动审查是必须的。

✅ 2. ownPublicKey() 使用审查（已知漏洞）

这是 Midnight 开发中最常见的安全错误之一。

⚠️ 警告：不要使用 ownPublicKey() 进行调用者验证！

ownPublicKey() 技术上是一个 witness 函数。这意味着每个用户的前端都可以产生恶意的返回值。攻击者可以修改本地 witness 实现来返回任意公钥。

// ❌ 严重漏洞：使用 ownPublicKey() 进行授权
export circuit transfer(to: Bytes<32>, amount: Uint<64>): [] {
  const sender = ownPublicKey();  // 攻击者可以返回任何密钥！
  assert(balances.member(sender), "No balance");
  // ... 使用伪造的发送者进行转账逻辑
}

// ✅ 正确：基于哈希的身份验证
witness secretKey(): Bytes<32>;

circuit publicKey(_sk: Bytes<32>): Bytes<32> {
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "midnight:auth:pk"),
    _sk
  ]);
}

export circuit authorizedOperation(newValue: Bytes<32>): [] {
  const _sk = secretKey();
  const pk = publicKey(_sk);
  assert(disclose(pk) == authority, "Authorization failed");
  ledgerValue = disclose(newValue);
}

检查项：

[ ] 搜索代码库中所有 ownPublicKey() 调用
[ ] 验证没有一个被用作唯一的授权机制
[ ] 将任何授权逻辑替换为基于哈希的模式
[ ] 如果必须使用 ownPublicKey()，添加额外的验证层

✅ 3. 重放保护验证（Nonces 和 Nullifiers）

Midnight 使用承诺/空值器模式（来自 Zerocash/Zswap）来防止双重花费，而不暴露哪个资源被花费。

空值器工作原理：

export ledger usedNullifiers: Set<Bytes<32>>;

circuit nullifier(secretKey: Bytes<32>): Bytes<32> {
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "nullifier-domain"),  // 域分隔符！
    secretKey
  ]);
}

export circuit spend(secretKey: Bytes<32>): [] {
  const nul = nullifier(secretKey);
  assert(!usedNullifiers.member(nul), "Already spent");
  usedNullifiers.insert(disclose(nul));
}

关键要求：

[ ] 域分隔符：承诺和空值器必须使用不同的域前缀，以防止哈希碰撞攻击
- 好的："nullifier-my-dapp-v1" vs "commitment-my-dapp-v1"
- 坏的：对两者使用相同的前缀
[ ] 不重用随机性：永远不要在承诺之间重用随机性——这会启用链接并破坏隐私
[ ] 使用 persistentHash：用于存储在账本状态中的值（保证升级后一致）
[ ] 回合计数器：为操作包含时间绑定计数器，防止旧证明的重放

✅ 4. 导出账本字段审查

每个 export ledger 字段在链上公开可见。审查每个字段：

export ledger balance: Counter;
export ledger authority: Bytes<32>;
export ledger usedNullifiers: Set<Bytes<32>>;

检查项：

[ ] 验证每个账本字段确实需要公开
[ ] 检查没有私有数据意外存储在账本字段中
[ ] 确保账本字段类型匹配其预期用途
[ ] 审查访问模式——谁可以读取和修改每个字段？

✅ 5. Witness 实现正确性

Witness 是链下 TypeScript 函数，在 ZK 电路外运行。它们不被加密验证。

// TypeScript 中的 Witness 实现
export const witnesses = {
  secretKey: ({ privateState }: WitnessContext<Ledger, PrivateState>) =>
    [privateState, privateState.secretKey],

  getUserBalance: ({ privateState }: WitnessContext<Ledger, PrivateState>) =>
    [privateState, privateState.balance],
};

安全影响：

每个用户提供自己的 witness 实现
攻击者可以从 witness 函数返回任何值
合约逻辑永远不能信任 witness 值而不验证

检查项：

[ ] 每个 witness 输出在电路中使用前都用 assert 验证
[ ] 没有关键逻辑仅依赖 witness 返回值
[ ] Witness 函数返回一致的 [PrivateState, ReturnValue] 元组
[ ] Witness 中没有可能在调用之间变化的外部依赖
[ ] 测试 witness 实现的多次调用一致性

✅ 6. 版本兼容性确认

Midnight 的工具链发展迅速。部署前：

检查项：

[ ] 验证 pragma language_version 与安装的 Compact 编译器匹配
[ ] 检查所有依赖（midnight-mcp、proof-server）版本兼容
[ ] 查看 Midnight 更新日志了解破坏性变更
[ ] 使用合约中指定的确切版本测试编译

✅ 7. 测试网上证明生成测试

在主网之前，验证你的证明生成管道端到端工作。

测试网层级：
| 层级 | 目的 | 代币 |
|------|------|------|
| 本地开发网 | 开发 | 无限 |
| 预览网 | 集成测试 | 测试 NIGHT |
| 预生产网 | 最终验证 | 预生产水龙头 |

检查项：

[ ] 部署合约到本地开发网并验证所有电路
[ ] 测试每个电路路径的证明生成
[ ] 验证 proof-server 处理并发请求
[ ] 测试边界情况：零值、最大值、空输入
[ ] 运行完整交易生命周期：部署→交互→验证状态
[ ] 在预生产网测试后再上主网

Proof 服务器验证：

# 检查 proof 服务器是否运行
curl http://localhost:6300/health

# 测试证明生成
compact prove --contract ./managed/my-contract \
  --circuit myCircuit \
  --inputs ./test-inputs.json

常见安全陷阱

陷阱 1：信任前端输入

永远不要信任来自前端的数据而不进行链上验证。用户控制他们的客户端。

陷阱 2：缺少域分隔

始终为不同的哈希操作使用唯一的域分隔符：

// 好：不同目的使用不同域
persistentHash<Vector<2, Bytes<32>>>([pad(32, "commitment-v1"), data])
persistentHash<Vector<2, Bytes<32>>>([pad(32, "nullifier-v1"), data])

陷阱 3：过早公开

将 disclose() 尽可能晚地放在计算链中。

陷阱 4：未验证的 Witness 数据

在电路逻辑中使用 witness 输出之前，始终进行 assert。

陷阱 5：忽略可链接性

当隐私重要时，使用回合计数器或其他机制打破交易可链接性。

安全模式快速参考

模式	用例	关键点
基于哈希的认证	调用者验证	不要单独使用 `ownPublicKey()`
承诺-公开	密封投标、拍卖	两阶段承诺
域分隔符	所有哈希操作	每个目的唯一前缀
回合计数器	打破可链接性	使旧密钥失效
延迟公开	所有 `disclose()` 调用	最小化暴露窗口

资源

总结

部署 Midnight dApp 前，验证：

✅ disclose() 审计——每次公开都是有意且最小化的
✅ ownPublicKey() 审查——没有依赖它进行授权
✅ 重放保护——正确的 nonces、nullifiers 和域分隔符
✅ 账本字段——没有意外公开私有数据
✅ Witness 验证——所有 witness 输出在使用前都经过断言
✅ 版本兼容性——编译器和依赖对齐
✅ 测试网验证——完整的证明生成管道已测试

隐私保护 dApp 功能强大，但需要额外的细致工作。每次部署前运行此清单，你的用户数据将保持安全。

📌 免责声明： 本指南仅供教育目的。请随时关注最新的 Midnight Network 文档和安全公告。安全领域变化迅速。

觉得有帮助？关注更多 Web3 安全内容。有问题？在下方评论。

Web3 钱包安全审计指南：如何用公开数据检测你的钱包风险

richard202605 — Wed, 13 May 2026 13:34:11 +0000

Web3 钱包安全审计指南：如何用公开数据检测你的钱包风险

在 Web3 世界里，你的钱包就是你的银行账户、身份证和保险箱。一旦被攻破，资产可能在几秒内消失殆尽。好消息是：你完全可以用公开数据和免费工具，对自己的钱包进行一次全面的安全体检。

1. 为什么需要钱包安全审计

在 DeFi 和 NFT 的世界里，用户每天都在与智能合约交互——授权代币、铸造 NFT、提供流动性。每一次交互都可能留下潜在的安全隐患。根据 Chainalysis 的报告，2024 年因钱包被盗和诈骗造成的损失超过 30 亿美元。

你可能已经处于风险中，却浑然不知：

你曾在某个 DEX 上授权了"无限额度"的代币授权，但早已不再使用该平台
你签署过一条恶意签名消息，攻击者获得了你的 off-chain 权限
你的钱包收到过来源不明的"空投"代币，可能是钓鱼陷阱
你曾连接钱包到钓鱼网站，并批准了一笔恶意交易

钱包安全审计不是"可选项"，而是"必修课"。 就像你会定期体检一样，你的 Web3 钱包也需要定期检查。区块链是公开透明的——所有交易、授权和合约交互都记录在链上，任何人都可以查看。

2. 常见的链上风险类型

2.1 钓鱼攻击（Phishing）

攻击者创建与知名项目外观相似的虚假网站，诱导用户连接钱包并签署恶意交易。典型特征：域名有细微差别（如 uniswwap.org）、承诺"免费领取"或"限时空投"、要求签署看不懂的消息。

2.2 恶意合约（Malicious Contracts）

攻击者部署看似合法的智能合约，实则内置窃取资产的后门。典型特征：合约未经审计、创建者地址没有历史交易、合约代码不可验证。

2.3 无限授权（Unlimited Approvals）

在 DEX 上交易代币时，你需要授权合约使用你的代币。很多用户选择"无限授权"以避免重复操作，但这意味着该合约可以在任何时候转走你的全部代币。如果该合约后来被发现有漏洞或被攻击者利用，你的资产将面临直接风险。

2.4 粉尘攻击（Dust Attack）

攻击者向大量地址发送极小数量的代币（"粉尘"），然后观察这些代币被如何使用，以分析钱包持有者的身份和行为模式。典型特征：钱包中突然出现不知名代币、代币名称模仿知名项目、尝试出售可能触发恶意授权。

3. 如何用公开工具检查钱包

3.1 Etherscan / 区块浏览器

Etherscan 是以太坊上最权威的区块浏览器。使用步骤：

访问 https://etherscan.io/tokenapprovalchecker
输入你的钱包地址
查看所有活跃的授权
重点关注"无限制"（Unlimited）的授权

3.2 Revoke.cash

Revoke.cash 专门用于管理代币授权，支持多条链。访问网站 → 连接钱包或输入地址 → 查看所有链上的授权列表 → 对可疑授权执行"撤销"操作。

3.3 其他有用工具

De.Fi Scanner： 综合安全扫描，检测与已知恶意合约的交互
ScamSniffer： 专门检测钓鱼攻击
各链区块浏览器： BscScan、PolygonScan、Arbiscan、Solscan 等

4. 手动审计步骤

建议每 1-3 个月执行一次以下流程：

步骤一：检查代币授权

这是最关键的一步。以下是用 ethers.js 查询授权的示例：

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://eth.llamarpc.com");
const APPROVE_TOPIC = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";

async function checkApprovals(walletAddress) {
  const logs = await provider.getLogs({
    topics: [APPROVE_TOPIC, ethers.zeroPadValue(walletAddress, 32)],
    fromBlock: 0, toBlock: "latest"
  });

  for (const log of logs) {
    const spender = ethers.getAddress("0x" + log.topics[2].slice(26));
    const value = BigInt(log.data);
    console.log(`代币: ${log.address} → 授权给: ${spender}`);
    console.log(`额度: ${value === ethers.MaxUint256 ? "⚠️ 无限授权!" : value.toString()}`);
  }
}

checkApprovals("0xYourWalletAddress");

步骤二：审查交易历史

使用 Etherscan API 查询与合约交互的交易：

const address = "0xYourWalletAddress";
const apiKey = "YOUR_ETHERSCAN_API_KEY";

const url = `https://api.etherscan.io/api?module=account&action=tokentx&address=${address}&startblock=0&endblock=99999999&sort=desc&apikey=${apiKey}`;
const data = await fetch(url).then(r => r.json());

// 检查 setApprovalForAll (ERC-721/1155 无限授权)
const risky = data.result.filter(tx => tx.input?.startsWith("0xa22cb465"));
if (risky.length > 0) console.log("⚠️ 发现 ERC-721/1155 无限授权调用:", risky.length, "次");

步骤三：检查未知代币

在区块浏览器上查看代币列表，识别不熟悉的代币。不要尝试出售或转移这些代币，也不要访问代币附带的链接。

步骤四：验证合约

对频繁交互的合约，检查：合约代码是否已验证、创建者是否可信、是否有安全审计报告。

5. 自动化审计工具介绍

手动审计虽然有效，但自动化工具可以大幅提升效率。

5.1 开源/免费工具

工具	用途
Revoke.cash	授权管理和撤销
De.Fi Scanner	综合安全扫描
ScamSniffer	钓鱼检测

5.2 AI 驱动的安全工具

近年来，AI 技术在钱包安全领域应用越来越广泛：

交易意图解析： 分析交易的 calldata，用自然语言告诉你这笔交易会做什么
异常行为检测： 基于机器学习识别偏离正常行为模式的可疑交易
智能合约风险评分： 自动识别合约代码中的常见安全漏洞
实时预警： 连接到已知钓鱼网站时弹出警告

5.3 自建监控脚本

import { ethers } from "ethers";

const provider = new ethers.WebSocketProvider("wss://eth.llamarpc.com");
const walletAddress = "0xYourWalletAddress";
const APPROVE_TOPIC = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";

provider.on({
  topics: [APPROVE_TOPIC, ethers.zeroPadValue(walletAddress, 32)]
}, (log) => {
  const spender = ethers.getAddress("0x" + log.topics[2].slice(26));
  console.log("🚨 检测到新的代币授权!");
  console.log(`代币: ${log.address} → 授权给: ${spender}`);
  console.log(`交易: ${log.transactionHash}`);
  // 可添加邮件/Telegram 通知
});

6. 安全最佳实践

6.1 使用硬件钱包

这是最重要的安全措施。 Ledger 或 Trezor 等硬件钱包将私钥存储在离线设备中，即使电脑被入侵也无法直接获取私钥。

6.2 分离钱包功能

钱包类型	用途	资金量
冷钱包（硬件）	长期存储	主要资金
热钱包 A	日常 DeFi	中等资金
热钱包 B	测试新项目	少量资金

6.3 定期授权审计

每两周检查一次代币授权，对不再使用的 DApp 执行撤销，使用 Revoke.cash 浏览器扩展实时提醒。

6.4 签名安全

不要签署看不懂的消息
警惕 eth_sign 类型的签名请求
优先使用 EIP-712 结构化签名

6.5 社交工程防护

不要相信主动联系你的"客服"
不要点击 Discord/Telegram 私信链接
绝不要将助记词或私钥输入任何网站

7. 什么时候应该寻求专业审计

以下情况建议寻求专业安全服务：

资产规模较大： 管理超过 10 万美元的资产时，自行审计可能存在盲点
曾与可疑合约交互： 需要专业团队追踪资产流向并评估风险
项目方开发： DeFi 协议或 NFT 项目的智能合约审计是必须的（推荐 CertiK、SlowMist、PeckShield 等）
遭受攻击后： 立即转移剩余资产 → 撤销所有授权 → 联系安全团队追踪 → 向执法机构报案

总结

[ ] 📋 今天就做： 用 Revoke.cash 检查所有代币授权
[ ] 🔍 本周做： 在 Etherscan 上审查交易历史
[ ] 🛡️ 本月做： 设置硬件钱包，分离钱包功能
[ ] 🔄 长期做： 建立每两周一次的安全检查习惯

🔐 需要专业帮助？

如果你管理的资产规模较大，或发现钱包存在可疑活动，建议寻求专业的安全审计服务。

我们提供专业的 Web3 钱包安全审计服务，包括：

🔎 钱包历史交易深度分析
🛡️ 代币授权风险评估与清理建议
🤖 AI 驱动的智能合约交互风险检测
📊 个性化安全加固方案
🚨 资产被盗应急响应与链上追踪

立即联系我们，为你的 Web3 资产保驾护航。 早期发现风险，远比事后追回资产容易得多。

📌 免责声明： 本文仅供教育和参考目的。区块链安全领域变化迅速，请保持警惕并持续学习最新的安全实践。

Security Checklist for Midnight dApps Before Deployment: A Developer's Guide

richard202605 — Wed, 13 May 2026 13:28:59 +0000

Security Checklist for Midnight dApps Before Deployment

Midnight Network brings privacy-preserving smart contracts to Web3 through zero-knowledge proofs and programmable confidentiality. But with great privacy power comes great security responsibility. This checklist will help you catch common vulnerabilities before your dApp goes live.

Why This Checklist Matters

Midnight's Compact language enforces privacy by default — all data stays private unless you explicitly disclose() it. This is powerful, but it also means:

One misplaced disclose() can leak sensitive data permanently
Witness functions run outside ZK circuits and can be manipulated
The ownPublicKey() function has a known vulnerability that many developers miss
Replay protection requires careful implementation of nonces and nullifiers

Let's walk through each security area systematically.

Pre-Deployment Checklist

✅ 1. disclose() Audit — No Secret Leaks

disclose() is the only mechanism for moving private data to the public ledger. Every disclose() call in your code is a conscious decision to make something public.

What to check:

// ❌ BAD: Early disclosure exposes the value for all subsequent operations
export circuit store(flag: Boolean): [] {
  const secret = disclose(getSecret());  // Public too early!
  const derived = computeValue(secret);  // `secret` is now visible
  result = disclose(flag) ? derived : 0;
}

// ✅ GOOD: Disclose only at the point of use
export circuit store(flag: Boolean): [] {
  const secret = getSecret();
  const derived = computeValue(secret);  // Still private
  result = disclose(flag) ? disclose(derived) : 0;  // Specific, targeted disclosure
}

Checklist:

[ ] Search your codebase for every disclose() call
[ ] Verify each disclosure is intentional and minimal
[ ] Ensure disclose() is positioned as close to the usage point as possible
[ ] Check that no code path accidentally discloses values that should remain private
[ ] Use underscore prefixes (_sk, _secret) for values that must never be disclosed

Pro tip: The Compact compiler will catch attempts to assign private values to ledger fields without disclose(), but it won't catch premature disclosures. Manual review is essential.

✅ 2. ownPublicKey() Usage Review (Known Vulnerability)

This is one of the most common security mistakes in Midnight development.

⚠️ WARNING: Do NOT use ownPublicKey() for caller verification!

ownPublicKey() is technically a witness function. This means each user's frontend can produce a malicious return value. An attacker can modify their local witness implementation to return any public key they choose.

// ❌ CRITICAL VULNERABILITY: Using ownPublicKey() for authorization
export circuit transfer(to: Bytes<32>, amount: Uint<64>): [] {
  const sender = ownPublicKey();  // Attacker can return ANY key!
  assert(balances.member(sender), "No balance");
  // ... transfer logic using spoofed sender
}

// ✅ CORRECT: Hash-based authentication
witness secretKey(): Bytes<32>;

circuit publicKey(_sk: Bytes<32>): Bytes<32> {
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "midnight:auth:pk"),
    _sk
  ]);
}

export circuit authorizedOperation(newValue: Bytes<32>): [] {
  const _sk = secretKey();
  const pk = publicKey(_sk);
  assert(disclose(pk) == authority, "Authorization failed");
  ledgerValue = disclose(newValue);
}

Checklist:

[ ] Search for all ownPublicKey() calls in your codebase
[ ] Verify none are used as the sole authorization mechanism
[ ] Replace any authorization logic with hash-based patterns
[ ] If you must use ownPublicKey(), add additional verification layers

✅ 3. Replay Protection Verification (Nonces and Nullifiers)

Midnight uses the commitment/nullifier pattern (from Zerocash/Zswap) to prevent double-spending without revealing which resource was spent.

How nullifiers work:

export ledger usedNullifiers: Set<Bytes<32>>;

circuit nullifier(secretKey: Bytes<32>): Bytes<32> {
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "nullifier-domain"),  // Domain separator!
    secretKey
  ]);
}

export circuit spend(secretKey: Bytes<32>): [] {
  const nul = nullifier(secretKey);
  assert(!usedNullifiers.member(nul), "Already spent");
  usedNullifiers.insert(disclose(nul));
}

Critical requirements:

[ ] Domain separators: Commitments and nullifiers MUST use different domain prefixes to prevent hash collision attacks
- Good: "nullifier-my-dapp-v1" vs "commitment-my-dapp-v1"
- Bad: Using the same prefix for both
[ ] No randomness reuse: Never reuse randomness across commitments — this enables linking and breaks privacy
[ ] Use persistentHash: For values stored in ledger state (guaranteed consistent across upgrades)
[ ] Round counters: Include time-bound counters for operations to prevent replay of old proofs

✅ 4. Exported Ledger Field Review

Every export ledger field is publicly visible on-chain. Review each one:

export ledger balance: Counter;
export ledger authority: Bytes<32>;
export ledger usedNullifiers: Set<Bytes<32>>;

Checklist:

[ ] Verify each ledger field genuinely needs to be public
[ ] Check that no private data is accidentally stored in ledger fields
[ ] Ensure ledger field types match their intended use (Counter vs Uint, etc.)
[ ] Review access patterns — who can read and modify each field?

✅ 5. Witness Implementation Correctness

Witnesses are off-chain TypeScript functions that run outside the ZK circuit. They are NOT cryptographically verified.

// Witness implementation in TypeScript
export const witnesses = {
  secretKey: ({ privateState }: WitnessContext<Ledger, PrivateState>) =>
    [privateState, privateState.secretKey],

  getUserBalance: ({ privateState }: WitnessContext<Ledger, PrivateState>) =>
    [privateState, privateState.balance],
};

Security implications:

Each user provides their own witness implementation
An attacker can return any value from a witness function
Contract logic must never trust witness values without validation

Checklist:

[ ] Every witness output is validated with assert before use in circuits
[ ] No critical logic depends solely on witness return values
[ ] Witness functions return consistent [PrivateState, ReturnValue] tuples
[ ] No external dependencies in witnesses that might change between invocations
[ ] Test witness implementations for consistency across multiple calls

✅ 6. Version Compatibility Confirmation

Midnight's toolchain evolves rapidly. Before deployment:

Checklist:

[ ] Verify pragma language_version matches your installed Compact compiler
[ ] Check that all dependencies (midnight-mcp, proof-server) are compatible versions
[ ] Review the Midnight changelog for breaking changes
[ ] Test compilation with the exact version specified in your contract

✅ 7. Proof Generation Testing on Testnet

Before mainnet, verify your proof generation pipeline works end-to-end.

Testnet tiers:
| Tier | Purpose | Tokens |
|------|---------|--------|
| Local Devnet | Development | Unlimited |
| Preview | Integration testing | Test NIGHT |
| Preprod | Final validation | Preprod faucet |

Checklist:

[ ] Deploy contract to Local Devnet and verify all circuits
[ ] Test proof generation for every circuit path
[ ] Verify proof-server handles concurrent requests
[ ] Test edge cases: zero values, maximum values, empty inputs
[ ] Run the full transaction lifecycle: deploy → interact → verify state
[ ] Test on Preprod before mainnet deployment

Proof server verification:

# Check proof server is running
curl http://localhost:6300/health

# Test proof generation
compact prove --contract ./managed/my-contract \
  --circuit myCircuit \
  --inputs ./test-inputs.json

Common Security Pitfalls

Pitfall 1: Trusting Frontend Input

Never trust data from the frontend without on-chain verification. The user controls their client.

Pitfall 2: Missing Domain Separation

Always use unique domain separators for different hash operations:

// Good: Different domains for different purposes
persistentHash<Vector<2, Bytes<32>>>([pad(32, "commitment-v1"), data])
persistentHash<Vector<2, Bytes<32>>>([pad(32, "nullifier-v1"), data])

Pitfall 3: Premature Disclosure

Position disclose() as late as possible in the computation chain.

Pitfall 4: Unvalidated Witness Data

Always assert witness outputs before using them in circuit logic.

Pitfall 5: Ignoring Linkability

Use round counters or other mechanisms to break transaction linkability when privacy matters.

Quick Reference: Security Patterns

Pattern	Use Case	Key Point
Hash-based auth	Caller verification	Don't use `ownPublicKey()` alone
Commit-reveal	Sealed bids, auctions	Two-phase commitment
Domain separators	All hash operations	Unique prefixes per purpose
Round counters	Breaking linkability	Invalidate old keys
Late disclosure	All `disclose()` calls	Minimize exposure window

Resources

Summary

Before deploying your Midnight dApp, verify:

✅ disclose() audit — Every disclosure is intentional and minimal
✅ ownPublicKey() review — No reliance on this for authorization
✅ Replay protection — Proper nonces, nullifiers, and domain separators
✅ Ledger fields — No accidental public exposure of private data
✅ Witness validation — All witness outputs are asserted before use
✅ Version compatibility — Compiler and dependencies aligned
✅ Testnet verification — Full proof generation pipeline tested

Privacy-preserving dApps are powerful, but they require extra diligence. Run this checklist before every deployment, and your users' data will stay safe.

📌 Disclaimer: This guide is for educational purposes. Always stay updated with the latest Midnight Network documentation and security advisories. The security landscape evolves rapidly.

Found this helpful? Follow for more Web3 security content. Questions? Drop a comment below.

Web3 Wallet Security Audit Guide: How to Detect Risk Using Public Data

richard202605 — Wed, 13 May 2026 13:21:42 +0000

Web3 钱包安全审计指南：如何用公开数据检测你的钱包风险

在 Web3 世界里，你的钱包就是你的银行账户、身份证和保险箱。一旦被攻破，资产可能在几秒内消失殆尽。好消息是：你完全可以用公开数据和免费工具，对自己的钱包进行一次全面的安全体检。

1. 为什么需要钱包安全审计

你可能已经处于风险中，却浑然不知：

你曾在某个 DEX 上授权了"无限额度"的代币授权，但早已不再使用该平台
你签署过一条恶意签名消息，攻击者获得了你的 off-chain 权限
你的钱包收到过来源不明的"空投"代币，可能是钓鱼陷阱
你曾连接钱包到钓鱼网站，并批准了一笔恶意交易

2. 常见的链上风险类型

2.1 钓鱼攻击（Phishing）

2.2 恶意合约（Malicious Contracts）

攻击者部署看似合法的智能合约，实则内置窃取资产的后门。典型特征：合约未经审计、创建者地址没有历史交易、合约代码不可验证。

2.3 无限授权（Unlimited Approvals）

2.4 粉尘攻击（Dust Attack）

3. 如何用公开工具检查钱包

3.1 Etherscan / 区块浏览器

Etherscan 是以太坊上最权威的区块浏览器。使用步骤：

访问 https://etherscan.io/tokenapprovalchecker
输入你的钱包地址
查看所有活跃的授权
重点关注"无限制"（Unlimited）的授权

3.2 Revoke.cash

Revoke.cash 专门用于管理代币授权，支持多条链。访问网站 → 连接钱包或输入地址 → 查看所有链上的授权列表 → 对可疑授权执行"撤销"操作。

3.3 其他有用工具

De.Fi Scanner： 综合安全扫描，检测与已知恶意合约的交互
ScamSniffer： 专门检测钓鱼攻击
各链区块浏览器： BscScan、PolygonScan、Arbiscan、Solscan 等

4. 手动审计步骤

建议每 1-3 个月执行一次以下流程：

步骤一：检查代币授权

这是最关键的一步。以下是用 ethers.js 查询授权的示例：

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://eth.llamarpc.com");
const APPROVE_TOPIC = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";

async function checkApprovals(walletAddress) {
  const logs = await provider.getLogs({
    topics: [APPROVE_TOPIC, ethers.zeroPadValue(walletAddress, 32)],
    fromBlock: 0, toBlock: "latest"
  });

  for (const log of logs) {
    const spender = ethers.getAddress("0x" + log.topics[2].slice(26));
    const value = BigInt(log.data);
    console.log(`代币: ${log.address} → 授权给: ${spender}`);
    console.log(`额度: ${value === ethers.MaxUint256 ? "⚠️ 无限授权!" : value.toString()}`);
  }
}

checkApprovals("0xYourWalletAddress");

步骤二：审查交易历史

使用 Etherscan API 查询与合约交互的交易：

const address = "0xYourWalletAddress";
const apiKey = "YOUR_ETHERSCAN_API_KEY";

const url = `https://api.etherscan.io/api?module=account&action=tokentx&address=${address}&startblock=0&endblock=99999999&sort=desc&apikey=${apiKey}`;
const data = await fetch(url).then(r => r.json());

// 检查 setApprovalForAll (ERC-721/1155 无限授权)
const risky = data.result.filter(tx => tx.input?.startsWith("0xa22cb465"));
if (risky.length > 0) console.log("⚠️ 发现 ERC-721/1155 无限授权调用:", risky.length, "次");

步骤三：检查未知代币

在区块浏览器上查看代币列表，识别不熟悉的代币。不要尝试出售或转移这些代币，也不要访问代币附带的链接。

步骤四：验证合约

对频繁交互的合约，检查：合约代码是否已验证、创建者是否可信、是否有安全审计报告。

5. 自动化审计工具介绍

手动审计虽然有效，但自动化工具可以大幅提升效率。

5.1 开源/免费工具

工具	用途
Revoke.cash	授权管理和撤销
De.Fi Scanner	综合安全扫描
ScamSniffer	钓鱼检测

5.2 AI 驱动的安全工具

近年来，AI 技术在钱包安全领域应用越来越广泛：

交易意图解析： 分析交易的 calldata，用自然语言告诉你这笔交易会做什么
异常行为检测： 基于机器学习识别偏离正常行为模式的可疑交易
智能合约风险评分： 自动识别合约代码中的常见安全漏洞
实时预警： 连接到已知钓鱼网站时弹出警告

5.3 自建监控脚本

import { ethers } from "ethers";

const provider = new ethers.WebSocketProvider("wss://eth.llamarpc.com");
const walletAddress = "0xYourWalletAddress";
const APPROVE_TOPIC = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";

provider.on({
  topics: [APPROVE_TOPIC, ethers.zeroPadValue(walletAddress, 32)]
}, (log) => {
  const spender = ethers.getAddress("0x" + log.topics[2].slice(26));
  console.log("🚨 检测到新的代币授权!");
  console.log(`代币: ${log.address} → 授权给: ${spender}`);
  console.log(`交易: ${log.transactionHash}`);
  // 可添加邮件/Telegram 通知
});

6. 安全最佳实践

6.1 使用硬件钱包

这是最重要的安全措施。 Ledger 或 Trezor 等硬件钱包将私钥存储在离线设备中，即使电脑被入侵也无法直接获取私钥。

6.2 分离钱包功能

钱包类型	用途	资金量
冷钱包（硬件）	长期存储	主要资金
热钱包 A	日常 DeFi	中等资金
热钱包 B	测试新项目	少量资金

6.3 定期授权审计

每两周检查一次代币授权，对不再使用的 DApp 执行撤销，使用 Revoke.cash 浏览器扩展实时提醒。

6.4 签名安全

不要签署看不懂的消息
警惕 eth_sign 类型的签名请求
优先使用 EIP-712 结构化签名

6.5 社交工程防护

不要相信主动联系你的"客服"
不要点击 Discord/Telegram 私信链接
绝不要将助记词或私钥输入任何网站

7. 什么时候应该寻求专业审计

以下情况建议寻求专业安全服务：

资产规模较大： 管理超过 10 万美元的资产时，自行审计可能存在盲点
曾与可疑合约交互： 需要专业团队追踪资产流向并评估风险
项目方开发： DeFi 协议或 NFT 项目的智能合约审计是必须的（推荐 CertiK、SlowMist、PeckShield 等）
遭受攻击后： 立即转移剩余资产 → 撤销所有授权 → 联系安全团队追踪 → 向执法机构报案

总结

[ ] 📋 今天就做： 用 Revoke.cash 检查所有代币授权
[ ] 🔍 本周做： 在 Etherscan 上审查交易历史
[ ] 🛡️ 本月做： 设置硬件钱包，分离钱包功能
[ ] 🔄 长期做： 建立每两周一次的安全检查习惯

🔐 需要专业帮助？

如果你管理的资产规模较大，或发现钱包存在可疑活动，建议寻求专业的安全审计服务。

我们提供专业的 Web3 钱包安全审计服务，包括：

🔎 钱包历史交易深度分析
🛡️ 代币授权风险评估与清理建议
🤖 AI 驱动的智能合约交互风险检测
📊 个性化安全加固方案
🚨 资产被盗应急响应与链上追踪

立即联系我们，为你的 Web3 资产保驾护航。 早期发现风险，远比事后追回资产容易得多。

📌 免责声明： 本文仅供教育和参考目的。区块链安全领域变化迅速，请保持警惕并持续学习最新的安全实践。

DEV Community: richard202605

Web3 开发者入门完全指南：从零构建你的第一个 DApp

Web3 开发者入门完全指南：从零构建你的第一个 DApp

为什么学 Web3 开发？

1. 开发环境搭建

1.1 安装 Node.js

1.2 安装开发框架

1.3 安装 MetaMask

2. Solidity 基础

2.1 Hello World 合约

2.2 核心概念

2.3 数据类型

3. 编写第一个完整合约

4. 编写测试

5. 部署到测试网

5.1 配置 Sepolia 网络

5.2 编写部署脚本

5.3 执行部署

6. 前端连接钱包

6.1 安装 ethers.js

6.2 连接 MetaMask

6.3 与合约交互

7. 安全最佳实践

7.1 常见漏洞

7.2 安全检查清单

8. 进阶学习路线

总结

Web3 开发者入门完全指南：从零开始构建你的第一个 DApp

Web3 开发者入门完全指南：从零开始构建你的第一个 DApp

一、Web3 开发环境搭建

1.1 安装 Node.js

1.2 安装 Hardhat（推荐）

1.3 可选：安装 Foundry

1.4 安装 VS Code 插件

二、Solidity 基础语法：Hello World 合约

2.1 第一个智能合约

2.2 Solidity 核心概念速览

2.3 编译合约

三、部署到测试网（Sepolia）

3.1 获取测试 ETH

3.2 配置 Hardhat 网络

3.3 编写部署脚本

3.4 执行部署

3.5 在 Etherscan 上验证合约

四、前端连接钱包（ethers.js）

4.1 创建 React 项目

4.2 连接 MetaMask 钱包

4.3 创建钱包连接组件

五、读写合约数据

5.1 创建合约实例工具

5.2 读取合约数据

5.3 写入合约数据

5.4 监听合约事件

六、实战：构建一个完整的投票 DApp

6.1 投票智能合约

6.2 投票 DApp 前端组件

七、安全最佳实践

7.1 常见安全漏洞

7.2 安全检查清单

7.3 测试的重要性

八、进阶学习路线图

初级阶段 ✅ （你在这里）

中级阶段 📚

高级阶段 🚀

推荐学习资源

工具推荐

总结

Midnight dApp 部署前安全检查清单：开发者完整指南

Midnight dApp 部署前安全检查清单：开发者指南

为什么需要这份清单

部署前检查清单

✅ 1. disclose() 审计——无秘密泄露

✅ 2. ownPublicKey() 使用审查（已知漏洞）

✅ 3. 重放保护验证（Nonces 和 Nullifiers）

✅ 4. 导出账本字段审查

✅ 5. Witness 实现正确性

✅ 6. 版本兼容性确认

✅ 7. 测试网上证明生成测试

常见安全陷阱

陷阱 1：信任前端输入