polkamarkets-js 1.0.2 → 3.1.0

package/contracts/PredictionMarketV3Controller.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "./FantasyERC20.sol";
+import "./RealityETH_ERC20_Factory.sol";
+import "./IPredictionMarketV3Factory.sol";
+import "./LandFactory.sol";
+
+// openzeppelin ownable contract import
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+contract PredictionMarketV3Controller is LandFactory {
+  address public immutable PMV3Factory; // PredictionMarketFactory contract
+  mapping(address => LandPermissions) public landPermissions;
+
+  // inherited variables from LandFactory
+  // address public immutable PMV3
+  // IERC20 public immutable token
+  // uint256 public lockAmount
+  // RealityETH_ERC20_Factory public immutable realitioFactory;
+  // mapping(address => Land) public lands;
+  // address[] public landTokens;
+  // uint256 public landTokensLength;
+
+  struct LandPermissions {
+    bool openMarketCreation;
+    bool openAdminManagement;
+  }
+
+  constructor(
+    address _PMV3,
+    address _realitioLibraryAddress,
+    address _PMV3Factory
+  ) {
+    require(_PMV3Factory != address(0), "PMV3Factory address cannot be 0 address");
+
+    PMV3 = _PMV3;
+    realitioFactory = new RealityETH_ERC20_Factory(_realitioLibraryAddress);
+    PMV3Factory = _PMV3Factory;
+  }
+
+  function createLand(
+    string memory name,
+    string memory symbol,
+    uint256 tokenAmountToClaim,
+    IERC20 tokenToAnswer
+  ) external override returns (FantasyERC20) {
+    require(
+      IPredictionMarketV3Factory(PMV3Factory).isPMControllerAdmin(address(this), msg.sender),
+      "Not allowed to create land"
+    );
+
+    // create a new fantasyERC20 token
+    return _createLand(name, symbol, tokenAmountToClaim, tokenToAnswer, PMV3Factory, address(this));
+  }
+
+  function setLandEveryoneCanCreateMarkets(IERC20 landToken, bool canCreate) external {
+    Land storage land = lands[address(landToken)];
+
+    require(land.active, "Land does not exist");
+    require(land.admins[msg.sender], "Not admin of the land");
+
+    landPermissions[address(landToken)].openMarketCreation = canCreate;
+  }
+
+  function isAllowedToCreateMarket(IERC20 marketToken, address user) public view override returns (bool) {
+    return
+      lands[address(marketToken)].active &&
+      (lands[address(marketToken)].admins[user] ||
+        landPermissions[address(lands[address(marketToken)].token)].openMarketCreation ||
+        IPredictionMarketV3Factory(PMV3Factory).isPMControllerAdmin(address(this), user));
+  }
+
+  function isAllowedToResolveMarket(IERC20 marketToken, address user) public view override returns (bool) {
+    return
+      lands[address(marketToken)].active &&
+      (lands[address(marketToken)].admins[user] ||
+        IPredictionMarketV3Factory(PMV3Factory).isPMControllerAdmin(address(this), user));
+  }
+
+  function isLandAdmin(IERC20 landToken, address user) public view override returns (bool) {
+    return
+      lands[address(landToken)].admins[user] ||
+      IPredictionMarketV3Factory(PMV3Factory).isPMControllerAdmin(address(this), user);
+  }
+}

package/contracts/PredictionMarketV3Factory.sol

