Playnance Web3架构师系统提示

# Playnance Web3 架构师指南：构建 G Coin 钱包应用

## 1. 架构与规划

### 1.1 技术栈总览

| 组件 | 技术选择 | 用途 | |------|----------|------| | 前端框架 | React 18 + Vite 5 + TypeScript | 构建用户界面 | | 区块链交互 | ethers.js v6 | RPC 调用、合约交互 | | 钱包逻辑 | BIP39 + HD 钱包 | 助记词生成/导入 | | 状态管理 | Zustand | 轻量级全局状态 | | 样式 | Tailwind CSS | 快速响应式 UI | | 构建工具 | Vite | 开发与生产构建 | | 部署平台 | Vercel | 前端托管 |

### 1.2 PlayBlock 网络配置

```typescript // src/config/network.ts export const PLAYBLOCK_CONFIG = { chainId: 1829, chainName: 'PlayBlock', nativeCurrency: { name: 'G Coin', symbol: 'G', decimals: 18 }, rpcUrls: ['https://rpc.playblock.io'], // 替换为实际 RPC 端点 blockExplorerUrls: ['https://explorer.playblock.io'] }; ```

### 1.3 文件结构蓝图

``` gcoin-wallet/ ├── src/ │ ├── components/ │ │ ├── Wallet/ │ │ │ ├── WalletDashboard.tsx │ │ │ ├── SendForm.tsx │ │ │ ├── ReceiveModal.tsx │ │ │ └── TransactionHistory.tsx │ │ └── Auth/ │ │ ├── CreateWallet.tsx │ │ └── ImportWallet.tsx │ ├── services/ │ │ ├── blockchain/ │ │ │ ├── provider.ts │ │ │ ├── wallet.ts │ │ │ └── gcoin.ts │ │ └── storage/ │ │ └── secureStore.ts │ ├── hooks/ │ │ ├── useWallet.ts │ │ └── useBalance.ts │ ├── types/ │ │ └── index.ts │ ├── utils/ │ │ └── validation.ts │ ├── App.tsx │ └── main.tsx ├── contracts/ │ ├── contracts/ │ │ └── GCoin.sol │ ├── scripts/ │ │ ├── deploy.ts │ │ └── interact.ts │ └── test/ │ └── GCoin.test.ts ├── .env ├── .env.example ├── hardhat.config.ts ├── package.json └── vite.config.ts ```

---

## 2. 代码交付

### 2.1 项目初始化命令

```bash # 创建 Vite 项目 npm create vite@latest gcoin-wallet -- --template react-ts cd gcoin-wallet

# 安装核心依赖 npm install ethers@6 zustand @tanstack/react-query npm install -D tailwindcss @tailwindcss/vite

# 初始化 Tailwind npx tailwindcss init -p ```

### 2.2 环境变量配置

```bash # .env.example VITE_PLAYBLOCK_RPC_URL=https://rpc.playblock.io VITE_GCOIN_CONTRACT_ADDRESS=0xYourGCoinContractAddress VITE_CHAIN_ID=1829 VITE_EXPLORER_URL=https://explorer.playblock.io ```

### 2.3 Provider 设置

```typescript // src/services/blockchain/provider.ts import { ethers } from 'ethers';

export class BlockchainProvider { private static instance: BlockchainProvider; private provider: ethers.JsonRpcProvider;

private constructor() { this.provider = new ethers.JsonRpcProvider( import.meta.env.VITE_PLAYBLOCK_RPC_URL, Number(import.meta.env.VITE_CHAIN_ID), { staticNetwork: true } ); }

public static getInstance(): BlockchainProvider { if (!BlockchainProvider.instance) { BlockchainProvider.instance = new BlockchainProvider(); } return BlockchainProvider.instance; }

public getProvider(): ethers.JsonRpcProvider { return this.provider; }

public getSigner(privateKey: string): ethers.Wallet { return new ethers.Wallet(privateKey, this.provider); } } ```

### 2.4 钱包创建/导入逻辑

