diff --git a/scripts/DeployHamzaVault.s.sol b/scripts/DeployHamzaVault.s.sol
index fde09a5..7fe618b 100644
--- a/scripts/DeployHamzaVault.s.sol
+++ b/scripts/DeployHamzaVault.s.sol
@@ -243,7 +243,7 @@ contract DeployHamzaVault is Script {
         bytes[] memory initActions = prepareBaalInitActions(pauseSharesOnInit, pauseLootOnInit, sharesToMintForSafe, vault);
 
         // 8) Summon Baal
-        newBaalAddr = summoner.summonBaal(initParams, initActions, uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 100);
+        newBaalAddr = summoner.summonBaal(initParams, initActions, uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao))) % 100);
 
         // fetch loot token address (Baal's "loot token")
         lootTokenAddr = address(Baal(newBaalAddr).lootToken());
diff --git a/test/Voting.t.sol b/test/Voting.t.sol
index e55c7d7..1984350 100644
--- a/test/Voting.t.sol
+++ b/test/Voting.t.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.17;
 
-import "forge-std/Test.sol";
+import "./DeploymentSetup.t.sol";
 import "@hamza-escrow/security/HatsSecurityContext.sol";
 import "../src/tokens/GovernanceToken.sol";
 import "../src/HamzaGovernor.sol";
@@ -11,39 +11,21 @@ import "@openzeppelin/contracts/governance/TimelockController.sol";
 import { HamzaGovernor } from "../src/HamzaGovernor.sol";
 import { Hats } from "@hats-protocol/Hats.sol";
 
