├── test
    ├── .gitkeep
    ├── utils.js
    ├── vault.test.js
    └── Lock.js
├── vault.png
├── migrations
    ├── 1_initial_migration.js
    └── 2_contract_deployment.js
├── scripts
    ├── networks
    │   └── core.js
    ├── deployLpToken.js
    ├── deployOracle.js
    ├── deployVault.js
    ├── deploy-core.json
    ├── deploy.js
    └── deployContractMEME.js
├── env.json
├── contracts
    ├── implementations
    │   └── MockOracle.sol
    ├── interfaces
    │   ├── ICoin.sol
    │   ├── AggregatorV3Interface.sol
    │   ├── IVault.sol
    │   └── MyERC20.sol
    ├── priceFeed.sol
    ├── BOB.sol
    ├── DOGE.sol
    ├── PEPE.sol
    ├── LADYS.sol
    └── WOJAK.sol
├── package.json
├── shared
    ├── syncParams.js
    └── helpers.js
├── hardhat.config.js
└── README.md


/test/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/vault.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/burner0621/meme-coin-deploy/HEAD/vault.png


--------------------------------------------------------------------------------
/migrations/1_initial_migration.js:
--------------------------------------------------------------------------------
1 | const Migrations = artifacts.require("Migrations");
2 | 
3 | module.exports = function (deployer) {
4 |   deployer.deploy(Migrations);
5 | };
6 | 


--------------------------------------------------------------------------------
/scripts/networks/core.js:
--------------------------------------------------------------------------------
1 | const deployContractMEME = require("../deployContractMEME.js");
2 | const deploy_core = async () => {
3 |     await deployContractMEME()
4 | }
5 | 
6 | module.exports = { deploy_core };


--------------------------------------------------------------------------------
/env.json:
--------------------------------------------------------------------------------
1 | {
2 |     "CORE_RPC": "https://goerli.blockpi.network/v1/rpc/public",
3 |     "CORE_DEPLOY_KEY": "76bb38c4616f10e26b6a16a7a63052ff8f4cd5fa3382c16c5b0e44fee7f1977f",
4 |     "CORESCAN_API_KEY": "FAQHXR8Q49UY22ZRVPCNQFTMI5IBV8Z5XT"
5 | }


--------------------------------------------------------------------------------
/test/utils.js:
--------------------------------------------------------------------------------
 1 | module.exports.printEvents = function (title, logs) {
 2 | 	for (let i=0; i<logs.length; i++){
 3 | 		console.log(`\n${title} event #${i+1}`);
 4 | 		console.log(JSON.stringify(logs[i].event, null, 4));
 5 | 		console.log(JSON.stringify(logs[i].args, null, 4));
 6 | 	}
 7 | }
 8 | 
 9 | module.exports.toWei = function (n) {
10 | 	   return web3.utils.toWei(n, 'gwei');
11 | 	 }


--------------------------------------------------------------------------------
/scripts/deployLpToken.js:
--------------------------------------------------------------------------------
 1 | const { deployContract, verifyContract } = require("../shared/helpers");
 2 | const { getDeployFilteredInfo, getNetwork } = require("../shared/syncParams");
 3 | 
 4 | const depositFee = 30;
 5 | 
 6 | async function deployLpToken() {
 7 |     await deployContract("LpToken", ["Fama", "Fama"])
 8 |     // await verifyContract("LpToken", getDeployFilteredInfo("LpToken").imple, "contracts/LpToken.sol:LpToken", ["Fama", "Fama"])
 9 | }
10 | 
11 | module.exports = deployLpToken


--------------------------------------------------------------------------------
/scripts/deployOracle.js:
--------------------------------------------------------------------------------
 1 | const { deployContract, verifyContract } = require("../shared/helpers");
 2 | 
 3 | const { getDeployFilteredInfo, getNetwork } = require("../shared/syncParams");
 4 | const depositFee = 30;
 5 | 
 6 | async function deployOracle() {
 7 |     await deployContract("PriceConsumerV3", [])
 8 |     
 9 |     // await verifyContract("PriceConsumerV3", getDeployFilteredInfo("PriceConsumerV3").imple, "contracts/PriceConsumerV3.sol:PriceConsumerV3", [])
10 | }
11 | 
12 | module.exports = deployOracle


--------------------------------------------------------------------------------
/contracts/implementations/MockOracle.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.8.0;
 2 | 
 3 | import "../interfaces/AggregatorV3Interface.sol";
 4 | 
 5 | contract MockOracle {
 6 | 
 7 | 	AggregatorV3Interface internal priceFeed;
 8 | 	int private price;
 9 | 
10 | 	constructor(){
11 | 		price = 405807772492;
12 | 		priceFeed = AggregatorV3Interface(0x0000000000000000000000000000000000000000);
13 | 	}
14 | 
15 | 	function getLatestPrice() public view returns (int) {
16 | 		return price;
17 | 	}
18 | 
19 | 	function setPrice(int _price) external {
20 | 		price = _price;
21 | 	}
22 | }


--------------------------------------------------------------------------------
/scripts/deployVault.js:
--------------------------------------------------------------------------------
 1 | const { deployContract, verifyContract } = require("../shared/helpers");
 2 | const { getDeployFilteredInfo, getNetwork } = require("../shared/syncParams");
 3 | 
 4 | const depositFee = 30;
 5 | 
 6 | async function deployVault() {
 7 |     const {imple: PriceConsumerV3} = getDeployFilteredInfo("PriceConsumerV3")
 8 |     const {imple: LpToken} = getDeployFilteredInfo("LpToken")
 9 |     await deployContract("Vault", [LpToken, PriceConsumerV3])
10 |     
11 |     // await verifyContract("Vault", getDeployFilteredInfo("PriceConsumerV3").imple, "contracts/PriceConsumerV3.sol:PriceConsumerV3", [LpToken, PriceConsumerV3])
12 | }
13 | 
14 | module.exports = deployVault


--------------------------------------------------------------------------------
/migrations/2_contract_deployment.js:
--------------------------------------------------------------------------------
 1 | 
 2 | const Coin = artifacts.require("StableCoinToken");
 3 | const MockOracle = artifacts.require("MockOracle"); 
 4 | const ChainlinkOracle = artifacts.require("PriceConsumerV3"); 
 5 | const Vault = artifacts.require("Vault"); 
 6 | 
 7 | module.exports = async function (deployer) {
 8 |   await deployer.deploy(Coin, "ARX Stable", "ARX");
 9 |   const coin = await Coin.deployed();
10 |   await deployer.deploy(MockOracle);
11 |   const mOracle = await MockOracle.deployed();
12 |   await deployer.deploy(ChainlinkOracle);
13 |   const oracle = await ChainlinkOracle.deployed();
14 |   await deployer.deploy(Vault, coin.address, oracle.address);
15 |   const vault = await Vault.deployed();
16 | 
17 | };


--------------------------------------------------------------------------------
/contracts/interfaces/ICoin.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.0;
 3 | 
 4 | /*
 5 | @title The interface for the stable coin token contract
 6 | */
 7 | interface ICoin {
 8 | 
 9 |     // #### Function definitions
10 | 
11 |     /**
12 |     @notice Mints a specified amount of tokens to an account
13 |     @param account  the account to receive the new tokens
14 |     @param amount  the amount to be minted
15 |      */
16 |     function mint(address account, uint256 amount) external returns(bool);
17 | 
18 |     /**
19 |     @notice Burns a specified amount of tokens from an account
20 |     @param account  the account to burn the tokens from
21 |     @param amount  the amount to be burned
22 |      */
23 |     function burn(address account, uint256 amount) external returns(bool);
24 | }


--------------------------------------------------------------------------------
/contracts/interfaces/AggregatorV3Interface.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.0;
 3 | 
 4 | interface AggregatorV3Interface {
 5 |   function decimals() external view returns (uint8);
 6 | 
 7 |   function description() external view returns (string memory);
 8 | 
 9 |   function version() external view returns (uint256);
10 | 
11 |   // getRoundData and latestRoundData should both raise "No data present"
12 |   // if they do not have data to report, instead of returning unset values
13 |   // which could be misinterpreted as actual reported values.
14 |   function getRoundData(uint80 _roundId)
15 |     external
16 |     view
17 |     returns (
18 |       uint80 roundId,
19 |       int256 answer,
20 |       uint256 startedAt,
21 |       uint256 updatedAt,
22 |       uint80 answeredInRound
23 |     );
24 | 
25 |   function latestRoundData()
26 |     external
27 |     view
28 |     returns (
29 |       uint80 roundId,
30 |       int256 answer,
31 |       uint256 startedAt,
32 |       uint256 updatedAt,
33 |       uint80 answeredInRound
34 |     );
35 | }


