Solidity中的访问控制：保护你的智能合约

天涯学馆
发布于 1天前
阅读 204

在以太坊智能合约开发中，访问控制是确保合约安全性的核心机制。未经适当的访问控制，合约可能面临未经授权的操作、数据泄露或资金损失等风险。Solidity提供了多种工具和模式（如函数修饰器、角色管理和权限检查）来实现访问控制。访问控制的重要性为什么需要访问控制？智能合约运行在公开的区块链上，任何

在以太坊智能合约开发中，访问控制是确保合约安全性的核心机制。未经适当的访问控制，合约可能面临未经授权的操作、数据泄露或资金损失等风险。Solidity 提供了多种工具和模式（如函数修饰器、角色管理和权限检查）来实现访问控制。

## 访问控制的重要性

### 为什么需要访问控制？

智能合约运行在公开的区块链上，任何人都可以调用公开函数或访问公开数据。没有访问控制，恶意用户可能：
- 执行受限操作（如提取资金、修改配置）。
- 访问敏感数据（如用户余额、合约参数）。
- 破坏合约逻辑（如更改所有者、暂停合约）。

### 常见风险
- **未经授权的访问**：任何用户调用关键函数。
- **权限提升**：用户通过漏洞获得更高权限。
- **重入攻击**：恶意合约通过递归调用窃取资金。
- **错误配置**：管理员错误设置权限，导致漏洞。

### Solidity 的访问控制工具
- **函数可见性**：`public`, `private`, `internal`, `external`。
- **修饰器（Modifier）**：限制函数调用条件。
- **角色管理**：通过映射或库实现权限分配。
- **事件日志**：记录权限变更，便于审计。

---

## 实现访问控制

### 函数可见性

Solidity 提供四种函数可见性修饰符，控制谁可以调用函数：
- **public**：任何地址（包括外部用户和合约）都可以调用。
- **external**：仅外部地址可以调用，优化 Gas。
- **internal**：仅本合约及其子合约可以调用。
- **private**：仅本合约内部可以调用。

**示例：使用可见性控制**
```solidity

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

contract VisibilityControl {
    uint256 private sensitiveData;
    address public owner;

constructor() {
        owner = msg.sender;
        sensitiveData = 100;
    }

// 仅本合约内部访问
    function getSensitiveData() private view returns (uint256) {
        return sensitiveData;
    }

// 本合约及其子合约访问
    function updateData(uint256 value) internal {
        sensitiveData = value;
    }

// 外部调用
    function getOwner() external view returns (address) {
        return owner;
    }

// 公开调用，但限制为 owner
    function setData(uint256 value) public {
        require(msg.sender == owner, "Not owner");
        updateData(value);
    }
}

```

**说明**：
- `sensitiveData` 使用 `private`，防止外部访问。
- `getSensitiveData` 是 `private`，仅内部使用。
- `updateData` 是 `internal`，允许子合约调用。
- `setData` 使用 `require` 限制为 `owner`，实现基本访问控制。

### 函数修饰器（Modifier）

修饰器是 Solidity 的强大工具，用于封装访问控制逻辑，减少代码重复。

**示例：Owner 修饰器**
```solidity

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

contract OwnerModifier {
    address public owner;
    uint256 public data;

event DataUpdated(address indexed updater, uint256 value);

modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

constructor() {
        owner = msg.sender;
    }

function updateData(uint256 value) public onlyOwner {
        data = value;
        emit DataUpdated(msg.sender, value);
    }

function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Invalid address");
        owner = newOwner;
    }
}

```

**说明**：
- `onlyOwner` 修饰器确保只有 `owner` 可以调用函数。
- `updateData` 和 `transferOwnership` 使用 `onlyOwner` 限制访问。
- `emit DataUpdated` 记录操作，便于审计。

**测试用例**：
```javascript

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

describe("OwnerModifier", function () {
    let OwnerModifier, contract, owner, user;

beforeEach(async function () {
        OwnerModifier = await ethers.getContractFactory("OwnerModifier");
        [owner, user] = await ethers.getSigners();
        contract = await OwnerModifier.deploy();
        await contract.deployed();
    });

it("should allow owner to update data", async function () {
        await expect(contract.connect(owner).updateData(100))
            .to.emit(contract, "DataUpdated")
            .withArgs(owner.address, 100);
        expect(await contract.data()).to.equal(100);
    });

it("should revert if non-owner updates data", async function () {
        await expect(contract.connect(user).updateData(100))
            .to.be.revertedWith("Not owner");
    });

it("should transfer ownership", async function () {
        await contract.connect(owner).transferOwnership(user.address);
        expect(await contract.owner()).to.equal(user.address);
    });
});

```

