MonkeyCode区块链应用案例：智能合约与去中心化开发实践

MonkeyCode区块链应用案例：智能合约与去中心化开发实践

前言

区块链技术正在从加密货币的单一场景，扩展到去中心化金融(DeFi)、供应链溯源、数字身份、NFT创作等广阔领域。智能合约开发涉及Solidity/Rust等专用语言、密码学原语、Gas优化和安全性审计等复杂知识。MonkeyCode作为AI编程助手，为区块链开发者提供了从智能合约编写到DApp前端构建的全栈支持。本文将通过多个实战案例展示MonkeyCode在区块链开发中的强大能力。

---

一、区块链开发生态全景

1.1 技术栈分层

┌─────────────────────────────────────────────────────────────────┐
│                  MonkeyCode 区块链开发全景                         │
├──────────┬──────────┬──────────────┬──────────┬─────────────────┤
│  智能合约   │ DApp前端   │ 后端服务     │ 基础设施    │ 安全审计          │
├──────────┼──────────┼──────────────┼──────────┼─────────────────┤
│ Solidity  │ Ethers.js │ Node.js索引器│ 节点部署   │ 静态分析(Slither) │
│ Rust(Sol) │ Web3.js  │ The Graph    │ 测试网     │ 形式化验证        │
│ Vyper     │ Wagmi    │ IPFS/Pinata  │ 钱包集成   │ 模糊测试         │
│ Move      │ RainbowKit│ Chainlink预言机│ RPC节点   │ 重入/溢出检测     │
│ Cairo     │ Next.js  │ Event监听    │ 多签钱包   │ Gas优化审计       │
└──────────┴──────────┴──────────────┴──────────┴─────────────────┘

1.2 主流区块链平台对比

平台	合约语言	TPS	共识机制	适用场景	学习曲线
Ethereum	Solidity/Vyper	~15-30	PoS	DeFi/NFT/DAO	⭐⭐⭐⭐
Polygon	Solidity (EVM兼容)	~2000+	PoS	高频DApp	⭐⭐⭐
Solana	Rust	~65,000+	PoH	高性能DeFi	⭐⭐⭐⭐⭐
Aptos/Sui	Move	~100,000+	PoS	安全优先应用	⭐⭐⭐⭐
StarkNet	Cairo (STARK)	~500+	ZK-Rollup	隐私保护	⭐⭐⭐⭐⭐

---

二、实战案例一：ERC20代币合约

2.1 完整的ERC20代币实现

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