```typescript // src/services/blockchain/wallet.ts import { ethers } from 'ethers'; import { BlockchainProvider } from './provider';

export class WalletService { private provider = BlockchainProvider.getInstance().getProvider();

public createWallet(): { mnemonic: string; address: string } { const wallet = ethers.Wallet.createRandom(); return { mnemonic: wallet.mnemonic!.phrase, address: wallet.address }; }

public importFromMnemonic(mnemonic: string): ethers.Wallet { const normalizedMnemonic = mnemonic.trim().toLowerCase(); if (!ethers.Mnemonic.isValidMnemonic(normalizedMnemonic)) { throw new Error('无效的助记词'); } return ethers.Wallet.fromPhrase(normalizedMnemonic); }

public importFromPrivateKey(privateKey: string): ethers.Wallet { try { return new ethers.Wallet(privateKey, this.provider); } catch { throw new Error('无效的私钥'); } }

public async getBalance(address: string): Promise { const balance = await this.provider.getBalance(address); return ethers.formatEther(balance); } } ```

### 2.5 G Coin ERC-20 ABI

```typescript // src/services/blockchain/gcoin.ts export const GCOIN_ABI = [ // ERC-20 标准函数 'function name() view returns (string)', 'function symbol() view returns (string)', 'function decimals() view returns (uint8)', 'function totalSupply() view returns (uint256)', 'function balanceOf(address owner) view returns (uint256)', 'function transfer(address to, uint256 amount) returns (bool)', 'function allowance(address owner, address spender) view returns (uint256)', 'function approve(address spender, uint256 amount) returns (bool)', 'function transferFrom(address from, address to, uint256 amount) returns (bool)', // 事件 'event Transfer(address indexed from, address indexed to, uint256 value)', 'event Approval(address indexed owner, address indexed spender, uint256 value)' ];

export class GCoinService { private contract: ethers.Contract;

constructor(signer: ethers.Wallet) { this.contract = new ethers.Contract( import.meta.env.VITE_GCOIN_CONTRACT_ADDRESS, GCOIN_ABI, signer ); }

public async getBalance(address: string): Promise { const balance = await this.contract.balanceOf(address); return ethers.formatUnits(balance, 18); }

public async transfer(to: string, amount: string): Promise { const tx = await this.contract.transfer(to, ethers.parseUnits(amount, 18)); return await tx.wait(); }

public async getGasPrice(): Promise { return await this.provider.getFeeData().then(f => f.gasPrice!); } } ```

### 2.6 React 钱包 UI 组件

```tsx // src/components/Wallet/WalletDashboard.tsx import { useState, useEffect } from 'react'; import { useWalletStore } from '../../store/walletStore'; import { GCoinService } from '../../services/blockchain/gcoin'; import { SendForm } from './SendForm'; import { ReceiveModal } from './ReceiveModal';

export function WalletDashboard() { const { address, signer } = useWalletStore(); const [balance, setBalance] = useState ('0'); const [showReceive, setShowReceive] = useState(false);

useEffect(() => { if (address && signer) { const gcoin = new GCoinService(signer); gcoin.getBalance(address).then(setBalance); } }, [address, signer]);

return ( G Coin 钱包 地址

{address}

余额

{balance} G

setShowReceive(true)} className="bg-blue-600 text-white px-4 py-2 rounded hover:bg-blue-700" > 接收

{showReceive && ( setShowReceive(false)} /> )} ); } ```

### 2.7 发送表单组件

```tsx // src/components/Wallet/SendForm.tsx import { useState } from 'react'; import { useWalletStore } from '../../store/walletStore'; import { GCoinService } from '../../services/blockchain/gcoin'; import { validateAddress, validateAmount } from '../../utils/validation';

export function SendForm() { const { signer } = useWalletStore(); const [to, setTo] = useState(''); const [amount, setAmount] = useState(''); const [status, setStatus] = useState ('idle'); const [error, setError] = useState('');

const handleSend = async () => { if (!validateAddress(to)) { setError('无效的接收地址'); return; } if (!validateAmount(amount)) { setError('无效的转账金额'); return; }

try { setStatus('pending'); const gcoin = new GCoinService(signer!); const receipt = await gcoin.transfer(to, amount); if (receipt.status === 1) { setStatus('success'); setTo(''); setAmount(''); } else { setStatus('error'); setError('交易失败'); } } catch (err: any) { setStatus('error'); setError(err.message || '转账失败'); } };

return ( setTo(e.target.value)} className="flex-1 px-3 py-2 border rounded" /> setAmount(e.target.value)} className="w-32 px-3 py-2 border rounded" /> {status === 'pending' ? '发送中...' : '发送'} {status === 'success' && ( 转账成功！

)} {status === 'error' && ( {error}

)} ); } ```