**运行测试**：
```bash
npx hardhat test
```

**注意**：
- `modifier` 提高代码复用性，但避免过度嵌套。
- 使用事件记录权限变更，便于跟踪。

### 角色管理

对于复杂合约（如 DAO 或 DeFi 协议），需要多角色管理。OpenZeppelin 的 `AccessControl` 库提供了灵活的角色管理机制。

**示例：使用 AccessControl**
```solidity

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

import "@openzeppelin/contracts/access/AccessControl.sol";

contract RoleBasedControl is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant USER_ROLE = keccak256("USER_ROLE");
    uint256 public data;

event DataUpdated(address indexed updater, uint256 value);

constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }

function updateData(uint256 value) public onlyRole(ADMIN_ROLE) {
        data = value;
        emit DataUpdated(msg.sender, value);
    }

function addUser(address user) public onlyRole(ADMIN_ROLE) {
        grantRole(USER_ROLE, user);
    }

function readData() public view onlyRole(USER_ROLE) returns (uint256) {
        return data;
    }
}

```

**说明**：
- 使用 OpenZeppelin 的 `AccessControl`，定义 `ADMIN_ROLE` 和 `USER_ROLE`。
- `onlyRole` 修饰器限制函数访问。
- `grantRole` 动态分配角色，`DEFAULT_ADMIN_ROLE` 管理权限。

**测试用例**：
```javascript

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

describe("RoleBasedControl", function () {
    let RoleBasedControl, contract, owner, admin, user;

beforeEach(async function () {
        RoleBasedControl = await ethers.getContractFactory("RoleBasedControl");
        [owner, admin, user] = await ethers.getSigners();
        contract = await RoleBasedControl.deploy();
        await contract.deployed();
    });

it("should allow admin to update data", async function () {
        await contract.connect(owner).addUser(admin.address);
        await expect(contract.connect(admin).updateData(100))
            .to.emit(contract, "DataUpdated")
            .withArgs(admin.address, 100);
        expect(await contract.data()).to.equal(100);
    });

it("should revert if non-admin updates data", async function () {
        await expect(contract.connect(user).updateData(100))
            .to.be.revertedWith("AccessControl: account is missing role");
    });

it("should allow user to read data", async function () {
        await contract.connect(owner).addUser(user.address);
        await contract.connect(owner).updateData(100);
        expect(await contract.connect(user).readData()).to.equal(100);
    });
});

```

**安装 OpenZeppelin**：
```bash
npm install @openzeppelin/contracts
```

**说明**：
- `AccessControl` 支持多角色管理，适合复杂系统。
- `keccak256` 生成角色 ID，确保唯一性。
- 角色可动态分配和撤销，灵活性高。

### 暂停机制

暂停机制允许管理员在紧急情况下暂停合约，防止进一步操作。

**示例：Pausable 合约**
```solidity

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

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

contract PausableContract is Pausable, Ownable {
    uint256 public balance;

event Deposited(address indexed user, uint256 amount);

constructor() Ownable(msg.sender) {}

function deposit() public payable whenNotPaused {
        balance += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

function pause() public onlyOwner {
        _pause();
    }

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

```

**说明**：
- 使用 OpenZeppelin 的 `Pausable` 和 `Ownable`。
- `whenNotPaused` 修饰器限制 `deposit` 在暂停时不可用。
- `pause` 和 `unpause` 由 `owner` 控制。

**测试用例**：
```javascript

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

describe("PausableContract", function () {
    let PausableContract, contract, owner, user;

beforeEach(async function () {
        PausableContract = await ethers.getContractFactory("PausableContract");
        [owner, user] = await ethers.getSigners();
        contract = await PausableContract.deploy();
        await contract.deployed();
    });

it("should allow deposit when not paused", async function () {
        await expect(contract.connect(user).deposit({ value: ethers.parseEther("1") }))
            .to.emit(contract, "Deposited")
            .withArgs(user.address, ethers.parseEther("1"));
        expect(await contract.balance()).to.equal(ethers.parseEther("1"));
    });

it("should revert deposit when paused", async function () {
        await contract.connect(owner).pause();
        await expect(contract.connect(user).deposit({ value: ethers.parseEther("1") }))
            .to.be.revertedWith("Pausable: paused");
    });

it("should allow unpause and deposit", async function () {
        await contract.connect(owner).pause();
        await contract.connect(owner).unpause();
        await contract.connect(user).deposit({ value: ethers.parseEther("1") });
        expect(await contract.balance()).to.equal(ethers.parseEther("1"));
    });
});

```

