Feat staker v2 no fp and subpointers

.gitignore

@@ -1,3 +1,7 @@
+.env
+.vscode
+.starkli
+.DS_Store
 #######
 Scarb
 #######

src/lib.cairo

@@ -16,6 +16,10 @@ pub mod governor;
 mod governor_test;
 
 pub mod staker;
+
+pub mod staker_log;
+#[cfg(test)]
+pub mod staker_log_test;
 #[cfg(test)]
 mod staker_test;
 

src/staker.cairo

@@ -52,22 +52,48 @@ pub trait IStaker<TContractState> {
     fn get_average_delegated_over_last(
         self: @TContractState, delegate: ContractAddress, period: u64,
     ) -> u128;
+
+    // Calculates snapshot for seconds_per_total_staked_sum (val) at given timestamp (ts).
+    // If timestamp if before first record, returns 0.
+    // If timestamp is between records, calculates Δt = (ts - record.ts) where record is
+    // first record in log before timestamp, then calculates total amount using the
+    // weighted_total_staked diff diveded by time diff.
+    // If timestamp is after last record, calculates Δt = (ts - last_record.ts) and
+    // takes total_staked from storage and adds Δt / total_staked to accumulator.
+    // In case total_staked is 0 this method turns is to 1 to simplify calculations
+    // TODO: this should be a part of StakingLog
+    fn get_seconds_per_total_staked_sum_at(self: @TContractState, timestamp: u64) -> u256;
+
+    // Calculates snapshot for time_weighted_total_staked (val) at given timestamp (ts).
+    // Does pretty much the same as `get_seconds_per_total_staked_sum_at` but simpler due to
+    // absence of FP division.
+    fn get_time_weighted_total_staked_sum_at(self: @TContractState, timestamp: u64) -> u256;
+
+    fn get_total_staked_at(self: @TContractState, timestamp: u64) -> u128;
+
+    fn get_average_total_staked_over_period(self: @TContractState, start: u64, end: u64) -> u128;
+
+    fn get_user_share_of_total_staked_over_period(
+        self: @TContractState, staked: u128, start: u64, end: u64,
+    ) -> u128;
 }
 
 #[starknet::contract]
 pub mod Staker {
     use core::num::traits::zero::{Zero};
+    use crate::staker_log::{LogOperations, StakingLog};
     use governance::interfaces::erc20::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::storage::VecTrait;
     use starknet::storage::{
         Map, StorageMapReadAccess, StorageMapWriteAccess, StoragePathEntry,
         StoragePointerReadAccess, StoragePointerWriteAccess,
     };
+
     use starknet::{
-        get_block_timestamp, get_caller_address, get_contract_address,
+        ContractAddress, get_block_timestamp, get_caller_address, get_contract_address,
         storage_access::{StorePacking},
     };
-    use super::{ContractAddress, IStaker};
-
+    use super::{IStaker};
 
     #[derive(Copy, Drop, PartialEq, Debug)]
     pub struct DelegatedSnapshot {
@@ -78,6 +104,7 @@ pub mod Staker {
     const TWO_POW_64: u128 = 0x10000000000000000;
     const TWO_POW_192: u256 = 0x1000000000000000000000000000000000000000000000000;
     const TWO_POW_192_DIVISOR: NonZero<u256> = 0x1000000000000000000000000000000000000000000000000;
+    const TWO_POW_127: u128 = 0x80000000000000000000000000000000_u128;
 
     pub(crate) impl DelegatedSnapshotStorePacking of StorePacking<DelegatedSnapshot, felt252> {
         fn pack(value: DelegatedSnapshot) -> felt252 {
@@ -104,6 +131,8 @@ pub mod Staker {
         amount_delegated: Map<ContractAddress, u128>,
         delegated_cumulative_num_snapshots: Map<ContractAddress, u64>,
         delegated_cumulative_snapshot: Map<ContractAddress, Map<u64, DelegatedSnapshot>>,
+        total_staked: u128,
+        staking_log: StakingLog,
     }
 
     #[constructor]
@@ -253,6 +282,12 @@ pub mod Staker {
             self
                 .amount_delegated
                 .write(delegate, self.insert_snapshot(delegate, get_block_timestamp()) + amount);
+
+            let current_total_staked = self.total_staked.read();
+
+            self.total_staked.write(current_total_staked + amount);
+            self.staking_log.log_change(amount, current_total_staked);
+
             self.emit(Staked { from, delegate, amount });
         }
 
@@ -280,6 +315,11 @@ pub mod Staker {
                 .amount_delegated
                 .write(delegate, self.insert_snapshot(delegate, get_block_timestamp()) - amount);
             assert(self.token.read().transfer(recipient, amount.into()), 'TRANSFER_FAILED');
+
+            let total_staked = self.total_staked.read();
+            self.total_staked.write(total_staked - amount);
+            self.staking_log.log_change(amount, total_staked);
+
             self.emit(Withdrawn { from, delegate, to: recipient, amount });
         }
 
@@ -333,5 +373,111 @@ pub mod Staker {
             let now = get_block_timestamp();
             self.get_average_delegated(delegate, now - period, now)
         }
+
+        // Check interface for detailed description.
+        fn get_seconds_per_total_staked_sum_at(self: @ContractState, timestamp: u64) -> u256 {
+            let record = self.staking_log.find_record_on_or_before_timestamp(timestamp);
+
+            if let Option::Some((record, idx)) = record {
+                let total_staked = if (idx == self.staking_log.len() - 1) {
+                    // if last record found
+                    self.total_staked.read()
+                } else {
+                    // This helps to avoid couple of FP divisions.
+                    let next_record = self.staking_log.at(idx + 1).read();
+                    let time_weighted_total_staked_sum_diff = next_record
+                        .time_weighted_total_staked_sum
+                        - record.time_weighted_total_staked_sum;
+                    let timestamp_diff = next_record.timestamp - record.timestamp;
+                    (time_weighted_total_staked_sum_diff / timestamp_diff.into())
+                        .try_into()
+                        .unwrap()
+                };
+
+                let seconds_diff = timestamp - record.timestamp;
+
+                let seconds_per_total_staked: u256 = if total_staked == 0 {
+                    seconds_diff.into() // as if total_staked is 1
+                } else {
+                    // Divide u64 by u128
+                    u256 { low: 0, high: seconds_diff.into() } / total_staked.into()
+                };
+
+                // Sum fixed posits
+                return record.seconds_per_total_staked_sum + seconds_per_total_staked;
+            }
+
+            return 0_u256;
+        }
+
+        fn get_time_weighted_total_staked_sum_at(self: @ContractState, timestamp: u64) -> u256 {
+            let record = self.staking_log.find_record_on_or_before_timestamp(timestamp);
+
+            if let Option::Some((record, idx)) = record {
+                let total_staked = if (idx == self.staking_log.len() - 1) {
+                    // if last rescord found
+                    self.total_staked.read()
+                } else {
+                    let next_record = self.staking_log.at(idx + 1).read();
+                    let time_weighted_total_staked_sum_diff = next_record
+                        .time_weighted_total_staked_sum
+                        - record.time_weighted_total_staked_sum;
+                    let timestamp_diff = next_record.timestamp - record.timestamp;
+                    (time_weighted_total_staked_sum_diff / timestamp_diff.into())
+                        .try_into()
+                        .unwrap()
+                };
+
+                let seconds_diff = timestamp - record.timestamp;
+                let time_weighted_total_staked: u256 = total_staked.into() * seconds_diff.into();
+
+                return record.time_weighted_total_staked_sum + time_weighted_total_staked;
+            }
+
+            return 0_u256;
+        }
+
+        fn get_total_staked_at(self: @ContractState, timestamp: u64) -> u128 {
+            let record = self.staking_log.find_record_on_or_before_timestamp(timestamp);
+            if let Option::Some((record, idx)) = record {
+                if (idx == self.staking_log.len() - 1) {
+                    self.total_staked.read()
+                } else {
+                    let next_record = self.staking_log.at(idx + 1).read();
+                    let time_weighted_total_staked_sum_diff = next_record
+                        .time_weighted_total_staked_sum
+                        - record.time_weighted_total_staked_sum;
+                    let timestamp_diff = next_record.timestamp - record.timestamp;
+                    (time_weighted_total_staked_sum_diff / timestamp_diff.into())
+                        .try_into()
+                        .unwrap()
+                }
+            } else {
+                0_u128
+            }
+        }
+
+        fn get_average_total_staked_over_period(
+            self: @ContractState, start: u64, end: u64,
+        ) -> u128 {
+            assert(end > start, 'ORDER');
+
+            let start_snapshot = self.get_time_weighted_total_staked_sum_at(start);
+            let end_snapshot = self.get_time_weighted_total_staked_sum_at(end);
+            let period_length = end - start;
+
+            ((end_snapshot - start_snapshot) / period_length.into()).try_into().unwrap()
+        }
+
+        fn get_user_share_of_total_staked_over_period(
+            self: @ContractState, staked: u128, start: u64, end: u64,
+        ) -> u128 {
+            assert(end > start, 'ORDER');
+
+            let start_snapshot = self.get_seconds_per_total_staked_sum_at(start);
+            let end_snapshot = self.get_seconds_per_total_staked_sum_at(end);
+
+            staked * ((end_snapshot - start_snapshot) * 100).high / (end - start).into()
+        }
     }
 }