├── .solhintignore
├── .npmignore
├── .eslintignore
├── .prettierignore
├── .prettierrc
├── .gitignore
├── contracts
    ├── test
    │   ├── LinkToken.sol
    │   ├── VRFCoordinatorMock.sol
    │   └── MockUFO.sol
    ├── ChampionQuestToken.sol
    └── ChampionQuest.sol
├── .solhint.json
├── .env.example
├── .eslintrc.js
├── hardhat-helper-config.js
├── deploy
    ├── 01_deploy_champion_quest_token.js
    ├── 00_deploy_mocks.js
    └── 02_deploy_champion_quest.js
├── package.json
├── scripts
    └── deploy.js
├── hardhat.config.js
├── README.md
├── test
    ├── championQuestToken.test.js
    └── championQuest.test.js
└── gasReport.md


/.solhintignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | hardhat.config.js
2 | scripts
3 | test
4 | 


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | artifacts
3 | cache
4 | coverage
5 | 


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | artifacts
3 | cache
4 | coverage*
5 | gasReporterOutput.json
6 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |     "semi": false,
3 |     "trailingComma": "all",
4 |     "printWidth": 127
5 | }
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | node_modules
 2 | .env
 3 | coverage
 4 | coverage.json
 5 | typechain
 6 | 
 7 | #Hardhat files
 8 | cache
 9 | artifacts
10 | 


--------------------------------------------------------------------------------
/contracts/test/LinkToken.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.4.24;
3 | 
4 | import "@chainlink/token/contracts/v0.4/LinkToken.sol";
5 | 


--------------------------------------------------------------------------------
/contracts/test/VRFCoordinatorMock.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.6.0;
3 | 
4 | import "@chainlink/contracts/src/v0.6/tests/VRFCoordinatorMock.sol";
5 | 