**说明**：
- 测试验证暂停和恢复功能。
- `Pausable` 提供标准化的暂停逻辑。

---

## 综合案例：安全的 DeFi 存款合约

以下是一个结合访问控制、安全数学运算和暂停机制的 DeFi 存款合约。

```solidity

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

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

contract SecureDeposit is AccessControl, Pausable, ReentrancyGuard {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    uint256 public constant DECIMAL_PRECISION = 1e18;
    mapping(address => uint256) public balances;
    uint256 public totalDeposits;

event Deposited(address indexed user, uint256 amount, uint256 scaledAmount);
    event Withdrawn(address indexed user, uint256 amount);

error InsufficientBalance();
    error InvalidAmount();

constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }

function deposit(uint256 amount, uint256 interestRate) public payable nonReentrant whenNotPaused {
        if (amount == 0 || msg.value != amount) revert InvalidAmount();
        
        // 安全数学运算：计算带利息的存款
        uint256 scaledAmount = (amount * interestRate) / DECIMAL_PRECISION;
        
        balances[msg.sender] += scaledAmount;
        totalDeposits += scaledAmount; // 内置溢出检查
        
        emit Deposited(msg.sender, amount, scaledAmount);
    }

function withdraw(uint256 amount) public nonReentrant whenNotPaused {
        if (amount > balances[msg.sender]) revert InsufficientBalance();
        
        balances[msg.sender] -= amount;
        totalDeposits -= amount; // 内置下溢检查
        
        payable(msg.sender).transfer(amount);
        emit Withdrawn(msg.sender, amount);
    }

function pause() public onlyRole(ADMIN_ROLE) {
        _pause();
    }

function unpause() public onlyRole(ADMIN_ROLE) {
        _unpause();
    }

function addAdmin(address newAdmin) public onlyRole(DEFAULT_ADMIN_ROLE) {
        grantRole(ADMIN_ROLE, newAdmin);
    }
}

```

**说明**：
- 使用 `AccessControl` 实现多管理员管理。
- `Pausable` 提供暂停功能，防止紧急情况下的操作。
- `ReentrancyGuard` 防止重入攻击。
- 安全数学运算处理利息计算。
- 事件记录存款和取款，便于审计。

**测试用例**：
```javascript

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

describe("SecureDeposit", function () {
    let SecureDeposit, contract, owner, admin, user;

beforeEach(async function () {
        SecureDeposit = await ethers.getContractFactory("SecureDeposit");
        [owner, admin, user] = await ethers.getSigners();
        contract = await SecureDeposit.deploy();
        await contract.deployed();
    });

it("should allow deposit with interest", async function () {
        const amount = ethers.parseEther("1");
        const interestRate = ethers.parseUnits("1.1", 18); // 1.1x
        await expect(contract.connect(user).deposit(amount, interestRate, { value: amount }))
            .to.emit(contract, "Deposited")
            .withArgs(user.address, amount, ethers.parseUnits("1.1", 18));
        expect(await contract.balances(user.address)).to.equal(ethers.parseUnits("1.1", 18));
    });

it("should revert deposit when paused", async function () {
        await contract.connect(owner).pause();
        await expect(contract.connect(user).deposit(ethers.parseEther("1"), ethers.parseUnits("1", 18), { value: ethers.parseEther("1") }))
            .to.be.revertedWith("Pausable: paused");
    });

it("should allow admin to pause", async function () {
        await contract.connect(owner).addAdmin(admin.address);
        await contract.connect(admin).pause();
        expect(await contract.paused()).to.be.true;
    });

it("should revert if non-admin pauses", async function () {
        await expect(contract.connect(user).pause())
            .to.be.revertedWith("AccessControl: account is missing role");
    });

it("should withdraw correctly", async function () {
        const amount = ethers.parseEther("1");
        await contract.connect(user).deposit(amount, ethers.parseUnits("1", 18), { value: amount });
        await expect(contract.connect(user).withdraw(amount))
            .to.emit(contract, "Withdrawn")
            .withArgs(user.address, amount);
        expect(await contract.balances(user.address)).to.equal(0);
    });
});

```

