Solidity智能合约开发基础教程

天涯学馆
更新于 12小时前
阅读 51

Solidity简介什么是SoliditySolidity是一种面向对象的高级编程语言，专门用于编写智能合约。智能合约是在区块链上自动执行的程序，可以用于实现各种去中心化应用（DApps）。Solidity的历史Solidity由以太坊基金会的成员在2014年创建，目的是为以太坊区块链提

### Solidity简介

**什么是Solidity**
Solidity 是一种面向对象的高级编程语言，专门用于编写智能合约。智能合约是在区块链上自动执行的程序，可以用于实现各种去中心化应用（DApps）。

**Solidity的历史**
Solidity 由以太坊基金会的成员在2014年创建，目的是为以太坊区块链提供一种易于使用的编程语言。自那时以来，Solidity 不断发展，成为最流行的智能合约编程语言之一。

**安装Solidity编译器**
安装Solidity编译器有多种方法，以下是几种常见的方法：

使用Node.js包管理器npm：

```sh
npm install -g solc
```

使用Docker：

```sh
docker pull ethereum/solc:stable
```

在线编译器：

Remix IDE：https://remix.ethereum.org/

### Solidity基础语法

#### 变量与数据类型

Solidity 支持多种数据类型，包括基本类型和复杂类型。

- 基本类型
- 布尔型：`bool`
- 整型：`int`, `uint`
- 地址型：`address`
- 字符串：`string`
- 字节型：`bytes`
- 复杂类型
  - 数组：`uint[]`, `uint[5]`
  - 映射：`mapping(address => uint)`
  - 结构体：`struct Person { string name; uint age; }`

#### 函数

函数是Solidity中的基本构建块，用于定义合约的行为。

```solidity
pragma solidity ^0.8.0;

contract Example {
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }
}
```

#### 控制结构

Solidity 支持常见的控制结构，如条件语句和循环语句。

**条件语句**

```solidity
function checkAge(uint age) public pure returns (string memory) {
    if (age < 18) {
        return "未成年";
    } else {
        return "成年";
    }
}
```

**循环语句**

```solidity
function sum(uint n) public pure returns (uint) {
    uint result = 0;
    for (uint i = 1; i <= n; i++) {
        result += i;
    }
    return result;
}
```

#### 事件

事件用于记录合约的重要操作，可以在前端应用中监听这些事件。

```solidity
event Transfer(address indexed from, address indexed to, uint value);

function transfer(address _to, uint _value) public {
    // 执行转账逻辑
    emit Transfer(msg.sender, _to, _value);
}
```

#### 错误处理

Solidity 提供了多种错误处理机制，如`require`、`assert`和`revert`。

```solidity
function divide(uint a, uint b) public pure returns (uint) {
    require(b != 0, "除数不能为零");
    return a / b;
}
```

### 智能合约基础

#### 智能合约的概念

智能合约是一种自动执行的合约，其条款直接写入代码中。在区块链上，智能合约可以用于实现各种去中心化应用。

#### 创建第一个智能合约

```solidity
pragma solidity ^0.8.0;

contract HelloWorld {
    string public message;

constructor(string memory initMessage) {
        message = initMessage;
    }

function updateMessage(string memory newMessage) public {
        message = newMessage;
    }
}
```

#### 合约状态变量

状态变量是存储在区块链上的变量，用于保存合约的状态信息。

```solidity
contract Storage {
    uint256 public storedData;

function set(uint256 x) public {
        storedData = x;
    }

function get() public view returns (uint256) {
        return storedData;
    }
}
```

#### 函数修饰符

函数修饰符用于修改函数的行为，常见的修饰符有`view`、`pure`和`payable`。

```solidity
contract ModifierExample {
    uint256 public value;

function setValue(uint256 _value) public {
        value = _value;
    }

function getValue() public view returns (uint256) {
        return value;
    }

function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

function payMe() public payable {
        // 接收以太币
    }
}
```