/// @title MonkeyToken - MonkeyCode生成的完整ERC20代币
/// @notice 包含标准ERC20 + 扩展功能: 代币销毁 + 暂停机制 + 白名单
/// @dev 符合OpenZeppelin最佳实践
contract MonkeyToken {
    // ──── 状态变量 ────
    
    string public constant NAME = "MonkeyCode Token";
    string public constant SYMBOL = "MKT";
    uint8 public constant DECIMALS = 18;
    uint256 public constant TOTAL_SUPPLY = 1_000_000_000 * 10**DECIMALS;
    
    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    
    // ──── 扩展功能状态 ────
    
    address public owner;
    bool public paused = false;
    mapping(address => bool) public isBlacklisted;
    mapping(address => bool) public whitelistMinters;
    uint256 public maxTxAmount = TOTAL_SUPPLY / 100; // 单笔最大1%
    
    // ──── 事件定义 ────
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Paused(address account);
    event Unpaused(address account);
    event Blacklisted(address account);
    event Unblacklisted(address account);
    event Minted(address to, uint256 amount);
    event Burned(address from, uint256 amount);
    
    // ──── 修饰符 ────
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }
    
    modifier whenNotPaused() {
        require(!paused, "Contract paused");
        _;
    }
    
    modifier notBlacklisted(address account) {
        require(!isBlacklisted[account], "Account blacklisted");
        _;
    }
    
    // ──── 构造函数 ────
    
    constructor() {
        owner = msg.sender;
        _totalSupply = TOTAL_SUPPLY;
        _balances[msg.sender] = TOTAL_SUPPLY;
        emit Transfer(address(0), msg.sender, TOTAL_SUPPLY);
        
        // 初始白名单铸造者
        whitelistMinters[msg.sender] = true;
    }
    
    // ──── ERC20 标准接口 ────
    
    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }
    
    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }
    
    function allowance(address _owner, address spender) external view returns (uint256) {
        return _allowances[_owner][spender];
    }
    
    /// @notice 转账 - 含黑名单检查和交易限额
    function transfer(address to, uint256 amount)
        external
        whenNotPaused
        notBlacklisted(msg.sender)
        notBlacklisted(to)
        returns (bool)
    {
        require(to != address(0), "Transfer to zero");
        require(amount <= maxTxAmount || whitelistMinters[msg.sender], "Exceeds max tx");
        
        _transfer(msg.sender, to, amount);
        return true;
    }
    
    /// @notice 授权转账
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) returns (bool) {
        address spender = msg.sender;
        uint256 currentAllowance = _allowances[from][spender];
        require(currentAllowance >= amount, "Insufficient allowance");
        
        unchecked { _allowances[from][spender] = currentAllowance - amount; }
        _transfer(from, to, amount);
        return true;
    }
    
    /// @notice 授权额度
    function approve(address spender, uint256 amount)
        external
        whenNotPaused
        notBlacklisted(spender)
        returns (bool)
    {
        require(spender != address(0), "Approve to zero");
        _approve(msg.sender, spender, amount);
        return true;
    }
    
    /// @notice 增加授权 (安全模式)
    function increaseAllowance(address spender, uint256 addedValue)
        external
        whenNotPaused
        returns (bool)
    {
        _approve(msg.sender, spender,
            _allowances[msg.sender][spender] + addedValue);
        return true;
    }
    
    /// @notice 减少授权 (安全模式)
    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        whenNotPaused
        returns (bool)
    {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(currentAllowance >= subtractedValue, "Decreased below zero");
        unchecked { _approve(msg.sender, spender, currentAllowance - subtractedValue); }
        return true;
    }
    
    // ──── 内部函数 ────
    
    function _transfer(address from, address to, uint256 amount) internal {
        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "Insufficient balance");
        
        unchecked {
            _balances[from] = fromBalance - amount;
            // 不检查溢出: totalSupply不会超过2^256
            _balances[to] += amount;
        }
        emit Transfer(from, to, amount);
    }
    
    function _approve(address _owner, address spender, uint256 amount) internal {
        _allowances[_owner][spender] = amount;
        emit Approval(_owner, spender, amount);
    }
    
    // ──── 管理员功能 ────
    
    /// @notice 铸造代币 (仅白名单)
    function mint(address to, uint256 amount)
        external
        onlyOwner
        whenNotPaused
        notBlacklisted(to)
    {
        require(whitelistMinters[msg.sender], "Not authorized minter");
        require(to != address(0), "Mint to zero");
        
        _totalSupply += amount;
        _balances[to] += amount;  // 无需unchecked: totalSupply有上限约束
        emit Transfer(address(0), to, amount);
        emit Minted(to, amount);
    }
    
    /// @notice 销毁代币
    function burn(uint256 amount) external whenNotPaused {
        address burner = msg.sender;
        uint256 balance = _balances[burner];
        require(balance >= amount, "Burn exceeds balance");
        
        unchecked {
            _balances[burner] = balance - amount;
            _totalSupply -= amount;
        }
        emit Transfer(burner, address(0), amount);
        emit Burned(burner, amount);
    }
    
    /// @notice 暂停合约
    function pause() external onlyOwner {
        paused = true;
        emit Paused(msg.sender);
    }
    
    /// @notice 解除暂停
    function unpause() external onlyOwner {
        paused = false;
        emit Unpaused(msg.sender);
    }
    
    /// @notice 黑名单地址
    function blacklist(address account) external onlyOwner {
        isBlacklisted[account] = true;
        emit Blacklisted(account);
    }
    
    /// @notice 移出黑名单
    function unblacklist(address account) external onlyOwner {
        isBlacklisted[account] = false;
        emit Unblacklisted(account);
    }
    
    /// @notice 设置最大交易额
    function setMaxTxAmount(uint256 newMax) external onlyOwner {
        maxTxAmount = newMax;
    }
    
    /// @notice 设置白名单铸造者
    function setWhitelistMinter(address minter, bool status) external onlyOwner {
        whitelistMinters[minter] = status;
    }
    
    /// @notice 转移所有权
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Zero address");
        owner = newOwner;
    }
}