**运行测试**：
```bash
npx hardhat test
```

**说明**：
- 测试覆盖存款、取款、暂停和角色管理。
- 验证事件触发和权限控制。
- 确保安全数学运算和重入保护有效。

访问控制的重要性

为什么需要访问控制？

智能合约运行在公开的区块链上，任何人都可以调用公开函数或访问公开数据。没有访问控制，恶意用户可能：

执行受限操作（如提取资金、修改配置）。
访问敏感数据（如用户余额、合约参数）。
破坏合约逻辑（如更改所有者、暂停合约）。

常见风险

未经授权的访问：任何用户调用关键函数。
权限提升：用户通过漏洞获得更高权限。
重入攻击：恶意合约通过递归调用窃取资金。
错误配置：管理员错误设置权限，导致漏洞。

Solidity 的访问控制工具

函数可见性：public, private, internal, external。
修饰器（Modifier）：限制函数调用条件。
角色管理：通过映射或库实现权限分配。
事件日志：记录权限变更，便于审计。

实现访问控制

函数可见性

Solidity 提供四种函数可见性修饰符，控制谁可以调用函数：

public：任何地址（包括外部用户和合约）都可以调用。
external：仅外部地址可以调用，优化 Gas。
internal：仅本合约及其子合约可以调用。
private：仅本合约内部可以调用。

示例：使用可见性控制


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

contract VisibilityControl {
    uint256 private sensitiveData;
    address public owner;

    constructor() {
        owner = msg.sender;
        sensitiveData = 100;
    }

    // 仅本合约内部访问
    function getSensitiveData() private view returns (uint256) {
        return sensitiveData;
    }

    // 本合约及其子合约访问
    function updateData(uint256 value) internal {
        sensitiveData = value;
    }

    // 外部调用
    function getOwner() external view returns (address) {
        return owner;
    }

    // 公开调用，但限制为 owner
    function setData(uint256 value) public {
        require(msg.sender == owner, "Not owner");
        updateData(value);
    }
}

说明：

sensitiveData 使用 private，防止外部访问。
getSensitiveData 是 private，仅内部使用。
updateData 是 internal，允许子合约调用。
setData 使用 require 限制为 owner，实现基本访问控制。

函数修饰器（Modifier）

修饰器是 Solidity 的强大工具，用于封装访问控制逻辑，减少代码重复。

示例：Owner 修饰器


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

contract OwnerModifier {
    address public owner;
    uint256 public data;

    event DataUpdated(address indexed updater, uint256 value);

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function updateData(uint256 value) public onlyOwner {
        data = value;
        emit DataUpdated(msg.sender, value);
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Invalid address");
        owner = newOwner;
    }
}

说明：

onlyOwner 修饰器确保只有 owner 可以调用函数。
updateData 和 transferOwnership 使用 onlyOwner 限制访问。
emit DataUpdated 记录操作，便于审计。

测试用例：


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

describe("OwnerModifier", function () {
    let OwnerModifier, contract, owner, user;

    beforeEach(async function () {
        OwnerModifier = await ethers.getContractFactory("OwnerModifier");
        [owner, user] = await ethers.getSigners();
        contract = await OwnerModifier.deploy();
        await contract.deployed();
    });

    it("should allow owner to update data", async function () {
        await expect(contract.connect(owner).updateData(100))
            .to.emit(contract, "DataUpdated")
            .withArgs(owner.address, 100);
        expect(await contract.data()).to.equal(100);
    });

    it("should revert if non-owner updates data", async function () {
        await expect(contract.connect(user).updateData(100))
            .to.be.revertedWith("Not owner");
    });

    it("should transfer ownership", async function () {
        await contract.connect(owner).transferOwnership(user.address);
        expect(await contract.owner()).to.equal(user.address);
    });
});

运行测试：

npx hardhat test

注意：

modifier 提高代码复用性，但避免过度嵌套。
使用事件记录权限变更，便于跟踪。

角色管理