@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "./PredictionMarketV3Controller.sol";
+
+// openzeppelin ownable contract import
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/proxy/Clones.sol";
+
+contract PredictionMarketV3Factory is Ownable, ReentrancyGuard {
+  IERC20 public immutable token; // Governance IERC20
+  uint256 public lockAmount; // amount necessary to lock to create a land
+  address public PMV3LibraryAddress; // PredictionMarketV3 library address
+  address public realitioLibraryAddress; // PredictionMarketV3 contract
+
+  event ControllerCreated(address indexed user, address indexed controller, uint256 amountLocked);
+
+  event ControllerDisabled(address indexed user, address indexed controller, uint256 amountUnlocked);
+
+  event ControllerEnabled(address indexed user, address indexed controller, uint256 amountUnlocked);
+
+  event ControllerOffsetUnlocked(address indexed user, address indexed controller, uint256 amountUnlocked);
+
+  event ControllerAdminAdded(address indexed user, address indexed controller, address indexed admin);
+
+  event ControllerAdminRemoved(address indexed user, address indexed controller, address indexed admin);
+
+  struct Controller {
+    bool active;
+    mapping(address => bool) admins;
+    uint256 lockAmount;
+    address lockUser;
+  }
+
+  mapping(address => Controller) public controllers;
+  address[] public controllersAddresses;
+  uint256 public controllersLength;
+
+  constructor(
+    IERC20 _token,
+    uint256 _lockAmount,
+    address _PMV3LibraryAddress,
+    address _realitioLibraryAddress
+  ) {
+    token = _token;
+    lockAmount = _lockAmount;
+    PMV3LibraryAddress = _PMV3LibraryAddress;
+    realitioLibraryAddress = _realitioLibraryAddress;
+  }
+
+  function updateLockAmount(uint256 newLockAmount) external onlyOwner {
+    require(newLockAmount != lockAmount, "Lock amount is the same");
+
+    lockAmount = newLockAmount;
+  }
+
+  function updatePMV3LibraryAddress(address _PMV3LibraryAddress) external onlyOwner {
+    require(_PMV3LibraryAddress != address(0), "PMV3LibraryAddress address cannot be 0 address");
+
+    PMV3LibraryAddress = _PMV3LibraryAddress;
+  }
+
+  function updateRealitioLibraryAddress(address _realitioLibraryAddress) external onlyOwner {
+    require(_realitioLibraryAddress != address(0), "RealitioLibraryAddress address cannot be 0 address");
+
+    realitioLibraryAddress = _realitioLibraryAddress;
+  }
+
+  // lockAmount is the amount of tokens that the user needs to lock to create a land
+  // by locking the amount the factory will create a PredictionMarketController contract and store it in the contract
+  // the user will be the admin of the PredictionMarketController contract
+  function createPMController(address _PMV3) external returns (PredictionMarketV3Controller) {
+    require(token.balanceOf(msg.sender) >= lockAmount, "Not enough tokens to lock");
+
+    // a PMV3 address can be provided, if not, the factory will deploy a new one
+    if (_PMV3 == address(0)) {
+      // deploy new PredictionMarketV3 contract
+      _PMV3 = Clones.clone(PMV3LibraryAddress);
+    }
+
+    // deploy prediction market controller contract
+    PredictionMarketV3Controller PMV3Controller = new PredictionMarketV3Controller(
+      _PMV3,
+      realitioLibraryAddress,
+      address(this)
+    );
+
+    // store the new controller in the contract
+    Controller storage controller = controllers[address(PMV3Controller)];
+    controller.active = true;
+    controller.admins[msg.sender] = true;
+    controller.lockAmount = lockAmount;
+    controller.lockUser = msg.sender;
+    controllersAddresses.push(address(PMV3Controller));
+    controllersLength++;
+
+    // transfer the lockAmount to the contract
+    token.transferFrom(msg.sender, address(this), lockAmount);
+
+    // ControllerCreated event
+    emit ControllerCreated(msg.sender, address(PMV3Controller), lockAmount);
+
+    return PMV3Controller;
+  }
+
+  function disablePMController(address controllerAddress) external returns (uint256) {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    require(controller.active, "Controller is not active");
+    require(controller.admins[msg.sender], "Not admin of the controller");
+
+    uint256 amountToUnlock = controller.lockAmount;
+
+    token.transfer(controller.lockUser, amountToUnlock);
+
+    // disable the land
+    controller.active = false;
+    controller.lockAmount = 0;
+    controller.lockUser = address(0);
+
+    // ControllerDisabled event
+    emit ControllerDisabled(msg.sender, address(controllerAddress), amountToUnlock);
+
+    return amountToUnlock;
+  }
+
+  function enablePMController(address controllerAddress) external returns (uint256) {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    require(!controller.active, "Controller is already active");
+    require(controller.admins[msg.sender], "Not admin of the controller");
+
+    uint256 amountToLock = lockAmount > controller.lockAmount ? lockAmount - controller.lockAmount : 0;
+
+    // transfer the lockAmount to the contract
+    token.transferFrom(msg.sender, address(this), amountToLock);
+
+    // enable the land
+    controller.active = true;
+    controller.lockAmount = controller.lockAmount + amountToLock;
+    controller.lockUser = msg.sender;
+
+    // ControllerEnabled event
+    emit ControllerEnabled(msg.sender, address(controllerAddress), amountToLock);
+
+    return amountToLock;
+  }
+
+  function unlockOffsetFromPMController(address controllerAddress) external returns (uint256) {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    require(controller.active, "controller does not exist");
+    require(controller.admins[msg.sender], "Not admin of the controller");
+
+    uint256 amountToUnlock = controller.lockAmount > lockAmount ? controller.lockAmount - lockAmount : 0;
+
+    if (amountToUnlock > 0) {
+      token.transfer(msg.sender, amountToUnlock);
+      controller.lockAmount = controller.lockAmount - amountToUnlock;
+    }
+
+    // ControllerOffsetUnlocked event
+    emit ControllerOffsetUnlocked(msg.sender, address(controllerAddress), amountToUnlock);
+
+    return amountToUnlock;
+  }
+
+  function addAdminToPMController(address controllerAddress, address admin) external {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    require(controller.active, "Controller does not exist");
+    require(controller.admins[msg.sender], "Not admin of the controller");
+
+    controller.admins[admin] = true;
+
+    // ControllerAdminAdded event
+    emit ControllerAdminAdded(msg.sender, address(controllerAddress), admin);
+  }
+
+  function removeAdminFromPMController(address controllerAddress, address admin) external {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    require(controller.active, "Controller does not exist");
+    require(controller.admins[msg.sender], "Not admin of the controller");
+    require(controller.lockUser != admin, "Can not remove from admin the lockUser");
+
+    controller.admins[admin] = false;
+
+    // ControllerAdminRemoved event
+    emit ControllerAdminRemoved(msg.sender, address(controllerAddress), admin);
+  }
+
+  function isPMControllerActive(address controllerAddress) external view returns (bool) {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    return controller.active;
+  }
+
+  function isPMControllerAdmin(address controllerAddress, address user) external view returns (bool) {
+    Controller storage controller = controllers[address(controllerAddress)];
+
+    return controller.admins[user];
+  }
+}