---

三、实战案例二：NFT市场智能合约

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

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

/// @title MonkeyNFTMarketplace - NFT交易平台
/// @notice 支持上架、购买、竞价、版税分成的完整NFT市场
contract MonkeyNFTMarketplace is ERC721URIStorage, ERC721Enumerable, Ownable, ReentrancyGuard {
    
    // ──── 数据结构 ────
    
    struct Listing {
        address seller;
        uint256 price;
        uint256 listedAt;
        bool active;
    }
    
    struct Offer {
        address buyer;
        uint256 amount;
        uint256 expiresAt;
        bool active;
    }
    
    struct RoyaltyInfo {
        address recipient;
        uint96 rateBps; // 基点: 10000 = 100%, 250 = 2.5%
    }
    
    // ──── 状态变量 ────
    
    string public constant NAME = "MonkeyCode NFT";
    string public constant SYMBOL = "MCNFT";
    
    uint256 private _nextTokenId = 1;
    
    mapping(uint256 => Listing) public listings;
    mapping(uint256 => Offer[]) public offers;
    mapping(uint256 => RoyaltyInfo) public royalties;
    mapping(address => uint256[]) public sellerTokens;
    mapping(address => mapping(uint256 => bool)) public tokenInListings;
    
    uint256 public platformFeeRate = 250; // 2.5% 平台费
    address payable public feeRecipient;
    uint256 public minPrice = 0.001 ether;
    
    // ──── 事件 ────
    
    event NFTMinted(uint256 indexed tokenId, address indexed creator, string uri);
    event NFTListed(uint256 indexed tokenId, address seller, uint256 price);
    event NFTDelisted(uint256 indexed tokenId, address seller);
    event NFTSold(uint256 indexed tokenId, address seller, address buyer, uint256 price);
    event OfferMade(uint256 indexed tokenId, address buyer, uint256 amount, uint256 expiresAt);
    event OfferAccepted(uint256 indexed tokenId, address seller, address buyer, uint256 amount);
    event OfferCancelled(uint256 indexed tokenId, address buyer);
    event RoyaltySet(uint256 indexed tokenId, address recipient, uint96 rateBps);
    
    // ──── 构造函数 ────
    
    constructor() ERC721(NAME, SYMBOL) Ownable(msg.sender) {
        feeRecipient = payable(msg.sender);
    }
    
    // ──── NFT铸造 ────
    
    /// @notice 铸造新NFT
    function mint(string memory uri, address royaltyRecipient, uint96 royaltyRate)
        external
        nonReentrant
        returns (uint256 tokenId)
    {
        require(bytes(uri).length > 0, "Empty URI");
        require(royaltyRate <= 5000, "Royalty too high"); // 最高50%
        
        tokenId = _nextTokenId++;
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, uri);
        
        royalties[tokenId] = RoyaltyInfo({
            recipient: royaltyRecipient != address(0) ? royaltyRecipient : msg.sender,
            rateBps: royaltyRate
        });
        
        emit NFTMinted(tokenId, msg.sender, uri);
    }
    
    /// @notice 批量铸造
    function batchMint(string[] memory uris, address royaltyRecipient, uint96 royaltyRate)
        external
        nonReentrant
        returns (uint256[] memory tokenIds)
    {
        require(uris.length <= 50, "Too many");
        tokenIds = new uint256[](uris.length);
        for (uint256 i = 0; i < uris.length; i++) {
            tokenIds[i] = mint(uris[i], royaltyRecipient, royaltyRate);
        }
    }
    
    // ──── 上架/下架 ────
    
    /// @notice 上架出售
    function listNFT(uint256 tokenId, uint256 price)
        external
        nonReentrant
    {
        require(ownerOf(tokenId) == msg.sender, "Not owner");
        require(isApprovedForAll(msg.sender, address(this)) ||
                getApproved(tokenId) == address(this),
                "Market not approved");
        require(price >= minPrice, "Below min price");
        require(!listings[tokenId].active, "Already listed");
        
        listings[tokenId] = Listing({
            seller: msg.sender,
            price: price,
            listedAt: block.timestamp,
            active: true
        });
        
        if (!tokenInListings[msg.sender][tokenId]) {
            sellerTokens[msg.sender].push(tokenId);
            tokenInListings[msg.sender][tokenId] = true;
        }
        
        emit NFTListed(tokenId, msg.sender, price);
    }
    
    /// @notice 下架
    function delistNFT(uint256 tokenId) external nonReentrant {
        require(listings[tokenId].seller == msg.sender, "Not your listing");
        require(listings[tokenId].active, "Not listed");
        
        listings[tokenId].active = false;
        emit NFTDelisted(tokenId, msg.sender);
    }
    
    // ──── 直接购买 ────
    
    /// @notice 以固定价格购买
    function buyNFT(uint256 tokenId) external payable nonReentrant {
        Listing storage listing = listings[tokenId];
        require(listing.active, "Not for sale");
        require(msg.value >= listing.price, "Insufficient payment");
        
        address seller = listing.seller;
        uint256 price = listing.price;
        listing.active = false;
        
        _distributeFunds(tokenId, seller, price);
        _transferFrom(seller, msg.sender, tokenId);
        
        emit NFTSold(tokenId, seller, msg.sender, price);
        
        // 退还多余ETH
        if (msg.value > price) {
            (bool sent,) = payable(msg.sender).call{value: msg.value - price}("");
            require(sent, "Refund failed");
        }
    }
    
    // ──── 竞价系统 ────
    
    /// @notice 出价
    function makeOffer(uint256 tokenId, uint256 duration) external payable nonReentrant {
        require(msg.value > 0, "Zero offer");
        require(duration > 0 && duration <= 30 days, "Invalid duration");
        require(_exists(tokenId), "NFT not exists");
        
        Offer memory newOffer = Offer({
            buyer: msg.sender,
            amount: msg.value,
            expiresAt: block.timestamp + duration,
            active: true
        });
        
        offers[tokenId].push(newOffer);
        emit OfferMade(tokenId, msg.sender, msg.value, newOffer.expiresAt);
    }
    
    /// @notice 接受出价
    function acceptOffer(uint256 tokenId, uint256 offerIndex) external nonReentrant {
        require(ownerOf(tokenId) == msg.sender, "Not owner");
        Offer[] storage tokenOffers = offers[tokenId];
        require(offerIndex < tokenOffers.length, "Invalid index");
        
        Offer storage offer = tokenOffers[offerIndex];
        require(offer.active, "Offer inactive");
        require(block.timestamp <= offer.expiresAt, "Offer expired");
        
        offer.active = false;
        
        address buyer = offer.buyer;
        uint256 amount = offer.amount;
        
        _distributeFunds(tokenId, msg.sender, amount);
        _transferFrom(msg.sender, buyer, tokenId);
        
        emit OfferAccepted(tokenId, msg.sender, buyer, amount);
    }
    
    /// @notice 取消自己的出价
    function cancelOffer(uint256 tokenId, uint256 offerIndex) external nonReentrant {
        Offer[] storage tokenOffers = offers[tokenId];
        require(offerIndex < tokenOffers.length, "Invalid index");
        Offer storage offer = tokenOffers[offerIndex];
        require(offer.buyer == msg.sender, "Not your offer");
        require(offer.active, "Already inactive");
        
        offer.active = false;
        (bool sent,) = payable(msg.sender).call{value: offer.amount}("");
        require(sent, "Refund failed");
        
        emit OfferCancelled(tokenId, msg.sender);
    }
    
    // ──── 资金分配 (含版税) ────
    
    function _distributeFunds(uint256 tokenId, address seller, uint256 price) internal {
        RoyaltyInfo memory royalty = royalties[tokenId];
        
        // 版税分配
        uint256 royaltyAmount = 0;
        if (royalty.rateBps > 0 && royalty.recipient != address(0)) {
            royaltyAmount = (price * royalty.rateBps) / 10000;
            (bool rSent,) = payable(royalty.recipient).call{value: royaltyAmount}("");
            require(rSent, "Royalty transfer failed");
        }
        
        // 平台费用
        uint256 feeAmount = (price * platformFeeRate) / 10000;
        (bool fSent,) = feeRecipient.call{value: feeAmount}("");
        require(fSent, "Fee transfer failed");
        
        // 卖家收入
        uint256 sellerProceeds = price - royaltyAmount - feeAmount;
        (bool sSent,) = payable(seller).call{value: sellerProceeds}("");
        require(sSent, "Seller transfer failed");
    }
    
    // ──── 查询函数 ────
    
    function getActiveListings() external view returns (uint256[] memory) {
        return sellerTokens[msg.sender];
    }
    
    function getOffers(uint256 tokenId) external view returns (Offer[] memory) {
        return offers[tokenId];
    }
    
    function getRoyalty(uint256 tokenId) external view returns (address, uint96) {
        return (royalties[tokenId].recipient, royalties[tokenId].rateBps);
    }
    
    // ──── 管理员设置 ────
    
    function setPlatformFee(uint256 newFeeRate) external onlyOwner {
        require(newFeeRate <= 1000, "Fee too high"); // 最高10%
        platformFeeRate = newFeeRate;
    }
    
    function setFeeRecipient(address payable newRecipient) external onlyOwner {
        feeRecipient = newRecipient;
    }
    
    function setMinPrice(uint256 newMin) external onlyOwner {
        minPrice = newMin;
    }
    
    // ──── 重写必要函数 ────
    
    function _update(address to, uint256 tokenId, address auth)
        internal override(ERC721, ERC721Enumerable)
    {
        super._update(to, tokenId, auth);
    }
    
    function _increaseBalance(address account, uint128 value)
        internal override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }
    
    function supportsInterface(bytes4 interfaceId)
        public view override(ERC721URIStorage, ERC721Enumerable) returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

