ADD:reveal bid function added and test passed

Author: TheCreatorNode

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "editor.inlineSuggest.suppressSuggestions": true
+}

src/blindAuction.sol

@@ -10,25 +10,27 @@ contract blindAuction is Ownable{
     }
 
     uint256 public constant BIDDING_DURATION = 10 hours;
-    uint256 public revealTime;
+    uint256 public constant REVEAL_DURATION = 1 hours;
     uint256 public auctionEndTime;
     uint256 public revealEndTime;
     uint256 public highestBid;
-    uint256 public highestBidder;
+    address public highestBidder;
     bool public ended;
     address payable public beneficiary;
-    uint256 public minimumDeposit;
+    uint256 public constant MINIMUM_DEPOSIT = 4 ether;
 
-    mapping (address => Bid[]) bids;
-    mapping (address => uint256) public revealedBid;
+    mapping (address => Bid[]) public bids;
+    mapping (address => Bid[]) public revealedBid;
     mapping (address => uint256) public pendingReturns;
 
     event bidSubmitted(address bidder);
     event auctionHasEnded(address winner, uint256 highestBid);
+    event bidRevealed(address caller, uint256 bid);
 
     error tooEarly();
     error tooLate();
     error invalidDeposit();
+    error lengthMismatch();
 
     constructor(
         address payable  _beneficiary
@@ -37,19 +39,52 @@ contract blindAuction is Ownable{
         _transferOwnership(_beneficiary);
 
         auctionEndTime = block.timestamp + BIDDING_DURATION;
-        revealEndTime =  auctionEndTime + revealTime;
+        revealEndTime =  auctionEndTime + REVEAL_DURATION;
     }
 
     function bid(bytes32 _blindedBid) external payable { 
             if(!(block.timestamp < auctionEndTime)) revert tooEarly();
-            if( msg.value <= 5 ether) revert invalidDeposit();
+            if( msg.value <= MINIMUM_DEPOSIT) revert invalidDeposit();
 
             bids[msg.sender].push(Bid({
                 blindedBid: _blindedBid,
                 deposit: msg.value
             }));
     }
+    function revealBid(
+        uint256[] calldata value,
+        bool[] calldata fake,
+        bytes32[] calldata secret
+    ) external {
+        if(block.timestamp < auctionEndTime) revert tooEarly();
+        if(block.timestamp > revealEndTime) revert tooLate();
 
+        uint256 length = bids[msg.sender].length;
+
+        if(value.length != length) revert lengthMismatch();
+        if(fake.length != length) revert lengthMismatch();
+        if(secret.length != length) revert lengthMismatch();
+
+        for (uint i = 0; i < length; i++){
+            Bid storage bitToReveal = bids[msg.sender][i];
+            bytes32 calculatedHash = keccak256(abi.encodePacked(value[i], fake[i], secret[i]));
+
+            if(calculatedHash == bitToReveal.blindedBid && bitToReveal.deposit >= MINIMUM_DEPOSIT) {
+
+                if(!fake[i] && value[i] > highestBid){
+                    if(highestBidder != address(0)){
+                        pendingReturns[address(uint160(msg.sender))] += highestBid;
+                    }
+
+                    highestBid = value[i];
+                    highestBidder = msg.sender;
+                }
+
+                 bids[msg.sender] = revealedBid[msg.sender];
+            }
+            emit bidRevealed(msg.sender, highestBid);
+        }
+    }
 
 
 } 

test/blindAuction.t.sol

@@ -12,7 +12,66 @@ contract testBlindAuction is Test{
      address public bidder2 = address(0x3);
 
      function setUp() public {
+       vm.warp(100);
+
         vm.prank(beneficiary);
+        beneficiary = payable(address(0x1));
+         vm.deal(beneficiary, 10 ether);
         auction = new blindAuction( beneficiary);
      }
-}
+
+     function testBid() public {
+        vm.deal(bidder1, 10 ether);
+        vm.prank(bidder1);
+        uint value = 7 ether;
+        bool fake = false;
+        bytes32 secret = keccak256(abi.encodePacked("mySecret"));
+        bytes32 blindedBid = keccak256(abi.encodePacked(value, fake, secret));
+
+         auction.bid{value: 5 ether}(blindedBid);
+         // Access the value field from the tuple (assuming bids returns array of (uint256 value, bytes32 blindedBid))
+         (uint256 deposit, ) = auction.bids(bidder1, 0);
+         assertEq(deposit, 5 ether, "Bid value should be 5 ether");
+     }
+     function testBidFail() public {
+          vm.deal(bidder2, 10 ether);
+          vm.prank(bidder2);
+          uint value = 7 ether;
+        bool fake = false;
+        bytes32 secret = keccak256(abi.encodePacked("mySecret"));
+        bytes32 blindedBid = keccak256(abi.encodePacked(value, fake, secret));
+
+      
+        vm.expectRevert(blindAuction.invalidDeposit.selector);
+          auction.bid{value: 3 ether}(blindedBid);
+     }
+     
+
+      function testRevealBid() public{
+        vm.deal(bidder1, 15 ether);
+        vm.prank(bidder1);
+        
+        uint value = 7 ether;
+        bool fake = false;
+        bytes32 secret = keccak256(abi.encodePacked("mySecret"));
+        bytes32 blindedBId = keccak256(abi.encodePacked(value, fake, secret));
+
+        auction.bid{value: 5 ether}(blindedBId);
+
+        vm.warp(auction.auctionEndTime() + 1);
+        
+        uint256 [] memory values = new uint256[](1);
+        bool [] memory fakes = new bool[](1);
+        bytes32 [] memory secrets = new bytes32[](1);
+
+        values[0] = value;
+        fakes[0] = fake;
+        secrets[0] = secret;
+        
+        vm.prank(bidder1);
+        auction.revealBid(values, fakes, secrets);
+
+        assertEq(auction.highestBid(), 7 ether);
+      }
+}
+