package/contracts/PredictionMarketV3Manager.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "./FantasyERC20.sol";
+import "./RealityETH_ERC20_Factory.sol";
+import "./LandFactory.sol";
+
+// openzeppelin ownable contract import
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+contract PredictionMarketV3Manager is LandFactory {
+  // inherited variables from LandFactory
+  // address public immutable PMV3
+  // IERC20 public immutable token
+  // uint256 public lockAmount
+  // RealityETH_ERC20_Factory public immutable realitioFactory;
+  // mapping(address => Land) public lands;
+  // address[] public landTokens;
+  // uint256 public landTokensLength;
+
+  constructor(
+    address _PMV3,
+    IERC20 _token,
+    uint256 _lockAmount,
+    address _realitioLibraryAddress
+  ) {
+    PMV3 = _PMV3;
+    token = _token;
+    lockAmount = _lockAmount;
+    realitioFactory = new RealityETH_ERC20_Factory(_realitioLibraryAddress);
+  }
+
+  // lockAmount is the amount of tokens that the user needs to lock to create a land
+  // by locking the amount the factory will create a fantasyERC20 token and store it in the contract
+  // the user will be the admin of the land
+  function createLand(
+    string memory name,
+    string memory symbol,
+    uint256 tokenAmountToClaim,
+    IERC20 tokenToAnswer
+  ) external override returns (FantasyERC20) {
+    return _createLand(name, symbol, tokenAmountToClaim, tokenToAnswer, address(0), address(0));
+  }
+}