---

四、实战案例三：DApp前端交互代码

/**
 * MonkeyCode DApp 工具库 - TypeScript
 * 功能: 钱包连接/切换、合约交互、事件监听、链上数据查询
 */

import { ethers, Contract, BrowserProvider, Signer, formatUnits, parseUnits } from 'ethers';
import type { EventLog } from 'ethers';

// ──── 类型定义 ────

interface WalletState {
  address: string | null;
  chainId: number | null;
  signer: Signer | null;
  provider: BrowserProvider | null;
  isConnected: boolean;
}

interface TokenInfo {
  name: string;
  symbol: string;
  decimals: number;
  totalSupply: bigint;
  userBalance: bigint;
}

interface NFTMetadata {
  tokenId: bigint;
  uri: string;
  owner: string;
  price?: bigint;
  seller?: string;
}

// ──── ABI 定义 (精简版) ────

const ERC20_ABI = [
  'function name() view returns (string)',
  'function symbol() view returns (string)',
  'function decimals() view returns (uint8)',
  'function totalSupply() view returns (uint256)',
  'function balanceOf(address) view returns (uint256)',
  'function transfer(address,uint256) returns (bool)',
  'function approve(address,uint256) returns (bool)',
  'function allowance(address,address) view returns (uint256)',
  'function transferFrom(address,address,uint256) returns (bool)',
  'event Transfer(address indexed,address indexed,uint256)',
  'event Approval(address indexed,address indexed,uint256)',
];

