├── LICENSE ├── README.md ├── lesson-1 ├── chapter-10 │ └── Contract.sol ├── chapter-11 │ └── Contract.sol ├── chapter-12 │ └── Contract.sol ├── chapter-13 │ └── Contract.sol ├── chapter-2 │ └── Contract.sol ├── chapter-3 │ └── Contract.sol ├── chapter-4 │ └── Contract.sol ├── chapter-5 │ └── Contract.sol ├── chapter-6 │ └── Contract.sol ├── chapter-7 │ └── Contract.sol ├── chapter-8 │ └── Contract.sol └── chapter-9 │ └── Contract.sol ├── lesson-10 ├── chapter-4 │ └── contracts │ │ └── 2_crypto_zombies.js ├── chapter-5 │ └── truffle.js └── chapter-8 │ └── truffle.js ├── lesson-11 ├── chapter-10 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ └── utils.js ├── chapter-11 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ └── utils.js ├── chapter-12 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ ├── time.js │ │ └── utils.js ├── chapter-13 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ ├── time.js │ │ └── utils.js ├── chapter-14 │ └── truffle.js ├── chapter-2 │ └── test │ │ └── CryptoZombies.js ├── chapter-3 │ └── test │ │ └── CryptoZombies.js ├── chapter-4 │ └── test │ │ └── CryptoZombies.js ├── chapter-5 │ └── test │ │ └── CryptoZombies.js ├── chapter-6 │ └── test │ │ └── CryptoZombies.js ├── chapter-7 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ └── utils.js ├── chapter-8 │ └── test │ │ ├── CryptoZombies.js │ │ └── helpers │ │ └── utils.js └── chapter-9 │ └── test │ ├── CryptoZombies.js │ └── helpers │ └── utils.js ├── lesson-2 ├── chapter-10 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-11 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-12 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-13 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-2 │ └── Contract.sol ├── chapter-3 │ └── Contract.sol ├── chapter-4 │ └── Contract.sol ├── chapter-5 │ └── Contract.sol ├── chapter-6 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-7 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-8 │ ├── zombiefactory.sol │ └── zombiefeeding.sol └── chapter-9 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── lesson-3 ├── chapter-1 │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-10 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-11 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-12 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-2 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-3 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-4 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-5 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-6 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-7 │ ├── ownable.sol │ ├── zombiefactory.sol │ └── zombiefeeding.sol ├── chapter-8 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol └── chapter-9 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── lesson-4 ├── chapter-1 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-10 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-11 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-2 │ ├── ownable.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-3 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-4 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-5 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-6 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-7 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── chapter-8 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol └── chapter-9 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ └── zombiehelper.sol ├── lesson-5 ├── chapter-1 │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-10 │ ├── erc721.sol │ ├── ownable.sol │ ├── safemath.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-11 │ ├── erc721.sol │ ├── ownable.sol │ ├── safemath.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-12 │ ├── erc721.sol │ ├── ownable.sol │ ├── safemath.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-13 │ ├── erc721.sol │ ├── ownable.sol │ ├── safemath.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-2 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-3 │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-4 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-5 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-6 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-7 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol ├── chapter-8 │ ├── erc721.sol │ ├── ownable.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol └── chapter-9 │ ├── erc721.sol │ ├── ownable.sol │ ├── safemath.sol │ ├── zombieattack.sol │ ├── zombiefactory.sol │ ├── zombiefeeding.sol │ ├── zombiehelper.sol │ └── zombieownership.sol └── lesson-6 ├── chapter-1 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-2 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-3 ├── cryptozombies_abi.js ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-4 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-5 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-6 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-7 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol ├── chapter-8 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol └── chapter-9 ├── erc721.sol ├── index.html ├── ownable.sol ├── safemath.sol ├── zombieattack.sol ├── zombiefactory.sol ├── zombiefeeding.sol ├── zombiehelper.sol └── zombieownership.sol /README.md: -------------------------------------------------------------------------------- 1 | # cryptozombies-lesson-code 2 | 3 | ![CryptoZombies](https://user-images.githubusercontent.com/13703497/69648502-c8f3db80-10ae-11ea-9d52-ce4d4bbc426a.jpeg) 4 | 5 | 6 | ## Overview 7 | This repository contains source codes for [Cryptozombies](https://cryptozombies.io/en/) lessons. 8 | 9 | The source codes are divided into `courses` and `chapters` as folders and chapters contain Solidity sample codes for each `lesson`. 10 | 11 | > _NOTE: Lesson 7, 8, 9 has been removed and currently no source code is available for those lessons._ 12 | 13 | ## How To Use 14 | You can simply clone the project to your local storage with following command: 15 | 16 | ``` 17 | git clone https://github.com/loomnetwork/cryptozombies-lesson-code.git 18 | ``` 19 | 20 | Or fork it to modify the sample codes for your own study. 21 | 22 | If you found any error in the codes while you study, Feel free to submit pull requests or issues. 23 | 24 | >_WARNING: Please note that these codes are just sample codes, so DO NOT use them on production._ 25 | 26 | ## License 27 | [![License shields](https://img.shields.io/badge/License-GPL%20v3-blue)](https://www.gnu.org/licenses/gpl-3.0) 28 | 29 | This project is licensed under the GNU General Public License v3.0. See the [LICENSE](https://github.com/loomnetwork/cryptozombies-lesson-code/blob/master/LICENSE) file for details. 30 | -------------------------------------------------------------------------------- /lesson-1/chapter-10/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function _createZombie(string _name, uint _dna) private { 16 | zombies.push(Zombie(_name, _dna)); 17 | } 18 | 19 | function _generateRandomDna(string _str) private view returns (uint) { 20 | 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /lesson-1/chapter-11/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function _createZombie(string _name, uint _dna) private { 16 | zombies.push(Zombie(_name, _dna)); 17 | } 18 | 19 | function _generateRandomDna(string _str) private view returns (uint) { 20 | uint rand = uint(keccak256(abi.encodePacked(_str))); 21 | return rand % dnaModulus; 22 | } 23 | 24 | } -------------------------------------------------------------------------------- /lesson-1/chapter-12/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function _createZombie(string _name, uint _dna) private { 16 | zombies.push(Zombie(_name, _dna)); 17 | } 18 | 19 | function _generateRandomDna(string _str) private view returns (uint) { 20 | uint rand = uint(keccak256(abi.encodePacked(_str))); 21 | return rand % dnaModulus; 22 | } 23 | 24 | function createRandomZombie(string _name) public { 25 | uint randDna = _generateRandomDna(_name); 26 | _createZombie(_name, randDna); 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /lesson-1/chapter-13/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | function _createZombie(string _name, uint _dna) private { 18 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 19 | emit NewZombie(id, _name, _dna); 20 | } 21 | 22 | function _generateRandomDna(string _str) private view returns (uint) { 23 | uint rand = uint(keccak256(abi.encodePacked(_str))); 24 | return rand % dnaModulus; 25 | } 26 | 27 | function createRandomZombie(string _name) public { 28 | uint randDna = _generateRandomDna(_name); 29 | _createZombie(_name, randDna); 30 | } 31 | 32 | } -------------------------------------------------------------------------------- /lesson-1/chapter-2/Contract.sol: -------------------------------------------------------------------------------- 1 | 2 | pragma solidity ^0.4.25; 3 | 4 | contract ZombieFactory { 5 | 6 | uint dnaDigits = 16; 7 | uint dnaModulus = 10 ** dnaDigits; 8 | 9 | struct Zombie { 10 | string name; 11 | uint dna; 12 | } 13 | 14 | Zombie[] public zombies; 15 | 16 | } -------------------------------------------------------------------------------- /lesson-1/chapter-3/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | 7 | } -------------------------------------------------------------------------------- /lesson-1/chapter-4/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | } -------------------------------------------------------------------------------- /lesson-1/chapter-5/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /lesson-1/chapter-6/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /lesson-1/chapter-7/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function createZombie(string _name, uint _dna) { 16 | 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /lesson-1/chapter-8/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function createZombie (string _name, uint _dna) { 16 | zombies.push(Zombie(_name, _dna)); 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /lesson-1/chapter-9/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | uint dnaDigits = 16; 6 | uint dnaModulus = 10 ** dnaDigits; 7 | 8 | struct Zombie { 9 | string name; 10 | uint dna; 11 | } 12 | 13 | Zombie[] public zombies; 14 | 15 | function _createZombie(string _name, uint _dna) private { 16 | zombies.push(Zombie(_name, _dna)); 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /lesson-10/chapter-4/contracts/2_crypto_zombies.js: -------------------------------------------------------------------------------- 1 | var CryptoZombies = artifacts.require("./CryptoZombies.sol"); 2 | module.exports = function(deployer) { 3 | deployer.deploy(CryptoZombies); 4 | }; 5 | -------------------------------------------------------------------------------- /lesson-10/chapter-5/truffle.js: -------------------------------------------------------------------------------- 1 | 2 | const HDWalletProvider = require("truffle-hdwallet-provider"); 3 | 4 | const mnemonic = "YOUR_MNEMONIC"; 5 | 6 | module.exports = { 7 | 8 | networks: { 9 | 10 | mainnet: { 11 | provider: function () { 12 | 13 | return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/YOUR_TOKEN") 14 | }, 15 | network_id: "1" 16 | }, 17 | 18 | rinkeby: { 19 | 20 | provider: function () { 21 | 22 | return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/YOUR_TOKEN") 23 | }, 24 | 25 | network_id: 4 26 | } 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /lesson-10/chapter-8/truffle.js: -------------------------------------------------------------------------------- 1 | // Initialize HDWalletProvider 2 | const HDWalletProvider = require("truffle-hdwallet-provider"); 3 | 4 | const LoomTruffleProvider = require('loom-truffle-provider'); 5 | 6 | const mnemonic = "YOUR_MNEMONIC"; 7 | 8 | module.exports = { 9 | 10 | networks: { 11 | 12 | mainnet: { 13 | provider: function () { 14 | 15 | return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/YOUR_TOKEN") 16 | }, 17 | network_id: "1" 18 | }, 19 | 20 | rinkeby: { 21 | 22 | provider: function () { 23 | 24 | return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/YOUR_TOKEN") 25 | }, 26 | 27 | network_id: 4 28 | }, 29 | 30 | loom_testnet: { 31 | provider: function() { 32 | const privateKey = 'YOUR_PRIVATE_KEY' 33 | const chainId = 'extdev-plasma-us1'; 34 | const writeUrl = 'http://extdev-plasma-us1.dappchains.com:80/rpc'; 35 | const readUrl = 'http://extdev-plasma-us1.dappchains.com:80/query';; 36 | return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey) 37 | }, 38 | network_id: '9545242630824' 39 | } 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lesson-11/chapter-10/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-11/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-12/test/helpers/time.js: -------------------------------------------------------------------------------- 1 | async function increase(duration) { 2 | 3 | //first, let's increase time 4 | await web3.currentProvider.sendAsync({ 5 | jsonrpc: "2.0", 6 | method: "evm_increaseTime", 7 | params: [duration], // there are 86400 seconds in a day 8 | id: new Date().getTime() 9 | }, () => {}); 10 | 11 | //next, let's mine a new block 12 | web3.currentProvider.send({ 13 | jsonrpc: '2.0', 14 | method: 'evm_mine', 15 | params: [], 16 | id: new Date().getTime() 17 | }) 18 | 19 | } 20 | 21 | const duration = { 22 | 23 | seconds: function (val) { 24 | return val; 25 | }, 26 | minutes: function (val) { 27 | return val * this.seconds(60); 28 | }, 29 | hours: function (val) { 30 | return val * this.minutes(60); 31 | }, 32 | days: function (val) { 33 | return val * this.hours(24); 34 | }, 35 | } 36 | 37 | module.exports = { 38 | increase, 39 | duration, 40 | }; 41 | -------------------------------------------------------------------------------- /lesson-11/chapter-12/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-13/test/helpers/time.js: -------------------------------------------------------------------------------- 1 | async function increase(duration) { 2 | 3 | //first, let's increase time 4 | await web3.currentProvider.sendAsync({ 5 | jsonrpc: "2.0", 6 | method: "evm_increaseTime", 7 | params: [duration], // there are 86400 seconds in a day 8 | id: new Date().getTime() 9 | }, () => {}); 10 | 11 | //next, let's mine a new block 12 | web3.currentProvider.send({ 13 | jsonrpc: '2.0', 14 | method: 'evm_mine', 15 | params: [], 16 | id: new Date().getTime() 17 | }) 18 | 19 | } 20 | 21 | const duration = { 22 | 23 | seconds: function (val) { 24 | return val; 25 | }, 26 | minutes: function (val) { 27 | return val * this.seconds(60); 28 | }, 29 | hours: function (val) { 30 | return val * this.minutes(60); 31 | }, 32 | days: function (val) { 33 | return val * this.hours(24); 34 | }, 35 | } 36 | 37 | module.exports = { 38 | increase, 39 | duration, 40 | }; 41 | -------------------------------------------------------------------------------- /lesson-11/chapter-13/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-2/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | contract("CryptoZombies", (accounts) => { 3 | it("should be able to create a new zombie", () => { 4 | 5 | }) 6 | }) 7 | -------------------------------------------------------------------------------- /lesson-11/chapter-3/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | contract("CryptoZombies", (accounts) => { 3 | let [alice, bob] = accounts; 4 | it("should be able to create a new zombie", async () => { 5 | }) 6 | }) 7 | -------------------------------------------------------------------------------- /lesson-11/chapter-4/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | const zombieNames = ["Zombie 1", "Zombie 2"]; 3 | contract("CryptoZombies", (accounts) => { 4 | let [alice, bob] = accounts; 5 | it("should be able to create a new zombie", async () => { 6 | const contractInstance = await CryptoZombies.new(); 7 | }) 8 | }) 9 | -------------------------------------------------------------------------------- /lesson-11/chapter-5/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | const zombieNames = ["Zombie 1", "Zombie 2"]; 3 | contract("CryptoZombies", (accounts) => { 4 | let [alice, bob] = accounts; 5 | it("should be able to create a new zombie", async () => { 6 | const contractInstance = await CryptoZombies.new(); 7 | const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice}); 8 | assert.equal(result.receipt.status, true); 9 | assert.equal(result.logs[0].args.name,zombieNames[0]); 10 | }) 11 | }) 12 | -------------------------------------------------------------------------------- /lesson-11/chapter-6/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | const zombieNames = ["Zombie 1", "Zombie 2"]; 3 | contract("CryptoZombies", (accounts) => { 4 | let [alice, bob] = accounts; 5 | let contractInstance; 6 | beforeEach(async () => { 7 | contractInstance = await CryptoZombies.new(); 8 | }); 9 | it("should be able to create a new zombie", async () => { 10 | const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice}); 11 | assert.equal(result.receipt.status, true); 12 | assert.equal(result.logs[0].args.name,zombieNames[0]); 13 | }) 14 | it("should not allow two zombies", async () => { 15 | }) 16 | }) 17 | -------------------------------------------------------------------------------- /lesson-11/chapter-7/test/CryptoZombies.js: -------------------------------------------------------------------------------- 1 | const CryptoZombies = artifacts.require("CryptoZombies"); 2 | const utils = require("./helpers/utils"); 3 | const zombieNames = ["Zombie 1", "Zombie 2"]; 4 | contract("CryptoZombies", (accounts) => { 5 | let [alice, bob] = accounts; 6 | let contractInstance; 7 | beforeEach(async () => { 8 | contractInstance = await CryptoZombies.new(); 9 | }); 10 | it("should be able to create a new zombie", async () => { 11 | const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice}); 12 | assert.equal(result.receipt.status, true); 13 | assert.equal(result.logs[0].args.name,zombieNames[0]); 14 | }) 15 | it("should not allow two zombies", async () => { 16 | await contractInstance.createRandomZombie(zombieNames[0], {from: alice}); 17 | await utils.shouldThrow(contractInstance.createRandomZombie(zombieNames[1], {from: alice})); 18 | }) 19 | }) 20 | -------------------------------------------------------------------------------- /lesson-11/chapter-7/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-8/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-11/chapter-9/test/helpers/utils.js: -------------------------------------------------------------------------------- 1 | async function shouldThrow(promise) { 2 | try { 3 | await promise; 4 | assert(true); 5 | } 6 | catch (err) { 7 | return; 8 | } 9 | assert(false, "The contract did not throw."); 10 | 11 | } 12 | 13 | module.exports = { 14 | shouldThrow, 15 | }; 16 | -------------------------------------------------------------------------------- /lesson-2/chapter-10/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /lesson-2/chapter-10/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 20 | require(msg.sender == zombieToOwner[_zombieId]); 21 | Zombie storage myZombie = zombies[_zombieId]; 22 | _targetDna = _targetDna % dnaModulus; 23 | uint newDna = (myZombie.dna + _targetDna) / 2; 24 | _createZombie("NoName", newDna); 25 | } 26 | 27 | } -------------------------------------------------------------------------------- /lesson-2/chapter-11/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /lesson-2/chapter-11/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d; 20 | KittyInterface kittyContract = KittyInterface(ckAddress); 21 | 22 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 23 | require(msg.sender == zombieToOwner[_zombieId]); 24 | Zombie storage myZombie = zombies[_zombieId]; 25 | _targetDna = _targetDna % dnaModulus; 26 | uint newDna = (myZombie.dna + _targetDna) / 2; 27 | _createZombie("NoName", newDna); 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /lesson-2/chapter-12/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /lesson-2/chapter-12/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d; 20 | KittyInterface kittyContract = KittyInterface(ckAddress); 21 | 22 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 23 | require(msg.sender == zombieToOwner[_zombieId]); 24 | Zombie storage myZombie = zombies[_zombieId]; 25 | _targetDna = _targetDna % dnaModulus; 26 | uint newDna = (myZombie.dna + _targetDna) / 2; 27 | _createZombie("NoName", newDna); 28 | } 29 | 30 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 31 | uint kittyDna; 32 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 33 | feedAndMultiply(_zombieId, kittyDna); 34 | } 35 | 36 | } -------------------------------------------------------------------------------- /lesson-2/chapter-13/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | randDna = randDna - randDna % 100; 36 | _createZombie(_name, randDna); 37 | } 38 | 39 | } -------------------------------------------------------------------------------- /lesson-2/chapter-13/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d; 20 | KittyInterface kittyContract = KittyInterface(ckAddress); 21 | 22 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 23 | require(msg.sender == zombieToOwner[_zombieId]); 24 | Zombie storage myZombie = zombies[_zombieId]; 25 | _targetDna = _targetDna % dnaModulus; 26 | uint newDna = (myZombie.dna + _targetDna) / 2; 27 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 28 | newDna = newDna - newDna % 100 + 99; 29 | } 30 | _createZombie("NoName", newDna); 31 | } 32 | 33 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 34 | uint kittyDna; 35 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 36 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 37 | } 38 | 39 | } -------------------------------------------------------------------------------- /lesson-2/chapter-2/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | emit NewZombie(id, _name, _dna); 23 | } 24 | 25 | function _generateRandomDna(string _str) private view returns (uint) { 26 | uint rand = uint(keccak256(abi.encodePacked(_str))); 27 | return rand % dnaModulus; 28 | } 29 | 30 | function createRandomZombie(string _name) public { 31 | uint randDna = _generateRandomDna(_name); 32 | _createZombie(_name, randDna); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /lesson-2/chapter-3/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | uint randDna = _generateRandomDna(_name); 34 | _createZombie(_name, randDna); 35 | } 36 | 37 | } -------------------------------------------------------------------------------- /lesson-2/chapter-4/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /lesson-2/chapter-5/Contract.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } 39 | contract ZombieFeeding is ZombieFactory { 40 | } 41 | -------------------------------------------------------------------------------- /lesson-2/chapter-6/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-2/chapter-6/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract ZombieFeeding is ZombieFactory { 4 | } 5 | -------------------------------------------------------------------------------- /lesson-2/chapter-7/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-2/chapter-7/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract ZombieFeeding is ZombieFactory { 4 | 5 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 6 | require(msg.sender == zombieToOwner[_zombieId]); 7 | Zombie storage myZombie = zombies[_zombieId]; 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /lesson-2/chapter-8/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) private { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | _createZombie(_name, randDna); 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /lesson-2/chapter-8/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract ZombieFeeding is ZombieFactory { 4 | 5 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 6 | require(msg.sender == zombieToOwner[_zombieId]); 7 | Zombie storage myZombie = zombies[_zombieId]; 8 | _targetDna = _targetDna % dnaModulus; 9 | uint newDna = (myZombie.dna + _targetDna) / 2; 10 | _createZombie("NoName", newDna); 11 | } 12 | 13 | } -------------------------------------------------------------------------------- /lesson-2/chapter-9/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | contract ZombieFactory { 3 | 4 | event NewZombie(uint zombieId, string name, uint dna); 5 | 6 | uint dnaDigits = 16; 7 | uint dnaModulus = 10 ** dnaDigits; 8 | 9 | struct Zombie { 10 | string name; 11 | uint dna; 12 | } 13 | 14 | Zombie[] public zombies; 15 | 16 | mapping (uint => address) public zombieToOwner; 17 | mapping (address => uint) ownerZombieCount; 18 | 19 | function _createZombie(string _name, uint _dna) internal { 20 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 21 | zombieToOwner[id] = msg.sender; 22 | ownerZombieCount[msg.sender]++; 23 | emit NewZombie(id, _name, _dna); 24 | } 25 | 26 | function _generateRandomDna(string _str) private view returns (uint) { 27 | uint rand = uint(keccak256(abi.encodePacked(_str))); 28 | return rand % dnaModulus; 29 | } 30 | 31 | function createRandomZombie(string _name) public { 32 | require(ownerZombieCount[msg.sender] == 0); 33 | uint randDna = _generateRandomDna(_name); 34 | _createZombie(_name, randDna); 35 | } 36 | 37 | } -------------------------------------------------------------------------------- /lesson-2/chapter-9/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract ZombieFeeding is ZombieFactory { 6 | 7 | function feedAndMultiply(uint _zombieId, uint _targetDna) public { 8 | require(msg.sender == zombieToOwner[_zombieId]); 9 | Zombie storage myZombie = zombies[_zombieId]; 10 | _targetDna = _targetDna % dnaModulus; 11 | uint newDna = (myZombie.dna + _targetDna) / 2; 12 | _createZombie("NoName", newDna); 13 | } 14 | 15 | } -------------------------------------------------------------------------------- /lesson-3/chapter-1/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ZombieFactory { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | randDna = randDna - randDna % 100; 36 | _createZombie(_name, randDna); 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /lesson-3/chapter-1/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | KittyInterface kittyContract; 20 | 21 | function setKittyContractAddress(address _address) external { 22 | kittyContract = KittyInterface(_address); 23 | } 24 | 25 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 26 | require(msg.sender == zombieToOwner[_zombieId]); 27 | Zombie storage myZombie = zombies[_zombieId]; 28 | _targetDna = _targetDna % dnaModulus; 29 | uint newDna = (myZombie.dna + _targetDna) / 2; 30 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 31 | newDna = newDna - newDna % 100 + 99; 32 | } 33 | _createZombie("NoName", newDna); 34 | } 35 | 36 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 37 | uint kittyDna; 38 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 39 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /lesson-3/chapter-10/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-10/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-10/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | modifier aboveLevel(uint _level, uint _zombieId) { 6 | require(zombies[_zombieId].level >= _level); 7 | _; 8 | } 9 | 10 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) { 11 | require(msg.sender == zombieToOwner[_zombieId]); 12 | zombies[_zombieId].name = _newName; 13 | } 14 | 15 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) { 16 | require(msg.sender == zombieToOwner[_zombieId]); 17 | zombies[_zombieId].dna = _newDna; 18 | } 19 | 20 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 21 | 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /lesson-3/chapter-11/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-11/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-11/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | modifier aboveLevel(uint _level, uint _zombieId) { 6 | require(zombies[_zombieId].level >= _level); 7 | _; 8 | } 9 | 10 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) { 11 | require(msg.sender == zombieToOwner[_zombieId]); 12 | zombies[_zombieId].name = _newName; 13 | } 14 | 15 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) { 16 | require(msg.sender == zombieToOwner[_zombieId]); 17 | zombies[_zombieId].dna = _newDna; 18 | } 19 | 20 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 21 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 22 | 23 | return result; 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /lesson-3/chapter-12/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-12/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-12/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | modifier aboveLevel(uint _level, uint _zombieId) { 6 | require(zombies[_zombieId].level >= _level); 7 | _; 8 | } 9 | 10 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) { 11 | require(msg.sender == zombieToOwner[_zombieId]); 12 | zombies[_zombieId].name = _newName; 13 | } 14 | 15 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) { 16 | require(msg.sender == zombieToOwner[_zombieId]); 17 | zombies[_zombieId].dna = _newDna; 18 | } 19 | 20 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 21 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 22 | uint counter = 0; 23 | for (uint i = 0; i < zombies.length; i++) { 24 | if (zombieToOwner[i] == _owner) { 25 | result[counter] = i; 26 | counter++; 27 | } 28 | } 29 | return result; 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /lesson-3/chapter-2/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./ownable.sol"; 3 | contract ZombieFactory is Ownable { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | } 14 | 15 | Zombie[] public zombies; 16 | 17 | mapping (uint => address) public zombieToOwner; 18 | mapping (address => uint) ownerZombieCount; 19 | 20 | function _createZombie(string _name, uint _dna) internal { 21 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 22 | zombieToOwner[id] = msg.sender; 23 | ownerZombieCount[msg.sender]++; 24 | emit NewZombie(id, _name, _dna); 25 | } 26 | 27 | function _generateRandomDna(string _str) private view returns (uint) { 28 | uint rand = uint(keccak256(abi.encodePacked(_str))); 29 | return rand % dnaModulus; 30 | } 31 | 32 | function createRandomZombie(string _name) public { 33 | require(ownerZombieCount[msg.sender] == 0); 34 | uint randDna = _generateRandomDna(_name); 35 | randDna = randDna - randDna % 100; 36 | _createZombie(_name, randDna); 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /lesson-3/chapter-2/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-3/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | 12 | struct Zombie { 13 | string name; 14 | uint dna; 15 | } 16 | 17 | Zombie[] public zombies; 18 | 19 | mapping (uint => address) public zombieToOwner; 20 | mapping (address => uint) ownerZombieCount; 21 | 22 | function _createZombie(string _name, uint _dna) internal { 23 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 24 | zombieToOwner[id] = msg.sender; 25 | ownerZombieCount[msg.sender]++; 26 | emit NewZombie(id, _name, _dna); 27 | } 28 | 29 | function _generateRandomDna(string _str) private view returns (uint) { 30 | uint rand = uint(keccak256(abi.encodePacked(_str))); 31 | return rand % dnaModulus; 32 | } 33 | 34 | function createRandomZombie(string _name) public { 35 | require(ownerZombieCount[msg.sender] == 0); 36 | uint randDna = _generateRandomDna(_name); 37 | randDna = randDna - randDna % 100; 38 | _createZombie(_name, randDna); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /lesson-3/chapter-3/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefactory.sol"; 3 | contract KittyInterface { 4 | function getKitty(uint256 _id) external view returns ( 5 | bool isGestating, 6 | bool isReady, 7 | uint256 cooldownIndex, 8 | uint256 nextActionAt, 9 | uint256 siringWithId, 10 | uint256 birthTime, 11 | uint256 matronId, 12 | uint256 sireId, 13 | uint256 generation, 14 | uint256 genes 15 | ); 16 | } 17 | contract ZombieFeeding is ZombieFactory { 18 | 19 | KittyInterface kittyContract; 20 | 21 | function setKittyContractAddress(address _address) external onlyOwner { 22 | kittyContract = KittyInterface(_address); 23 | } 24 | 25 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 26 | require(msg.sender == zombieToOwner[_zombieId]); 27 | Zombie storage myZombie = zombies[_zombieId]; 28 | _targetDna = _targetDna % dnaModulus; 29 | uint newDna = (myZombie.dna + _targetDna) / 2; 30 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 31 | newDna = newDna - newDna % 100 + 99; 32 | } 33 | _createZombie("NoName", newDna); 34 | } 35 | 36 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 37 | uint kittyDna; 38 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 39 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /lesson-3/chapter-4/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./ownable.sol"; 3 | contract ZombieFactory is Ownable { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | 10 | struct Zombie { 11 | string name; 12 | uint dna; 13 | uint32 level; 14 | uint32 readyTime; 15 | } 16 | 17 | Zombie[] public zombies; 18 | 19 | mapping (uint => address) public zombieToOwner; 20 | mapping (address => uint) ownerZombieCount; 21 | 22 | function _createZombie(string _name, uint _dna) internal { 23 | uint id = zombies.push(Zombie(_name, _dna)) - 1; 24 | zombieToOwner[id] = msg.sender; 25 | ownerZombieCount[msg.sender]++; 26 | emit NewZombie(id, _name, _dna); 27 | } 28 | 29 | function _generateRandomDna(string _str) private view returns (uint) { 30 | uint rand = uint(keccak256(abi.encodePacked(_str))); 31 | return rand % dnaModulus; 32 | } 33 | 34 | function createRandomZombie(string _name) public { 35 | require(ownerZombieCount[msg.sender] == 0); 36 | uint randDna = _generateRandomDna(_name); 37 | randDna = randDna - randDna % 100; 38 | _createZombie(_name, randDna); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /lesson-3/chapter-4/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-5/ownable.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-5/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./ownable.sol"; 3 | contract ZombieFactory is Ownable { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | uint cooldownTime = 1 days; 10 | 11 | struct Zombie { 12 | string name; 13 | uint dna; 14 | uint32 level; 15 | uint32 readyTime; 16 | } 17 | 18 | Zombie[] public zombies; 19 | 20 | mapping (uint => address) public zombieToOwner; 21 | mapping (address => uint) ownerZombieCount; 22 | 23 | function _createZombie(string _name, uint _dna) internal { 24 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 25 | zombieToOwner[id] = msg.sender; 26 | ownerZombieCount[msg.sender]++; 27 | emit NewZombie(id, _name, _dna); 28 | } 29 | 30 | function _generateRandomDna(string _str) private view returns (uint) { 31 | uint rand = uint(keccak256(abi.encodePacked(_str))); 32 | return rand % dnaModulus; 33 | } 34 | 35 | function createRandomZombie(string _name) public { 36 | require(ownerZombieCount[msg.sender] == 0); 37 | uint randDna = _generateRandomDna(_name); 38 | randDna = randDna - randDna % 100; 39 | _createZombie(_name, randDna); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /lesson-3/chapter-5/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-6/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-7/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-8/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-8/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | modifier aboveLevel(uint _level, uint _zombieId) { 6 | require(zombies[_zombieId].level >= _level); 7 | _; 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /lesson-3/chapter-9/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-3/chapter-9/zombiefeeding.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefactory.sol"; 4 | 5 | contract KittyInterface { 6 | function getKitty(uint256 _id) external view returns ( 7 | bool isGestating, 8 | bool isReady, 9 | uint256 cooldownIndex, 10 | uint256 nextActionAt, 11 | uint256 siringWithId, 12 | uint256 birthTime, 13 | uint256 matronId, 14 | uint256 sireId, 15 | uint256 generation, 16 | uint256 genes 17 | ); 18 | } 19 | 20 | contract ZombieFeeding is ZombieFactory { 21 | 22 | KittyInterface kittyContract; 23 | 24 | function setKittyContractAddress(address _address) external onlyOwner { 25 | kittyContract = KittyInterface(_address); 26 | } 27 | 28 | function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) public { 29 | require(msg.sender == zombieToOwner[_zombieId]); 30 | Zombie storage myZombie = zombies[_zombieId]; 31 | _targetDna = _targetDna % dnaModulus; 32 | uint newDna = (myZombie.dna + _targetDna) / 2; 33 | if (keccak256(abi.encodePacked(_species)) == keccak256(abi.encodePacked("kitty"))) { 34 | newDna = newDna - newDna % 100 + 99; 35 | } 36 | _createZombie("NoName", newDna); 37 | } 38 | 39 | function feedOnKitty(uint _zombieId, uint _kittyId) public { 40 | uint kittyDna; 41 | (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId); 42 | feedAndMultiply(_zombieId, kittyDna, "kitty"); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /lesson-3/chapter-9/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | modifier aboveLevel(uint _level, uint _zombieId) { 6 | require(zombies[_zombieId].level >= _level); 7 | _; 8 | } 9 | 10 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) { 11 | require(msg.sender == zombieToOwner[_zombieId]); 12 | zombies[_zombieId].name = _newName; 13 | } 14 | 15 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) { 16 | require(msg.sender == zombieToOwner[_zombieId]); 17 | zombies[_zombieId].dna = _newDna; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /lesson-4/chapter-1/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-1/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | uint levelUpFee = 0.001 ether; 6 | 7 | modifier aboveLevel(uint _level, uint _zombieId) { 8 | require(zombies[_zombieId].level >= _level); 9 | _; 10 | } 11 | 12 | function levelUp(uint _zombieId) external payable { 13 | require(msg.value == levelUpFee); 14 | zombies[_zombieId].level++; 15 | } 16 | 17 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) { 18 | require(msg.sender == zombieToOwner[_zombieId]); 19 | zombies[_zombieId].name = _newName; 20 | } 21 | 22 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) { 23 | require(msg.sender == zombieToOwner[_zombieId]); 24 | zombies[_zombieId].dna = _newDna; 25 | } 26 | 27 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 28 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 29 | uint counter = 0; 30 | for (uint i = 0; i < zombies.length; i++) { 31 | if (zombieToOwner[i] == _owner) { 32 | result[counter] = i; 33 | counter++; 34 | } 35 | } 36 | return result; 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /lesson-4/chapter-10/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | uint randNonce = 0; 5 | uint attackVictoryProbability = 70; 6 | 7 | function randMod(uint _modulus) internal returns(uint) { 8 | randNonce++; 9 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 10 | } 11 | 12 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 13 | Zombie storage myZombie = zombies[_zombieId]; 14 | Zombie storage enemyZombie = zombies[_targetId]; 15 | uint rand = randMod(100); 16 | if (rand <= attackVictoryProbability) { 17 | myZombie.winCount++; 18 | myZombie.level++; 19 | enemyZombie.lossCount++; 20 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /lesson-4/chapter-10/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-4/chapter-10/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-4/chapter-11/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | uint randNonce = 0; 5 | uint attackVictoryProbability = 70; 6 | 7 | function randMod(uint _modulus) internal returns(uint) { 8 | randNonce++; 9 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 10 | } 11 | 12 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 13 | Zombie storage myZombie = zombies[_zombieId]; 14 | Zombie storage enemyZombie = zombies[_targetId]; 15 | uint rand = randMod(100); 16 | if (rand <= attackVictoryProbability) { 17 | myZombie.winCount++; 18 | myZombie.level++; 19 | enemyZombie.lossCount++; 20 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 21 | } else { 22 | myZombie.lossCount++; 23 | enemyZombie.winCount++; 24 | _triggerCooldown(myZombie); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /lesson-4/chapter-11/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-4/chapter-11/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-4/chapter-2/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-3/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | } 5 | -------------------------------------------------------------------------------- /lesson-4/chapter-3/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-4/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | uint randNonce = 0; 5 | 6 | function randMod(uint _modulus) internal returns(uint) { 7 | randNonce++; 8 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lesson-4/chapter-4/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str)));; 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-5/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | uint randNonce = 0; 5 | uint attackVictoryProbability = 70; 6 | 7 | function randMod(uint _modulus) internal returns(uint) { 8 | randNonce++; 9 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 10 | } 11 | 12 | function attack(uint _zombieId, uint _targetId) external { 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /lesson-4/chapter-5/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-6/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external { 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /lesson-4/chapter-6/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-7/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external { 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /lesson-4/chapter-7/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-7/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiefeeding.sol"; 3 | contract ZombieHelper is ZombieFeeding { 4 | 5 | uint levelUpFee = 0.001 ether; 6 | 7 | modifier aboveLevel(uint _level, uint _zombieId) { 8 | require(zombies[_zombieId].level >= _level); 9 | _; 10 | } 11 | 12 | function withdraw() external onlyOwner { 13 | address _owner = owner(); 14 | _owner.transfer(address(this).balance); 15 | } 16 | 17 | function setLevelUpFee(uint _fee) external onlyOwner { 18 | levelUpFee = _fee; 19 | } 20 | 21 | function levelUp(uint _zombieId) external payable { 22 | require(msg.value == levelUpFee); 23 | zombies[_zombieId].level++; 24 | } 25 | 26 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 27 | zombies[_zombieId].name = _newName; 28 | } 29 | 30 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 31 | zombies[_zombieId].dna = _newDna; 32 | } 33 | 34 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 35 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 36 | uint counter = 0; 37 | for (uint i = 0; i < zombies.length; i++) { 38 | if (zombieToOwner[i] == _owner) { 39 | result[counter] = i; 40 | counter++; 41 | } 42 | } 43 | return result; 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-4/chapter-8/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./zombiehelper.sol"; 3 | contract ZombieAttack is ZombieHelper { 4 | uint randNonce = 0; 5 | uint attackVictoryProbability = 70; 6 | 7 | function randMod(uint _modulus) internal returns(uint) { 8 | randNonce++; 9 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 10 | } 11 | 12 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 13 | Zombie storage myZombie = zombies[_zombieId]; 14 | Zombie storage enemyZombie = zombies[_targetId]; 15 | uint rand = randMod(100); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /lesson-4/chapter-8/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-8/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-4/chapter-9/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /lesson-4/chapter-9/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | import "./ownable.sol"; 3 | contract ZombieFactory is Ownable { 4 | 5 | event NewZombie(uint zombieId, string name, uint dna); 6 | 7 | uint dnaDigits = 16; 8 | uint dnaModulus = 10 ** dnaDigits; 9 | uint cooldownTime = 1 days; 10 | 11 | struct Zombie { 12 | string name; 13 | uint dna; 14 | uint32 level; 15 | uint32 readyTime; 16 | uint16 winCount; 17 | uint16 lossCount; 18 | } 19 | 20 | Zombie[] public zombies; 21 | 22 | mapping (uint => address) public zombieToOwner; 23 | mapping (address => uint) ownerZombieCount; 24 | 25 | function _createZombie(string _name, uint _dna) internal { 26 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 27 | zombieToOwner[id] = msg.sender; 28 | ownerZombieCount[msg.sender]++; 29 | emit NewZombie(id, _name, _dna); 30 | } 31 | 32 | function _generateRandomDna(string _str) private view returns (uint) { 33 | uint rand = uint(keccak256(abi.encodePacked(_str))); 34 | return rand % dnaModulus; 35 | } 36 | 37 | function createRandomZombie(string _name) public { 38 | require(ownerZombieCount[msg.sender] == 0); 39 | uint randDna = _generateRandomDna(_name); 40 | randDna = randDna - randDna % 100; 41 | _createZombie(_name, randDna); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /lesson-4/chapter-9/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-1/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-1/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-1/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-1/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | 5 | contract ZombieOwnership is ZombieAttack { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/safemath.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | /** 4 | * @title SafeMath 5 | * @dev Math operations with safety checks that throw on error 6 | */ 7 | library SafeMath { 8 | 9 | /** 10 | * @dev Multiplies two numbers, throws on overflow. 11 | */ 12 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 13 | if (a == 0) { 14 | return 0; 15 | } 16 | uint256 c = a * b; 17 | assert(c / a == b); 18 | return c; 19 | } 20 | 21 | /** 22 | * @dev Integer division of two numbers, truncating the quotient. 23 | */ 24 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 25 | // assert(b > 0); // Solidity automatically throws when dividing by 0 26 | uint256 c = a / b; 27 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 28 | return c; 29 | } 30 | 31 | /** 32 | * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). 33 | */ 34 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 35 | assert(b <= a); 36 | return a - b; 37 | } 38 | 39 | /** 40 | * @dev Adds two numbers, throws on overflow. 41 | */ 42 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 43 | uint256 c = a + b; 44 | assert(c >= a); 45 | return c; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | import "./safemath.sol"; 5 | 6 | contract ZombieFactory is Ownable { 7 | 8 | using SafeMath for uint256; 9 | 10 | event NewZombie(uint zombieId, string name, uint dna); 11 | 12 | uint dnaDigits = 16; 13 | uint dnaModulus = 10 ** dnaDigits; 14 | uint cooldownTime = 1 days; 15 | 16 | struct Zombie { 17 | string name; 18 | uint dna; 19 | uint32 level; 20 | uint32 readyTime; 21 | uint16 winCount; 22 | uint16 lossCount; 23 | } 24 | 25 | Zombie[] public zombies; 26 | 27 | mapping (uint => address) public zombieToOwner; 28 | mapping (address => uint) ownerZombieCount; 29 | 30 | function _createZombie(string _name, uint _dna) internal { 31 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 32 | zombieToOwner[id] = msg.sender; 33 | ownerZombieCount[msg.sender]++; 34 | emit NewZombie(id, _name, _dna); 35 | } 36 | 37 | function _generateRandomDna(string _str) private view returns (uint) { 38 | uint rand = uint(keccak256(abi.encodePacked(_str))); 39 | return rand % dnaModulus; 40 | } 41 | 42 | function createRandomZombie(string _name) public { 43 | require(ownerZombieCount[msg.sender] == 0); 44 | uint randDna = _generateRandomDna(_name); 45 | randDna = randDna - randDna % 100; 46 | _createZombie(_name, randDna); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-10/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[_from] = ownerZombieCount[_from].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals [_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-5/chapter-11/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-11/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-11/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-11/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-5/chapter-12/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-12/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-12/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-12/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-5/chapter-13/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-13/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-13/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-13/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-5/chapter-2/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-2/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-2/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-2/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-2/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | } 9 | -------------------------------------------------------------------------------- /lesson-5/chapter-3/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-3/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-3/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-3/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | function balanceOf(address _owner) external view returns (uint256) { 9 | return ownerZombieCount[_owner]; 10 | } 11 | 12 | function ownerOf(uint256 _tokenId) external view returns (address) { 13 | return zombieToOwner[_tokenId]; 14 | } 15 | 16 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 17 | 18 | } 19 | 20 | function approve(address _approved, uint256 _tokenId) external payable { 21 | 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /lesson-5/chapter-4/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-4/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-4/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-4/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | 18 | } 19 | 20 | function setLevelUpFee(uint _fee) external onlyOwner { 21 | levelUpFee = _fee; 22 | } 23 | 24 | function levelUp(uint _zombieId) external payable { 25 | require(msg.value == levelUpFee); 26 | zombies[_zombieId].level++; 27 | } 28 | 29 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 30 | zombies[_zombieId].name = _newName; 31 | } 32 | 33 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 34 | zombies[_zombieId].dna = _newDna; 35 | } 36 | 37 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 38 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 39 | uint counter = 0; 40 | for (uint i = 0; i < zombies.length; i++) { 41 | if (zombieToOwner[i] == _owner) { 42 | result[counter] = i; 43 | counter++; 44 | } 45 | } 46 | return result; 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /lesson-5/chapter-4/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | function balanceOf(address _owner) external view returns (uint256) { 9 | return ownerZombieCount[_owner]; 10 | } 11 | 12 | function ownerOf(uint256 _tokenId) external view returns (address) { 13 | return zombieToOwner[_tokenId]; 14 | } 15 | 16 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 17 | 18 | } 19 | 20 | function approve(address _approved, uint256 _tokenId) external payable { 21 | 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /lesson-5/chapter-5/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | function balanceOf(address _owner) external view returns (uint256); 7 | function ownerOf(uint256 _tokenId) external view returns (address); 8 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 9 | function approve(address _approved, uint256 _tokenId) external payable; 10 | } 11 | -------------------------------------------------------------------------------- /lesson-5/chapter-5/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-5/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-5/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-5/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | function balanceOf(address _owner) external view returns (uint256) { 9 | return ownerZombieCount[_owner]; 10 | } 11 | 12 | function ownerOf(uint256 _tokenId) external view returns (address) { 13 | return zombieToOwner[_tokenId]; 14 | } 15 | 16 | function _transfer(address _from, address _to, uint256 _tokenId) private { 17 | ownerZombieCount[_to]++; 18 | ownerZombieCount[_from]--; 19 | zombieToOwner[_tokenId] = _to; 20 | emit Transfer(_from, _to, _tokenId); 21 | } 22 | 23 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 24 | 25 | } 26 | 27 | function approve(address _approved, uint256 _tokenId) external payable { 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /lesson-5/chapter-6/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-6/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-6/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-6/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-6/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | mapping (uint => address) zombieApprovals; 9 | 10 | function balanceOf(address _owner) external view returns (uint256) { 11 | return ownerZombieCount[_owner]; 12 | } 13 | 14 | function ownerOf(uint256 _tokenId) external view returns (address) { 15 | return zombieToOwner[_tokenId]; 16 | } 17 | 18 | function _transfer(address _from, address _to, uint256 _tokenId) private { 19 | ownerZombieCount[_to]++; 20 | ownerZombieCount[_from]--; 21 | zombieToOwner[_tokenId] = _to; 22 | emit Transfer(_from, _to, _tokenId); 23 | } 24 | 25 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 26 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 27 | _transfer(_from, _to, _tokenId); 28 | } 29 | 30 | function approve(address _approved, uint256 _tokenId) external payable { 31 | 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /lesson-5/chapter-7/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-7/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-7/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-7/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-7/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | mapping (uint => address) zombieApprovals; 9 | 10 | function balanceOf(address _owner) external view returns (uint256) { 11 | return ownerZombieCount[_owner]; 12 | } 13 | 14 | function ownerOf(uint256 _tokenId) external view returns (address) { 15 | return zombieToOwner[_tokenId]; 16 | } 17 | 18 | function _transfer(address _from, address _to, uint256 _tokenId) private { 19 | ownerZombieCount[_to]++; 20 | ownerZombieCount[_from]--; 21 | zombieToOwner[_tokenId] = _to; 22 | emit Transfer(_from, _to, _tokenId); 23 | } 24 | 25 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 26 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 27 | _transfer(_from, _to, _tokenId); 28 | } 29 | 30 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 31 | zombieApprovals[_tokenId] = _approved; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /lesson-5/chapter-8/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-8/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-8/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | 5 | contract ZombieFactory is Ownable { 6 | 7 | event NewZombie(uint zombieId, string name, uint dna); 8 | 9 | uint dnaDigits = 16; 10 | uint dnaModulus = 10 ** dnaDigits; 11 | uint cooldownTime = 1 days; 12 | 13 | struct Zombie { 14 | string name; 15 | uint dna; 16 | uint32 level; 17 | uint32 readyTime; 18 | uint16 winCount; 19 | uint16 lossCount; 20 | } 21 | 22 | Zombie[] public zombies; 23 | 24 | mapping (uint => address) public zombieToOwner; 25 | mapping (address => uint) ownerZombieCount; 26 | 27 | function _createZombie(string _name, uint _dna) internal { 28 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 29 | zombieToOwner[id] = msg.sender; 30 | ownerZombieCount[msg.sender]++; 31 | emit NewZombie(id, _name, _dna); 32 | } 33 | 34 | function _generateRandomDna(string _str) private view returns (uint) { 35 | uint rand = uint(keccak256(abi.encodePacked(_str))); 36 | return rand % dnaModulus; 37 | } 38 | 39 | function createRandomZombie(string _name) public { 40 | require(ownerZombieCount[msg.sender] == 0); 41 | uint randDna = _generateRandomDna(_name); 42 | randDna = randDna - randDna % 100; 43 | _createZombie(_name, randDna); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lesson-5/chapter-8/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-8/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | mapping (uint => address) zombieApprovals; 9 | 10 | function balanceOf(address _owner) external view returns (uint256) { 11 | return ownerZombieCount[_owner]; 12 | } 13 | 14 | function ownerOf(uint256 _tokenId) external view returns (address) { 15 | return zombieToOwner[_tokenId]; 16 | } 17 | 18 | function _transfer(address _from, address _to, uint256 _tokenId) private { 19 | ownerZombieCount[_to]++; 20 | ownerZombieCount[_from]--; 21 | zombieToOwner[_tokenId] = _to; 22 | emit Transfer(_from, _to, _tokenId); 23 | } 24 | 25 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 26 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 27 | _transfer(_from, _to, _tokenId); 28 | } 29 | 30 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 31 | zombieApprovals[_tokenId] = _approved; 32 | emit Approval(msg.sender, _approved, _tokenId); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/safemath.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | /** 4 | * @title SafeMath 5 | * @dev Math operations with safety checks that throw on error 6 | */ 7 | library SafeMath { 8 | 9 | /** 10 | * @dev Multiplies two numbers, throws on overflow. 11 | */ 12 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 13 | if (a == 0) { 14 | return 0; 15 | } 16 | uint256 c = a * b; 17 | assert(c / a == b); 18 | return c; 19 | } 20 | 21 | /** 22 | * @dev Integer division of two numbers, truncating the quotient. 23 | */ 24 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 25 | // assert(b > 0); // Solidity automatically throws when dividing by 0 26 | uint256 c = a / b; 27 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 28 | return c; 29 | } 30 | 31 | /** 32 | * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). 33 | */ 34 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 35 | assert(b <= a); 36 | return a - b; 37 | } 38 | 39 | /** 40 | * @dev Adds two numbers, throws on overflow. 41 | */ 42 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 43 | uint256 c = a + b; 44 | assert(c >= a); 45 | return c; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce++; 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount++; 20 | myZombie.level++; 21 | enemyZombie.lossCount++; 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount++; 25 | enemyZombie.winCount++; 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/zombiefactory.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./ownable.sol"; 4 | import "./safemath.sol"; 5 | 6 | contract ZombieFactory is Ownable { 7 | 8 | using SafeMath for uint256; 9 | 10 | event NewZombie(uint zombieId, string name, uint dna); 11 | 12 | uint dnaDigits = 16; 13 | uint dnaModulus = 10 ** dnaDigits; 14 | uint cooldownTime = 1 days; 15 | 16 | struct Zombie { 17 | string name; 18 | uint dna; 19 | uint32 level; 20 | uint32 readyTime; 21 | uint16 winCount; 22 | uint16 lossCount; 23 | } 24 | 25 | Zombie[] public zombies; 26 | 27 | mapping (uint => address) public zombieToOwner; 28 | mapping (address => uint) ownerZombieCount; 29 | 30 | function _createZombie(string _name, uint _dna) internal { 31 | uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1; 32 | zombieToOwner[id] = msg.sender; 33 | ownerZombieCount[msg.sender]++; 34 | emit NewZombie(id, _name, _dna); 35 | } 36 | 37 | function _generateRandomDna(string _str) private view returns (uint) { 38 | uint rand = uint(keccak256(abi.encodePacked(_str))); 39 | return rand % dnaModulus; 40 | } 41 | 42 | function createRandomZombie(string _name) public { 43 | require(ownerZombieCount[msg.sender] == 0); 44 | uint randDna = _generateRandomDna(_name); 45 | randDna = randDna - randDna % 100; 46 | _createZombie(_name, randDna); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level++; 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-5/chapter-9/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | 6 | contract ZombieOwnership is ZombieAttack, ERC721 { 7 | 8 | mapping (uint => address) zombieApprovals; 9 | 10 | function balanceOf(address _owner) external view returns (uint256) { 11 | return ownerZombieCount[_owner]; 12 | } 13 | 14 | function ownerOf(uint256 _tokenId) external view returns (address) { 15 | return zombieToOwner[_tokenId]; 16 | } 17 | 18 | function _transfer(address _from, address _to, uint256 _tokenId) private { 19 | ownerZombieCount[_to]++; 20 | ownerZombieCount[_from]--; 21 | zombieToOwner[_tokenId] = _to; 22 | emit Transfer(_from, _to, _tokenId); 23 | } 24 | 25 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 26 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 27 | _transfer(_from, _to, _tokenId); 28 | } 29 | 30 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 31 | zombieApprovals[_tokenId] = _approved; 32 | emit Approval(msg.sender, _approved, _tokenId); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /lesson-6/chapter-1/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-1/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CryptoZombies front-end 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /lesson-6/chapter-1/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-1/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-6/chapter-1/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-2/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-2/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CryptoZombies front-end 6 | 7 | 8 | 9 | 10 | 11 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-2/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-2/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-6/chapter-2/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-3/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-3/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CryptoZombies front-end 6 | 7 | 8 | 9 | 10 | 11 | 12 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /lesson-6/chapter-3/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-3/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-6/chapter-3/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-4/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-4/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-4/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-6/chapter-4/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-5/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-5/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-5/zombiehelper.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiefeeding.sol"; 4 | 5 | contract ZombieHelper is ZombieFeeding { 6 | 7 | uint levelUpFee = 0.001 ether; 8 | 9 | modifier aboveLevel(uint _level, uint _zombieId) { 10 | require(zombies[_zombieId].level >= _level); 11 | _; 12 | } 13 | 14 | function withdraw() external onlyOwner { 15 | address _owner = owner(); 16 | _owner.transfer(address(this).balance); 17 | } 18 | 19 | function setLevelUpFee(uint _fee) external onlyOwner { 20 | levelUpFee = _fee; 21 | } 22 | 23 | function levelUp(uint _zombieId) external payable { 24 | require(msg.value == levelUpFee); 25 | zombies[_zombieId].level = zombies[_zombieId].level.add(1); 26 | } 27 | 28 | function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) onlyOwnerOf(_zombieId) { 29 | zombies[_zombieId].name = _newName; 30 | } 31 | 32 | function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) onlyOwnerOf(_zombieId) { 33 | zombies[_zombieId].dna = _newDna; 34 | } 35 | 36 | function getZombiesByOwner(address _owner) external view returns(uint[]) { 37 | uint[] memory result = new uint[](ownerZombieCount[_owner]); 38 | uint counter = 0; 39 | for (uint i = 0; i < zombies.length; i++) { 40 | if (zombieToOwner[i] == _owner) { 41 | result[counter] = i; 42 | counter++; 43 | } 44 | } 45 | return result; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lesson-6/chapter-5/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-6/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-6/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-6/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-7/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-7/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-7/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-8/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-8/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-8/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /lesson-6/chapter-9/erc721.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | contract ERC721 { 4 | event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); 5 | event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); 6 | 7 | function balanceOf(address _owner) external view returns (uint256); 8 | function ownerOf(uint256 _tokenId) external view returns (address); 9 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable; 10 | function approve(address _approved, uint256 _tokenId) external payable; 11 | } 12 | -------------------------------------------------------------------------------- /lesson-6/chapter-9/zombieattack.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombiehelper.sol"; 4 | 5 | contract ZombieAttack is ZombieHelper { 6 | uint randNonce = 0; 7 | uint attackVictoryProbability = 70; 8 | 9 | function randMod(uint _modulus) internal returns(uint) { 10 | randNonce = randNonce.add(1); 11 | return uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus; 12 | } 13 | 14 | function attack(uint _zombieId, uint _targetId) external onlyOwnerOf(_zombieId) { 15 | Zombie storage myZombie = zombies[_zombieId]; 16 | Zombie storage enemyZombie = zombies[_targetId]; 17 | uint rand = randMod(100); 18 | if (rand <= attackVictoryProbability) { 19 | myZombie.winCount = myZombie.winCount.add(1); 20 | myZombie.level = myZombie.level.add(1); 21 | enemyZombie.lossCount = enemyZombie.lossCount.add(1); 22 | feedAndMultiply(_zombieId, enemyZombie.dna, "zombie"); 23 | } else { 24 | myZombie.lossCount = myZombie.lossCount.add(1); 25 | enemyZombie.winCount = enemyZombie.winCount.add(1); 26 | _triggerCooldown(myZombie); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /lesson-6/chapter-9/zombieownership.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.25; 2 | 3 | import "./zombieattack.sol"; 4 | import "./erc721.sol"; 5 | import "./safemath.sol"; 6 | 7 | contract ZombieOwnership is ZombieAttack, ERC721 { 8 | 9 | using SafeMath for uint256; 10 | 11 | mapping (uint => address) zombieApprovals; 12 | 13 | function balanceOf(address _owner) external view returns (uint256) { 14 | return ownerZombieCount[_owner]; 15 | } 16 | 17 | function ownerOf(uint256 _tokenId) external view returns (address) { 18 | return zombieToOwner[_tokenId]; 19 | } 20 | 21 | function _transfer(address _from, address _to, uint256 _tokenId) private { 22 | ownerZombieCount[_to] = ownerZombieCount[_to].add(1); 23 | ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].sub(1); 24 | zombieToOwner[_tokenId] = _to; 25 | emit Transfer(_from, _to, _tokenId); 26 | } 27 | 28 | function transferFrom(address _from, address _to, uint256 _tokenId) external payable { 29 | require (zombieToOwner[_tokenId] == msg.sender || zombieApprovals[_tokenId] == msg.sender); 30 | _transfer(_from, _to, _tokenId); 31 | } 32 | 33 | function approve(address _approved, uint256 _tokenId) external payable onlyOwnerOf(_tokenId) { 34 | zombieApprovals[_tokenId] = _approved; 35 | emit Approval(msg.sender, _approved, _tokenId); 36 | } 37 | 38 | } 39 | --------------------------------------------------------------------------------