-//TODO: inherit from DeploymentSetup
-contract VotingTest is Test {
-    HatsSecurityContext securityContext;
-    GovernanceToken govToken;
-    HamzaGovernor governor;
-    TestToken lootToken;
-    SystemSettings systemSettings;
-    TimelockController timelock;
+contract VotingTest is DeploymentSetup {
     string proposalDescription = "Test Proposal";
 
-    address admin;
     address[] voters;
     address[] targets;
     uint256[] values;
     bytes[] calldatas;
+    address noVotingRightsAddr;
 
-    uint256 public adminHatId;
-
-    enum ProposalState {
-        Pending,
-        Active,
-        Canceled,
-        Defeated,
-        Succeeded,
-        Queued,
-        Expired,
-        Executed
-    }
 
-    function setUp() public {
-        address[] memory empty;
+    function setUp() public override {
+        // Call DeploymentSetup's setUp function first
+        super.setUp();
 
-        admin = address(0x12);
+        // Initialize voters
         voters.push(address(0x13));
         voters.push(address(0x14));
         voters.push(address(0x15));
@@ -53,199 +35,151 @@ contract VotingTest is Test {
         voters.push(address(0x19));
         voters.push(address(0x20));
         voters.push(address(0x21));
+        
+        // Add an address that won't have voting rights
+        noVotingRightsAddr = address(0x22);
+        
+        // Use the existing securityContext, lootToken, and govToken from DeploymentSetup
+        HatsSecurityContext securityContextLocal = HatsSecurityContext(hatsCtx);
+        TestToken lootTokenLocal = TestToken(lootToken);
+        GovernanceToken govTokenLocal = GovernanceToken(govToken);
 
-        //security context
-        securityContext = createHatsSecurityContext();
-
-        //create tokens & mint
-        lootToken = new TestToken("LOOT", "LOOT");
-        govToken = new GovernanceToken(securityContext, lootToken, "Hamg", "HAMG");
-
-        //mint tokens 
+        // Mint loot tokens to voters
         for(uint256 n=0; n<voters.length; n++) {
-            lootToken.mint(voters[n], 100);
+            vm.startPrank(baal);
+            lootTokenLocal.mint(voters[n], 100);
+            vm.stopPrank();
         }
 
-        vm.startPrank(admin);
-        
-        // deploy main contracts
-        timelock = new TimelockController(1, empty, empty, admin);
-        governor = new HamzaGovernor(govToken, timelock);
-        systemSettings = new SystemSettings(securityContext, admin, 0);
-
-        //grant permissions for governor
-        timelock.grantRole(keccak256("EXECUTOR_ROLE"), address(governor));
-        timelock.grantRole(0xb09aa5aeb3702cfd50b6b62bc4532604938f21248a27a1d5ca736082b6819cc1, address(governor));
-
-        // 1) Grab the Hats protocol reference & adminHatId from our security context
-        Hats hats = Hats(securityContext.hats()); 
-
-        // 2) Create new child-hats as needed for tests
-        uint256 daoHatId = hats.getNextId(adminHatId);
-        hats.createHat(
-            adminHatId,
-            "DAO Hat",   // optional name
-            2,          // maxSupply
-            address(1), // eligibility module (none in this simple test)
-            address(1), // toggle module (none in this simple test)
-            true,       // mutable
-            ""          // details
-        );
-        uint256 minterHatId = hats.getNextId(adminHatId);
-        hats.createHat(
-            adminHatId,
-            "Minter Hat",   // optional name
-            uint32(voters.length),      // maxSupply
-            address(1), // eligibility module (none in this simple test)
-            address(1), // toggle module (none in this simple test)
-            true,       // mutable
-            ""          // details
-        );
-
-        // 3) Assign roles to hats
-        securityContext.setRoleHat(Roles.DAO_ROLE, daoHatId);
-        securityContext.setRoleHat(Roles.MINTER_ROLE, minterHatId);
-
-        // 4) Mint the hats
-        hats.mintHat(daoHatId, address(timelock));
+        // Mint hats to voters
+        vm.startPrank(safe);
+        Hats hats = Hats(securityContextLocal.hats());
+        uint256 minterHatId = script.minterHatId();
+
         for(uint8 n=0; n<voters.length; n++) {
             hats.mintHat(minterHatId, voters[n]);
         }
+        vm.stopPrank();
 
-        //prepare proposal data
-        targets.push(address(systemSettings));
+        // Prepare proposal data
+        targets.push(systemSettings);
         values.push(uint256(0));
         calldatas.push(abi.encodeWithSignature("setFeeBps(uint256)", 1));
 
-        vm.stopPrank();
-
+        // Have all voters deposit their tokens to get governance rights
         for(uint8 n=0; n<voters.length; n++) {
             vm.startPrank(voters[n]);
-            lootToken.approve(address(govToken), 100);
-            govToken.depositFor(voters[n], 100);
+            lootTokenLocal.approve(govToken, 100);
+            govTokenLocal.depositFor(voters[n], 100);
             vm.stopPrank();
         }
     }
 
-    function createHatsSecurityContext() internal returns (HatsSecurityContext) {
-        address hatsAddress = 0x3bc1A0Ad72417f2d411118085256fC53CBdDd137;
-        Hats hats = Hats(hatsAddress);
-        adminHatId = uint256(hats.lastTopHatId()) << 224;
-        // mint top-hat to admin
-        hats.mintTopHat(admin, "ipfs://bafkreih3vqseitn7pijlkl2jcawbjrhae3dfb2pakqtgd4epvxxfulwoqq","");
-        adminHatId = uint256(hats.lastTopHatId()) << 224;
-
-        securityContext = new HatsSecurityContext(hatsAddress, adminHatId);
-
-
-        return securityContext;
-    }
-
     function vote(address addr, uint256 proposal, uint8 support) internal {
         vm.startPrank(addr);
-        governor.castVote(proposal, support);
+        HamzaGovernor(governor).castVote(proposal, support);
         vm.stopPrank();
     }
     
     function testProposeVote() public {
-        //make a proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
+        // Make a proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
 
-        //test proposal
+        // Test proposal
         assertGt(proposal, 0);
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Pending));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Pending));
         
-        //roll fwd
-        vm.roll(block.number +2);
+        // Roll forward
+        vm.roll(block.number + 2);
 
-        //state here should be active 
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        // State here should be active 
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
     }
     
     function testVote() public {
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
 
-        //let everyone vote for
+        // Let everyone vote for
         for(uint8 n=0; n<voters.length; n++) {
             vote(voters[n], proposal, 1);
         }
 
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
         vm.warp(block.timestamp + 50401);
 
-        //assert number of votes & checkpoints
+        // Assert number of votes & checkpoints
         for(uint8 n=0; n<voters.length; n++) {
-            assertEq(govToken.getVotes(voters[n]), 100);
+            assertEq(GovernanceToken(govToken).getVotes(voters[n]), 100);
         }
         for(uint8 n=0; n<voters.length; n++) {
-            assertEq(govToken.numCheckpoints(voters[n]), 1);
+            assertEq(GovernanceToken(govToken).numCheckpoints(voters[n]), 1);
         }
 
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Succeeded));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
     }
     
     function testUnanimousVoteDefeat() public {
-        assertEq(systemSettings.feeBps(), 0);
-        vm.roll(block.number +1);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
+        vm.roll(block.number + 1);
         
-        //create proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
 
-        //let everyone vote agin
+        // Let everyone vote against
         for(uint8 n=0; n<voters.length; n++) {
             vote(voters[n], proposal, 0);
         }
 
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
 
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Defeated));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Defeated));
         vm.warp(block.timestamp + 999999);
 