#### 构造函数

构造函数在合约部署时执行，用于初始化合约的状态。

```solidity
contract ConstructorExample {
    uint256 public initialValue;

constructor(uint256 _initialValue) {
        initialValue = _initialValue;
    }
}
```

### 高级特性

#### 继承

继承允许一个合约继承另一个合约的功能。

```solidity
contract Base {
    uint256 public baseValue;

function setBaseValue(uint256 _value) public {
        baseValue = _value;
    }
}

contract Derived is Base {
    uint256 public derivedValue;

function setDerivedValue(uint256 _value) public {
        derivedValue = _value;
    }
}
```

#### 接口

接口定义了一组方法签名，但不包含实现。

```solidity
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract MyToken is IERC20 {
    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

function transfer(address recipient, uint256 amount) public override returns (bool) {
        _balances[msg.sender] -= amount;
        _balances[recipient] += amount;
        return true;
    }
}
```

#### 库

库用于定义一组可重用的函数。

```solidity
library Math {
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }
}

contract LibraryExample {
    using Math for uint256;

function getMax(uint256 a, uint256 b) public pure returns (uint256) {
        return a.max(b);
    }
}
```

#### 内部和外部调用

内部调用和外部调用分别用于调用同一合约内的函数和不同合约的函数。

```solidity
contract InternalExternalCalls {
    uint256 public value;

function internalCall() internal {
        value = 100;
    }

function externalCall() public {
        internalCall();
    }
}
```

#### Gas优化

Gas 是以太坊网络中执行智能合约操作所需支付的费用。优化Gas消耗可以降低交易成本并提高合约效率。

**常见的Gas优化技巧**
- 减少存储读写：尽量减少对状态变量的读写操作。
- 批量操作：将多个操作合并为一个事务。
- 使用内存变量：在函数内部使用内存变量而不是状态变量。
- 避免循环：尽量避免在合约中使用循环，特别是在涉及大量数据的情况下。

**示例：优化存储读写**

```solidity
pragma solidity ^0.8.0;

contract GasOptimization {
    uint256[] public data;

function addData(uint256[] memory newData) public {
        for (uint256 i = 0; i < newData.length; i++) {
            data.push(newData[i]);
        }
    }

function getDataLength() public view returns (uint256) {
        return data.length;
    }

function optimizeGetDataLength() public view returns (uint256) {
        uint256 len = data.length;
        return len;
    }
}
```

#### 事件和日志

事件和日志用于记录合约的重要操作，可以在前端应用中监听这些事件。

**示例：使用事件记录转账**

```solidity
pragma solidity ^0.8.0;

contract EventExample {
    event Transfer(address indexed from, address indexed to, uint256 value);

function transfer(address _to, uint256 _value) public {
        emit Transfer(msg.sender, _to, _value);
    }
}
```

#### 自动化测试

自动化测试是确保智能合约正确性的关键步骤。使用Truffle和Mocha等工具可以方便地编写和运行测试用例。

**示例：编写单元测试**

```javascript
const MyContract = artifacts.require("MyContract");

contract("MyContract", (accounts) => {
    let instance;

beforeEach(async () => {
        instance = await MyContract.new();
    });

it("should set the initial value", async () => {
        const value = await instance.getValue();
        assert.equal(value, 0, "Initial value should be 0");
    });

it("should update the value", async () => {
        await instance.setValue(100);
        const value = await instance.getValue();
        assert.equal(value, 100, "Value should be updated to 100");
    });

it("should emit an event on value update", async () => {
        const result = await instance.setValue(100);
        const event = result.logs[0].args;
        assert.equal(event.newValue.toNumber(), 100, "Event should log the new value");
    });
});
```

#### 常见设计模式

- 代理模式：用于升级智能合约。
- 工厂模式：用于创建多个合约实例。
- 访问控制模式：用于限制合约的访问权限。

### 安全性和最佳实践

