Feat staker v2 no fp and subpointers by baitcode · Pull Request #67 · EkuboProtocol/governance · GitHub

Added staker_log to track cumulatives depending on total staking amount changes.
Added calculation of total_staked amount at any given timestamp
Added calculation for seconds_per_total_staked_sum at any given timestamp ∑(Δt / total_staked)
Added calculation for time_weighted_total_staked at any given timestamp ∑(Δt * total_staked)
Added calculation for average total_staked over period of time (using seconds_per_total_staked_sum)
Added calculation for get_user_share_of_total_staked_over_period (using time_weighted_total_staked)
Changed storage for staker:

        delegated_cumulative_num_snapshots: Map<ContractAddress, u64>,
        delegated_cumulative_snapshot: Map<ContractAddress, Map<u64, DelegatedSnapshot>>,

for

        delegated_cumulative_snapshot: Map<ContractAddress, Vec<DelegatedSnapshot>>,

Closes #64 and #61

…governor.

…support Q128.128 FP. Added cumulative seconds per total staked history value, and getter for that value Added method that allows to calculate how much staked seconds would staked token amount generate in between 2 timestamps: `calculate_staked_seconds_for_amount_between` Added tiny amount of tests

* removed staked seconds calculation * added seconds per total staked test and added logic for calculation of that value when nothing is staked

…ilerplate. Implemented custom packing and custom data SubPointers.

…ize. Added convienience method for u64 / u128 case.

finished subpointers for staking_log. Subpointer always read whole felt252 from memory and converts it. So I had to change approach for packing.

inline everything remove storage read optimisations

TWO_POW_127 is more descriptive

is this supposed to be an overflow check? this cannot happen ever because addition is checked by default

think it would be more readable if you just wrote assert_eq!(value, u256 {high: integer, low:fractional}) and also inlined that into the below test

wdym?

Oh. I've already did that. Forgot to remove. Thank you for catching.

what is this value?

maximum value that can be store in felt252 is MAX_V = 0x800000000000011000000000000000000000000000000000000000000000000.
MAX_FP = MAX_V >> 128 (maximum value of highest 123 bit of felt252).

block timestamps are in seconds arent they? why are we dividing by 1k

This is absolutely right. I can't believe tests did not catch it. Aaaa found it. Turned out I saved ms in record. Thank you for catching this. Need to add think on how to test storage.

* uniform get_block_timestamp usage * store log_record timestamp in seconds * inline test assert for fp value * rename HALF to TWO_POW_127

timestamp should not be expressed in milliseconds when everything onchain is in seconds

because of this division, there is no difference between e.g. 4000 and 4999

Oh my! I though on-chain everything is in ms.

can this actually happen?

Unfortunately, in my practice things tend to happen. Assertions are also a good way of documenting code. But I see your point. Will remove.

is it required to write total staked before calling log_change? if so, it's not locally obvious from the function names and arguments

it is not. I'll think on how to rename those.

it's not finding that specific timestamp, maybe rename to find_previous.. or something

Good point.

Changed to find_change_log_on_or_before_timestamp.

in hindsight, we should actually treat total staked of 0 as if it's 1 with regards to this accumulator

that allows us to still compute the harmonic mean for periods where total staked is zero (it will not be perfectly accurate, but ok for it to be off by one)

it also means you don't have to worry about this value being 0 between two indices

I refactored that bit. I calculate total_staked using total_staked * seconds passed. It's much simpler.

variable name is confusing

changed to seconds_per_total_staked

here you can just use the value 1 for total_staked

@moodysalem
Do I understand you correctly, that this is a technic to cap the infinity? meaning that we probably wont really calculate stake shares over periods like that and those will be negated when snapshots are subtracted?

why are you doing this assertion? if it's because you're storing a u256 as a felt252 in the store packing, then it should be asserted where you're actually doing the storage

Had same though, but decided to fail as early as possible.

Looks like in storage packing it'll fail anyway during conversion. Removing.

is this comment accurate? there were 2 diff quantities we wanted to be able to compute:

average total staked for a period of time

requires storing seconds passed * total_staked, a 160+ bit wide value
can be computed by taking (snapshotB-snapshotA) / periodLength
can be used to calculate the total voting weight at the time a proposal's voting starts, so functionality could be added for proposal to be immediately passed if it reaches quorum with majority of total staked in favor

user's share of total stake over a period