package/contracts/PredictionMarketV3Querier.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+// local imports
+import "./IPredictionMarketV3.sol";
+
+/// @title Market Contract Factory
+contract PredictionMarketV3Querier {
+  IPredictionMarketV3 public immutable PredictionMarketV3;
+
+  struct UserMarketData {
+    uint256 liquidityShares;
+    uint256[] outcomeShares;
+    bool winningsToClaim;
+    bool winningsClaimed;
+    bool liquidityToClaim;
+    bool liquidityClaimed;
+    bool voidedSharesToClaim;
+  }
+
+  /// @dev protocol is immutable and has no ownership
+  constructor(IPredictionMarketV3 _PredictionMarketV3) {
+    PredictionMarketV3 = _PredictionMarketV3;
+  }
+
+  function getUserMarketData(uint256 marketId, address user) public view returns (UserMarketData memory) {
+    bool isMarketVoided = PredictionMarketV3.isMarketVoided(marketId);
+    bool voidedSharesToClaim = false;
+
+    (uint256 liquidityShares, uint256[] memory outcomeShares) = PredictionMarketV3.getUserMarketShares(marketId, user);
+    (bool winningsToClaim, bool winningsClaimed, bool liquidityToClaim, bool liquidityClaimed, ) = PredictionMarketV3
+      .getUserClaimStatus(marketId, user);
+
+    if (isMarketVoided) {
+      for (uint256 i = 0; i < outcomeShares.length; i++) {
+        if (outcomeShares[i] > 0) {
+          voidedSharesToClaim = true;
+          break;
+        }
+      }
+    }
+
+    return
+      UserMarketData({
+        liquidityShares: liquidityShares,
+        outcomeShares: outcomeShares,
+        winningsToClaim: winningsToClaim,
+        winningsClaimed: winningsClaimed,
+        liquidityToClaim: liquidityToClaim,
+        liquidityClaimed: liquidityClaimed,
+        voidedSharesToClaim: voidedSharesToClaim
+      });
+  }
+
+  function getUserMarketsData(uint256[] calldata marketIds, address user)
+    external
+    view
+    returns (UserMarketData[] memory)
+  {
+    UserMarketData[] memory userMarketsData = new UserMarketData[](marketIds.length);
+
+    for (uint256 i = 0; i < marketIds.length; i++) {
+      userMarketsData[i] = getUserMarketData(marketIds[i], user);
+    }
+
+    return userMarketsData;
+  }
+
+  function getUserAllMarketsData(address user) external view returns (UserMarketData[] memory) {
+    uint256[] memory marketIds = PredictionMarketV3.getMarkets();
+    UserMarketData[] memory userMarketsData = new UserMarketData[](marketIds.length);
+
+    for (uint256 i = 0; i < marketIds.length; i++) {
+      userMarketsData[i] = getUserMarketData(marketIds[i], user);
+    }
+
+    return userMarketsData;
+  }
+}