对于复杂合约（如 DAO 或 DeFi 协议），需要多角色管理。OpenZeppelin 的 AccessControl 库提供了灵活的角色管理机制。

示例：使用 AccessControl


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

import "@openzeppelin/contracts/access/AccessControl.sol";

contract RoleBasedControl is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant USER_ROLE = keccak256("USER_ROLE");
    uint256 public data;

    event DataUpdated(address indexed updater, uint256 value);

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }

    function updateData(uint256 value) public onlyRole(ADMIN_ROLE) {
        data = value;
        emit DataUpdated(msg.sender, value);
    }

    function addUser(address user) public onlyRole(ADMIN_ROLE) {
        grantRole(USER_ROLE, user);
    }

    function readData() public view onlyRole(USER_ROLE) returns (uint256) {
        return data;
    }
}

说明：

使用 OpenZeppelin 的 AccessControl，定义 ADMIN_ROLE 和 USER_ROLE。
onlyRole 修饰器限制函数访问。
grantRole 动态分配角色，DEFAULT_ADMIN_ROLE 管理权限。

测试用例：


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

describe("RoleBasedControl", function () {
    let RoleBasedControl, contract, owner, admin, user;

    beforeEach(async function () {
        RoleBasedControl = await ethers.getContractFactory("RoleBasedControl");
        [owner, admin, user] = await ethers.getSigners();
        contract = await RoleBasedControl.deploy();
        await contract.deployed();
    });

    it("should allow admin to update data", async function () {
        await contract.connect(owner).addUser(admin.address);
        await expect(contract.connect(admin).updateData(100))
            .to.emit(contract, "DataUpdated")
            .withArgs(admin.address, 100);
        expect(await contract.data()).to.equal(100);
    });

    it("should revert if non-admin updates data", async function () {
        await expect(contract.connect(user).updateData(100))
            .to.be.revertedWith("AccessControl: account is missing role");
    });

    it("should allow user to read data", async function () {
        await contract.connect(owner).addUser(user.address);
        await contract.connect(owner).updateData(100);
        expect(await contract.connect(user).readData()).to.equal(100);
    });
});

安装 OpenZeppelin：

npm install @openzeppelin/contracts

说明：

AccessControl 支持多角色管理，适合复杂系统。
keccak256 生成角色 ID，确保唯一性。
角色可动态分配和撤销，灵活性高。

暂停机制

暂停机制允许管理员在紧急情况下暂停合约，防止进一步操作。

示例：Pausable 合约


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

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