-        assertEq(systemSettings.feeBps(), 0);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
     }
     
     function testNonUnanimousVoteDefeat() public {
-        assertEq(systemSettings.feeBps(), 0);
-        vm.roll(block.number +1);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
+        vm.roll(block.number + 1);
         
-        //create proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
 
-        //let this guy vote for
+        // Let this guy vote for
         vote(voters[0], proposal, 1);
 
-        //let everyone else vote agin
+        // Let everyone else vote against
         for(uint8 n=1; n<voters.length; n++) {
             vote(voters[n], proposal, 0);
         }
 
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
 
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Defeated));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Defeated));
         vm.warp(block.timestamp + 999999);
 
-        assertEq(systemSettings.feeBps(), 0);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
     }
     
     function testNonUnanimousVoteExecute() public {
-        assertEq(systemSettings.feeBps(), 0);
-        vm.roll(block.number +1);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
+        vm.roll(block.number + 1);
         
-        //create proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
 
-        //let everyone vote for
+        // Let everyone vote for or against in alternating pattern
         for(uint8 n=0; n<voters.length; n++) {
             if (n % 2 == 0)
                 vote(voters[n], proposal, 1);
@@ -253,88 +187,257 @@ contract VotingTest is Test {
                 vote(voters[n], proposal, 0);
         }
 
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
 
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Succeeded));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
         vm.warp(block.timestamp + 999999);
 
-        // queue 
-        governor.queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        // Queue 
+        HamzaGovernor(governor).queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
 
         vm.warp(block.timestamp + 2);
 
-        governor.execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Executed));
+        HamzaGovernor(governor).execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Executed));
 
-        assertEq(systemSettings.feeBps(), 1);
+        assertEq(SystemSettings(systemSettings).feeBps(), 1);
     }
     
     function testProposalVote() public {
-        assertEq(systemSettings.feeBps(), 0);
-        vm.roll(block.number +1);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
+        vm.roll(block.number + 1);
         
-        //create proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
-
-        //vote(voters[0], proposal, 1);
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
         
         for(uint8 n=0; n<voters.length; n++) {
             vote(voters[n], proposal, 1);
         }
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
 
-
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Succeeded));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
         vm.warp(block.timestamp + 999999);
 
-        // queue
-        governor.queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        // Queue
+        HamzaGovernor(governor).queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
 
         vm.warp(block.timestamp + 2);
 
-        governor.execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Executed));
+        HamzaGovernor(governor).execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Executed));
 
-        assertEq(systemSettings.feeBps(), 1);
+        assertEq(SystemSettings(systemSettings).feeBps(), 1);
     }
     
     function testVoteQueue() public {
-        assertEq(systemSettings.feeBps(), 0);
-        vm.roll(block.number +1);
+        assertEq(SystemSettings(systemSettings).feeBps(), initialFeeBps);
+        vm.roll(block.number + 1);
         
-        //create proposal
-        uint256 proposal = governor.propose(targets, values, calldatas, proposalDescription);
-        vm.roll(block.number +2);
-        assertEq(uint256(governor.state(proposal)), uint(ProposalState.Active));
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
 
-        //let everyone vote for
+        // Let everyone vote for
         for(uint8 n=0; n<voters.length; n++) {
             vote(voters[n], proposal, 1);
         }
 
-        //roll forward
-        vm.roll(block.number +50401);
+        // Roll forward
+        vm.roll(block.number + 50401);
 
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Succeeded));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
         vm.warp(block.timestamp + 999999);
 
-        //queue the proposal 
-        governor.queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Queued));
+        // Queue the proposal 
+        HamzaGovernor(governor).queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Queued));
 
-        //and then wait 
-        vm.roll(block.number +50401);
+        // And then wait 
+        vm.roll(block.number + 50401);
         vm.warp(block.timestamp + 50401);
 