package/contracts/RealityETH_ERC20_Factory.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Based on https://github.com/RealityETH/reality-eth-monorepo/blob/main/packages/contracts/development/contracts/RealityETH_ERC20_Factory.sol
+
+pragma solidity ^0.8.18;
+
+// local imports
+import "./IRealityETH_ERC20.sol";
+
+// definining interface this way instead of IERC20 to avoid conflicts
+interface IRealityETH_IERC20 {
+  function decimals() external view returns (uint8);
+  function symbol() external view returns (string memory);
+}
+
+contract RealityETH_ERC20_Factory {
+
+  address public libraryAddress;
+  mapping(address => address) public deployments;
+
+  event RealityETH_ERC20_deployed (address reality_eth, address token, uint8 decimals, string token_ticker);
+
+  constructor(address _libraryAddress) {
+    libraryAddress = _libraryAddress;
+  }
+
+  /// @notice Returns the address of a proxy based on the specified address
+  /// @dev based on https://github.com/optionality/clone-factory
+  function _deployProxy(address _target)
+  internal returns (address result) {
+     bytes20 targetBytes = bytes20(_target);
+     assembly {
+         let clone := mload(0x40)
+         mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
+         mstore(add(clone, 0x14), targetBytes)
+         mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
+         result := create(0, clone, 0x37)
+     }
+  }
+
+  function createInstance(address _token) external {
+    require(deployments[_token] == address(0), "There should only be one deployment per version per token");
+    uint8 decimals = IRealityETH_IERC20(_token).decimals();
+    string memory ticker = IRealityETH_IERC20(_token).symbol();
+    address clone = _deployProxy(libraryAddress);
+    IRealityETH_ERC20(clone).setToken(_token);
+    IRealityETH_ERC20(clone).createTemplate('{"title": "%s", "type": "bool", "category": "%s", "lang": "%s"}');
+    IRealityETH_ERC20(clone).createTemplate('{"title": "%s", "type": "uint", "decimals": 18, "category": "%s", "lang": "%s"}');
+    IRealityETH_ERC20(clone).createTemplate('{"title": "%s", "type": "single-select", "outcomes": [%s], "category": "%s", "lang": "%s"}');
+    IRealityETH_ERC20(clone).createTemplate('{"title": "%s", "type": "multiple-select", "outcomes": [%s], "category": "%s", "lang": "%s"}');
+    IRealityETH_ERC20(clone).createTemplate('{"title": "%s", "type": "datetime", "category": "%s", "lang": "%s"}');
+    deployments[_token] = clone;
+    emit RealityETH_ERC20_deployed(clone, _token, decimals, ticker);
+  }
+}