contract PausableContract is Pausable, Ownable {
    uint256 public balance;

    event Deposited(address indexed user, uint256 amount);

    constructor() Ownable(msg.sender) {}

    function deposit() public payable whenNotPaused {
        balance += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

    function pause() public onlyOwner {
        _pause();
    }

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

说明：

使用 OpenZeppelin 的 Pausable 和 Ownable。
whenNotPaused 修饰器限制 deposit 在暂停时不可用。
pause 和 unpause 由 owner 控制。

测试用例：


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

describe("PausableContract", function () {
    let PausableContract, contract, owner, user;

    beforeEach(async function () {
        PausableContract = await ethers.getContractFactory("PausableContract");
        [owner, user] = await ethers.getSigners();
        contract = await PausableContract.deploy();
        await contract.deployed();
    });

    it("should allow deposit when not paused", async function () {
        await expect(contract.connect(user).deposit({ value: ethers.parseEther("1") }))
            .to.emit(contract, "Deposited")
            .withArgs(user.address, ethers.parseEther("1"));
        expect(await contract.balance()).to.equal(ethers.parseEther("1"));
    });

    it("should revert deposit when paused", async function () {
        await contract.connect(owner).pause();
        await expect(contract.connect(user).deposit({ value: ethers.parseEther("1") }))
            .to.be.revertedWith("Pausable: paused");
    });

    it("should allow unpause and deposit", async function () {
        await contract.connect(owner).pause();
        await contract.connect(owner).unpause();
        await contract.connect(user).deposit({ value: ethers.parseEther("1") });
        expect(await contract.balance()).to.equal(ethers.parseEther("1"));
    });
});

说明：

测试验证暂停和恢复功能。
Pausable 提供标准化的暂停逻辑。

综合案例：安全的 DeFi 存款合约

以下是一个结合访问控制、安全数学运算和暂停机制的 DeFi 存款合约。


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

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

contract SecureDeposit is AccessControl, Pausable, ReentrancyGuard {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    uint256 public constant DECIMAL_PRECISION = 1e18;
    mapping(address => uint256) public balances;
    uint256 public totalDeposits;

    event Deposited(address indexed user, uint256 amount, uint256 scaledAmount);
    event Withdrawn(address indexed user, uint256 amount);

    error InsufficientBalance();
    error InvalidAmount();

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }

    function deposit(uint256 amount, uint256 interestRate) public payable nonReentrant whenNotPaused {
        if (amount == 0 || msg.value != amount) revert InvalidAmount();

        // 安全数学运算：计算带利息的存款
        uint256 scaledAmount = (amount * interestRate) / DECIMAL_PRECISION;

        balances[msg.sender] += scaledAmount;
        totalDeposits += scaledAmount; // 内置溢出检查

        emit Deposited(msg.sender, amount, scaledAmount);
    }

    function withdraw(uint256 amount) public nonReentrant whenNotPaused {
        if (amount > balances[msg.sender]) revert InsufficientBalance();

        balances[msg.sender] -= amount;
        totalDeposits -= amount; // 内置下溢检查

        payable(msg.sender).transfer(amount);
        emit Withdrawn(msg.sender, amount);
    }

    function pause() public onlyRole(ADMIN_ROLE) {
        _pause();
    }

    function unpause() public onlyRole(ADMIN_ROLE) {
        _unpause();
    }

    function addAdmin(address newAdmin) public onlyRole(DEFAULT_ADMIN_ROLE) {
        grantRole(ADMIN_ROLE, newAdmin);
    }
}

说明：

使用 AccessControl 实现多管理员管理。
Pausable 提供暂停功能，防止紧急情况下的操作。
ReentrancyGuard 防止重入攻击。
安全数学运算处理利息计算。
事件记录存款和取款，便于审计。

测试用例：


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

describe("SecureDeposit", function () {
    let SecureDeposit, contract, owner, admin, user;

    beforeEach(async function () {
        SecureDeposit = await ethers.getContractFactory("SecureDeposit");
        [owner, admin, user] = await ethers.getSigners();
        contract = await SecureDeposit.deploy();
        await contract.deployed();
    });

    it("should allow deposit with interest", async function () {
        const amount = ethers.parseEther("1");
        const interestRate = ethers.parseUnits("1.1", 18); // 1.1x
        await expect(contract.connect(user).deposit(amount, interestRate, { value: amount }))
            .to.emit(contract, "Deposited")
            .withArgs(user.address, amount, ethers.parseUnits("1.1", 18));
        expect(await contract.balances(user.address)).to.equal(ethers.parseUnits("1.1", 18));
    });

    it("should revert deposit when paused", async function () {
        await contract.connect(owner).pause();
        await expect(contract.connect(user).deposit(ethers.parseEther("1"), ethers.parseUnits("1", 18), { value: ethers.parseEther("1") }))
            .to.be.revertedWith("Pausable: paused");
    });

    it("should allow admin to pause", async function () {
        await contract.connect(owner).addAdmin(admin.address);
        await contract.connect(admin).pause();
        expect(await contract.paused()).to.be.true;
    });

    it("should revert if non-admin pauses", async function () {
        await expect(contract.connect(user).pause())
            .to.be.revertedWith("AccessControl: account is missing role");
    });

    it("should withdraw correctly", async function () {
        const amount = ethers.parseEther("1");
        await contract.connect(user).deposit(amount, ethers.parseUnits("1", 18), { value: amount });
        await expect(contract.connect(user).withdraw(amount))
            .to.emit(contract, "Withdrawn")
            .withArgs(user.address, amount);
        expect(await contract.balances(user.address)).to.equal(0);
    });
});

运行测试：

npx hardhat test

说明：

测试覆盖存款、取款、暂停和角色管理。
验证事件触发和权限控制。
确保安全数学运算和重入保护有效。

原创
学分: 6
分类: Solidity
标签: Solidity 智能合约以太坊

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

Solidity中的访问控制：保护你的智能合约

访问控制的重要性

为什么需要访问控制？

常见风险

Solidity 的访问控制工具

实现访问控制

函数可见性

函数修饰器（Modifier）

角色管理

暂停机制

综合案例：安全的 DeFi 存款合约

0 条评论

文章目录