原力元宇宙MetaForce佛萨奇马蹄莲系统开发详情及功能丨MetaForce佛萨奇马蹄莲开发成品源码案例

Force是一个全球加密货币生态系统，其成员使用我们的智能合约即时利润分配工具和算法互相帮助以实现财务福利。

META FORCE系统属于我们的社区并且是完全去中心化的，这意味着它是透明的、安全的并且可以抵抗外部影响。

智能合约是一种自执行算法（程序代码）。它保证了在区块链内执行逻辑或传输的透明性和安全性。

原力元宇宙MetaForce是在Polygon马蹄链上部署的一个智能合约，Polygon马蹄链，是基于ETH开发的一个独立公链，用于构建和连接与以太坊兼容的区块链网络，智能合约可以直接在马蹄链上部署，百分百开源，百分百去中心化，一旦运行，不可篡改。本文由系统开发对接唯：MrsFu123编辑整理发布。

互联网是人类通信技术的重大革命，对人类社会产生了极其深远的影响。随着当前各类信息技术的迭代创新，互联网正呈现向下一代互联网演进的趋势。这一演进或将引发新一轮的信息革命，进一步深刻改变人们的生活、工作以及社会的方方面面。

4.2. 编写Solidity智能合约
4.2.1. 搭建开发环境
开发者无需自己搭建开发环境，可使用Remix在线IDE开发solidity合约。长安链对solidity完全兼容，使用Remix开发的或者以太坊生态内的solidity合约，可直接在长安链部署运行。

4.2.2. 代码编写规则
solidity语法和代码编写规则参见solidity官方开发文档：https://docs.soliditylang.org/。

4.2.2.1. 长安链solidity与以太坊solidity的异同
长安链的solidity在内置接口、预编译合约和跨合约调用上，与以太坊有一些区别，具体参见本章节下，各分小节详细内容。

4.2.2.1.1. solidity 内置接口
solidity为开发者提供了一些内置接口，包括内置变量和函数，可在合约中直接使用。因为长安链为无币链，所以，与原生token相关的内置接口，多默认为0，详见以下内置接口说明。

//指定区块的区块哈希，已经不推荐使用，由 blockhash(uint blockNumber) 代替
block.blockhash(uint blockNumber) returns (bytes32)

//address类型，当前区块的出块节点地址，即 block 的 proposer
block.coinbase

//uint类型，当前区块难度，值固定为0
block.difficulty

//uint类型，当前区块 gas 限额
block.gaslimit

//uint类型，当前区块号
block.number

//uint类型，自 unix epoch 起始当前区块以秒计的时间戳
block.timestamp

//uint256类型，剩余的 gas
gasleft() returns

//bytes类型，完整的 calldata
msg.data

//uint类型，剩余 gas - 自 0.4.21 版本开始已经不推荐使用，由 gesleft() 代替
msg.gas

//address类型，消息发送者（当前调用）
msg.sender

//bytes4类型，calldata 的前 4 字节（也就是函数标识符）
msg.sig

//uint类型，随消息发送的 wei 的数量，值固定为0
msg.value

//uint类型，目前区块时间戳（block.timestamp）
now

//uint类型，交易的 gas 价格，值固定为1
tx.gasprice

//address类型，交易发起者
tx.origin

4.2.3. 合约示例源码展示
Token合约示例，实现功能ERC20

/*
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity >0.5.11;
contract Token {

string public name = "token";      //  token name
string public symbol = "TK";           //  token symbol
uint256 public decimals = 6;            //  token digit

mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

uint256 public totalSupply = 0;
bool public stopped = false;

uint256 constant valueFounder = 100000000000000000;
address owner = address(0x0);

modifier isOwner {
    assert(owner == msg.sender);
    _;
}

modifier isRunning {
    assert (!stopped);
    _;
}

modifier validAddress {
    assert(address(0x0) != msg.sender);
    _;
}

constructor (address _addressFounder) {
    owner = msg.sender;
    totalSupply = valueFounder;
    balanceOf[_addressFounder] = valueFounder;
    
    emit Transfer(address(0x0), _addressFounder, valueFounder);
}

function transfer(address _to, uint256 _value) public isRunning validAddress returns (bool success) {
    require(balanceOf[msg.sender] >= _value);
    require(balanceOf[_to] + _value >= balanceOf[_to]);
    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value;
    emit Transfer(msg.sender, _to, _value);
    return true;
}

function transferFrom(address _from, address _to, uint256 _value) public isRunning validAddress returns (bool success) {
    require(balanceOf[_from] >= _value);
    require(balanceOf[_to] + _value >= balanceOf[_to]);
    require(allowance[_from][msg.sender] >= _value);
    balanceOf[_to] += _value;
    balanceOf[_from] -= _value;
    allowance[_from][msg.sender] -= _value;
    emit Transfer(_from, _to, _value);
    return true;
}

function approve(address _spender, uint256 _value) public isRunning validAddress returns (bool success) {
    require(_value == 0 || allowance[msg.sender][_spender] == 0);
    allowance[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

function stop() public isOwner {
    stopped = true;
}

function start() public isOwner {
    stopped = false;
}

function setName(string memory _name) public isOwner {
    name = _name;
}

function burn(uint256 _value) public {
    require(balanceOf[msg.sender] >= _value);
    balanceOf[msg.sender] -= _value;
    balanceOf[address(0x0)] += _value;
    emit Transfer(msg.sender, address(0x0), _value);
}

event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

}