第2章：合约篇——智能合约开发入门与Solidity精讲
本章将引领你从熟悉的PHP后端开发领域，跨入区块链智能合约构建的全新世界。作为一名PHP开发者，你早已精通如何在服务器端处理业务逻辑、与数据库交互并构建安全的API。在本章，你将发现智能合约本质上是一个运行在区块链网络上的“不可篡改的后端脚本”，而Solidity则是撰写这个脚本的专用语言。我们将把你已有的编程理念，如变量、函数、流程控制和事件驱动，映射到去中心化的环境中，让你能像设计一个精密的PHP类一样，设计并部署属于你自己的链上业务逻辑。
本章定位于整个教程的核心技术转折点。在第1章搭建好本地开发环境（如Ganache）并理解基础概念之后，本章将深入区块链应用的“大脑”与“规则制定者”——智能合约。掌握本章内容，是后续所有章节的基础。无论是第3章中通过PHP与合约进行交互，还是后续构建完整的去中心化应用（DApp），你都必须深刻理解合约是如何被编写和运作的。它相当于为你提供了在Web3.0世界中创建核心业务规则的“立法权”。
我们将系统性地深入Solidity语言的核心。首先从合约的基本结构开始，对比PHP的类（Class）来理解合约（Contract）如何封装状态和数据。接着，详细探讨Solidity特有的数据类型（如address、uint）与你熟悉的PHP类型的异同，并重点讲解“映射”（mapping）——这个类似于PHP关联数组但运行在链上的强大存储结构。随后，我们将深入研究函数，包括可见性（public, private）、状态可变性（view, pure）以及至关重要的支付函数（payable）和修饰器（modifier），后者能让你像在PHP中使用中间件一样优雅地处理函数权限和验证。最后，我们会讲解事件（event）机制，它是合约向外部（包括你的PHP应用）发送通知的日志系统，是实现前后端异步通信的关键。
本章的内容承前启后，至关重要。它直接承接第1章所建立的环境和基础概念，将理论知识转化为具体的、可执行的代码。当你完成本章学习后，你将具备独立编写、测试和部署简单智能合约的能力。这为进入第3章“交互篇”铺平了道路，在那里，你将学习如何使用PHP库（如web3.php）与本章编写的合约进行对话，调用其函数、监听其事件，从而真正实现将PHP传统后端与区块链智能合约后端无缝融合，构建出完整的Web3.0应用架构。
作为一名PHP开发者，你已经习惯于构建由类和对象组成的应用，这些类封装了数据（属性）和行为（方法）。在Solidity中，智能合约（Contract） 就是这个哲学在区块链上的直接体现。你可以将其理解为一个部署到链上后就无法被修改的、特殊的PHP类。这个“类”的实例（即部署后的合约）拥有一个独一无二的区块链地址，可以永久地存储资产（ETH/Token）和数据，并执行其中定义的逻辑。我们将通过以下几个核心概念，为你搭建起从PHP思维到Solidity思维的桥梁。
第一，合约即账户与状态持久化。 在PHP中，对象的数据通常随请求结束而消失，持久化数据依赖于MySQL或Redis。在区块链上，状态变量直接写入到分布式账本中，实现了真正的永久存储。每个合约都有一个专属的存储空间。例如，一个简单的银行合约需要记录每个用户的余额。在Solidity中，我们会使用 mapping(address => uint256) public balances; 来声明。请对比以下PHP实现，它模拟了类似“状态”的持久化思维，但实际存储仍依赖于数据库：
/**
* PHP模拟：一个简单的“链下”银行合约逻辑类。
* 注意：实际持久化依赖于数据库，此处用数组模拟内存状态以便理解。
*/
class SimpleBankContract {
// 模拟区块链的“状态存储”，实际应用中对应数据库表
private $balances = [];
/**
* 存款函数，模拟Solidity中的`payable`函数。
* @param string $userAddress 用户地址（模拟区块链地址）
* @param float $amount 存款金额
*/
public function deposit(string $userAddress, float $amount): void {
if (!isset($this->balances[$userAddress])) {
$this->balances[$userAddress] = 0.0;
}
$this->balances[$userAddress] += $amount;
// 在真实PHP应用中，这里会执行SQL UPDATE操作，如：
// UPDATE balances SET amount = amount + ? WHERE address = ?
echo "用户 {$userAddress} 存款 {$amount} 单位。当前余额: {$this->balances[$userAddress]}" . PHP_EOL;
}
/**
* 查询余额，模拟Solidity中的`view`函数。
* @param string $userAddress
* @return float
*/
public function getBalance(string $userAddress): float {
return $this->balances[$userAddress] ?? 0.0;
}
}
// 使用示例
$bank = new SimpleBankContract();
$bank->deposit('0xAbc123...', 100.5);
$balance = $bank->getBalance('0xAbc123...');
echo "查询余额: {$balance}" . PHP_EOL;
第二，函数、可见性与状态可变性。 如同PHP类的方法，合约函数定义了可执行的操作。但区块链的公开性和价值传输特性，要求更精细的控制。public/private 控制谁可以调用，这与PHP类似。关键区别在于 状态可变性修饰符：view（承诺不修改状态）和 pure（承诺不读也不修改状态），它们允许以太坊节点免费执行调用，而 payable 关键字则表明该函数可以接收ETH，这是资产交互的基础。此外，修饰器（modifier） 如同PHP的中间件或面向切面编程（AOP），用于在函数执行前进行统一的权限或条件检查（例如“只有合约所有者才能调用”）。
第三，事件（Event）与日志（Log）。 在PHP中，你可能会用Monolog将重要操作记录到文件或ELK栈中。在区块链上，事件是合约将特定操作和结果“打印”到交易日志中的机制。你的PHP后端可以像订阅消息队列一样，监听这些事件，从而异步、可靠地获知链上状态的变化，并触发相应的业务逻辑（如更新本地数据库、发送通知等）。这是智能合约与外部世界（你的PHP应用）通信的主要方式。
/**
* PHP模拟：事件发射与监听机制。
* 模拟智能合约触发事件，以及PHP应用监听并处理该事件的模式。
*/
class EventEmitter {
private $listeners = [];
/**
* 注册事件监听器，模拟web3.php中对合约事件的监听订阅。
* @param string $eventName 事件名称
* @param callable $callback 回调函数
*/
public function on(string $eventName, callable $callback): void {
$this->listeners[$eventName][] = $callback;
}
/**
* 触发事件，模拟智能合约中`emit`关键字的行为。
* @param string $eventName
* @param mixed ...$args 事件参数
*/
public function emit(string $eventName, ...$args): void {
if (isset($this->listeners[$eventName])) {
foreach ($this->listeners[$eventName] as $listener) {
call_user_func_array($listener, $args);
}
}
}
}
// 定义一个“用户注册”事件模拟器
class UserRegistry {
private $emitter;
public function __construct(EventEmitter $emitter) {
$this->emitter = $emitter;
}
public function registerUser(string $address, string $username): void {
// ... 执行注册逻辑（例如写入状态） ...
echo "用户 {$username} ({$address}) 注册成功。" . PHP_EOL;
// **关键步骤：触发一个事件**，相当于Solidity中的 `emit UserRegistered(address, username);`
$this->emitter->emit('UserRegistered', $address, $username, time());
}
}
// --- 应用场景：PHP后端监听并处理事件 ---
$emitter = new EventEmitter();
$registry = new UserRegistry($emitter);
// 模拟PHP DApp后端监听“UserRegistered”事件
$emitter->on('UserRegistered', function(string $address, string $username, int $timestamp) {
// 当监听到事件时，执行以下业务逻辑：
// 1. 将用户信息同步到本地数据库
echo "[监听器] 同步用户 {$username} 到MySQL..." . PHP_EOL;
// 2. 发送欢迎邮件
echo "[监听器] 向 {$username} 发送欢迎邮件..." . PHP_EOL;
// 3. 记录审计日志
echo "[监听器] 审计日志：地址 {$address} 于 " . date('Y-m-d H:i:s', $timestamp) . " 注册。" . PHP_EOL;
});
// 模拟一个链上交易调用合约函数，触发事件
$registry->registerUser('0xDef456...', '区块链先锋');
这些核心概念之间环环相扣，构成了智能合约的骨架。 “状态变量”定义了合约需要永久记住的数据结构，而“函数”则是读写这些数据的唯一途径。函数的“可见性”和“修饰器”确保了数据访问的安全与合规，防止未授权的操作。当关键函数（如转账、状态更新）被执行后，通过“事件”将结果广播出去，从而使得链下的PHP应用能够感知并响应链上的状态变化，完成一个完整的业务闭环。
在实际应用中，这些概念共同作用于几乎所有去中心化场景。例如，在代币合约中，mapping存储余额（状态），transfer函数（需修饰器校验余额）改变状态，并在成功后emit Transfer事件。在去中心化投票系统中，mapping记录投票状态，vote函数（用修饰器确保一人一票且在规定时间内）更新票数，并emit Voted事件。你的PHP应用则通过监听这些事件，实时更新前端界面或将最终结果归档。掌握这些概念，你便掌握了用Solidity为Web3.0世界编写“不可篡改的业务逻辑”的核心能力。
掌握了Solidity的基础语法，如同获得了乐高积木。现在，让我们用PHP作为桥梁，亲手搭建几个通往Web3.0世界的应用。下面的实践案例将带你体验如何与部署在链上的智能合约进行完整交互。
案例一：链上计数器合约交互
这是一个最基础的案例，展示了如何从PHP读取合约状态、发送交易改变状态以及监听事件。
1. Solidity 合约代码 (Counter.sol)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Counter {
uint256 private _count; // 状态变量：计数器
address public owner; // 状态变量：合约所有者
// 事件：当计数器增加时触发
event Incremented(address indexed by, uint256 newCount);
// 构造函数，初始化所有者和计数值
constructor(uint256 initialCount) {
owner = msg.sender;
_count = initialCount;
}
// 公共函数：获取当前计数值（只读，不消耗Gas）
function getCount() public view returns (uint256) {
return _count;
}
// 公共函数：增加计数（需要发送交易，消耗Gas）
// 仅限所有者调用
function increment() public {
require(msg.sender == owner, "Only owner can increment");
_count += 1;
emit Incremented(msg.sender, _count); // 触发事件
}
}
2. PHP 交互实现 (CounterInteraction.php)
<?php
require __DIR__ . '/vendor/autoload.php'; // 假设通过Composer安装了web3.php
use Web3\Web3;
use Web3\Contract;
use Web3\Providers\HttpProvider;
use Web3\RequestManagers\HttpRequestManager;
use kornrunner\Keccak; // 用于事件签名
class CounterInteraction {
private $web3;
private $contract;
private $contractAddress = '0xYourDeployedContractAddressHere';
private $ownerPrivateKey = '0xYourOwnerPrivateKeyHere'; // 警告：实际应用中务必从安全配置中读取，切勿硬编码！
private $ownerAddress;
public function __construct($rpcEndpoint = 'https://sepolia.infura.io/v3/YOUR_INFURA_KEY') {
// 1. 初始化Web3连接
$provider = new HttpProvider(new HttpRequestManager($rpcEndpoint, 10));
$this->web3 = new Web3($provider);
// 2. 从私钥推导出地址
$this->ownerAddress = $this->privateKeyToAddress($this->ownerPrivateKey);
// 3. 加载合约ABI（来自编译后的Counter.sol）
$contractABI = '[{"inputs":[{"internalType":"uint256","name":"initialCount","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":false,"internalType":"uint256","name":"newCount","type":"uint256"}],"name":"Incremented","type":"event"},{"inputs":[],"name":"getCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"increment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]';
// 4. 实例化合约对象
$this->contract = new Contract($this->web3->getProvider(), $contractABI);
$this->contract->at($this->contractAddress);
}
/**
* 从PHP调用合约的view函数（只读）
*/
public function getCurrentCount(): int {
try {
$this->contract->call('getCount', null, function ($err, $result) use (&$count) {
if ($err !== null) {
throw new RuntimeException("调用getCount失败: " . $err->getMessage());
}
// $result 是一个数组，索引0是返回值
$count = (int)$result[0]->toString();
});
return $count ?? 0;
} catch (Exception $e) {
error_log("获取计数错误: " . $e->getMessage());
return 0;
}
}
/**
* 从PHP发送交易，调用increment函数（写操作）
*/
public function incrementCounter(): string {
try {
// 1. 构建原始交易数据
$data = $this->contract->getData('increment');
// 2. 获取当前nonce和gas价格
$nonce = $this->getNonce($this->ownerAddress);
$gasPrice = $this->getGasPrice();
// 3. 估算Gas（对于简单操作，也可以设定一个安全值如200000）
$estimatedGas = $this->estimateGas($data);
// 4. 构建、签名并发送交易
$signedTx = $this->signTransaction([
'nonce' => $nonce,
'gasPrice' => $gasPrice,
'gas' => $estimatedGas,
'to' => $this->contractAddress,
'value' => '0x0',
'data' => $data,
'chainId' => 11155111 // Sepolia测试网Chain ID
], $this->ownerPrivateKey);
$txHash = '';
$this->web3->getEth()->sendRawTransaction('0x' . $signedTx, function ($err, $result) use (&$txHash) {
if ($err !== null) {
throw new RuntimeException("发送交易失败: " . $err->getMessage());
}
$txHash = $result;
});
echo "交易已发送，哈希: $txHash" . PHP_EOL;
// 5. （可选）等待交易被挖出并获取回执
$receipt = $this->waitForTransactionReceipt($txHash);
if ($receipt && isset($receipt['status']) && $receipt['status'] === '0x1') {
echo "交易成功上链！区块号: {$receipt['blockNumber']}" . PHP_EOL;
$this->parseIncrementEvents($receipt); // 解析交易回执中的事件
} else {
echo "交易失败或未被确认。" . PHP_EOL;
}
return $txHash;
} catch (Exception $e) {
error_log("增加计数交易失败: " . $e->getMessage());
throw $e;
}
}
/**
* 监听合约的Incremented事件（使用轮询或WebSocket订阅）
* 这里展示基于新区块轮询的简易监听
*/
public function listenForIncrementEvents($fromBlock = 'latest', $toBlock = 'latest') {
try {
// 事件签名：Incremented(address,uint256)
$eventSignature = 'Incremented(address,uint256)';
$eventTopic = '0x' . Keccak::hash($eventSignature, 256);
// 创建过滤器
$filterId = null;
$this->web3->getEth()->newFilter([
'fromBlock' => $fromBlock,
'toBlock' => $toBlock,
'address' => $this->contractAddress,
'topics' => [$eventTopic] // 只监听此事件
], function ($err, $result) use (&$filterId) {
if ($err !== null) throw $err;
$filterId = $result;
});
if (!$filterId) {
throw new RuntimeException("创建事件过滤器失败");
}
echo "开始监听 Incremented 事件..." . PHP_EOL;
// 模拟轮询（实际生产环境建议使用WebSocket或更高效的轮询库）
while (true) {
sleep(5); // 每5秒检查一次
$logs = [];
$this->web3->getEth()->getFilterLogs($filterId, function ($err, $result) use (&$logs) {
if ($err !== null) {
error_log("获取日志失败: " . $err->getMessage());
return;
}
$logs = $result;
});
foreach ($logs as $log) {
$this->decodeAndProcessIncrementEvent($log);
}
}
} catch (Exception $e) {
error_log("监听事件失败: " . $e->getMessage());
}
}
// --- 以下为辅助方法，实际项目应考虑使用更完整的库（如ethereum-php）处理 ---
private function privateKeyToAddress($privateKey) { /* 实现私钥到地址的转换 */ }
private function getNonce($address) { /* 获取地址的nonce */ }
private function getGasPrice() { /* 获取当前Gas价格 */ }
private function estimateGas($data) { /* 估算交易所需Gas */ }
private function signTransaction($txParams, $privateKey) { /* 签名交易 */ }
private function waitForTransactionReceipt($txHash) { /* 等待交易收据 */ }
private function parseIncrementEvents($receipt) {
// 从收据的logs中解析出Incremented事件
$eventSignature = 'Incremented(address,uint256)';
$eventTopic = '0x' . Keccak::hash($eventSignature, 256);
foreach ($receipt['logs'] as $log) {
if ($log['topics'][0] === $eventTopic) {
$by = '0x' . substr($log['topics'][1], 26); // 解码 indexed 参数
// 解码非 indexed 参数 (newCount)，这里需要ABI解码逻辑
// 假设我们有一个解码器
// $decoded = $this->contract->decodeEventLog('Incremented', $log);
// $newCount = $decoded['newCount'];
echo "[PHP 事件处理器] 计数器被地址 {$by} 增加。" . PHP_EOL;
}
}
}
private function decodeAndProcessIncrementEvent($log) {
// 解码和处理通过过滤器得到的日志
echo "[PHP 事件监听器] 监听到链上计数器增加事件！" . PHP_EOL;
// 详细解码逻辑...
}
}
// ==================== 使用示例 ====================
echo "案例一：链上计数器交互" . PHP_EOL;
$counterApp = new CounterInteraction();
// 1. 读取当前计数
$currentCount = $counterApp->getCurrentCount();
echo "当前链上计数: $currentCount" . PHP_EOL;
// 2. 发送交易增加计数 (需要等待和Gas)
// $txHash = $counterApp->incrementCounter();
// 3. 再次读取，确认更新 (由于区块确认延迟，可能需要稍等片刻)
// sleep(10);
// $newCount = $counterApp->getCurrentCount();
// echo "增加后的链上计数: $newCount" . PHP_EOL;
// 4. 启动一个简单的事件监听进程（在后台运行）
// pcntl_fork() 或使用进程管理工具来运行以下代码
// $counterApp->listenForIncrementEvents('latest', 'latest');
输入/输出示例：
当前链上计数: 5
交易已发送，哈希: 0xabc123def456...
交易成功上链！区块号: 0x3a4f2c
[PHP 事件处理器] 计数器被地址 0xYourOwnerAddress 增加。
（等待后...）
增加后的链上计数: 6
[PHP 事件监听器] 监听到链上计数器增加事件！
常见问题与解决方案：
- Q：交易为什么一直处于pending状态？
- A：检查Gas价格是否设置过低，在测试网可以使用
getGasPrice获取建议值并适当提高。同时确认nonce值是否正确。
- A：检查Gas价格是否设置过低，在测试网可以使用
- Q：调用
call方法时返回空或错误？- A：确保合约地址和ABI完全正确。对于view函数，调用者地址（默认为
0x0）通常不影响，但某些函数可能有权限检查。
- A：确保合约地址和ABI完全正确。对于view函数，调用者地址（默认为
- Q：如何高效监听事件而不阻塞主程序？
- A：轮询（如示例）效率低且延迟高。生产环境应使用WebSocket订阅（如果节点支持），或使用专门的事件监听服务如The Graph，或者将监听逻辑放入独立的常驻PHP进程（如使用Swoole、Workerman或PHP的CLI模式配合进程守护）。
案例二：与ERC20代币合约交互
这是DeFi的基础，我们将使用标准的OpenZeppelin ERC20合约。
1. Solidity 合约代码 (使用OpenZeppelin库)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MyToken is ERC20 {
constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
_mint(msg.sender, initialSupply);
}
}
2. PHP 交互实现 (ERC20Interaction.php)
<?php
require __DIR__ . '/vendor/autoload.php';
// 假设有类似的Web3和工具类初始化
use Web3\Contract;
class ERC20Interaction {
private $contract;
private $web3;
private $tokenAddress = '0xYourDeployedTokenAddressHere';
public function __construct($web3Instance) {
$this->web3 = $web3Instance;
$erc20ABI = '[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],...}]'; // 完整的ERC20 ABI很长，应从编译结果获取
$this->contract = new Contract($this->web3->getProvider(), $erc20ABI);
$this->contract->at($this->tokenAddress);
}
/**
* 查询代币信息
*/
public function getTokenInfo(): array {
$name = $symbol = $totalSupply = '';
$this->contract->call('name', null, function ($err, $result) use (&$name) {
if (!$err) $name = $result[0];
});
$this->contract->call('symbol', null, function ($err, $result) use (&$symbol) {
if (!$err) $symbol = $result[0];
});
$this->contract->call('totalSupply', null, function ($err, $result) use (&$totalSupply) {
if (!$err) $totalSupply = $result[0]->toString();
});
return [
'name' => $name,
'symbol' => $symbol,
'totalSupply' => $totalSupply
];
}
/**
* 查询地址余额
*/
public function getBalanceOf(string $address): string {
$balance = '0';
$this->contract->call('balanceOf', $address, function ($err, $result) use (&$balance) {
if ($err !== null) {
throw new RuntimeException("查询余额失败: " . $err->getMessage());
}
$balance = $result[0]->toString();
});
return $balance;
}
/**
* 发起转账交易 (from PHP脚本控制的地址 to 目标地址)
*/
public function transfer(string $fromPrivateKey, string $toAddress, string $amount): string {
// 1. 构建transfer函数调用数据
// amount需要转换为合约单位的最小精度 (例如乘以10^18)
$decimals = $this->getDecimals();
$amountInWei = bcmul($amount, bcpow('10', $decimals));
$data = $this->contract->getData('transfer', $toAddress, $amountInWei);
// 2. 发送签名交易（复用案例一的交易构建和发送逻辑）
$txSender = new TransactionSender($this->web3); // 假设有一个封装好的交易发送类
$txHash = $txSender->sendSignedTransaction($fromPrivateKey, [
'to' => $this->tokenAddress,
'data' => $data,
// nonce, gasPrice, gasLimit 由TransactionSender内部处理
]);
echo "ERC20 转账交易已发送，哈希: $txHash" . PHP_EOL;
return $txHash;
}
private function getDecimals(): int {
$decimals = 18; // 默认
$this->contract->call('decimals', null, function ($err, $result) use (&$decimals) {
if (!$err) $decimals = (int)$result[0]->toString();
});
return $decimals;
}
}
// ==================== 使用示例 ====================
echo PHP_EOL . "案例二：ERC20代币交互" . PHP_EOL;
$erc20 = new ERC20Interaction($web3); // 传入已初始化的$web3对象
// 1. 查询代币信息
$info = $erc20->getTokenInfo();
echo "代币名称: {$info['name']}, 符号: {$info['symbol']}, 总供应量: {$info['totalSupply']}" . PHP_EOL;
// 2. 查询某个地址的余额 (例如: 0x123...)
$balance = $erc20->getBalanceOf('0x1234567890123456789012345678901234567890');
echo "地址余额: " . $balance . " 个最小单位" . PHP_EOL;
// 转换为可读单位
$readableBalance = bcdiv($balance, bcpow('10', 18), 6);
echo "可读余额: $readableBalance MTK" . PHP_EOL;
// 3. 从脚本控制的账户转账 (需要私钥和Gas)
// $txHash = $erc20->transfer('0xYourPrivateKey', '0xRecipientAddress', '10.5'); // 转账10.5个MTK
输入/输出示例：
代币名称: MyToken, 符号: MTK, 总供应量: 1000000000000000000000000
地址余额: 50000000000000000000
可读余额: 50.000000 MTK
ERC20 转账交易已发送，哈希: 0x789012abc345...
常见问题与解决方案：
- Q：余额查询返回的数字非常大且难以理解？
- A：这是代币的最小单位（如Wei之于ETH）。必须查询合约的
decimals()函数（通常是18），然后进行换算：实际数量 = 查询结果 / 10^decimals。
- A：这是代币的最小单位（如Wei之于ETH）。必须查询合约的
- Q：转账交易成功了，但对方没收到代币？
- A：首先在区块浏览器查询交易详情，确认
status为成功，且logs里包含Transfer事件。最可能的原因是接收地址是合约地址，但该合约没有实现接收ERC20代币的逻辑（如IERC20Receiver接口），导致代币被锁定。永远先向普通地址（EOA）进行测试转账。
- A：首先在区块浏览器查询交易详情，确认
- Q：如何批量查询多个地址的余额？
- A：逐个
call效率极低。最佳实践是：1) 在智能合约中编写一个返回数组的view函数（对于大量地址可能超Gas限制）；2) 使用多调用（Multicall） 合约将多个静态调用打包成一个；3) 使用索引服务（如The Graph）预先索引并暴露API。
- A：逐个
案例三：去中心化投票系统合约交互
这个案例结合了结构体、映射和复杂事件。
1. Solidity 合约代码 (SimpleVoting.sol)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract SimpleVoting {
struct Proposal {
string description;
uint voteCount;
}
Proposal[] public proposals;
mapping(address => bool) public voters; // 记录已投票地址
address public chairperson;
bool public votingClosed;
event Voted(address indexed voter, uint proposalId);
event VotingClosed();
constructor(string[] memory proposalDescriptions) {
chairperson = msg.sender;
for (uint i = 0; i < proposalDescriptions.length; i++) {
proposals.push(Proposal({
description: proposalDescriptions[i],
voteCount: 0
}));
}
}
modifier onlyChairperson() {
require(msg.sender == chairperson, "Only chairperson can do this");
_;
}
function vote(uint proposalId) public {
require(!votingClosed, "Voting is closed");
require(!voters[msg.sender], "Already voted");
require(proposalId < proposals.length, "Invalid proposal");
voters[msg.sender] = true;
proposals[proposalId].voteCount += 1;
emit Voted(msg.sender, proposalId);
}
function closeVoting() public onlyChairperson {
require(!votingClosed, "Already closed");
votingClosed = true;
emit VotingClosed();
}
function getProposals() public view returns (Proposal[] memory) {
return proposals;
}
}
2. PHP 交互实现 (VotingSystemInteraction.php)
<?php
require __DIR__ . '/vendor/autoload.php';
class VotingSystemInteraction {
private $contract;
private $web3;
private $contractAddress = '0xYourDeployedVotingAddressHere';
public function __construct($web3Instance) {
$this->web3 = $web3Instance;
$votingABI = '[...]'; // 从编译后的Voting.sol获取完整ABI
$this->contract = new Contract($this->web3->getProvider(), $votingABI);
$this->contract->at($this->contractAddress);
}
/**
* 获取所有提案详情
*/
public function getAllProposals(): array {
$proposalsData = [];
// 注意：返回结构体数组的view函数在旧版本web3.php中可能需要特殊处理
// 这里假设合约有一个返回简单格式（如描述和票数分开）或我们已知提案数量的变通方法
$proposalCount = 0;
// 首先，可能需要一个函数来获取提案数量，或者我们通过事件日志来推断。
// 作为示例，我们假设我们知道有3个提案，并逐个获取（实际不推荐）
for ($i = 0; $i < 3; $i++) {
$desc = ''; $count = 0;
$this->contract->call('proposals', $i, function ($err, $result) use (&$desc, &$count) {
if (!$err) {
// 解码结构体，$result[0] 是 description, $result[1] 是 voteCount
$desc = $result[0];
$count = (int)$result[1]->toString();
}
});
if (!empty($desc)) {
$proposalsData[] = ['id' => $i, 'description' => $desc, 'voteCount' => $count];
}
}
return $proposalsData;
}
/**
* 检查地址是否已投票
*/
public function hasVoted(string $address): bool {
$hasVoted = false;
$this->contract->call('voters', $address, function ($err, $result) use (&$hasVoted) {
if (!$err) $hasVoted = (bool)$result[0];
});
return $hasVoted;
}
/**
* 执行投票（发送交易）
*/
public function castVote(string $voterPrivateKey, int $proposalId): string {
$data = $this->contract->getData('vote', $proposalId);
$txSender = new TransactionSender($this->web3);
$txHash = $txSender->sendSignedTransaction($voterPrivateKey, [
'to' => $this->contractAddress,
'data' => $data,
]);
echo "投票交易已发送，哈希: $txHash (投给提案#$proposalId)" . PHP_EOL;
return $txHash;
}
/**
* 获取投票最终结果（在投票结束后）
*/
public function getResults(): array {
$proposals = $this->getAllProposals();
usort($proposals, function($a, $b) {
return $b['voteCount'] <=> $a['voteCount'];
});
return $proposals;
}
}
// ==================== 使用示例 ====================
echo PHP_EOL . "案例三：去中心化投票系统" . PHP_EOL;
$voting = new VotingSystemInteraction($web3);
// 1. 获取提案列表
$proposals = $voting->getAllProposals();
echo "当前提案列表：" . PHP_EOL;
foreach ($proposals as $proposal) {
echo " [提案#{$proposal['id']}] {$proposal['description']} - 票数: {$proposal['voteCount']}" . PHP_EOL;
}
// 2. 检查某个地址（如0xABC...）是否已投票
$checkAddress = '0xABC123...';
if ($voting->hasVoted($checkAddress)) {
echo "地址 $checkAddress 已投票。" . PHP_EOL;
} else {
echo "地址 $checkAddress 尚未投票。" . PHP_EOL;
}
// 3. 模拟一个投票者进行投票（假设投票给提案0）
// $voterKey = '0xVoterPrivateKey...';
// $txHash = $voting->castVote($voterKey, 0);
// 4. 获取并展示最终结果（假设投票已结束）
// $results = $voting->getResults();
// echo "最终投票结果（按票数排序）：" . PHP_EOL;
// foreach ($results as $result) {
// echo " {$result['description']}: {$result['voteCount']} 票" . PHP_EOL;
// }
输入/输出示例：
当前提案列表：
[提案#0] 支持方案A - 票数: 42
[提案#1] 支持方案B - 票数: 18
[提案#2] 弃权 - 票数: 5
地址 0xABC123... 尚未投票。
投票交易已发送，哈希: 0xdef456... (投给提案#0)
（交易确认后，再次查询）
当前提案列表：
[提案#0] 支持方案A - 票数: 43 <- 票数增加了！
[提案#1] 支持方案B - 票数: 18
[提案#2] 弃权 - 票数: 5
常见问题与解决方案：
- Q：
getAllProposals()方法为什么用循环，且提案数量是硬编码的？- A：这是一个关键限制。Solidity的公共状态变量
proposals虽然标记为public，会生成一个proposals(uint256)的getter函数，但它只能通过索引单个查询。合约本身没有返回数组长度或整个数组的view函数。最佳解决方案是在智能合约中添加一个getProposalCount和getAllProposalData函数，或者在PHP端通过监听Voted事件来构建和维护提案状态的本地缓存，这才是去中心化应用（DApp）后端的标准做法。
- A：这是一个关键限制。Solidity的公共状态变量
- Q：如何防止用户重复投票？
- A：示例合约已经通过
voters映射和require实现了链上防重。PHP后端在用户请求投票时，可以先调用hasVoted进行预检查，提供即时反馈，但最终的安全保障仍然在链上。
- A：示例合约已经通过
- Q：如何让投票结果页面实时更新？
- A：PHP后端无法“推送”更新给浏览器。标准架构是：1) PHP提供初始数据API；2) 前端（JavaScript）使用Web3.js或Ethers.js直接连接用户钱包和区块链节点（如Infura）；3) 前端监听
Voted事件并自动更新界面票数。PHP后端更多地用于处理与用户身份关联的非链上逻辑（如登录会话）和复杂数据聚合。
- A：PHP后端无法“推送”更新给浏览器。标准架构是：1) PHP提供初始数据API；2) 前端（JavaScript）使用Web3.js或Ethers.js直接连接用户钱包和区块链节点（如Infura）；3) 前端监听
通过这些案例，你已看到PHP在Web3.0开发中扮演着关键的后台角色：管理服务器自有密钥进行自动操作、监听和索引链上事件以更新本地数据库、提供安全的API接口供前端查询聚合信息，以及在需要信任的场合作为中继。将链上不可篡改的逻辑与链下灵活高效的业务处理相结合，正是构建成熟DApp的精髓。
本章通过一个完整的投票DApp案例，深入探讨了PHP在智能合约驱动应用中的核心角色。作为主要后端语言，PHP并非直接编写链上逻辑，而是充当区块链世界与传统Web应用之间的关键桥梁，其核心职责是管理服务器端操作、处理链下数据并与智能合约安全交互。
您需要掌握的关键技能包括：使用web3.php等库连接以太坊节点（如Infura或自建Geth节点），构建并发送签署交易以调用合约的写方法（如vote），以及调用只读方法查询状态（如getAllProposals的循环查询）。一个至关重要的技能是监听并处理链上事件（如Voted），这是实现数据实时索引和本地数据库同步的标准范式。此外，管理用于支付Gas费用的服务器账户私钥（必须高度安全，如使用环境变量或硬件安全模块），并设计面向前端的安全API，聚合链上与链下数据，构成了PHP后端开发者的核心工作流。
基于此，我们建议的实践路径是：首先，将服务器私钥视为最高机密，绝不硬编码在源码中。其次，积极建议智能合约开发者添加返回数组长度和批量数据的视图函数，以显著减轻PHP后端的查询负担。在应用架构上，应采用“PHP后端服务+前端直接链交互”的混合模式：PHP负责用户会话、复杂业务逻辑、事件历史数据提供及需要信任的签名提交；而实时状态更新和用户直接投票交易则应交给前端JavaScript通过Web3.js库与用户钱包交互完成，这既确保了安全，又提升了用户体验。
回顾常见问题，其解决方案清晰勾勒了最佳实践：针对合约数据查询限制，首要方案是优化合约设计，次要方案是在PHP层建立基于事件监听的数据缓存。防重投票机制体现了链上验证为最终仲裁，PHP可做前置检查以提升友好性。而实时更新的需求，则直接印证了上述前后端职责分离架构的必要性——PHP提供初始和聚合数据，前端负责监听事件和更新UI。总而言之，精通PHP在Web3.0中的开发，意味着深刻理解并实践其作为“链下服务层”的定位，高效、安全地连接智能合约的确定性逻辑与灵活多变的业务需求。
扫一扫
1676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