### 2.8 Zustand 状态管理

```typescript // src/store/walletStore.ts import { create } from 'zustand'; import { ethers } from 'ethers'; import { persist } from 'zustand/middleware';

interface WalletState { address: string | null; mnemonic: string | null; signer: ethers.Wallet | null; isLocked: boolean; setWallet: (wallet: ethers.Wallet) => void; lock: () => void; unlock: (password: string) => void; clear: () => void; }

export const useWalletStore = create ()( persist( (set, get) => ({ address: null, mnemonic: null, signer: null, isLocked: true, setWallet: (wallet) => set({ address: wallet.address, mnemonic: wallet.mnemonic?.phrase || null, signer: wallet, isLocked: false }), lock: () => set({ isLocked: true, signer: null }), unlock: (password) => { const { mnemonic } = get(); if (!mnemonic) return; // 使用密码解密助记词 const wallet = ethers.Wallet.fromPhrase(mnemonic); set({ signer: wallet, isLocked: false }); }, clear: () => set({ address: null, mnemonic: null, signer: null, isLocked: true }) }), { name: 'gcoin-wallet-storage', partialize: (state) => ({ address: state.address, mnemonic: state.mnemonic }) } ) ); ```

---

## 3. 开发环境设置

### 3.1 Node.js 安装

```bash # 使用 nvm (推荐) curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash nvm install 20.11.0 nvm use 20.11.0

# 验证 node --version # 应输出 v20.11.0 npm --version # 应输出 10.x.x ```

### 3.2 Vite 项目配置

```typescript // vite.config.ts import { defineConfig } from 'vite'; import react from '@vitejs/plugin-react'; import tailwindcss from '@tailwindcss/vite';

export default defineConfig({ plugins: [react(), tailwindcss()], build: { target: 'es2020', minify: 'terser', terserOptions: { compress: { drop_console: true, drop_debugger: true } }, rollupOptions: { output: { manualChunks: { ethers: ['ethers'], react: ['react', 'react-dom'], zustand: ['zustand'] } } } }, server: { port: 3000, host: true } }); ```

### 3.3 连接 PlayBlock RPC

```typescript // src/services/blockchain/provider.ts (完整版) import { ethers } from 'ethers';

export class BlockchainProvider { private static instance: BlockchainProvider; private provider: ethers.JsonRpcProvider; private networkInfo: any;

private constructor() { this.provider = new ethers.JsonRpcProvider( import.meta.env.VITE_PLAYBLOCK_RPC_URL, Number(import.meta.env.VITE_CHAIN_ID), { staticNetwork: true } ); this.networkInfo = { chainId: `0x${Number(import.meta.env.VITE_CHAIN_ID).toString(16)}`, chainName: 'PlayBlock', nativeCurrency: { name: 'G Coin', symbol: 'G', decimals: 18 }, rpcUrls: [import.meta.env.VITE_PLAYBLOCK_RPC_URL], blockExplorerUrls: [import.meta.env.VITE_EXPLORER_URL] }; }

public static getInstance(): BlockchainProvider { if (!BlockchainProvider.instance) { BlockchainProvider.instance = new BlockchainProvider(); } return BlockchainProvider.instance; }

public getProvider(): ethers.JsonRpcProvider { return this.provider; }

public async checkConnection(): Promise { try { const network = await this.provider.getNetwork(); return network.chainId === BigInt(import.meta.env.VITE_CHAIN_ID); } catch { return false; } }

public async addToMetaMask(): Promise { if (typeof window.ethereum !== 'undefined') { try { await window.ethereum.request({ method: 'wallet_addEthereumChain', params: [this.networkInfo] }); } catch (error) { console.error('添加网络失败:', error); } } } } ```

---

## 4. 智能合约工具链

### 4.1 Hardhat 配置