package/contracts/Voting.sol

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+pragma experimental ABIEncoderV2;
+
+// openzeppelin imports
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/// @title Upvoting / Downvoting Contract
+contract Voting {
+  using SafeMath for uint256;
+
+  event ItemVotesUpdated(uint256 indexed itemId, uint256 upvotes, uint256 downvotes, uint256 timestamp);
+
+  event ItemVoteAction(address indexed user, VoteAction indexed action, uint256 indexed itemId, uint256 timestamp);
+
+  enum VoteAction {
+    upvote,
+    removeUpvote,
+    downvote,
+    removeDownvote
+  }
+
+  struct ItemVotes {
+    mapping(address => bool) usersUpvoted;
+    mapping(address => bool) usersDownvoted;
+    uint256 upvotes;
+    uint256 downvotes;
+  }
+
+  mapping(uint256 => ItemVotes) items;
+
+  IERC20 public token;
+  uint256 public requiredBalance; // required balance for voting
+
+  // ------ Modifiers ------
+
+  modifier mustHoldRequiredBalance() {
+    require(token.balanceOf(msg.sender) >= requiredBalance, "msg.sender must hold minimum erc20 balance");
+    _;
+  }
+
+  // ------ Modifiers End ------
+
+  /// @dev protocol is immutable and has no ownership
+  constructor(IERC20 _token, uint256 _requiredBalance) {
+    token = _token;
+    requiredBalance = _requiredBalance;
+  }
+
+  /// @dev allows user to upvote an item
+  function upvoteItem(uint256 itemId) external mustHoldRequiredBalance {
+    voteItem(itemId, VoteAction.upvote);
+  }
+
+  /// @dev allows user to downvote an item
+  function downvoteItem(uint256 itemId) external mustHoldRequiredBalance {
+    voteItem(itemId, VoteAction.downvote);
+  }
+
+  /// @dev logic of upvoting/downvoting an item
+  function voteItem(uint256 itemId, VoteAction action) private {
+    require(
+      action == VoteAction.upvote || action == VoteAction.downvote,
+      "Function parameter has to be upvoted or downvoted"
+    );
+
+    ItemVotes storage item = items[itemId];
+
+    mapping(address => bool) storage listToAddVote = action == VoteAction.upvote
+      ? item.usersUpvoted
+      : item.usersDownvoted;
+    mapping(address => bool) storage listToRemoveVote = action == VoteAction.upvote
+      ? item.usersDownvoted
+      : item.usersUpvoted;
+
+    // check if user has not already voted on the selected direction
+    bool hasUserVotedSelectedDirection = listToAddVote[msg.sender];
+
+    require(hasUserVotedSelectedDirection == false, "User has already a vote on this item");
+
+    // check if user has already downvoted
+    bool hasUserVotedOtherDirection = listToRemoveVote[msg.sender];
+
+    // remove from total downvoted if needed
+    if (hasUserVotedOtherDirection) {
+      action == VoteAction.upvote ? item.downvotes = item.downvotes.sub(1) : item.upvotes = item.upvotes.sub(1);
+    }
+
+    // add the vote
+    action == VoteAction.upvote ? item.upvotes = item.upvotes.add(1) : item.downvotes = item.downvotes.add(1);
+    listToAddVote[msg.sender] = true;
+    listToRemoveVote[msg.sender] = false;
+
+    // emit events
+    emit ItemVoteAction(msg.sender, action, itemId, block.timestamp);
+
+    emit ItemVotesUpdated(itemId, item.upvotes, item.downvotes, block.timestamp);
+  }
+
+  /// @dev allows user to remove an upvote from an item
+  function removeUpvoteItem(uint256 itemId) external mustHoldRequiredBalance {
+    removeVoteItem(itemId, VoteAction.removeUpvote);
+  }
+
+  /// @dev allows user to remove a downvote from an item
+  function removeDownvoteItem(uint256 itemId) external mustHoldRequiredBalance {
+    removeVoteItem(itemId, VoteAction.removeDownvote);
+  }
+
+  /// @dev logic of removing an upvote/downvote from an item
+  function removeVoteItem(uint256 itemId, VoteAction action) private {
+    require(
+      action == VoteAction.removeUpvote || action == VoteAction.removeDownvote,
+      "Function parameter has to be removeUpvoted or removeDownvoted"
+    );
+
+    // get item votes
+    ItemVotes storage item = items[itemId];
+
+    mapping(address => bool) storage listToRemoveVote = action == VoteAction.removeUpvote
+      ? item.usersUpvoted
+      : item.usersDownvoted;
+
+    // check if user has voted item
+    bool hasUserVoted = listToRemoveVote[msg.sender];
+
+    require(hasUserVoted == true, "User doesn't have a vote on this item");
+
+    // remove the vote
+    action == VoteAction.removeUpvote ? item.upvotes = item.upvotes.sub(1) : item.downvotes = item.downvotes.sub(1);
+    listToRemoveVote[msg.sender] = false;
+
+    // emit events
+    emit ItemVoteAction(msg.sender, action, itemId, block.timestamp);
+
+    emit ItemVotesUpdated(itemId, item.upvotes, item.downvotes, block.timestamp);
+  }
+
+  /// @dev Returns the number of upvotes/downvotes of an item
+  function getItemVotes(uint256 itemId) external view returns (uint256, uint256) {
+    ItemVotes storage item = items[itemId];
+
+    return (item.upvotes, item.downvotes);
+  }
+
+  /// @dev Returns info if the user has a upvote or a downvote in an item
+  function hasUserVotedItem(address user, uint256 itemId) external view returns (bool, bool) {
+    ItemVotes storage item = items[itemId];
+
+    return (item.usersUpvoted[user], item.usersDownvoted[user]);
+  }
+}

package/contracts/WETH9.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+contract WETH9 {
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8 public decimals = 18;
+
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    fallback() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 wad) public {
+        require(balanceOf[msg.sender] >= wad);
+        balanceOf[msg.sender] -= wad;
+        payable(msg.sender).transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return address(this).balance;
+    }
+
+    function approve(address guy, uint256 wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint256 wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(address src, address dst, uint256 wad) public returns (bool) {
+        require(balanceOf[src] >= wad);
+
+        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
+            require(allowance[src][msg.sender] >= wad);
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        emit Transfer(src, dst, wad);
+
+        return true;
+    }
+}