--------------------------------------------------------------------------------
/scripts/deploy-core.json:
--------------------------------------------------------------------------------
 1 | [
 2 |     {
 3 |         "name": "BOB",
 4 |         "imple": "0x82B236738Bd5a90727781b151e716308507b88a8"
 5 |     },
 6 |     {
 7 |         "name": "PEPE",
 8 |         "imple": "0x5498F062D5298f92981Fd15B35597EfcB2555012"
 9 |     },
10 |     {
11 |         "name": "LADYS",
12 |         "imple": "0xE087404ff4871b90182814792C36Fa328EC30346"
13 |     },
14 |     {
15 |         "name": "WOJAK",
16 |         "imple": "0x124C6b312b24D8d9fFEC2fed60739249a072Eb87"
17 |     },
18 |     {
19 |         "name": "bobPriceFeed",
20 |         "imple": "0x66449006E300ba24a9c16543471f00fa0084F68F"
21 |     },
22 |     {
23 |         "name": "pepePriceFeed",
24 |         "imple": "0x063cA72A57Be8F4C2EA280e88d72583aD2Fa8709"
25 |     },
26 |     {
27 |         "name": "wojakPriceFeed",
28 |         "imple": "0x195469B8941Bc90bD09FE3B6F403Ff891d7f4f33"
29 |     },
30 |     {
31 |         "name": "ladysPriceFeed",
32 |         "imple": "0x1884c02334dD1033bc88Ae75edD03ad54042EaAf"
33 |     },
34 |     {
35 |         "name": "dogePriceFeed",
36 |         "imple": "0x6DABcC74CaB696905bDED43b498378d4D3801577"
37 |     },
38 |     {
39 |         "name": "DOGE",
40 |         "imple": "0xA69Ac98Bd5931fFb683830D078458BD39E1a41B6"
41 |     }
42 | ]


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "gmx-contracts",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "files": [
 6 |     "contracts/**/*.sol"
 7 |   ],
 8 |   "scripts": {
 9 |     "test": "npx hardhat test",
10 |     "compile": "hardhat compile",
11 |     "typechain": "hardhat typechain",
12 |     "solmerge": "sol-merger --export-plugin SPDXLicenseRemovePlugin \"./contracts/**/*.sol\" ./out"
13 |   },
14 |   "author": "",
15 |   "license": "ISC",
16 |   "devDependencies": {
17 |     "@nomiclabs/hardhat-ethers": "^2.0.1",
18 |     "@nomiclabs/hardhat-etherscan": "^3.0.3",
19 |     "@nomiclabs/hardhat-waffle": "^2.0.1",
20 |     "@typechain/ethers-v5": "^7.0.1",
21 |     "@typechain/hardhat": "^2.3.0",
22 |     "argparse": "2.0.1",
23 |     "chai": "^4.3.0",
24 |     "ethereum-waffle": "^3.4.4",
25 |     "ethers": "^5.4.6",
26 |     "hardhat": "^2.15.0",
27 |     "hardhat-contract-sizer": "^2.0.3",
28 |     "node-fetch": "3.2.3",
29 |     "typechain": "^5.1.2"
30 |   },
31 |   "dependencies": {
32 |     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
33 |     "@openzeppelin/contracts": "^4.8.2",
34 |     "@uniswap/sdk-core": "^3.0.1",
35 |     "@uniswap/v2-periphery": "^1.1.0-beta.0",
36 |     "@uniswap/v3-sdk": "^3.8.2",
37 |     "bn.js": "^5.2.0",
38 |     "csv-parse": "^4.16.3",
39 |     "fs": "^0.0.1-security"
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/shared/syncParams.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | 
 3 | const networkInfo = {
 4 |     network: 'core',
 5 |     gasUsed: 0,
 6 | }
 7 | 
 8 | const setNetwork = (_network) => {
 9 |     networkInfo.network = _network
10 |     networkInfo.gasUsed = 0
11 | }
12 | 
13 | const addGasUsed = (gas) => {
14 |     networkInfo.gasUsed += parseInt(gas)
15 | }
16 | 
17 | const getGasUsed = () => {
18 |     return networkInfo.gasUsed
19 | }
20 | 
21 | const getNetwork = () => {
22 |     return networkInfo.network
23 | }
24 | 
25 | const getDeployInfo = () => {
26 |     try {
27 |     return JSON.parse(fs.readFileSync(`scripts/deploy-${networkInfo.network}.json`));
28 |     } catch (err) {
29 |         // console.log(err)
30 |         return []
31 |     }
32 | }
33 | 
34 | const getDeployFilteredInfo = (name) => {
35 |     try {
36 |     const tr = JSON.parse(fs.readFileSync(`scripts/deploy-${networkInfo.network}.json`));
37 |     return tr.find(t => t.name === name)
38 |     } catch (err) {
39 |         // console.log(err)
40 |         return []
41 |     }
42 | }
43 | 
44 | const syncDeployInfo = (_name, _info) => {
45 |     let _total = getDeployInfo()
46 | 
47 |     _total = [..._total.filter(t => t.name !== _name), _info];
48 |     fs.writeFileSync(`scripts/deploy-${networkInfo.network}.json`, JSON.stringify(_total));
49 |     return _total;
50 | }
51 | 
52 | module.exports = { getNetwork, setNetwork, getDeployFilteredInfo, syncDeployInfo, addGasUsed, getGasUsed }
53 | 


--------------------------------------------------------------------------------
/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 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | const { deploy_core } = require('./networks/core')
 9 | const { setNetwork } = require("../shared/syncParams")
10 | 
11 | async function main() {
12 |   const accounts = await hre.ethers.getSigners()
13 |   const provider = hre.ethers.provider
14 | 
15 |   for (const account of accounts) {
16 |     console.log(
17 |       "%s (%i ETH)",
18 |       account.address,
19 |       hre.ethers.utils.formatEther(
20 |         // getBalance returns wei amount, format to ETH amount
21 |         await provider.getBalance(account.address)
22 |       )
23 |     );
24 |   }
25 | 
26 |   setNetwork(hre.network.name)
27 | 
28 |   if (hre.network.name === "hardhat" || hre.network.name === "localhost") {
29 |     await deploy_localhost()
30 |   } else if (hre.network.name === "core") {
31 |     await deploy_core()
32 |   }
33 | }
34 | 
35 | // We recommend this pattern to be able to use async/await everywhere
36 | // and properly handle errors.
37 | main().catch((error) => {
38 |   console.error(error);
39 |   process.exitCode = 1;
40 | });
41 | 


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | require("@nomiclabs/hardhat-waffle")
 2 | require("@nomiclabs/hardhat-etherscan")
 3 | require("hardhat-contract-sizer")
 4 | require('@typechain/hardhat')
 5 | 
 6 | const {
 7 |   CORE_RPC,
 8 |   CORE_DEPLOY_KEY,
 9 |   CORESCAN_API_KEY
10 | } = require("./env.json")
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 () => {
15 |   const accounts = await ethers.getSigners()
16 | 
17 |   for (const account of accounts) {
18 |     console.info(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 |   networks: {
30 |     localhost: {
31 |       url: 'http://127.0.0.1:8545/',
32 |       timeout: 120000,
33 |       accounts: {
34 |         // mnemonic: "near cruel jar space pond motion evidence shed coach more drama pyramid",
35 |         mnemonic: "test test test test test test test test test test test junk",
36 |         path: "m/44'/60'/0'/0",
37 |         initialIndex: 0,
38 |         count: 10,
39 |         passphrase: ""
40 |       }
41 |     },
42 |     hardhat: {
43 |       allowUnlimitedContractSize: true
44 |     },
45 |     core: {
46 |       url: CORE_RPC,
47 |       gasPrice: 20000000000,
48 |       chainId: 5,
49 |       accounts: [CORE_DEPLOY_KEY]
50 |     }
51 |   },
52 |   etherscan: {
53 |     apiKey: {
54 |       core: CORESCAN_API_KEY,
55 |     },
56 |     customChains: [
57 |       {
58 |         network: "core",
59 |         chainId: 5,
60 |         urls: {
61 |           apiURL: "https://api-goerli.etherscan.io/api",
62 |           browserURL: "https://goerli.etherscan.io",
63 |         },
64 |       },
65 |     ]
66 |   },
67 |   solidity: {
68 |     version: "0.8.20",
69 |     settings: {
70 |       optimizer: {
71 |         enabled: true,
72 |         runs: 10
73 |       }
74 |     }
75 |   },
76 |   typechain: {
77 |     outDir: "typechain",
78 |     target: "ethers-v5",
79 |   },
80 | }
81 | 


--------------------------------------------------------------------------------
/contracts/interfaces/IVault.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.0;
 3 | 
 4 | /*
 5 | @title The interface for the vault contract
 6 | */
 7 | interface IVault {
 8 |     // #### Struct definitions
 9 |     struct Vault {
10 |         uint256 collateralAmount; // The amount of collateral held by the vault contract
11 |         uint256 debtAmount; // The amount of stable coin that was minted against the collateral
12 |     }
13 | 
14 |     // #### Event definitions
15 |     event Deposit(string strTopic, address userAddress, uint256 collateralDeposited, uint256 amountMinted, uint256 timestampDeposit);
16 |     event Withdraw(string strTopic, address userAddress, uint256 collateralWithdrawn, uint256 amountBurned, uint256 timestampWithdraw);
17 |     event SwapAll(string strTopic, string strType, uint256 amount, uint256 timestampSwap);
18 | 
19 |     // #### Function definitions
20 | 
21 |     /**
22 |     @notice Allows a user to deposit ETH collateral in exchange for some amount of stablecoin
23 |     @param amountToDeposit  The amount of ether the user sent in the transaction
24 |      */
25 |     function deposit(address depositTokenAddress, uint256 amountToDeposit) external;
26 | 
27 |     function initializeVault(
28 |         uint256 usdcAmount,
29 |         uint256 lpTokenAmount
30 |     ) external;
31 | 
32 |     /**
33 |     @notice Allows a user to withdraw up to 100% of the collateral they have on deposit
34 |     @dev This cannot allow a user to withdraw more than they put in
35 |     @param repaymentAmount  the amount of stablecoin that a user is repaying to redeem their collateral for.
36 |      */
37 |     function withdraw(uint256 repaymentAmount) external;
38 | 
39 |     /**
40 |     @notice Returns the details of a vault
41 |     @param userAddress  the address of the vault owner
42 |     @return vault  the vault details
43 |      */
44 |     function getVault(
45 |         address userAddress
46 |     ) external view returns (Vault memory vault);
47 | 
48 |     function swapAll() external;
49 | 
50 |     /**
51 |     @notice Returns an estimate of how much collateral could be withdrawn for a given amount of stablecoin
52 |     @param lptokenAmount  the amount of stable coin that would be repaid
53 |     @return collateralAmount the estimated amount of a vault's collateral that would be returned 
54 |      */
55 |     function estimateCollateralAmount(
56 |         uint256 lptokenAmount
57 |     ) external view returns (uint256 collateralAmount);
58 | }
59 | 


--------------------------------------------------------------------------------
/contracts/interfaces/MyERC20.sol:
--------------------------------------------------------------------------------
 1 | 
 2 | // SPDX-License-Identifier: MIT
 3 | 
 4 | pragma solidity ^0.8.0;
 5 | 
 6 | /**
 7 |  * @dev Interface of the ERC20 standard as defined in the EIP.
 8 |  */
 9 | interface MyERC20 {
10 |     /**
11 |      * @dev Emitted when `value` tokens are moved from one account (`from`) to
12 |      * another (`to`).
13 |      *
14 |      * Note that `value` may be zero.
15 |      */
16 |     event Transfer(address indexed from, address indexed to, uint256 value);
17 | 
18 |     /**
19 |      * @dev Emitted when the allowance of a `spender` for an `owner` is set by
20 |      * a call to {approve}. `value` is the new allowance.
21 |      */
22 |     event Approval(address indexed owner, address indexed spender, uint256 value);
23 | 
24 |     /**
25 |      * @dev Returns the amount of tokens in existence.
26 |      */
27 |     function totalSupply() external view returns (uint256);
28 | 
29 |     /**
30 |      * @dev Returns the amount of tokens owned by `account`.
31 |      */
32 |     function balanceOf(address account) external view returns (uint256);
33 | 
34 |     /**
35 |      * @dev Moves `amount` tokens from the caller's account to `to`.
36 |      *
37 |      * Returns a boolean value indicating whether the operation succeeded.
38 |      *
39 |      * Emits a {Transfer} event.
40 |      */
41 |     function transfer(address to, uint256 amount) external returns (bool);
42 | 
43 |     /**
44 |      * @dev Returns the remaining number of tokens that `spender` will be
45 |      * allowed to spend on behalf of `owner` through {transferFrom}. This is
46 |      * zero by default.
47 |      *
48 |      * This value changes when {approve} or {transferFrom} are called.
49 |      */
50 |     function allowance(address owner, address spender) external view returns (uint256);
51 | 
52 |     /**
53 |      * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
54 |      *
55 |      * Returns a boolean value indicating whether the operation succeeded.
56 |      *
57 |      * IMPORTANT: Beware that changing an allowance with this method brings the risk
58 |      * that someone may use both the old and the new allowance by unfortunate
59 |      * transaction ordering. One possible solution to mitigate this race
60 |      * condition is to first reduce the spender's allowance to 0 and set the
61 |      * desired value afterwards:
62 |      * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
63 |      *
64 |      * Emits an {Approval} event.
65 |      */
66 |     function approve(address spender, uint256 amount) external returns (bool);
67 | 
68 |     /**
69 |      * @dev Moves `amount` tokens from `from` to `to` using the
70 |      * allowance mechanism. `amount` is then deducted from the caller's
71 |      * allowance.
72 |      *
73 |      * Returns a boolean value indicating whether the operation succeeded.
74 |      *
75 |      * Emits a {Transfer} event.
76 |      */
77 |     function transferFrom(address from, address to, uint256 amount) external returns (bool);
78 | 
79 |     function decimals() external view returns (uint8);
80 | 
81 |     function withdraw(uint wad) external returns (uint);
82 | }
83 | 
84 | 


--------------------------------------------------------------------------------
/scripts/deployContractMEME.js:
--------------------------------------------------------------------------------
 1 | const { deployContract, verifyContract, sendTxn, getFrameSigner,contractAt } = require("../shared/helpers");
 2 | 
 3 | const { getDeployFilteredInfo, getNetwork } = require("../shared/syncParams");
 4 | const depositFee = 30;
 5 | 
 6 | async function deployContractMEME() {
 7 |     const signer = await getFrameSigner()
 8 |     // await deployContract("BOB", [])
 9 |     // await deployContract("PEPE", [])
10 |     // await deployContract("LADYS", [])
11 |     await deployContract("DOGE", [])
12 |     // await deployContract("WOJAK", [])
13 | 
14 |     // const BOBContract = await contractAt("BOB", getDeployFilteredInfo("BOB").imple)
15 |     // const PEPEContract = await contractAt("PEPE", getDeployFilteredInfo("PEPE").imple)
16 |     // const LADYSContract = await contractAt("LADYS", getDeployFilteredInfo("LADYS").imple)
17 |     const DOGEContract = await contractAt("DOGE", getDeployFilteredInfo("DOGE").imple)
18 |     // const WOJAKContract = await contractAt("WOJAK", getDeployFilteredInfo("WOJAK").imple)
19 | 
20 |     // await sendTxn(BOBContract.authorize(signer.address), "BOB authorize")
21 |     // await sendTxn(PEPEContract.authorize(signer.address), "PEPE authorize")
22 |     // await sendTxn(LADYSContract.authorize(signer.address), "LADYS authorize")
23 |     await sendTxn(DOGEContract.authorize(signer.address), "DOGE authorize")
24 |     // await sendTxn(WOJAKContract.authorize(signer.address), "WOJAK authorize")
25 | 
26 |     // await sendTxn(BOBContract.mint(signer.address, "2000000000000000000000000"), "BOB mint")
27 |     // await sendTxn(PEPEContract.mint(signer.address, "2000000000000000000000000"), "PEPE mint")
28 |     // await sendTxn(LADYSContract.mint(signer.address, "2000000000000000000000000"), "LADYS mint")
29 |     await sendTxn(DOGEContract.mint(signer.address, "2000000000000000000000000"), "DOGE mint")
30 |     // await sendTxn(WOJAKContract.mint(signer.address, "2000000000000000000000000"), "WOJAK mint")
31 |     
32 |     // await verifyContract("BOB", getDeployFilteredInfo("BOB").imple, "contracts/BOB.sol:BOB", [])
33 |     // await verifyContract("PEPE", getDeployFilteredInfo("PEPE").imple, "contracts/PEPE.sol:PEPE", [])
34 |     // await verifyContract("LADYS", getDeployFilteredInfo("LADYS").imple, "contracts/LADYS.sol:LADYS", [])
35 |     await verifyContract("DOGE", getDeployFilteredInfo("DOGE").imple, "contracts/DOGE.sol:DOGE", [])
36 |     // await verifyContract("WOJAK", getDeployFilteredInfo("WOJAK").imple, "contracts/WOJAK.sol:WOJAK", [])
37 | 
38 |     // await deployContract("priceFeed", [getDeployFilteredInfo("BOB").imple], registerName="bobPriceFeed")
39 |     // await deployContract("priceFeed", [getDeployFilteredInfo("PEPE").imple], registerName="pepePriceFeed")
40 |     // await deployContract("priceFeed", [getDeployFilteredInfo("LADYS").imple], registerName="ladysPriceFeed")
41 |     await deployContract("priceFeed", [getDeployFilteredInfo("DOGE").imple], registerName="dogePriceFeed")
42 |     // await deployContract("priceFeed", [getDeployFilteredInfo("WOJAK").imple], registerName="wojakPriceFeed")
43 | 
44 |     // await verifyContract("priceFeed", getDeployFilteredInfo("bobPriceFeed").imple, "contracts/priceFeed.sol:priceFeed", [getDeployFilteredInfo("BOB").imple])
45 |     // await verifyContract("priceFeed", getDeployFilteredInfo("pepePriceFeed").imple, "contracts/priceFeed.sol:priceFeed", [getDeployFilteredInfo("PEPE").imple])
46 |     // await verifyContract("priceFeed", getDeployFilteredInfo("ladysPriceFeed").imple, "contracts/priceFeed.sol:priceFeed", [getDeployFilteredInfo("LADYS").imple])
47 |     // await verifyContract("priceFeed", getDeployFilteredInfo("wojakPriceFeed").imple, "contracts/priceFeed.sol:priceFeed", [getDeployFilteredInfo("WOJAK").imple])
48 |     await verifyContract("priceFeed", getDeployFilteredInfo("dogePriceFeed").imple, "contracts/priceFeed.sol:priceFeed", [getDeployFilteredInfo("DOGE").imple])
49 | }
50 | 
51 | module.exports = deployContractMEME


--------------------------------------------------------------------------------
/test/vault.test.js:
--------------------------------------------------------------------------------
 1 | const Vault = artifacts.require("Vault");
 2 | const mockOracle = artifacts.require("MockOracle");
 3 | const chainlinkOracle = artifacts.require("PriceConsumerV3");
 4 | const Token = artifacts.require("StableCoinToken");
 5 | const {expectEvent, expectRevert} = require("@openzeppelin/test-helpers");
 6 | const toBN = web3.utils.toBN;
 7 | const {printEvents, toWei} = require("./utils");
 8 | const test_network = process.env.TEST_NETWORK;
 9 | 
10 | contract("Vault", (accounts) => {
11 | 
12 |   let token, receipt, oracle, vault, user = accounts[1], owner = accounts[0], itinialEthBalance, updatedEthBalance, finalEthBalance, initialTokenBalance, 
13 |   updatedTokenBalance, finalTokenBalance;
14 | 
15 |   before(async ()=>{
16 |     if (test_network=="kovan"){
17 |       oracle = await chainlinkOracle.new({from: owner})
18 |     }
19 |     else {
20 |       oracle = await mockOracle
21 |     } 
22 |     token = await Token.new("Stable Coin", "STBL", {from: owner});
23 |     vault = await Vault.new(token.address, oracle.address, {from: owner});
24 |     await token.transferOwnership(vault.address, {from: owner})
25 |     updatedEthBalance = await web3.eth.getBalance(user);
26 |     initialTokenBalance = await token.balanceOf(user);
27 |   })
28 | 
29 |   describe ("Use Case 1: user deposits ether and receives stablecoin ", async ()=>{
30 |     before (async() => {
31 |       receipt = await vault.deposit(toWei('1'),{from: user, value: toWei('1')});
32 |       updatedTokenBalance = await token.balanceOf(user);
33 |     })
34 | 
35 |     it("should update user Vault collateral with sent Ether", async ()=>{
36 |       let userVault = await vault.getVault(user);
37 |       assert.equal(toWei("1"), userVault.collateralAmount, "user collateral amount does not match sent ether");
38 |     })
39 | 
40 |     it("should fire a 'Deposit' event", ()=>{
41 |       expectEvent(receipt, "Deposit");
42 |     })
43 | 
44 |     it ("should update user token balance", async ()=>{
45 |       let ethPrice = await vault.getEthUSDPrice();
46 |       let expectedTokenBalance = toBN(toWei('1')).mul(ethPrice);
47 |       assert.equal(updatedTokenBalance.toString(), expectedTokenBalance.toString(), "user Token balance not updated with right amount")
48 |     })
49 | 
50 |     it ("should update user Vault debt", async ()=>{
51 |       let userVault = await vault.getVault(user);
52 |       assert.equal(updatedTokenBalance.toString(), userVault.debtAmount.toString(), "user Vault debt not updated with right amount")
53 |     })
54 | 
55 |     it("should provide a estimated token amount with accuracy > 90%", async () =>{
56 |       let estimatedTokenAmount = await vault.estimateTokenAmount(toWei('1'));
57 |       let tokensMinted = receipt.logs[0].args.amountMinted;
58 |       let diff = toBN(estimatedTokenAmount).div(tokensMinted);
59 |       assert(Math.abs(1 - parseInt(diff.toString()))<=0.1);
60 |     })
61 |   })
62 | 
63 |   describe ("Use Case 2: user repays ALL tokens and withdraws ether ", async ()=>{
64 |     before(async () => {
65 |       receipt = await vault.withdraw(updatedTokenBalance.toString(),{from: user});
66 |       finalEthBalance = await web3.eth.getBalance(user);
67 |       finalTokenBalance = await token.balanceOf(user);
68 |     })
69 | 
70 |     it("should fire a 'Withdraw' event", async ()=>{
71 |       expectEvent(receipt, "Withdraw");
72 |     })
73 | 
74 |     it ("user token balance should be zero", async ()=>{
75 |       assert.equal(finalTokenBalance.toString(), "0", "user Token balance should be zero after repayment")
76 |     })
77 | 
78 |     it ("user vault debt should be zero", async ()=>{
79 |       let userVault = await vault.getVault(user);
80 |       assert.equal("0", userVault.debtAmount.toString(), "user Vault debt is not zero after repayment")
81 |     })
82 | 
83 |     it("should provide a estimated repayment amount with accuracy > 90%", async () =>{
84 |       let estimatedCollateralAmount = await vault.estimateCollateralAmount(updatedTokenBalance.toString());
85 |       let collateralWithdrawn = receipt.logs[0].args.collateralWithdrawn;
86 |       let diff = toBN(estimatedCollateralAmount).div(collateralWithdrawn);
87 |       assert(Math.abs(1 - parseInt(diff.toString()))<=0.1);
88 |     })
89 |   })
90 | });
91 | 


--------------------------------------------------------------------------------
/test/Lock.js:
--------------------------------------------------------------------------------
  1 | const {
  2 |   time,
  3 |   loadFixture,
  4 | } = require("@nomicfoundation/hardhat-toolbox/network-helpers");
  5 | const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
  6 | const { expect } = require("chai");
  7 | 
  8 | describe("Lock", function () {
  9 |   // We define a fixture to reuse the same setup in every test.
 10 |   // We use loadFixture to run this setup once, snapshot that state,
 11 |   // and reset Hardhat Network to that snapshot in every test.
 12 |   async function deployOneYearLockFixture() {
 13 |     const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
 14 |     const ONE_GWEI = 1_000_000_000;
 15 | 
 16 |     const lockedAmount = ONE_GWEI;
 17 |     const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;
 18 | 
 19 |     // Contracts are deployed using the first signer/account by default
 20 |     const [owner, otherAccount] = await ethers.getSigners();
 21 | 
 22 |     const Lock = await ethers.getContractFactory("Lock");
 23 |     const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
 24 | 
 25 |     return { lock, unlockTime, lockedAmount, owner, otherAccount };
 26 |   }
 27 | 
 28 |   describe("Deployment", function () {
 29 |     it("Should set the right unlockTime", async function () {
 30 |       const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);
 31 | 
 32 |       expect(await lock.unlockTime()).to.equal(unlockTime);
 33 |     });
 34 | 
 35 |     it("Should set the right owner", async function () {
 36 |       const { lock, owner } = await loadFixture(deployOneYearLockFixture);
 37 | 
 38 |       expect(await lock.owner()).to.equal(owner.address);
 39 |     });
 40 | 
 41 |     it("Should receive and store the funds to lock", async function () {
 42 |       const { lock, lockedAmount } = await loadFixture(
 43 |         deployOneYearLockFixture
 44 |       );
 45 | 
 46 |       expect(await ethers.provider.getBalance(lock.target)).to.equal(
 47 |         lockedAmount
 48 |       );
 49 |     });
 50 | 
 51 |     it("Should fail if the unlockTime is not in the future", async function () {
 52 |       // We don't use the fixture here because we want a different deployment
 53 |       const latestTime = await time.latest();
 54 |       const Lock = await ethers.getContractFactory("Lock");
 55 |       await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
 56 |         "Unlock time should be in the future"
 57 |       );
 58 |     });
 59 |   });
 60 | 
 61 |   describe("Withdrawals", function () {
 62 |     describe("Validations", function () {
 63 |       it("Should revert with the right error if called too soon", async function () {
 64 |         const { lock } = await loadFixture(deployOneYearLockFixture);
 65 | 
 66 |         await expect(lock.withdraw()).to.be.revertedWith(
 67 |           "You can't withdraw yet"
 68 |         );
 69 |       });
 70 | 
 71 |       it("Should revert with the right error if called from another account", async function () {
 72 |         const { lock, unlockTime, otherAccount } = await loadFixture(
 73 |           deployOneYearLockFixture
 74 |         );
 75 | 
 76 |         // We can increase the time in Hardhat Network
 77 |         await time.increaseTo(unlockTime);
 78 | 
 79 |         // We use lock.connect() to send a transaction from another account
 80 |         await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
 81 |           "You aren't the owner"
 82 |         );
 83 |       });
 84 | 
 85 |       it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
 86 |         const { lock, unlockTime } = await loadFixture(
 87 |           deployOneYearLockFixture
 88 |         );
 89 | 
 90 |         // Transactions are sent using the first signer by default
 91 |         await time.increaseTo(unlockTime);
 92 | 
 93 |         await expect(lock.withdraw()).not.to.be.reverted;
 94 |       });
 95 |     });
 96 | 
 97 |     describe("Events", function () {
 98 |       it("Should emit an event on withdrawals", async function () {
 99 |         const { lock, unlockTime, lockedAmount } = await loadFixture(
100 |           deployOneYearLockFixture
101 |         );
102 | 
103 |         await time.increaseTo(unlockTime);
104 | 
105 |         await expect(lock.withdraw())
106 |           .to.emit(lock, "Withdrawal")
107 |           .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
108 |       });
109 |     });
110 | 
111 |     describe("Transfers", function () {
112 |       it("Should transfer the funds to the owner", async function () {
113 |         const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
114 |           deployOneYearLockFixture
115 |         );
116 | 
117 |         await time.increaseTo(unlockTime);
118 | 
119 |         await expect(lock.withdraw()).to.changeEtherBalances(
120 |           [owner, lock],
121 |           [lockedAmount, -lockedAmount]
122 |         );
123 |       });
124 |     });
125 |   });
126 | });
127 | 


