Solid learning record - Chapter 4

Posted by MikeSnead on Tue, 05 Oct 2021 20:43:28 +0200

Solid learning record

Chapter 1 creating a zombie factory
The second chapter sets up the attack function of zombies
The third chapter is the basic theory required for writing DAPP
Chapter IV improving zombie function


There are many things during the National Day holiday. The update was delayed for two days. Please forgive me.

1, Main purpose of this chapter

In the previous course, we learned most of the knowledge of Solidity. In this chapter, we learned about the payable function, how to develop DApp that can receive payments from other players, and how to improve our program through function modifiers.

2, Learning process

1. Knowledge points of this course

1. payable modifier
The payable method is part of what makes Solidity and Ethereum so cool - they are a special function that can receive ether. In Ethereum, because the money (Ether), the data (transaction payload), and the contract code itself exist in Ethereum. You can call the function at the same time and pay another contract. If a function is not marked payable, the function will reject the transaction when the user attempts to send Ethernet.

2. msg.value is a method to check how many ethers are sent to the contract. It is usually expressed by msg.value == XXX. If you think of a transaction as an envelope, the parameters you send to the function are the contents of the letter. Adding a value is much like putting money in an envelope - the content of the letter and the money are sent to the recipient at the same time.

3. We can pay any Ethereum address through transfer. Withdrawal method:

contract GetPaid is Ownable {
  function withdraw() external onlyOwner {

4. The best random number generator in solid is the keccak256 hash function. But this method is easy to be attacked by dishonest nodes.

5. Principle of keccak256 attack of solidness:
On Ethereum, when you call a function on a contract, you will broadcast it to a node or transaction nodes on the network. Nodes on the network will collect many transactions, try to be the first person to solve computing intensive mathematical problems as "proof of work", and then publish the "proof of work (POW) and transactions as a block on the network.
Once a node solves a PoW, other nodes will stop trying to solve the PoW, verify that the transaction list of other nodes is valid, and then accept the node and try to solve the next node.
This makes our random number function available
If you run a node, you can publish only one transaction to my own node without sharing it. If it is not the result I want, I will not include this transaction in the next block I want to solve. I can always run this method until I get the results I want (similar to the mobile game weak Networking (not real-time monitoring whether it is networked) game. I can constantly refresh what I want by disconnecting the network, such as card drawing, dropped rare items, etc.).

2. Final code

The code is as follows:


//this is ownable.sol

pragma solidity ^0.4.19;

* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
contract Ownable {
  address private _owner;

  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner

  * @dev The Ownable constructor sets the original `owner` of the contract to the sender
  * account.
  constructor() internal {
    _owner = msg.sender;
    emit OwnershipTransferred(address(0), _owner);

  * @return the address of the owner.
  function owner() public view returns(address) {
    return _owner;

  * @dev Throws if called by any account other than the owner.
  modifier onlyOwner() {

  * @return true if `msg.sender` is the owner of the contract.
  function isOwner() public view returns(bool) {
    return msg.sender == _owner;

  * @dev Allows the current owner to relinquish control of the contract.
  * @notice Renouncing to ownership will leave the contract without an owner.
  * It will not be possible to call the functions with the `onlyOwner`
  * modifier anymore.
  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);

  * @dev Allows the current owner to transfer control of the contract to a newOwner.
  * @param newOwner The address to transfer ownership to.
  function transferOwnership(address newOwner) public onlyOwner {

  * @dev Transfers control of the contract to a newOwner.
  * @param newOwner The address to transfer ownership to.
  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0));
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;


//this is zombiefactory.sol

pragma solidity ^0.4.19;

import "./ownable.sol";

contract ZombieFactory is Ownable {

    event NewZombie(uint zombieId, string name, uint dna);

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;
    uint cooldownTime = 1 days;

    struct Zombie {
      string name;
      uint dna;
      uint32 level;
      uint32 readyTime;
      uint16 winCount;
      uint16 lossCount;

    Zombie[] public zombies;

    mapping (uint => address) public zombieToOwner;
    mapping (address => uint) ownerZombieCount;

    function _createZombie(string _name, uint _dna) internal {
        uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1;
        zombieToOwner[id] = msg.sender;
        emit NewZombie(id, _name, _dna);

    function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(abi.encodePacked(_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);



//this is zombiefeeding.sol

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;

  modifier ownerOf(uint _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);

  function setKittyContractAddress(address _address) external onlyOwner {
    kittyContract = KittyInterface(_address);

  function _triggerCooldown(Zombie storage _zombie) internal {
    _zombie.readyTime = uint32(now + cooldownTime);

  function _isReady(Zombie storage _zombie) internal view returns (bool) {
      return (_zombie.readyTime <= now);

  function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) internal ownerOf(_zombieId) {
    Zombie storage myZombie = zombies[_zombieId];
    _targetDna = _targetDna % dnaModulus;
    uint newDna = (myZombie.dna + _targetDna) / 2;
    if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) {
      newDna = newDna - newDna % 100 + 99;
    _createZombie("NoName", newDna);

  function feedOnKitty(uint _zombieId, uint _kittyId) public {
    uint kittyDna;
    (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);
    feedAndMultiply(_zombieId, kittyDna, "kitty");


//this is zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  uint levelUpFee = 0.001 ether;

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);

  function withdraw() external onlyOwner {
    address _owner = owner();

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

  function levelUp(uint _zombieId) external payable {
    require(msg.value == levelUpFee);

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) {
    zombies[_zombieId].name = _newName;

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) {
    zombies[_zombieId].dna = _newDna;

  function getZombiesByOwner(address _owner) external view returns(uint[]) {
    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;
    return result;



//this is zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";
contract ZombieAttack is ZombieHelper {
  uint randNonce = 0;
  uint attackVictoryProbability = 70;

  function randMod(uint _modulus) internal returns(uint) {
    return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus;

  function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) {
    Zombie storage myZombie = zombies[_zombieId];
    Zombie storage enemyZombie = zombies[_targetId];
    uint rand = randMod(100);
    if (rand <= attackVictoryProbability) {
      feedAndMultiply(_zombieId, enemyZombie.dna, "zombie");
    } else {


There are few knowledge points in this chapter, most of which are the knowledge content before use. There are only two key knowledge in this chapter:

1. payable can be used for payment, value is used to indicate how much money is paid, and transfer is used for transfer (it can be transferred to anyone).
2.keccak256 function is unsafe. One random number method is to use oracle to access random number functions outside the Ethereum blockchain.

Topics: Blockchain