requires storing seconds passed / total staked, a 160+ bit wide value
computed via stakedAmount * snapshotStakeEnd - snapshotStakeStart
this also lets you compute the harmonic mean of total staked over a period, which could be useful for dynamically adjusting quorum

No it's not. It's outdated. I've updated it. This method calculates shapshots for "user's share of total stake over a period"

Fixed. That one. Will add other snapshots soon. Then add methods for 2 diff quantities.

@moodysalem

computed via stakedAmount * snapshotStakeEnd - snapshotStakeStart

Formula for user's share seems incorrect:

the dimension of the result is seconds. which raises suspicion.
brackets are missing.

I think that correct one is: stakedAmount * (snapshotStakeEnd - snapshotStakeStart) / (snapshotTimestampEnd-snapshotTimestampStart)
Can you please confirm that this is correct?

* find_in_change_log -> find_change_log_on_or_before_timestamp * log_change argument rename

added get_time_weighted_total_staked_sum_at added get_total_staked_at to staker added get_user_share_of_total_staked_over_period to staker added get_average_total_staked_over_period to staker

@moodysalem I decided not to wait your replies and implemented. There are tests missing for
get_average_total_staked_over_period
get_user_share_of_total_staked_over_period
I'll add a bit later.

@moodysalem
Should user share be fixed point value?

- reverted changes to staker - moved changes to staker_v2 - changed delegated_cumulative_snapshot to Map<ContractAddress, Vec<DelegatedSnapshot>>

baitcode added 30 commits December 10, 2024 23:58

Initial implementation of staked seconds calculation

cb3e4dd

a bit of naming

01b3f73

added upgrade method. NOTE: constructor changed. Staker now requires …

924aef3

…governor.

fix import

88f8db8

TODO: removal

9553035

remove todo

aedb403

test

9ee9324

local settings

c3c0244

revert upgrade code for now

692c36a

removed upgrade due to cyclic dependency with governor

349919e

finalise

d6504e9

typo

5f32326

removed old tests

2f9516a

* debugged fixed point math. added tests

bb4f99a

* removed staked seconds calculation * added seconds per total staked test and added logic for calculation of that value when nothing is staked

some comment fixes

1a2d6fc

Extracted staker storage into separate file due to large amount of bo…

b18d702

…ilerplate. Implemented custom packing and custom data SubPointers.

rename staker_storage -> staker_log. moved all relevant logic there

7fdfb19

Simplified Fixed Point operations library. Reduced internal storage s…

b82953f

…ize. Added convienience method for u64 / u128 case.

simplified more. better naming

80cf041

clean up bitshifts from tests

f507631

overflow checks

164f64f

old tests did not respect overflow. had to create new ones.

6e931c6

finished subpointers for staking_log. Subpointer always read whole felt252 from memory and converts it. So I had to change approach for packing.

Debugging, cleaning up, fixing missed issues

fafba15

final fix

b55b320

final debugging

a28971c

cleanup

aa07801

cleanup

61f085c

removing UFixedPoint124x128 struct

f52fff1

BugFix for a case when fetl252 is overflown

4cc807e

baitcode added 3 commits January 11, 2025 02:34

remove fixed point lib

7e35137

inline everything remove storage read optimisations

small fix

815d539

lost deletions

284ae39

moodysalem reviewed Jan 13, 2025

View reviewed changes

baitcode added 2 commits January 13, 2025 22:32

Review fixes

c6102a1

* uniform get_block_timestamp usage * store log_record timestamp in seconds * inline test assert for fp value * rename HALF to TWO_POW_127

scarb fmt

e3067ab

moodysalem reviewed Jan 14, 2025

View reviewed changes

baitcode added 2 commits January 15, 2025 00:37

Review fixes

f622f34

scarb format

56ec424

moodysalem mentioned this pull request Jan 20, 2025

[WIP] Feat staker v2 #63

Closed

moodysalem reviewed Jan 20, 2025

View reviewed changes

baitcode added 2 commits January 23, 2025 23:58

* remove MAX_FP related code

974c68d

* find_in_change_log -> find_change_log_on_or_before_timestamp * log_change argument rename

simplified and renamed get_seconds_per_total_staked_sum_at

955ef24

added get_time_weighted_total_staked_sum_at added get_total_staked_at to staker added get_user_share_of_total_staked_over_period to staker added get_average_total_staked_over_period to staker

baitcode requested a review from moodysalem January 31, 2025 01:49

uncomment tests + scarb format

83eb22d

baitcode and others added 8 commits February 17, 2025 21:34

Review fix:

f6ee4fb

