Hook up ERC20 token and payout fnction

Author: czechdave

contracts/GoldenProtocol.sol

@@ -2,20 +2,35 @@
 pragma solidity ^0.8.16;
 
 import '@openzeppelin/contracts/access/Ownable.sol';
-
+import './GoldenToken.sol';
 import './libraries/AddressSet.sol';
 
 /// @custom:security-contact security@golden.com
 contract GoldenProtocol is Ownable {
-    using AddressSet for AddressSet.Set;
-    // This is not going to scale well... how to keep track of questions without this?
-    AddressSet.Set _questions;
+    GoldenToken tokenContract;
+    uint256 public minimumBounty;
     uint256 public minimumVotes;
 
-    constructor(uint256 _minimumVotes) Ownable() {
+    event QuestionCreated(
+        address indexed questionAddress,
+        bytes16 subjectUUID,
+        bytes16 predicateUUID
+    );
+
+    constructor(
+        address goldenTokenAddress,
+        uint256 _minimumBounty,
+        uint256 _minimumVotes
+    ) Ownable() {
+        tokenContract = GoldenToken(goldenTokenAddress);
+        minimumBounty = _minimumBounty;
         minimumVotes = _minimumVotes;
     }
 
+    function setMinimumBounty(uint256 _minimumBounty) external onlyOwner {
+        minimumBounty = _minimumBounty;
+    }
+
     function setMinimumVotes(uint256 _minimumVotes) public onlyOwner {
         minimumVotes = _minimumVotes;
     }
@@ -25,30 +40,33 @@ contract GoldenProtocol is Ownable {
         bytes16 predicateUUID,
         uint256 bounty
     ) public returns (address) {
+        require(bounty >= minimumBounty, 'GoldenProtocol: bounty is too low');
+        require(
+            tokenContract.allowance(_msgSender(), address(this)) >= bounty,
+            'GoldenProtocol: insufficient allowance'
+        );
+
         // TODO: Creating new contracts is going to be very expensive.
         // Is there a cheaper alternative to encapsulate the question logic?
         GoldenProtocolQuestion newQuestion = new GoldenProtocolQuestion(
+            address(tokenContract),
             msg.sender,
             subjectUUID,
-            predicateUUID,
-            bounty
+            predicateUUID
         );
         address newQuestionAddress = address(newQuestion);
-        _questions.insert(newQuestionAddress);
+        tokenContract.transferFrom(_msgSender(), newQuestionAddress, bounty);
+        emit QuestionCreated(newQuestionAddress, subjectUUID, predicateUUID);
         return newQuestionAddress;
     }
-
-    // TODO: This is not going to scale well... how to keep track of questions without this?
-    function questions() public view returns (address[] memory) {
-        return _questions.keyList;
-    }
 }
 
 contract GoldenProtocolQuestion is Ownable {
+    GoldenToken tokenContract;
+
     using AddressSet for AddressSet.Set;
 
     address public asker;
-    uint256 public bounty;
     bytes16 public subjectUUID;
     bytes16 public predicateUUID;
     string public answer;
@@ -72,28 +90,38 @@ contract GoldenProtocolQuestion is Ownable {
         uint256 voteCount;
     }
 
+    event AnswerAdded(
+        bytes16 subjectUUID,
+        bytes16 predicateUUID,
+        string answer,
+        uint256 index
+    );
+
     constructor(
+        address goldenTokenAddress,
         address _asker,
         bytes16 _subjectUUID,
-        bytes16 _predicateUUID,
-        uint256 _bounty
+        bytes16 _predicateUUID
     ) Ownable() {
         require(
             _asker != address(0),
             'GoldenProtocolQuestion: asker is the zero address'
         );
-
+        tokenContract = GoldenToken(goldenTokenAddress);
         asker = _asker;
         subjectUUID = _subjectUUID;
         predicateUUID = _predicateUUID;
-        bounty = _bounty;
     }
 
     modifier onlyAsker() {
         require(msg.sender == asker, 'GoldenProtocolQuestion: onlyAsker');
         _;
     }
 
+    function bounty() public view returns (uint256) {
+        return tokenContract.balanceOf(address(this));
+    }
+
     function addAnswer(string calldata _answer) public {
         require(
             bytes(_answer).length > 0,
@@ -104,6 +132,12 @@ contract GoldenProtocolQuestion is Ownable {
         answerByAnswerer[answerer] = _answer;
         answerers.upsert(answerer);
         voteCountByAnswerer[answerer] = 0;
+        emit AnswerAdded(
+            subjectUUID,
+            predicateUUID,
+            _answer,
+            answerers.indexOfKey(answerer)
+        );
     }
 
     function answers() public view returns (Answer[] memory) {
@@ -159,7 +193,10 @@ contract GoldenProtocolQuestion is Ownable {
         );
         answer = _topAnswer.answer;
         address payable answerer = payable(_topAnswer.answerer);
-        answerer.transfer(bounty);
+        tokenContract.transfer(
+            answerer,
+            tokenContract.balanceOf(address(this))
+        );
     }
 
     // Utils

contracts/GoldenToken.sol

@@ -28,13 +28,13 @@ contract GoldenToken is
     ) internal override {
         super._beforeTokenTransfer(from, to, amount);
 
-        require(
-            (from == address(0) ||
-                from == owner() ||
-                from == address(this) ||
-                to == address(this)),
-            'ERC20: Not allowed to transfer'
-        );
+        // require(
+        //     (from == address(0) ||
+        //         from == owner() ||
+        //         from == address(this) ||
+        //         to == address(this)),
+        //     'ERC20: Not allowed to transfer'
+        // );
     }
 
     // ============ Staking ============

contracts/libraries/AddressSet.sol

@@ -58,4 +58,12 @@ library AddressSet {
     {
         return self.keyList[index];
     }
+
+    function indexOfKey(Set storage self, address key)
+        internal
+        view
+        returns (uint256)
+    {
+        return self.keyPointers[key];
+    }
 }

deploy/0_GoldenProtocol.ts renamed to deploy/999_GoldenProtocol.ts

@@ -6,15 +6,18 @@ const deploy: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
 
   const { deployer } = await getNamedAccounts();
 
+  const GoldenTokenDeployment = await deployments.get('GoldenToken');
+
   await deployments.deploy('GoldenProtocol', {
     from: deployer,
     // skipIfAlreadyDeployed: true,
-    args: [3],
+    args: [GoldenTokenDeployment.address, 3, 10],
     log: true,
   });
 };
 
 deploy.id = 'deploy_golden_protocol';
 deploy.tags = ['GoldenProtocol'];
+deploy.dependencies = ['GoldenToken'];
 
 export default deploy;