const ERC721_ABI = [
  'function name() view returns (string)',
  'function symbol() view returns (string)',
  'function ownerOf(uint256) view returns (address)',
  'function tokenURI(uint256) view returns (string)',
  'function balanceOf(address) view returns (uint256)',
  'function tokenOfOwnerByIndex(address,uint256) view returns (uint256)',
  'function safeTransferFrom(address,address,uint256)',
  'function approve(address,uint256)',
  'function setApprovalForAll(address,bool)',
  'event Transfer(address indexed,address indexed,uint256 indexed)',
];

// ──── 钱包管理类 ────

class WalletManager {
  private state: WalletState;
  private listeners: Set<(state: WalletState) => void> = new Set();
  private _chainChangeHandler: ((chainId: string) => void) | null = null;
  private _accountsChangedHandler: ((accounts: string[]) => void) | null = null;

  constructor() {
    this.state = {
      address: null,
      chainId: null,
      signer: null,
      provider: null,
      isConnected: false,
    };
  }

  async connect(): Promise<WalletState> {
    if (!this._hasEthereum()) throw new Error('No wallet found');

    const provider = new BrowserProvider(window.ethereum!);
    await provider.send('eth_requestAccounts', []);
    const signer = await provider.getSigner();
    const address = await signer.getAddress();
    const network = await provider.getNetwork();

    this.state = { address, chainId: Number(network.chainId), signer, provider, isConnected: true };
    this._setupEventListeners();
    this._notifyListeners();
    return this.state;
  }