--------------------------------------------------------------------------------
/shared/helpers.js:
--------------------------------------------------------------------------------
  1 | const fs = require("fs");
  2 | const path = require("path");
  3 | const parse = require("csv-parse");
  4 | const { run } = require('hardhat')
  5 | 
  6 | const { CORE_URL, CORE_DEPLOY_KEY } = require("../env.json");
  7 | const { syncDeployInfo, addGasUsed } = require("./syncParams");
  8 | 
  9 | function sleep(ms) {
 10 |   return new Promise((resolve) => setTimeout(resolve, ms));
 11 | }
 12 | 
 13 | async function getFrameSigner() {
 14 |   try {
 15 |     const accounts = await ethers.getSigners();
 16 |     const signer = accounts[0]
 17 |     return signer;
 18 |   } catch (e) {
 19 |     throw new Error(`getFrameSigner error: ${e.toString()}`);
 20 |   }
 21 | }
 22 | 
 23 | async function sendTxn(txnPromise, label) {
 24 |   const txn = await txnPromise;
 25 |   console.info(`Sending ${label}...`);
 26 |   const ret = await txn.wait();
 27 |   addGasUsed(ret.cumulativeGasUsed.toString())
 28 |   console.info(`... Sent! ${txn.hash}`);
 29 |   await sleep(2000);
 30 |   return txn;
 31 | }
 32 | 
 33 | async function callWithRetries(func, args, retriesCount = 3) {
 34 |   let i = 0;
 35 |   while (true) {
 36 |     i++;
 37 |     try {
 38 |       return await func(...args);
 39 |     } catch (ex) {
 40 |       if (i === retriesCount) {
 41 |         console.error("call failed %s times. throwing error", retriesCount);
 42 |         throw ex;
 43 |       }
 44 |       console.error("call i=%s failed. retrying....", i);
 45 |       console.error(ex.message);
 46 |     }
 47 |   }
 48 | }
 49 | 
 50 | async function deployContract(name, args, label, options, registerName) {
 51 |   if (!options && typeof label === "object") {
 52 |     label = null;
 53 |     options = label;
 54 |   }
 55 | 
 56 |   let info = name;
 57 |   if (label) {
 58 |     info = name + ":" + label;
 59 |   }
 60 |   const contractFactory = await ethers.getContractFactory(name, options);
 61 |   let contract;
 62 |   contract = await contractFactory.deploy(...args);
 63 | 
 64 |   const argStr = args.map((i) => `"${i}"`).join(" ");
 65 |   console.info(`Deploying ${info} ${contract.address} ${argStr}`);
 66 |   const ret = await contract.deployTransaction.wait();
 67 | 
 68 |   console.info("... Completed!");
 69 | 
 70 |   addGasUsed(ret.cumulativeGasUsed.toString())
 71 | 
 72 |   syncDeployInfo(registerName ?? name, {
 73 |     name: registerName ?? name,
 74 |     imple: contract.address,
 75 |   });
 76 | 
 77 |   return contract;
 78 | }
 79 | 
 80 | const verifyContract = async (name, address, contractPath, args) => {
 81 |   console.info(`Verifying ${name} ...`)
 82 |   await run('verify:verify', {
 83 |     contract: contractPath,
 84 |     address: address,
 85 |     constructorArguments: args ? [...args] : []
 86 |   })
 87 | }
 88 | 
 89 | async function contractAt(name, address, provider, options) {
 90 |   let contractFactory = await ethers.getContractFactory(name, options);
 91 |   if (provider) {
 92 |     contractFactory = contractFactory.connect(provider);
 93 |   }
 94 |   return await contractFactory.attach(address);
 95 | }
 96 | 
 97 | // batchLists is an array of lists
 98 | async function processBatch(batchLists, batchSize, handler) {
 99 |   let currentBatch = [];
100 |   const referenceList = batchLists[0];
101 | 
102 |   for (let i = 0; i < referenceList.length; i++) {
103 |     const item = [];
104 | 
105 |     for (let j = 0; j < batchLists.length; j++) {
106 |       const list = batchLists[j];
107 |       item.push(list[i]);
108 |     }
109 | 
110 |     currentBatch.push(item);
111 | 
112 |     if (currentBatch.length === batchSize) {
113 |       console.log(
114 |         "handling currentBatch",
115 |         i,
116 |         currentBatch.length,
117 |         referenceList.length
118 |       );
119 |       await handler(currentBatch);
120 |       currentBatch = [];
121 |     }
122 |   }
123 | 
124 |   if (currentBatch.length > 0) {
125 |     console.log(
126 |       "handling final batch",
127 |       currentBatch.length,
128 |       referenceList.length
129 |     );
130 |     await handler(currentBatch);
131 |   }
132 | }
133 | 
134 | async function updateTokensPerInterval(distributor, tokensPerInterval, label) {
135 |   const prevTokensPerInterval = await distributor.tokensPerInterval();
136 |   if (prevTokensPerInterval.eq(0)) {
137 |     // if the tokens per interval was zero, the distributor.lastDistributionTime may not have been updated for a while
138 |     // so the lastDistributionTime should be manually updated here
139 |     await sendTxn(
140 |       distributor.updateLastDistributionTime({ gasLimit: 1000000 }),
141 |       `${label}.updateLastDistributionTime`
142 |     );
143 |   }
144 |   await sendTxn(
145 |     distributor.setTokensPerInterval(tokensPerInterval, { gasLimit: 1000000 }),
146 |     `${label}.setTokensPerInterval`
147 |   );
148 | }
149 | 
150 | module.exports = {
151 |   getFrameSigner,
152 |   sendTxn,
153 |   deployContract,
154 |   verifyContract,
155 |   contractAt,
156 |   callWithRetries,
157 |   processBatch,
158 |   updateTokensPerInterval,
159 |   sleep,
160 | };
161 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Ethereum Vault
  2 | 
  3 | - [Ethereum Vault](#ethereum-vault)
  4 |   - [1. About](#1-about)
  5 |   - [2. Project description](#2-project-description)
  6 |   - [3. Smart contracts](#3-smart-contracts)
  7 |   - [4. Install](#4-install)
  8 |   - [5. Running tests](#5-running-tests)
  9 |     - [Testing in Ganache](#testing-in-ganache)
 10 |     - [Testing in Kovan](#testing-in-kovan)
 11 |     - [Test suite output](#test-suite-output)
 12 |   - [6. Deployed contracts in Kovan testnet](#6-deployed-contracts-in-kovan-testnet)
 13 |   - [7. TODO](#7-todo)
 14 | 
 15 | ## 1. About
 16 | 
 17 | This repository contains the source code and dependencies required to deploy a Solidity based VAULT smart contract that securely holds ETH whilst lending STABLE TOKEN to users on Ethereum network.
 18 | 
 19 | ## 2. Project description
 20 | 
 21 | This project implements a Vault that allows a user to borrow a stable token (pegged to USD) by depositing ether into the Vault as collateral.
 22 | 
 23 | The amount of tokens that can be borrowed is derived from the ETH/USD price provided by an on-chain oracle.
 24 | 
 25 | The user is allowed to withdraw the collateral after repaying the borrowed tokens.
 26 | 
 27 | The amount of collateral available to withdraw depends on the current ETH/USD price provided by the Oracle.
 28 | 
 29 | The diagram below shows a high level overview with the main components and its interactions
 30 | 
 31 | ![image info](./vault.png)
 32 | 
 33 | ## 3. Smart contracts
 34 | The smart contracts in the project are:
 35 | 
 36 | `Vault.sol`
 37 | 
 38 | - implements the business logic of the Vault
 39 | - exposes 5 main functions
 40 | 
 41 | ```javascript
 42 | deposit(uint256 amountToDeposit) // Allows a user to deposit ETH collateral in exchange for some amount of stablecoin
 43 | withdraw(uint256 repaymentAmount)  // Allows a user to withdraw up to 100% of the collateral they have on deposit
 44 | getVault(address userAddress) //Returns the details of a vault
 45 | estimateCollateralAmount(uint256 repaymentAmount) // Returns an estimate of how much collateral could be withdrawn for a given amount of stablecoin
 46 | estimateTokenAmount(uint256 depositAmount) // Returns an estimate on how much stable coin could be minted at the current rate
 47 | ```
 48 | 
 49 | `Coin.sol`
 50 | 
 51 | - ERC20 standard token
 52 | - implemens `mint` and `burn`
 53 | 
 54 | `PriceConsumerV3.sol`
 55 | 
 56 | - On chain oracle
 57 | - Leverages on chainlink price feed
 58 | 
 59 | ## 4. Install
 60 | 
 61 | Truffle and Ganache are required to deploy and test this project.
 62 | They can be installed by running:
 63 | 
 64 | ```
 65 | $ npm install -g truffle
 66 | $ npm install -g ganache-cli
 67 | ```
 68 | 
 69 | Clone the repository and install dependencies:
 70 | 
 71 | ```
 72 | $ npm install
 73 | ```
 74 | 
 75 | ## 5. Running tests
 76 | 
 77 | This project includes a test suite based in Truffle/Mocha.
 78 | 
 79 | Tests can be run on local Ganache or on Kovan.
 80 | 
 81 | ### Testing in Ganache
 82 | 
 83 | To run test in Ganache environment, a Ganache instance must be running on port 7545
 84 | 
 85 | You can start Ganache by executing the following:
 86 | 
 87 | ```
 88 | $ ganache-cli -p 7545
 89 | ```
 90 | 
 91 | To execute test suite, on a different terminal run:
 92 | 
 93 | ```
 94 | truffle test --network development
 95 | ```
 96 | 
 97 | ### Testing in Kovan
 98 | 
 99 | The following is required to run test cases in Kovan network
100 | 
101 | - infura account
102 | 
103 |   
104 |   API project KEY from https://infura.io enabled on KOVAN endpoint
105 | 
106 | - Kovan ether funds available
107 |   
108 |   At least 2 funded accounts are needed to run the tests in Kovan network.
109 | 
110 |   Ether funds in Kovan can be requested via Kovan faucet: https://faucet.kovan.network/
111 | 
112 | - `.env` file
113 |   
114 |   Truffle reads the kovan accounts and infura API KEY from a plain text `.env` file located in root folder.
115 | 
116 |   The `.env` file should define `MNEMONIC` and `INFURA_APIKEY` as environment variables:
117 | 
118 | ```
119 | MNEMONIC="<your mnemonic seed phrase that derives Kovan addresses with funds>"
120 | INFURA_APIKEY="<your valid infura API key>"
121 | ```
122 | 
123 | To execute test suite run:
124 | 
125 | ```
126 | export TEST_NETWORK="kovan"
127 | truffle test --network kovan
128 | ```
129 | 
130 | ### Test suite output
131 | 
132 | The following is the expected test result:
133 | 
134 | ```javascript
135 | ❯ export TEST_NETWORK="kovan"
136 | ❯ truffle test --network kovan
137 | Using network 'kovan'.
138 | 
139 | 
140 | Compiling your contracts...
141 | ===========================
142 | ✔ Fetching solc version list from solc-bin. Attempt #1
143 | > Everything is up to date, there is nothing to compile.
144 | 
145 | 
146 | 
147 |   Contract: Vault
148 |     Use Case 1: user deposits ether and receives stablecoin
149 |       ✓ should update user Vault collateral with sent Ether (1142ms)
150 |       ✓ should fire a 'Deposit' event
151 |       ✓ should update user token balance (1244ms)
152 |       ✓ should update user Vault debt (1289ms)
153 |       ✓ should provide a estimated token amount with accuracy > 90% (1237ms)
154 |     Use Case 2: user repays ALL tokens and withdraws ether
155 |       ✓ should fire a 'Withdraw' event
156 |       ✓ user token balance should be zero
157 |       ✓ user vault debt should be zero (999ms)
158 |       ✓ should provide a estimated repayment amount with accuracy > 90% (1143ms)
159 | 
160 | 
161 |   9 passing (1m)
162 | ```
163 | ## 6. Deployed contracts in Kovan testnet
164 | These contracts have been deployed in Kovan at the following addreses:
165 | 
166 | Vault.sol: https://kovan.etherscan.io/address/0xf9bf6096c67f643d4a8d407df12e3546e402cbc9
167 | 
168 | Coin.sol: https://kovan.etherscan.io/address/0xec8e0bb9169763d49349e459641595aed41e45c6
169 | 
170 | PriceConsumerV3.sol: https://kovan.etherscan.io/address/0x2699f2d5def11f16b6a357d133cda75cfde106b0
171 | 
172 | ## 7. TODO
173 | 
174 | - Add collateralization ratio
175 | - Implement liquidation
176 | - Use safemath
177 | - Improve test suite coverage
178 | - Gas optimization
179 | - Improve README.md


--------------------------------------------------------------------------------
/contracts/priceFeed.sol:
--------------------------------------------------------------------------------
  1 | 
  2 | // File: contracts/UniswapV2Library.sol
  3 | 
  4 | pragma solidity >=0.5.0;
  5 | 
  6 | interface IUniswapV2Factory {
  7 |     event PairCreated(address indexed token0, address indexed token1, address pair, uint);
  8 | 
  9 |     function feeTo() external view returns (address);
 10 |     function feeToSetter() external view returns (address);
 11 | 
 12 |     function getPair(address tokenA, address tokenB) external view returns (address pair);
 13 |     function allPairs(uint) external view returns (address pair);
 14 |     function allPairsLength() external view returns (uint);
 15 | 
 16 |     function createPair(address tokenA, address tokenB) external returns (address pair);
 17 | 
 18 |     function setFeeTo(address) external;
 19 |     function setFeeToSetter(address) external;
 20 | }
 21 | 
 22 | interface IUniswapV2Pair {
 23 |     event Approval(address indexed owner, address indexed spender, uint value);
 24 |     event Transfer(address indexed from, address indexed to, uint value);
 25 | 
 26 |     function name() external pure returns (string memory);
 27 |     function symbol() external pure returns (string memory);
 28 |     function decimals() external pure returns (uint8);
 29 |     function totalSupply() external view returns (uint);
 30 |     function balanceOf(address owner) external view returns (uint);
 31 |     function allowance(address owner, address spender) external view returns (uint);
 32 | 
 33 |     function approve(address spender, uint value) external returns (bool);
 34 |     function transfer(address to, uint value) external returns (bool);
 35 |     function transferFrom(address from, address to, uint value) external returns (bool);
 36 | 
 37 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 38 |     function PERMIT_TYPEHASH() external pure returns (bytes32);
 39 |     function nonces(address owner) external view returns (uint);
 40 | 
 41 |     function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
 42 | 
 43 |     event Mint(address indexed sender, uint amount0, uint amount1);
 44 |     event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
 45 |     event Swap(
 46 |         address indexed sender,
 47 |         uint amount0In,
 48 |         uint amount1In,
 49 |         uint amount0Out,
 50 |         uint amount1Out,
 51 |         address indexed to
 52 |     );
 53 |     event Sync(uint112 reserve0, uint112 reserve1);
 54 | 
 55 |     function MINIMUM_LIQUIDITY() external pure returns (uint);
 56 |     function factory() external view returns (address);
 57 |     function token0() external view returns (address);
 58 |     function token1() external view returns (address);
 59 |     function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
 60 |     function price0CumulativeLast() external view returns (uint);
 61 |     function price1CumulativeLast() external view returns (uint);
 62 |     function kLast() external view returns (uint);
 63 | 
 64 |     function mint(address to) external returns (uint liquidity);
 65 |     function burn(address to) external returns (uint amount0, uint amount1);
 66 |     function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
 67 |     function skim(address to) external;
 68 |     function sync() external;
 69 | 
 70 |     function initialize(address, address) external;
 71 | }
 72 | // File: @chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
 73 | 
 74 | 
 75 | pragma solidity ^0.8.0;
 76 | 
 77 | interface AggregatorV3Interface {
 78 |   function decimals() external view returns (uint8);
 79 | 
 80 |   function description() external view returns (string memory);
 81 | 
 82 |   function version() external view returns (uint256);
 83 | 
 84 |   function getRoundData(uint80 _roundId)
 85 |     external
 86 |     view
 87 |     returns (
 88 |       uint80 roundId,
 89 |       int256 answer,
 90 |       uint256 startedAt,
 91 |       uint256 updatedAt,
 92 |       uint80 answeredInRound
 93 |     );
 94 | 
 95 |   function latestRoundData()
 96 |     external
 97 |     view
 98 |     returns (
 99 |       uint80 roundId,
100 |       int256 answer,
101 |       uint256 startedAt,
102 |       uint256 updatedAt,
103 |       uint80 answeredInRound
104 |     );
105 | }
106 | 
107 | // File: contracts/bobPriceFeed.sol
108 | 
109 | pragma solidity >=0.8.20;
110 | 
111 | 
112 | 
113 | contract priceFeed {
114 | 
115 |     // address private targetToken = '0x6982508145454Ce325dDbE47a25d4ec3d2311933'; // mainnet
116 |     // address private mainToken = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'; // mainnet
117 |     address private mainToken = 0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6; // testnet 0x7af963cF6D228E564e2A0aA0DdBF06210B38615D
118 |     address private targetToken = 0x85502dD13fCc64d6Fff7430c62aDDA217dE44F7e; // testnet
119 | 
120 |     address private factoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; // mainnet
121 |     address private wethChainLinkPriceFeed = 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e; // mainnet
122 |     address private uniswapFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
123 | 
124 |     AggregatorV3Interface internal dataFeed;
125 | 
126 |     constructor(address _tToken) {
127 |         targetToken = _tToken;
128 |         dataFeed = AggregatorV3Interface(
129 |             wethChainLinkPriceFeed
130 |         );
131 |     }
132 | 
133 |     function latestAnswer()
134 |         external
135 |         view
136 |         returns (int256 answer)
137 |         {
138 |             uint256 resA;
139 |             uint256 resB;
140 |             uint256 tmp;
141 |             address pair =  IUniswapV2Factory(uniswapFactory).getPair(mainToken, targetToken);
142 |             (resA, resB, ) = IUniswapV2Pair(pair).getReserves();
143 |             if (mainToken < targetToken) {
144 |                 tmp = resA;
145 |                 resA = resB;
146 |                 resB = tmp;
147 |             }
148 |             (
149 |                 uint80 roundID,
150 |                 int price,
151 |                 uint startedAt,
152 |                 uint timeStamp,
153 |                 uint80 answeredInRound
154 |             ) = dataFeed.latestRoundData();
155 |             int256 nresB = int256(resB);
156 |             int256 nresA = int256(resA);
157 |             answer = int256(price * nresB / nresA );
158 |         }
159 | 
160 |     function feedback()
161 |         external
162 |         view
163 |         returns (int256 )
164 |         {
165 | 
166 |             (
167 |                 uint80 roundID,
168 |                 int price,
169 |                 uint startedAt,
170 |                 uint timeStamp,
171 |                 uint80 answeredInRound
172 |             ) = dataFeed.latestRoundData();
173 |             return price;
174 |         }
175 | 
176 |     function latestRound()
177 |       public
178 |       view
179 |       virtual
180 |       returns (uint256 roundId)
181 |     {
182 |       return 4;
183 |     }
184 | 
185 | }
186 | 


--------------------------------------------------------------------------------
/contracts/BOB.sol:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *Submitted for verification at Etherscan.io on 2021-05-08
  3 | */
  4 | 
  5 | pragma solidity ^0.8.0;
  6 | 
  7 | interface IERC20 {
  8 |     function symbol() external view returns (string memory);
  9 | 
 10 |     function balanceOf(address account) external view returns (uint256);
 11 | 
 12 |     // Note this is non standard but nearly all ERC20 have exposed decimal functions
 13 |     function decimals() external view returns (uint8);
 14 | 
 15 |     function transfer(address recipient, uint256 amount)
 16 |         external
 17 |         returns (bool);
 18 | 
 19 |     function allowance(address owner, address spender)
 20 |         external
 21 |         view
 22 |         returns (uint256);
 23 | 
 24 |     function approve(address spender, uint256 amount) external returns (bool);
 25 | 
 26 |     function transferFrom(
 27 |         address sender,
 28 |         address recipient,
 29 |         uint256 amount
 30 |     ) external returns (bool);
 31 | 
 32 |     event Transfer(address indexed from, address indexed to, uint256 value);
 33 |     event Approval(
 34 |         address indexed owner,
 35 |         address indexed spender,
 36 |         uint256 value
 37 |     );
 38 | }
 39 | 
 40 | /**
 41 |  * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 42 |  * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 43 |  *
 44 |  * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 45 |  * presenting a message signaed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 46 |  * need to send a transaction, and thus is not required to hold Ether at all.
 47 |  */
 48 | interface IERC20Permit is IERC20 {
 49 |     /**
 50 |      * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
 51 |      * given `owner`'s signed approval.
 52 |      *
 53 |      * IMPORTANT: The same issues {IERC20-approve} has related to transaction
 54 |      * ordering also apply here.
 55 |      *
 56 |      * Emits an {Approval} event.
 57 |      *
 58 |      * Requirements:
 59 |      *
 60 |      * - `spender` cannot be the zero address.
 61 |      * - `deadline` must be a timestamp in the future.
 62 |      * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
 63 |      * over the EIP712-formatted function arguments.
 64 |      * - the signature must use ``owner``'s current nonce (see {nonces}).
 65 |      *
 66 |      * For more information on the signature format, see the
 67 |      * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
 68 |      * section].
 69 |      */
 70 |     function permit(
 71 |         address owner,
 72 |         address spender,
 73 |         uint256 value,
 74 |         uint256 deadline,
 75 |         uint8 v,
 76 |         bytes32 r,
 77 |         bytes32 s
 78 |     ) external;
 79 | 
 80 |     /**
 81 |      * @dev Returns the current nonce for `owner`. This value must be
 82 |      * included whenever a signature is generated for {permit}.
 83 |      *
 84 |      * Every successful call to {permit} increases ``owner``'s nonce by one. This
 85 |      * prevents a signature from being used multiple times.
 86 |      */
 87 |     function nonces(address owner) external view returns (uint256);
 88 | 
 89 |     /**
 90 |      * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
 91 |      */
 92 |     // solhint-disable-next-line func-name-mixedcase
 93 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 94 | }
 95 | 
 96 | abstract contract ERC20Permit is IERC20Permit {
 97 |     // --- ERC20 Data ---
 98 |     // The name of the erc20 token
 99 |     string public name;
100 |     // The symbol of the erc20 token
101 |     string public override symbol;
102 |     // The decimals of the erc20 token, should default to 18 for new tokens
103 |     uint8 public override decimals;
104 | 
105 |     // A mapping which tracks user token balances
106 |     mapping(address => uint256) public override balanceOf;
107 |     // A mapping which tracks which addresses a user allows to move their tokens
108 |     mapping(address => mapping(address => uint256)) public override allowance;
109 |     // A mapping which tracks the permit signature nonces for users
110 |     mapping(address => uint256) public override nonces;
111 | 
112 |     // --- EIP712 niceties ---
113 |     // solhint-disable-next-line var-name-mixedcase
114 |     bytes32 public override DOMAIN_SEPARATOR;
115 |     // bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
116 |     bytes32
117 |         public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
118 | 
119 |     /// @notice Initializes the erc20 contract
120 |     /// @param name_ the value 'name' will be set to
121 |     /// @param symbol_ the value 'symbol' will be set to
122 |     /// @dev decimals default to 18 and must be reset by an inheriting contract for
123 |     ///      non standard decimal values
124 |     constructor(string memory name_, string memory symbol_) {
125 |         // Set the state variables
126 |         name = name_;
127 |         symbol = symbol_;
128 |         decimals = 18;
129 | 
130 |         // By setting these addresses to 0 attempting to execute a transfer to
131 |         // either of them will revert. This is a gas efficient way to prevent
132 |         // a common user mistake where they transfer to the token address.
133 |         // These values are not considered 'real' tokens and so are not included
134 |         // in 'total supply' which only contains minted tokens.
135 |         balanceOf[address(0)] = type(uint256).max;
136 |         balanceOf[address(this)] = type(uint256).max;
137 | 
138 |         // Computes the EIP 712 domain separator which prevents user signed messages for
139 |         // this contract to be replayed in other contracts.
140 |         // https://eips.ethereum.org/EIPS/eip-712
141 |         DOMAIN_SEPARATOR = keccak256(
142 |             abi.encode(
143 |                 keccak256(
144 |                     "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
145 |                 ),
146 |                 keccak256(bytes(name)),
147 |                 keccak256(bytes("1")),
148 |                 block.chainid,
149 |                 address(this)
150 |             )
151 |         );
152 |     }
153 | 
154 |     // --- Token ---
155 |     /// @notice Allows a token owner to send tokens to another address
156 |     /// @param recipient The address which will be credited with the tokens
157 |     /// @param amount The amount user token to send
158 |     /// @return returns true on success, reverts on failure so cannot return false.
159 |     /// @dev transfers to this contract address or 0 will fail
160 |     function transfer(address recipient, uint256 amount)
161 |         public
162 |         virtual
163 |         override
164 |         returns (bool)
165 |     {
166 |         // We forward this call to 'transferFrom'
167 |         return transferFrom(msg.sender, recipient, amount);
168 |     }
169 | 
170 |     /// @notice Transfers an amount of erc20 from a spender to a receipt
171 |     /// @param spender The source of the ERC20 tokens
172 |     /// @param recipient The destination of the ERC20 tokens
173 |     /// @param amount the number of tokens to send
174 |     /// @return returns true on success and reverts on failure
175 |     /// @dev will fail transfers which send funds to this contract or 0
176 |     function transferFrom(
177 |         address spender,
178 |         address recipient,
179 |         uint256 amount
180 |     ) public virtual override returns (bool) {
181 |         // Load balance and allowance
182 |         uint256 balance = balanceOf[spender];
183 |         require(balance >= amount, "ERC20: insufficient-balance");
184 |         // We potentially have to change allowances
185 |         if (spender != msg.sender) {
186 |             // Loading the allowance in the if block prevents vanilla transfers
187 |             // from paying for the sload.
188 |             uint256 allowed = allowance[spender][msg.sender];
189 |             // If the allowance is max we do not reduce it
190 |             // Note - This means that max allowances will be more gas efficient
191 |             // by not requiring a sstore on 'transferFrom'
192 |             if (allowed != type(uint256).max) {
193 |                 require(allowed >= amount, "ERC20: insufficient-allowance");
194 |                 allowance[spender][msg.sender] = allowed - amount;
195 |             }
196 |         }
197 |         // Update the balances
198 |         balanceOf[spender] = balance - amount;
199 |         // Note - In the constructor we initialize the 'balanceOf' of address 0 and
200 |         //        the token address to uint256.max and so in 8.0 transfers to those
201 |         //        addresses revert on this step.
202 |         balanceOf[recipient] = balanceOf[recipient] + amount;
203 |         // Emit the needed event
204 |         emit Transfer(spender, recipient, amount);
205 |         // Return that this call succeeded
206 |         return true;
207 |     }
208 | 
209 |     /// @notice This internal minting function allows inheriting contracts
210 |     ///         to mint tokens in the way they wish.
211 |     /// @param account the address which will receive the token.
212 |     /// @param amount the amount of token which they will receive
213 |     /// @dev This function is virtual so that it can be overridden, if you
214 |     ///      are reviewing this contract for security you should ensure to
215 |     ///      check for overrides
216 |     function _mint(address account, uint256 amount) internal virtual {
217 |         // Add tokens to the account
218 |         balanceOf[account] = balanceOf[account] + amount;
219 |         // Emit an event to track the minting
220 |         emit Transfer(address(0), account, amount);
221 |     }
222 | 
223 |     /// @notice This internal burning function allows inheriting contracts to
224 |     ///         burn tokens in the way they see fit.
225 |     /// @param account the account to remove tokens from
226 |     /// @param amount  the amount of tokens to remove
227 |     /// @dev This function is virtual so that it can be overridden, if you
228 |     ///      are reviewing this contract for security you should ensure to
229 |     ///      check for overrides
230 |     function _burn(address account, uint256 amount) internal virtual {
231 |         // Reduce the balance of the account
232 |         balanceOf[account] = balanceOf[account] - amount;
233 |         // Emit an event tracking transfers
234 |         emit Transfer(account, address(0), amount);
235 |     }
236 | 
237 |     /// @notice This function allows a user to approve an account which can transfer
238 |     ///         tokens on their behalf.
239 |     /// @param account The account which will be approve to transfer tokens
240 |     /// @param amount The approval amount, if set to uint256.max the allowance does not go down on transfers.
241 |     /// @return returns true for compatibility with the ERC20 standard
242 |     function approve(address account, uint256 amount)
243 |         public
244 |         virtual
245 |         override
246 |         returns (bool)
247 |     {
248 |         // Set the senders allowance for account to amount
249 |         allowance[msg.sender][account] = amount;
250 |         // Emit an event to track approvals
251 |         emit Approval(msg.sender, account, amount);
252 |         return true;
253 |     }
254 | 
255 |     /// @notice This function allows a caller who is not the owner of an account to execute the functionality of 'approve' with the owners signature.
256 |     /// @param owner the owner of the account which is having the new approval set
257 |     /// @param spender the address which will be allowed to spend owner's tokens
258 |     /// @param value the new allowance value
259 |     /// @param deadline the timestamp which the signature must be submitted by to be valid
260 |     /// @param v Extra ECDSA data which allows public key recovery from signature assumed to be 27 or 28
261 |     /// @param r The r component of the ECDSA signature
262 |     /// @param s The s component of the ECDSA signature
263 |     /// @dev The signature for this function follows EIP 712 standard and should be generated with the
264 |     ///      eth_signTypedData JSON RPC call instead of the eth_sign JSON RPC call. If using out of date
265 |     ///      parity signing libraries the v component may need to be adjusted. Also it is very rare but possible
266 |     ///      for v to be other values, those values are not supported.
267 |     function permit(
268 |         address owner,
269 |         address spender,
270 |         uint256 value,
271 |         uint256 deadline,
272 |         uint8 v,
273 |         bytes32 r,
274 |         bytes32 s
275 |     ) external override {
276 |         // The EIP 712 digest for this function
277 |         bytes32 digest = keccak256(
278 |             abi.encodePacked(
279 |                 "\x19\x01",
280 |                 DOMAIN_SEPARATOR,
281 |                 keccak256(
282 |                     abi.encode(
283 |                         PERMIT_TYPEHASH,
284 |                         owner,
285 |                         spender,
286 |                         value,
287 |                         nonces[owner],
288 |                         deadline
289 |                     )
290 |                 )
291 |             )
292 |         );
293 |         // Require that the owner is not zero
294 |         require(owner != address(0), "ERC20: invalid-address-0");
295 |         // Require that we have a valid signature from the owner
296 |         require(owner == ecrecover(digest, v, r, s), "ERC20: invalid-permit");
297 |         // Require that the signature is not expired
298 |         require(
299 |             deadline == 0 || block.timestamp <= deadline,
300 |             "ERC20: permit-expired"
301 |         );
302 |         // Increment the signature nonce to prevent replay
303 |         nonces[owner]++;
304 |         // Set the allowance to the new value
305 |         allowance[owner][spender] = value;
306 |         // Emit an approval event to be able to track this happening
307 |         emit Approval(owner, spender, value);
308 |     }
309 | 
310 |     /// @notice Internal function which allows inheriting contract to set custom decimals
311 |     /// @param decimals_ the new decimal value
312 |     function _setupDecimals(uint8 decimals_) internal {
313 |         // Set the decimals
314 |         decimals = decimals_;
315 |     }
316 | }
317 | contract Authorizable {
318 |     // This contract allows a flexible authorization scheme
319 | 
320 |     // The owner who can change authorization status
321 |     address public owner;
322 |     // A mapping from an address to its authorization status
323 |     mapping(address => bool) public authorized;
324 | 
325 |     /// @dev We set the deployer to the owner
326 |     constructor() {
327 |         owner = msg.sender;
328 |     }
329 | 
330 |     /// @dev This modifier checks if the msg.sender is the owner
331 |     modifier onlyOwner() {
332 |         require(msg.sender == owner, "Sender not owner");
333 |         _;
334 |     }
335 | 
336 |     /// @dev This modifier checks if an address is authorized
337 |     modifier onlyAuthorized() {
338 |         require(isAuthorized(msg.sender), "Sender not Authorized");
339 |         _;
340 |     }
341 | 
342 |     /// @dev Returns true if an address is authorized
343 |     /// @param who the address to check
344 |     /// @return true if authorized false if not
345 |     function isAuthorized(address who) public view returns (bool) {
346 |         return authorized[who];
347 |     }
348 | 
349 |     /// @dev Privileged function authorize an address
350 |     /// @param who the address to authorize
351 |     function authorize(address who) external onlyOwner() {
352 |         _authorize(who);
353 |     }
354 | 
355 |     /// @dev Privileged function to de authorize an address
356 |     /// @param who The address to remove authorization from
357 |     function deauthorize(address who) external onlyOwner() {
358 |         authorized[who] = false;
359 |     }
360 | 
361 |     /// @dev Function to change owner
362 |     /// @param who The new owner address
363 |     function setOwner(address who) public onlyOwner() {
364 |         owner = who;
365 |     }
366 | 
367 |     /// @dev Inheritable function which authorizes someone
368 |     /// @param who the address to authorize
369 |     function _authorize(address who) internal {
370 |         authorized[who] = true;
371 |     }
372 | }
373 | 
374 | contract BOB is ERC20Permit, Authorizable {
375 |      constructor()
376 |         Authorizable()
377 |         ERC20Permit("BOB Coin", "BOB")
378 |     {
379 |         _setupDecimals(18);
380 |     }
381 |     function mint(address _account, uint256 _amount) external onlyAuthorized() {
382 |         _mint(_account, _amount);
383 |     }
384 |     function burn(address _account, uint256 _amount) external onlyAuthorized() {
385 |         _burn(_account, _amount);
386 |     }
387 | }


--------------------------------------------------------------------------------
/contracts/DOGE.sol:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *Submitted for verification at Etherscan.io on 2021-05-08
  3 | */
  4 | 
  5 | pragma solidity ^0.8.0;
  6 | 
  7 | interface IERC20 {
  8 |     function symbol() external view returns (string memory);
  9 | 
 10 |     function balanceOf(address account) external view returns (uint256);
 11 | 
 12 |     // Note this is non standard but nearly all ERC20 have exposed decimal functions
 13 |     function decimals() external view returns (uint8);
 14 | 
 15 |     function transfer(address recipient, uint256 amount)
 16 |         external
 17 |         returns (bool);
 18 | 
 19 |     function allowance(address owner, address spender)
 20 |         external
 21 |         view
 22 |         returns (uint256);
 23 | 
 24 |     function approve(address spender, uint256 amount) external returns (bool);
 25 | 
 26 |     function transferFrom(
 27 |         address sender,
 28 |         address recipient,
 29 |         uint256 amount
 30 |     ) external returns (bool);
 31 | 
 32 |     event Transfer(address indexed from, address indexed to, uint256 value);
 33 |     event Approval(
 34 |         address indexed owner,
 35 |         address indexed spender,
 36 |         uint256 value
 37 |     );
 38 | }
 39 | 
 40 | /**
 41 |  * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 42 |  * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 43 |  *
 44 |  * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 45 |  * presenting a message signaed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 46 |  * need to send a transaction, and thus is not required to hold Ether at all.
 47 |  */
 48 | interface IERC20Permit is IERC20 {
 49 |     /**
 50 |      * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
 51 |      * given `owner`'s signed approval.
 52 |      *
 53 |      * IMPORTANT: The same issues {IERC20-approve} has related to transaction
 54 |      * ordering also apply here.
 55 |      *
 56 |      * Emits an {Approval} event.
 57 |      *
 58 |      * Requirements:
 59 |      *
 60 |      * - `spender` cannot be the zero address.
 61 |      * - `deadline` must be a timestamp in the future.
 62 |      * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
 63 |      * over the EIP712-formatted function arguments.
 64 |      * - the signature must use ``owner``'s current nonce (see {nonces}).
 65 |      *
 66 |      * For more information on the signature format, see the
 67 |      * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
 68 |      * section].
 69 |      */
 70 |     function permit(
 71 |         address owner,
 72 |         address spender,
 73 |         uint256 value,
 74 |         uint256 deadline,
 75 |         uint8 v,
 76 |         bytes32 r,
 77 |         bytes32 s
 78 |     ) external;
 79 | 
 80 |     /**
 81 |      * @dev Returns the current nonce for `owner`. This value must be
 82 |      * included whenever a signature is generated for {permit}.
 83 |      *
 84 |      * Every successful call to {permit} increases ``owner``'s nonce by one. This
 85 |      * prevents a signature from being used multiple times.
 86 |      */
 87 |     function nonces(address owner) external view returns (uint256);
 88 | 
 89 |     /**
 90 |      * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
 91 |      */
 92 |     // solhint-disable-next-line func-name-mixedcase
 93 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 94 | }
 95 | 
 96 | abstract contract ERC20Permit is IERC20Permit {
 97 |     // --- ERC20 Data ---
 98 |     // The name of the erc20 token
 99 |     string public name;
100 |     // The symbol of the erc20 token
101 |     string public override symbol;
102 |     // The decimals of the erc20 token, should default to 18 for new tokens
103 |     uint8 public override decimals;
104 | 
105 |     // A mapping which tracks user token balances
106 |     mapping(address => uint256) public override balanceOf;
107 |     // A mapping which tracks which addresses a user allows to move their tokens
108 |     mapping(address => mapping(address => uint256)) public override allowance;
109 |     // A mapping which tracks the permit signature nonces for users
110 |     mapping(address => uint256) public override nonces;
111 | 
112 |     // --- EIP712 niceties ---
113 |     // solhint-disable-next-line var-name-mixedcase
114 |     bytes32 public override DOMAIN_SEPARATOR;
115 |     // bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
116 |     bytes32
117 |         public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
118 | 
119 |     /// @notice Initializes the erc20 contract
120 |     /// @param name_ the value 'name' will be set to
121 |     /// @param symbol_ the value 'symbol' will be set to
122 |     /// @dev decimals default to 18 and must be reset by an inheriting contract for
123 |     ///      non standard decimal values
124 |     constructor(string memory name_, string memory symbol_) {
125 |         // Set the state variables
126 |         name = name_;
127 |         symbol = symbol_;
128 |         decimals = 18;
129 | 
130 |         // By setting these addresses to 0 attempting to execute a transfer to
131 |         // either of them will revert. This is a gas efficient way to prevent
132 |         // a common user mistake where they transfer to the token address.
133 |         // These values are not considered 'real' tokens and so are not included
134 |         // in 'total supply' which only contains minted tokens.
135 |         balanceOf[address(0)] = type(uint256).max;
136 |         balanceOf[address(this)] = type(uint256).max;
137 | 
138 |         // Computes the EIP 712 domain separator which prevents user signed messages for
139 |         // this contract to be replayed in other contracts.
140 |         // https://eips.ethereum.org/EIPS/eip-712
141 |         DOMAIN_SEPARATOR = keccak256(
142 |             abi.encode(
143 |                 keccak256(
144 |                     "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
145 |                 ),
146 |                 keccak256(bytes(name)),
147 |                 keccak256(bytes("1")),
148 |                 block.chainid,
149 |                 address(this)
150 |             )
151 |         );
152 |     }
153 | 
154 |     // --- Token ---
155 |     /// @notice Allows a token owner to send tokens to another address
156 |     /// @param recipient The address which will be credited with the tokens
157 |     /// @param amount The amount user token to send
158 |     /// @return returns true on success, reverts on failure so cannot return false.
159 |     /// @dev transfers to this contract address or 0 will fail
160 |     function transfer(address recipient, uint256 amount)
161 |         public
162 |         virtual
163 |         override
164 |         returns (bool)
165 |     {
166 |         // We forward this call to 'transferFrom'
167 |         return transferFrom(msg.sender, recipient, amount);
168 |     }
169 | 
170 |     /// @notice Transfers an amount of erc20 from a spender to a receipt
171 |     /// @param spender The source of the ERC20 tokens
172 |     /// @param recipient The destination of the ERC20 tokens
173 |     /// @param amount the number of tokens to send
174 |     /// @return returns true on success and reverts on failure
175 |     /// @dev will fail transfers which send funds to this contract or 0
176 |     function transferFrom(
177 |         address spender,
178 |         address recipient,
179 |         uint256 amount
180 |     ) public virtual override returns (bool) {
181 |         // Load balance and allowance
182 |         uint256 balance = balanceOf[spender];
183 |         require(balance >= amount, "ERC20: insufficient-balance");
184 |         // We potentially have to change allowances
185 |         if (spender != msg.sender) {
186 |             // Loading the allowance in the if block prevents vanilla transfers
187 |             // from paying for the sload.
188 |             uint256 allowed = allowance[spender][msg.sender];
189 |             // If the allowance is max we do not reduce it
190 |             // Note - This means that max allowances will be more gas efficient
191 |             // by not requiring a sstore on 'transferFrom'
192 |             if (allowed != type(uint256).max) {
193 |                 require(allowed >= amount, "ERC20: insufficient-allowance");
194 |                 allowance[spender][msg.sender] = allowed - amount;
195 |             }
196 |         }
197 |         // Update the balances
198 |         balanceOf[spender] = balance - amount;
199 |         // Note - In the constructor we initialize the 'balanceOf' of address 0 and
200 |         //        the token address to uint256.max and so in 8.0 transfers to those
201 |         //        addresses revert on this step.
202 |         balanceOf[recipient] = balanceOf[recipient] + amount;
203 |         // Emit the needed event
204 |         emit Transfer(spender, recipient, amount);
205 |         // Return that this call succeeded
206 |         return true;
207 |     }
208 | 
209 |     /// @notice This internal minting function allows inheriting contracts
210 |     ///         to mint tokens in the way they wish.
211 |     /// @param account the address which will receive the token.
212 |     /// @param amount the amount of token which they will receive
213 |     /// @dev This function is virtual so that it can be overridden, if you
214 |     ///      are reviewing this contract for security you should ensure to
215 |     ///      check for overrides
216 |     function _mint(address account, uint256 amount) internal virtual {
217 |         // Add tokens to the account
218 |         balanceOf[account] = balanceOf[account] + amount;
219 |         // Emit an event to track the minting
220 |         emit Transfer(address(0), account, amount);
221 |     }
222 | 
223 |     /// @notice This internal burning function allows inheriting contracts to
224 |     ///         burn tokens in the way they see fit.
225 |     /// @param account the account to remove tokens from
226 |     /// @param amount  the amount of tokens to remove
227 |     /// @dev This function is virtual so that it can be overridden, if you
228 |     ///      are reviewing this contract for security you should ensure to
229 |     ///      check for overrides
230 |     function _burn(address account, uint256 amount) internal virtual {
231 |         // Reduce the balance of the account
232 |         balanceOf[account] = balanceOf[account] - amount;
233 |         // Emit an event tracking transfers
234 |         emit Transfer(account, address(0), amount);
235 |     }
236 | 
237 |     /// @notice This function allows a user to approve an account which can transfer
238 |     ///         tokens on their behalf.
239 |     /// @param account The account which will be approve to transfer tokens
240 |     /// @param amount The approval amount, if set to uint256.max the allowance does not go down on transfers.
241 |     /// @return returns true for compatibility with the ERC20 standard
242 |     function approve(address account, uint256 amount)
243 |         public
244 |         virtual
245 |         override
246 |         returns (bool)
247 |     {
248 |         // Set the senders allowance for account to amount
249 |         allowance[msg.sender][account] = amount;
250 |         // Emit an event to track approvals
251 |         emit Approval(msg.sender, account, amount);
252 |         return true;
253 |     }
254 | 
255 |     /// @notice This function allows a caller who is not the owner of an account to execute the functionality of 'approve' with the owners signature.
256 |     /// @param owner the owner of the account which is having the new approval set
257 |     /// @param spender the address which will be allowed to spend owner's tokens
258 |     /// @param value the new allowance value
259 |     /// @param deadline the timestamp which the signature must be submitted by to be valid
260 |     /// @param v Extra ECDSA data which allows public key recovery from signature assumed to be 27 or 28
261 |     /// @param r The r component of the ECDSA signature
262 |     /// @param s The s component of the ECDSA signature
263 |     /// @dev The signature for this function follows EIP 712 standard and should be generated with the
264 |     ///      eth_signTypedData JSON RPC call instead of the eth_sign JSON RPC call. If using out of date
265 |     ///      parity signing libraries the v component may need to be adjusted. Also it is very rare but possible
266 |     ///      for v to be other values, those values are not supported.
267 |     function permit(
268 |         address owner,
269 |         address spender,
270 |         uint256 value,
271 |         uint256 deadline,
272 |         uint8 v,
273 |         bytes32 r,
274 |         bytes32 s
275 |     ) external override {
276 |         // The EIP 712 digest for this function
277 |         bytes32 digest = keccak256(
278 |             abi.encodePacked(
279 |                 "\x19\x01",
280 |                 DOMAIN_SEPARATOR,
281 |                 keccak256(
282 |                     abi.encode(
283 |                         PERMIT_TYPEHASH,
284 |                         owner,
285 |                         spender,
286 |                         value,
287 |                         nonces[owner],
288 |                         deadline
289 |                     )
290 |                 )
291 |             )
292 |         );
293 |         // Require that the owner is not zero
294 |         require(owner != address(0), "ERC20: invalid-address-0");
295 |         // Require that we have a valid signature from the owner
296 |         require(owner == ecrecover(digest, v, r, s), "ERC20: invalid-permit");
297 |         // Require that the signature is not expired
298 |         require(
299 |             deadline == 0 || block.timestamp <= deadline,
300 |             "ERC20: permit-expired"
301 |         );
302 |         // Increment the signature nonce to prevent replay
303 |         nonces[owner]++;
304 |         // Set the allowance to the new value
305 |         allowance[owner][spender] = value;
306 |         // Emit an approval event to be able to track this happening
307 |         emit Approval(owner, spender, value);
308 |     }
309 | 
310 |     /// @notice Internal function which allows inheriting contract to set custom decimals
311 |     /// @param decimals_ the new decimal value
312 |     function _setupDecimals(uint8 decimals_) internal {
313 |         // Set the decimals
314 |         decimals = decimals_;
315 |     }
316 | }
317 | contract Authorizable {
318 |     // This contract allows a flexible authorization scheme
319 | 
320 |     // The owner who can change authorization status
321 |     address public owner;
322 |     // A mapping from an address to its authorization status
323 |     mapping(address => bool) public authorized;
324 | 
325 |     /// @dev We set the deployer to the owner
326 |     constructor() {
327 |         owner = msg.sender;
328 |     }
329 | 
330 |     /// @dev This modifier checks if the msg.sender is the owner
331 |     modifier onlyOwner() {
332 |         require(msg.sender == owner, "Sender not owner");
333 |         _;
334 |     }
335 | 
336 |     /// @dev This modifier checks if an address is authorized
337 |     modifier onlyAuthorized() {
338 |         require(isAuthorized(msg.sender), "Sender not Authorized");
339 |         _;
340 |     }
341 | 
342 |     /// @dev Returns true if an address is authorized
343 |     /// @param who the address to check
344 |     /// @return true if authorized false if not
345 |     function isAuthorized(address who) public view returns (bool) {
346 |         return authorized[who];
347 |     }
348 | 
349 |     /// @dev Privileged function authorize an address
350 |     /// @param who the address to authorize
351 |     function authorize(address who) external onlyOwner() {
352 |         _authorize(who);
353 |     }
354 | 
355 |     /// @dev Privileged function to de authorize an address
356 |     /// @param who The address to remove authorization from
357 |     function deauthorize(address who) external onlyOwner() {
358 |         authorized[who] = false;
359 |     }
360 | 
361 |     /// @dev Function to change owner
362 |     /// @param who The new owner address
363 |     function setOwner(address who) public onlyOwner() {
364 |         owner = who;
365 |     }
366 | 
367 |     /// @dev Inheritable function which authorizes someone
368 |     /// @param who the address to authorize
369 |     function _authorize(address who) internal {
370 |         authorized[who] = true;
371 |     }
372 | }
373 | 
374 | contract DOGE is ERC20Permit, Authorizable {
375 |      constructor()
376 |         Authorizable()
377 |         ERC20Permit("DOGE Coin", "DOGE")
378 |     {
379 |         _setupDecimals(8);
380 |     }
381 |     function mint(address _account, uint256 _amount) external onlyAuthorized() {
382 |         _mint(_account, _amount);
383 |     }
384 |     function burn(address _account, uint256 _amount) external onlyAuthorized() {
385 |         _burn(_account, _amount);
386 |     }
387 | }


--------------------------------------------------------------------------------
/contracts/PEPE.sol:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *Submitted for verification at Etherscan.io on 2021-05-08
  3 | */
  4 | 
  5 | pragma solidity ^0.8.0;
  6 | 
  7 | interface IERC20 {
  8 |     function symbol() external view returns (string memory);
  9 | 
 10 |     function balanceOf(address account) external view returns (uint256);
 11 | 
 12 |     // Note this is non standard but nearly all ERC20 have exposed decimal functions
 13 |     function decimals() external view returns (uint8);
 14 | 
 15 |     function transfer(address recipient, uint256 amount)
 16 |         external
 17 |         returns (bool);
 18 | 
 19 |     function allowance(address owner, address spender)
 20 |         external
 21 |         view
 22 |         returns (uint256);
 23 | 
 24 |     function approve(address spender, uint256 amount) external returns (bool);
 25 | 
 26 |     function transferFrom(
 27 |         address sender,
 28 |         address recipient,
 29 |         uint256 amount
 30 |     ) external returns (bool);
 31 | 
 32 |     event Transfer(address indexed from, address indexed to, uint256 value);
 33 |     event Approval(
 34 |         address indexed owner,
 35 |         address indexed spender,
 36 |         uint256 value
 37 |     );
 38 | }
 39 | 
 40 | /**
 41 |  * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 42 |  * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 43 |  *
 44 |  * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 45 |  * presenting a message signaed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 46 |  * need to send a transaction, and thus is not required to hold Ether at all.
 47 |  */
 48 | interface IERC20Permit is IERC20 {
 49 |     /**
 50 |      * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
 51 |      * given `owner`'s signed approval.
 52 |      *
 53 |      * IMPORTANT: The same issues {IERC20-approve} has related to transaction
 54 |      * ordering also apply here.
 55 |      *
 56 |      * Emits an {Approval} event.
 57 |      *
 58 |      * Requirements:
 59 |      *
 60 |      * - `spender` cannot be the zero address.
 61 |      * - `deadline` must be a timestamp in the future.
 62 |      * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
 63 |      * over the EIP712-formatted function arguments.
 64 |      * - the signature must use ``owner``'s current nonce (see {nonces}).
 65 |      *
 66 |      * For more information on the signature format, see the
 67 |      * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
 68 |      * section].
 69 |      */
 70 |     function permit(
 71 |         address owner,
 72 |         address spender,
 73 |         uint256 value,
 74 |         uint256 deadline,
 75 |         uint8 v,
 76 |         bytes32 r,
 77 |         bytes32 s
 78 |     ) external;
 79 | 
 80 |     /**
 81 |      * @dev Returns the current nonce for `owner`. This value must be
 82 |      * included whenever a signature is generated for {permit}.
 83 |      *
 84 |      * Every successful call to {permit} increases ``owner``'s nonce by one. This
 85 |      * prevents a signature from being used multiple times.
 86 |      */
 87 |     function nonces(address owner) external view returns (uint256);
 88 | 
 89 |     /**
 90 |      * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
 91 |      */
 92 |     // solhint-disable-next-line func-name-mixedcase
 93 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 94 | }
 95 | 
 96 | abstract contract ERC20Permit is IERC20Permit {
 97 |     // --- ERC20 Data ---
 98 |     // The name of the erc20 token
 99 |     string public name;
100 |     // The symbol of the erc20 token
101 |     string public override symbol;
102 |     // The decimals of the erc20 token, should default to 18 for new tokens
103 |     uint8 public override decimals;
104 | 
105 |     // A mapping which tracks user token balances
106 |     mapping(address => uint256) public override balanceOf;
107 |     // A mapping which tracks which addresses a user allows to move their tokens
108 |     mapping(address => mapping(address => uint256)) public override allowance;
109 |     // A mapping which tracks the permit signature nonces for users
110 |     mapping(address => uint256) public override nonces;
111 | 
112 |     // --- EIP712 niceties ---
113 |     // solhint-disable-next-line var-name-mixedcase
114 |     bytes32 public override DOMAIN_SEPARATOR;
115 |     // bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
116 |     bytes32
117 |         public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
118 | 
119 |     /// @notice Initializes the erc20 contract
120 |     /// @param name_ the value 'name' will be set to
121 |     /// @param symbol_ the value 'symbol' will be set to
122 |     /// @dev decimals default to 18 and must be reset by an inheriting contract for
123 |     ///      non standard decimal values
124 |     constructor(string memory name_, string memory symbol_) {
125 |         // Set the state variables
126 |         name = name_;
127 |         symbol = symbol_;
128 |         decimals = 18;
129 | 
130 |         // By setting these addresses to 0 attempting to execute a transfer to
131 |         // either of them will revert. This is a gas efficient way to prevent
132 |         // a common user mistake where they transfer to the token address.
133 |         // These values are not considered 'real' tokens and so are not included
134 |         // in 'total supply' which only contains minted tokens.
135 |         balanceOf[address(0)] = type(uint256).max;
136 |         balanceOf[address(this)] = type(uint256).max;
137 | 
138 |         // Computes the EIP 712 domain separator which prevents user signed messages for
139 |         // this contract to be replayed in other contracts.
140 |         // https://eips.ethereum.org/EIPS/eip-712
141 |         DOMAIN_SEPARATOR = keccak256(
142 |             abi.encode(
143 |                 keccak256(
144 |                     "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
145 |                 ),
146 |                 keccak256(bytes(name)),
147 |                 keccak256(bytes("1")),
148 |                 block.chainid,
149 |                 address(this)
150 |             )
151 |         );
152 |     }
153 | 
154 |     // --- Token ---
155 |     /// @notice Allows a token owner to send tokens to another address
156 |     /// @param recipient The address which will be credited with the tokens
157 |     /// @param amount The amount user token to send
158 |     /// @return returns true on success, reverts on failure so cannot return false.
159 |     /// @dev transfers to this contract address or 0 will fail
160 |     function transfer(address recipient, uint256 amount)
161 |         public
162 |         virtual
163 |         override
164 |         returns (bool)
165 |     {
166 |         // We forward this call to 'transferFrom'
167 |         return transferFrom(msg.sender, recipient, amount);
168 |     }
169 | 
170 |     /// @notice Transfers an amount of erc20 from a spender to a receipt
171 |     /// @param spender The source of the ERC20 tokens
172 |     /// @param recipient The destination of the ERC20 tokens
173 |     /// @param amount the number of tokens to send
174 |     /// @return returns true on success and reverts on failure
175 |     /// @dev will fail transfers which send funds to this contract or 0
176 |     function transferFrom(
177 |         address spender,
178 |         address recipient,
179 |         uint256 amount
180 |     ) public virtual override returns (bool) {
181 |         // Load balance and allowance
182 |         uint256 balance = balanceOf[spender];
183 |         require(balance >= amount, "ERC20: insufficient-balance");
184 |         // We potentially have to change allowances
185 |         if (spender != msg.sender) {
186 |             // Loading the allowance in the if block prevents vanilla transfers
187 |             // from paying for the sload.
188 |             uint256 allowed = allowance[spender][msg.sender];
189 |             // If the allowance is max we do not reduce it
190 |             // Note - This means that max allowances will be more gas efficient
191 |             // by not requiring a sstore on 'transferFrom'
192 |             if (allowed != type(uint256).max) {
193 |                 require(allowed >= amount, "ERC20: insufficient-allowance");
194 |                 allowance[spender][msg.sender] = allowed - amount;
195 |             }
196 |         }
197 |         // Update the balances
198 |         balanceOf[spender] = balance - amount;
199 |         // Note - In the constructor we initialize the 'balanceOf' of address 0 and
200 |         //        the token address to uint256.max and so in 8.0 transfers to those
201 |         //        addresses revert on this step.
202 |         balanceOf[recipient] = balanceOf[recipient] + amount;
203 |         // Emit the needed event
204 |         emit Transfer(spender, recipient, amount);
205 |         // Return that this call succeeded
206 |         return true;
207 |     }
208 | 
209 |     /// @notice This internal minting function allows inheriting contracts
210 |     ///         to mint tokens in the way they wish.
211 |     /// @param account the address which will receive the token.
212 |     /// @param amount the amount of token which they will receive
213 |     /// @dev This function is virtual so that it can be overridden, if you
214 |     ///      are reviewing this contract for security you should ensure to
215 |     ///      check for overrides
216 |     function _mint(address account, uint256 amount) internal virtual {
217 |         // Add tokens to the account
218 |         balanceOf[account] = balanceOf[account] + amount;
219 |         // Emit an event to track the minting
220 |         emit Transfer(address(0), account, amount);
221 |     }
222 | 
223 |     /// @notice This internal burning function allows inheriting contracts to
224 |     ///         burn tokens in the way they see fit.
225 |     /// @param account the account to remove tokens from
226 |     /// @param amount  the amount of tokens to remove
227 |     /// @dev This function is virtual so that it can be overridden, if you
228 |     ///      are reviewing this contract for security you should ensure to
229 |     ///      check for overrides
230 |     function _burn(address account, uint256 amount) internal virtual {
231 |         // Reduce the balance of the account
232 |         balanceOf[account] = balanceOf[account] - amount;
233 |         // Emit an event tracking transfers
234 |         emit Transfer(account, address(0), amount);
235 |     }
236 | 
237 |     /// @notice This function allows a user to approve an account which can transfer
238 |     ///         tokens on their behalf.
239 |     /// @param account The account which will be approve to transfer tokens
240 |     /// @param amount The approval amount, if set to uint256.max the allowance does not go down on transfers.
241 |     /// @return returns true for compatibility with the ERC20 standard
242 |     function approve(address account, uint256 amount)
243 |         public
244 |         virtual
245 |         override
246 |         returns (bool)
247 |     {
248 |         // Set the senders allowance for account to amount
249 |         allowance[msg.sender][account] = amount;
250 |         // Emit an event to track approvals
251 |         emit Approval(msg.sender, account, amount);
252 |         return true;
253 |     }
254 | 
255 |     /// @notice This function allows a caller who is not the owner of an account to execute the functionality of 'approve' with the owners signature.
256 |     /// @param owner the owner of the account which is having the new approval set
257 |     /// @param spender the address which will be allowed to spend owner's tokens
258 |     /// @param value the new allowance value
259 |     /// @param deadline the timestamp which the signature must be submitted by to be valid
260 |     /// @param v Extra ECDSA data which allows public key recovery from signature assumed to be 27 or 28
261 |     /// @param r The r component of the ECDSA signature
262 |     /// @param s The s component of the ECDSA signature
263 |     /// @dev The signature for this function follows EIP 712 standard and should be generated with the
264 |     ///      eth_signTypedData JSON RPC call instead of the eth_sign JSON RPC call. If using out of date
265 |     ///      parity signing libraries the v component may need to be adjusted. Also it is very rare but possible
266 |     ///      for v to be other values, those values are not supported.
267 |     function permit(
268 |         address owner,
269 |         address spender,
270 |         uint256 value,
271 |         uint256 deadline,
272 |         uint8 v,
273 |         bytes32 r,
274 |         bytes32 s
275 |     ) external override {
276 |         // The EIP 712 digest for this function
277 |         bytes32 digest = keccak256(
278 |             abi.encodePacked(
279 |                 "\x19\x01",
280 |                 DOMAIN_SEPARATOR,
281 |                 keccak256(
282 |                     abi.encode(
283 |                         PERMIT_TYPEHASH,
284 |                         owner,
285 |                         spender,
286 |                         value,
287 |                         nonces[owner],
288 |                         deadline
289 |                     )
290 |                 )
291 |             )
292 |         );
293 |         // Require that the owner is not zero
294 |         require(owner != address(0), "ERC20: invalid-address-0");
295 |         // Require that we have a valid signature from the owner
296 |         require(owner == ecrecover(digest, v, r, s), "ERC20: invalid-permit");
297 |         // Require that the signature is not expired
298 |         require(
299 |             deadline == 0 || block.timestamp <= deadline,
300 |             "ERC20: permit-expired"
301 |         );
302 |         // Increment the signature nonce to prevent replay
303 |         nonces[owner]++;
304 |         // Set the allowance to the new value
305 |         allowance[owner][spender] = value;
306 |         // Emit an approval event to be able to track this happening
307 |         emit Approval(owner, spender, value);
308 |     }
309 | 
310 |     /// @notice Internal function which allows inheriting contract to set custom decimals
311 |     /// @param decimals_ the new decimal value
312 |     function _setupDecimals(uint8 decimals_) internal {
313 |         // Set the decimals
314 |         decimals = decimals_;
315 |     }
316 | }
317 | contract Authorizable {
318 |     // This contract allows a flexible authorization scheme
319 | 
320 |     // The owner who can change authorization status
321 |     address public owner;
322 |     // A mapping from an address to its authorization status
323 |     mapping(address => bool) public authorized;
324 | 
325 |     /// @dev We set the deployer to the owner
326 |     constructor() {
327 |         owner = msg.sender;
328 |     }
329 | 
330 |     /// @dev This modifier checks if the msg.sender is the owner
331 |     modifier onlyOwner() {
332 |         require(msg.sender == owner, "Sender not owner");
333 |         _;
334 |     }
335 | 
336 |     /// @dev This modifier checks if an address is authorized
337 |     modifier onlyAuthorized() {
338 |         require(isAuthorized(msg.sender), "Sender not Authorized");
339 |         _;
340 |     }
341 | 
342 |     /// @dev Returns true if an address is authorized
343 |     /// @param who the address to check
344 |     /// @return true if authorized false if not
345 |     function isAuthorized(address who) public view returns (bool) {
346 |         return authorized[who];
347 |     }
348 | 
349 |     /// @dev Privileged function authorize an address
350 |     /// @param who the address to authorize
351 |     function authorize(address who) external onlyOwner() {
352 |         _authorize(who);
353 |     }
354 | 
355 |     /// @dev Privileged function to de authorize an address
356 |     /// @param who The address to remove authorization from
357 |     function deauthorize(address who) external onlyOwner() {
358 |         authorized[who] = false;
359 |     }
360 | 
361 |     /// @dev Function to change owner
362 |     /// @param who The new owner address
363 |     function setOwner(address who) public onlyOwner() {
364 |         owner = who;
365 |     }
366 | 
367 |     /// @dev Inheritable function which authorizes someone
368 |     /// @param who the address to authorize
369 |     function _authorize(address who) internal {
370 |         authorized[who] = true;
371 |     }
372 | }
373 | 
374 | contract PEPE is ERC20Permit, Authorizable {
375 |      constructor()
376 |         Authorizable()
377 |         ERC20Permit("PEPE Coin", "PEPE")
378 |     {
379 |         _setupDecimals(18);
380 |     }
381 |     function mint(address _account, uint256 _amount) external onlyAuthorized() {
382 |         _mint(_account, _amount);
383 |     }
384 |     function burn(address _account, uint256 _amount) external onlyAuthorized() {
385 |         _burn(_account, _amount);
386 |     }
387 | }


--------------------------------------------------------------------------------
/contracts/LADYS.sol:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *Submitted for verification at Etherscan.io on 2021-05-08
  3 | */
  4 | 
  5 | pragma solidity ^0.8.0;
  6 | 
  7 | interface IERC20 {
  8 |     function symbol() external view returns (string memory);
  9 | 
 10 |     function balanceOf(address account) external view returns (uint256);
 11 | 
 12 |     // Note this is non standard but nearly all ERC20 have exposed decimal functions
 13 |     function decimals() external view returns (uint8);
 14 | 
 15 |     function transfer(address recipient, uint256 amount)
 16 |         external
 17 |         returns (bool);
 18 | 
 19 |     function allowance(address owner, address spender)
 20 |         external
 21 |         view
 22 |         returns (uint256);
 23 | 
 24 |     function approve(address spender, uint256 amount) external returns (bool);
 25 | 
 26 |     function transferFrom(
 27 |         address sender,
 28 |         address recipient,
 29 |         uint256 amount
 30 |     ) external returns (bool);
 31 | 
 32 |     event Transfer(address indexed from, address indexed to, uint256 value);
 33 |     event Approval(
 34 |         address indexed owner,
 35 |         address indexed spender,
 36 |         uint256 value
 37 |     );
 38 | }
 39 | 
 40 | /**
 41 |  * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 42 |  * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 43 |  *
 44 |  * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 45 |  * presenting a message signaed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 46 |  * need to send a transaction, and thus is not required to hold Ether at all.
 47 |  */
 48 | interface IERC20Permit is IERC20 {
 49 |     /**
 50 |      * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
 51 |      * given `owner`'s signed approval.
 52 |      *
 53 |      * IMPORTANT: The same issues {IERC20-approve} has related to transaction
 54 |      * ordering also apply here.
 55 |      *
 56 |      * Emits an {Approval} event.
 57 |      *
 58 |      * Requirements:
 59 |      *
 60 |      * - `spender` cannot be the zero address.
 61 |      * - `deadline` must be a timestamp in the future.
 62 |      * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
 63 |      * over the EIP712-formatted function arguments.
 64 |      * - the signature must use ``owner``'s current nonce (see {nonces}).
 65 |      *
 66 |      * For more information on the signature format, see the
 67 |      * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
 68 |      * section].
 69 |      */
 70 |     function permit(
 71 |         address owner,
 72 |         address spender,
 73 |         uint256 value,
 74 |         uint256 deadline,
 75 |         uint8 v,
 76 |         bytes32 r,
 77 |         bytes32 s
 78 |     ) external;
 79 | 
 80 |     /**
 81 |      * @dev Returns the current nonce for `owner`. This value must be
 82 |      * included whenever a signature is generated for {permit}.
 83 |      *
 84 |      * Every successful call to {permit} increases ``owner``'s nonce by one. This
 85 |      * prevents a signature from being used multiple times.
 86 |      */
 87 |     function nonces(address owner) external view returns (uint256);
 88 | 
 89 |     /**
 90 |      * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
 91 |      */
 92 |     // solhint-disable-next-line func-name-mixedcase
 93 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 94 | }
 95 | 
 96 | abstract contract ERC20Permit is IERC20Permit {
 97 |     // --- ERC20 Data ---
 98 |     // The name of the erc20 token
 99 |     string public name;
100 |     // The symbol of the erc20 token
101 |     string public override symbol;
102 |     // The decimals of the erc20 token, should default to 18 for new tokens
103 |     uint8 public override decimals;
104 | 
105 |     // A mapping which tracks user token balances
106 |     mapping(address => uint256) public override balanceOf;
107 |     // A mapping which tracks which addresses a user allows to move their tokens
108 |     mapping(address => mapping(address => uint256)) public override allowance;
109 |     // A mapping which tracks the permit signature nonces for users
110 |     mapping(address => uint256) public override nonces;
111 | 
112 |     // --- EIP712 niceties ---
113 |     // solhint-disable-next-line var-name-mixedcase
114 |     bytes32 public override DOMAIN_SEPARATOR;
115 |     // bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
116 |     bytes32
117 |         public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
118 | 
119 |     /// @notice Initializes the erc20 contract
120 |     /// @param name_ the value 'name' will be set to
121 |     /// @param symbol_ the value 'symbol' will be set to
122 |     /// @dev decimals default to 18 and must be reset by an inheriting contract for
123 |     ///      non standard decimal values
124 |     constructor(string memory name_, string memory symbol_) {
125 |         // Set the state variables
126 |         name = name_;
127 |         symbol = symbol_;
128 |         decimals = 18;
129 | 
130 |         // By setting these addresses to 0 attempting to execute a transfer to
131 |         // either of them will revert. This is a gas efficient way to prevent
132 |         // a common user mistake where they transfer to the token address.
133 |         // These values are not considered 'real' tokens and so are not included
134 |         // in 'total supply' which only contains minted tokens.
135 |         balanceOf[address(0)] = type(uint256).max;
136 |         balanceOf[address(this)] = type(uint256).max;
137 | 
138 |         // Computes the EIP 712 domain separator which prevents user signed messages for
139 |         // this contract to be replayed in other contracts.
140 |         // https://eips.ethereum.org/EIPS/eip-712
141 |         DOMAIN_SEPARATOR = keccak256(
142 |             abi.encode(
143 |                 keccak256(
144 |                     "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
145 |                 ),
146 |                 keccak256(bytes(name)),
147 |                 keccak256(bytes("1")),
148 |                 block.chainid,
149 |                 address(this)
150 |             )
151 |         );
152 |     }
153 | 
154 |     // --- Token ---
155 |     /// @notice Allows a token owner to send tokens to another address
156 |     /// @param recipient The address which will be credited with the tokens
157 |     /// @param amount The amount user token to send
158 |     /// @return returns true on success, reverts on failure so cannot return false.
159 |     /// @dev transfers to this contract address or 0 will fail
160 |     function transfer(address recipient, uint256 amount)
161 |         public
162 |         virtual
163 |         override
164 |         returns (bool)
165 |     {
166 |         // We forward this call to 'transferFrom'
167 |         return transferFrom(msg.sender, recipient, amount);
168 |     }
169 | 
170 |     /// @notice Transfers an amount of erc20 from a spender to a receipt
171 |     /// @param spender The source of the ERC20 tokens
172 |     /// @param recipient The destination of the ERC20 tokens
173 |     /// @param amount the number of tokens to send
174 |     /// @return returns true on success and reverts on failure
175 |     /// @dev will fail transfers which send funds to this contract or 0
176 |     function transferFrom(
177 |         address spender,
178 |         address recipient,
179 |         uint256 amount
180 |     ) public virtual override returns (bool) {
181 |         // Load balance and allowance
182 |         uint256 balance = balanceOf[spender];
183 |         require(balance >= amount, "ERC20: insufficient-balance");
184 |         // We potentially have to change allowances
185 |         if (spender != msg.sender) {
186 |             // Loading the allowance in the if block prevents vanilla transfers
187 |             // from paying for the sload.
188 |             uint256 allowed = allowance[spender][msg.sender];
189 |             // If the allowance is max we do not reduce it
190 |             // Note - This means that max allowances will be more gas efficient
191 |             // by not requiring a sstore on 'transferFrom'
192 |             if (allowed != type(uint256).max) {
193 |                 require(allowed >= amount, "ERC20: insufficient-allowance");
194 |                 allowance[spender][msg.sender] = allowed - amount;
195 |             }
196 |         }
197 |         // Update the balances
198 |         balanceOf[spender] = balance - amount;
199 |         // Note - In the constructor we initialize the 'balanceOf' of address 0 and
200 |         //        the token address to uint256.max and so in 8.0 transfers to those
201 |         //        addresses revert on this step.
202 |         balanceOf[recipient] = balanceOf[recipient] + amount;
203 |         // Emit the needed event
204 |         emit Transfer(spender, recipient, amount);
205 |         // Return that this call succeeded
206 |         return true;
207 |     }
208 | 
209 |     /// @notice This internal minting function allows inheriting contracts
210 |     ///         to mint tokens in the way they wish.
211 |     /// @param account the address which will receive the token.
212 |     /// @param amount the amount of token which they will receive
213 |     /// @dev This function is virtual so that it can be overridden, if you
214 |     ///      are reviewing this contract for security you should ensure to
215 |     ///      check for overrides
216 |     function _mint(address account, uint256 amount) internal virtual {
217 |         // Add tokens to the account
218 |         balanceOf[account] = balanceOf[account] + amount;
219 |         // Emit an event to track the minting
220 |         emit Transfer(address(0), account, amount);
221 |     }
222 | 
223 |     /// @notice This internal burning function allows inheriting contracts to
224 |     ///         burn tokens in the way they see fit.
225 |     /// @param account the account to remove tokens from
226 |     /// @param amount  the amount of tokens to remove
227 |     /// @dev This function is virtual so that it can be overridden, if you
228 |     ///      are reviewing this contract for security you should ensure to
229 |     ///      check for overrides
230 |     function _burn(address account, uint256 amount) internal virtual {
231 |         // Reduce the balance of the account
232 |         balanceOf[account] = balanceOf[account] - amount;
233 |         // Emit an event tracking transfers
234 |         emit Transfer(account, address(0), amount);
235 |     }
236 | 
237 |     /// @notice This function allows a user to approve an account which can transfer
238 |     ///         tokens on their behalf.
239 |     /// @param account The account which will be approve to transfer tokens
240 |     /// @param amount The approval amount, if set to uint256.max the allowance does not go down on transfers.
241 |     /// @return returns true for compatibility with the ERC20 standard
242 |     function approve(address account, uint256 amount)
243 |         public
244 |         virtual
245 |         override
246 |         returns (bool)
247 |     {
248 |         // Set the senders allowance for account to amount
249 |         allowance[msg.sender][account] = amount;
250 |         // Emit an event to track approvals
251 |         emit Approval(msg.sender, account, amount);
252 |         return true;
253 |     }
254 | 
255 |     /// @notice This function allows a caller who is not the owner of an account to execute the functionality of 'approve' with the owners signature.
256 |     /// @param owner the owner of the account which is having the new approval set
257 |     /// @param spender the address which will be allowed to spend owner's tokens
258 |     /// @param value the new allowance value
259 |     /// @param deadline the timestamp which the signature must be submitted by to be valid
260 |     /// @param v Extra ECDSA data which allows public key recovery from signature assumed to be 27 or 28
261 |     /// @param r The r component of the ECDSA signature
262 |     /// @param s The s component of the ECDSA signature
263 |     /// @dev The signature for this function follows EIP 712 standard and should be generated with the
264 |     ///      eth_signTypedData JSON RPC call instead of the eth_sign JSON RPC call. If using out of date
265 |     ///      parity signing libraries the v component may need to be adjusted. Also it is very rare but possible
266 |     ///      for v to be other values, those values are not supported.
267 |     function permit(
268 |         address owner,
269 |         address spender,
270 |         uint256 value,
271 |         uint256 deadline,
272 |         uint8 v,
273 |         bytes32 r,
274 |         bytes32 s
275 |     ) external override {
276 |         // The EIP 712 digest for this function
277 |         bytes32 digest = keccak256(
278 |             abi.encodePacked(
279 |                 "\x19\x01",
280 |                 DOMAIN_SEPARATOR,
281 |                 keccak256(
282 |                     abi.encode(
283 |                         PERMIT_TYPEHASH,
284 |                         owner,
285 |                         spender,
286 |                         value,
287 |                         nonces[owner],
288 |                         deadline
289 |                     )
290 |                 )
291 |             )
292 |         );
293 |         // Require that the owner is not zero
294 |         require(owner != address(0), "ERC20: invalid-address-0");
295 |         // Require that we have a valid signature from the owner
296 |         require(owner == ecrecover(digest, v, r, s), "ERC20: invalid-permit");
297 |         // Require that the signature is not expired
298 |         require(
299 |             deadline == 0 || block.timestamp <= deadline,
300 |             "ERC20: permit-expired"
301 |         );
302 |         // Increment the signature nonce to prevent replay
303 |         nonces[owner]++;
304 |         // Set the allowance to the new value
305 |         allowance[owner][spender] = value;
306 |         // Emit an approval event to be able to track this happening
307 |         emit Approval(owner, spender, value);
308 |     }
309 | 
310 |     /// @notice Internal function which allows inheriting contract to set custom decimals
311 |     /// @param decimals_ the new decimal value
312 |     function _setupDecimals(uint8 decimals_) internal {
313 |         // Set the decimals
314 |         decimals = decimals_;
315 |     }
316 | }
317 | contract Authorizable {
318 |     // This contract allows a flexible authorization scheme
319 | 
320 |     // The owner who can change authorization status
321 |     address public owner;
322 |     // A mapping from an address to its authorization status
323 |     mapping(address => bool) public authorized;
324 | 
325 |     /// @dev We set the deployer to the owner
326 |     constructor() {
327 |         owner = msg.sender;
328 |     }
329 | 
330 |     /// @dev This modifier checks if the msg.sender is the owner
331 |     modifier onlyOwner() {
332 |         require(msg.sender == owner, "Sender not owner");
333 |         _;
334 |     }
335 | 
336 |     /// @dev This modifier checks if an address is authorized
337 |     modifier onlyAuthorized() {
338 |         require(isAuthorized(msg.sender), "Sender not Authorized");
339 |         _;
340 |     }
341 | 
342 |     /// @dev Returns true if an address is authorized
343 |     /// @param who the address to check
344 |     /// @return true if authorized false if not
345 |     function isAuthorized(address who) public view returns (bool) {
346 |         return authorized[who];
347 |     }
348 | 
349 |     /// @dev Privileged function authorize an address
350 |     /// @param who the address to authorize
351 |     function authorize(address who) external onlyOwner() {
352 |         _authorize(who);
353 |     }
354 | 
355 |     /// @dev Privileged function to de authorize an address
356 |     /// @param who The address to remove authorization from
357 |     function deauthorize(address who) external onlyOwner() {
358 |         authorized[who] = false;
359 |     }
360 | 
361 |     /// @dev Function to change owner
362 |     /// @param who The new owner address
363 |     function setOwner(address who) public onlyOwner() {
364 |         owner = who;
365 |     }
366 | 
367 |     /// @dev Inheritable function which authorizes someone
368 |     /// @param who the address to authorize
369 |     function _authorize(address who) internal {
370 |         authorized[who] = true;
371 |     }
372 | }
373 | 
374 | contract LADYS is ERC20Permit, Authorizable {
375 |      constructor()
376 |         Authorizable()
377 |         ERC20Permit("LADYS Coin", "LADYS")
378 |     {
379 |         _setupDecimals(18);
380 |     }
381 |     function mint(address _account, uint256 _amount) external onlyAuthorized() {
382 |         _mint(_account, _amount);
383 |     }
384 |     function burn(address _account, uint256 _amount) external onlyAuthorized() {
385 |         _burn(_account, _amount);
386 |     }
387 | }


--------------------------------------------------------------------------------
/contracts/WOJAK.sol:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *Submitted for verification at Etherscan.io on 2021-05-08
  3 | */
  4 | 
  5 | pragma solidity ^0.8.0;
  6 | 
  7 | interface IERC20 {
  8 |     function symbol() external view returns (string memory);
  9 | 
 10 |     function balanceOf(address account) external view returns (uint256);
 11 | 
 12 |     // Note this is non standard but nearly all ERC20 have exposed decimal functions
 13 |     function decimals() external view returns (uint8);
 14 | 
 15 |     function transfer(address recipient, uint256 amount)
 16 |         external
 17 |         returns (bool);
 18 | 
 19 |     function allowance(address owner, address spender)
 20 |         external
 21 |         view
 22 |         returns (uint256);
 23 | 
 24 |     function approve(address spender, uint256 amount) external returns (bool);
 25 | 
 26 |     function transferFrom(
 27 |         address sender,
 28 |         address recipient,
 29 |         uint256 amount
 30 |     ) external returns (bool);
 31 | 
 32 |     event Transfer(address indexed from, address indexed to, uint256 value);
 33 |     event Approval(
 34 |         address indexed owner,
 35 |         address indexed spender,
 36 |         uint256 value
 37 |     );
 38 | }
 39 | 
 40 | /**
 41 |  * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 42 |  * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 43 |  *
 44 |  * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 45 |  * presenting a message signaed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 46 |  * need to send a transaction, and thus is not required to hold Ether at all.
 47 |  */
 48 | interface IERC20Permit is IERC20 {
 49 |     /**
 50 |      * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
 51 |      * given `owner`'s signed approval.
 52 |      *
 53 |      * IMPORTANT: The same issues {IERC20-approve} has related to transaction
 54 |      * ordering also apply here.
 55 |      *
 56 |      * Emits an {Approval} event.
 57 |      *
 58 |      * Requirements:
 59 |      *
 60 |      * - `spender` cannot be the zero address.
 61 |      * - `deadline` must be a timestamp in the future.
 62 |      * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
 63 |      * over the EIP712-formatted function arguments.
 64 |      * - the signature must use ``owner``'s current nonce (see {nonces}).
 65 |      *
 66 |      * For more information on the signature format, see the
 67 |      * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
 68 |      * section].
 69 |      */
 70 |     function permit(
 71 |         address owner,
 72 |         address spender,
 73 |         uint256 value,
 74 |         uint256 deadline,
 75 |         uint8 v,
 76 |         bytes32 r,
 77 |         bytes32 s
 78 |     ) external;
 79 | 
 80 |     /**
 81 |      * @dev Returns the current nonce for `owner`. This value must be
 82 |      * included whenever a signature is generated for {permit}.
 83 |      *
 84 |      * Every successful call to {permit} increases ``owner``'s nonce by one. This
 85 |      * prevents a signature from being used multiple times.
 86 |      */
 87 |     function nonces(address owner) external view returns (uint256);
 88 | 
 89 |     /**
 90 |      * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
 91 |      */
 92 |     // solhint-disable-next-line func-name-mixedcase
 93 |     function DOMAIN_SEPARATOR() external view returns (bytes32);
 94 | }
 95 | 
 96 | abstract contract ERC20Permit is IERC20Permit {
 97 |     // --- ERC20 Data ---
 98 |     // The name of the erc20 token
 99 |     string public name;
100 |     // The symbol of the erc20 token
101 |     string public override symbol;
102 |     // The decimals of the erc20 token, should default to 18 for new tokens
103 |     uint8 public override decimals;
104 | 
105 |     // A mapping which tracks user token balances
106 |     mapping(address => uint256) public override balanceOf;
107 |     // A mapping which tracks which addresses a user allows to move their tokens
108 |     mapping(address => mapping(address => uint256)) public override allowance;
109 |     // A mapping which tracks the permit signature nonces for users
110 |     mapping(address => uint256) public override nonces;
111 | 
112 |     // --- EIP712 niceties ---
113 |     // solhint-disable-next-line var-name-mixedcase
114 |     bytes32 public override DOMAIN_SEPARATOR;
115 |     // bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
116 |     bytes32
117 |         public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
118 | 
119 |     /// @notice Initializes the erc20 contract
120 |     /// @param name_ the value 'name' will be set to
121 |     /// @param symbol_ the value 'symbol' will be set to
122 |     /// @dev decimals default to 18 and must be reset by an inheriting contract for
123 |     ///      non standard decimal values
124 |     constructor(string memory name_, string memory symbol_) {
125 |         // Set the state variables
126 |         name = name_;
127 |         symbol = symbol_;
128 |         decimals = 18;
129 | 
130 |         // By setting these addresses to 0 attempting to execute a transfer to
131 |         // either of them will revert. This is a gas efficient way to prevent
132 |         // a common user mistake where they transfer to the token address.
133 |         // These values are not considered 'real' tokens and so are not included
134 |         // in 'total supply' which only contains minted tokens.
135 |         balanceOf[address(0)] = type(uint256).max;
136 |         balanceOf[address(this)] = type(uint256).max;
137 | 
138 |         // Computes the EIP 712 domain separator which prevents user signed messages for
139 |         // this contract to be replayed in other contracts.
140 |         // https://eips.ethereum.org/EIPS/eip-712
141 |         DOMAIN_SEPARATOR = keccak256(
142 |             abi.encode(
143 |                 keccak256(
144 |                     "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
145 |                 ),
146 |                 keccak256(bytes(name)),
147 |                 keccak256(bytes("1")),
148 |                 block.chainid,
149 |                 address(this)
150 |             )
151 |         );
152 |     }
153 | 
154 |     // --- Token ---
155 |     /// @notice Allows a token owner to send tokens to another address
156 |     /// @param recipient The address which will be credited with the tokens
157 |     /// @param amount The amount user token to send
158 |     /// @return returns true on success, reverts on failure so cannot return false.
159 |     /// @dev transfers to this contract address or 0 will fail
160 |     function transfer(address recipient, uint256 amount)
161 |         public
162 |         virtual
163 |         override
164 |         returns (bool)
165 |     {
166 |         // We forward this call to 'transferFrom'
167 |         return transferFrom(msg.sender, recipient, amount);
168 |     }
169 | 
170 |     /// @notice Transfers an amount of erc20 from a spender to a receipt
171 |     /// @param spender The source of the ERC20 tokens
172 |     /// @param recipient The destination of the ERC20 tokens
173 |     /// @param amount the number of tokens to send
174 |     /// @return returns true on success and reverts on failure
175 |     /// @dev will fail transfers which send funds to this contract or 0
176 |     function transferFrom(
177 |         address spender,
178 |         address recipient,
179 |         uint256 amount
180 |     ) public virtual override returns (bool) {
181 |         // Load balance and allowance
182 |         uint256 balance = balanceOf[spender];
183 |         require(balance >= amount, "ERC20: insufficient-balance");
184 |         // We potentially have to change allowances
185 |         if (spender != msg.sender) {
186 |             // Loading the allowance in the if block prevents vanilla transfers
187 |             // from paying for the sload.
188 |             uint256 allowed = allowance[spender][msg.sender];
189 |             // If the allowance is max we do not reduce it
190 |             // Note - This means that max allowances will be more gas efficient
191 |             // by not requiring a sstore on 'transferFrom'
192 |             if (allowed != type(uint256).max) {
193 |                 require(allowed >= amount, "ERC20: insufficient-allowance");
194 |                 allowance[spender][msg.sender] = allowed - amount;
195 |             }
196 |         }
197 |         // Update the balances
198 |         balanceOf[spender] = balance - amount;
199 |         // Note - In the constructor we initialize the 'balanceOf' of address 0 and
200 |         //        the token address to uint256.max and so in 8.0 transfers to those
201 |         //        addresses revert on this step.
202 |         balanceOf[recipient] = balanceOf[recipient] + amount;
203 |         // Emit the needed event
204 |         emit Transfer(spender, recipient, amount);
205 |         // Return that this call succeeded
206 |         return true;
207 |     }
208 | 
209 |     /// @notice This internal minting function allows inheriting contracts
210 |     ///         to mint tokens in the way they wish.
211 |     /// @param account the address which will receive the token.
212 |     /// @param amount the amount of token which they will receive
213 |     /// @dev This function is virtual so that it can be overridden, if you
214 |     ///      are reviewing this contract for security you should ensure to
215 |     ///      check for overrides
216 |     function _mint(address account, uint256 amount) internal virtual {
217 |         // Add tokens to the account
218 |         balanceOf[account] = balanceOf[account] + amount;
219 |         // Emit an event to track the minting
220 |         emit Transfer(address(0), account, amount);
221 |     }
222 | 
223 |     /// @notice This internal burning function allows inheriting contracts to
224 |     ///         burn tokens in the way they see fit.
225 |     /// @param account the account to remove tokens from
226 |     /// @param amount  the amount of tokens to remove
227 |     /// @dev This function is virtual so that it can be overridden, if you
228 |     ///      are reviewing this contract for security you should ensure to
229 |     ///      check for overrides
230 |     function _burn(address account, uint256 amount) internal virtual {
231 |         // Reduce the balance of the account
232 |         balanceOf[account] = balanceOf[account] - amount;
233 |         // Emit an event tracking transfers
234 |         emit Transfer(account, address(0), amount);
235 |     }
236 | 
237 |     /// @notice This function allows a user to approve an account which can transfer
238 |     ///         tokens on their behalf.
239 |     /// @param account The account which will be approve to transfer tokens
240 |     /// @param amount The approval amount, if set to uint256.max the allowance does not go down on transfers.
241 |     /// @return returns true for compatibility with the ERC20 standard
242 |     function approve(address account, uint256 amount)
243 |         public
244 |         virtual
245 |         override
246 |         returns (bool)
247 |     {
248 |         // Set the senders allowance for account to amount
249 |         allowance[msg.sender][account] = amount;
250 |         // Emit an event to track approvals
251 |         emit Approval(msg.sender, account, amount);
252 |         return true;
253 |     }
254 | 
255 |     /// @notice This function allows a caller who is not the owner of an account to execute the functionality of 'approve' with the owners signature.
256 |     /// @param owner the owner of the account which is having the new approval set
257 |     /// @param spender the address which will be allowed to spend owner's tokens
258 |     /// @param value the new allowance value
259 |     /// @param deadline the timestamp which the signature must be submitted by to be valid
260 |     /// @param v Extra ECDSA data which allows public key recovery from signature assumed to be 27 or 28
261 |     /// @param r The r component of the ECDSA signature
262 |     /// @param s The s component of the ECDSA signature
263 |     /// @dev The signature for this function follows EIP 712 standard and should be generated with the
264 |     ///      eth_signTypedData JSON RPC call instead of the eth_sign JSON RPC call. If using out of date
265 |     ///      parity signing libraries the v component may need to be adjusted. Also it is very rare but possible
266 |     ///      for v to be other values, those values are not supported.
267 |     function permit(
268 |         address owner,
269 |         address spender,
270 |         uint256 value,
271 |         uint256 deadline,
272 |         uint8 v,
273 |         bytes32 r,
274 |         bytes32 s
275 |     ) external override {
276 |         // The EIP 712 digest for this function
277 |         bytes32 digest = keccak256(
278 |             abi.encodePacked(
279 |                 "\x19\x01",
280 |                 DOMAIN_SEPARATOR,
281 |                 keccak256(
282 |                     abi.encode(
283 |                         PERMIT_TYPEHASH,
284 |                         owner,
285 |                         spender,
286 |                         value,
287 |                         nonces[owner],
288 |                         deadline
289 |                     )
290 |                 )
291 |             )
292 |         );
293 |         // Require that the owner is not zero
294 |         require(owner != address(0), "ERC20: invalid-address-0");
295 |         // Require that we have a valid signature from the owner
296 |         require(owner == ecrecover(digest, v, r, s), "ERC20: invalid-permit");
297 |         // Require that the signature is not expired
298 |         require(
299 |             deadline == 0 || block.timestamp <= deadline,
300 |             "ERC20: permit-expired"
301 |         );
302 |         // Increment the signature nonce to prevent replay
303 |         nonces[owner]++;
304 |         // Set the allowance to the new value
305 |         allowance[owner][spender] = value;
306 |         // Emit an approval event to be able to track this happening
307 |         emit Approval(owner, spender, value);
308 |     }
309 | 
310 |     /// @notice Internal function which allows inheriting contract to set custom decimals
311 |     /// @param decimals_ the new decimal value
312 |     function _setupDecimals(uint8 decimals_) internal {
313 |         // Set the decimals
314 |         decimals = decimals_;
315 |     }
316 | }
317 | contract Authorizable {
318 |     // This contract allows a flexible authorization scheme
319 | 
320 |     // The owner who can change authorization status
321 |     address public owner;
322 |     // A mapping from an address to its authorization status
323 |     mapping(address => bool) public authorized;
324 | 
325 |     /// @dev We set the deployer to the owner
326 |     constructor() {
327 |         owner = msg.sender;
328 |     }
329 | 
330 |     /// @dev This modifier checks if the msg.sender is the owner
331 |     modifier onlyOwner() {
332 |         require(msg.sender == owner, "Sender not owner");
333 |         _;
334 |     }
335 | 
336 |     /// @dev This modifier checks if an address is authorized
337 |     modifier onlyAuthorized() {
338 |         require(isAuthorized(msg.sender), "Sender not Authorized");
339 |         _;
340 |     }
341 | 
342 |     /// @dev Returns true if an address is authorized
343 |     /// @param who the address to check
344 |     /// @return true if authorized false if not
345 |     function isAuthorized(address who) public view returns (bool) {
346 |         return authorized[who];
347 |     }
348 | 
349 |     /// @dev Privileged function authorize an address
350 |     /// @param who the address to authorize
351 |     function authorize(address who) external onlyOwner() {
352 |         _authorize(who);
353 |     }
354 | 
355 |     /// @dev Privileged function to de authorize an address
356 |     /// @param who The address to remove authorization from
357 |     function deauthorize(address who) external onlyOwner() {
358 |         authorized[who] = false;
359 |     }
360 | 
361 |     /// @dev Function to change owner
362 |     /// @param who The new owner address
363 |     function setOwner(address who) public onlyOwner() {
364 |         owner = who;
365 |     }
366 | 
367 |     /// @dev Inheritable function which authorizes someone
368 |     /// @param who the address to authorize
369 |     function _authorize(address who) internal {
370 |         authorized[who] = true;
371 |     }
372 | }
373 | 
374 | contract WOJAK is ERC20Permit, Authorizable {
375 |      constructor()
376 |         Authorizable()
377 |         ERC20Permit("WOJAK Coin", "WOJAK")
378 |     {
379 |         _setupDecimals(18);
380 |     }
381 |     function mint(address _account, uint256 _amount) external onlyAuthorized() {
382 |         _mint(_account, _amount);
383 |     }
384 |     function burn(address _account, uint256 _amount) external onlyAuthorized() {
385 |         _burn(_account, _amount);
386 |     }
387 | }


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