类似以太猫的智能合约

最新推荐文章于 2022-03-27 23:00:25 发布
最新推荐文章于 2022-03-27 23:00:25 发布
阅读量441 收藏
点赞数
分类专栏： 智能合约
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianlongtc/article/details/80260893
版权 
//erc721.sol
contract ERC721 {
  event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
  event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);

  function balanceOf(address _owner) public view returns (uint256 _balance);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function transfer(address _to, uint256 _tokenId) public;
  function approve(address _to, uint256 _tokenId) public;
  function takeOwnership(uint256 _tokenId) public;
}






//safemath.sol
pragma solidity ^0.4.18;


/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {


  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }


  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }


  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }


  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}










//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 public owner;


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }




  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }




  /**
   * @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 {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }


}












//zombiefactory.sol
pragma solidity ^0.4.19;


import "./ownable.sol";
import "./safemath.sol";


contract ZombieFactory is Ownable {


  using SafeMath for uint256;


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


}










//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 onlyOwnerOf(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 onlyOwnerOf(_zombieId) {
    Zombie storage myZombie = zombies[_zombieId];
    require(_isReady(myZombie));
    _targetDna = _targetDna % dnaModulus;
    uint newDna = (myZombie.dna + _targetDna) / 2;
    if (keccak256(_species) == keccak256("kitty")) {
      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.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 {
    owner.transfer(this.balance);
  }


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


  function levelUp(uint _zombieId) external payable {
    require(msg.value == levelUpFee);
    zombies[_zombieId].level++;
  }


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


  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_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;
        counter++;
      }
    }
    return result;
  }


}












//zombieattack.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) {
    randNonce++;
    return uint(keccak256(now, msg.sender, randNonce)) % _modulus;
  }


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








//zombieownership.sol
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);
  }
}










//cryptozombies_abi.js
var cryptozombiesABI = [
  {
    "constant": false,
    "inputs": [
      {
        "name": "_to",
        "type": "address"
      },
      {
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "approve",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_zombieId",
        "type": "uint256"
      }
    ],
    "name": "levelUp",
    "outputs": [],
    "payable": true,
    "stateMutability": "payable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_zombieId",
        "type": "uint256"
      },
      {
        "name": "_kittyId",
        "type": "uint256"
      }
    ],
    "name": "feedOnKitty",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "name": "zombies",
    "outputs": [
      {
        "name": "name",
        "type": "string"
      },
      {
        "name": "dna",
        "type": "uint256"
      },
      {
        "name": "level",
        "type": "uint32"
      },
      {
        "name": "readyTime",
        "type": "uint32"
      },
      {
        "name": "winCount",
        "type": "uint16"
      },
      {
        "name": "lossCount",
        "type": "uint16"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [],
    "name": "withdraw",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "_owner",
        "type": "address"
      }
    ],
    "name": "getZombiesByOwner",
    "outputs": [
      {
        "name": "",
        "type": "uint256[]"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "name": "zombieToOwner",
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_address",
        "type": "address"
      }
    ],
    "name": "setKittyContractAddress",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_zombieId",
        "type": "uint256"
      },
      {
        "name": "_newDna",
        "type": "uint256"
      }
    ],
    "name": "changeDna",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "ownerOf",
    "outputs": [
      {
        "name": "_owner",
        "type": "address"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "_owner",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "name": "_balance",
        "type": "uint256"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_name",
        "type": "string"
      }
    ],
    "name": "createRandomZombie",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_to",
        "type": "address"
      },
      {
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "transfer",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "getAllZombies",
    "outputs": [
      {
        "name": "",
        "type": "uint256[]"
      }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "takeOwnership",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_zombieId",
        "type": "uint256"
      },
      {
        "name": "_newName",
        "type": "string"
      }
    ],
    "name": "changeName",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_fee",
        "type": "uint256"
      }
    ],
    "name": "setLevelUpFee",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_zombieId",
        "type": "uint256"
      },
      {
        "name": "_targetId",
        "type": "uint256"
      }
    ],
    "name": "attack",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "transferOwnership",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "_from",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "_to",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "_owner",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "_approved",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "_tokenId",
        "type": "uint256"
      }
    ],
    "name": "Approval",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "name": "attackResult",
        "type": "bool"
      },
      {
        "indexed": false,
        "name": "winCount",
        "type": "uint16"
      },
      {
        "indexed": false,
        "name": "lossCount",
        "type": "uint16"
      }
    ],
    "name": "AttackResult",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "name": "zombieId",
        "type": "uint256"
      },
      {
        "indexed": false,
        "name": "name",
        "type": "string"
      },
      {
        "indexed": false,
        "name": "dna",
        "type": "uint256"
      }
    ],
    "name": "NewZombie",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "previousOwner",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "OwnershipTransferred",
    "type": "event"
  }
]      












//index.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>CryptoZombies front-end</title>
    <script language="javascript" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    <script language="javascript" type="text/javascript" src="web3.min.js"></script>
    <script language="javascript" type="text/javascript" src="cryptozombies_abi.js"></script>
  </head>
  <body>
    <div id="txStatus"></div>
    <div id="zombies"></div>


    <script>
      var cryptoZombies;
      var userAccount;


      function startApp() {
        var cryptoZombiesAddress = "YOUR_CONTRACT_ADDRESS";
        cryptoZombies = new web3js.eth.Contract(cryptoZombiesABI, cryptoZombiesAddress);


        var accountInterval = setInterval(function() {
          // Check if account has changed
          if (web3.eth.accounts[0] !== userAccount) {
            userAccount = web3.eth.accounts[0];
            // Call a function to update the UI with the new account
            getZombiesByOwner(userAccount)
            .then(displayZombies);
          }
        }, 100);


        // Start here
      }


      function displayZombies(ids) {
        $("#zombies").empty();
        for (id of ids) {
          // Look up zombie details from our contract. Returns a `zombie` object
          getZombieDetails(id)
          .then(function(zombie) {
            // Using ES6's "template literals" to inject variables into the HTML.
            // Append each one to our #zombies div
            $("#zombies").append(`<div class="zombie">
              <ul>
                <li>Name: ${zombie.name}</li>
                <li>DNA: ${zombie.dna}</li>
                <li>Level: ${zombie.level}</li>
                <li>Wins: ${zombie.winCount}</li>
                <li>Losses: ${zombie.lossCount}</li>
                <li>Ready Time: ${zombie.readyTime}</li>
              </ul>
            </div>`);
          });
        }
      }


      function createRandomZombie(name) {
        // This is going to take a while, so update the UI to let the user know
        // the transaction has been sent
        $("#txStatus").text("Creating new zombie on the blockchain. This may take a while...");
        // Send the tx to our contract:
        return CryptoZombies.methods.createRandomZombie(name)
        .send({ from: userAccount })
        .on("receipt", function(receipt) {
          $("#txStatus").text("Successfully created " + name + "!");
          // Transaction was accepted into the blockchain, let's redraw the UI
          getZombiesByOwner(userAccount).then(displayZombies);
        })
        .on("error", function(error) {
          // Do something to alert the user their transaction has failed
          $("#txStatus").text(error);
        });
      }


      function feedOnKitty(zombieId, kittyId) {
        $("#txStatus").text("Eating a kitty. This may take a while...");
        return CryptoZombies.methods.feedOnKitty(zombieId, kittyId)
        .send({ from: userAccount })
        .on("receipt", function(receipt) {
          $("#txStatus").text("Ate a kitty and spawned a new Zombie!");
          getZombiesByOwner(userAccount).then(displayZombies);
        })
        .on("error", function(error) {
          $("#txStatus").text(error);
        });
      }


      function levelUp(zombieId) {
        $("#txStatus").text("Leveling up your zombie...");
        return CryptoZombies.methods.levelUp(zombieId)
        .send({ from: userAccount, value: web3.utils.toWei("0.001", "ether") })
        .on("receipt", function(receipt) {
          $("#txStatus").text("Power overwhelming! Zombie successfully leveled up");
        })
        .on("error", function(error) {
          $("#txStatus").text(error);
        });
      }


      function getZombieDetails(id) {
        return cryptoZombies.methods.zombies(id).call()
      }


      function zombieToOwner(id) {
        return cryptoZombies.methods.zombieToOwner(id).call()
      }


      function getZombiesByOwner(owner) {
        return cryptoZombies.methods.getZombiesByOwner(owner).call()
      }


      window.addEventListener('load', function() {


        // Checking if Web3 has been injected by the browser (Mist/MetaMask)
        if (typeof web3 !== 'undefined') {
          // Use Mist/MetaMask's provider
          web3js = new Web3(web3.currentProvider);
        } else {
          // Handle the case where the user doesn't have Metamask installed
          // Probably show them a message prompting them to install Metamask
        }


        // Now you can start your app & access web3 freely:
        startApp()


      })
    </script>
  </body>
</html>

 

tianlongtc
关注
专栏目录
指南：保护以太坊智能合约的开发者
chinadefi的博客
05-23 334
指南：保护以太坊智能合约的开发者 以太坊使用“智能合约”，或者是使用构建在区块链技术上的可编程软件程序，来支持去中心化应用程序(dApp)、NFT和DAO。以太坊智能合约提供的丰富功能允许web3开发者创建复杂的基于区块链的应用程序。 然而，智能合约的实验性增加了漏洞和错误，随着加密货币市值达到数万亿美元，黑帽黑客正在寻找智能合约中的弱点，以便加以利用。 在本文中，我们将介绍智能合约安全最佳实践、故障安全保护以及用于加强智能合约安全性的智能合约分析工具。 以太坊智能合约简介 以太坊的智能合约是用solid
以太坊智能合约的原理和使用方法
cactusblossom
02-11 8234
一、智能合约概述 1. 智能合约是什么 智能合约本质上是运行在区块链上的一段代码，代码的逻辑定义了合约的内容。 智能合约账户保存了合约当前的运行状态，包括当前余额（balance）、交易次数（nonce）、合约代码（code）、存储（storage 数据结构是MPT）。 2. solidity语言 智能合约的最常用的语言是Solidity，语法上与JavaScript很接近。如下图所示： “pr...
加密僵尸
02-15
加密僵尸
以太猫合约关系梳理（七）
u010304442的博客
04-28 298
这段时间分析以太猫的合约源码，其代码基本都是通过合约继承来实现后续的功能。对于各个合约间的关联，我画了一张图，仅供大家参考，如有表述不正确的地方烦请指出，谢谢。 ...
跟着cryptokitties（以太坊云养猫）学写智能合约（下）
mergerly的专栏
01-17 3163
本人培育的鸭子，只要0.2ETH便宜了 kittes数组，所有的猫都会存储在 kitties数组里，这个数组会不断增长，kittyId其实就是Kitty对象在这个数组中的下标。而kittyId其实就是erc721的tokenId。kitties数组建立了erc721 token 和猫数据结构的映射关系。通过erc721的tokenid就能够获取到Kitty对象数据. kittyIn
以太猫合约之基础合约分析（一）
u010304442的博客
04-26 770
通过https://etherscan.io/查看部署在以太坊主链上的ERC721合约，排在第一位是代币名为CryptoKitties (CK)的合约，其合约地址为：0x06012c8cf97bead5deae237070f9587f8e7a266d。经查询它就是大名鼎鼎的以太猫游戏的合约地址，接下来我们就来撸撸以太猫的源码。 ...
以太猫游戏主合约（六）
u010304442的博客
04-28 326
通过前述5篇博文的分析，分别介绍了以太猫的基础数据，权限控制，生产，拍卖，交易等相关合约代码分析，今天将介绍一下，以太猫游戏开始，宣传猫和一代猫的生成过程以及该休息的主合约。 宣传猫&一代猫 // 游戏刚开始时，有宣传猫和初代猫两种，宣传猫直接给账号，初代猫放大市场拍卖 contract KittyMinting is KittyAuction { uint256 public c...
以太坊智能合约编程2.docx
03-23
- **Embark** 是另一个类似的框架，它提供了集成的开发和测试环境，可以自动处理智能合约的部署和前端应用的链接。 2. **Web开发工具**： - **Meteor** 结合了web3.js库，提供了一种构建DApp的通用web应用程序...
解码以太坊智能合约数据
chinadefi的博客
11-05 2243
解码以太坊智能合约数据 正如我们在之前的文章中所讨论的，智能合约交易类似于智能合约驱动的web3应用程序中的后端API调用。每个智能合约交易和结果应用程序状态更改的细节都记录在称为交易、调用和日志的数据元素中。交易数据元素表示用户发起的函数调用(更准确地说是EOA)，调用数据元素表示智能合约在交易中发起的其他函数调用，而日志数据元素表示交易执行期间发生的事件。 使用这些数据元素，可以非常精细地描述由于交易而在应用程序和区块链上发生的状态更改。当对一个去中心化的web3应用程序的所有交易、跟踪和日志进行汇
以太坊智能合约语言Solidity - 3 数组
weixin_51487151的博客
03-13 2440
3. 数组 1字节（Byte） = 8位 (bit), bytes32 = 256位，bytes1 实质上就等于 int8 3.1 固定长度的字节数组 固定长度的数组一旦被定义就无法再更改，并且长度在一开始就会被显式定义 我们再来创建一个新的文件用来编写代码 pragma solidity ^0.4.0; contract BytesArray { bytes2 num = 125; //如下返回值为2 function getLength() view public retu
cryptokitties(以太坊云养猫)中KittyCore合约源码
03-12
cryptokitties(以太坊云养猫)中KittyCore合约源码,solidity文件，合约地址： 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d ,大家可以好好消化下代码，强烈推荐！
cryptvise:加密网络
03-10
cryptvise:加密网络
以太猫合约地址
软件工程小施同学 的专栏
03-27 3233
0x06012c8cf97bead5deae237070f9587f8e7a266d CryptoKitties: Core | Address 0x06012c8cf97bead5deae237070f9587f8e7a266d | Etherscan
以太猫合约之数据合约分析（二）
u010304442的博客
04-26 442
上一篇讲解以太猫的一些基础合约，包含权限控制和ERC721函数定义合约。本篇将重点介绍以太猫的基础数据合约和ERC721代币实现合约。我们先看以太猫基础数据合约。 以太猫基础数据合约 contract KittyBase is KittyAccessControl { // 事件 event Birth(address owner, uint256 kittyId, uint256...
智能合约遇到的问题整合
猴赛雷艾米军
03-08 1095
参考文档： 手把手参考文档链接：https://blog.csdn.net/liyuechun520/article/details/78036363 Solidity 编译合约错误 No visibility specified. Did you intend to add "public"：https://www.twle.cn/t/640#reply1 https://blog.csdn.net/weixin_45112822/article/details/90480872 第一...
跟着cryptokitties（以太坊云养猫）学写智能合约（上）
mergerly的专栏
01-17 6689
cryptokitties（以太坊云养猫）是近期出现在以太坊区块链上一个游戏。超级可爱的猫形象，再配合上繁殖，配种，拍卖这样丰富的玩法，一下子就引爆了以太坊的区块链。这款游戏的核心是基于以太坊的智能合约，也是第一款基于智能合约的游戏。这款游戏除了繁殖时候的基因工程合约以外，其他合约都是开源的，她的源码对于学习智能合约的编写有着很大的启发意义。下面是我的一点点对于智能合约和cryptokitties
智能合约的典型应用场景
以太猫的博客
06-05 2796
dao 数字共识空间（我正在测试中的加密货币2.0的新术语）中最热门的主题之一是分散的自治实体的概念。现在有许多团体迅速涉足这一领域，包括Bitshares（也称为Invictus Innovations）开发“去中心化自治公司”，BitAngels的David Johnston具有去中心化应用程序，我们自己的去中心化自治公司概念，此后转变为更为普遍且不一定是财务的“权力下放的自治组织”（DAO）；总而言之，可以肯定地说，“ DAOism”正逐步成为准网络宗教。但是，潜伏在空间下面的一个隐藏问题是一个相当公
第一个solidity智能合约遇到的坑
终生学习
05-23 9707
自学solidity智能合约遇到的第一个坑，照着老师的写了一段代码，编译的时候遇到版本问题，语法发生了巨大改变范例的代码：如果没有选择正确的版本号，编译会出现如下错误，我们来一步一步解决：下面我把修改后的完整代码贴出来： 范例的代码： pragma solidity ^0.4.4; 表示0.4.4以上，0.5以下版本兼容： 编译环境是在http://remix.ethereum.org 需要注意选...
go-ethereum-code-analysis 以太坊源码分析
热门推荐
omnispace的博客
02-11 1万+
分析go-ethereum的过程，我希望从依赖比较少的底层技术组件开始，慢慢深入到核心逻辑。目录go-ethereum代码阅读环境搭建以太坊黄皮书 符号索引rlp源码解析trie源码分析ethdb源码分析rpc源码分析p2p源码分析eth协议源码分析core源码分析区块链索引 chain_indexer源码分析布隆过滤器索引 bloombits源码分析以太坊的trie树管理 回滚等操作 state...
Truffle与以太坊智能合约编程实践：TDD与Promise应用
本文档深入探讨了以太坊智能合约编程的第三部分，主要关注在Truffle框架中的编程实践和测试驱动开发(TDD)。Truffle是一个用于以太坊智能合约开发的强大工具，特别适合初学者学习和实践。它集成了web3.js的JSPromise...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值