  async disconnect(): Promise<void> {
    this.state = { address: null, chainId: null, signer: null, provider: null, isConnected: false };
    this._cleanupListeners();
    this._notifyListeners();
  }

  async switchChain(chainId: number): Promise<void> {
    if (!window.ethereum) throw new Error('No wallet');
    const hexChainId = `0x${chainId.toString(16)}`;
    try {
      await window.ethereum.request({ method: 'wallet_switchEthereumChain', params: [{ chainId: hexChainId }] });
    } catch (switchError: any) {
      if (switchError.code === 4902) {
        throw new Error('Chain not added to wallet');
      }
      throw switchError;
    }
  }

  subscribe(listener: (state: WalletState) => void): () => void {
    this.listeners.add(listener);
    listener(this.state);
    return () => this.listeners.delete(listener);
  }

  get stateSnapshot(): WalletState { return { ...this.state }; }

  private _hasEthereum(): boolean {
    return typeof window !== 'undefined' && !!window.ethereum?.isMetaMask;
  }

  private _notifyListeners(): void {
    this.listeners.forEach(l => l(this.state));
  }

  private _setupEventListeners(): void {
    if (!window.ethereum) return;
    this._chainChangeHandler = (chainId: string) => {
      this.state.chainId = parseInt(chainId, 16);
      this._notifyListeners();
    };
    this._accountsChangedHandler = async (accounts: string[]) => {
      if (accounts.length === 0) { await this.disconnect(); }
      else { await this.connect(); }
    };
    window.ethereum.on('chainChanged', this._chainChangeHandler);
    window.ethereum.on('accountsChanged', this._accountsChangedHandler);
  }

  private _cleanupListeners(): void {
    if (window.ethereum && this._chainChangeHandler) {
      window.ethereum.removeListener('chainChanged', this._chainChangeHandler);
      window.ethereum.removeListener('accountsChanged', this._accountsChangedHandler!);
    }
  }
}

// ──── 合约交互工具类 ────

class ContractHelper {
  private wallet: WalletManager;

  constructor(wallet: WalletManager) { this.wallet = wallet; }

  getContract(address: string, abi: any[]): Contract | null {
    const { signer } = this.wallet.stateSnapshot;
    if (!signer) return null;
    return new Contract(address, abi, signer);
  }

  getReadOnlyContract(address: string, abi: any[]): Contract | null {
    const { provider } = this.wallet.stateSnapshot;
    if (!provider) return null;
    return new Contract(address, abi, provider);
  }

  // ERC20 操作
  async getTokenInfo(tokenAddress: string): Promise<TokenInfo> {
    const contract = this.getReadOnlyContract(tokenAddress, ERC20_ABI);
    if (!contract) throw new Error('Not connected');

    const [name, symbol, decimals, totalSupply, userBalance] = await Promise.all([
      contract.name(), contract.symbol(), contract.decimals(),
      contract.totalSupply(), contract.balanceOf(this.wallet.stateSnapshot.address!),
    ]);

    return { name, symbol, decimals: Number(totalSupply), totalSupply, userBalance };
  }