**常见的安全漏洞**
- 重入攻击：通过多次调用合约函数来窃取资金。
- 溢出和下溢：通过数值运算导致的错误。
- 时间戳依赖：依赖区块时间戳进行决策。

**安全审计工具**
- MythX：专业的智能合约安全审计工具。
- Slither：开源的智能合约安全分析工具。
- Echidna：基于模糊测试的安全审计工具。

**编写安全的智能合约**
- 使用最新的Solidity版本。
- 避免使用低级别的调用。
- 使用OpenZeppelin库。

### 合约应用

#### 简单的ERC20代币合约

```solidity
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);
    }
}
```

#### 去中心化投票系统

```solidity
pragma solidity ^0.8.0;

contract Voting {
    struct Proposal {
        bytes32 name;
        uint256 voteCount;
    }

address public chairperson;
    mapping(address => bool) public voters;
    Proposal[] public proposals;

modifier onlyChairperson() {
        require(msg.sender == chairperson, "Only chairperson can call this function");
        _;
    }

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

function giveRightToVote(address voter) public onlyChairperson {
        require(!voters[voter], "The voter already has the right to vote");
        voters[voter] = true;
    }

function vote(uint256 proposal) public {
        require(voters[msg.sender], "You do not have the right to vote");
        require(proposal < proposals.length, "Invalid proposal");
        proposals[proposal].voteCount++;
    }

#### NFT市场合约

```solidity
pragma solidity ^0.8.0;

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

contract NFTMarket is ERC721URIStorage, Ownable {
    uint256 private _tokenIds;
    mapping(uint256 => uint256) private _tokenPrices;

event TokenListed(uint256 tokenId, uint256 price);
    event TokenSold(uint256 tokenId, address buyer, uint256 price);

constructor() ERC721("NFTMarket", "NFTM") {}

function createToken(string memory tokenURI, uint256 price) public onlyOwner returns (uint256) {
        _tokenIds++;
        uint256 newItemId = _tokenIds;
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        _tokenPrices[newItemId] = price;
        emit TokenListed(newItemId, price);
        return newItemId;
    }

function purchaseToken(uint256 tokenId) public payable {
        require(_exists(tokenId), "Token does not exist");
        require(msg.value >= _tokenPrices[tokenId], "Insufficient funds");
        address seller = ownerOf(tokenId);
        _transfer(seller, msg.sender, tokenId);
        payable(seller).transfer(msg.value);
        emit TokenSold(tokenId, msg.sender, msg.value);
    }

function setTokenPrice(uint256 tokenId, uint256 newPrice) public onlyOwner {
        require(_exists(tokenId), "Token does not exist");
        _tokenPrices[tokenId] = newPrice;
    }

function getTokenPrice(uint256 tokenId) public view returns (uint256) {
        return _tokenPrices[tokenId];
    }
}
```

#### 去中心化交易所（DEX）

去中心化交易所（DEX）是一种基于智能合约的交易平台，用户可以直接在链上进行资产交换。

**核心功能**
- 订单簿：记录用户的买卖订单。
- 撮合引擎：匹配买卖订单并执行交易。
- 资产托管：安全地管理用户的资产。

**示例代码**

```solidity
pragma solidity ^0.8.0;

contract DecentralizedExchange {
    struct Order {
        address trader;
        bool isBuyOrder;
        uint256 price;
        uint256 amount;
    }

mapping(uint256 => Order) public orders;
    uint256 public orderCount;

event OrderCreated(uint256 orderId, address trader, bool isBuyOrder, uint256 price, uint256 amount);
    event OrderFilled(uint256 orderId, address taker, uint256 filledAmount);

function createOrder(bool isBuyOrder, uint256 price, uint256 amount) public {
        orderCount++;
        orders[orderCount] = Order(msg.sender, isBuyOrder, price, amount);
        emit OrderCreated(orderCount, msg.sender, isBuyOrder, price, amount);
    }

function fillOrder(uint256 orderId, uint256 amount) public {
        Order storage order = orders[orderId];
        require(order.amount >= amount, "Insufficient order amount");
        order.amount -= amount;
        emit OrderFilled(orderId, msg.sender, amount);
    }
}
```

#### 去中心化借贷平台

去中心化借贷平台允许用户借出和借入加密货币，通过智能合约实现自动化的借贷流程。

**核心功能**
- 借贷池：管理用户的借贷资金。
- 利率模型：动态调整借贷利率。
- 风险控制：防止违约风险。

**示例代码**

```solidity
pragma solidity ^0.8.0;

