refactor: migrate block numbers to timestamps (#491)

* refactor: migrate block numbers to timestamps

* chore: update starknet sig auth test timelines

---------

Co-authored-by: Orlando <[email protected]>

starknet/src/execution_strategies/simple_quorum.cairo

@@ -30,16 +30,16 @@ mod SimpleQuorumExecutionStrategy {
         let accepted = _quorum_reached(self._quorum.read(), votes_for, votes_against, votes_abstain)
             & _supported(votes_for, votes_against);
 
-        let block_number = info::get_block_number().try_into().unwrap();
+        let timestamp = info::get_block_timestamp().try_into().unwrap();
         if *proposal.finalization_status == FinalizationStatus::Cancelled(()) {
             ProposalStatus::Cancelled(())
         } else if *proposal.finalization_status == FinalizationStatus::Executed(()) {
             ProposalStatus::Executed(())
-        } else if block_number < *proposal.start_block_number {
+        } else if timestamp < *proposal.start_timestamp {
             ProposalStatus::VotingDelay(())
-        } else if block_number < *proposal.min_end_block_number {
+        } else if timestamp < *proposal.min_end_timestamp {
             ProposalStatus::VotingPeriod(())
-        } else if block_number < *proposal.max_end_block_number {
+        } else if timestamp < *proposal.max_end_timestamp {
             if accepted {
                 ProposalStatus::VotingPeriodAccepted(())
             } else {

starknet/src/interfaces/i_voting_strategy.cairo

@@ -5,7 +5,7 @@ use sx::types::UserAddress;
 trait IVotingStrategy<TContractState> {
     fn get_voting_power(
         self: @TContractState,
-        block_number: u32,
+        timestamp: u32,
         voter: UserAddress,
         params: Array<felt252>,
         user_params: Array<felt252>,

starknet/src/space/space.cairo

@@ -203,11 +203,11 @@ mod Space {
                 );
             assert(is_valid, 'Proposal is not valid');
 
-            // The snapshot block number is the start of the voting period
-            let start_block_number = info::get_block_number().try_into().unwrap()
+            // The snapshot block timestamp is the start of the voting period
+            let start_timestamp = info::get_block_timestamp().try_into().unwrap()
                 + self._voting_delay.read();
-            let min_end_block_number = start_block_number + self._min_voting_duration.read();
-            let max_end_block_number = start_block_number + self._max_voting_duration.read();
+            let min_end_timestamp = start_timestamp + self._min_voting_duration.read();
+            let max_end_timestamp = start_timestamp + self._max_voting_duration.read();
 
             // TODO: we use a felt252 for the hash despite felts being discouraged 
             // a new field would just replace the hash. Might be worth casting to a Uint256 though? 
@@ -216,9 +216,9 @@ mod Space {
             );
 
             let proposal = Proposal {
-                start_block_number: start_block_number,
-                min_end_block_number: min_end_block_number,
-                max_end_block_number: max_end_block_number,
+                start_timestamp: start_timestamp,
+                min_end_timestamp: min_end_timestamp,
+                max_end_timestamp: max_end_timestamp,
                 execution_payload_hash: execution_payload_hash,
                 execution_strategy: execution_strategy.address,
                 author: author,
@@ -249,10 +249,10 @@ mod Space {
             let proposal = self._proposals.read(proposal_id);
             assert_proposal_exists(@proposal);
 
-            let block_number = info::get_block_number().try_into().unwrap();
+            let timestamp = info::get_block_timestamp().try_into().unwrap();
 
-            assert(block_number < proposal.max_end_block_number, 'Voting period has ended');
-            assert(block_number >= proposal.start_block_number, 'Voting period has not started');
+            assert(timestamp < proposal.max_end_timestamp, 'Voting period has ended');
+            assert(timestamp >= proposal.start_timestamp, 'Voting period has not started');
             assert(
                 proposal.finalization_status == FinalizationStatus::Pending(()),
                 'Proposal has been finalized'
@@ -264,7 +264,7 @@ mod Space {
             let voting_power = _get_cumulative_power(
                 @self,
                 voter,
-                proposal.start_block_number,
+                proposal.start_timestamp,
                 user_voting_strategies,
                 proposal.active_voting_strategies
             );
@@ -315,7 +315,7 @@ mod Space {
             assert_proposal_exists(@proposal);
             assert(proposal.author == author, 'Only Author');
             assert(
-                info::get_block_number() < proposal.start_block_number.into(),
+                info::get_block_timestamp() < proposal.start_timestamp.into(),
                 'Voting period started'
             );
 
@@ -537,13 +537,13 @@ mod Space {
     }
 
     fn assert_proposal_exists(proposal: @Proposal) {
-        assert(!(*proposal.start_block_number).is_zero(), 'Proposal does not exist');
+        assert(!(*proposal.start_timestamp).is_zero(), 'Proposal does not exist');
     }
 
     fn _get_cumulative_power(
         self: @ContractState,
         voter: UserAddress,
-        block_number: u32,
+        timestamp: u32,
         user_strategies: Array<IndexedStrategy>,
         allowed_strategies: u256
     ) -> u256 {
@@ -561,7 +561,7 @@ mod Space {
                 contract_address: strategy.address
             }
                 .get_voting_power(
-                    block_number, voter, strategy.params, user_strategies.at(i).params.clone()
+                    timestamp, voter, strategy.params, user_strategies.at(i).params.clone()
                 );
             i += 1;
         };

starknet/src/tests/test_space.cairo

@@ -153,11 +153,11 @@ mod tests {
         );
 
         let proposal = space.proposals(u256_from_felt252(1));
-        let block_number = info::get_block_number().try_into().unwrap();
+        let timestamp = info::get_block_timestamp().try_into().unwrap();
         let expected_proposal = Proposal {
-            start_block_number: block_number + 1_u32,
-            min_end_block_number: block_number + 2_u32,
-            max_end_block_number: block_number + 3_u32,
+            start_timestamp: timestamp + 1_u32,
+            min_end_timestamp: timestamp + 2_u32,
+            max_end_timestamp: timestamp + 3_u32,
             execution_payload_hash: poseidon::poseidon_hash_span(
                 vanilla_execution_strategy.clone().params.span()
             ),
@@ -185,8 +185,8 @@ mod tests {
         authenticator
             .authenticate(space.contract_address, UPDATE_PROPOSAL_SELECTOR, update_calldata);
 
-        // Increasing block block_number by 1 to pass voting delay
-        testing::set_block_number(1_u64);
+        // Increasing block timestamp by 1 to pass voting delay
+        testing::set_block_timestamp(1_u64);
 
         let mut vote_calldata = array::ArrayTrait::<felt252>::new();
         let voter = UserAddress::Starknet(contract_address_const::<0x8765>());
@@ -204,7 +204,7 @@ mod tests {
         // Vote on Proposal
         authenticator.authenticate(space.contract_address, VOTE_SELECTOR, vote_calldata);
 
-        testing::set_block_number(2_u64);
+        testing::set_block_timestamp(2_u64);
 
         // Execute Proposal
         space.execute(u256_from_felt252(1), vanilla_execution_strategy.params);
@@ -306,8 +306,8 @@ mod tests {
         authenticator.authenticate(space.contract_address, PROPOSE_SELECTOR, propose_calldata);
         let proposal_id = u256_from_felt252(1);
 
-        // Increasing block block_number by 1 to pass voting delay
-        testing::set_block_number(1_u64);
+        // Increasing block timestamp by 1 to pass voting delay
+        testing::set_block_timestamp(1_u64);
         let proposal = space.proposals(proposal_id);
         assert(proposal.finalization_status == FinalizationStatus::Pending(()), 'pending');
 

starknet/src/tests/test_stark_tx_auth.cairo

@@ -104,8 +104,8 @@ mod tests {
                 ArrayTrait::<felt252>::new()
             );
 
-        // Increasing block block_number by 1 to pass voting delay
-        testing::set_block_number(1_u64);
+        // Increasing block timestamp by 1 to pass voting delay
+        testing::set_block_timestamp(1_u64);
 
         let voter = contract_address_const::<0x8765>();
         let choice = Choice::For(());
@@ -125,7 +125,7 @@ mod tests {
                 ArrayTrait::<felt252>::new()
             );
 
-        testing::set_block_number(2_u64);
+        testing::set_block_timestamp(2_u64);
 
         // Execute Proposal
         space.execute(u256_from_felt252(1), new_payload);
@@ -289,8 +289,8 @@ mod tests {
                 ArrayTrait::<felt252>::new()
             );
 
-        // Increasing block block_number by 1 to pass voting delay
-        testing::set_block_number(1_u64);
+        // Increasing block timestamp by 1 to pass voting delay
+        testing::set_block_timestamp(1_u64);
 
         let voter = contract_address_const::<0x8765>();
         let choice = Choice::For(());

starknet/src/types/proposal.cairo

@@ -5,9 +5,9 @@ use sx::types::{FinalizationStatus, UserAddress};
 
 #[derive(Clone, Drop, Serde, PartialEq, starknet::Store)]
 struct Proposal {
-    start_block_number: u32,
-    min_end_block_number: u32,
-    max_end_block_number: u32,
+    start_timestamp: u32,
+    min_end_timestamp: u32,
+    max_end_timestamp: u32,
     execution_payload_hash: felt252,
     execution_strategy: ContractAddress,
     author: UserAddress,

starknet/src/utils/single_slot_proof.cairo

@@ -65,7 +65,7 @@ mod SingleSlotProof {
     #[internal]
     fn get_storage_slot(
         self: @ContractState,
-        block_number: u32,
+        timestamp: u32,
         contract_address: felt252,
         slot_index: u256,
         mapping_key: u256,
@@ -90,7 +90,7 @@ mod SingleSlotProof {
             contract_address: self._facts_registry.read()
         }
             .get_storage_uint(
-                block_number.into(),
+                timestamp.into(),
                 contract_address,
                 proofs.slot,
                 proofs.proof_size_bytes,

starknet/src/voting_strategies/eth_balance_of.cairo

@@ -13,7 +13,7 @@ mod EthBalanceOfVotingStrategy {
     impl EthBalanceOfVotingStrategy of IVotingStrategy<ContractState> {
         fn get_voting_power(
             self: @ContractState,
-            block_number: u32,
+            timestamp: u32,
             voter: UserAddress,
             params: Array<felt252>,
             user_params: Array<felt252>,
@@ -30,9 +30,9 @@ mod EthBalanceOfVotingStrategy {
             let state: SingleSlotProof::ContractState =
                 SingleSlotProof::unsafe_new_contract_state();
 
-            // Get the balance of the voter at the given block number
+            // Get the balance of the voter at the given block timestamp
             let balance = SingleSlotProof::get_storage_slot(
-                @state, block_number, voter.into(), contract_address, slot_index, user_params
+                @state, timestamp, voter.into(), contract_address, slot_index, user_params
             );
             balance
         }

starknet/src/voting_strategies/merkle_whitelist.cairo

@@ -17,7 +17,7 @@ mod MerkleWhitelistVotingStrategy {
     impl MerkleWhitelistImpl of IVotingStrategy<ContractState> {
         fn get_voting_power(
             self: @ContractState,
-            block_number: u32,
+            timestamp: u32,
             voter: UserAddress,
             params: Array<felt252>, // [root]
             user_params: Array<felt252>, // [Serde(leaf), Serde(proofs)]

starknet/src/voting_strategies/vanilla.cairo

@@ -11,7 +11,7 @@ mod VanillaVotingStrategy {
     impl VanillaVotingStrategy of IVotingStrategy<ContractState> {
         fn get_voting_power(
             self: @ContractState,
-            block_number: u32,
+            timestamp: u32,
             voter: UserAddress,
             params: Array<felt252>,
             user_params: Array<felt252>,

starknet/tests/stark-sig.test.ts

@@ -20,7 +20,6 @@ const network = process.env.NETWORK_URL || '';
 describe('Starknet Signature Authenticator', () => {
   const provider = new Provider({ sequencer: { baseUrl: network } });
   // starknet devnet predeployed account 0 with seed 0
-
   const privateKey_0 = '0xe3e70682c2094cac629f6fbed82c07cd';
   const address0 = '0x7e00d496e324876bbc8531f2d9a82bf154d1a04a50218ee74cdd372f75a551a';
   const account0 = new Account(provider, address0, privateKey_0);
@@ -99,7 +98,7 @@ describe('Starknet Signature Authenticator', () => {
         _owner: 1,
         _max_voting_duration: 100,
         _min_voting_duration: 100,
-        _voting_delay: 1,
+        _voting_delay: 10,
         _proposal_validation_strategy: {
           address: vanillaProposalValidationStrategyAddress,
           params: [[]],
@@ -190,24 +189,6 @@ describe('Starknet Signature Authenticator', () => {
       calldata: CallData.compile(updateProposalCalldata as any),
     });
 
-    {
-      // Random Tx just to advance the block number on the devnet so the voting period begins.
-
-      await account0.declareAndDeploy({
-        contract: json.parse(
-          fs
-            .readFileSync('starknet/target/dev/sx_StarkSigAuthenticator.sierra.json')
-            .toString('ascii'),
-        ),
-        casm: json.parse(
-          fs
-            .readFileSync('starknet/target/dev/sx_StarkSigAuthenticator.casm.json')
-            .toString('ascii'),
-        ),
-        constructorCalldata: CallData.compile({ name: 'sx-sn', version: '0.1.0' }),
-      });
-    }
-
     // VOTE
 
     const voteMsg: Vote = {