Add exercises

4 files changed, 508 insertions, 0 deletions

diff --git a/Year_3/Blockchain/CorporateManagement.sol b/Year_3/Blockchain/CorporateManagement.sol
new file mode 100644
index 0000000..cb74871
--- /dev/null
+++ b/Year_3/Blockchain/CorporateManagement.sol
@@ -0,0 +1,188 @@
+/*
+    Corso Blockchain e Cryptocurrencies - Compito di laboratorio del 12/07/2021
+
+    Scrivere un contratto `CorporateManagement` che implementi l'interfaccia `CorporateManagementSpecs`
+    per la gestione delle decisioni di una società sulla piattaforma Ethereum usando il linguaggio Solidity.
+
+    All'interno della società ci possono essere una serie di soci (associates): il primo è il fondatore che
+    crea il contratto stesso con relativa quota (share). Gli altri soci si possono auto-candidare depositando
+    una quota sufficiente: tale candidatura viene considerata accettata solo se accettata a maggioranza dai
+    soci attuali. Ogni socio può depositare una generica proposta, consistente in una semplice descrizione
+    testuale: essa sarà considerata accettata se votata a maggioranza dai soci. Il voto per maggioranza (50% + 1)
+    tiene conto del peso della quota in ETH depositata da ogni socio.
+    La società, su proposta di qualche socio, può essere anche sciolta purché la risoluzione venga votata 
+    all'unanimità.
+
+    Di seguito alcuni dettagli sui singoli elementi obbligatori dell'interfaccia:
+    - tutti i casi illustrati sopra vengono considerti come proposte da accettare: le tipologie di proposte 
+      corrispondono all'enumerazione `ProposalCategory`;
+    - il primo socio (fondatore) crea il contratto specificando la quota minima e versando, contestualmente, la
+      propria di quota sufficiente;
+
+    X - il metodo `depositFunds` può essere usato da chiunque per auto-candidarsi a socio, versando la relativa
+      sufficiente quota; il metodo può essere usato sia dai soci che da candidati-soci per aumentare la propria 
+      quota;
+    X - il metodo `voteProposal`, utilizzabile solo dai soci effettivi, può essere usato per aderire, con la propria
+      quota, all'accettazione della proposta tramite l'apposito identificativo; ovviamente un socio può votare una
+      sola volta per ogni singola proposta, tale metodo dovrà anche verificare se la proposta ha raggiunto i voti 
+      necessari e far scaturire i relativi effetti;
+    X - i metodi `depositGenericProposal` e `depositDissolutionProposal` permettono, unicamente ai soci, di depositare,
+      rispettivamente, una generica proposta con descrizione testuale o una proposta di scioglimento;
+    - nel caso in cui una proposta di scioglimento venga accettata all'unanimità la società va in liquidazione e pertanto
+      nessuna funzionalità avrà più effetti ad eccezione del metodo `requestShareRefunding` che permette al singolo
+      socio di riscuotere la propria quota;
+    - i predicati `isAssociated` e `isDissoluted` permettono, rispettivamente, di verificare se un indirizzo specificato
+      corrisponde ad un socio effettivo o se la società è in scioglimento;
+
+    - gli eventi di tipo `New...` dovranno essere generati quando una proposta viene creata a seguito di un'azione 
+      esterna; depositare dei fondi sufficienti da parte di un non-socio rappresenta una proposta di candidatura;
+    - gli eventi di tipo `Accepted....` dovranno essere generati ogniqualvolta una relativa proposta viene accettata;
+      notare che all'atto della creazione della società il socio fondatore è implicitamente accettato.
+    
+    Il contratto dovrà occuparsi di validare gli input ricevuti secondo criteri ovvi di sensatezza.
+
+*/
+
+// SPDX-License-Identifier: None
+
+pragma solidity ^0.8.0;
+import "exam.sol";
+
+contract CorporateManagement is CorporateManagementSpecs {
+    enum AssociateRole { NONE, CANDIDATE, ASSOCIATE, FOUNDER }
+    struct Associate {
+        address payable id;
+        uint share;
+        AssociateRole role;
+    }
+
+    struct Proposal {
+        ProposalCategory category;
+        address owner;
+        Associate[] votes;
+        string descr;
+    }
+
+    uint public minimumShare;
+    mapping(address => Associate) associates;
+    address[] associateIds;
+    address public immutable founder;
+
+    Proposal[] public proposals;
+
+    bool public override isDissoluted = false;
+
+    function isAssociated(address id) external view override returns (bool) {
+        if (associates[id].id == address(0)) {
+            return false;
+        }
+
+        return (associates[id].role == AssociateRole.ASSOCIATE || associates[id].role == AssociateRole.FOUNDER);
+    }
+
+
+    constructor(uint minimumAssociatingShare) payable {
+        assert(minimumAssociatingShare == msg.value);
+        minimumShare = msg.value;
+        associates[msg.sender] = Associate({
+            id: payable(msg.sender),
+            share: msg.value,
+            role: AssociateRole.FOUNDER
+        });
+
+        associateIds.push(msg.sender);
+        founder = msg.sender; 
+    }
+
+    modifier NeedDissolution(bool action) {
+        if (!action) {
+            require(!isDissoluted, "Can't do this action because the corporate is dissoluting");
+        } else {
+            require(isDissoluted, "Can't do this action because the corporate is not dissoluting");
+        }
+        _;
+    }
+    
+    modifier NeedAssociate {
+        if (!this.isAssociated(msg.sender)) {
+            revert("You must be an associated to vote this proposal.");
+        }
+        _;
+    }
+
+    function depositFunds() external override payable NeedDissolution(false) {
+        if (associates[msg.sender].id == address(0)) {
+            require(msg.value >= minimumShare, "The share must be at least equals to the minimum");
+            associates[msg.sender] = Associate({
+                id: payable(msg.sender),
+                share: msg.value,
+                role: AssociateRole.CANDIDATE
+            });
+            Proposal storage p = proposals.push();
+            p.category = ProposalCategory.NewAssociationAcceptance;
+            p.owner = msg.sender;
+
+            emit NewAssociateCandidate(proposals.length-1, p.owner);
+        } else {
+            associates[msg.sender].share += msg.value;
+        }
+    }
+
+
+    function depositGenericProposal(string calldata description) external override NeedDissolution(false) NeedAssociate {
+        Proposal storage p = proposals.push();
+        p.category = ProposalCategory.Generic;
+        p.owner = msg.sender;
+        p.descr = description;
+
+        emit NewGenericProposal(proposals.length-1, description);
+    }
+
+     
+    function depositDissolutionProposal() external override NeedDissolution(false) NeedAssociate {
+        Proposal storage p = proposals.push();
+        p.category = ProposalCategory.CorporateDissolution;
+        p.owner = msg.sender;
+
+        emit NewDissolutionProposal(proposals.length-1);
+    }
+
+
+    function voteProposal(uint proposalId) external override NeedDissolution(false) NeedAssociate {
+        Proposal storage p = proposals[proposalId];
+        uint totalShare = 0;
+        for (uint i = 0; i < p.votes.length; ++i) {
+            totalShare += p.votes[i].share;
+            if (p.votes[i].id == msg.sender) {
+                revert("Already voted this proposal!");
+            }
+        }
+        p.votes.push(associates[msg.sender]);
+        totalShare += associates[msg.sender].share;
+
+        uint minQuote = (address(this).balance / 2) + 1;
+
+        if (p.category == ProposalCategory.CorporateDissolution && p.votes.length == associateIds.length) {
+            isDissoluted = true;
+            emit AcceptedCorporateDissolution();
+        } else if (totalShare >= minQuote) {
+            if (p.category == ProposalCategory.NewAssociationAcceptance) {
+                assert(associates[p.owner].role == AssociateRole.CANDIDATE);
+                associateIds.push(p.owner);
+                associates[p.owner].role = AssociateRole.ASSOCIATE;
+                emit AcceptedAssociate(p.owner);
+            } else if (p.category == ProposalCategory.Generic) {
+                emit AcceptedGenericProposal(p.descr);
+            }
+        }
+    }
+
+
+    function requestShareRefunding() external override NeedDissolution(true) {
+        if (associates[msg.sender].id == address(0)) {
+            revert("You're not one of the associates, can't refund");
+        }
+
+        associates[msg.sender].id.transfer(associates[msg.sender].share);
+    }
+}
diff --git a/Year_3/Blockchain/RandomMoney.sol b/Year_3/Blockchain/RandomMoney.sol
new file mode 100644
index 0000000..2a5def4
--- /dev/null
+++ b/Year_3/Blockchain/RandomMoney.sol
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >0.7 <0.9;
+
+contract RandomMoney {
+    uint public total;
+    uint public constant minFee = 10;
+    mapping(address => uint) public amounts;
+    address[] private members;
+
+
+    function play() public payable returns (uint) {
+        require(msg.value >= minFee, "Value is less than the required minimum");
+
+
+        amounts[msg.sender] += msg.value;
+
+        if (amounts[msg.sender] == msg.value) {
+            members.push(msg.sender);
+        }
+
+        total += msg.value;
+
+        return total;
+    }
+
+    function pay() public payable {
+        address payable account = payable(randomAddress());
+        account.transfer(total);
+        total = 0;
+    }
+
+    function randomAddress() internal view returns (address) {
+        uint8 num = uint8(
+            uint256(
+                keccak256(abi.encode(block.timestamp, block.difficulty))
+            ) % members.length
+        );
+
+        return members[num];
+    }
+}
+
diff --git a/Year_3/Blockchain/RockPaperScissor.sol b/Year_3/Blockchain/RockPaperScissor.sol
new file mode 100644
index 0000000..528bc4c
--- /dev/null
+++ b/Year_3/Blockchain/RockPaperScissor.sol
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "TrustworthyRockPaperScissorsTournamentSpecs.sol";
+
+contract TrustworthyRockPaperScissorsTournament is TrustworthyRockPaperScissorsTournamentSpecs {
+    enum Move { ROCK, PAPER, SCISSOR }
+    enum Status { IN_PROGRESS, END }
+    struct PlayerInfo {
+        address payable id;
+        uint8 wins;
+        Move[] games;
+        uint fees;
+    }
+
+    mapping(Player => PlayerInfo) players;
+    uint8 target;
+    uint256 matchFee;
+    Status status;
+    Player winner;
+    address payable owner;
+
+    uint8 override public disputedMatches;
+ 
+    constructor(
+        address payable firstPlayer,
+        address payable secondPlayer,
+        uint8 targetWins,
+        uint256 singleMatchFee
+    ) {
+        require(firstPlayer != secondPlayer, "Players must be two different addresses.");
+        require(firstPlayer != address(0) && secondPlayer != address(0), "Players address are not valid.");
+
+        players[Player.First].id = firstPlayer;
+        players[Player.Second].id = secondPlayer;
+        target = targetWins;
+        matchFee = singleMatchFee;
+        status = Status.IN_PROGRESS;
+        disputedMatches = 0;
+        owner = payable(msg.sender);
+    }
+
+    function moveRock() external override payable {
+        move(Move.ROCK);
+    }
+
+    function movePaper() external override payable {
+        move(Move.PAPER);
+    }
+
+    function moveScissor() external override payable {
+        move(Move.SCISSOR);
+    }
+
+    modifier mustBeAPlayer() {
+        require(msg.sender == players[Player.First].id || msg.sender == players[Player.Second].id, "You're not one of the players.");
+        _;
+    }
+
+    function move(Move move_type) internal mustBeAPlayer {
+        require(status != Status.END, "Game has already finish");
+        require(msg.value >= matchFee, "You need to pass the minimum fee to play");
+
+        Player p = (msg.sender == players[Player.First].id ? Player.First : Player.Second);
+        players[p].games.push(move_type);
+        players[p].fees += msg.value;
+
+        checkGame();
+    }
+
+    function checkGame() internal {
+        uint8 n = uint8(
+                players[Player.First].games.length < players[Player.Second].games.length 
+                ? players[Player.First].games.length
+                : players[Player.Second].games.length
+            );
+
+        for (uint8 i = disputedMatches; i < n; ++i) {
+            Move p1 = players[Player.First].games[i];
+            Move p2 = players[Player.Second].games[i];
+
+            // Fair play
+            if (p1 == p2) continue;
+
+            if (
+                (p1 == Move.ROCK && p2 == Move.SCISSOR) ||
+                (p1 == Move.SCISSOR && p2 == Move.PAPER) ||
+                (p1 == Move.PAPER && p2 == Move.ROCK)
+            ) {
+                players[Player.First].wins++;
+                emit MatchWonBy(Player.First, i);
+            } else {
+                players[Player.Second].wins++;
+                emit MatchWonBy(Player.Second, i);
+            }
+
+            disputedMatches++;
+
+            if (players[Player.First].wins == target) {
+                emit TournamentWonBy(Player.First);
+                winner = Player.First;
+                endGame();
+            } else if (players[Player.Second].wins == target) {
+                emit TournamentWonBy(Player.Second);
+                winner = Player.Second;
+                endGame();
+            }
+        }
+    }
+
+    function endGame() internal {
+        require(status != Status.END, "Game has already finish");
+
+        assert(players[winner].wins == target);
+
+        uint total = players[Player.First].fees + players[Player.Second].fees;
+        assert(total == address(this).balance);
+        players[winner].id.transfer(total);
+
+        status = Status.END;
+        selfdestruct(owner);
+    }
+}
diff --git a/Year_3/Blockchain/TicTacToe.sol b/Year_3/Blockchain/TicTacToe.sol
new file mode 100644
index 0000000..582e10d
--- /dev/null
+++ b/Year_3/Blockchain/TicTacToe.sol
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: None
+
+pragma solidity ^0.8.0;
+
+contract TicTacToe {
+    enum Player { X, O }
+    struct PlayerInfo {
+        address payable id;
+        Player p_type;
+    }
+    enum Cell { X, O, NONE }
+    enum GameStatus { TURN_X, TURN_O, WAIT, END }
+
+    mapping(address => PlayerInfo) players;
+    address[2] playerIds;
+    Cell[3][3] cells;
+    Player turn;
+    GameStatus status = GameStatus.WAIT;
+    uint immutable minFee;
+    uint fee;
+    uint8 moves = 9;
+
+    event Movement(address sender, Player player, Cell[3][3] cells);
+    event EndGame(address winner, uint amount);
+
+    constructor(address payable firstPlayer, address payable secondPlayer, uint _minFee) {
+        require(firstPlayer != address(0) && secondPlayer != address(0), "You must define both address");
+        require(firstPlayer != secondPlayer, "Players must be different");
+
+        players[firstPlayer] = PlayerInfo({
+            id: firstPlayer,
+            p_type: Player.X
+        });
+        playerIds[0] = firstPlayer;
+        players[secondPlayer] = PlayerInfo({
+            id: secondPlayer,
+            p_type: Player.O
+        });
+        playerIds[1] = secondPlayer;
+        minFee = _minFee;
+        turn = Player(getRandomTurn());
+
+        for (uint8 i = 0; i < 3; ++i)
+            for (uint8 j = 0; j < 3; ++j)
+                cells[i][j] = Cell.NONE;
+    }
+
+    function play(uint x, uint y) public payable {
+        require(status != GameStatus.END, "Game is over");
+        require(players[msg.sender].id != address(0), "You're not one of the players");
+        require(players[msg.sender].p_type == turn, "It's not your turn");
+        require(msg.value >= minFee, "Value is less than the min fee");
+
+        fee += msg.value;
+
+        if (cells[y][x] != Cell.NONE) {
+            revert("Can't use this cell");
+        }
+
+        cells[y][x] = (turn == Player.X ? Cell.X : Cell.O);
+        turn = Player(1 - uint(turn));
+        moves--;
+        checkGame();
+    }
+
+    function getBoard() public view returns (Cell[3][3] memory) {
+        return cells;
+    }
+
+    /*
+    -------------
+    |   |   |   |
+    |---|---|---|
+    |   |   |   |
+    |---|---|---|
+    |   |   |   |
+    -------------
+    */
+
+    function checkGame() internal {
+        // It's useless to check when moves > 4
+        if (moves > 4) return;
+
+        bool result = false;
+        PlayerInfo memory winner;
+
+        if (moves == 0) {
+            emit EndGame(address(this), fee);
+            status = GameStatus.END;
+        }
+
+        // Diagonal wins
+        if (
+            (cells[0][0] == cells[1][1] && cells[0][0] == cells[2][2]) ||
+            (cells[0][2] == cells[1][1] && cells[0][2] == cells[2][0])
+        ) {
+            address addr = address(0);
+            if (cells[0][0] != Cell.NONE) {
+                addr = playerIds[uint256(cells[0][0])];
+                winner = players[addr];
+                assert(uint(winner.p_type) == uint(cells[0][0]));
+                result = true;
+            } else if (cells[0][2] != Cell.NONE) {
+                addr = playerIds[uint256(cells[0][2])];
+                winner = players[addr];
+                assert(uint(winner.p_type) == uint(cells[0][2]));
+                result = true;
+            }
+        }
+
+        if (!result) {
+            for (uint8 i = 0; i < 3; i+=3) {
+                for (uint8 j = 0; j < 3; j+=3) {
+                    if (cells[i][j] == Cell.NONE) continue;
+
+                    address addr = playerIds[uint256(cells[i][j])];
+
+                    if (
+                        (cells[i][j] == cells[i+1][j] && cells[i][j] == cells[i+2][j]) ||
+                        (cells[i][j] == cells[i][j+1] && cells[i][j+1] == cells[i][j+2])
+                    ) {
+                        result = true; 
+                    }
+
+                    if (result) {
+                        winner = players[addr];
+                        assert(uint(winner.p_type) == uint(cells[i][j]));
+                        break;
+                    }
+
+               }
+
+                if (result) break;
+            }
+        }
+
+        if (result && winner.id != address(0)) {
+            assert(fee == address(this).balance);
+            winner.id.transfer(fee);
+            status = GameStatus.END;
+            emit EndGame(winner.id, fee);
+            fee = 0;
+        }
+    }
+
+    function getRandomTurn() internal view returns (uint8) {
+        return uint8(
+            uint256(
+                keccak256(abi.encode(block.timestamp, block.difficulty))
+            ) % 2
+        );
+    }
+}