```typescript // hardhat.config.ts import { HardhatUserConfig } from 'hardhat/config'; import '@nomicfoundation/hardhat-toolbox'; import '@nomiclabs/hardhat-ethers'; import * as dotenv from 'dotenv';

dotenv.config();

const config: HardhatUserConfig = { solidity: { version: '0.8.24', settings: { optimizer: { enabled: true, runs: 200 } } }, networks: { playblock: { url: process.env.PLAYBLOCK_RPC_URL || 'https://rpc.playblock.io', chainId: 1829, accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [] }, hardhat: { chainId: 1829 } }, etherscan: { apiKey: { playblock: process.env.BLOCK_EXPLORER_API_KEY || '' }, customChains: [ { network: 'playblock', chainId: 1829, urls: { apiURL: 'https://explorer.playblock.io/api', browserURL: 'https://explorer.playblock.io' } } ] }, paths: { sources: './contracts/contracts', tests: './contracts/test', cache: './contracts/cache', artifacts: './contracts/artifacts' } };

export default config; ```

### 4.2 G Coin 合约

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";

contract GCoin is ERC20, ERC20Burnable, Ownable, ERC20Permit { uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10**18; // 10亿 G Coin constructor() ERC20("G Coin", "G") ERC20Permit("G Coin") Ownable(msg.sender) { _mint(msg.sender, 100_000_000 * 10**18); // 初始供应 1亿 }

function mint(address to, uint256 amount) external onlyOwner { require(totalSupply() + amount <= MAX_SUPPLY, "GCoin: exceeds max supply"); _mint(to, amount); }

// 支持 gasless 交易 function executeMetaTransaction( address userAddress, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV ) external payable returns (bytes memory) { require(verify(userAddress, functionSignature, sigR, sigS, sigV), "GCoin: invalid signature"); (bool success, bytes memory returnData) = address(this).call( abi.encodePacked(functionSignature, userAddress) ); require(success, "GCoin: function call failed"); return returnData; }

function verify( address user, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV ) internal view returns (bool) { bytes32 hash = keccak256( abi.encodePacked( "\x19Ethereum Signed Message:\n32", keccak256(abi.encodePacked(address(this), user, functionSignature)) ) ); address recovered = ecrecover(hash, sigV, sigR, sigS); return recovered == user; } } ```

### 4.3 部署脚本

```typescript // contracts/scripts/deploy.ts import { ethers } from 'hardhat';

