solidity 语法学习

基于 cryptozombies.io

ZombieFactory

pragma solidity ^0.4.19;

contract ZombieFactory {

    // 事件， web3.js 可以监控它
    event NewZombie(uint zombieId, string name, uint dna);

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits; // 乘方

    // 定义结构体
    struct Zombie {
        string name;
        uint dna;
    }

    // 定义数组
    Zombie[] public zombies;

    // 定义 mapping 结构， 可理解为 python 里面的 dict
    mapping (uint => address) public zombieToOwner;
    mapping (address => uint) ownerZombieCount;

    function _createZombie(string _name, uint _dna) internal {
        uint id = zombies.push(Zombie(_name, _dna)) - 1; // 获取刚刚放到数组的元素的 id
        
        // msg.sender 为调用者的 地址。
        zombieToOwner[id] = msg.sender; 
        ownerZombieCount[msg.sender]++;
        
        // 触发事件
        NewZombie(id, _name, _dna);
    }

    function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(_str));
        return rand % dnaModulus;
    }

    function createRandomZombie(string _name) public {
    
        // 要求每个账户只能有一只僵尸，否则退出
        require(ownerZombieCount[msg.sender] == 0);
        
        uint randDna = _generateRandomDna(_name);
        randDna = randDna - randDna % 100;
        _createZombie(_name, randDna);
    }

}

学到了

函数的定义
数组的使用
mapping 的使用
require的使用
事件的使用

ZombieFeeding

pragma solidity ^0.4.19;

import "./zombiefactory.sol";

// 定义一个合约接口，通过这种方式可以调用其他合约的公开方法
contract KittyInterface {
  function getKitty(uint256 _id) external view returns (
    bool isGestating,
    bool isReady,
    uint256 cooldownIndex,
    uint256 nextActionAt,
    uint256 siringWithId,
    uint256 birthTime,
    uint256 matronId,
    uint256 sireId,
    uint256 generation,
    uint256 genes
  );
}

// 继承
contract ZombieFeeding is ZombieFactory {

  KittyInterface kittyContract;

  // 使用了函数修饰符，确保只有 合约账户本身可以调用该方法
  function setKittyContractAddress(address _address) external onlyOwner {
    // 通过 合约地址实例化接口，以后可以通过这个接口调用该合约的方法
    kittyContract = KittyInterface(_address); 
  }

  // 传输结构体指针
  function _triggerCooldown(Zombie storage _zombie) internal {
    _zombie.readyTime = uint32(now + cooldownTime);
  }

  // 返回 bool 类型
  function _isReady(Zombie storage _zombie) internal view returns (bool) {
      return (_zombie.readyTime <= now);
  }

  function feedAndMultiply(uint _zombieId, uint _targetDna, string species) internal {
    require(msg.sender == zombieToOwner[_zombieId]);
    Zombie storage myZombie = zombies[_zombieId];
    require(_isReady(myZombie));
    _targetDna = _targetDna % dnaModulus;
    uint newDna = (myZombie.dna + _targetDna) / 2;
    if (keccak256(species) == keccak256("kitty")) { // if 语句的使用
      newDna = newDna - newDna % 100 + 99;
    }
    _createZombie("NoName", newDna);
    _triggerCooldown(myZombie);
  }

  function feedOnKitty(uint _zombieId, uint _kittyId) public {
    uint kittyDna;
    // 调用其他合约的方法
    (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);  // 多个返回值的获取
    
    feedAndMultiply(_zombieId, kittyDna, "kitty");
  }

}

学到了

调用其他合约的方法
结构体传值
接收多个返回值的方法
函数修饰符的使用

ZombieHelper

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  uint levelUpFee = 0.001 ether;

  // 定义修饰函数，会在被修饰函数调用前调用
  modifier aboveLevel(uint _level, uint _zombieId) {
    // 如果指定僵尸的 level 小于 _level 就会退出，否则继续执行被修饰的函数
    require(zombies[_zombieId].level >= _level);
    _;
  }

  // 用于提出 以太坊里面的 eth
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }

  // 
  function setLevelUpFee(uint _fee) external onlyOwner {
    levelUpFee = _fee;
  }

  // payable 修饰符表示，可以往这个方法发送 eth
  function levelUp(uint _zombieId) external payable {
    require(msg.value == levelUpFee);  // 判断 eth 的值
    zombies[_zombieId].level++;
  }

  // 使用了修饰符，当级别大于 2 时才能修改名字
  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  // 返回一个列表
  function getZombiesByOwner(address _owner) external view returns(uint[]) {
   
    // 定义 memory 数组，节省 gas
    uint[] memory result = new uint[](ownerZombieCount[_owner]);
    uint counter = 0;
    for (uint i = 0; i < zombies.length; i++) {
      if (zombieToOwner[i] == _owner) {
        result[counter] = i;
        counter++;
      }
    }
    return result;
  }

}

学到了

定义修饰函数，以及往修饰函数传参
接收，提取 eth
返回 uint[]
memory 变量， for 循环的使用

后面接着又了解了 SafeMath 的使用

pragma solidity ^0.4.19;

import "./zombieattack.sol";
import "./erc721.sol";
import "./safemath.sol";

contract ZombieOwnership is ZombieAttack, ERC721 {

  using SafeMath for uint256;

  mapping (uint => address) zombieApprovals;

  function balanceOf(address _owner) public view returns (uint256 _balance) {
    return ownerZombieCount[_owner];
  }

  function ownerOf(uint256 _tokenId) public view returns (address _owner) {
    return zombieToOwner[_tokenId];
  }

  function _transfer(address _from, address _to, uint256 _tokenId) private {
    ownerZombieCount[_to] = ownerZombieCount[_to].add(1);
    ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1);
    zombieToOwner[_tokenId] = _to;
    Transfer(_from, _to, _tokenId);
  }

  function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
    _transfer(msg.sender, _to, _tokenId);
  }

  function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
    zombieApprovals[_tokenId] = _to;
    Approval(msg.sender, _to, _tokenId);
  }

  function takeOwnership(uint256 _tokenId) public {
    require(zombieApprovals[_tokenId] == msg.sender);
    address owner = ownerOf(_tokenId);
    _transfer(owner, msg.sender, _tokenId);
  }
}