contract LendingPlatform {
    struct Loan {
        address borrower;
        uint256 amount;
        uint256 interestRate;
        uint256 repaymentDate;
    }

mapping(address => uint256) public balances;
    mapping(uint256 => Loan) public loans;
    uint256 public loanCount;

event LoanCreated(uint256 loanId, address borrower, uint256 amount, uint256 interestRate, uint256 repaymentDate);
    event LoanRepaid(uint256 loanId, uint256 amount);

function deposit(uint256 amount) public payable {
        require(msg.value == amount, "Deposit amount must match the sent Ether");
        balances[msg.sender] += amount;
    }

function createLoan(uint256 amount, uint256 interestRate, uint256 repaymentPeriod) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        loanCount++;
        uint256 repaymentDate = block.timestamp + repaymentPeriod;
        loans[loanCount] = Loan(msg.sender, amount, interestRate, repaymentDate);
        balances[msg.sender] -= amount;
        emit LoanCreated(loanCount, msg.sender, amount, interestRate, repaymentDate);
    }

function repayLoan(uint256 loanId) public payable {
        Loan storage loan = loans[loanId];
        require(loan.borrower == msg.sender, "Not the borrower");
        require(block.timestamp <= loan.repaymentDate, "Repayment period expired");
        uint256 totalAmount = loan.amount + (loan.amount * loan.interestRate / 100);
        require(msg.value == totalAmount, "Incorrect repayment amount");
        balances[msg.sender] += totalAmount;
        delete loans[loanId];
        emit LoanRepaid(loanId, totalAmount);
    }
}
```

Solidity简介

什么是Solidity Solidity 是一种面向对象的高级编程语言，专门用于编写智能合约。智能合约是在区块链上自动执行的程序，可以用于实现各种去中心化应用（DApps）。

Solidity的历史 Solidity 由以太坊基金会的成员在2014年创建，目的是为以太坊区块链提供一种易于使用的编程语言。自那时以来，Solidity 不断发展，成为最流行的智能合约编程语言之一。

安装Solidity编译器 安装Solidity编译器有多种方法，以下是几种常见的方法：

使用Node.js包管理器npm：

npm install -g solc

使用Docker：

docker pull ethereum/solc:stable

在线编译器：

Remix IDE：https://remix.ethereum.org/

Solidity基础语法

变量与数据类型

Solidity 支持多种数据类型，包括基本类型和复杂类型。

基本类型
布尔型：bool
整型：int, uint
地址型：address
字符串：string
字节型：bytes
复杂类型
- 数组：uint[], uint[5]
- 映射：mapping(address => uint)
- 结构体：struct Person { string name; uint age; }

函数

函数是Solidity中的基本构建块，用于定义合约的行为。

pragma solidity ^0.8.0;

contract Example {
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }
}

控制结构

Solidity 支持常见的控制结构，如条件语句和循环语句。

条件语句

function checkAge(uint age) public pure returns (string memory) {
    if (age &lt; 18) {
        return "未成年";
    } else {
        return "成年";
    }
}

循环语句

function sum(uint n) public pure returns (uint) {
    uint result = 0;
    for (uint i = 1; i &lt;= n; i++) {
        result += i;
    }
    return result;
}

事件

事件用于记录合约的重要操作，可以在前端应用中监听这些事件。

event Transfer(address indexed from, address indexed to, uint value);

function transfer(address _to, uint _value) public {
    // 执行转账逻辑
    emit Transfer(msg.sender, _to, _value);
}

错误处理

Solidity 提供了多种错误处理机制，如require、assert和revert。

function divide(uint a, uint b) public pure returns (uint) {
    require(b != 0, "除数不能为零");
    return a / b;
}

智能合约基础

智能合约的概念

智能合约是一种自动执行的合约，其条款直接写入代码中。在区块链上，智能合约可以用于实现各种去中心化应用。

创建第一个智能合约

pragma solidity ^0.8.0;

contract HelloWorld {
    string public message;

    constructor(string memory initMessage) {
        message = initMessage;
    }

    function updateMessage(string memory newMessage) public {
        message = newMessage;
    }
}

合约状态变量

状态变量是存储在区块链上的变量，用于保存合约的状态信息。

contract Storage {
    uint256 public storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

函数修饰符

函数修饰符用于修改函数的行为，常见的修饰符有view、pure和payable。

contract ModifierExample {
    uint256 public value;

    function setValue(uint256 _value) public {
        value = _value;
    }

    function getValue() public view returns (uint256) {
        return value;
    }

    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    function payMe() public payable {
        // 接收以太币
    }
}

构造函数

构造函数在合约部署时执行，用于初始化合约的状态。

contract ConstructorExample {
    uint256 public initialValue;

    constructor(uint256 _initialValue) {
        initialValue = _initialValue;
    }
}

高级特性

继承

继承允许一个合约继承另一个合约的功能。

contract Base {
    uint256 public baseValue;

    function setBaseValue(uint256 _value) public {
        baseValue = _value;
    }
}

contract Derived is Base {
    uint256 public derivedValue;

    function setDerivedValue(uint256 _value) public {
        derivedValue = _value;
    }
}

接口

接口定义了一组方法签名，但不包含实现。

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract MyToken is IERC20 {
    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _balances[msg.sender] -= amount;
        _balances[recipient] += amount;
        return true;
    }
}

库

库用于定义一组可重用的函数。

library Math {
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }
}

contract LibraryExample {
    using Math for uint256;

    function getMax(uint256 a, uint256 b) public pure returns (uint256) {
        return a.max(b);
    }
}

内部和外部调用

内部调用和外部调用分别用于调用同一合约内的函数和不同合约的函数。

contract InternalExternalCalls {
    uint256 public value;

    function internalCall() internal {
        value = 100;
    }

    function externalCall() public {
        internalCall();
    }
}

Gas优化

Gas 是以太坊网络中执行智能合约操作所需支付的费用。优化Gas消耗可以降低交易成本并提高合约效率。

常见的Gas优化技巧

减少存储读写：尽量减少对状态变量的读写操作。
批量操作：将多个操作合并为一个事务。
使用内存变量：在函数内部使用内存变量而不是状态变量。
避免循环：尽量避免在合约中使用循环，特别是在涉及大量数据的情况下。

示例：优化存储读写

pragma solidity ^0.8.0;

contract GasOptimization {
    uint256[] public data;

    function addData(uint256[] memory newData) public {
        for (uint256 i = 0; i &lt; newData.length; i++) {
            data.push(newData[i]);
        }
    }

    function getDataLength() public view returns (uint256) {
        return data.length;
    }

    function optimizeGetDataLength() public view returns (uint256) {
        uint256 len = data.length;
        return len;
    }
}

事件和日志

事件和日志用于记录合约的重要操作，可以在前端应用中监听这些事件。

示例：使用事件记录转账

pragma solidity ^0.8.0;

contract EventExample {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function transfer(address _to, uint256 _value) public {
        emit Transfer(msg.sender, _to, _value);
    }
}

自动化测试

自动化测试是确保智能合约正确性的关键步骤。使用Truffle和Mocha等工具可以方便地编写和运行测试用例。

示例：编写单元测试

const MyContract = artifacts.require("MyContract");

contract("MyContract", (accounts) => {
    let instance;

    beforeEach(async () => {
        instance = await MyContract.new();
    });

    it("should set the initial value", async () => {
        const value = await instance.getValue();
        assert.equal(value, 0, "Initial value should be 0");
    });

    it("should update the value", async () => {
        await instance.setValue(100);
        const value = await instance.getValue();
        assert.equal(value, 100, "Value should be updated to 100");
    });

    it("should emit an event on value update", async () => {
        const result = await instance.setValue(100);
        const event = result.logs[0].args;
        assert.equal(event.newValue.toNumber(), 100, "Event should log the new value");
    });
});

常见设计模式

代理模式：用于升级智能合约。
工厂模式：用于创建多个合约实例。
访问控制模式：用于限制合约的访问权限。

安全性和最佳实践

常见的安全漏洞

重入攻击：通过多次调用合约函数来窃取资金。
溢出和下溢：通过数值运算导致的错误。
时间戳依赖：依赖区块时间戳进行决策。

安全审计工具

MythX：专业的智能合约安全审计工具。
Slither：开源的智能合约安全分析工具。
Echidna：基于模糊测试的安全审计工具。

编写安全的智能合约

使用最新的Solidity版本。
避免使用低级别的调用。
使用OpenZeppelin库。

合约应用

简单的ERC20代币合约

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);
    }
}

去中心化投票系统

pragma solidity ^0.8.0;

contract Voting {
    struct Proposal {
        bytes32 name;
        uint256 voteCount;
    }

    address public chairperson;
    mapping(address => bool) public voters;
    Proposal[] public proposals;

    modifier onlyChairperson() {
        require(msg.sender == chairperson, "Only chairperson can call this function");
        _;
    }

    constructor(bytes32[] memory proposalNames) {
        chairperson = msg.sender;
        for (uint256 i = 0; i &lt; proposalNames.length; i++) {
            proposals.push(Proposal({name: proposalNames[i], voteCount: 0}));
        }
    }

    function giveRightToVote(address voter) public onlyChairperson {
        require(!voters[voter], "The voter already has the right to vote");
        voters[voter] = true;
    }

    function vote(uint256 proposal) public {
        require(voters[msg.sender], "You do not have the right to vote");
        require(proposal &lt; proposals.length, "Invalid proposal");
        proposals[proposal].voteCount++;
    }

    function winningProposal() public view returns (uint256 winningProposal_) {
        uint256 winningVoteCount = 0;
        for (uint256 p = 0; p &lt; proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }
}

NFT市场合约

pragma solidity ^0.8.0;

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

contract NFTMarket is ERC721URIStorage, Ownable {
    uint256 private _tokenIds;
    mapping(uint256 => uint256) private _tokenPrices;

    event TokenListed(uint256 tokenId, uint256 price);
    event TokenSold(uint256 tokenId, address buyer, uint256 price);

    constructor() ERC721("NFTMarket", "NFTM") {}

    function createToken(string memory tokenURI, uint256 price) public onlyOwner returns (uint256) {
        _tokenIds++;
        uint256 newItemId = _tokenIds;
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        _tokenPrices[newItemId] = price;
        emit TokenListed(newItemId, price);
        return newItemId;
    }

    function purchaseToken(uint256 tokenId) public payable {
        require(_exists(tokenId), "Token does not exist");
        require(msg.value >= _tokenPrices[tokenId], "Insufficient funds");
        address seller = ownerOf(tokenId);
        _transfer(seller, msg.sender, tokenId);
        payable(seller).transfer(msg.value);
        emit TokenSold(tokenId, msg.sender, msg.value);
    }

    function setTokenPrice(uint256 tokenId, uint256 newPrice) public onlyOwner {
        require(_exists(tokenId), "Token does not exist");
        _tokenPrices[tokenId] = newPrice;
    }

    function getTokenPrice(uint256 tokenId) public view returns (uint256) {
        return _tokenPrices[tokenId];
    }
}

去中心化交易所（DEX）

去中心化交易所（DEX）是一种基于智能合约的交易平台，用户可以直接在链上进行资产交换。

核心功能

订单簿：记录用户的买卖订单。
撮合引擎：匹配买卖订单并执行交易。
资产托管：安全地管理用户的资产。

示例代码

pragma solidity ^0.8.0;

contract DecentralizedExchange {
    struct Order {
        address trader;
        bool isBuyOrder;
        uint256 price;
        uint256 amount;
    }

    mapping(uint256 => Order) public orders;
    uint256 public orderCount;

    event OrderCreated(uint256 orderId, address trader, bool isBuyOrder, uint256 price, uint256 amount);
    event OrderFilled(uint256 orderId, address taker, uint256 filledAmount);

    function createOrder(bool isBuyOrder, uint256 price, uint256 amount) public {
        orderCount++;
        orders[orderCount] = Order(msg.sender, isBuyOrder, price, amount);
        emit OrderCreated(orderCount, msg.sender, isBuyOrder, price, amount);
    }

    function fillOrder(uint256 orderId, uint256 amount) public {
        Order storage order = orders[orderId];
        require(order.amount >= amount, "Insufficient order amount");
        order.amount -= amount;
        emit OrderFilled(orderId, msg.sender, amount);
    }
}

去中心化借贷平台

去中心化借贷平台允许用户借出和借入加密货币，通过智能合约实现自动化的借贷流程。

核心功能

借贷池：管理用户的借贷资金。
利率模型：动态调整借贷利率。
风险控制：防止违约风险。

示例代码

pragma solidity ^0.8.0;

contract LendingPlatform {
    struct Loan {
        address borrower;
        uint256 amount;
        uint256 interestRate;
        uint256 repaymentDate;
    }

    mapping(address => uint256) public balances;
    mapping(uint256 => Loan) public loans;
    uint256 public loanCount;

    event LoanCreated(uint256 loanId, address borrower, uint256 amount, uint256 interestRate, uint256 repaymentDate);
    event LoanRepaid(uint256 loanId, uint256 amount);

    function deposit(uint256 amount) public payable {
        require(msg.value == amount, "Deposit amount must match the sent Ether");
        balances[msg.sender] += amount;
    }

    function createLoan(uint256 amount, uint256 interestRate, uint256 repaymentPeriod) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        loanCount++;
        uint256 repaymentDate = block.timestamp + repaymentPeriod;
        loans[loanCount] = Loan(msg.sender, amount, interestRate, repaymentDate);
        balances[msg.sender] -= amount;
        emit LoanCreated(loanCount, msg.sender, amount, interestRate, repaymentDate);
    }

    function repayLoan(uint256 loanId) public payable {
        Loan storage loan = loans[loanId];
        require(loan.borrower == msg.sender, "Not the borrower");
        require(block.timestamp &lt;= loan.repaymentDate, "Repayment period expired");
        uint256 totalAmount = loan.amount + (loan.amount * loan.interestRate / 100);
        require(msg.value == totalAmount, "Incorrect repayment amount");
        balances[msg.sender] += totalAmount;
        delete loans[loanId];
        emit LoanRepaid(loanId, totalAmount);
    }
}

原创
学分: 2
分类: Solidity合约
标签: Solidity

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

Solidity智能合约开发基础教程

Solidity简介

Solidity基础语法

变量与数据类型

函数

控制结构

事件

错误处理

智能合约基础

智能合约的概念

创建第一个智能合约

合约状态变量

函数修饰符

构造函数

高级特性

继承

接口

库

内部和外部调用

Gas优化

事件和日志

自动化测试

常见设计模式

安全性和最佳实践

合约应用

简单的ERC20代币合约

去中心化投票系统

NFT市场合约

去中心化交易所（DEX）

去中心化借贷平台

0 条评论

文章目录