- reverted changes to staker - moved changes to staker_v2 - changed delegated_cumulative_snapshot to Map<ContractAddress, Vec<DelegatedSnapshot>>

fixup

0e8b8a6

fixup

1acb535

remove Timestamped

204fa73

remove TODO

49ee037

* rewrite while loop as recursion

04a4edb

make search private

08dd762

Merge branch 'main' into feat-staker-v2-no-fp-and-subpointers

65dda9b

moodysalem merged commit eac52cc into EkuboProtocol:main Feb 19, 2025

                   const TWO_POW_64: u128 = 0x10000000000000000;
                   const TWO_POW_192: u256 = 0x1000000000000000000000000000000000000000000000000;
                   const TWO_POW_192_DIVISOR: NonZero<u256> = 0x1000000000000000000000000000000000000000000000000;
+                  const HALF: u128    = 0x80000000000000000000000000000000_u128;

+              const TWO_POW_32: u64 = 0x100000000_u64;
+              const MASK_32_BITS: u128 = 0x100000000_u128 - 1;
+              const TWO_POW_160: u256 = 0x10000000000000000000000000000000000000000;
+              pub const MAX_FP: u128 = 0x8000000000000110000000000000000_u128;

+                      fn get_cumulative_seconds_per_total_staked_at(
+                          self: @ContractState, timestamp: u64,
+                      ) -> u256 {
+                          let timestamp_seconds = timestamp / 1000;

+                                  // substract fixed point values
+                                  let divisor = next_log_record.cumulative_seconds_per_total_staked
+                                      - log_record.cumulative_seconds_per_total_staked;
+                                  assert(divisor.high < MAX_FP, 'FP_OVERFLOW');

+                      ) -> u256 {
+                          if let Option::Some((log_record, idx)) = self
+                              .staking_log
+                              .find_in_change_log(timestamp) {

                               .write(delegate, self.insert_snapshot(delegate, get_block_timestamp()) + amount);
+                          let total_staked = self.total_staked.read();
+                          assert(total_staked + amount >= total_staked, 'BAD AMOUNT');

		assert_eq!(value.high, integer);
		assert_eq!(value.low, fractional);

+                  pub(crate) timestamp: u64,
+                  // Only 128+32=160 bits are used
+                  // TODO: add validation checks

+                                  }
+                              };
+                              let seconds_diff = (timestamp - log_record.timestamp) / 1000;

		self.total_staked.write(total_staked + amount);
		self.staking_log.log_change(amount, total_staked);

+                                      - log_record.cumulative_seconds_per_total_staked;
+                                  if divisor.is_zero() {
+                                      return 0_u64.into();


		let seconds_diff = timestamp - log_record.timestamp;

		let staked_seconds: u256 = if total_staked == 0 {

+                              let seconds_diff = timestamp - log_record.timestamp;
+                              let staked_seconds: u256 = if total_staked == 0 {
+_u256

+                              // Sum fixed posits
+                              let result = log_record.cumulative_seconds_per_total_staked + staked_seconds;
+                              assert(result.high < MAX_FP, 'FP_OVERFLOW');

                       self: @TContractState, delegate: ContractAddress, period: u64,
                   ) -> u128;
+                  // Gets the cumulative staked amount * per second staked for the given timestamp and account.

Feat staker v2 no fp and subpointers by baitcode · Pull Request #67 · EkuboProtocol/governance · GitHub

Feat staker v2 no fp and subpointers - #67

Feat staker v2 no fp and subpointers#67moodysalem merged 48 commits intoEkuboProtocol:mainEkuboProtocol/governance:mainfrom baitcode:feat-staker-v2-no-fp-and-subpointersbaitcode/governance:feat-staker-v2-no-fp-and-subpointersCopy head branch name to clipboard

Conversation

baitcode commented Jan 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

baitcode Jan 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

baitcode Jan 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

baitcode Jan 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

baitcode Jan 31, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

baitcode commented Jan 31, 2025

Uh oh!

baitcode commented Jan 31, 2025

Feat staker v2 no fp and subpointers#67
moodysalem merged 48 commits into
EkuboProtocol:mainfrom
baitcode:feat-staker-v2-no-fp-and-subpointers

baitcode commented Jan 10, 2025 •
edited
Loading

baitcode Jan 13, 2025 •
edited
Loading

baitcode Jan 13, 2025 •
edited
Loading

baitcode Jan 23, 2025 •
edited
Loading

baitcode Jan 31, 2025 •
edited
Loading