  async transfer(tokenAddress: string, to: string, amount: string): Promise<string> {
    const contract = this.getContract(tokenAddress, ERC20_ABI);
    if (!contract) throw new Error('Not connected');
    const info = await this.getTokenInfo(tokenAddress);
    const parsedAmount = parseUnits(amount, info.decimals);
    const tx = await contract.transfer(to, parsedAmount);
    const receipt = await tx.wait();
    return receipt.hash;
  }

  // ERC721 操作
  async getUserNFTs(nftAddress: string): Promise<NFTMetadata[]> {
    const contract = this.getReadOnlyContract(nftAddress, ERC721_ABI);
    if (!contract) throw new Error('Not connected');
    const userAddr = this.wallet.stateSnapshot.address!;
    const balance = await contract.balanceOf(userAddr);

    const nfts: NFTMetadata[] = [];
    for (let i = 0n; i < balance; i++) {
      const tokenId = await contract.tokenOfOwnerByIndex(userAddr, i);
      const [uri, owner] = await Promise.all([
        contract.tokenURI(tokenId), contract.ownerOf(tokenId),
      ]);
      nfts.push({ tokenId, uri, owner });
    }
    return nfts;
  }

  // 通用事件监听
  async listenToTransfers(contractAddress: string, callback: (log: EventLog) => void): Promise<() => void> {
    const contract = this.getReadOnlyContract(contractAddress, ERC20_ABI);
    if (!contract) throw new Error('Not connected');
    const filter = contract.filters.Transfer(null, null, null);
    contract.on(filter, (...args) => {
      const log = args[args.length - 1] as EventLog;
      callback(log);
    });
    return () => contract.removeAllListeners(filter);
  }

  // 等待确认
  async waitForConfirmation(txHash: string, confirmations = 1): Promise<number> {
    const { provider } = this.wallet.stateSnapshot;
    if (!provider) throw new Error('No provider');
    const tx = await provider.getTransaction(txHash);
    const receipt = await tx.wait(confirmations);
    return receipt!.blockNumber;
  }
}

// ──── 导出单例 ────

export const wallet = new WalletManager();
export const contracts = new ContractHelper(wallet);
export type { WalletState, TokenInfo, NFTMetadata };

---

五、MonkeyCode区块链开发提示词模板

📝 MonkeyCode 区块链提示词:

【智能合约】
"用 Solidity ^0.8.20 编写一个 [类型] 的智能合约：
 - 符合 OpenZeppelin 最佳实践
 - 使用 ReentrancyGuard 防重入
 - 包含暂停/恢复机制
 - Gas 优化: 使用 unchecked 和 calldata
 - 添加完整的 NatSpec 注释"

【DApp前端】
"创建一个 React + TypeScript 的 DApp 前端：
 - 连接 MetaMask 钱包
 - 显示用户 ETH 和 ERC20 余额
 - 调用合约的 mint/buy/list 函数
 - 监听链上事件并实时更新UI
 - 错误处理和加载状态"

【安全审计】
"审查以下智能合约的安全漏洞:
 - 重入攻击、整数溢出、前置运行
 - 访问控制缺陷
 - Gas 优化建议
 - 给出修复后的完整代码"

---

六、总结

MonkeyCode在区块链开发中的核心价值：

• 🔐 安全优先 — 自动生成防重入、防溢出的安全合约代码
• ⛽️ Gas优化 — 智能选择省Gas的数据类型和存储方案
• 🌐 全栈支持 — 从Solidity合约到React前端的端到端辅助
• 📋 规范遵循 — EIP标准、OpenZeppelin最佳实践的自动遵守
• 🔍 审计辅助 — 常见漏洞模式的自动识别和修复建议

"区块链开发的门槛不应是密码学或Gas优化——而应该是你的创意本身。MonkeyCode帮你跨越技术门槛，让每个人都能参与去中心化的未来。"

---

本文最后更新：2026年7月16日
作者：MonkeyCode团队

相关阅读：

• MonkeyCode快速入门教程
• MonkeyCode多语言支持详解
• MonkeyCode物联网(IoT)开发实战

下一篇预告：[MonkeyCode云计算集成方案]