Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

voici un code en cours d'écriture qui utilise "chainlinkVRF" avec abonnement. Peux tu…

  1. User

    voici un code en cours d'écriture qui utilise "chainlinkVRF" avec abonnement. Peux tu compléter/corriger les fonctions "requestRandomWords" et "fulfillRandomWords" qui proviennent des contrats "RFCoordinatorV2Interface.sol" et "VRFConsumerBaseV2.sol" ? le code en cours d'écriture "// SPDX-License-Identifier: UNLICENSED //PARTIE 1 : //Jeu qui consiste à deviné un mot. Il se joue à 2 joueurs. Chacun doit miser la même mise des ethers //ce contrat utilise chainlinkVRF pour les mots aléatoires pragma solidity 0.8.17;

    import "../node_modules/@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol"; import "../node_modules/@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

    contract Penduel is VRFConsumerBaseV2 {

    VRFCoordinatorV2Interface COORDINATOR;
    
    address public s_owner;
    address public player1;
    address public player2;
    string public word; // mot à deviner
    string[] private wordList; //liste de mots utllisés pour le jeu
    string[] public lettersWin; //stocke les lettres gagnantes
    uint256 public gameId = 0;
    uint256 public requestId; 
    uint256[] private requestIds;
    uint public wordLength;
    uint public pot;
    uint256 amount; //montant spécifique
    GameStatus public status;
    
    uint64 s_subscriptionId;
    address vrfCoordinator = 0x2Ca8E0C643bDe4C2E08ab1fA0da3401AdAD7734D;
    bytes32 keyHash = 0x79d3d8832d904592c0bf9818b621522c988bb8b0c05cdc3b15aea1b6e8db0c15;
    uint32 callbackGasLimit = 100000;
    uint16 requestConfirmations = 3; 
    uint32 numWords = 2;
    uint256 public randomResult;
    uint256 public delay = 10; 
    
    struct Game {
        address player1;
        address player2;
        uint256 gameId;
        uint256 balance;//solde en ether de ce jeu
        uint256 turn;  
    }
    
    enum GameStatus { //etat du jeux
        waitingForPlayers, 
        waitingForRandomWord, 
        inProgress, 
        finished, 
        cancelled
    }
    mapping(uint256 => Game) public games;
    mapping(address => mapping(uint => bool)) public guessedLetters;
    mapping(address => mapping(uint => string)) public guessedWords;
    
    event GameCreated(uint256 indexed gameId, address player1, address player2);
    event GameJoined(uint256 indexed _gameId, address indexed player2, address indexed player1);
    event GameStarted(uint256 indexed gameId, string firstLetter);
    event GameEnded(uint256 indexed gameId, address activePLayer, address otherPlayer);
    event GameCancelled(uint256 indexed gameId, address cancelled);
    event FirstLetter(uint256 indexed gameId, bytes1 _letterToGuess);
    event LetterSuggested(uint256 indexed gameId, address indexed player1, address indexed player2, string letterToGuess);
    event LetterWin(uint256 indexed _gameId,address indexed player1, address indexed player2, string letterWin);
    event WordGuessed(uint256 indexed gameId, address activePlayer, address otherPlayer, string wordGuess);
    event WordWin(uint256 indexed gameId, address activePlayer, address otherPlayer, string wordFound);
    event PlayerSwitched(uint256 gameId, address indexed player1, address indexed player2);
    event BalanceDeposited(address indexed player, uint256 amount);
    event BalanceWithdrawn(address indexed player, uint256 amount);
    event PotWon(uint256 indexed gameId, address activePlayer, uint256 currentPot);
    
     constructor(uint64 subscriptionId) VRFConsumerBaseV2(vrfCoordinator) {
        COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
        s_owner = msg.sender;
        s_subscriptionId = subscriptionId;
    }
    modifier onlyOwner() {
        require(msg.sender == s_owner, "Seul l'admin peut appeler cette fonction");
        _;
    }
    modifier inProgress() {
        require(pot > 0, "Le jeu n'est pas actif");
        _;
    }
    /**
     * @notice  permet au joueur 1 de créer une nouvelle partie en effectuant une mise
     * @dev     elle met à jour le joueur 1, la mise, l'ID de la partie et l'état de la partie
     * @dev     elle crée un nouvel objet Game en mémoire avec les informations pertinentes et ajoute la partie au mapping games
     * @dev     msg.sender L'adresse de l'émetteur de la transaction (joueur 1)
     * @dev     msg.value La valeur (en wei) transférée lors de l'appel de la fonction  
     * @dev     émet un événement pour la création du jeu (identifiant de la partie, adresse du joueur1 et adresse vide du joueur 2)
     * @return  identifiant unique de la partie créée
     */
    function createGame() external payable returns (uint256) {
        require(status == GameStatus.waitingForPlayers, unicode"Le jeu est en cours de création, misez en rejoignant joinGame");
        require(msg.sender != player1, unicode"Vous êtes déjà le créateur de la partie");
        require(pot > 0, unicode"Le montant de la mise doit être supérieur à zéro");
        player1 = msg.sender;
        pot = msg.value;
        gameId++;
        status = GameStatus.waitingForRandomWord; 
    
        Game memory newGame;
        newGame.player1 = player1;
        newGame.gameId = gameId;
        newGame.balance = pot;
        games[gameId] = newGame;
    
        emit GameCreated(gameId, player1, address(0));
        emit BalanceDeposited(player1, msg.value);
        return gameId;
    }
     /** 
     * @notice  permet au joueur 2 de rejoindre une partie existante identifié par gameId en effectuant une mise égale au montant de la mise
     * @dev     elle récupère les références de jeu, elle vérifie si la partie existe, est en attente de joueur et n'est pas déjà rejointe 
     * @dev     par un joueur, vérifie si le montant est égal à la mise...
     * @dev     si le montant envoyé par le joueur 2 dépasse la mise du jeu, le montant excédentaire lui est remboursé et la balance est mise à jour 
     * @dev     Mise à jour du solde du jeu en ajoutant le montant envoyé par le joueur 2 et enregistrement de l'adresse du joueur 2 dans le jeu 
     * @dev     et mise à jour du joueur 2 dans le contrat principal - changement du statut de la partie pour indiquer qu'elle attend un mot aléatoire
     * @dev     ajout du montant envoyé par le joueur 2 au solde du jeu
     * @dev     inversement des rôlms pour que le joueur 2 puisse jouer en premier
     * @param   _gameId l'identifiant du jeu auquel le joueur 2 souhaite se joindre
     */
    function joinGame(uint256 _gameId) external payable returns (bool) {
        Game storage game = games[_gameId];
        require(game.player1 != address(0), unicode"La partie avec l'ID spécifié n'existe pas");
        require(status == GameStatus.waitingForPlayers, "La partie n'est pas en attente de joueurs");
        require(msg.sender != player1, "Vous ne pouvez pas rejoindre votre propre partie");
        require(msg.value == game.balance, unicode"Le montant envoyé doit être égal à la mise du jeu");
        require(game.player2 == address(0), unicode"La partie est déjà rejointe par un joueur");
    
        uint256 refundAmount = 0;
        if (msg.value > game.balance) {
        refundAmount = msg.value - game.balance;
        (bool success, ) = payable(msg.sender).transfer{value: refundAmount}("");
        require(success, unicode"Le remboursement a échoué");
        }
        game.balance = game.balance - refundAmount;
    
        game.balance += msg.value;
        game.player2 = msg.sender;
        player2 = msg.sender;
        status = GameStatus.waitingForRandomWord;
    
        emit GameJoined(_gameId, player2, player1);
        emit PlayerSwitched(_gameId, player1, player2);
    
        return true;
    }
    /**
     * @notice  permet d'échanger les rôles des joueurs dans un jeu spécifié
     * @dev     la fonction est utilisée pour échanger les rôles des joueurs dans le jeu identifié par l'identifiant _gameId
     * @param   _gameId identifiant du jeu dans lequel les rôles des joueurs doivent être échangés
     */
    function playersSwitched(uint256 _gameId) private {
        Game storage game = games[_gameId];
        require(msg.sender == game.player1 || msg.sender == game.player2, unicode"Vous n'êtes pas un joueur dans ce jeu");
    
        address player1Address = game.player1;
        game.player1 = game.player2;
        game.player2 = player1Address;
        
        game.activePlayer = game.player1;
    
        emit PlayerSwitched(_gameId, game.player1, game.player2);
    }
    /**
     * @notice  permet d'obtenir l'adresse du joueur actif dans un jeu spécifique
     * @dev     elle est utilisée en interne par les fonctions setLetterGuess, setWordGuess
     * @dev     et endGame pour obtenir l'adresse du joueur actif en fonction de l'état du jeu
     * @dev     Si le nombre de mouvements est pair, cela signifie que le joueur 1 a déjà joué et 
     * @dev     c'est maintenant au tour du joueur 2. Si le nombre de mouvements est impair, c'est le tour du joueur 1
     * @param   _gameId identifiant du jeu pour lequel récupérer le joueur actif
     * @return  adresse du joueur actif. Si aucun joueur actif n'est trouvé ou si l'identifiant du jeu 
     *           est invalide, renvoie address(0).
     */
    function getActivePlayer(uint256 _gameId) internal view returns (address) {
        Game storage game = games[_gameId];
    
        if (game.player1 != address(0) && game.player2 == address(0)) {
            return game.player1;
        } else if (game.player1 != address(0) && game.player2 != address(0)) {
            if (game.status == GameStatus.waitingForRandomWord) {
                return address(this);
            } else if (game.status == GameStatus.inProgress) {
                if (game.turn % 2 == 0) {
                    require(msg.sender == game.player1, unicode"Vous n'êtes pas le joueur actif dans ce jeu");
                    return game.player1;
                } else {
                    require(msg.sender == game.player2, unicode"Vous n'êtes pas le joueur actif dans ce jeu");
                    return game.player2;
                }
            }
        }
        return address(0);
    }
    /**
     * @notice  permet de récupérer le nombre de mouvements effectués dans un jeu spécifié
     * @dev     elle renvoie le nombre de mouvements effectués dans le jeu spécifié, permettant
     * @dev     ainsi de suivre l'avancement du jeu et de déterminer quel joueur est censé jouer ensuite
     * @dev     elle est utilisée en interne par la fonction getActivePlayer 
     * @param   _gameId identifiant du jeu pour lequel récupérer le nombre de mouvements
     * @return  nombre de mouvements effectués dans le jeu spécifié
     */
    function turnPlayer(uint256 _gameId) internal view returns (uint256) {
        Game memory game = games[_gameId];
        return game.turn;
    }
    

    //PARTIE 5 /** * @notice permet de demander la génération de mots aléatoires à l'oracle Chainlink * @dev la fonction est accessible uniquement par le propriétaire du contrat * @dev elle utilise l'interface du Coordinateur Chainlink pour demander la génération de mots aléatoires * @dev l'identifiant de la demande est ensuite stocké dans le tableau requestIds et renvoyé en sortie de la fonction : * @return _requestId identifiant de la demande de génération de mots aléatoires / function requestRandomWords() public onlyOwner returns (uint256 _requestId) { requestId = COORDINATOR.requestRandomWords( keyHash, s_subscriptionId, requestConfirmations, callbackGasLimit, numWords ); requestIds.push(requestId); return requestId; } /* * @notice permet d'obtenir le mot filtré dans le jeu en utilisant les mots aléatoires générés * @dev la fonction est appelée par le service Oracle pour fournir les mots aléatoires demandés puis * @dev parcourt chaque mot aléatoire et le convertit en une représentation de chaine de caractères * @dev en appelant la fonction uint256ToString, elle filtre les caractères spéciaux dans le mot en appelant * @dev filterSpecialCharacter puis assigne le mot à la structure du jeu * @param _requestId identifiant de la demande pour laquelle les mots aléatoires sont générés * @param _randomWords mots aléatoires générés */ function fulfillRandomWords(uint256 _requestId, uint256[] memory _randomWords) internal override { requestIds.push(_requestId);

        for (uint256 i = 0; i < _randomWords.length; i++) {
            word = _randomWords[i];
            games[_requestId].word = Wordlist;
        }
    }
    

    }"

  2. Assistant

    Voici le code complété et corrigé avec les fonctions "requestRandomWords" et "fulfillRandomWords":

    // SPDX-License-Identifier: UNLICENSED
    pragma solidity 0.8.17;
    
    import "../node_modules/@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
    import "../node_modules/@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
    
    contract Penduel is VRFConsumerBaseV2 {
    
        // ...
    
        // Modifier cette fonction pour utiliser le modificateur onlyOwner
        function requestRandomWords() public onlyOwner returns (uint256 _requestId) {
            // Modifier pour utiliser le modificateur onlyOwner
            _requestId = COORDINATOR.requestRandomWords(
                keyHash,
                s_subscriptionId,
                requestConfirmations,
                callbackGasLimit,
                numWords
            );
            requestIds.push(_requestId);
        }
    
        // Modifier cette fonction pour qu'elle soit appelée par fulfillRandomWords de VRFConsumerBaseV2
        function fulfillRandomWords(uint256 _requestId, uint256[] memory _randomWords) internal override {
            requestIds.push(_requestId);
    
            for (uint256 i = 0; i < _randomWords.length; i++) {
                word = uint256ToString(_randomWords[i]);
                filterSpecialCharacter();
    
                games[_requestId].word = wordList[_requestId];
            }
        }
    
        // Ajouter cette fonction pour convertir les uint256 en chaîne de caractères
        function uint256ToString(uint256 value) internal pure returns (string memory) {
            if (value == 0) {
                return "0";
            }
            uint256 temp_value = value;
            uint256 digits;
            while (temp_value != 0) {
                digits++;
                temp_value /= 10;
            }
            bytes memory buffer = new bytes(digits);
            while (value != 0) {
                digits -= 1;
                buffer[digits] = bytes1(uint8(48 + value % 10));
                value /= 10;
            }
            return string(buffer);
        }
    
        // Ajouter cette fonction pour filtrer les caractères spéciaux dans le mot
        function filterSpecialCharacter() internal {
            bytes memory wordBytes = bytes(word);
            bytes memory filteredBytes = new bytes(wordBytes.length);
    
            uint256 index;
            for (uint256 i = 0; i < wordBytes.length; i++) {
                if (wordBytes[i] >= "A" && wordBytes[i] <= "Z" || wordBytes[i] >= "a" && wordBytes[i] <= "z") {
                    filteredBytes[index++] = wordBytes[i];
                }
            }
    
            // Enregistrez le mot filtré dans la liste des mots
            wordList.push(string(abi.encodePacked(filteredBytes)));
        }
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.