-        // and then execute
-        governor.execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
-        assertEq(uint256(governor.state(proposal)), uint256(ProposalState.Executed));
+        // And then execute
+        HamzaGovernor(governor).execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Executed));
+
+        // The fee has been changed at this point
+        assertEq(SystemSettings(systemSettings).feeBps(), 1);
+    }
+    
+    // Test abstain votes (support = 2) behavior
+    function testAbstainVotes() public {
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        // Let half vote for
+        for(uint8 n=0; n<voters.length/2; n++) {
+            vote(voters[n], proposal, 1);
+        }
+        
+        // Let half abstain (support = 2)
+        for(uint8 n=uint8(voters.length/2); n<voters.length; n++) {
+            vote(voters[n], proposal, 2);
+        }
+        
+        vm.roll(block.number + 50401);
+        
+        // Proposal should succeed because abstain votes count toward quorum but not against
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
+    }
+    
+    // Test quorum requirement - make sure we need 4% of total votes to pass
+    function testQuorumRequirement() public {
+        // Create proposal
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        // Get total votes
+        uint256 totalVotes = 0;
+        for(uint8 n=0; n<voters.length; n++) {
+            totalVotes += GovernanceToken(govToken).getVotes(voters[n]);
+        }
+        
+        // Calculate 4% of total votes (quorum)
+        uint256 quorumVotes = (totalVotes * 4) / 100;
+        
+        // Only have voters representing less than quorum vote
+        uint256 votedPower = 0;
+        uint8 voterIndex = 0;
+        
+        // Ensure we don't subtract more than quorumVotes to avoid underflow
+        uint256 targetVotes = quorumVotes > 100 ? quorumVotes - 100 : 0;
+        
+        while(votedPower < targetVotes && voterIndex < voters.length) {
+            vote(voters[voterIndex], proposal, 1);
+            votedPower += GovernanceToken(govToken).getVotes(voters[voterIndex]);
+            voterIndex++;
+        }
+        
+        // Roll forward to end voting period
+        vm.roll(block.number + 50401);
+        
+        // Should be defeated due to not meeting quorum
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Defeated));
+    }
+    
+    // Test proposal cancellation
+    function testProposalCancellation() public {
+        // Create proposal from the first voter
+        vm.startPrank(voters[0]);
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.stopPrank();
+        
+        vm.roll(block.number + 2);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint(ProposalState.Active));
+        
+        // Cancel the proposal
+        vm.startPrank(voters[0]);
+        HamzaGovernor(governor).cancel(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        vm.stopPrank();
+        
+        // Verify it's canceled
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Canceled));
+        
+        // Ensure we can't vote on canceled proposals
+        vm.startPrank(voters[1]);
+        vm.expectRevert();
+        HamzaGovernor(governor).castVote(proposal, 1);
+        vm.stopPrank();
+    }
+    
+    // Test that a voter can't vote twice
+    function testDoubleVotePrevention() public {
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        // First vote for
+        vote(voters[0], proposal, 1);
+        
+        // Try to vote again - should revert
+        vm.startPrank(voters[0]);
+        vm.expectRevert();
+        HamzaGovernor(governor).castVote(proposal, 0);
+        vm.stopPrank();
+    }
+    
+    // Test that an account without voting power can't vote
+    function testVoteWithoutPower() public {
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        // Try to vote from account with no voting power
+        vm.startPrank(noVotingRightsAddr);
 
-        //the fee has not changed at this point
-        assertEq(systemSettings.feeBps(), 1);
+        HamzaGovernor(governor).castVote(proposal, 1);
+        vm.stopPrank();
+        
+        // Skip ahead
+        vm.roll(block.number + 50401);
+        
+        // If all others haven't voted, proposal should be defeated (zero votes)
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Defeated));
+    }
+    
+    // Test vote delegation functionality
+    function testVoteDelegation() public {
+        TestToken lootTokenLocal = TestToken(lootToken);
+        GovernanceToken govTokenLocal = GovernanceToken(govToken);
+        
+        // Delegate voter[1]'s votes to voter[0]
+        vm.startPrank(voters[1]);
+        govTokenLocal.delegate(voters[0]);
+        vm.stopPrank();
+        
+        // Check that voter[0] now has their votes plus voter[1]'s votes
+        assertEq(govTokenLocal.getVotes(voters[0]), 200); // 100 + 100
+        assertEq(govTokenLocal.getVotes(voters[1]), 0);   // Delegated away
+        
+        // Create a proposal and vote with the delegated votes
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        // Only voter[0] votes (with delegated power)
+        vote(voters[0], proposal, 1);
+        
+        // Skip ahead
+        vm.roll(block.number + 50401);
+        
+        // If voter[0] has 200 votes and voted for the proposal, it should pass
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
+        
+        // Also verify the total voting power of voter[0]
+        assertEq(govTokenLocal.getVotes(voters[0]), 200);
+    }
+    
+    // Test that proposals can't be executed before the timelock has passed
+    function testTimelockEnforcement() public {
+        uint256 proposal = HamzaGovernor(governor).propose(targets, values, calldatas, proposalDescription);
+        vm.roll(block.number + 2);
+        
+        for(uint8 n=0; n<voters.length; n++) {
+            vote(voters[n], proposal, 1);
+        }
+        
+        vm.roll(block.number + 50401);
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Succeeded));
+        
+        // Queue the proposal
+        HamzaGovernor(governor).queue(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        
+        // Try to execute immediately (before timelock delay)
+        vm.expectRevert();
+        HamzaGovernor(governor).execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        
+        // Wait for timelock to pass
+        vm.warp(block.timestamp + timeLockDelay + 1);
+        
+        // Now execution should work
+        HamzaGovernor(governor).execute(targets, values, calldatas, keccak256(bytes(proposalDescription)));
+        assertEq(uint256(HamzaGovernor(governor).state(proposal)), uint256(ProposalState.Executed));
     }
 }