async function main() { console.log('部署 G Coin 合约到 PlayBlock...');

const GCoin = await ethers.getContractFactory('GCoin'); const gcoin = await GCoin.deploy(); await gcoin.waitForDeployment(); const address = await gcoin.getAddress(); console.log(`G Coin 合约已部署: ${address}`); // 验证合约 await hre.run('verify:verify', { address: address, constructorArguments: [] }); console.log('合约验证完成'); }

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

### 4.4 测试脚本

```typescript // contracts/test/GCoin.test.ts import { expect } from 'chai'; import { ethers } from 'hardhat';

describe('GCoin', function () { let gcoin: any; let owner: any; let addr1: any; let addr2: any;

beforeEach(async function () { const GCoin = await ethers.getContractFactory('GCoin'); [owner, addr1, addr2] = await ethers.getSigners(); gcoin = await GCoin.deploy(); });

describe('部署', function () { it('应设置正确的名称和符号', async function () { expect(await gcoin.name()).to.equal('G Coin'); expect(await gcoin.symbol()).to.equal('G'); });

it('应分配初始供应量给部署者', async function () { const ownerBalance = await gcoin.balanceOf(owner.address); expect(await gcoin.totalSupply()).to.equal(ownerBalance); }); });

describe('转账', function () { it('应转移代币', async function () { await gcoin.transfer(addr1.address, 1000); expect(await gcoin.balanceOf(addr1.address)).to.equal(1000); });

it('余额不足时应失败', async function () { await expect( gcoin.connect(addr1).transfer(owner.address, 1) ).to.be.revertedWith('ERC20: transfer amount exceeds balance'); }); });

describe('铸造', function () { it('只有所有者可以铸造', async function () { await expect( gcoin.connect(addr1).mint(addr1.address, 1000) ).to.be.revertedWith('Ownable: caller is not the owner'); });

it('不能超过最大供应量', async function () { await expect( gcoin.mint(owner.address, ethers.parseEther('1000000001')) ).to.be.revertedWith('GCoin: exceeds max supply'); }); }); }); ```

---

## 5. 部署到 Vercel

### 5.1 部署配置

```json // vercel.json { "buildCommand": "npm run build", "outputDirectory": "dist", "framework": "vite", "rewrites": [ { "source": "/(.*)", "destination": "/index.html" } ], "headers": [ { "source": "/assets/(.*)", "headers": [ { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" } ] }, { "source": "/(.*)", "headers": [ { "key": "X-Content-Type-Options", "value": "nosniff" }, { "key": "X-Frame-Options", "value": "DENY" }, { "key": "X-XSS-Protection", "value": "1; mode=block" }, { "key": "Referrer-Policy", "value": "strict-origin-when-cross-origin" }, { "key": "Content-Security-Policy", "value": "default-src 'self'; connect-src 'self' https://rpc.playblock.io; img-src 'self' data:; style-src 'self' 'unsafe-inline'" } ] } ] } ```

### 5.2 环境变量设置

在 Vercel 控制台设置：

| 变量名 | 值 | 环境 | |--------|-----|------| | `VITE_PLAYBLOCK_RPC_URL` | `https://rpc.playblock.io` | Production | | `VITE_GCOIN_CONTRACT_ADDRESS` | 部署后的合约地址 | Production | | `VITE_CHAIN_ID` | `1829` | Production | | `VITE_EXPLORER_URL` | `https://explorer.playblock.io` | Production |

### 5.3 部署命令

```bash # 安装 Vercel CLI npm i -g vercel

# 登录 vercel login

# 部署到生产环境 vercel --prod

# 或使用 Git 集成 # 在 Vercel 控制台导入 GitHub 仓库 ```

---

## 6. 变现策略

### 6.1 收入模型对比

| 策略 | 实现难度 | 收入潜力 | 用户影响 | 建议优先级 | |------|----------|----------|----------|------------| | 交易手续费 | 低 | 中 | 低 | 高 | | 高级功能订阅 | 中 | 高 | 中 | 高 | | 法币入金推荐 | 低 | 中 | 低 | 中 | | 质押收益分成 | 高 | 高 | 中 | 中 | | 代币实用工具 | 高 | 高 | 高 | 低 |

### 6.2 交易手续费实现

```typescript // src/services/blockchain/feeService.ts export class FeeService { private static readonly FEE_BPS = 30; // 0.3% private static readonly MIN_FEE = ethers.parseUnits('0.01', 18); private static readonly MAX_FEE = ethers.parseUnits('10', 18);

public static calculateFee(amount: bigint): bigint { const fee = (amount * BigInt(this.FEE_BPS)) / BigInt(10000); if (fee this.MAX_FEE) return this.MAX_FEE; return fee; }

public static async executeSwapWithFee( gcoin: GCoinService, from: string, to: string, amount: string ): Promise { const amountBigInt = ethers.parseUnits(amount, 18); const fee = this.calculateFee(amountBigInt); const netAmount = amountBigInt - fee; // 先转账给接收方 await gcoin.transfer(to, ethers.formatUnits(netAmount, 18)); // 再收取手续费 return await gcoin.transfer(process.env.FEE_COLLECTOR!, ethers.formatUnits(fee, 18)); } } ```

### 6.3 高级功能订阅

```typescript // src/services/subscriptionService.ts export interface SubscriptionTier { name: string; price: number; // 每月 G Coin features: string[]; }

export const SUBSCRIPTION_TIERS: SubscriptionTier[] = [ { name: '免费版', price: 0, features: ['基础钱包', '发送/接收', '交易历史'] }, { name: '专业版', price: 50, features: ['无限交易', '高级图表', '多钱包管理', '优先客服'] }, { name: '企业版', price: 500, features: ['API 访问', '批量交易', '自定义报告', '专属支持'] } ]; ```

---

## 7. 安全与合规

### 7.1 安全清单

| 类别 | 措施 | 状态 | |------|------|------| | 密钥管理 | 助记词加密存储（AES-256） | 必须 | | 密钥管理 | 支持硬件钱包集成 | 推荐 | | 前端安全 | CSP 头配置 | 必须 | | 前端安全 | 输入验证与 XSS 防护 | 必须 | | 智能合约 | 使用 OpenZeppelin 标准 | 必须 | | 智能合约 | 部署前进行审计 | 必须 | | 合规 | KYC/AML 集成 | 推荐 | | 合规 | 隐私政策与条款 | 必须 |

### 7.2 安全存储实现

```typescript // src/services/storage/secureStore.ts import CryptoJS from 'crypto-js';

export class SecureStore { private static readonly STORAGE_KEY = 'gcoin_secure_vault'; public static async encryptAndStore( data: string, password: string ): Promise { const encrypted = CryptoJS.AES.encrypt(data, password).toString(); localStorage.setItem(this.STORAGE_KEY, encrypted); }

public static async decryptAndRetrieve( password: string ): Promise { const encrypted = localStorage.getItem(this.STORAGE_KEY); if (!encrypted) return null; try { const decrypted = CryptoJS.AES.decrypt(encrypted, password); return decrypted.toString(CryptoJS.enc.Utf8); } catch { return null; } }

public static async clear(): Promise { localStorage.removeItem(this.STORAGE_KEY); } } ```

### 7.3 智能合约安全最佳实践

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

contract SecurityPatterns { // 重入保护 uint256 private _locked = 1; modifier nonReentrant() { require(_locked == 1, "ReentrancyGuard: reentrant call"); _locked = 2; _; _locked = 1; }

// 检查-效果-交互模式 function safeTransfer(address token, address to, uint256 amount) external nonReentrant { require(to != address(0), "Invalid address"); require(amount > 0, "Amount must be > 0"); // 效果 balances[msg.sender] -= amount; balances[to] += amount; // 交互 (bool success, ) = token.call( abi.encodeWithSignature("transfer(address,uint256)", to, amount) ); require(success, "Transfer failed"); }

// 紧急暂停 bool public paused = false; modifier whenNotPaused() { require(!paused, "Contract is paused"); _; }

function emergencyPause() external onlyOwner { paused = true; }

function emergencyResume() external onlyOwner { paused = false; } } ```

---

## 8. 最终交付清单

### 8.1 开发完成检查表

- [ ] 项目初始化完成 - [ ] PlayBlock RPC 连接成功 - [ ] 钱包创建/导入功能正常 - [ ] G Coin 余额显示正确 - [ ] 发送/接收功能测试通过 - [ ] 交易历史记录完整 - [ ] 错误处理与用户提示完善 - [ ] 响应式设计适配移动端 - [ ] 安全存储实现 - [ ] 环境变量配置完成

### 8.2 部署检查表

- [ ] Vercel 项目创建 - [ ] 环境变量配置 - [ ] 构建测试通过 - [ ] 安全头配置 - [ ] 域名绑定 - [ ] SSL 证书生效 - [ ] 监控与日志设置

### 8.3 上线后监控

```typescript // src/services/monitoring.ts export class MonitoringService { public static trackEvent(eventName: string, data?: any): void { // 集成分析工具 if (import.meta.env.PROD) { // 发送到分析平台 console.log(`[Analytics] ${eventName}`, data); } }

public static trackError(error: Error, context?: string): void { // 集成错误追踪 console.error(`[Error] ${context || ''}`, error); }

public static trackPerformance(metric: string, value: number): void { // 性能监控 console.log(`[Performance] ${metric}: ${value}ms`); } } ```

---

## 下一步行动

1. **立即开始**：按照第 3 节设置开发环境 2. **核心功能**：先实现钱包创建、余额查询、转账功能 3. **合约部署**：使用 Hardhat 部署 G Coin 合约 4. **测试**：在 PlayBlock 测试网完成全流程测试 5. **上线**：部署到 Vercel 并配置生产环境 6. **迭代**：根据用户反馈添加高级功能

如需任何部分的详细代码或遇到具体问题，请随时提出。我会提供针对性的解决方案。

Playnance Web3架构师系统提示

提示词内容收藏

用法

参考资料

讨论