Merge pull request #21 from EYBlockchain/Jiajie/de-register-proposer

Jiajie/de register proposer

Author: jiajieey

Cargo.lock

@@ -511,6 +511,7 @@ contract Nightfall is
 
             // Load the hashed value and shift right by 4 bits
             result := shr(4, mload(freePtr))
+            
         }
     }
 

blockchain_assets/contracts/Nightfall.sol

@@ -3,42 +3,75 @@ pragma solidity ^0.8.20;
 
 import "./ProposerManager.sol";
 import "./Nightfall.sol";
+import "./X509/Certified.sol";
+
+
 /// @title Proposers
 /// @notice An Round-Robin implementation for choosing proposers
 
-contract RoundRobin is ProposerManager {
+contract RoundRobin is ProposerManager, Certified {
+
     mapping(address => Proposer) public proposers;
     mapping(address => uint) public pending_withdraws;
     mapping(string => bool) public proposer_urls;
+    // When a proposer voluntarily deregisters:
+    // Record the block number. Enforce that they cannot reregister until a certain COOLDOWN_BLOCKS window has passed.
+    mapping(address => uint) public last_exit_block;
     Proposer private current;
     uint public start_l1_block;
     int public start_l2_block;
     uint public proposer_count;
     uint public immutable STAKE;
     uint public immutable DING;
+    // When the current proposer voluntarily deregisters, a small but nontrivial penalty is deducted.
+    uint public immutable EXIT_PENALTY;
+    // This is the number of blocks that must pass before a proposer can reregister after exiting
+    uint public immutable COOLDOWN_BLOCKS; 
     uint public immutable ROTATION_BlOCKS;
     uint public escrow = 0;
     Nightfall private nightfall;
-    address private owner;
+
+    // instance of the certified contract
+    Certified private certified;
 
     modifier only_owner() {
         require(msg.sender == owner, "Only the owner can call this function");
         _;
     }
 
     constructor(
+        address x509_address,
+        address sanctionsListAddress,
         address default_proposer_address,
         string memory default_proposer_url,
         uint stake,
         uint ding,
+        uint exit_penalty,
+        uint cooling_blocks,
         uint rotation_blocks
-    ) payable {
+    ) 
+        Certified(
+            X509Interface(x509_address),
+            SanctionsListInterface(sanctionsListAddress)
+        )
+        payable 
+    {
         STAKE = stake;
         DING = ding;
+        EXIT_PENALTY = exit_penalty;
+        COOLDOWN_BLOCKS = cooling_blocks;
+        require(
+            cooling_blocks > 0,
+            "Cooling blocks must be greater than zero"
+        );
+        require(
+            stake >= exit_penalty,
+            "Stake must be greater than exit penalty"
+        );
         ROTATION_BlOCKS = rotation_blocks;
         require(
             msg.value == STAKE,
-            "You have not paid the correct staking amount"
+            "You have not paid the correct staking amount during deployment"
         );
         current = Proposer({
             stake: STAKE,
@@ -47,10 +80,20 @@ contract RoundRobin is ProposerManager {
             next_addr: default_proposer_address,
             previous_addr: default_proposer_address
         });
+        escrow += STAKE;
         proposers[default_proposer_address] = current;
         proposer_urls[default_proposer_url] = true;
         proposer_count = 1;
-        owner = msg.sender;
+    }
+
+    function set_x509_address(address x509_address) external onlyOwner {
+        x509 = X509(x509_address);
+    }
+
+    function set_sanctions_list(
+        address sanctionsListAddress
+    ) external onlyOwner {
+        sanctionsList = SanctionsListInterface(sanctionsListAddress);
     }
 
     // we set the nightfall contract address later because we probably don't know it at the time of deployment
@@ -69,10 +112,14 @@ contract RoundRobin is ProposerManager {
 
     function add_proposer(
         string calldata proposer_url
-    ) external payable override {
+    ) external payable override onlyCertified{
+        // Enforce cooldown only if they have previously exited
+        if (last_exit_block[msg.sender] != 0) {
+            require(block.number > last_exit_block[msg.sender] + COOLDOWN_BLOCKS, "Cooldown period not met");
+        }
         require(
             msg.value == STAKE,
-            "You have not paid the correct staking amount"
+            "You have not paid the correct staking amount during registration"
         );
         require(
             proposers[msg.sender].addr == address(0),
@@ -83,6 +130,7 @@ contract RoundRobin is ProposerManager {
             "This proposer URL is already in use"
         );
         escrow += STAKE;
+
         // we add the new proposer behind the current proposer, so it will be the last to be called for
         // first, insert its address in the linked list
         address current_address = current.addr;
@@ -126,10 +174,26 @@ contract RoundRobin is ProposerManager {
             proposer_address != address(0),
             "The proposer address cannot be zero"
         );
-        require(
-            proposer_address != current.addr,
-            "You cannot remove the current proposer"
+        if (msg.sender == current.addr) {
+            require(
+            proposer_count > 1,
+            "Cannot deregister the only active proposer"
+        );
+            require(
+            proposers[proposer_address].stake >= EXIT_PENALTY, 
+            "Insufficient stake for exit"
         );
+
+        proposers[proposer_address].stake -= EXIT_PENALTY;
+        escrow -= EXIT_PENALTY;
+
+        // Rotate to the next proposer before removing
+        current = proposers[current.next_addr];
+        start_l1_block = block.number;
+        start_l2_block = nightfall.layer2_block_number();
+
+        last_exit_block[proposer_address] = block.number;
+        }
         Proposer storage this_proposer = proposers[proposer_address]; // don't forget these only create references
         Proposer storage next_proposer = proposers[this_proposer.next_addr];
         Proposer storage previous_proposer = proposers[
@@ -195,5 +259,6 @@ contract RoundRobin is ProposerManager {
             return;
         }
         proposer.stake = uint(new_stake);
+        escrow -= DING;
     }
 }

blockchain_assets/contracts/RoundRobin.sol

@@ -7,7 +7,7 @@ import './DerParser.sol';
 import './Allowlist.sol';
 import './X509Interface.sol';
 import './Sha.sol';
-
+import "forge-std/console2.sol";
 contract X509 is DERParser, Allowlist, Sha, X509Interface {
     uint256 constant SECONDS_PER_DAY = 24 * 60 * 60;
     int256 constant OFFSET19700101 = 2440588;
@@ -31,6 +31,9 @@ contract X509 is DERParser, Allowlist, Sha, X509Interface {
     mapping(bytes32 => RSAPublicKey) trustedPublicKeys;
     mapping(bytes32 => bool) revokedKeys;
     mapping(address => bytes32) keysByUser;
+    // Reverse mapping to ensure one certificate is tied to one address
+    mapping(bytes32 => address) addressByKey; 
+
     bytes32[][] extendedKeyUsageOIDs; // this is an array of arrays because each CA has their own set of OIDs that they use
     bytes32[][] certificatePoliciesOIDs; // this is an array of arrays because each CA has their own set of OIDs that they use
 
@@ -412,6 +415,10 @@ contract X509 is DERParser, Allowlist, Sha, X509Interface {
         uint256 expiry = checkDates(tlvs);
         RSAPublicKey memory certificatePublicKey = extractPublicKey(tlvs);
         bytes32 subjectKeyIdentifier = extractSubjectKeyIdentifier(tlvs);
+        console2.log(
+            'X509: Subject Key Identifier: %s',
+            uint256(subjectKeyIdentifier)
+        );
         require(
             !revokedKeys[subjectKeyIdentifier],
             'X509: The subject key of this certificate has been revoked'
@@ -437,11 +444,24 @@ contract X509 is DERParser, Allowlist, Sha, X509Interface {
         checkCertificatePolicies(tlvs, oidGroup);
         // // If we get here, we're good so add this user to the allowlist data, unless we're only checking the certificate.
         if (!checkOnly) {
+            // Ensure one certificate is tied to one address and vice versa
+            require(
+                keysByUser[addr] == bytes32(0) || keysByUser[addr] == subjectKeyIdentifier,
+                'X509: This address is already linked to a different certificate'
+            );
+            require(
+                addressByKey[subjectKeyIdentifier] == address(0) || addressByKey[subjectKeyIdentifier] == addr,
+                'X509: This certificate is already linked to a different address'
+            );
             // Before we finally add the address to the allowlist, just check that the sender of the allowlist request actually owns the
             // end user cert.  We do this by getting them to sign the Ethereum address they want allowlisted.
             checkSignature(addressSignature, abi.encodePacked(uint160(addr)), certificatePublicKey);
             expires[addr] = expiry;
             keysByUser[addr] = subjectKeyIdentifier;
+
+            // RECORD reverse mapping for one-to-one binding
+            addressByKey[subjectKeyIdentifier] = addr; 
+
             addUserToAllowlist(addr); // all checks have passed, so they are free to trade for now.
         }
     }
@@ -472,6 +492,11 @@ contract X509 is DERParser, Allowlist, Sha, X509Interface {
         );
         revokedKeys[subjectKeyIdentifier] = true;
         delete trustedPublicKeys[subjectKeyIdentifier];
+
+        // CLEANUP: remove bidirectional binding when revoked
+        address addr = addressByKey[subjectKeyIdentifier];
+        delete keysByUser[addr];
+        delete addressByKey[subjectKeyIdentifier];
     }
 
     /** 
@@ -495,5 +520,10 @@ contract X509 is DERParser, Allowlist, Sha, X509Interface {
         );
         revokedKeys[subjectKeyIdentifier] = true;
         delete trustedPublicKeys[subjectKeyIdentifier];
+
+        // CLEANUP: remove bidirectional binding when revoked
+        address addr = addressByKey[subjectKeyIdentifier];
+        delete keysByUser[addr];
+        delete addressByKey[subjectKeyIdentifier];
     }
-}
+}