GolfGamer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Golf Gamer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Project - Alan Ranciato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Image of Augusta National](https://golf.com/wp-content/uploads/2020/04/augusta-national-12-996x560.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project Description\n",
    "This project is a golf contest wagering contract to be used for small to large groups.\n",
    "\n",
    "The contract tracks multiple players, their number of skins and CTPs (closest to the pin) won as well as their total scores for multiple rounds of golf.  After requiring a buyin from each player, the contract calculates the pro-rated payout per contest for each player, calculates a commission (to pay for both gas and administration), and provides payouts to the players and the owner of the contract.\n",
    "\n",
    "Along the way, the contract allows for changing the percentage of payout for each game, the number of score attestations needed to finalize the game, and the ability to see scores and contest standings along the way.  \n",
    "\n",
    "At the end, when the withdraw() function is called, final payouts are calculated (total won - commission), players are all paid, the contract remaining balance is paid to the owner of the contract and events are emited to the blockchain.\n",
    "\n",
    "The steps to run and validate the contract are illustrated below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Copy of the Final Project Proposal \n",
    "\n",
    "1) Type of app\n",
    "\n",
    "This will be a DApp.  I plan to implement with a javascript front end, but due to limited experience with it, may stick to Jupyter (will definitely do a notebook to test and submit along side.)\n",
    "\n",
    "2) Main Idea\n",
    "\n",
    "DApp for managing a golf tournament and prizes. Will calculate different games (skins, closest to the pin, etc) and payouts in coin (GOLF coin is already in existance.  Might need to come up with something else via ICO, or accept multiple forms of payment / coins)\n",
    "\n",
    "3) Potential Market\n",
    "\n",
    "Golfers and gamers.  The intent is to use for small tournaments and golf trips between friends, but could see it as being a service offered and take a \"house percentage\".\n",
    "\n",
    "4) Logistics\n",
    "\n",
    "Contract written in Solidity.  Jupyter Notebook for testing and Demo.  Potentially - web front-end interface.  Will likely demo with jupyter via Youtube so I can show the outcomes of the data as well.  Testing via Remix. \n",
    "\n",
    "5) Last Mile Problem\n",
    "\n",
    "Biggest issue is the oracle problem. The data entry will likely always be manual as it's golf and not a sanctioned professional event. In order to solve - will build in capability to specify the number of votes needed for consensus.\n",
    "\n",
    "6) Scaling issues\n",
    "\n",
    "I don't know that scaling would be too big of an issue.  Obviously managing the front-end capacity would be a thing.  Nothing should be too time sensitive.  I think the biggest issue could be a rise in cost of gas for the blockchain and pricing out usage.\n",
    "\n",
    "7) Fraud and Malicious behavior\n",
    "\n",
    "Inputting incorrect scores could be an issue - hence the reason for consensus and the ability to update.  Also, as golfers are not traditionally the most technical of people, I can see kay management being an issue.\n",
    "\n",
    "8) Compare without blockchain\n",
    "\n",
    "The solution could definitley be done without blockchain as a centralized service.  I think what blockchain provides is the ability to manage contracts and tournaments yourself vs relying on a service.  Additionally, the gambling aspect is now just a friendly game between friends vs. a centralized service that might be regulated.  \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic housekeeping and configuration before the good stuff starts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup the address of the contract in Ganache.  This is the one part of this notebook that needs to be configured"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The contract has been deployed to Ganache via Truffle migrate.  The constructor of the contract has the following inputs (and values being used for this deployment test):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Players (addresses) : players 1-4 from the test accounts provided in Ganache \n",
    "* Entry fee (in ETH) : 20 - conversion to wei is done within the contract\n",
    "* Attestors: 1 - how many attestors are needed to validate results - the Last Mile problem\n",
    "* Commission Percent: 3 - this is the administration fee for running the contract and gets paid to the owner after all players are paid\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Setting the contract Address for Ganache\n",
    "GOLFGAMER_CONTRACT_ADDR = \"0xc808Ff8bD6548E877a4104E94B40F82Ef6D7AE6b\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup solc / ganache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from solcx import install_solc, set_solc_version, compile_files\n",
    "from web3 import Web3\n",
    "from decimal import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "install_solc('v0.7.6')\n",
    "set_solc_version('v0.7.6')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GANACHE=\"http://127.0.0.1:7545\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# web3.py instance\n",
    "w3 = Web3(Web3.HTTPProvider(GANACHE))\n",
    "w3.eth.accounts\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_account = w3.eth.accounts[0]\n",
    "main_account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set default account on web3 object\n",
    "w3.eth.defaultAccount = main_account\n",
    "w3.eth.defaultAccount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct path to compiled contract file\n",
    "def get_compiled_contract_path(contract_name):\n",
    "    return \"./build/contracts/\"+contract_name+\".json\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CONTRACT_NAME = \"GolfGamer\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "golfgamer_compiled_path = get_compiled_contract_path(CONTRACT_NAME)\n",
    "golfgamer_compiled = json.load(open(golfgamer_compiled_path))\n",
    "golfgamer_abi = golfgamer_compiled['abi']\n",
    "golfgamer_bytecode = golfgamer_compiled['bytecode']\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll make sure we can see all of the public functions from our contract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "golfgamer_contract.all_functions()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build out Utility functions to make life easier for testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# execute a call, which does not execute a transaction (i.e. no write => no gas)\n",
    "def exec_call(w3, contract_inst, function_name, *f_args):\n",
    "    func_inst = contract_inst.get_function_by_name(function_name)\n",
    "\n",
    "    return_value = func_inst(*f_args).call()\n",
    "    return return_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# execute a transaction (i.e. a write), and return the transaction receipt (costs gas paid in Ether)\n",
    "def exec_transact_receipt(w3, contract_inst, function_name, *f_args):\n",
    "    func_inst = contract_inst.get_function_by_name(function_name)\n",
    "    \n",
    "    # get the return value, without executing transaction\n",
    "    return_value = exec_call(w3, contract_inst, function_name, *f_args)\n",
    "    \n",
    "    # execute the transaction\n",
    "    tx_hash = func_inst(*f_args).transact()\n",
    "    # receipt does not contain values returned by function\n",
    "    tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash)\n",
    "    \n",
    "    return return_value, tx_receipt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# execute transaction, but ignore the receipt\n",
    "def exec_transact(w3, contract_inst, function_name, *f_args):\n",
    "    rv, _ = exec_transact_receipt(w3, contract_inst, function_name, *f_args)\n",
    "    return rv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the Golf Gamer contract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's start by finding out some information about the players and payouts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll create a similar status enum for easier mapping in the notebook - This enum maps to the statuses of the contract."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import enum\n",
    "class Statuses(enum.Enum):\n",
    "   OPEN = 0\n",
    "   PENDINGATTEST = 1\n",
    "   CLOSED = 2   \n",
    "   CLOSEDPAID = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll pull the players from the contract construction and set variables for easier access throughout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "players = exec_call(w3, golfgamer_contract, 'getPlayers')\n",
    "player1 = players[0]\n",
    "player2 = players[1]\n",
    "player3 = players[2]\n",
    "player4 = players[3]\n",
    "players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "player2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial status of the contract should be OPEN.  Let's verify that here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = Statuses(exec_call(w3, golfgamer_contract, 'getStatus')).name\n",
    "assert status == 'OPEN'\n",
    "status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll look to see what the payout values are currently based on how many skins / ctps have been won.  Since no scores have been entered yet, we're expecting 0 amounts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.fromWei(exec_call(w3, golfgamer_contract, 'getSkinsValue'),'ether')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.fromWei(exec_call(w3, golfgamer_contract, 'getCtpValue'), 'ether')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total pot should consist of the number of players (4) * the entry fee (20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "totalPot = w3.fromWei(exec_call(w3, golfgamer_contract, 'getTotalPot'), 'ether')\n",
    "assert totalPot == 80\n",
    "totalPot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The getPayouts function returns us the payouts based on the percentage of each game * the total pot.  Note that this does not calculate in the commission percentage. That is only calculated at withdrawl.  Note that we are /100 on the payouts due to the decimal conversion for %s.\n",
    "\n",
    "The default payouts at contract creation are set at 33/33/34%.  These can be changed as show in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "payouts = exec_call(w3, golfgamer_contract, 'getPayouts')\n",
    "print (\"Skins: \", w3.fromWei(payouts[0],'ether')/100 ,  ' | ' , \"CTP: \", w3.fromWei(payouts[1],'ether')/100 , ' | ' , \"Overall Winner: \", w3.fromWei(payouts[2],'ether')/100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now, we're going to edit the payout percentages and check the payouts again.  They should have changed from the default 33%, 33%, 34% values to the values below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's be sure that we validate that the percentages add up to 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    exec_transact(w3, golfgamer_contract, 'setPayouts', 20, 23, 40) \n",
    "except Exception as e:\n",
    "    print (\"Failed as designed: \\n\", e)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll set the payouts a little differently, but in an amount that adds to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exec_transact(w3, golfgamer_contract, 'setPayouts', 20, 23, 57) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "payouts = exec_call(w3, golfgamer_contract, 'getPayouts')\n",
    "print (\"Skins: \", w3.fromWei(payouts[0],'ether')/100 ,  ' | ' , \"CTP: \", w3.fromWei(payouts[1],'ether')/100 , ' | ' , \"Overall Winner: \", w3.fromWei(payouts[2],'ether')/100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now, let's setup some scores and enter them into the contract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "exec_transact(w3, golfgamer_contract, 'postScore', player1, 2, 1, 87) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player1, 1, 0, 82) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player2, 2, 1, 91) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player2, 3, 2, 97) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player3, 4, 0, 86) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player3, 2, 0, 102) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player4, 1, 0, 89) \n",
    "exec_transact(w3, golfgamer_contract, 'postScore', player4, 5, 1, 78) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have scores posted, let's check the payouts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "payouts = exec_call(w3, golfgamer_contract, 'getPayouts')\n",
    "overallWinner = w3.fromWei(payouts[2],'ether')/100\n",
    "print (\"Skins: \", w3.fromWei(payouts[0],'ether')/100 ,  ' | ' , \"CTP: \", w3.fromWei(payouts[1],'ether')/100 , ' | ' , \"Overall Winner: \", w3.fromWei(payouts[2],'ether')/100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skins Payout based on the number won - with the current scores posted, there are 20 skins at 16 eth == .8 per skin won."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "skinValue = w3.fromWei(exec_call(w3, golfgamer_contract, 'getSkinsValue'),'ether')/100\n",
    "skinValue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CTP Payout based on number won"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ctpValue = w3.fromWei(exec_call(w3, golfgamer_contract, 'getCtpValue'), 'ether')/100\n",
    "ctpValue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now let's check the player scores and their winnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player1)\n",
    "print (\"Player 1: \", player1,\" Winnings: \", w3.fromWei(score[4],'ether'), \" OverallScore: \", score[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player2)\n",
    "print (\"Player 2: \", player2, \"Winnings: \", w3.fromWei(score[4],'ether'), \" OverallScore: \", score[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player3)\n",
    "print (\"Player 3: \", player3,\"Winnings: \", w3.fromWei(score[4],'ether'), \" OverallScore: \", score[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player4)\n",
    "print (\"Player 4: \", player4, \"Winnings: \", w3.fromWei(score[4],'ether'), \" OverallScore: \", score[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now that the scores are all posted, we'll close the game and pay our players"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Close the game so no more scores can be posted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = exec_transact(w3, golfgamer_contract, 'closeGame')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make sure we can't add anymore scores now that the game is closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    exec_transact(w3, golfgamer_contract, 'postScore', player4, 4, 1, 78) \n",
    "except Exception as e:\n",
    "    print(\"This should have failed as we're not allowing any additional score entry when the status is not OPEN \\n\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we constructed the contract to require at least one attestation, the status should be pending attest vs. closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert Statuses(status).name == 'PENDINGATTEST'\n",
    "Statuses(status).name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we need to attest the scores prior to paying out and closing the game, we'll call the attest function which will add to the attestors and update the status of the game to Closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainingAttestations = exec_transact(w3, golfgamer_contract, 'attestGame')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert  remainingAttestations == 0\n",
    "remainingAttestations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see who the attestors are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exec_call(w3, golfgamer_contract, 'getAttestors')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've attested to the scores, the status of the game should be CLOSED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = Statuses(exec_call(w3, golfgamer_contract, 'getStatus')).name\n",
    "assert status == 'CLOSED'\n",
    "status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now that we've attested, we'll try to payout the players"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll test the withdrawl, which should fail since we haven't made any deposits just yet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    exec_transact(w3, golfgamer_contract, 'withdraw')\n",
    "except Exception as e:\n",
    "    print (\"Failed as designed: \\n\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll create some transaction details to pass into the deposits.  This is the from address of each player as well as their entry fees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transaction_dict1 = {\n",
    "     'from': player1,\n",
    "    'value': w3.toWei(20, 'ether') # send this much ether as part of transaction\n",
    "}\n",
    "transaction_dict2 = {\n",
    "     'from': player2,\n",
    "    'value': w3.toWei(20, 'ether') # send this much ether as part of transaction\n",
    "}\n",
    "transaction_dict3 = {\n",
    "     'from': player3,\n",
    "    'value': w3.toWei(20, 'ether') # send this much ether as part of transaction\n",
    "}\n",
    "transaction_dict4 = {\n",
    "     'from': player4,\n",
    "    'value': w3.toWei(20, 'ether') # send this much ether as part of transaction\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll make the deposits to fund the contract."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the balance -  should start at 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "balance = exec_call(w3, golfgamer_contract, 'getContractBalance')\n",
    "assert balance == 0\n",
    "balance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to switch accounts to send some deposits to the contract now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.default_account = w3.eth.accounts[1]\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)\n",
    "golfgamer_contract.functions.deposit().transact( transaction_dict1 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.default_account = w3.eth.accounts[2]\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)\n",
    "golfgamer_contract.functions.deposit().transact( transaction_dict2 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.default_account = w3.eth.accounts[3]\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)\n",
    "golfgamer_contract.functions.deposit().transact( transaction_dict3 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.default_account = w3.eth.accounts[4]\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)\n",
    "golfgamer_contract.functions.deposit().transact( transaction_dict4 )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now our balance should be 80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "balance = exec_call(w3, golfgamer_contract, 'getContractBalance')\n",
    "assert balance == w3.toWei(80,'ether')\n",
    "w3.fromWei(balance, 'ether')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now that we've deposited the entry fees and closed the game, it's time to payout the players (and the contract owner)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w3.default_account = w3.eth.accounts[0]\n",
    "golfgamer_contract= w3.eth.contract(address=GOLFGAMER_CONTRACT_ADDR, bytecode=golfgamer_bytecode, abi=golfgamer_abi)\n",
    "\n",
    "try:\n",
    "    exec_transact(w3, golfgamer_contract, 'withdraw')\n",
    "except Exception as e:\n",
    "    print (\"Error with payouts: \\n\", e)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's check the status - which should now be CLOSEDPAID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = Statuses(exec_call(w3, golfgamer_contract, 'getStatus')).name\n",
    "assert status == 'CLOSEDPAID'\n",
    "status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And Finally, our contract balance should be back to Zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "balance = exec_call(w3, golfgamer_contract, 'getContractBalance')\n",
    "assert balance == w3.toWei(0,'ether')\n",
    "w3.fromWei(balance, 'ether')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final wrap up and validation of the balances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, let's check the balances on the accounts we used.  Account 0 was the contract owner and should have received 3% of the contract value.  The other players should have received payouts based upon their winnings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contractOwner = w3.fromWei(w3.eth.getBalance(w3.eth.accounts[0]), 'ether')\n",
    "contractOwner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player1)\n",
    "winnings = (w3.fromWei(score[4],'ether')) * Decimal('.97')\n",
    "print (\"Player 1: \", player1,\" Winnings: \", winnings, \"Balance: \", w3.fromWei(w3.eth.getBalance(player1), 'ether'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player2)\n",
    "winnings = (w3.fromWei(score[4],'ether')) * Decimal('.97')\n",
    "print (\"Player 2: \", player2,\" Winnings: \", winnings, \"Balance: \", w3.fromWei(w3.eth.getBalance(player2), 'ether'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player3)\n",
    "winnings = (w3.fromWei(score[4],'ether')) * Decimal('.97')\n",
    "\n",
    "print (\"Player 3: \", player3,\" Winnings: \", winnings, \"Balance: \", w3.fromWei(w3.eth.getBalance(player3), 'ether'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Player 4 also has the low total which is an additional 45.6 eth in addition to their 8.48 winning below.  The balance should reflect that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = exec_call(w3, golfgamer_contract, 'getScore', player4)\n",
    "winnings = (w3.fromWei(score[4],'ether') + overallWinner) * Decimal('.97')\n",
    "print (\"Player 4: \", player4,\" Winnings: \", winnings, \"Balance: \", w3.fromWei(w3.eth.getBalance(player4), 'ether'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# And that's it!  Happy Golfing!  Fairways and Greens!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Closing Course Image](https://images.ctfassets.net/56u5qdsjym8c/3b96eGN9KodYhSYaBsYpI/261024d195ef6803bca98d4e10fd2793/Blue-Doral-Monster-Hero.jpg?fl=progressive&q=80)\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (block_env)",
   "language": "python",
   "name": "block_env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}