--------------------------------------------------------------------------------
/.solhint.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "solhint:recommended",
3 |   "rules": {
4 |     "compiler-version": ["error", "^0.8.0"],
5 |     "func-visibility": ["warn", { "ignoreConstructors": true }]
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
1 | ETHERSCAN_API_KEY=ABC123ABC123ABC123ABC123ABC123ABC1
2 | ROPSTEN_URL=https://eth-ropsten.alchemyapi.io/v2/<YOUR ALCHEMY KEY>
3 | PRIVATE_KEY=0xabc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1
4 | 


--------------------------------------------------------------------------------
/contracts/test/MockUFO.sol:
--------------------------------------------------------------------------------
 1 | // contracts/GLDToken.sol
 2 | // SPDX-License-Identifier: MIT
 3 | pragma solidity ^0.8.0;
 4 | 
 5 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 6 | 
 7 | contract MockUFO is ERC20 {
 8 |     constructor(uint256 initial_supply) ERC20("UFO", "UFO") {
 9 |         _mint(msg.sender, initial_supply); // 5000 UFOs
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   env: {
 3 |     browser: false,
 4 |     es2021: true,
 5 |     mocha: true,
 6 |     node: true,
 7 |   },
 8 |   plugins: ["@typescript-eslint"],
 9 |   extends: [
10 |     "standard",
11 |     "plugin:prettier/recommended",
12 |     "plugin:node/recommended",
13 |   ],
14 |   "prettier/prettier": ["error", {}, {
15 |     "usePrettierrc": true
16 |   }],
17 |   parser: "@typescript-eslint/parser",
18 |   parserOptions: {
19 |     ecmaVersion: 12,
20 |   },
21 |   rules: {
22 |     "node/no-unsupported-features/es-syntax": [
23 |       "error",
24 |       { ignores: ["modules"] },
25 |     ],
26 |   },
27 | };
28 | 


--------------------------------------------------------------------------------
/hardhat-helper-config.js:
--------------------------------------------------------------------------------
 1 | const networkConfig = {
 2 |     hardhat: {
 3 |         id: 31337,
 4 |         linkToken: "0xa36085F69e2889c224210F603D836748e7dC0088",
 5 |         oracle: "0xc57b33452b4f7bb189bb5afae9cc4aba1f7a4fd8",
 6 |         jobId: "d5270d1c311941d0b08bead21fea7747",
 7 |         fundAmount: "1000000000000000000",
 8 |         keyHash: '0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4',
 9 |         fee: '100000000000000000',
10 |         battleFee: '100000000000000000',
11 |         ufoInitialSupply: '5000000000000000000000'
12 |     }
13 | }
14 | 
15 | const developmentChains = ["hardhat", "localhost"]
16 | 
17 | module.exports = {
18 |     networkConfig,
19 |     developmentChains
20 | }
21 | 


--------------------------------------------------------------------------------
/deploy/01_deploy_champion_quest_token.js:
--------------------------------------------------------------------------------
 1 | /* eslint-disable node/no-unpublished-import */
 2 | // eslint-disable-next-line node/no-missing-import
 3 | 
 4 | const hre = require("hardhat")
 5 | 
 6 | const deployMocks = async function (hre) {
 7 |     const { deployments, getNamedAccounts, getChainId } = hre
 8 |     const { deploy, log, get } = deployments
 9 |     const { deployer } = await getNamedAccounts()
10 |     const chainId = await getChainId()
11 |     const ufoToken = await get("MockUFO")
12 |     const championQuestToken = await deploy("ChampionQuestToken", {
13 |         from: deployer,
14 |         log: true,
15 |         args: [ufoToken.address],
16 |     })
17 | }
18 | module.exports = deployMocks
19 | deployMocks.tags = ["all", "token"]
20 | 


--------------------------------------------------------------------------------
/contracts/ChampionQuestToken.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.0;
 3 | 
 4 | // inspired by woofy: https://etherscan.io/address/0xd0660cd418a64a1d44e9214ad8e459324d8157f1#code
 5 | 
 6 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 7 | import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 8 | 
 9 | contract ChampionQuestToken is ERC20 {
10 |     IERC20 public immutable s_ufoToken;
11 | 
12 |     constructor(address ufoTokenAddress) ERC20("ChampionQuestToken", "CQT") {
13 |         s_ufoToken = IERC20(ufoTokenAddress);
14 |     }
15 | 
16 |     function decimals() public view virtual override returns (uint8) {
17 |         return 12;
18 |     }
19 | 
20 |     function swapUFOForCQT(uint256 amount) public {
21 |         s_ufoToken.transferFrom(msg.sender, address(this), amount);
22 |         _mint(msg.sender, amount);
23 |     }
24 | 
25 |     function swapCQTForUFO(uint256 amount) public {
26 |         _burn(msg.sender, amount);
27 |         s_ufoToken.transfer(msg.sender, amount);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "hardhat-project",
 3 |   "devDependencies": {
 4 |     "@nomiclabs/hardhat-ethers": "^2.0.2",
 5 |     "@nomiclabs/hardhat-etherscan": "^2.1.7",
 6 |     "@nomiclabs/hardhat-waffle": "^2.0.1",
 7 |     "chai": "^4.3.4",
 8 |     "dotenv": "^10.0.0",
 9 |     "eslint": "^7.32.0",
10 |     "eslint-config-prettier": "^8.3.0",
11 |     "eslint-config-standard": "^16.0.3",
12 |     "eslint-plugin-import": "^2.25.3",
13 |     "eslint-plugin-node": "^11.1.0",
14 |     "eslint-plugin-prettier": "^3.4.1",
15 |     "eslint-plugin-promise": "^5.1.1",
16 |     "ethereum-waffle": "^3.4.0",
17 |     "ethers": "^5.5.1",
18 |     "hardhat": "^2.6.8",
19 |     "hardhat-gas-reporter": "^1.0.4",
20 |     "prettier": "^2.4.1",
21 |     "prettier-plugin-solidity": "^1.0.0-beta.13",
22 |     "solhint": "^3.3.6",
23 |     "solidity-coverage": "^0.7.17"
24 |   },
25 |   "dependencies": {
26 |     "@appliedblockchain/chainlink-plugins-fund-link": "^0.0.3",
27 |     "@chainlink/contracts": "^0.2.2",
28 |     "@chainlink/token": "^1.1.0",
29 |     "@openzeppelin/contracts": "^4.3.3",
30 |     "hardhat-deploy": "^0.9.13"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/scripts/deploy.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // When running the script with `npx hardhat run <script>` you'll find the Hardhat
 5 | // Runtime Environment's members available in the global scope.
 6 | const hre = require("hardhat");
 7 | 
 8 | async function main() {
 9 |   // Hardhat always runs the compile task when running scripts with its command
10 |   // line interface.
11 |   //
12 |   // If this script is run directly using `node` you may want to call compile
13 |   // manually to make sure everything is compiled
14 |   // await hre.run('compile');
15 | 
16 |   // We get the contract to deploy
17 |   const Greeter = await hre.ethers.getContractFactory("Greeter");
18 |   const greeter = await Greeter.deploy("Hello, Hardhat!");
19 | 
20 |   await greeter.deployed();
21 | 
22 |   console.log("Greeter deployed to:", greeter.address);
23 | }
24 | 
25 | // We recommend this pattern to be able to use async/await everywhere
26 | // and properly handle errors.
27 | main().catch((error) => {
28 |   console.error(error);
29 |   process.exitCode = 1;
30 | });
31 | 


--------------------------------------------------------------------------------
/deploy/00_deploy_mocks.js:
--------------------------------------------------------------------------------
 1 | /* eslint-disable node/no-unpublished-import */
 2 | // eslint-disable-next-line node/no-missing-import
 3 | 
 4 | // const hre = require("hardhat")
 5 | const { networkConfig } = require("../hardhat-helper-config")
 6 | const { network } = require("hardhat")
 7 | 
 8 | const deployMocks = async function (hre) {
 9 |   const { deployments, getNamedAccounts, getChainId } = hre
10 |   const { deploy, log } = deployments
11 |   const { deployer } = await getNamedAccounts()
12 |   const chainId = await getChainId()
13 |   if (chainId === "31337") {
14 |     log("Local network detected! Deploying mocks...")
15 |     const linkToken = await deploy("LinkToken", {
16 |       from: deployer,
17 |       log: true,
18 |       args: [],
19 |     })
20 |     await deploy("VRFCoordinatorMock", {
21 |       from: deployer,
22 |       log: true,
23 |       args: [linkToken.address],
24 |     })
25 |     await deploy("MockUFO", {
26 |       from: deployer,
27 |       log: true,
28 |       args: [networkConfig[network.name].ufoInitialSupply],
29 |     })
30 |     log("Mocks Deployed!")
31 |     log("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
32 |     log(
33 |       "You are deploying to a local network, you'll need a local network running to interact"
34 |     )
35 |     log(
36 |       "Please run `npx hardhat console` to interact with the deployed smart contracts!"
37 |     )
38 |     log("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
39 |   }
40 | }
41 | module.exports = deployMocks
42 | deployMocks.tags = ["all", "mocks"]
43 | 


--------------------------------------------------------------------------------
/deploy/02_deploy_champion_quest.js:
--------------------------------------------------------------------------------
 1 | /* eslint-disable node/no-unpublished-import */
 2 | // eslint-disable-next-line node/no-missing-import
 3 | 
 4 | const { network } = require("hardhat")
 5 | const { networkConfig, developmentChains } = require("../hardhat-helper-config")
 6 | 
 7 | const deployMocks = async function (hre) {
 8 |     const { deployments, getNamedAccounts, getChainId } = hre
 9 |     const { deploy, log, get } = deployments
10 |     const { deployer } = await getNamedAccounts()
11 |     const chainId = await getChainId()
12 |     const ufoToken = await get("MockUFO")
13 |     let vrfCoodinator, linkToken, championQuestToken, keyHash, fee, battleFee
14 |     if (developmentChains.includes(network.name)) {
15 |         vrfCoodinator = (await get("VRFCoordinatorMock")).address
16 |         linkToken = (await get("LinkToken")).address
17 | 
18 |     } else {
19 |         vrfCoodinator = networkConfig[network.name].vrfCoodinator
20 |         linkToken = networkConfig[network.name].linkToken
21 |     }
22 |     championQuestToken = await get("ChampionQuestToken") // should use config actually.. but whatever
23 |     keyHash = networkConfig[network.name].keyHash
24 |     fee = networkConfig[network.name].fee
25 |     battleFee = networkConfig[network.name].battleFee
26 | 
27 |     const championQuest = await deploy("ChampionQuest", {
28 |         from: deployer,
29 |         log: true,
30 |         args: [vrfCoodinator, linkToken, championQuestToken.address, keyHash, fee, battleFee],
31 |     })
32 | }
33 | module.exports = deployMocks
34 | deployMocks.tags = ["all", "token"]
35 | 


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | require("dotenv").config();
 2 | 
 3 | require("@nomiclabs/hardhat-etherscan");
 4 | require("@nomiclabs/hardhat-waffle");
 5 | require("hardhat-gas-reporter");
 6 | require("solidity-coverage");
 7 | require("hardhat-deploy");
 8 | require("hardhat-gas-reporter");
 9 | require("@nomiclabs/hardhat-ethers");
10 | require("@appliedblockchain/chainlink-plugins-fund-link")
11 | 
12 | // This is a sample Hardhat task. To learn how to create your own go to
13 | // https://hardhat.org/guides/create-task.html
14 | task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
15 |   const accounts = await hre.ethers.getSigners();
16 | 
17 |   for (const account of accounts) {
18 |     console.log(account.address);
19 |   }
20 | });
21 | 
22 | // You need to export an object to set up your config
23 | // Go to https://hardhat.org/config/ to learn more
24 | 
25 | /**
26 |  * @type import('hardhat/config').HardhatUserConfig
27 |  */
28 | module.exports = {
29 |   solidity: {
30 |     compilers: [
31 |       {
32 |         version: '0.6.6'
33 |       },
34 |       {
35 |         version: '0.4.24'
36 |       },
37 |       {
38 |         version: '0.8.7'
39 |       }
40 |     ]
41 |   },
42 |   networks: {
43 |     ropsten: {
44 |       url: process.env.ROPSTEN_URL || "",
45 |       accounts:
46 |         process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
47 |     },
48 |   },
49 |   gasReporter: {
50 |     enabled: true,
51 |     currency: "USD",
52 |     outputFile: "gasReport.md",
53 |     noColors: true
54 |   },
55 |   etherscan: {
56 |     apiKey: process.env.ETHERSCAN_API_KEY,
57 |   },
58 |   namedAccounts: {
59 |     deployer: {
60 |       default: 0,
61 |     }
62 |   },
63 | };
64 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Advanced Sample Hardhat Project
 2 | 
 3 | This project demonstrates an advanced Hardhat use case, integrating other tools commonly used alongside Hardhat in the ecosystem.
 4 | 
 5 | The project comes with a sample contract, a test for that contract, a sample script that deploys that contract, and an example of a task implementation, which simply lists the available accounts. It also comes with a variety of other tools, preconfigured to work with the project code.
 6 | 
 7 | Try running some of the following tasks:
 8 | 
 9 | ```shell
10 | npx hardhat accounts
11 | npx hardhat compile
12 | npx hardhat clean
13 | npx hardhat test
14 | npx hardhat node
15 | npx hardhat help
16 | REPORT_GAS=true npx hardhat test
17 | npx hardhat coverage
18 | npx hardhat run scripts/deploy.js
19 | node scripts/deploy.js
20 | npx eslint '**/*.js'
21 | npx eslint '**/*.js' --fix
22 | npx prettier '**/*.{json,sol,md}' --check
23 | npx prettier '**/*.{json,sol,md}' --write
24 | npx solhint 'contracts/**/*.sol'
25 | npx solhint 'contracts/**/*.sol' --fix
26 | ```
27 | 
28 | # Etherscan verification
29 | 
30 | To try out Etherscan verification, you first need to deploy a contract to an Ethereum network that's supported by Etherscan, such as Ropsten.
31 | 
32 | In this project, copy the .env.example file to a file named .env, and then edit it to fill in the details. Enter your Etherscan API key, your Ropsten node URL (eg from Alchemy), and the private key of the account which will send the deployment transaction. With a valid .env file in place, first deploy your contract:
33 | 
34 | ```shell
35 | hardhat run --network ropsten scripts/deploy.js
36 | ```
37 | 
38 | Then, copy the deployment address and paste it in to replace `DEPLOYED_CONTRACT_ADDRESS` in this command:
39 | 
40 | ```shell
41 | npx hardhat verify --network ropsten DEPLOYED_CONTRACT_ADDRESS "Hello, Hardhat!"
42 | ```
43 | 


--------------------------------------------------------------------------------
/test/championQuestToken.test.js:
--------------------------------------------------------------------------------
 1 | const { networkConfig, developmentChains } = require("../hardhat-helper-config")
 2 | const { network, deployments, ethers } = require("hardhat")
 3 | const { expect } = require('chai')
 4 | 
 5 | describe('championQuestToken', async () => {
 6 |     let runTest = false
 7 |     let ufoSwapAmount = ethers.utils.parseEther('1')
 8 |     let championQuestToken, mockUFO, admin
 9 |     beforeEach(async () => {
10 |         if (developmentChains.includes(network.name)) {
11 |             runTest = true
12 |         }
13 |         accounts = await ethers.getSigners()
14 |         admin = accounts[0]
15 |         if (runTest) {
16 |             await deployments.fixture(["all"])
17 |             let championQuestTokenDeployment = await deployments.get("ChampionQuestToken")
18 |             championQuestToken = await ethers.getContractAt("ChampionQuestToken", championQuestTokenDeployment.address, admin)
19 |             mockUFODeployment = await deployments.get("MockUFO")
20 |             mockUFO = await ethers.getContractAt("MockUFO", mockUFODeployment.address, admin)
21 | 
22 |         }
23 |     })
24 |     it("swapUFOForCQT should be able to swap UFO token for CQT", async () => {
25 |         if (runTest) {
26 |             expect(await championQuestToken.balanceOf(admin.address)).to.eq(0)
27 |             expect(await mockUFO.balanceOf(admin.address)).to.eq(networkConfig[network.name].ufoInitialSupply)
28 |             await mockUFO.approve(championQuestToken.address, ufoSwapAmount)
29 |             await championQuestToken.swapUFOForCQT(ufoSwapAmount)
30 |             expect(await championQuestToken.balanceOf(admin.address)).to.eq(ufoSwapAmount)
31 |         }
32 |     })
33 |     it("swapUFOForCQT should be able to swap CQT token for UFO", async () => {
34 |         if (runTest) {
35 |             await mockUFO.approve(championQuestToken.address, ufoSwapAmount)
36 |             await championQuestToken.swapUFOForCQT(ufoSwapAmount)
37 |             expect(await championQuestToken.totalSupply()).to.eq(ufoSwapAmount)
38 |             await championQuestToken.swapCQTForUFO(ufoSwapAmount)
39 |             expect(await championQuestToken.balanceOf(admin.address)).to.eq(0)
40 |             expect(await championQuestToken.totalSupply()).to.eq(0)
41 |         }
42 |     })
43 | })
44 | 


--------------------------------------------------------------------------------
/gasReport.md:
--------------------------------------------------------------------------------
 1 | ·---------------------------------------------------|----------------------------|-------------|-----------------------------·
 2 | |                Solc version: 0.6.6                ·  Optimizer enabled: false  ·  Runs: 200  ·  Block limit: 30000000 gas  │
 3 | ····················································|····························|·············|······························
 4 | |  Methods                                                                                                                   │
 5 | ·······················|····························|··············|·············|·············|···············|··············
 6 | |  Contract            ·  Method                    ·  Min         ·  Max        ·  Avg        ·  # calls      ·  usd (avg)  │
 7 | ·······················|····························|··············|·············|·············|···············|··············
 8 | |  ChampionQuest       ·  requestBattle             ·           -  ·          -  ·     160674  ·            2  ·          -  │
 9 | ·······················|····························|··············|·············|·············|···············|··············
10 | |  ChampionQuest       ·  requestNewRandomChampion  ·      112704  ·     146892  ·     135496  ·            6  ·          -  │
11 | ·······················|····························|··············|·············|·············|···············|··············
12 | |  ChampionQuestToken  ·  approve                   ·           -  ·          -  ·      46892  ·            1  ·          -  │
13 | ·······················|····························|··············|·············|·············|···············|··············
14 | |  ChampionQuestToken  ·  swapUFOForCQT             ·           -  ·          -  ·     105835  ·            1  ·          -  │
15 | ·······················|····························|··············|·············|·············|···············|··············
16 | |  LinkToken           ·  transfer                  ·           -  ·          -  ·      51799  ·            4  ·          -  │
17 | ·······················|····························|··············|·············|·············|···············|··············
18 | |  MockUFO             ·  approve                   ·           -  ·          -  ·      46881  ·            1  ·          -  │
19 | ·······················|····························|··············|·············|·············|···············|··············
20 | |  VRFCoordinatorMock  ·  callBackWithRandomness    ·       70188  ·     173525  ·     139138  ·            4  ·          -  │
21 | ·······················|····························|··············|·············|·············|···············|··············
22 | |  Deployments                                      ·                                          ·  % of limit   ·             │
23 | ····················································|··············|·············|·············|···············|··············
24 | |  ChampionQuest                                    ·           -  ·          -  ·    4365641  ·       14.6 %  ·          -  │
25 | ····················································|··············|·············|·············|···············|··············
26 | |  ChampionQuestToken                               ·           -  ·          -  ·    1658467  ·        5.5 %  ·          -  │
27 | ····················································|··············|·············|·············|···············|··············
28 | |  LinkToken                                        ·           -  ·          -  ·    1279499  ·        4.3 %  ·          -  │
29 | ····················································|··············|·············|·············|···············|··············
30 | |  MockUFO                                          ·           -  ·          -  ·    1245554  ·        4.2 %  ·          -  │
31 | ····················································|··············|·············|·············|···············|··············
32 | |  VRFCoordinatorMock                               ·           -  ·          -  ·     363662  ·        1.2 %  ·          -  │
33 | ·---------------------------------------------------|--------------|-------------|-------------|---------------|-------------·


--------------------------------------------------------------------------------
/test/championQuest.test.js:
--------------------------------------------------------------------------------
 1 | const { networkConfig, developmentChains } = require("../hardhat-helper-config")
 2 | const { network, deployments, ethers, run } = require("hardhat")
 3 | const { expect } = require('chai')
 4 | 
 5 | describe('championQuest', async () => {
 6 |     let runTest = false
 7 |     const ufoSwapAmount = '1000000000000000000'
 8 |     const randomNumber = '777'
 9 |     const randomNumber2 = '222'
10 |     const championName = "champ"
11 |     const championName2 = "champ2"
12 |     let championQuest, championQuestToken, vrfCoordinator, UFO, admin, linkToken
13 |     beforeEach(async () => {
14 |         if (developmentChains.includes(network.name)) {
15 |             runTest = true
16 |         }
17 |         accounts = await ethers.getSigners()
18 |         admin = accounts[0]
19 |         if (runTest) {
20 |             await deployments.fixture(["all"])
21 |             let championQuestTokenDeployment = await deployments.get("ChampionQuestToken")
22 |             championQuestToken = await ethers.getContractAt("ChampionQuestToken", championQuestTokenDeployment.address, admin)
23 |             let championQuestDeployment = await deployments.get("ChampionQuest")
24 |             championQuest = await ethers.getContractAt("ChampionQuest", championQuestDeployment.address, admin)
25 |             linkToken = await deployments.get("LinkToken")
26 |             let vrfCoordinatorDeployment = await deployments.get("VRFCoordinatorMock")
27 |             vrfCoordinator = await ethers.getContractAt("VRFCoordinatorMock", vrfCoordinatorDeployment.address, admin)
28 |             let ufoDeployment = await deployments.get("MockUFO")
29 |             ufo = await ethers.getContractAt("MockUFO", ufoDeployment.address, admin)
30 | 
31 |         }
32 |     })
33 |     it("should be able to request a new random champion", async () => {
34 |         if (runTest) {
35 |             await expect(championQuest.requestNewRandomChampion(championName)).to.be.revertedWith("Not enough LINK")
36 |             await run("fund-link", { contract: championQuest.address, linkaddress: linkToken.address })
37 |             let champRequestTransactionResponse = await championQuest.requestNewRandomChampion(championName)
38 |             let champRequestTransactionReceipt = await champRequestTransactionResponse.wait()
39 |             let requestId = champRequestTransactionReceipt.events[3].topics[1]
40 |             vrfCoordinator.callBackWithRandomness(requestId, randomNumber, championQuest.address)
41 |             expect((await championQuest.s_champions(0)).name).to.equal(championName)
42 |             expect((await championQuest.s_champions(0)).attack).to.equal(77)
43 |             expect((await championQuest.s_champions(0)).defense).to.equal(86)
44 |             expect((await championQuest.s_champions(0)).experience).to.equal(0)
45 |         }
46 |     })
47 |     it("should be able to battle with each other", async () => {
48 |         if (runTest) {
49 |             await run("fund-link", { contract: championQuest.address, linkaddress: linkToken.address })
50 |             let champRequestTransactionResponse = await championQuest.requestNewRandomChampion(championName)
51 |             let champRequestTransactionReceipt = await champRequestTransactionResponse.wait()
52 |             let requestId = champRequestTransactionReceipt.events[3].topics[1]
53 |             vrfCoordinator.callBackWithRandomness(requestId, randomNumber, championQuest.address)
54 | 
55 |             let champRequestTransactionResponse2 = await championQuest.requestNewRandomChampion(championName2)
56 |             let champRequestTransactionReceipt2 = await champRequestTransactionResponse2.wait()
57 |             let requestId2 = champRequestTransactionReceipt2.events[3].topics[1]
58 |             vrfCoordinator.callBackWithRandomness(requestId2, randomNumber2, championQuest.address)
59 |             expect((await championQuest.s_champions(1)).name).to.equal(championName2)
60 | 
61 |             // need to mint CQT to fight
62 |             await ufo.approve(championQuestToken.address, ufoSwapAmount)
63 |             await championQuestToken.swapUFOForCQT(ufoSwapAmount)
64 |             await championQuestToken.approve(championQuest.address, ufoSwapAmount)
65 | 
66 | 
67 |             // time to fight
68 |             let transactionBattleResponse = await championQuest.requestBattle(0, 1)
69 |             let transactionBattleReceipt = await transactionBattleResponse.wait()
70 |             let battleRequestId = transactionBattleReceipt.events[5].topics[1]
71 |             await vrfCoordinator.callBackWithRandomness(battleRequestId, randomNumber, championQuest.address)
72 |             // console.log((await championQuest.s_champions(0)).experience.toString())
73 |             // console.log((await championQuest.s_champions(1)).experience.toString())
74 |             // console.log((await championQuest.requestToFulfillmentFunction(battleRequestId)).toString())
75 |             expect((await championQuest.s_champions(0)).experience).to.eq(2)
76 |         }
77 |     })
78 | })
79 | 


--------------------------------------------------------------------------------
/contracts/ChampionQuest.sol:
--------------------------------------------------------------------------------
  1 | // contracts/DungeonsAndDragonsCharacter.sol
  2 | // SPDX-License-Identifier: MIT
  3 | pragma solidity ^0.8.7;
  4 | 
  5 | import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
  6 | import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
  7 | import "@openzeppelin/contracts/access/Ownable.sol";
  8 | import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  9 | import "hardhat/console.sol";
 10 | 
 11 | contract ChampionQuest is ERC721URIStorage, VRFConsumerBase, Ownable {
 12 |     bytes32 internal s_keyHash;
 13 |     uint256 internal s_fee;
 14 |     IERC20 public s_championQuestToken;
 15 |     uint256 public s_battleFee;
 16 | 
 17 |     struct Champion {
 18 |         uint256 attack;
 19 |         uint256 defense;
 20 |         uint256 experience;
 21 |         string name;
 22 |     }
 23 | 
 24 |     struct NewChampionRequest {
 25 |         string championName;
 26 |         address sender;
 27 |     }
 28 | 
 29 |     struct BattleRequest {
 30 |         uint256 championTokenIdOne;
 31 |         uint256 championTokenIdTwo;
 32 |     }
 33 | 
 34 |     // also known as "callback"
 35 |     enum RandomNumberFulfillmentFunction {
 36 |         ChampionCreation,
 37 |         ChampionBattle
 38 |     }
 39 | 
 40 |     Champion[] public s_champions;
 41 | 
 42 |     mapping(bytes32 => NewChampionRequest) public requestToNewChampionRequest;
 43 |     mapping(bytes32 => BattleRequest) public requestToBattleRequest;
 44 |     mapping(bytes32 => RandomNumberFulfillmentFunction) public requestToFulfillmentFunction;
 45 | 
 46 |     event requestedChampion(bytes32 indexed requestId);
 47 |     event requestedBattle(bytes32 indexed requestId);
 48 |     event battleDone(uint256 indexed winnerTokenId);
 49 | 
 50 |     constructor(
 51 |         address _vrfCoordinator,
 52 |         address _linkToken,
 53 |         address _championQuestToken,
 54 |         bytes32 _keyhash,
 55 |         uint256 _fee,
 56 |         uint256 _battleFee
 57 |     ) VRFConsumerBase(_vrfCoordinator, _linkToken) ERC721("ChampionQuest", "CQ") {
 58 |         s_keyHash = _keyhash;
 59 |         s_fee = _fee;
 60 |         s_championQuestToken = IERC20(_championQuestToken);
 61 |         s_battleFee = _battleFee;
 62 |     }
 63 | 
 64 |     function requestNewRandomChampion(string memory name) public returns (bytes32) {
 65 |         require(LINK.balanceOf(address(this)) >= s_fee, "Not enough LINK");
 66 |         bytes32 requestId = requestRandomness(s_keyHash, s_fee);
 67 |         requestToFulfillmentFunction[requestId] = RandomNumberFulfillmentFunction.ChampionCreation;
 68 |         requestToNewChampionRequest[requestId] = NewChampionRequest(name, msg.sender);
 69 |         emit requestedChampion(requestId);
 70 |         return requestId;
 71 |     }
 72 | 
 73 |     function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
 74 |         if (requestToFulfillmentFunction[requestId] == RandomNumberFulfillmentFunction.ChampionCreation) {
 75 |             characterCreationFulfillment(requestId, randomNumber);
 76 |         } else {
 77 |             battleFulfillment(requestId, randomNumber);
 78 |         }
 79 |     }
 80 | 
 81 |     function getLevel(uint256 tokenId) public view returns (uint256) {
 82 |         return sqrt(s_champions[tokenId].experience);
 83 |     }
 84 | 
 85 |     function getNumberOfCharacters() public view returns (uint256) {
 86 |         return s_champions.length;
 87 |     }
 88 | 
 89 |     function getCharacterStats(uint256 tokenId)
 90 |         public
 91 |         view
 92 |         returns (
 93 |             uint256,
 94 |             uint256,
 95 |             uint256
 96 |         )
 97 |     {
 98 |         return (s_champions[tokenId].attack, s_champions[tokenId].defense, s_champions[tokenId].experience);
 99 |     }
100 | 
101 |     function sqrt(uint256 x) internal pure returns (uint256 y) {
102 |         uint256 z = (x + 1) / 2;
103 |         y = x;
104 |         while (z < y) {
105 |             y = z;
106 |             z = (x / z + z) / 2;
107 |         }
108 |     }
109 | 
110 |     function characterCreationFulfillment(bytes32 requestId, uint256 randomNumber) internal {
111 |         uint256 newId = s_champions.length;
112 |         uint256 attack = randomNumber % 100;
113 |         uint256 defense = uint256(keccak256(abi.encode(randomNumber, 1))) % 100;
114 |         uint256 experience = 0;
115 |         NewChampionRequest memory champRequest = requestToNewChampionRequest[requestId];
116 |         Champion memory character = Champion(attack, defense, experience, champRequest.championName);
117 |         s_champions.push(character);
118 |         _safeMint(champRequest.sender, newId);
119 |     }
120 | 
121 |     function requestBattle(uint256 championOneId, uint256 championTwoId) public returns (bytes32 requestId) {
122 |         require(_isApprovedOrOwner(msg.sender, championOneId), "You don't own champion one!");
123 |         require(LINK.balanceOf(address(this)) >= s_fee, "Not enough LINK");
124 |         s_championQuestToken.transferFrom(msg.sender, address(this), s_battleFee);
125 |         requestId = requestRandomness(s_keyHash, s_fee);
126 |         requestToFulfillmentFunction[requestId] = RandomNumberFulfillmentFunction(1);
127 |         requestToBattleRequest[requestId] = BattleRequest(championOneId, championTwoId);
128 |         emit requestedBattle(requestId);
129 |     }
130 | 
131 |     // Winner gets +2
132 |     // Loser gets -1
133 | 
134 |     // NFT A has attack of 50 and B has defense of 25
135 |     // A's chance of winning is going to be 50 / 75
136 | 
137 |     function battleFulfillment(bytes32 requestId, uint256 randomness) internal {
138 |         BattleRequest memory battleRequest = requestToBattleRequest[requestId];
139 |         uint256 attack = s_champions[battleRequest.championTokenIdOne].attack;
140 |         uint256 defense = s_champions[battleRequest.championTokenIdTwo].defense;
141 |         uint256 probabilityTotal = attack + defense;
142 |         uint256 winningNumber = randomness % probabilityTotal;
143 |         console.log(winningNumber);
144 |         console.log(attack);
145 |         console.log(defense);
146 |         if (winningNumber >= attack) {
147 |             s_champions[battleRequest.championTokenIdOne].experience += 2;
148 |             if (s_champions[battleRequest.championTokenIdTwo].experience >= 10) {
149 |                 s_champions[battleRequest.championTokenIdTwo].experience -= 1;
150 |             }
151 |             emit battleDone(battleRequest.championTokenIdOne);
152 |         } else {
153 |             s_champions[battleRequest.championTokenIdTwo].experience += 2;
154 |             if (s_champions[battleRequest.championTokenIdOne].experience >= 10) {
155 |                 s_champions[battleRequest.championTokenIdOne].experience -= 1;
156 |             }
157 |             emit battleDone(battleRequest.championTokenIdTwo);
158 |         }
159 |     }
160 | 
161 |     function useExperienceOnAttack(uint256 tokenId, uint256 amount) public {
162 |         require(_isApprovedOrOwner(msg.sender, tokenId), "You don't own this character!");
163 |         require(s_champions[tokenId].experience >= amount, "Not enough experience");
164 |         s_champions[tokenId].attack += amount;
165 |         s_champions[tokenId].experience -= amount;
166 |     }
167 | 
168 |     function useExperienceOnDefense(uint256 tokenId, uint256 amount) public {
169 |         require(_isApprovedOrOwner(msg.sender, tokenId), "You don't own this character!");
170 |         require(s_champions[tokenId].experience >= amount, "Not enough experience");
171 |         s_champions[tokenId].defense += amount;
172 |         s_champions[tokenId].experience -= amount;
173 |     }
174 | }
175 | 


--------------------------------------------------------------------------------