feat: substitute calcSlashedAmount for scaleForBurning

[nadir-akhtar]

Motivation:

When developing the slashing release, two different functions for calculating slashed shares were ideated: calcSlashedAmount and scaleForBurning. The former is used to calculated slashed "operator shares," or shares currently delegated to an operator, and the latter for "queued shares," or shares in the withdrawal queue that are currently slashable.

Despite the functionality effectively being equivalent (determine how many of these shares are to be slashed), two different functions were maintained due to uncertainty as to how to deduplicate them.

During the redistribution release, manual analysis yielded the conclusion that there is a way to consolidate these two functions. In order to reduce disparate logic, this PR removes scaleForBurning and replaces it with calcSlashedAmount.

Context:

calcSlashedAmount and scaleForBurning both attempt to do the same thing: return how many shares to slash as a result of an operator's magnitude change. However, they each go about it in different ways:

• calcSlashedAmount reduces an operator's shares by a certain proportion, specifically by newMaxMag / prevMaxMag, then returns that number of shares.
• scaleForBurning calculates the effective shares at the current and expected max mags, then returns the difference.

Note that the "type" of share entering each equation is not the same: calcSlashedAmount takes in operator shares, whereas scaleForBurning takes in "scaled shares," i.e. shares that are scaled based on staker deposit scaling factors (DSFs), but do not change based on operator slashings.

Once this type discrepancy was evident, the next step was to determine how to convert from one type to the other. Choosing calcSlashedAmount as the natural base function, it became evident that "scaled shares" can be translated to operator shares by simply multiplying by the current operator magnitude. With that simple change, calcSlashedAmount can be used to calculate shares slashed from both operator shares as well as queued shares.

Math:

Variables

• $s_n$ - The amount of shares in the storage of the {EP,S}M at time n
• $k_n$ - The “staker deposit scaling factor” at time n. This is initialized to 1.
• $m_n$ - The operator magnitude at time n
• $op_{n}$ - The shares of the operator $op_{n}=s_{n}k_{n}m_{n}$
• $ss_{n}$ - The scaled shares of the operator in storage. This is stored upon queueing of a withdrawal $ss_{n}=s_{n}k_{n}$. See scaleForQueueWithdrawal in SlashingLib

Scale For Burning
$ss_{n}(m_{n}-m_{n+1})$

= $s_nk_n(m_{n}-m_{n+1})$

= $s_nk_nm_{n}- s_nk_nm_{n+1}$

= $op_n - s_nk_nm_{n+1}$

Calc Slashed Amount

$op_{n} - op_{n}*\frac{m_{n+1}}{m_n}$

= $op_{n} - s_nk_nm_n*\frac{m_{n+1}}{m_n}$

= $op_{n} - s_nk_n{m_{n+1}}$

Modifications:

• Removes scaleForBurning from SlashingLib.sol and replaces its use with calcSlashedAmount

Result:

• Cleaned up code
• Clearer logic

[ypatil12]

Can we change the base to release-dev/slashing-ux-improvements? Also need to run make bindings after.